Android中高级进阶

关于Service总结知识

2019-03-27  本文已影响2人  Sincerity_

StartService

intent = new Intent(this, MyService.class);
        startService(intent); //开启
@Override
    protected void onDestroy() {
        super.onDestroy();
        stopService(intent); //停止
    }

BindService

connection=new MyServiceConnection();
bindService(intent, connection, Service.BIND_AUTO_CREATE);
 private class MyServiceConnection implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {

        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    }
 @Override
    protected void onDestroy() {
        super.onDestroy();
      if(connection!=null);
        unbindService(connection);
    }

一般进程保活套路

  当前业界的Android进程保活手段主要分为** 黑、白、灰 **三种，其大致的实现思路如下：

进程划分(重要性从高到底)

前台进程

  正在使用的程序,一般系统不会杀死,除非用户强制停止或者系统内存不足等极端情况下会杀死

  1. 某个进程持有正在与用户交互的Activity并且该Activity正处于resume状态
  2. 某个进程持有一个Service,并且该Service正在与用户交互的Activity绑定
  3. 某个进程持有一个Service,并且该Service调用setForeground方法使自己位于前台
  4. 某个进程持有一个Service,并且该Service正在执行它的某个生命周期回调方法
  5. 某个进程持有一个broadcastReceiver,并且broadcastreceiver正在执行onReceiver方法
可见进程

用户正在使用,看得到,没有覆盖到整个屏幕,只有屏幕的一部分可见进程不包含任何前台进程,一般系统也是不会杀死

  1. 拥有不在前台,但仍对用户可见的Activity(一调用onPause)
  2. 拥有绑定到可见Activity的Service
服务进程
  1. 某个进程中运行着一个Service且改Service是通过StartService启动,与用户看见的界面没有直接关联
后台进程
  1. 用户按了"back"或者"Home"后,程序本身看不到了,但是其实还在运行的程序,不如Activity调用了Onpause方法
空进程
  1. 某个进程不包含任何活跃的组件时,该进程就会被设置为空进程,完全没用,杀了他只有好处没有坏处

进程保活方法

1. 开启一个1像素的Activity (前台进程保活)

//二个Activity
/****MainActivity**/
 LiveService.toLiveService(this); //开启一个service
/***********ServiceActivity*********/
public class ServiceActivity extends Activity {
  //打开自己的方法
    public static void actionStartActivity(Context context) {
        Intent intent = new Intent(context, ServiceActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(intent);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service);
        Window window = getWindow();
        window.setGravity(Gravity.START | Gravity.TOP);
        WindowManager.LayoutParams params = window.getAttributes();
        params.height = 1;//设置当前的Activity为1像素
        params.width = 1;
        params.x = 0;//位置在左上角
        params.y = 0;
        window.setAttributes(params);
      //注册当前Activity用来开启或者关闭当前页面
        ScreenManager.getDefault(this).setActivity(this);
    }
}


//LiveService页面
public class LiveService extends Service {
  //开启service
    public static void toLiveService(Context context) {
        Intent intent = new Intent(context, LiveService.class);
        context.startService(intent);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        final ScreenManager aDefault = ScreenManager.getDefault(this);
      //注册广播监听锁屏或者解锁
        ScreenBroadcastListener listener = new ScreenBroadcastListener(this);
        listener.setListener(new ScreenBroadcastListener.BroadcastListener() {
            @Override
            public void screenOn() {
              //解锁
                aDefault.finshActivity();
            }

            @Override
            public void screenOff() {
              //锁屏
                aDefault.startActivity();
            }
        });
        return START_REDELIVER_INTENT;
    }
}


//开启广播页面
public class ScreenBroadcastListener {
    private BroadcastListener listener;
    private Context mContext;
    private ScreenBroadcastReceiver broadcastReceiver;

    public ScreenBroadcastListener(Context mContext) {
        this.mContext = mContext;
        broadcastReceiver = new ScreenBroadcastReceiver();
    }

    public void setListener(BroadcastListener listener) {
        this.listener = listener;
        registerListener();
    }

    private void registerListener() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        mContext.registerReceiver(broadcastReceiver, filter);
    }

    public interface BroadcastListener {
        void screenOn();

        void screenOff();
    }

    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)) {
                listener.screenOn();
            } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
                listener.screenOff();
            }
        }
    }
}


//页面管理器
public class ScreenManager {
    private WeakReference<Activity> weakReference; //弱引用
    private Context mContext;
    private static ScreenManager screenManager;

    public static ScreenManager getDefault(Context context) {
        if (screenManager == null) {
            screenManager = new ScreenManager(context.getApplicationContext());
        }
        return screenManager;
    }

    public ScreenManager(Context mContext) {
        this.mContext = mContext;
    }

    public void setActivity(Activity activity) {
        weakReference = new WeakReference<Activity>(activity);
    }

    public void startActivity() {
        ServiceActivity.actionStartActivity(mContext);
    }

    public void finshActivity() {
        if (weakReference != null) {
            Activity activity = weakReference.get();
            if (activity != null)
                activity.finish();
        }
    }
}

//查看当前程序的进程 
adb shell  //进入设备 exit退出
ps|grep 完整包名  //查看当前程序的进程ID

u0_a79     2997    254      835760 83964    ep_poll f1e34bb9 S com.sincerity.interviewdemo
进程用户   进程ID   进程父ID   进程虚拟内存 实际驻留内存              进程名称
 
cat /proc/进程ID/oom_adj  //查看进程的优先级
adj级别 值 解释
UNKNOWN_ADJ 16 预留的最低级别，一般对于缓存的进程才有可能设置成这个级别
CACHED_APP_MAX_ADJ 15 缓存进程，空进程，在内存不足的情况下就会优先被kill
CACHED_APP_MIN_ADJ 9 缓存进程，也就是空进程
SERVICE_B_ADJ 8 不活跃的进程
PREVIOUS_APP_ADJ 7 切换进程
HOME_APP_ADJ 6 与Home交互的进程
SERVICE_ADJ 5 有Service的进程
VY_WEIGHT_APP_ADJ 4 高权重进程
BACKUP_APP_ADJ 3 正在备份的进程
PERCEPTIBLE_APP_ADJ 2 可感知的进程，比如那种播放音乐
VISIBLE_APP_ADJ 1 可见进程
FOREGROUND_APP_ADJ 0 前台进程
PERSISTENT_SERVICE_ADJ -11 重要进程
PERSISTENT_PROC_ADJ -12 核心进程
SYSTEM_ADJ -16 系统进程
NATIVE_ADJ -17 系统起的Native进程

不同设备的adj不同 oom_adj越大，占用物理内存越多会被最先kill掉

2. 前台服务保活(服务保活)

public class KeepLiveService extends Service {
    public static final int NOTIFICATION_ID = 0x11;

    public KeepLiveService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public void onCreate() {
        super.onCreate();
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
            startForeground(NOTIFICATION_ID, new Notification());
        } else {
            Notification.Builder builder = new Notification.Builder(this);
            builder.setSmallIcon(R.mipmap.ic_launcher);
            startForeground(NOTIFICATION_ID, builder.build());
            startService(new Intent(this, InnerService.class));
        }
    }

    public static class InnerService extends Service {

        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }

        @Override
        public void onCreate() {
            super.onCreate();
            Notification.Builder builder = new Notification.Builder(this);
            builder.setSmallIcon(R.mipmap.ic_launcher);
            startForeground(NOTIFICATION_ID, builder.build());
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    stopForeground(true);
                    NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
                    manager.cancel(NOTIFICATION_ID);
                    stopSelf();
                }
            }, 200);
        }
    }
}

3. 相互唤醒

4. josSchudler

public class MyJobService extends JobService {
    @Override
    public void onCreate() {
        super.onCreate();
        startScheduler();
    }

    private void startScheduler() {
        JobInfo.Builder builder = new JobInfo.Builder(1, new ComponentName(getPackageName(), MyJobService.class.getName()));
        builder.setPeriodic(5);
        builder.setPersisted(true);
        JobScheduler scheduler = (JobScheduler) this.getSystemService(Context.JOB_SCHEDULER_SERVICE);
        scheduler.schedule(builder.build());
    }

    @Override
    public boolean onStartJob(JobParameters params) {
        return false;
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        return false;
    }
}

5. 粘性服务和系统捆绑服务

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    return START_REDELIVER_INTENT;
}

6. 双进程守护

总结

上一篇 下一篇

猜你喜欢

热点阅读