上海天局信息技术有限责任公司

网站首页 > 天局论坛 > Android > App

android service 教你打造不被杀死的service-------service进程守护

2017-12-08 14:14:24 上海天局信息技术有限责任公司 已读

简介


相信做android的兄弟们经常会提出这样的要求,我们能不能让我们的程序在后台运行且不停的采集数据,我们给我的答案是能-------service可以做到这样的事,那我们能不能让我们后台运行的程序不要轻易被系统回收呢?----------这个有点难:下面我就正对如何不被系统回收提高service优先级来聊一聊。

方案

方案一:将service设置为前台service,这样的做会在前端弹出一个notification切是一直存在。具体实现在service中加上如下代码:


[java] view plain copy
  1.           

  2.            <span style="font-size:14px;">Notification notification = new Notification(R.drawable.ic_lancher, "上传数据", System.currentTimeMillis());  

  3.         Intent notificationIntent = new Intent(this, MainActivity.class);  

  4.         PendingIntent pendingIntent = PendingIntent.getActivity(this0, notificationIntent, 0);  

  5.              notification.setLatestEventInfo(this"前端service""前端service", pendingIntent);  

  6.              startForeground(1, notification);</span>  


方法二:提高service的优先级,在AndroidManifest中设置android:priority="1000".

方法三:将应用做成系统应用,(这方法基本呵呵了),

上面的一和二当系统内存不足时还是会被系统回收,且在服务中手动杀掉服务就不会在自动启动,那可不可做到服务杀不掉呢?当然可以,双服务进程相互监听守护,教打造不被杀死的后台服务,通过aidl实现进程间的通信:

首先我们先看看效果图:

图片关键词


Service1


[java] view plain copy
  1. package com.lzg.strongservice.service;  

  2.   

  3. import android.app.Service;  

  4. import android.content.Intent;  

  5. import android.os.Handler;  

  6. import android.os.IBinder;  

  7. import android.os.Message;  

  8. import android.os.RemoteException;  

  9. import android.widget.Toast;  

  10.   

  11. import com.lzg.strongservice.utils.Utils;  

  12.   

  13. /** 

  14.  *  

  15.  * @author henry 

  16.  * 

  17.  */  

  18. public class Service1 extends Service {  

  19.     private Handler handler = new Handler() {  

  20.         public void handleMessage(android.os.Message msg) {  

  21.             switch (msg.what) {  

  22.             case 1:  

  23.                 startService2();  

  24.                 break;  

  25.   

  26.             default:  

  27.                 break;  

  28.             }  

  29.   

  30.         };  

  31.     };  

  32.   

  33.     /** 

  34.      * 使用aidl 启动Service2 

  35.      */  

  36.     private StrongService startS2 = new StrongService.Stub() {  

  37.         @Override  

  38.         public void stopService() throws RemoteException {  

  39.             Intent i = new Intent(getBaseContext(), Service2.class);  

  40.             getBaseContext().stopService(i);  

  41.         }  

  42.   

  43.         @Override  

  44.         public void startService() throws RemoteException {  

  45.             Intent i = new Intent(getBaseContext(), Service2.class);  

  46.             getBaseContext().startService(i);  

  47.         }  

  48.     };  

  49.   

  50.     /** 

  51.      * 在内存紧张的时候,系统回收内存时,会回调OnTrimMemory, 重写onTrimMemory当系统清理内存时从新启动Service2 

  52.      */  

  53.     @Override  

  54.     public void onTrimMemory(int level) {  

  55.         /* 

  56.          * 启动service2 

  57.          */  

  58.         startService2();  

  59.   

  60.     }  

  61.   

  62.     @Override  

  63.     public void onCreate() {  

  64.         Toast.makeText(Service1.this"Service1 正在启动...", Toast.LENGTH_SHORT)  

  65.                 .show();  

  66.         startService2();  

  67.         /* 

  68.          * 此线程用监听Service2的状态 

  69.          */  

  70.         new Thread() {  

  71.             public void run() {  

  72.                 while (true) {  

  73.                     boolean isRun = Utils.isServiceWork(Service1.this,  

  74.                             "com.lzg.strongservice.service.Service2");  

  75.                     if (!isRun) {  

  76.                         Message msg = Message.obtain();  

  77.                         msg.what = 1;  

  78.                         handler.sendMessage(msg);  

  79.                     }  

  80.                     try {  

  81.                         Thread.sleep(1);  

  82.                     } catch (InterruptedException e) {  

  83.                         // TODO Auto-generated catch block  

  84.                         e.printStackTrace();  

  85.                     }  

  86.                 }  

  87.             };  

  88.         }.start();  

  89.     }  

  90.   

  91.     /** 

  92.      * 判断Service2是否还在运行,如果不是则启动Service2 

  93.      */  

  94.     private void startService2() {  

  95.         boolean isRun = Utils.isServiceWork(Service1.this,  

  96.                 "com.lzg.strongservice.service.Service2");  

  97.         if (isRun == false) {  

  98.             try {  

  99.                 startS2.startService();  

  100.             } catch (RemoteException e) {  

  101.                 e.printStackTrace();  

  102.             }  

  103.         }  

  104.     }  

  105.   

  106.     @Override  

  107.     public int onStartCommand(Intent intent, int flags, int startId) {  

  108.         return START_STICKY;  

  109.     }  

  110.   

  111.     @Override  

  112.     public IBinder onBind(Intent intent) {  

  113.         return (IBinder) startS2;  

  114.     }  

  115. }  


Service2:



[java] view plain copy
  1. <strong><span style="font-size:14px;">package com.lzg.strongservice.service;  

  2.   

  3. import android.annotation.SuppressLint;  

  4. import android.app.Service;  

  5. import android.content.Intent;  

  6. import android.os.Handler;  

  7. import android.os.IBinder;  

  8. import android.os.Message;  

  9. import android.os.RemoteException;  

  10. import android.widget.Toast;  

  11.   

  12. import com.lzg.strongservice.utils.Utils;  

  13.   

  14. /** 

  15.  *  

  16.  * @author henry 

  17.  * 

  18.  */  

  19. public class Service2 extends Service {  

  20.   

  21.     private Handler handler = new Handler() {  

  22.         public void handleMessage(android.os.Message msg) {  

  23.             switch (msg.what) {  

  24.             case 1:  

  25.                 startService1();  

  26.                 break;  

  27.   

  28.             default:  

  29.                 break;  

  30.             }  

  31.   

  32.         };  

  33.     };  

  34.   

  35.     /** 

  36.      * 使用aidl 启动Service1 

  37.      */  

  38.     private StrongService startS1 = new StrongService.Stub() {  

  39.   

  40.         @Override  

  41.         public void stopService() throws RemoteException {  

  42.             Intent i = new Intent(getBaseContext(), Service1.class);  

  43.             getBaseContext().stopService(i);  

  44.         }  

  45.   

  46.         @Override  

  47.         public void startService() throws RemoteException {  

  48.             Intent i = new Intent(getBaseContext(), Service1.class);  

  49.             getBaseContext().startService(i);  

  50.   

  51.         }  

  52.     };  

  53.   

  54.     /** 

  55.      * 在内存紧张的时候,系统回收内存时,会回调OnTrimMemory, 重写onTrimMemory当系统清理内存时从新启动Service1 

  56.      */  

  57.     @Override  

  58.     public void onTrimMemory(int level) {  

  59.         startService1();  

  60.     }  

  61.   

  62.     @SuppressLint("NewApi")  

  63.     public void onCreate() {  

  64.   

  65.         Toast.makeText(Service2.this"Service2 启动中...", Toast.LENGTH_SHORT)  

  66.                 .show();  

  67.         startService1();  

  68.         /* 

  69.          * 此线程用监听Service2的状态 

  70.          */  

  71.         new Thread() {  

  72.             public void run() {  

  73.                 while (true) {  

  74.                     boolean isRun = Utils.isServiceWork(Service2.this,  

  75.                             "com.lzg.strongservice.service.Service1");  

  76.                     if (!isRun) {  

  77.                         Message msg = Message.obtain();  

  78.                         msg.what = 1;  

  79.                         handler.sendMessage(msg);  

  80.                     }  

  81.                     try {  

  82.                         Thread.sleep(1);  

  83.                     } catch (InterruptedException e) {  

  84.                         e.printStackTrace();  

  85.                     }  

  86.                 }  

  87.             };  

  88.         }.start();  

  89.     }  

  90.   

  91.     /** 

  92.      * 判断Service1是否还在运行,如果不是则启动Service1 

  93.      */  

  94.     private void startService1() {  

  95.         boolean isRun = Utils.isServiceWork(Service2.this,  

  96.                 "com.lzg.strongservice.service.Service1");  

  97.         if (isRun == false) {  

  98.             try {  

  99.                 startS1.startService();  

  100.             } catch (RemoteException e) {  

  101.                 e.printStackTrace();  

  102.             }  

  103.         }  

  104.     }  

  105.   

  106.     @Override  

  107.     public int onStartCommand(Intent intent, int flags, int startId) {  

  108.         return START_STICKY;  

  109.     }  

  110.   

  111.     @Override  

  112.     public IBinder onBind(Intent intent) {  

  113.         return (IBinder) startS1;  

  114.     }  

  115.   

  116. }</span></strong>  



aidl


[java] view plain copy
  1. <span style="font-size:14px;">package com.lzg.strongservice.service;  

  2. interface StrongService{  

  3.     void startService();  

  4.     void stopService();  

  5. }</span>  




Powered by MetInfo 5.3.17 ©2008-2022 www.metinfo.cn