Gauss Fuzzy Android

Keywords: Android Java xml encoding

Gauss Fuzzy Android

Prerequisite: Current requirements require users to see the ambiguous background of opening applications every time they slide down the status bar. The following introduction focuses on the implementation of this requirement.

Here are some ways to use and see them

Method 1:

Get the current screen shot (using SurfaceControl.screenshot) and process it in high-speed mode if the result is null Instead of using wallpaper (in order to consider the compression of wide screen wallpaper or non-home wallpaper), Layer Drawable is used after acquisition to take the resulting Drawable as the background of the current application, which not only achieves the ambiguous effect, but also saves the content of the current program. (Prevents wallpaper from being easily blurred when the color of the wallpaper is similar to the content of the current program.) Question)

Method 2:

Get the system wallpaper, cut, and synthesize the cut wallpaper and a translucent picture (size should be noted). This is not directly used by Layer Drawable, but by Canvas. Then the synthesized wallpaper is blurred by Gauss.

Note: Method 2 actually needs to cut wallpaper in the process of using. This can not be tailored. It needs to copy the wallpaper first. A Bitmap object can only be operated on. In addition, memory overflow is prone to occur during subsequent synthesis and fuzzification. The following methods can be used to solve this problem. Of course, it is necessary to call Bitmap's receyle() method in time for recovery.
New Bitmap = bmp. copy (Bitmap. Config. ARGB_4444, true); //Use ARGB_4444 to reduce memory usage

Because the two methods are used separately in different projects, the advantages and disadvantages of each method can be combined with the actual situation to achieve the relevant requirements.

Method 3:

The above method is mainly realized by using java, that is, the method of getting bitmap is different, and the actual method of fuzzy processing is exactly the same. That is, RenderScript and cript Intrinsic Blur are used to deal with all the above methods. After learning from other people's achievements, it is found that there is also the part of using C to achieve fuzzy processing, which temporarily does not compare the performance differences. At the same time, this method also uses Su. RfaceControl. screenshot To get bitmap resources.

Note: You need to add <uses-permission android:name="android.permission.READ_FRAME_BUFFER"/> At the same time, system signature is required.


The source code of method 1 is as follows: 

    

  1. private static final int BLUR_RADIUS = 3;
private static final int SCALE_RATIO = 8;

    2. 

  2. public void blur(){
    3. 

  3.    Bitmap mBackBitmap = getScreenshot(context, BLUR_RADIUS);
    4. 

  4. 	Drawable backgroundDrawable = null;
    5. 

  5. 	if (mBackBitmap != null) {
    6. 

  6. 		backgroundDrawable = new BitmapDrawable(mBackBitmap);
    7. 

  7. 	} else {
    8. 

  8. 		Log.i(TAG, "mBackBitmap is null.");
    9. 

  9. 		WallpaperManager wallpaperManager = WallpaperManager.getInstance(mDialogContext);
    10. 

  10. 		backgroundDrawable = wallpaperManager.getDrawable();
    11. 

  11. 	}
    12. 

  12. 	if (backgroundDrawable != null) {
    13. 

  13. 		getWindow().getDecorView().setBackground(new LayerDrawable(new Drawable[]{backgroundDrawable,
    14. 

  14. 			context.getResources().getDrawable(R.drawable.ali_poweroff_background)}));
    15. 

  15. 	}
    16. 

  16. }
    17. 

  17. private Bitmap getScreenshot(Context context, int radius) {
    18. 

  18. 	long start = System.currentTimeMillis();
    19. 

  19. 	Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
    20. 

  20. 	DisplayMetrics displayMetrics = new DisplayMetrics();
    21. 

  21. 	Matrix displayMatrix = new Matrix();
    22. 

  22. 	display.getRealMetrics(displayMetrics);
    23. 

  23. 	final int w = displayMetrics.widthPixels;
    24. 

  24. 	final int h = displayMetrics.heightPixels;
    25. 

  25. 	float[] dims = {w, h};
    26. 

  26. 	float degrees = getDegreesForRotation(display.getRotation());
    27. 

  27. 	boolean requiresRotation = (degrees > 0);
    28. 

  28. 	if (requiresRotation) {
    29. 

  29. 		// Get the dimensions of the device in its native orientation
    30. 

  30. 		displayMatrix.reset();
    31. 

  31. 		displayMatrix.preRotate(-degrees);
    32. 

  32. 		displayMatrix.mapPoints(dims);
    33. 

  33. 		dims[0] = Math.abs(dims[0]);
    34. 

  34. 		dims[1] = Math.abs(dims[1]);
    35. 

  35. 	}
    36. 

  36. 	Bitmap bp = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);
    37. 

  37. 	if (bp == null) return null;
    38. 

  38. 	//clip bitmap
    39. 

  39. 	Bitmap ss = Bitmap.createBitmap((int) dims[0]/SCALE_RATIO, (int) dims[1]/SCALE_RATIO, Bitmap.Config.ARGB_8888);
    40. 

  40. 	if (ss == null) return null;
    41. 

  41. 	Canvas c = new Canvas(ss);
    42. 

  42. 	c.clipRect(0, 0, dims[0] / SCALE_RATIO, dims[1] / SCALE_RATIO);
    43. 

  43. 	Rect srcRect = new Rect(0, 0, bp.getWidth(), bp.getHeight());
    44. 

  44. 	Rect dstRect = new Rect(0, 0, ss.getWidth(), ss.getHeight());
    45. 

  45. 	c.drawBitmap(bp, srcRect, dstRect, null);
    46. 

  46. 	c.setBitmap(null);
    47. 

  47. 	bp.recycle();
    48. 

  48. 	bp = ss;
    49. 

  49.       //rotate bitmap
    50. 

  50. 	if (requiresRotation) {
    51. 

  51. 		ss = Bitmap.createBitmap(w / SCALE_RATIO, h / SCALE_RATIO, Bitmap.Config.ARGB_8888);
    52. 

  52. 		if (ss == null) return null;
    53. 

  53. 		c = new Canvas(ss);
    54. 

  54. 		c.translate(ss.getWidth() / 2, ss.getHeight() / 2);
    55. 

  55. 		c.rotate(degrees);
    56. 

  56. 		c.translate(-dims[0] / (2 * SCALE_RATIO), -dims[1] / (2 * SCALE_RATIO));
    57. 

  57. 		c.drawBitmap(bp, 0, 0, null);
    58. 

  58. 		c.setBitmap(null);
    59. 

  59. 		bp.recycle();
    60. 

  60. 		bp = ss;
    61. 

  61. 	}
    62. 

  62. 	//blur bitmap
    63. 

  63. 	Bitmap bitmap = bp.copy(bp.getConfig(), true);
    64. 

  64. 	final RenderScript rs = RenderScript.create(context);
    65. 

  65. 	final Allocation input = Allocation.createFromBitmap(rs, bp, Allocation.MipmapControl.MIPMAP_NONE,
    66. 

  66. 			Allocation.USAGE_SCRIPT);
    67. 

  67. 	final Allocation output = Allocation.createTyped(rs, input.getType());
    68. 

  68. 	final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
    69. 

  69. 	script.setRadius(radius);
    70. 

  70. 	script.setInput(input);
    71. 

  71. 	script.forEach(output);
    72. 

  72. 	output.copyTo(bitmap);
    73. 

  73. 	long end = System.currentTimeMillis();
    74. 

  74. 	Log.d(TAG, "Take time " + (end - start));
    75. 

  75. 	return bitmap;
    76. 

  76. }
    77. 

  77. private float getDegreesForRotation(int value) {
    78. 

  78. 	switch (value) {
    79. 

  79. 	case Surface.ROTATION_90:
    80. 

  80. 		return 360f - 90f;
    81. 

  81. 	case Surface.ROTATION_180:
    82. 

  82. 		return 360f - 180f;
    83. 

  83. 	case Surface.ROTATION_270:
    84. 

  84. 		return 360f - 270f;
    85. 

  85. 	}
    86. 

  86. 	return 0f;
    87. 

  87. }
    88.
drawable:ali_poweroff_background

    

  1. <?xml version="1.0" encoding="utf-8"?>
    2. 

  2. <shape xmlns:android="http://schemas.android.com/apk/res/android">
    3. 

  3.     <gradient android:name="poweroff_background"
    4. 

  4.         android:startColor="#e5000000"
    5. 

  5.         android:endColor="#7f000000"
    6. 

  6.         android:angle="90"
    7. 

  7.         />
    8. 

  8. </shape>
    9.

Method 2 source code is as follows:

    

  1. private Bitmap blur_wallpaper = null;
    2. 

  2. public void applyBlur() {
    3. 

  3.     	Log.d(TAG,"applyBlur ------- ");
    4. 

  4.     	if(null != blur_wallpaper && !blur_wallpaper.isRecycled()){//Recycle variables that last saved wallpaper
    5. 

  5.     		Log.d(TAG,"applyBlur blur_wallpaper isRecycled");
    6. 

  6.     		setBackgroundResource(R.drawable.backgoud_bulr);
    7. 

  7. 			blur_wallpaper.recycle();
    8. 

  8. 			blur_wallpaper = null;
    9. 

  9. 		}
    10. 

  10.     	if(wallpaperManager == null){
    11. 

  11.     		wallpaperManager = WallpaperManager.getInstance(this.getContext());
    12. 

  12.     	}
    13. 

  13. Drawable wallpaperDrawable = wallpaperManager.getDrawable();
    14. 

  14.    		Bitmap bmp = ((BitmapDrawable) wallpaperDrawable).getBitmap();
    15. 

  15.    		Bitmap newBitmap = bmp;
    16. 

  16.    		if(null == newBitmap){
    17. 

  17.    			Log.d(TAG,"applyBlur newBitmap is null" );
    18. 

  18.    			if(blur_wallpaper == null){
    19. 

  19.    				setBackgroundResource(R.drawable.backgoud_bulr_default);
    20. 

  20.    				blur_wallpaper = ((BitmapDrawable)getResources().getDrawable(R.drawable.backgoud_bulr_default)).getBitmap();
    21. 

  21.    			}
    22. 

  22.    			return;
    23. 

  23.    		}else if(!newBitmap.isMutable()){
    24. 

  24.    			int w = bmp.getWidth();
    25. 

  25.    			int h = bmp.getHeight();
    26. 

  26.    			Log.d(TAG,"applyBlur w=" + w + " h=" + h);
    27. 

  27.    			
    28. 

  28.    	    	Log.d(TAG,"applyBlur not isMutable");
    29. 

  29.    	         try {
    30. 

  30. 				newBitmap = bmp.copy(Bitmap.Config.ARGB_4444, true);//Reducing memory usage with ARGB_4444
    31. 

  31. 			} catch (Exception e) {
    32. 

  32. 				Log.d(TAG,"bitmap copy error,out of memory");
    33. 

  33. 				if(null != bmp && !bmp.isRecycled()){
    34. 

  34. //					bmp.recycle();
    35. 

  35. 					bmp = null;
    36. 

  36. 				}
    37. 

  37. 				if(null != newBitmap && !newBitmap.isRecycled()){
    38. 

  38. 					newBitmap.recycle();
    39. 

  39. 					newBitmap = null;
    40. 

  40. 				}
    41. 

  41. 				setBackgroundResource(R.drawable.backgoud_bulr_default);
    42. 

  42. 				blur_wallpaper = ((BitmapDrawable)getResources().getDrawable(R.drawable.backgoud_bulr_default)).getBitmap();
    43. 

  43. 				Log.d(TAG,"use default background");
    44. 

  44. 				return ;
    45. 

  45. 			}
    46. 

  46.    	    }
    47. 

  47. newBitmap = mPictureUtil.setAndcropWallpaper(mContext, newBitmap);
    48. 

  48.    	    if(null == newBitmap){
    49. 

  49.    	    	Toast.makeText(mContext, R.string.update_status_bar_ground_error, Toast.LENGTH_SHORT).show();
    50. 

  50.    	    	
    51. 

  51.    	    	setBackgroundResource(R.drawable.backgoud_bulr_default);
    52. 

  52. 			blur_wallpaper = ((BitmapDrawable)getResources().getDrawable(R.drawable.backgoud_bulr_default)).getBitmap();
    53. 

  53. 			Log.d(TAG,"use default background----");
    54. 

  54.    	    	return;
    55. 

  55.    	    }
    56. 

  56.        
    57. 

  57.    	    Canvas canvas = new Canvas(newBitmap);
    58. 

  58.         Drawable backgoud_bulr = this.getResources().getDrawable(R.drawable.backgoud_bulr);//Translucent black background
    59. 

  59.         Bitmap bitmap_backgoud_bulr = ((BitmapDrawable)backgoud_bulr).getBitmap();
    60. 

  60.         canvas.drawBitmap(bitmap_backgoud_bulr, 0, 0, null );
    61. 

  61.         
    62. 

  62.         canvas.save(Canvas.ALL_SAVE_FLAG); 
    63. 

  63.         //Store newly synthesized pictures
    64. 

  64.         canvas.restore(); 
    65. 

  65.         
    66. 

  66.    		if(bmp != null && !bmp.isRecycled()){
    67. 

  67.    			Log.d(TAG,"applyBlur bmp.isRecycled");
    68. 

  68. //   			bmp.recycle();
    69. 

  69.    			bmp = null;
    70. 

  70.    		}
    71. 

  71.    		if(bitmap_backgoud_bulr != null && !bitmap_backgoud_bulr.isRecycled()){
    72. 

  72.    			Log.d(TAG,"applyBlur bitmap_backgoud_bulr.isRecycled");
    73. 

  73.    			bitmap_backgoud_bulr.recycle();
    74. 

  74.    			bitmap_backgoud_bulr = null;
    75. 

  75.    			backgoud_bulr = null;
    76. 

  76.    		}
    77. 

  77.    		
    78. 

  78.    		blur_wallpaper = mPictureUtil.blur(mContext, newBitmap);
    79. 

  79.    		Drawable background = new BitmapDrawable(getResources(), blur_wallpaper);
    80. 

  80.    		setBackground(background);
    81. 

  81.    		
    82. 

  82.    		if(null != newBitmap && !newBitmap.isRecycled()){
    83. 

  83.    			Log.d(TAG,"blur bkg.isRecycled");
    84. 

  84.    			newBitmap.recycle();
    85. 

  85.    			newBitmap = null;
    86. 

  86.    		}
    87. 

  87.    		
    88. 

  88.    	}
    89. 


    

    2. 

  2. /**   
    3. 

  3. * @Title: PictureUtil.java 
    4. 

  4. * @Package com.doov.systemui.utils 
    5. 

  5. * @Description: TODO(Describe what the document does in one sentence. 
    6. 

  6. * @author
    7. 

  7. * @date 2015 7 August 2000, 3:54:46 p.m. 
    8. 

  8. * @version V1.0   
    9. 

  9. */
    10. 

  10. package com.doov.systemui.utils;
    11. 

  11. import android.annotation.TargetApi;
    12. 

  12. import android.content.Context;
    13. 

  13. import android.graphics.Bitmap;
    14. 

  14. import android.graphics.Matrix;
    15. 

  15. import android.graphics.drawable.BitmapDrawable;
    16. 

  16. import android.graphics.drawable.Drawable;
    17. 

  17. import android.os.Build;
    18. 

  18. import android.renderscript.Allocation;
    19. 

  19. import android.renderscript.Element;
    20. 

  20. import android.renderscript.RenderScript;
    21. 

  21. import android.renderscript.ScriptIntrinsicBlur;
    22. 

  22. import android.util.DisplayMetrics;
    23. 

  23. import android.util.Log;
    24. 

  24. import android.view.WindowManager;
    25. 

  25. /** 
    26. 

  26.  * @ClassName: PictureUtil 
    27. 

  27.  * @Description:Picture processing
    28. 

  28.  * @author  zhang.le
    29. 

  29.  * @date 2015 7 August 2000, 3:54:46 p.m. 
    30. 

  30.  *  
    31. 

  31.  */
    32. 

  32. public class PictureUtil {
    33. 

  33. 	private static final String TAG = "PictureUtil";
    34. 

  34. 	public final static int mScal = 2;
    35. 

  35. 	private final boolean DEBUG = true;
    36. 

  36. 	 
    37. 

  37. 	
    38. 

  38. 	/**
    39. 

  39. 	 * 
    40. 

  40. 	*Gauss Mode Processing
    41. 

  41. 	* @param  context
    42. 

  42. 	* @param  bkg
    43. 

  43. 	* @return Bitmap    Return type 
    44. 

  44. 	 */
    45. 

  45.    	@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
    46. 

  46.    	public Bitmap blur(Context context,Bitmap bkg) {
    47. 

  47.    		long startMs = System.currentTimeMillis();
    48. 

  48.    		float radius = 25;
    49. 

  49.    		bkg = small(bkg);
    50. 

  50.    		bkg = bkg.copy(bkg.getConfig(), true);
    51. 

  51.    		
    52. 

  52.    		final RenderScript rs = RenderScript.create(context);
    53. 

  53.    		final Allocation input = Allocation.createFromBitmap(rs, bkg, Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT);
    54. 

  54.    		final Allocation output = Allocation.createTyped(rs, input.getType());
    55. 

  55.    		final ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs,
    56. 

  56.    				Element.U8_4(rs));
    57. 

  57.    		script.setRadius(radius);
    58. 

  58.    		script.setInput(input);
    59. 

  59.    		script.forEach(output);
    60. 

  60.    		output.copyTo(bkg);
    61. 

  61.    		
    62. 

  62.    		rs.destroy();
    63. 

  63.    		script.destroy();
    64. 

  64.    		input.destroy();
    65. 

  65.    		output.destroy();
    66. 

  66.    		
    67. 

  67.    		Log.d(TAG, "blur take away:" + (System.currentTimeMillis() - startMs) + "ms");
    68. 

  68.    		return bkg;
    69. 

  69.    	}
    70. 

  70.    	
    71. 

  71.    	private static Bitmap small(Bitmap bitmap) {
    72. 

  72.    		Matrix matrix = new Matrix();
    73. 

  73.    		matrix.postScale(1f/mScal, 1f/mScal); // Ratio of length and width amplification to reduction
    74. 

  74.    		Bitmap resizeBmp = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
    75. 

  75.    				bitmap.getHeight(), matrix, true);
    76. 

  76.    		return resizeBmp;
    77. 

  77.    	}
    78. 

  78.    	
    79. 

  79. /**
    80. 

  80.    	 * 
    81. 

  81.    	* Cut pictures
    82. 

  82.    	* @param  context
    83. 

  83.    	* @param  wallpaper
    84. 

  84.    	* @return Bitmap  
    85. 

  85.    	 */
    86. 

  86. 	public Bitmap setAndcropWallpaper(Context context,Bitmap wallpaper) {
    87. 

  87. 		Bitmap targetBitmap = null;
    88. 

  88. 		if (wallpaper != null) {
    89. 

  89. 			try {
    90. 

  90. 				int wallpaperWidth = wallpaper.getWidth();
    91. 

  91. 				int wallpaperHeight = wallpaper.getHeight();
    92. 

  92. 				DisplayMetrics dm = new DisplayMetrics();
    93. 

  93. 				WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    94. 

  94. 				wm.getDefaultDisplay().getMetrics(dm);
    95. 

  95. 				int screenWidth = dm.widthPixels;// 1080
    96. 

  96. 				int screenHeight = dm.heightPixels;// 1920
    97. 

  97. 				float defaultScreen =  (float)screenHeight / (float)screenWidth;
    98. 

  98. 				Log.d(TAG, "defaultScreen=" + defaultScreen);
    99. 

  99. 				if (defaultScreen < 1) {
    100. 

  100. 					defaultScreen = (float)screenWidth / (float)screenHeight;
    101. 

  101. 				}
    102. 

  102. 				float bitmapSize = (float)wallpaperHeight /(float)wallpaperWidth;
    103. 

  103. 				int disWidth = 0;
    104. 

  104. 				int disHeight = 0;
    105. 

  105. 				int captureBitmapWidth = wallpaperWidth;
    106. 

  106. 				int captureBitmapHeight = wallpaperHeight;
    107. 

  107. 				Log.d(TAG, "defaultScreen=" + defaultScreen + " bitmapSize="
    108. 

  108. 						+ bitmapSize);
    109. 

  109. 				if (defaultScreen > bitmapSize) { // bitmapHeight is min ,  capture bitmapWidth
    110. 

  110. 					captureBitmapWidth = (int) ((screenWidth * wallpaperHeight) / screenHeight);
    111. 

  111. 					disWidth = wallpaperWidth - captureBitmapWidth;
    112. 

  112. 				} else if (defaultScreen < bitmapSize) {
    113. 

  113. 					captureBitmapHeight = (int) ((wallpaperWidth * screenHeight) / screenWidth);
    114. 

  114. 					disHeight = wallpaperHeight - captureBitmapHeight;
    115. 

  115. 				}
    116. 

  116. if (DEBUG) {
    117. 

  117. 					Log.d(TAG, "setAndcropWallpaper ----- disWidth="
    118. 

  118. 							+ disWidth + ",disHeight=" + disHeight
    119. 

  119. 							+ ",captureBitmapWidth=" + captureBitmapWidth
    120. 

  120. 							+ ",captureBitmapHeight=" + captureBitmapHeight
    121. 

  121. 							+ " screenWidth=" + screenWidth + " screenHeight="
    122. 

  122. 							+ screenHeight);
    123. 

  123. 				}
    124. 

  124. 				if (disWidth < 0 || disHeight < 0) {
    125. 

  125. 					return null;
    126. 

  126. 				}
    127. 

  127. 				targetBitmap = Bitmap.createBitmap(wallpaper, disWidth / 2,
    128. 

  128. 						disHeight / 2, captureBitmapWidth, captureBitmapHeight);
    129. 

  129. 				float scaleWidth = (float) ((float) captureBitmapWidth / screenWidth);
    130. 

  130. 				float scaleHeight = (float) ((float) captureBitmapHeight / screenHeight);
    131. 

  131. 				Log.d(TAG, "scaleWidth=" + scaleWidth + " scaleHeight="
    132. 

  132. 						+ scaleHeight);
    133. 

  133. 				if ((targetBitmap != null)
    134. 

  134. 						&& (scaleWidth != 1 || scaleHeight != 1)) {
    135. 

  135. 					Matrix matrix = new Matrix();
    136. 

  136. 					/**
    137. 

  137. 					 * After processing, the image size is smaller than the screen size. The original image proportion is the same as the screen proportion, but the size is larger than the screen size.
    138. 

  138. 					 */
    139. 

  139. 					if (scaleWidth != 0.0f && scaleHeight != 0.0f
    140. 

  140. 							&& (scaleWidth != 1.0f || scaleHeight != 1.0f)) {//
    141. 

  141. 						scaleWidth = 1.0f / scaleWidth;
    142. 

  142. 						scaleHeight = 1.0f / scaleHeight;
    143. 

  143. 						Log.d(TAG, "---scaleWidth=" + scaleWidth + " scaleHeight=" + scaleHeight);
    144. 

  144. 					}
    145. 

  145. 					matrix.postScale(scaleWidth, scaleHeight);
    146. 

  146. 					int width = targetBitmap.getWidth();
    147. 

  147. 					int height = targetBitmap.getHeight();
    148. 

  148. 					Log.d(TAG, "---width=" + width + " height=" + height);
    149. 

  149. 					targetBitmap = Bitmap.createBitmap(targetBitmap, 0, 0,
    150. 

  150. 							screenWidth > width ? width : screenWidth,
    151. 

  151. 							screenHeight > height ? height : screenHeight,
    152. 

  152. 							matrix, true);
    153. 

  153. 				}
    154. 

  154. 			} catch (OutOfMemoryError e) {
    155. 

  155. 				e.printStackTrace();
    156. 

  156. 			}
    157. 

  157. 		}
    158. 

  158. 		return targetBitmap;
    159. 

  159. 	}
    160. 

  160. }
    161.

Method 3 source code

PhoneStatusBar.java
    

  1. protected static final int MSG_SCREEN_SHOT = 2031;

    2. 

  2. 

    3. 

  3. public boolean interceptTouchEvent(MotionEvent event) {
    4. 

  4. 	//......
    5. 

  5. 	//zhangle add start 
    6. 

  6. 	int action = event.getAction();
    7. 

  7. 	if (MotionEvent.ACTION_DOWN == action) {
    8. 

  8. 		if (!mExpandedVisible) {
    9. 

  9. 			boolean hasScreenShotMsg = myHandler.hasMessages(MSG_SCREEN_SHOT);
    10. 

  10. 			LogD.d(TAG, "interceptTouchEvent hasScreenShotMsg = " + hasScreenShotMsg);
    11. 

  11. 			if (!hasScreenShotMsg) {
    12. 

  12. 				 Log.d(TAG, " sendEmptyMessage MSG_SCREEN_SHOT currentTimeMillis = " + System.currentTimeMillis());
    13. 

  13. 				 myHandler.sendEmptyMessage(MSG_SCREEN_SHOT);
    14. 

  14. 			}
    15. 

  15. 		}
    16. 

  16. 	}
    17. 

  17. 	//zhangel add end
    18. 

  18. 	return false;
    19. 

  19. }
    20.
The above modification is to ensure that the latest screenshots are available every time you click on the status bar. For specific reasons, refer to notes related to the System UI process.
NotificationPanelView.java
Add the following code
    

  1. private Bitmap mScreenShotBg;
    2. 

  2. protected void setScreenShotBitmap(Bitmap bitmap) {
    3. 

  3. 	mScreenShotBg = bitmap;
    4. 

  4. }
    5. 

    6. 

  6. public void recyleScreenShotBg(){
    7. 

  7. 	if (mScreenShotBg != null) {
    8. 

  8. 		mScreenShotBg.recycle();
    9. 

  9. 		mScreenShotBg = null;
    10. 

  10. 	}
    11. 

  11. }
    12. 

    13. 

  13. @Override
    14. 

  14. public void draw(Canvas canvas) {
    15. 

  15. 	if (canvas == null) {
    16. 

  16. 		return;
    17. 

  17. 	}
    18. 

  18. 	if (mScreenShotBg != null) {
    19. 

  19. 		Bitmap bp = mScreenShotBg;
    20. 

  20. 		Rect dstRect = new Rect(0, 0, getWidth(), (int) getFullHeight());
    21. 

  21. 		Paint paint = new Paint();
    22. 

  22. 		paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC));
    23. 

  23. 		canvas.drawBitmap(bp, new Rect(0, 0, bp.getWidth(), bp.getHeight()), dstRect, paint);
    24. 

  24. 	}
    25. 

  25. 	super.draw(canvas);
    26. 

  26. 	
    27. 

  27. }
    28.
At the same time, recyleScreenShotBg() is added at the end of onDetachedFromWindow to reclaim memory.

The following is mainly about using Handler to send messages to use SurfaceControl.screenshot to obtain bitmap resources for JNI processing.
PhoneStatusBar.java
    

  1. //zhangle add start
    2. 

  2. private Handler myHandler = new Handler(){
    3. 

    4. 

  4. 	@Override
    5. 

  5. 	public void dispatchMessage(Message msg) {
    6. 

  6. 		switch (msg.what) {
    7. 

  7. 		case MSG_SCREEN_SHOT:
    8. 

  8. 			Xlog.d(TAG, "MSG_SCREEN_SHOT.");
    9. 

  9. 			Bitmap screenShotBitmap = screenshotFocusedWindow(mDisplayMetrics.widthPixels,
    10. 

  10. 					mDisplayMetrics.heightPixels);
    11. 

  11. 			if (screenShotBitmap != null) {
    12. 

  12. 				mNotificationPanel.setScreenShotBitmap(screenShotBitmap);
    13. 

  13. 			}
    14. 

  14. 			break;
    15. 

  15. 		default:
    16. 

  16. 			break;
    17. 

  17. 		}
    18. 

  18. 	}
    19. 

  19. };
    20. 

  20. private Bitmap screenshotFocusedWindow(int maxWidth, int maxHeight) {
    21. 

  21. 	long beginScreenShot = System.currentTimeMillis();
    22. 

  22. 	int rot = mDisplay.getRotation();
    23. 

  23. 	Rect frame = new Rect();
    24. 

  24. 	float degrees = 0f;
    25. 

  25. 	switch (rot) {
    26. 

  26. 		case Surface.ROTATION_90:
    27. 

  27. 			degrees = 360f - 90f;
    28. 

  28. 			break;
    29. 

  29. 		case Surface.ROTATION_180:
    30. 

  30. 			degrees = 360f - 180f;
    31. 

  31. 			break;
    32. 

  32. 		case Surface.ROTATION_270:
    33. 

  33. 			degrees = 360f - 270f;
    34. 

  34. 			break;
    35. 

  35. 		default:
    36. 

  36. 			degrees = 0f;
    37. 

  37. 			break;
    38. 

  38. 	}
    39. 

    40. 

  40. 	int mNavSize = 0;
    41. 

  41. 	try {
    42. 

  42. 		boolean showNav = mWindowManagerService.hasNavigationBar();//IWindowManager
    43. 

  43. 		if (showNav) {
    44. 

  44. 			mNavSize = mContext.getResources().getDimensionPixelSize(
    45. 

  45. 					R.dimen.navigation_bar_size);
    46. 

  46. 		}
    47. 

  47. 	} catch (RemoteException ex) {
    48. 

  48. 		// no window manager? good luck with that
    49. 

  49. 		Slog.e(TAG, "resolve navigationbar layout fail");
    50. 

  50. 	}
    51. 

  51. 	
    52. 

  52. 	if (mNavSize > 0) {
    53. 

  53. 		if (maxHeight > maxWidth) {
    54. 

  54. 			maxHeight += mNavSize;
    55. 

  55. 		} else {
    56. 

  56. 			maxWidth += mNavSize;
    57. 

  57. 		}
    58. 

  58. 	}
    59. 

    60. 

  60. 	Matrix matrix = new Matrix();
    61. 

  61. 	int dw = maxWidth;
    62. 

  62. 	int dh = maxHeight;
    63. 

  63. 	if (DEBUG) Log.d("screenshot", "bitmap dw =" + maxWidth + " dh = " + maxHeight);
    64. 

    65. 

  65. 	frame.set(0, 0/* getStatusBarHeight() */, dw, dh);
    66. 

    67. 

  67. 	float dims[] = {
    68. 

  68. 			dw, dh
    69. 

  69. 	};
    70. 

  70. 	boolean requiresRotation = (degrees > 0);
    71. 

  71. 	if (requiresRotation) {
    72. 

  72. 		// Get the dimensions of the device in its native orientation
    73. 

  73. 		matrix.reset();
    74. 

  74. 		matrix.preRotate(-degrees);
    75. 

  75. 		matrix.mapPoints(dims);
    76. 

  76. 		dims[0] = Math.abs(dims[0]);
    77. 

  77. 		dims[1] = Math.abs(dims[1]);
    78. 

  78. 	}
    79. 

    80. 

  80. 	if (frame.isEmpty()) {
    81. 

  81. 		return null;
    82. 

  82. 	}
    83. 

  83. 	if (DEBUG) Log.d("screenshot", "bitmap width =" + dims[0] + "height = " + dims[1]);
    84. 

  84. 	Bitmap bp = SurfaceControl.screenshot((int) dims[0], (int) dims[1]);
    85. 

  85. 	// The screenshot() interface may fail. If it fail, it will return null.
    86. 

  86. 	// If the screenshot is null, the statusbar will be transparent.
    87. 

  87. 	if (bp == null) {
    88. 

  88. 		return null;
    89. 

  89. 	}
    90. 

  90. 	final int SCALE_RATIO = 8;
    91. 

  91. 	if (requiresRotation) {
    92. 

  92. 		// Rotate the screenshot to the current orientation
    93. 

  93. 		Bitmap ss = Bitmap.createBitmap(dw / SCALE_RATIO, dh / SCALE_RATIO,
    94. 

  94. 				Bitmap.Config.ARGB_8888);
    95. 

  95. 		if (DEBUG)
    96. 

  96. 			Log.d("screenshot", "Canvas width =" + dims[0] + " height = " + dims[1]);
    97. 

  97. 		if (ss == null) {
    98. 

  98. 			return null;
    99. 

  99. 		}
    100. 

  100. 		Canvas c = new Canvas(ss);
    101. 

  101. 		c.clipRect(0, frame.top / SCALE_RATIO, dw / SCALE_RATIO, dh / SCALE_RATIO);
    102. 

  102. 		if (mNavSize > 0) {
    103. 

  103. 			c.clipRect(0, 0, (dw - mNavSize) / SCALE_RATIO, dh / SCALE_RATIO);
    104. 

  104. 		}
    105. 

  105. 		c.translate(ss.getWidth() / 2, ss.getHeight() / 2);
    106. 

  106. 		c.rotate(degrees);
    107. 

  107. 		c.translate(-dims[0] / (2 * SCALE_RATIO), -dims[1] / (2 * SCALE_RATIO));
    108. 

  108. 		// c.drawBitmap(bp, 0, 0, null);
    109. 

  109. 		Rect dstRect = new Rect(0, 0, ss.getHeight(), ss.getWidth());
    110. 

  110. 		c.drawBitmap(bp, new Rect(0, 0, bp.getWidth(), bp.getHeight()), dstRect, null);
    111. 

  111. 		Paint paint = new Paint();
    112. 

  112. 		// Reset the screen shot color alpha for text show clearly.
    113. 

  113. 		// 80% black
    114. 

  114. 		paint.setColor(mContext.getResources().getColor(R.color.notification_background_color));
    115. 

  115. 		/* YUNOS END */
    116. 

  116. 		c.drawRect(dstRect, paint);
    117. 

  117. 		c.setBitmap(null);
    118. 

  118. 		bp.recycle();
    119. 

  119. 		bp = ss;
    120. 

  120. 				} else {
    121. 

  121. 		Bitmap ss = Bitmap.createBitmap(dw / SCALE_RATIO, dh / SCALE_RATIO,
    122. 

  122. 				Bitmap.Config.ARGB_8888);
    123. 

  123. 		if (ss == null) {
    124. 

  124. 			return null;
    125. 

  125. 		}
    126. 

  126. 		Canvas c = new Canvas(ss);
    127. 

  127. 		c.clipRect(0, frame.top / SCALE_RATIO, dw / SCALE_RATIO, dh / SCALE_RATIO);
    128. 

  128. 		if (mNavSize > 0) {
    129. 

  129. 			c.clipRect(0, 0, dw / SCALE_RATIO, (dh - mNavSize) / SCALE_RATIO);
    130. 

  130. 		}
    131. 

  131. 		// c.drawBitmap(bp, 0, 0, null);
    132. 

  132. 		Rect dstRect = new Rect(0, 0, ss.getWidth(), ss.getHeight());
    133. 

  133. 		c.drawBitmap(bp, new Rect(0, 0, bp.getWidth(), bp.getHeight()), dstRect, null);
    134. 

  134. 		Paint paint = new Paint();
    135. 

  135. 		// Reset the screen shot color alpha for text show clearly.
    136. 

  136. 		// 80% black
    137. 

  137. 		paint.setColor(mContext.getResources().getColor(R.color.notification_background_color));
    138. 

  138. 		c.drawRect(dstRect, paint);
    139. 

  139. 		c.setBitmap(null);
    140. 

    141. 

  141. 		bp.recycle();
    142. 

  142. 		bp = ss;
    143. 

  143. 	}
    144. 

    145. 

  145. 	// Invoke jni with thread safe
    146. 

  146. 	bp = FrostedGlassUtil.getInstance().convertToBlur(bp, 20);
    147. 

  147. 	return bp;
    148. 

  148. }
    149. 

  149. //zhangle add end
    150.
FrostedGlassUtil.getInstance().convertToBlur(bp, 20) is where JNI is called.
FrostedGlassUtil.java:
    

    2. 

  2. package com.android.systemui.utils;
    3. 

    4. 

  4. import android.graphics.Bitmap;
    5. 

    6. 

  6. public class FrostedGlassUtil {
    7. 

  7.     private volatile static FrostedGlassUtil mFrostedGlassUtil;
    8. 

  8.     /*YUNOS BEGIN*/
    9. 

  9.     //##module(SystemUI)
    10. 

  10.     //##date:2013/3/29 ##author:sunchen.sc@alibaba-inc.com##BugID:104943
    11. 

  11.     //Invoke jni with thread safe
    12. 

  12.     public static FrostedGlassUtil getInstance() {
    13. 

  13.         if (mFrostedGlassUtil == null) {
    14. 

  14.             synchronized (FrostedGlassUtil.class) {
    15. 

  15.                 if (mFrostedGlassUtil == null) {
    16. 

  16.                     mFrostedGlassUtil = new FrostedGlassUtil();
    17. 

  17.                 }
    18. 

  18.             }
    19. 

  19.         }
    20. 

  20.         return mFrostedGlassUtil;
    21. 

  21.     }
    22. 

  22.     /*YUNOS END*/
    23. 

    24. 

  24.     public native void clearColor(Bitmap image, int color);
    25. 

    26. 

  26.     public native void imageBlur(Bitmap srcBitmap, Bitmap dstBitmap);
    27. 

    28. 

  28.     public native void boxBlur(Bitmap srcBitmap, int radius);
    29. 

    30. 

  30.     public native void stackBlur(Bitmap srcBitmap, int radius);
    31. 

    32. 

  32.     public native void oilPaint(Bitmap srcBitmap, int radius);
    33. 

    34. 

  34.     public native void colorWaterPaint(Bitmap srcBitmap, int radius);
    35. 

  35.     /*YUNOS BEGIN*/
    36. 

  36.     //##module(SystemUI)
    37. 

  37.     //##date:2013/3/29 ##author:sunchen.sc@alibaba-inc.com##BugID:104943
    38. 

  38.     //Invoke jni with thread safe
    39. 

  39.     public synchronized Bitmap convertToBlur(Bitmap bmp, int radius) {
    40. 

  40.         long beginBlur = System.currentTimeMillis();
    41. 

  41.         stackBlur(bmp, radius);
    42. 

  42.         return bmp;
    43. 

  43.     }
    44. 

    45. 

  45.     static {
    46. 

  46.         // load frosted glass lib
    47. 

  47.         System.loadLibrary("frostedGlass");
    48. 

  48.     }
    49. 

  49.     /*YUNOS END*/
    50. 

  50. }
    51.
Here is a list of the classes used under JNI.

In order to be able to associate the generated so library with the System UI at compilation time, the following two lines need to be added to Android.mk of the System UI, where libfrostedGlass is the name of the so library configured in Android.mk in the JNI directory above. After compiling jni, a libfrostedGlass.so library will be generated.
LOCAL_JNI_SHARED_LIBRARIES := libfrostedGlass
LOCAL_REQUIRED_MODULES := libfrostedGlass
The purpose of the above two lines is that the compiler can copy the generated libfrostedGlass.so to System/System UI/lib/arm64/.
The source code for the above jni file is listed below.
Android.mk
    

  1. LOCAL_PATH := $(call my-dir)
    2. 

    3. 

  3. include $(CLEAR_VARS)
    4. 

    5. 

  5. LOCAL_MODULE    := libfrostedGlass
    6. 

  6. LOCAL_SRC_FILES := frostedGlass.c bitmapPort.c imageProcess.c
    7. 

  7. #LOCAL_LDLIBS    := -llog -ljnigraphics
    8. 

  8. LOCAL_SHARED_LIBRARIES += \
    9. 

  9. liblog libjnigraphics
    10. 

    11. 

  11. include $(BUILD_SHARED_LIBRARY)
    12.
See the attachment for the source code of other jni implementations. Click Open Link



















Posted by Jenski on Wed, 27 Mar 2019 22:39:32 -0700

Hot Keywords

©2025 Programmer Group