继承SurfaceView Runnable android在现有图片上面继续画图（保留上次画的和不保留上次的）

• 登录 | 注册

u010840444的专栏

。

[java] view plain copy

 

1. import android.app.Activity;  
2. import android.os.Bundle;  
3. import android.view.Window;  
4.   
5. public class Run extends Activity{  
6.       
7.     DrawView drawView;  
8.     @Override  
9.     protected void onCreate(Bundle savedInstanceState) {  
10.         // TODO Auto-generated method stub  
11.         super.onCreate(savedInstanceState);  
12.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
13.           
14.         drawView = new DrawView(this);  
15.         setContentView(drawView);  
16.     }  
17.       
18.     @Override  
19.     protected void onResume() {  
20.         // TODO Auto-generated method stub  
21.         super.onResume();  
22.         drawView.resume();//因为可能出现 返回屏幕的情况，这这里调用 来控制 线程，当返回的时候，暂停线程，如果用到设备监听，这样可以节电  
23.     }  
24.       
25.     @Override  
26.     protected void onPause() {  
27.         // TODO Auto-generated method stub  
28.         super.onPause();  
29.         drawView.pause();  
30.     }  
31.   
32. }  

首先这是这主程序，主要用来启动控制下面(1),(2),程序：

(1)为调用的时候每次保留 canvas到bitmap中，每次刷新的时候继续使用之前的bitmap

（2）为每次  刷新canvas，用白色做背景，在其上面重新画图

（1）：

[java] view plain copy

 

1. import java.io.IOException;  
2. import java.io.InputStream;  
3. import java.io.InputStreamReader;  
4. import java.util.Random;  
5.   
6. import org.xml.sax.InputSource;  
7.   
8. import android.R.color;  
9. import android.content.Context;  
10. import android.content.res.AssetManager;  
11. import android.graphics.Bitmap;  
12. import android.graphics.Bitmap.Config;  
13. import android.graphics.BitmapFactory;  
14. import android.graphics.Canvas;  
15. import android.graphics.Color;  
16. import android.graphics.Paint;  
17. import android.graphics.Point;  
18. import android.graphics.Rect;  
19. import android.util.Log;  
20. import android.view.SurfaceHolder;  
21. import android.view.SurfaceView;  
22.   
23.   
24. public class DrawView extends SurfaceView implements Runnable{//继承runnable实现线程  
25.                //  
26.         Thread gameloop= null;  
27.     SurfaceHolder surface;  
28.     volatile Boolean running= false;  
29.     Bitmap bitmap;  
30.     Canvas can;  
31.     AssetManager assets = null;  
32.     BitmapFactory.Options options = null;  
33.       
34.     public DrawView(Context context) {  
35.         super(context);  
36.         // TODO Auto-generated constructor stub  
37.   
38.       
39.         surface=getHolder();  
40.         assets=context.getAssets();  
41.         options=new BitmapFactory.Options();  
42.         options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
43.           
44.           
45.           
46.     }  
47.       
48.     public void pause(){  
49.         running = false;  
50.         while(true){  
51.               
52.             try {  
53.                 gameloop.join();  
54.             } catch (InterruptedException e) {  
55.                 // TODO Auto-generated catch block  
56.                 e.printStackTrace();  
57.             }  
58.         }  
59.     }  
60.       
61.       
62.     public void resume(){  
63.         running = true;  
64.         gameloop = new Thread(this);  
65.         gameloop.start();  
66.     }  
67.   
68.     Random r=new Random();  
69.     boolean flag=true;  
70.     Point p=new Point();  
71.     @Override  
72.     public void run() {  
73.         // TODO Auto-generated method stub  
74.           
75.         int i=0;  
76.         while(running){  
77.             if(!surface.getSurface().isValid())  
78.                 continue;  
79.           
80.             Canvas canvas = surface.lockCanvas();  
81.               
82.             if(flag==true){  
83.                 paint.setColor(Color.rgb(r.nextInt(256),r.nextInt(256),r.nextInt(256)));  
84.                 flag=false;  
85.                 bitmap=Bitmap.createBitmap(  
86.                         canvas.getWidth(),canvas.getHeight(),Config.ARGB_8888);  
87.   
88.                 p.x=canvas.getWidth();  
89.                 p.y=canvas.getHeight();  
90.                 can=new Canvas();  
91.                 can.setBitmap(bitmap);  
92.                 can.drawColor(Color.WHITE);  
93.             }  
94.             getNext();  
95.             canvas.drawBitmap(bitmap, 0,0, paint);  
96.       
97.             surface.unlockCanvasAndPost(canvas);  
98.               
99.                   
100.                 try {  
101.                       
102.                     Thread.sleep(50);  
103.                 } catch (InterruptedException e) {  
104.                     // TODO Auto-generated catch block  
105.                     e.printStackTrace();  
106.                 }  
107.               
108.                   
109.         }  
110.     }  
111.     Paint paint=new Paint();  
112.     private void getNext() {  
113.         // TODO Auto-generated method stub  
114.         paint.setColor(Color.rgb(r.nextInt(256),r.nextInt(256),r.nextInt(256)));  
115.         can.drawLine(r.nextInt(p.x), r.nextInt(p.y), r.nextInt(p.x), r.nextInt(p.y), paint);  
116.     }  
117. }  

在（1）中，我尝试过直接使用   canvas所得到的画布，但是每次都不能得到所想要的前一个画布

测试得到的情况如下：

    null   null     null      一开始有三个为空的canvas，第一个设置的第一个会在 3的位置，但是获得的在第一个的位置，之后每次获得都是当前的三个之前，这样

    就无法每次得到之前的canvas，然后在其中画图，我所做的处理是使用一个bitmap，每次将其保存在bitmap中，要画图的时候再从bitmap中提取出来

   就相当于用一个bitmap来保存  状态，实质上还是每次  刷新canvas

(2)

[java] view plain copy

 

1. //  
2. public class CopyOfDrawView extends SurfaceView implements Runnable{  
3.   
4.     Thread gameloop= null;  
5.     SurfaceHolder surface;  
6.     volatile Boolean running= false;  
7.   
8.     AssetManager assets = null;  
9.     BitmapFactory.Options options = null;  
10.     Bitmap knight[];  
11.     int frame=0;  
12.       
13.     public CopyOfDrawView(Context context) {  
14.         super(context);  
15.         // TODO Auto-generated constructor stub  
16.   
17.       
18.         surface=getHolder();  
19.         assets=context.getAssets();  
20.         options=new BitmapFactory.Options();  
21.         options.inPreferredConfig = Bitmap.Config.ARGB_8888;  
22.           
23.         knight= new Bitmap[8];  
24.         try {  
25.             for(int i =0;i<8;i++){  
26.                 String filename= "knight"+String.valueOf(i+1)+".png";//在 assets中放图片实现存8张bitmap在knight中，显示这8张位图就可以实现动态的动画  
27.                 InputStream input = assets.open(filename);  
28.                 knight[i]=BitmapFactory.decodeStream(input, null, options);  
29.                   
30.                     input.close();  
31.                   
32.             }  
33.         } catch (IOException e) {  
34.                 // TODO Auto-generated catch block  
35.                 e.printStackTrace();  
36.             }  
37.           
38.     }  
39.       
40.     public void pause(){  
41.         running = false;  
42.         while(true){  
43.               
44.             try {  
45.                 gameloop.join();  
46.             } catch (InterruptedException e) {  
47.                 // TODO Auto-generated catch block  
48.                 e.printStackTrace();  
49.             }  
50.         }  
51.     }  
52.       
53.       
54.     public void resume(){  
55.         running = true;  
56.         gameloop = new Thread(this);  
57.         gameloop.start();  
58.     }  
59.   
60.     Random r=new Random();  
61.     boolean flag=true;  
62.     Point p=new Point();  
63.     @Override  
64.     public void run() {  
65.         // TODO Auto-generated method stub  
66.           
67.         int i=0;  
68.         while(running){  
69.             if(!surface.getSurface().isValid())  
70.                 continue;  
71.               
72.             Canvas canvas = surface.lockCanvas();  
73.   
74.                 canvas.drawColor(Color.WHITE);  
75.           
76.                 canvas.drawBitmap(knight[frame], 0, 0,null);  
77.                   
78.                 Rect dest = new Rect(100,0,300,200);               //使用 dest得到一个矩形，这个矩形作为bitmap的框，这样就可以实现不同大小的bitmap  
79.                 canvas.drawBitmap(knight[frame],null, dest, null);  
80.                   
81.                 dest = new Rect(200,0,800,600);  
82.                 canvas.drawBitmap(knight[frame],null, dest, null);//画位图  
83.                   
84.           
85.               
86.       
87.             surface.unlockCanvasAndPost(canvas);  
88.               
89.                   
90.                 try {  
91.                       
92.                     Thread.sleep(50);  
93.                 } catch (InterruptedException e) {  
94.                     // TODO Auto-generated catch block  
95.                     e.printStackTrace();  
96.                 }  
97.               
98.                   
99.         }  
100.     }  
101.   
102. }  

这个是每次都在canvas中重画