乐乐音乐播放器(六) 仿酷狗的左滑菜单

源码下载：http://www.eoeandroid.com/thread-588446-1-1.html

该功能主要是使用开源的SlidingMenu来实现的，其中盗用了这篇文章的大部分代码，http://blog.csdn.net/xinayida/article/details/40614835


不过他是右滑动的，我修改了一下，弄了一个左滑动的，并为背景图片添加了 模糊 效果


修改代码如下：

1. package com.happy.ui;
   
2. 
   
3. import java.io.InputStream;
   
4. 
   
5. import android.app.Activity;
   
6. import android.graphics.Bitmap;
   
7. import android.graphics.BitmapFactory;
   
8. import android.graphics.Canvas;
   
9. import android.graphics.drawable.BitmapDrawable;
   
10. import android.graphics.drawable.Drawable;
    
11. import android.os.AsyncTask;
    
12. import android.os.Bundle;
    
13. 
    
14. import com.happy.logger.LoggerManage;
    
15. import com.happy.slidingmenu.SlidingMenu;
    
16. import com.happy.slidingmenu.SlidingMenu.CanvasTransformer;
    
17. import com.happy.util.FastBlur;
    
18. import com.happy.util.ImageUtil;
    
19. 
    
20. public class MainActivity extends Activity {
    
21. 
    
22.         private LoggerManage logger;
    
23. 
    
24.         private SlidingMenu slidingMenu;
    
25. 
    
26.         @Override
    
27.         public void onCreate(Bundle savedInstanceState) {
    
28.                 super.onCreate(savedInstanceState);
    
29.                 setContentView(R.layout.activity_main);
    
30.                 init();
    
31.         }
    
32. 
    
33.         private void init() {
    
34.                 logger = LoggerManage.getZhangLogger(this);
    
35. 
    
36.                 slidingMenu = (SlidingMenu) findViewById(R.id.slidingMenu);
    
37. 
    
38.                 slidingMenu.setMode(SlidingMenu.RIGHT);// 设置滑动的方向 向左 、向右或向左向右
    
39.                 slidingMenu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);//
    
40.                 // 设置从哪里可以触发滑动效果：全屏、边界、不可以
    
41.                 slidingMenu.setTouchModeBehind(SlidingMenu.TOUCHMODE_FULLSCREEN);
    
42. 
    
43.                 slidingMenu.setContent(R.layout.slidmenu_mainview);
    
44.                 slidingMenu.setMenu(R.layout.slidmenu_menu);
    
45. 
    
46.                 slidingMenu.setBehindOffsetRes(R.dimen.slidingmenu_offset);
    
47. 
    
48.                 slidingMenu.setFadeDegree(0f);// menu的渐隐效果系数(0-1)
    
49.                 slidingMenu.setBehindScrollScale(0f);// 主页面移动1个像素，menu移动0.1个像素
    
50.                 slidingMenu.setAboveCanvasTransformer(new CanvasTransformer() {
    
51. 
    
52.                         @Override
    
53.                         public void transformCanvas(Canvas canvas, float percentOpen) {
    
54.                                 // percentOpen从0变到1，原图从1倍大小缩小到3/4
    
55.                                 float scale = (float) (1.0 - 0.25 * percentOpen);
    
56.                                 // x，y方向同时放大，动画的相对中心定在“右中”
    
57.                                 canvas.scale(scale, scale, canvas.getWidth(),
    
58.                                                 canvas.getHeight() / 2);
    
59.                         }
    
60.                 });
    
61. 
    
62.                 slidingMenu.setBehindCanvasTransformer(new CanvasTransformer() {
    
63. 
    
64.                         @Override
    
65.                         public void transformCanvas(Canvas canvas, float percentOpen) {
    
66.                                 // // 原图从3/4增加到1倍大小
    
67.                                 // float scale = (float) (0.75 + 0.25 * percentOpen);
    
68.                                 // // x坐标先向屏幕右边移动3/4的视图宽度，然后再慢慢移动到0，这样来实现从屏幕右边移动进屏幕的效果
    
69.                                 // canvas.translate(3 * canvas.getWidth() / 4 - 3 * percentOpen
    
70.                                 // * canvas.getWidth() / 4, 0);
    
71.                                 // // x，y方向同时缩小，动画的相对中心定在“左中”，这样就不至于缩放的时候屏幕左边出现一条空白。
    
72.                                 // canvas.scale(scale, scale, 0, canvas.getHeight() / 2);
    
73. 
    
74.                                 float scale = (float) (percentOpen * 0.25 + 0.75);
    
75.                                 canvas.scale(scale, scale, canvas.getWidth(),
    
76.                                                 canvas.getHeight() / 2);
    
77. 
    
78.                         }
    
79.                 });
    
80. 
    
81.                  BitmapFactory.Options opt = new BitmapFactory.Options();
    
82.                  opt.inPreferredConfig = Bitmap.Config.RGB_565;// 表示16位位图
    
83.                  // 565代表对应三原色占的位数
    
84.                  opt.inInputShareable = true;
    
85.                  opt.inPurgeable = true;// 设置图片可以被回收
    
86.                  InputStream is = getResources().openRawResource(
    
87.                  R.drawable.bg_skin_thumb3);
    
88.                  Bitmap bmp = BitmapFactory.decodeStream(is, null, opt);
    
89.                  //将 immutable bitmap 转为 mutable bitmap 防止报 java.lang.IllegalStateException        at android.graphics.Bitmap.setPixels(Bitmap.java:1461)
    
90.                  //具体可以参考 http://www.educity.cn/wenda/155359.html
    
91.                  
    
92.                  Bitmap bmp2 =  Bitmap.createScaledBitmap(bmp, 480, 320,false);
    
93.                 // Drawable drawable = ImageUtil.boxBlurFilter(bmp);
    
94.                 // new AsyncTask<String, Integer, String>() {
    
95.                 //
    
96.                 // @Override
    
97.                 // protected String doInBackground(String... params) {
    
98. //                final Bitmap bitmap = BitmapFactory.decodeResource(getResources(),
    
99. //                                R.drawable.bg_skin_thumb3);
    
100.                  //添加图片模糊
     
101.                 Bitmap drawable = FastBlur.doBlur(bmp2, 20, true);
     
102.                 slidingMenu.setBackground(new BitmapDrawable(drawable));
     
103.                 // return null;
     
104.                 // }
     
105.                 // }.execute("");
     
106. 
     
107.         }
     
108. 
     
109. }
     

复制代码

图片模糊处理

1. package com.happy.util;
   
2. 
   
3. import android.graphics.Bitmap;
   
4. 
   
5. /**
   
6. * Created by paveld on 3/6/14.
   
7. */
   
8. public class FastBlur {
   
9. 
   
10.     public static Bitmap doBlur(Bitmap sentBitmap, int radius, boolean canReuseInBitmap) {
    
11. 
    
12.         // Stack Blur v1.0 from
    
13.         // http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html
    
14.         //
    
15.         // Java Author: Mario Klingemann 
    
16.         // http://incubator.quasimondo.com
    
17.         // created Feburary 29, 2004
    
18.         // Android port : Yahel Bouaziz 
    
19.         // http://www.kayenko.com
    
20.         // ported april 5th, 2012
    
21. 
    
22.         // This is a compromise between Gaussian Blur and Box blur
    
23.         // It creates much better looking blurs than Box Blur, but is
    
24.         // 7x faster than my Gaussian Blur implementation.
    
25.         //
    
26.         // I called it Stack Blur because this describes best how this
    
27.         // filter works internally: it creates a kind of moving stack
    
28.         // of colors whilst scanning through the image. Thereby it
    
29.         // just has to add one new block of color to the right side
    
30.         // of the stack and remove the leftmost color. The remaining
    
31.         // colors on the topmost layer of the stack are either added on
    
32.         // or reduced by one, depending on if they are on the right or
    
33.         // on the left side of the stack.
    
34.         //
    
35.         // If you are using this algorithm in your code please add
    
36.         // the following line:
    
37.         //
    
38.         // Stack Blur Algorithm by Mario Klingemann 
    
39. 
    
40.         Bitmap bitmap;
    
41.         if (canReuseInBitmap) {
    
42.             bitmap = sentBitmap;
    
43.         } else {
    
44.             bitmap = sentBitmap.copy(sentBitmap.getConfig(), true);
    
45.         }
    
46. 
    
47.         if (radius < 1) {
    
48.             return (null);
    
49.         }
    
50. 
    
51.         int w = bitmap.getWidth();
    
52.         int h = bitmap.getHeight();
    
53. 
    
54.         int[] pix = new int[w * h];
    
55.         bitmap.getPixels(pix, 0, w, 0, 0, w, h);
    
56. 
    
57.         int wm = w - 1;
    
58.         int hm = h - 1;
    
59.         int wh = w * h;
    
60.         int div = radius + radius + 1;
    
61. 
    
62.         int r[] = new int[wh];
    
63.         int g[] = new int[wh];
    
64.         int b[] = new int[wh];
    
65.         int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
    
66.         int vmin[] = new int[Math.max(w, h)];
    
67. 
    
68.         int divsum = (div + 1) >> 1;
    
69.         divsum *= divsum;
    
70.         int dv[] = new int[256 * divsum];
    
71.         for (i = 0; i < 256 * divsum; i++) {
    
72.             dv[i] = (i / divsum);
    
73.         }
    
74. 
    
75.         yw = yi = 0;
    
76. 
    
77.         int[][] stack = new int[div][3];
    
78.         int stackpointer;
    
79.         int stackstart;
    
80.         int[] sir;
    
81.         int rbs;
    
82.         int r1 = radius + 1;
    
83.         int routsum, goutsum, boutsum;
    
84.         int rinsum, ginsum, binsum;
    
85. 
    
86.         for (y = 0; y < h; y++) {
    
87.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
    
88.             for (i = -radius; i <= radius; i++) {
    
89.                 p = pix[yi + Math.min(wm, Math.max(i, 0))];
    
90.                 sir = stack[i + radius];
    
91.                 sir[0] = (p & 0xff0000) >> 16;
    
92.                 sir[1] = (p & 0x00ff00) >> 8;
    
93.                 sir[2] = (p & 0x0000ff);
    
94.                 rbs = r1 - Math.abs(i);
    
95.                 rsum += sir[0] * rbs;
    
96.                 gsum += sir[1] * rbs;
    
97.                 bsum += sir[2] * rbs;
    
98.                 if (i > 0) {
    
99.                     rinsum += sir[0];
    
100.                     ginsum += sir[1];
     
101.                     binsum += sir[2];
     
102.                 } else {
     
103.                     routsum += sir[0];
     
104.                     goutsum += sir[1];
     
105.                     boutsum += sir[2];
     
106.                 }
     
107.             }
     
108.             stackpointer = radius;
     
109. 
     
110.             for (x = 0; x < w; x++) {
     
111. 
     
112.                 r[yi] = dv[rsum];
     
113.                 g[yi] = dv[gsum];
     
114.                 b[yi] = dv[bsum];
     
115. 
     
116.                 rsum -= routsum;
     
117.                 gsum -= goutsum;
     
118.                 bsum -= boutsum;
     
119. 
     
120.                 stackstart = stackpointer - radius + div;
     
121.                 sir = stack[stackstart % div];
     
122. 
     
123.                 routsum -= sir[0];
     
124.                 goutsum -= sir[1];
     
125.                 boutsum -= sir[2];
     
126. 
     
127.                 if (y == 0) {
     
128.                     vmin[x] = Math.min(x + radius + 1, wm);
     
129.                 }
     
130.                 p = pix[yw + vmin[x]];
     
131. 
     
132.                 sir[0] = (p & 0xff0000) >> 16;
     
133.                 sir[1] = (p & 0x00ff00) >> 8;
     
134.                 sir[2] = (p & 0x0000ff);
     
135. 
     
136.                 rinsum += sir[0];
     
137.                 ginsum += sir[1];
     
138.                 binsum += sir[2];
     
139. 
     
140.                 rsum += rinsum;
     
141.                 gsum += ginsum;
     
142.                 bsum += binsum;
     
143. 
     
144.                 stackpointer = (stackpointer + 1) % div;
     
145.                 sir = stack[(stackpointer) % div];
     
146. 
     
147.                 routsum += sir[0];
     
148.                 goutsum += sir[1];
     
149.                 boutsum += sir[2];
     
150. 
     
151.                 rinsum -= sir[0];
     
152.                 ginsum -= sir[1];
     
153.                 binsum -= sir[2];
     
154. 
     
155.                 yi++;
     
156.             }
     
157.             yw += w;
     
158.         }
     
159.         for (x = 0; x < w; x++) {
     
160.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
     
161.             yp = -radius * w;
     
162.             for (i = -radius; i <= radius; i++) {
     
163.                 yi = Math.max(0, yp) + x;
     
164. 
     
165.                 sir = stack[i + radius];
     
166. 
     
167.                 sir[0] = r[yi];
     
168.                 sir[1] = g[yi];
     
169.                 sir[2] = b[yi];
     
170. 
     
171.                 rbs = r1 - Math.abs(i);
     
172. 
     
173.                 rsum += r[yi] * rbs;
     
174.                 gsum += g[yi] * rbs;
     
175.                 bsum += b[yi] * rbs;
     
176. 
     
177.                 if (i > 0) {
     
178.                     rinsum += sir[0];
     
179.                     ginsum += sir[1];
     
180.                     binsum += sir[2];
     
181.                 } else {
     
182.                     routsum += sir[0];
     
183.                     goutsum += sir[1];
     
184.                     boutsum += sir[2];
     
185.                 }
     
186. 
     
187.                 if (i < hm) {
     
188.                     yp += w;
     
189.                 }
     
190.             }
     
191.             yi = x;
     
192.             stackpointer = radius;
     
193.             for (y = 0; y < h; y++) {
     
194.                 // Preserve alpha channel: ( 0xff000000 & pix[yi] )
     
195.                 pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
     
196. 
     
197.                 rsum -= routsum;
     
198.                 gsum -= goutsum;
     
199.                 bsum -= boutsum;
     
200. 
     
201.                 stackstart = stackpointer - radius + div;
     
202.                 sir = stack[stackstart % div];
     
203. 
     
204.                 routsum -= sir[0];
     
205.                 goutsum -= sir[1];
     
206.                 boutsum -= sir[2];
     
207. 
     
208.                 if (x == 0) {
     
209.                     vmin[y] = Math.min(y + r1, hm) * w;
     
210.                 }
     
211.                 p = x + vmin[y];
     
212. 
     
213.                 sir[0] = r[p];
     
214.                 sir[1] = g[p];
     
215.                 sir[2] = b[p];
     
216. 
     
217.                 rinsum += sir[0];
     
218.                 ginsum += sir[1];
     
219.                 binsum += sir[2];
     
220. 
     
221.                 rsum += rinsum;
     
222.                 gsum += ginsum;
     
223.                 bsum += binsum;
     
224. 
     
225.                 stackpointer = (stackpointer + 1) % div;
     
226.                 sir = stack[stackpointer];
     
227. 
     
228.                 routsum += sir[0];
     
229.                 goutsum += sir[1];
     
230.                 boutsum += sir[2];
     
231. 
     
232.                 rinsum -= sir[0];
     
233.                 ginsum -= sir[1];
     
234.                 binsum -= sir[2];
     
235. 
     
236.                 yi += w;
     
237.             }
     
238.         }
     
239. 
     
240.         bitmap.setPixels(pix, 0, w, 0, 0, w, h);
     
241. 
     
242.         return (bitmap);
     
243.     }
     
244. }

复制代码

这次上传代码比较急，不过代码后期会优化