【0196】Android 性能优化--Service优化

1.基本知识

service：后台服务，专门用来处理常驻后台的工作的组件

即时通讯：service来做常驻后台的心跳传输。

使用服务注意点：核心服务尽可能地轻！！！如果服务的任务量过重，则容易出现bug。

很多人喜欢把所有的后台操作都集中在一个service里面，这是不好的习惯。应该为核心服务专门做一个进程，跟其他的所有后台操作隔离。

2.进程的优先级

进程的重要性优先级：（越往后的就越容易被系统杀死）

1.前台进程；Foreground process

• 1）用户正在交互的Activity（onResume（））
• 2）当某个Service绑定正在交互的Activity。
• 3）被主动调用为前台Service（startForeground()）
• 4）组件正在执行生命周期的回调（onCreate()/onStart()/onDestroy()）
• 5）BroadcastReceiver 正在执行onReceive();

2.可见进程；Visible process

• 1)我们的Activity处在onPause()（没有进入onStop()）
• 2)绑定到前台Activity的Service。

3.服务进程；Service process

• 简单的startService()启动。

4.后台进程；Background process

• 对用户没有直接影响的进程----Activity出于onStop()的时候。

          android:process=":xxx"
5.空进程； Empty process

• 不含有任何的活动的组件。（android设计的，为了第二次启动更快，采取的一个权衡）

3.建立一像素锁屏保留进程

qq使用一像素Activity，在锁屏的启动该一像素acitivity，被锁屏界面覆盖在下面。当屏幕解锁的时候自动杀死该Activity，得到保留该app的进程不被杀死。

需要配合Service，
【KeepLiveActivity.java】保留一个像素的Acitivity

public class KeepLiveActivity extends Activity {

    private static final String TAG = "ricky";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
//        setContentView(R.layout.activity_main);
        Log.i(TAG, "KeepLiveActivity----onCreate!!!");
        
        Window window = getWindow();
        window.setGravity(Gravity.LEFT|Gravity.TOP);
        LayoutParams params = window.getAttributes();
        params.height = 1;
        params.width = 1;
        params.x = 0;
        params.y = 0;
        
        window.setAttributes(params);
        
        KeepLiveActivityManager.getInstance(this).setKeepLiveActivity(this);
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        Log.i(TAG, "KeepLiveActivity----onDestroy!!!");
    }
    
}

 

【ScreenListener】锁屏监听，系统在锁屏/解锁屏幕的时候会发出广播，listener用于监听广播，通过接口将监听的状态回传给Service

public class ScreenListener {
    private Context mContext;
    private ScreenBroadcastReceiver mScreenReceiver;
    private ScreenStateListener mScreenStateListener;

    public ScreenListener(Context context) {
        mContext = context;
        mScreenReceiver = new ScreenBroadcastReceiver();
    }

    /**
     * screen状态广播接收者
     */
    private class ScreenBroadcastReceiver extends BroadcastReceiver {
        private String action = null;
        @Override
        public void onReceive(Context context, Intent intent) {
            action = intent.getAction();
            if (Intent.ACTION_SCREEN_ON.equals(action)) { // 开屏
                mScreenStateListener.onScreenOn();
            } else if (Intent.ACTION_SCREEN_OFF.equals(action)) { // 锁屏
                mScreenStateListener.onScreenOff();
            } else if (Intent.ACTION_USER_PRESENT.equals(action)) { // 解锁
                mScreenStateListener.onUserPresent();
            }
        }
    }

    /**
     * 开始监听screen状态
     * 
     * @param listener
     */
    public void begin(ScreenStateListener listener) {
        mScreenStateListener = listener;
        registerListener();
        getScreenState();
    }

    /**
     * 获取screen状态
     */
    private void getScreenState() {
        PowerManager manager = (PowerManager) mContext
                .getSystemService(Context.POWER_SERVICE);
        if (manager.isScreenOn()) {
            if (mScreenStateListener != null) {
                mScreenStateListener.onScreenOn();
            }
        } else {
            if (mScreenStateListener != null) {
                mScreenStateListener.onScreenOff();
            }
        }
    }

    /**
     * 停止screen状态监听
     */
    public void unregisterListener() {
        mContext.unregisterReceiver(mScreenReceiver);
    }

    /**
     * 启动screen状态广播接收器
     */
    private void registerListener() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_USER_PRESENT);
        mContext.registerReceiver(mScreenReceiver, filter);
    }

    public interface ScreenStateListener {// 返回给调用者屏幕状态信息
        public void onScreenOn();

        public void onScreenOff();

        public void onUserPresent();
    }
}

【Service】使用服务运行在后台，对屏幕的响应进行动作的响应，其中使用了KeepLiveActivityManager

public class ScreenService extends Service {

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    
    @Override
    public void onCreate() {
        super.onCreate();
        ScreenListener listener = new ScreenListener(this);
        listener.begin(new ScreenStateListener() {
            
            @Override
            public void onUserPresent() {    
            }
            
            @Override
            public void onScreenOn() {
                // 开屏---finish这个一个像素的Activity
                KeepLiveActivityManager.getInstance(ScreenService.this).finishKeepLiveActivity();
            }
            
            @Override
            public void onScreenOff() {
                // 锁屏---启动一个像素的Activity
//                startActivity(intent);
                KeepLiveActivityManager.getInstance(ScreenService.this).startKeepLiveActivity();
            }
        });
    }
}

【KeepLiveActivityManager.工具类】主要对一像素Acitivity的begin和finish

public class KeepLiveActivityManager {
    private static KeepLiveActivityManager instance;
    private Context context;
    private WeakReference<Activity> activityInstance;

    public static KeepLiveActivityManager getInstance(Context context) {
        if(instance==null){
            instance = new KeepLiveActivityManager(context.getApplicationContext());
        }
        return instance;
    }
    
    private KeepLiveActivityManager(Context context) {
        this.context = context;
    }
    
    public void setKeepLiveActivity(Activity activity){
        activityInstance = new WeakReference<Activity>(activity);
    }

    public void startKeepLiveActivity() {
        Intent intent = new  Intent(context, KeepLiveActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }
    public void finishKeepLiveActivity() {
        if(activityInstance!=null&&activityInstance.get()!=null){
            Activity activity = activityInstance.get();
            activity.finish();
        }
    }

}

【MainAcitivity】 开启服务，点击按钮之后跳转到一像素的Activity

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Intent intent = new Intent(this, ScreenService.class);
        startService(intent);
    }
    
    public void jump(View v){
        Intent intent = new Intent(this, KeepLiveActivity.class);
        startActivity(intent);
        finish();
    }
}

在跳转之后可以操作锁屏键，看到一像素Activity的运行，在锁屏时，KeepLiveActivity 的onCreate方法会被调用，在解锁屏幕的时候，KeepLiveActivity 的onDestory方法会被调用。说明该进程确实被锁屏时保留了。

 3.双进程守护

一像素Activity能够正常工作的前提是Service的能够在后台保留，如果系统将Service杀死（通过手机设置中对进程的管理同样可以杀死进程），则通过一像素Activity保留app进程会失效，因此使用双进程守护。