android service重启

首先,说一下思路,很简单,启动两个service检测对方,如果发现对方killed,立马启动就可以了.具体实现代码如下

1.先准备两个service,CoreService和DaemonService

<service
    android:name="com.david.service.CoreService"
    android:enabled="true">
    <intent-filter android:priority="1000">
        <action android:name="com.david.service.CoreService" />
    </intent-filter>
</service>

<service
    android:name="com.david.service.DaemonService"
    android:enabled="true"
    android:process=":daemon">
    <intent-filter android:priority="1000">
        <action android:name="com.david.service.DaemonService" />
    </intent-filter>
</service>

注意,DaemonService多了一项属性.

android:process=":daemon"

这里其实通过观察设置-应用管理-正在运行,你会发现QQ,微信等都会有两个进程.那两个QQ的进程,就是这么来的.

2.然后准备两个Receiver用来接受service发出的检测对方是否运行的广播

<receiver
    android:name="com.david.receiver.CoreReceiver"
    android:enabled="true">
    <intent-filter>
        <action android:name="com.david.receiver.CORE" />
    </intent-filter>
</receiver>
<receiver
    android:name="com.david.receiver.DaemonReceiver"
    android:enabled="true"
    android:process=":daemon">
    <intent-filter>
        <action android:name="com.david.receiver.DAEMON" />
    </intent-filter>
</receiver>

同样,DaemonReceiver跟DaemonService一样,被放到了:daemon进程中.

3.Service相互检测对方

CoreService启动线程发送广播:

public class CoreService extends Service {
    private static final int DAEMON_CHECK_INTERVAL=1000 * 2;
    private Intent coreIntent = new Intent("com.david.receiver.CORE");
    private Thread coreThread = null;
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        startThread();
    }
    private void startThread(){
        coreThread = new Thread(new DaemonCheckThread());
        coreThread.start();
    }

    private class DaemonCheckThread implements Runnable {

        public DaemonCheckThread() {
        }

        @Override
        public void run() {
            while (true) {
                try {
                    sendBroadcast(coreIntent);
                    Thread.sleep(DAEMON_CHECK_INTERVAL);
                } catch (InterruptedException e) {
                    // ignore
                }
            }
        }
    }
}

CoreReceiver中检测DaemonService是否运行,如果killed,则启动DaemonService:

public class CoreReceiver extends BroadcastReceiver {
    private static final String DAEMON_SERVICE="com.david.service.DaemonService";
    @Override
    public void onReceive(Context context, Intent intent) {
        if(!ServiceUtil.isServiceRunning(context,DAEMON_SERVICE)){
            ServiceUtil.startService(context,DAEMON_SERVICE);
        }
    }
}

另外一边也是一样,DaemonService中启动线程发送广播,DaemonReceiver中接受广播,检测CoreService的运行状态

DaemonService:

public class DaemonService extends Service {
    private static final int CORE_CHECK_INTERVAL=1000 * 2;
    private Intent daemonIntent = new Intent("com.david.receiver.DAEMON");
    private Thread daemonThread = null;
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        startThread();
    }
    private void startThread(){
        daemonThread = new Thread(new CoreCheckThread());
        daemonThread.start();
    }

    private class CoreCheckThread implements Runnable {

        public CoreCheckThread() {
        }

        @Override
        public void run() {
            while (true) {
                try {
                    sendBroadcast(daemonIntent);
                    Thread.sleep(CORE_CHECK_INTERVAL);
                } catch (InterruptedException e) {
                    // ignore
                }
            }
        }
    }
}

DaemonReceiver:

public class DaemonReceiver extends BroadcastReceiver {
    private static final String CORE_SERVICE="com.david.service.CoreService";
    @Override
    public void onReceive(Context context, Intent intent) {
        if(!ServiceUtil.isServiceRunning(context,CORE_SERVICE)){
            ServiceUtil.startService(context,CORE_SERVICE);
        }
    }
}

4.最后一步,检测服务是否运行

public class ServiceUtil {

    private static final Logger logger = LoggerFactory.getLogger(ServiceUtil.class);

    public static boolean isServiceRunning(Context context, String serviceName) {
        boolean isServiceRunning = false;
        ActivityManager manager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        for (ActivityManager.RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
            if (serviceName.equals(service.service.getClassName())) {
                isServiceRunning = true;
                break;
            }

        }
        logger.debug(String.format("service [%s] running status:[%s]", serviceName, isServiceRunning));
        return isServiceRunning;
    }

    public static void startService(Context context, String action) {
        logger.debug(String.format("start service [%s]", action));
        Intent mIntent = new Intent();
        mIntent.setAction(action);
        mIntent.setPackage(context.getPackageName());
        context.startService(mIntent);
    }

}

总结一下就是两个进程中各有一个service,互相检测对方运行状态,如果没在运行,则启动.我这里android 4.4.4测试有效.

转载于:https://my.oschina.net/u/725579/blog/611913