Summary of Android App memory optimization picture optimization

 public class ImageButtonClickUtils {
 private ImageButtonClickUtils(){

 }

 /**
   * Set the button's forward and reverse selection effect
   *
   * */
 public static void setClickState(View view, final int normalResId, final int pressResId){
  (new OnTouchListener() {
  @Override
  public boolean onTouch(View v, MotionEvent event) {
   switch(()){
   case MotionEvent.ACTION_DOWN:{
   (pressResId);
   }
   break;
   case MotionEvent.ACTION_MOVE:{
   (pressResId);
   }
   break;
   case MotionEvent.ACTION_UP:{
   (normalResId);
   }
   break;
   default:{

   }
   break;
   }

   // In order not to affect the onClick callback of the listen button, the return value should be false   return false;
  }
  });
 }
}

 ImageButton personalInfoBtn = (ImageButton)findViewById();
 (new OnTouchListener() {
 @SuppressLint("ClickableViewAccessibility")
 @Override
 public boolean onTouch(View v, MotionEvent event) {
  int action = ();

  if(action == MotionEvent.ACTION_DOWN){
  ((ImageButton)v).setColorFilter(getResources().getColor(0X50000000));
  }else if(action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL){
  ((ImageButton)v).clearColorFilter();
  }

  // In order not to affect the onClick callback of the listen button, the return value should be false  return false;
 }
 });

import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;
import ;

import ;

public class RootSurfaceView extends SurfaceView implements , Runnable{
 private float mViewWidth = 0;
 private float mViewHeight = 0;
 private int mResourceId = 0;
 private Context mContext = null;
 private volatile boolean isRunning = false;
 private SurfaceHolder mSurfaceHolder = null;

 public RootSurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
 super(context, attrs, defStyleAttr);
 initRootSurfaceView(context, attrs, defStyleAttr, 0);
 }

 public RootSurfaceView(Context context, AttributeSet attrs) {
 super(context, attrs);
 initRootSurfaceView(context, attrs, 0, 0);
 }

 private void initRootSurfaceView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes){
 mContext = context;
 DisplayMetrics displayMetrics = ().getDisplayMetrics();
 TypedArray a = (attrs, , defStyleAttr, defStyleRes);
 int n = ();
 mViewWidth = ;
 mViewHeight = ;
 for(int index=0; index<n; index++){
  int attr = (index);
  switch(attr){
  case .RootSurfaceView_background:{
  mResourceId = (attr, 0);
  }
  break;
  case .RootSurfaceView_view_width:{
  mViewWidth = (attr, );
  }
  break;
  case .RootSurfaceView_view_height:{
  mViewHeight = (attr, );
  }
  break;
  default:{

  }
  break;
  }
 }
 ();
 mSurfaceHolder = getHolder();
 (this);
 ();
 }

 private Bitmap getDrawBitmap(Context context, float width, float height) {
 Bitmap bitmap = (getResources(), mResourceId);
 Bitmap resultBitmap = zoomImage(bitmap, width, height);
 return resultBitmap;
 }

 @Override
 public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
 ("RootSurfaceView surfaceChanged");
 }

 @Override
 public void surfaceCreated(SurfaceHolder holder) {
 drawBackGround(holder);
 ("RootSurfaceView surfaceCreated");
 }

 @Override
 public void surfaceDestroyed(SurfaceHolder holder) {
 isRunning = false;
 ("RootSurfaceView surfaceDestroyed");
 }

 @Override
 protected void onAttachedToWindow() {
 ();
 ("RootSurfaceView onAttachedToWindow");
 }

 @Override
 protected void onDetachedFromWindow() {
 ();
 ("RootSurfaceView onDetachedFromWindow");
 }

 @Override
 public void run(){ 
 while(isRunning){ 
  synchronized (mSurfaceHolder) { 
  if(!().isValid()){
   continue;
  }
  drawBackGround(mSurfaceHolder);
  }
  isRunning = false;
  break;
 } 
 }

 private void drawBackGround(SurfaceHolder holder) {
 Canvas canvas = ();
 Bitmap bitmap = getDrawBitmap(mContext, mViewWidth, mViewHeight);
 (bitmap, 0, 0, null);
 ();
 (canvas);
 }

 public static Bitmap zoomImage( Bitmap bgimage , float newWidth , float newHeight ) {
 float width = ( );
 float height = ( );
 Matrix matrix = new Matrix();
 float scaleWidth = newWidth/width;
 float scaleHeight = newHeight/height;
 ( scaleWidth, scaleHeight );
 Bitmap bitmap = ( bgimage, 0, 0, ( int ) width , ( int ) height, matrix, true );
 if( bitmap != bgimage ){
  ();
  bgimage = null;
 }
 return bitmap;
 }
}

<declare-styleable name="RootSurfaceView">
 <attr name="background" format="reference" />
 <attr name="view_width" format="dimension" />
 <attr name="view_height" format="dimension" />
</declare-styleable>

<!-- Settings interface -->
<activity
 android:name=".SettingActivity"
 android:hardwareAccelerated="false"
 android:screenOrientation="sensorLandscape"
 android:theme="@style/Translucent_NoTitle">
</activity>

// || Call this method in the constructor that defines the viewsetLayerType(View.LAYER_TYPE_SOFTWARE, null);

/**
  * Free the memory occupied by AnimationDrawable
  *
  *
  * */
@SuppressWarnings("unused")
private void freeAnimationDrawable(AnimationDrawable animationDrawable) {
 (); 
 for (int i = 0; i < (); ++i){
 Drawable frame = (i);
 if (frame instanceof BitmapDrawable) {
  ((BitmapDrawable)frame).getBitmap().recycle();
 } 
 (null);
 } 

 (null);
}

/**
  * Picture dynamic switcher
  *
  * */
public class AnimImageView {
 private static final int MSG_START = 0xf1;
 private static final int MSG_STOP = 0xf2;
 private static final int STATE_STOP = 0xf3;
 private static final int STATE_RUNNING = 0xf4;

 /* Running status*/
 private int mState = STATE_RUNNING;
 private ImageView mImageView;
 /* Image resource ID list*/
 private List<Integer> mResourceIdList = null;
 /* Timed tasks*/
 private Timer mTimer = null;
 private AnimTimerTask mTimeTask = null;
 /* Record playback position*/
 private int mFrameIndex = 0;
 /* Playback format*/
 private boolean isLooping = false;

 public AnimImageView( ){
 mTimer = new Timer();
 }

 /**
  * Set animation playback resources
  *
  * */
 public void setAnimation( HanziImageView imageview, List<Integer> resourceIdList ){
 mImageView = imageview;
 mResourceIdList = resourceIdList;
 }

 /**
  * Start playing animation
  * @param loop playback
  * @param duration Animation playback time interval
  * */
 public void start(boolean loop, int duration){
 stop();
 isLooping = loop;
 mFrameIndex = 0;
 mState = STATE_RUNNING;
 mTimeTask = new AnimTimerTask( );
 (mTimeTask, 0, duration);
 }

 /**
  * Stop animation playback
  *
  * */
 public void stop(){
 if (mTimeTask != null) {
  mFrameIndex = 0;
  mState = STATE_STOP;
  ();
  ();
  mTimeTask = null;
  (0);
 }
 }

 /**
  * Timer task
  *
  *
  */
 class AnimTimerTask extends TimerTask {
 @Override
 public void run() {
  if(mFrameIndex < 0 || mState == STATE_STOP){
  return;
  }

  if( mFrameIndex < () ){
  Message msg = (MSG_START,0,0,null);
  ();
  }else{
  mFrameIndex = 0;
  if(!isLooping){
   Message msg = (MSG_STOP,0,0,null);
   ();
  }
  }
 }
 }

 private Handler AnimHanlder = new Handler(){
  public void handleMessage( msg) {
  switch () {
  case MSG_START:{
   if(mFrameIndex >=0 && mFrameIndex < () && mState == STATE_RUNNING){
   ((mFrameIndex));
   mFrameIndex++;
   }
  }
   break;
  case MSG_STOP:{
   if (mTimeTask != null) {
   mFrameIndex = 0;
   ();
   ();
   mState = STATE_STOP;
   mTimeTask = null;
   (0);
   }
  }
   break;
  default:
   break;
  }
  }
 };
}

<!--Never do it in the subjectActivitySet the default background

<style name="Activity_Style" parent="@android:">
<item name="android:background">@drawable/*</item>
</style>