首页 > 系统相关 >Service保活 双进程

Service保活 双进程

时间：2023-04-14 16:33:50浏览次数：45  
标签：Service 保活 public StepService Intent 进程 new class

本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net

写在前头

保活Service我们需要做什么：

1.在应用被关闭后保活（最难）

2.在内用占用过大，系统自动释放内存时保活（优先杀死占用较高的Service）

3.重启手机后自动开启Service

4.手机息屏后不被释放内存

5.手动清理内存时保活

首先介绍一下Service的等级：

一、前台进程
二、可见进程
三、服务进程
四、后台进程
五、空进程  ---关闭应用后，没有清理缓存

所以为了提高优先级我们可以使用startForeground（）方法将Service设置为前台进程。

一、在AndroidManifest中添加Service



1.  <service android:
2.              android:process="istep.service"  //放入新进程
3.              >
4.              <intent-filter android:priority="1000">
5.                  <!-- 系统启动完成后会调用-->
6.                  <action android:/>
7.                  <action android:/>
8.                  <action android: />
9.                  <action android: />
10.                  <action android: />
11.                  <action android: />
12.                  <action android: />
13.              </intent-filter>
14.  </service>

17.  <service android:
18.              android:process=":GuardService">
19.              <intent-filter >
20.                  <!-- 系统启动完成后会调用-->
21.                  <action android:/>
22.                  <action android:/>
23.                  <action android: />
24.                  <action android: />
25.                  <action android: />
26.                  <action android: />
27.                  <action android: />
28.              </intent-filter>
29.          </service>

二、双进程保护

1.创建aidl实现跨进程通信（新建一个aidl）



1.  interface ProcessConnection {
2.      /**
3.       * Demonstrates some basic types that you can use as parameters
4.       * and return values in AIDL.
5.       */
6.      //删除不必要方法
7.   }

2.创建主服务

`

1.  /**
2.   * 主进程 双进程通讯
3.   * Created by db on 2018/1/11.
4.   */

6.  public class StepService extends Service{
7.      @Nullable
8.      @Override
9.      public IBinder onBind(Intent intent) {
10.          return new ProcessConnection.Stub() {};
11.      }

13.      @Override
14.      public int onStartCommand(Intent intent, int flags, int startId) {
15.          startForeground(1,new Notification());
16.          //绑定建立链接
17.          bindService(new Intent(this,GuardService.class),
18.                  mServiceConnection, Context.BIND_IMPORTANT);
19.          return START_STICKY;
20.      }

22.      private ServiceConnection mServiceConnection = new ServiceConnection() {
23.          @Override
24.          public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
25.              //链接上
26.              Log.d("test","StepService:建立链接");
27.          }

29.          @Override
30.          public void onServiceDisconnected(ComponentName componentName) {
31.              //断开链接
32.              startService(new Intent(StepService.this,GuardService.class));
33.              //重新绑定
34.              bindService(new Intent(StepService.this,GuardService.class),
35.                      mServiceConnection, Context.BIND_IMPORTANT);
36.          }
37.      };

39.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

3.创建守护服务

 `1.   /**
2.   * 守护进程 双进程通讯
3.   * Created by db on 2018/1/11.
4.   */

6.  public class GuardService extends Service{
7.      @Nullable
8.      @Override
9.      public IBinder onBind(Intent intent) {
10.          return new ProcessConnection.Stub() {};
11.      }

13.      @Override
14.      public int onStartCommand(Intent intent, int flags, int startId) {
15.          startForeground(1,new Notification());
16.          //绑定建立链接
17.          bindService(new Intent(this,StepService.class),
18.                  mServiceConnection, Context.BIND_IMPORTANT);
19.          return START_STICKY;
20.      }

22.      private ServiceConnection mServiceConnection = new ServiceConnection() {
23.          @Override
24.          public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
25.              //链接上
26.              Log.d("test","GuardService:建立链接");
27.          }

29.          @Override
30.          public void onServiceDisconnected(ComponentName componentName) {
31.              //断开链接
32.              startService(new Intent(GuardService.this,StepService.class));
33.              //重新绑定
34.              bindService(new Intent(GuardService.this,StepService.class),
35.                      mServiceConnection, Context.BIND_IMPORTANT);
36.          }
37.      };

39.  }` ![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

返回参数含义：

  • START_STICKY：在Service被关闭后,重新开启Service
  • START_NOT_STICKY：服务被异常杀掉后，系统将会被设置为started状态，系统不会重启该服务，直到startService(Intent intent)方法再次被调用。
  • START_REDELIVER_INTENT：重传Intent，使用这个返回值时，如果在执行完onStartCommand后，服务被异常kill掉，系统会自动重启该服务,并将Intent的值传入。
  • START_STICKY_COMPATIBILITY：START_STICKY的兼容版本，但不保证服务被kill后一定能重启。

三、使用JobService来实现应用退出后重启Service

1、在AndroidManifest中添加Service和权限



1.  <service android:
2.      android:permission="android.permission.BIND_JOB_SERVICE" >
3.  </service>

2、JobService代码

`

1.  /**
2.   * 用于判断Service是否被杀死
3.   * Created by db on 2018/1/11.
4.   */
5.  @TargetApi(Build.VERSION_CODES.LOLLIPOP)//5.0以后可用
6.  public class JobWakeUpService extends JobService{
7.      private int JobWakeUpId = 1;
8.      @Override
9.      public int onStartCommand(Intent intent, int flags, int startId) {
10.          //开启轮寻
11.          JobInfo.Builder mJobBulider = new JobInfo.Builder(
12.                  JobWakeUpId,new ComponentName(this,JobWakeUpService.class));
13.          //设置轮寻时间
14.          mJobBulider.setPeriodic(2000);
15.          JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
16.          mJobScheduler.schedule(mJobBulider.build());
17.          return START_STICKY;
18.      }

20.      @Override
21.      public boolean onStartJob(JobParameters jobParameters) {
22.          //开启定时任务 定时轮寻 判断应用Service是否被杀死
23.          //如果被杀死则重启Service
24.          boolean messageServiceAlive = serviceAlive(StepService.class.getName());
25.          if(!messageServiceAlive){
26.              startService(new Intent(this,StepService.class));
27.          }

29.          return false;
30.      }

32.      @Override
33.      public boolean onStopJob(JobParameters jobParameters) {

35.          return false;
36.      }

38.      /**
39.       * 判断某个服务是否正在运行的方法
40.       * @param serviceName
41.       *            是包名+服务的类名（例如：net.loonggg.testbackstage.TestService）
42.       * @return true代表正在运行，false代表服务没有正在运行
43.       */
44.      private boolean serviceAlive(String serviceName) {
45.          boolean isWork = false;
46.          ActivityManager myAM = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
47.          List<ActivityManager.RunningServiceInfo> myList = myAM.getRunningServices(100);
48.          if (myList.size() <= 0) {
49.              return false;
50.          }
51.          for (int i = 0; i < myList.size(); i++) {
52.              String mName = myList.get(i).service.getClassName().toString();
53.              if (mName.equals(serviceName)) {
54.                  isWork = true;
55.                  break;
56.              }
57.          }
58.          return isWork;
59.      }
60.  }

`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

四、保证Service在开机后自动启动

（1）注册广播

 1.    <receiver android:>
2.              <intent-filter>
3.                  <action android:/>
4.              </intent-filter>
5.    </receiver>

（2）广播代码



1.  /**
2.   * 开机完成广播
3.   */

5.  public class mReceiver extends BroadcastReceiver {
6.      @Override
7.      public void onReceive(Context context, Intent intent){
8.          Intent mIntent = new Intent(context,StepService.class);
9.          context.startService(mIntent);
10.      }
11.  }

五、保证息屏后不被释放资源杀死（WakeLock的使用）

（1）添加权限

 <uses-permission android: />

（2）在创建Service以后调用方法

 `1.     /**
2.       * 同步方法   得到休眠锁
3.       * @param context
4.       * @return
5.       */
6.      synchronized private void getLock(Context context){
7.          if(mWakeLock==null){
8.              PowerManager mgr=(PowerManager)context.getSystemService(Context.POWER_SERVICE);
9.              mWakeLock=mgr.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,StepService.class.getName());
10.              mWakeLock.setReferenceCounted(true);
11.              Calendar c=Calendar.getInstance();
12.              c.setTimeInMillis((System.currentTimeMillis()));
13.              int hour =c.get(Calendar.HOUR_OF_DAY);
14.              if(hour>=23||hour<=6){
15.                  mWakeLock.acquire(5000);
16.              }else{
17.                  mWakeLock.acquire(300000);
18.              }
19.          }
20.          Log.v(TAG,"get lock");
21.      }`![](https://csdnimg.cn/release/blogv2/dist/pc/img/newCodeMoreWhite.png)

（3）在onDestroy()方法中调用释放锁的方法（避免占用内存）



1.  synchronized private void releaseLock()
2.      {
3.          if(mWakeLock!=null){
4.              if(mWakeLock.isHeld()) {
5.                  mWakeLock.release();
6.                  Log.v(TAG,"release lock");
7.              }

9.              mWakeLock=null;
10.          }
11.      }
PARTIAL_WAKE_LOCK保持CPU运转，屏幕和键盘灯有可能是关闭的。
SCREEN_DIM_WAKE_LOCK保持CPU运转，允许保持屏幕显示但有可能是灰的，允许关闭键盘灯。
SCREEN_BRIGHT_WAKE_LOCK保持CPU运转，保持屏幕高亮显示，允许关闭键盘灯。
FULL_WAKE_LOCK保持CPU运转，保持屏幕高亮显示，键盘灯也保持亮度。
ACQUIRE_CAUSES_WAKEUP不会唤醒设备，强制屏幕马上高亮显示，键盘灯开启。有一个例外，如果有notification弹出的话，会唤醒设备。
ON_AFTER_RELEASEWake Lock被释放后，维持屏幕亮度一小段时间，减少Wake Lock循环时的闪烁情况。

六、启动所有Service（在Activity中）

 1.     /**
2.       * 开启所有Service
3.       */
4.      private void startAllServices()
5.      {
6.          startService(new Intent(this, StepService.class));
7.          startService(new Intent(this, GuardService.class));
8.          if(Build.VERSION.SDK_INT >=Build.VERSION_CODES.LOLLIPOP) {
9.              Log.d(TAG, "startAllServices: ");
10.              //版本必须大于5.0
11.              startService(new Intent(this, JobWakeUpService.class));
12.          }
13.      }

注意：该方法不能保证在所有机型上有效，而且除非在必要时，否则不建议写这样的流氓软件。特别是谷歌在android7.0以后对管理加强，想要保活Service其实已经变得不太可能了，谷歌这样做无疑是为了减少流氓软件的数量，这样做也是可取的。

标签：Service,保活,public,StepService,Intent,进程,new,class
From： https://www.cnblogs.com/cps666/p/17318696.html

相关文章

  • Linux内核进程管理并发同步与原子操作
    并发同步并发是指在某一时间段内能够处理多个任务的能力，而并行是指同一时间能够处理多个任务的能力。并发和并行看起来很像，但实际上是有区别的，如下图（图片来源于网络）：上图的意思是，有两条在排队买咖啡的队列，并且只有一架咖啡机在处理，而并行就有两架的咖啡机在处理。咖啡机的数量......
  • Linux内核进程管理进程优先级
    **前言：**进程优先级实际上是系统对进程重要性的一个客观评价。根据这个评价的结果来为进程分配不同的系统资源，这个资源包括内存资源和CPU资源。为了保证“公平公正”的评价每个进程，Google工程师为此设计了一套评价系统。为什么要有进程优先级？这似乎不用过多的解释，毕竟自从多任......
  • Linux内核进程管理六种状态
    进程概念1）正在执行的程序2）正在计算机上执行的程序实例3）能分配处理器并由处理器执行的实体进程的两个基本元素是程序代码和代码相关联的数据集。Linux是一个多用户，多任务的系统，可以同时运行多个用户的多个程序，就必然会产生很多的进程，而每个进程会有不同的状态。这就可以引入‘进......
  • Linux内核进程管理实时调度与SMP
    一，实时调度器类实时调度类有两类进程：循环进程SCHED_RR：循环进程有时间片，随着进程的运行时间会减少。当时间片用完时又将其置为初值，并将进程置于队列末尾。先进先出SCHED_FIFO：没有时间片调度，运行后可执行任意长时间直到自己放弃CPU。实际上两类进程在相同优先级队列上都是先进先出......
  • Linux内核进程管理原理详解(代码演示)
    **前言：**Linux内核里大部分都是C语言。建议先看《Linux内核设计与实现(LinuxKernelDevelopment)》,RobertLove，也就是LKD。Linux是一种动态系统，能够适应不断变化的计算需求。Linux计算需求的表现是以进程的通用抽象为中心的。进程可以是短期的（从命令行执行的一个命令），也可以是......
  • Service Mesh是什么，为我们解决了什么问题？
    1、ServiceMesh介绍ServiceMesh翻译为“服务网格”，作为服务间通信的基础设施层。轻量级高性能网络代理，提供安全的、快速的、可靠地服务间通讯，与实际应用部署一起，但对应用透明。应用作为服务的发起方，只需要用最简单的方式将请求发送给本地的服务网格代理，然后网格代理会进行后续的......
  • Service Mesh框架选型对比分析：Linkerd、Envoy、Istio、Conduit
    当前，业界主要有以下主要几种ServiceMesh框架，下面进行详细的说明及对比。1、LinkerdLinkerd是Buoyant公司2016年率先开源的高性能网络代理，是业界的第一款ServiceMesh框架。其主要用于解决分布式环境中服务之间通信面临的一些问题，如网络不可靠、不安全、延迟丢包等问题。Linkerd使......
  • Service进阶
    上节我们学习了Service的生命周期，以及两种启动Service的两种方法，本节继续来深入了解Service中的IntentService，Service的使用实例：前台服务与轮询的实现!1.IntentService的使用在上一节后我们已经知道了如何去定义和启动Service，但是如果我们直接把耗时线程放到Service中的onStart()方......
  • 查看linux进程/线程跑在哪个cpu核上
    方法一：使用top-Hppid然后按f，选择p,然后esc就行了方法二： psH-opid,lwp,psr,comm -p11115psr对应系统cpu线程号......
  • 进程
    进程进程控制块PCB任何进程在运行时都会有一个进程信息;可以使用psaux查看部分信息。task_struct进程idC语言中用pid_t类型表示进程状态：运行、停止、僵尸等进程切换时保存和恢复的一些CPU寄存器控制中断当前工作目录umask掩码文件描述符表，包含指向很对file结构体的......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99