Android Launcher开发(三)动态壁纸(LiveWallPaper)气泡流动效果

最近在研究Laucher应用，今天写了一下四组件中的壁纸(WallPaper),关于静态壁纸的实现，比较简单，在此就不再描述. 参考了系统源代码之后，我自己做了一个简单的动态壁纸：气泡流动效果. 图案比较简单，但基本原理可在此例子上加以扩展，比如3D动画效果，复杂的触摸改变动画事件，有兴趣的朋友可以试一试.

大概效果如下,最开始得时候，会从四个角落的方向浮出四个气泡，然后以一定的路线移动，当移出屏幕时重新开始以新的坐标浮出,以此实现了一个简单的气泡浮动的效果:

实现的思路 ：

1、新建一个Android工程 ,注意,对于Live Wallpaper来说传统的布局文件是不需要的。

2、在res下面新建一个xml文件夹 然后新建一个livewallpaper.xml 内容如下：

[java] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <wallpaper xmlns:android="http://schemas.android.com/apk/res/android" android:thumbnail="@drawable/icon"/>  

注意: 这里的android:thumbnail值得是你这个动态壁纸的小图标 会在你选着动态壁纸的时候出现,也可以不写此属性

3. 实现动态壁纸是不需要使用Activity, 创建LiveWallpaper类，让其继承WallpaperService:

实现 onCreateEngine()方法,返回自己实现的Engine类

 在Engine类中的onCreate()方法中进行调用绘制图形的drawFrame()方法

 定义四个圆形的起始坐标，每次调用drawFrame()时改变圆形的坐标,通过mHandler.postDelayed(drawTarget, 100);方法，进行重新绘制图形，更新UI

具体代码如下:

1.AndroidManifest.xml

[java] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
3.       package="org.crazyit.desktop"  
4.       android:versionCode="1"  
5.       android:versionName="1.0">  
6.     <application  
7.         android:icon="@drawable/icon"  
8.         android:label="@string/app_name">  
9.         <!-- 配置实时壁纸Service -->  
10.         <service android:label="@string/app_name"  
11.             android:name=".LiveWallpaper"  
12.             android:permission="android.permission.BIND_WALLPAPER">  
13.             <!-- 为实时壁纸配置intent-filter -->  
14.             <intent-filter>  
15.                 <action  android:name="android.service.wallpaper.WallpaperService" />  
16.             </intent-filter>  
17.             <!-- 为实时壁纸配置meta-data -->  
18.             <meta-data android:name="android.service.wallpaper"  
19.                 android:resource="@xml/livewallpaper" />  
20.         </service>  
21.     </application>  
22. </manifest>   

2. 壁纸的xml文件: livewallpaper.xml

[java] view plain copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <wallpaper xmlns:android="http://schemas.android.com/apk/res/android" android:thumbnail="@drawable/icon"/>  

3. 实现动态壁纸的LiveWallpaper类:

[java] view plain copy

1. import android.graphics.Canvas;  
2. import android.graphics.Paint;  
3. import android.os.Handler;  
4. import android.service.wallpaper.WallpaperService;  
5. import android.view.MotionEvent;  
6. import android.view.SurfaceHolder;  
7. /** 
8.  *  
9.  * @author Tian 
10.  * 
11.  */  
12. public class LiveWallpaper extends WallpaperService  
13. {  
14.     // 实现WallpaperService必须实现的抽象方法  
15.     public Engine onCreateEngine()  
16.     {  
17.         // 返回自定义的Engine  
18.         return new MyEngine();  
19.     }  
20.   
21.     class MyEngine extends Engine  
22.     {  
23.         // 记录程序界面是否可见  
24.         private boolean mVisible;  
25.         // 记录当前当前用户动作事件的发生位置  
26.         private float mTouchX = -1;  
27.         private float mTouchY = -1;  
28.         // 记录当前圆圈的绘制位置  
29.           
30.         //左上角坐标  
31.         private float cx1 = 15;  
32.         private float cy1 = 20;  
33.           
34.         //右下角坐标  
35.         private float cx2 = 300;  
36.         private float cy2 = 380;  
37.           
38.         //右上角坐标  
39.         private float cx3 = 300;  
40.         private float cy3 = 20;  
41.           
42.         //左下角坐标  
43.         private float cx4 = 15;  
44.         private float cy4 = 380;  
45.           
46.         // 定义画笔  
47.         private Paint mPaint = new Paint();  
48.         // 定义一个Handler  
49.         Handler mHandler = new Handler();  
50.         // 定义一个周期性执行的任务  
51.         private final Runnable drawTarget = new Runnable()  
52.         {  
53.             public void run()  
54.             {  
55.                 // 动态地绘制图形  
56.                 drawFrame();  
57.             }  
58.         };  
59.   
60.         @Override  
61.         public void onCreate(SurfaceHolder surfaceHolder)  
62.         {  
63.             super.onCreate(surfaceHolder);  
64.             // 初始化画笔  
65.             mPaint.setColor(0xffffffff);  
66.             mPaint.setAntiAlias(true);  
67.             mPaint.setStrokeWidth(2);  
68.             mPaint.setStrokeCap(Paint.Cap.ROUND);  
69.             mPaint.setStyle(Paint.Style.STROKE);  
70.             // 设置处理触摸事件  
71.             setTouchEventsEnabled(true);  
72.         }  
73.   
74.         @Override  
75.         public void onDestroy()  
76.         {  
77.             super.onDestroy();  
78.             // 删除回调  
79.             mHandler.removeCallbacks(drawTarget);  
80.         }  
81.   
82.         @Override  
83.         public void onVisibilityChanged(boolean visible)  
84.         {  
85.             mVisible = visible;  
86.             // 当界面可见时候，执行drawFrame()方法。  
87.             if (visible)  
88.             {  
89.                 // 动态地绘制图形  
90.                 drawFrame();  
91.             }  
92.             else  
93.             {  
94.                 // 如果界面不可见，删除回调  
95.                 mHandler.removeCallbacks(drawTarget);  
96.             }  
97.         }  
98.   
99.         public void onOffsetsChanged(float xOffset, float yOffset, float xStep,  
100.             float yStep, int xPixels, int yPixels)  
101.         {  
102.             drawFrame();  
103.         }  
104.   
105.   
106.         public void onTouchEvent(MotionEvent event)  
107.         {  
108.             // 如果检测到滑动操作  
109.             if (event.getAction() == MotionEvent.ACTION_MOVE)  
110.             {  
111.                 mTouchX = event.getX();  
112.                 mTouchY = event.getY();  
113.             }  
114.             else  
115.             {  
116.                 mTouchX = -1;  
117.                 mTouchY = -1;  
118.             }  
119.             super.onTouchEvent(event);  
120.         }  
121.   
122.         // 定义绘制图形的工具方法  
123.         private void drawFrame()  
124.         {  
125.             // 获取该壁纸的SurfaceHolder  
126.             final SurfaceHolder holder = getSurfaceHolder();  
127.             Canvas c = null;  
128.             try  
129.             {  
130.                 // 对画布加锁  
131.                 c = holder.lockCanvas();  
132.                 if (c != null)  
133.                 {  
134.                     c.save();  
135.                     // 绘制背景色  
136.                     c.drawColor(0xff000000);  
137.                     // 在触碰点绘制圆圈  
138.                     drawTouchPoint(c);  
139.                       
140.                     // 绘制圆圈  
141.                     c.drawCircle(cx1, cy1, 80, mPaint);  
142.                     c.drawCircle(cx2, cy2, 40, mPaint);  
143.                     c.drawCircle(cx3, cy3, 50, mPaint);  
144.                     c.drawCircle(cx4, cy4, 60, mPaint);  
145.                     c.restore();  
146.                 }  
147.             }  
148.             finally  
149.             {  
150.                 if (c != null)  
151.                     holder.unlockCanvasAndPost(c);  
152.             }  
153.             mHandler.removeCallbacks(drawTarget);  
154.             // 调度下一次重绘  
155.             if (mVisible)  
156.             {  
157.                 cx1 += 6;  
158.                 cy1 += 8;  
159.                 // 如果cx1、cy1移出屏幕后从左上角重新开始  
160.                 if (cx1 > 320)  
161.                     cx1 = 15;  
162.                 if (cy1 > 400)  
163.                     cy1 = 20;  
164.                   
165.                   
166.                 cx2 -= 6;  
167.                 cy2 -= 8;  
168.                 // 如果cx2、cy2移出屏幕后从右下角重新开始  
169.                 if (cx2 <15)  
170.                     cx2 = 300;  
171.                 if (cy2 <20)  
172.                     cy2 = 380;  
173.                   
174.                   
175.                 cx3 -= 6;  
176.                 cy3 += 8;  
177.                 // 如果cx3、cy3移出屏幕后从右上角重新开始  
178.                 if (cx3 <0)  
179.                     cx3 = 300;  
180.                 if (cy3 >400)  
181.                     cy3 = 20;  
182.                   
183.                   
184.                 cx4 += 6;  
185.                 cy4 -= 8;  
186.                 // 如果cx4、cy4移出屏幕后从左下角重新开始  
187.                 if (cx4 >320)  
188.                     cx4 = 15;  
189.                 if (cy4 <0)  
190.                     cy4 = 380;  
191.                   
192.                 // 指定0.1秒后重新执行mDrawCube一次  
193.                 mHandler.postDelayed(drawTarget, 100);  
194.             }  
195.         }  
196.   
197.         // 在屏幕触碰点绘制圆圈  
198.         private void drawTouchPoint(Canvas c)  
199.         {  
200.             if (mTouchX >= 0 && mTouchY >= 0)  
201.             {  
202.                 c.drawCircle(mTouchX, mTouchY, 40, mPaint);  
203.             }  
204.         }  
205.     }  
206. }  

这样，就基本实现了一个动态壁纸：气泡浮动的效果.

不过这只是一个入门的小例子，如果想达到商用效果,还有很多方面需要进行优化:

1. 绘制更加复杂的图形

2. 使用3D Animation动画效果

3. 色彩方面需要丰富起来

4. 更新UI的方法我使用了handler的postDelay(runnable,millsecond)的方法，这里虽然实现的代码较少，但效率较低，画面仍不够流畅.

不过本人精力有限，因此在此提供了代码，希望有兴趣的朋友可以将其完善,或者给出具体的解决方案，共同讨论