/**
 * @author 邱永恒
 *
 * @time 2018/3/1  13:49
 *
 * @desc
 *  监听系统广播，复活进程
 *  (1) 网络变化广播
 *  (2) 屏幕解锁广播(不能使用静态注册)
 *  (3) 应用安装卸载广播
 *  (4) 开机广播
 */
class KeepAliveReceiver : BroadcastReceiver() {
    companion object {
        val TAG = "KeepAliveReceiver"
    }

    override fun onReceive(context: Context?, intent: Intent?) {
        val action = intent?.action
        Log.d(TAG, "AliveBroadcastReceiver---->接收到的系统广播：" + action!!)
        getNetworkBroadcast(context!!, intent)
        if (SystemUtils.isAppAlive(context, Contants.PACKAGE_NAME)) {
            Log.i(TAG, "AliveBroadcastReceiver---->APP还是活着的")
            return
        }
        val intentAlive = Intent(context, SportActivity::class.java)
        intentAlive.flags = Intent.FLAG_ACTIVITY_NEW_TASK
        context.startActivity(intentAlive)
        Log.i(TAG, "AliveBroadcastReceiver---->复活进程(APP)")
    }

    private fun getNetworkBroadcast(context: Context, intent: Intent) {
        val action = intent.action
        // wifi状态改变
        if (WifiManager.WIFI_STATE_CHANGED_ACTION == action) {
            val wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0)
            when (wifiState) {
                WifiManager.WIFI_STATE_DISABLED -> Toast.makeText(context, "wifi关闭", Toast.LENGTH_SHORT).show()
                WifiManager.WIFI_STATE_ENABLED -> Toast.makeText(context, "wifi开启", Toast.LENGTH_SHORT).show()
                else -> {
                }
            }
        }
        // 连接到一个有效wifi路由器
        if (WifiManager.NETWORK_STATE_CHANGED_ACTION == action) {
            val parcelableExtra = intent.getParcelableExtra<Parcelable>(WifiManager.EXTRA_NETWORK_INFO)
            if (null != parcelableExtra) {
                val networkInfo = parcelableExtra as NetworkInfo
                val state = networkInfo.state
                val isConnected = state == NetworkInfo.State.CONNECTED
                if (isConnected) {
                    Toast.makeText(context, "设备连接到一个有效WIFI路由器", Toast.LENGTH_SHORT).show()
                }
            }
        }
        // 监听网络连接状态，包括wifi和移动网络数据的打开和关闭
        // 由于上面已经对wifi进行处理，这里只对移动网络进行监听(该方式检测有点慢)
        // 其中，移动网络--->ConnectivityManager.TYPE_MOBILE；
        //       Wifi--->ConnectivityManager.TYPE_WIFI
        //       不明确类型：ConnectivityManager.EXTRA_NETWORK_INFO
        if (ConnectivityManager.CONNECTIVITY_ACTION == action) {
            val manager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val gprs = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
            if (gprs.isConnected) {
                Toast.makeText(context, "移动网络打开", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(context, "移动网络关闭", Toast.LENGTH_SHORT).show()
            }
        }
    }

}

package com.qyh.keepalivekotlin.service

import android.annotation.SuppressLint
import android.app.Notification
import android.app.Service
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.IBinder
import android.util.Log
import com.qyh.keepalivekotlin.DaemonConnection
import com.qyh.keepalivekotlin.R
import com.qyh.keepalivekotlin.utils.BroadcastManager
import com.qyh.keepalivekotlin.utils.Contants.Companion.TIME_ACTION
import java.util.*

/**
 * @author 邱永恒
 *
 * @time 2018/3/2  16:35
 *
 * @desc ${TODD}
 *
 */
class SportService : Service() {
    private val binder : SportBinder by lazy { SportBinder() }
    private val serviceConnection : SportServiceConnection by lazy { SportServiceConnection() }
    private lateinit var runTimer: Timer
    private var timeHour: Int = 0
    private var timeMin: Int = 0
    private var timeSec: Int = 0
    companion object {
        val TAG = "SportService"
        var startMs: Long = 0L
    }

    override fun onBind(intent: Intent?): IBinder {
        return binder
    }

    override fun onCreate() {
        super.onCreate()
        val builder = Notification.Builder(this)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle("运动中")
                .setContentText("正在运动...")
        startForeground(200, builder.build())
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // 绑定本地service
        bindService(Intent(this, DaemonService::class.java), serviceConnection, Context.BIND_IMPORTANT)
        Log.d(TAG, "$TAG onStartCommand")
        return START_STICKY
    }

    fun startRunTimer() {
        val task = object : TimerTask() {
            @SuppressLint("SetTextI18n")
            override fun run() {
                // 更新UI
                val ms = System.currentTimeMillis() - startMs
                Log.d(TAG, "时间间隔: ${System.currentTimeMillis()}")
                val hms = ms2HMS(ms)
                BroadcastManager.getInstance().sendBroadcast(TIME_ACTION, hms)
            }
        }
        // 每隔1s更新一下时间
        startMs = System.currentTimeMillis()
        Log.d(TAG, "开始时间: $startMs")
        runTimer = Timer()
        runTimer.schedule(task, 0, 1000)
    }

    fun ms2HMS(ms: Long): String {
        val m = ms / 1000
        val hour = m / 3600
        val mint = m % 3600 / 60
        val sed = m % 60
        return String.format("%02d:%02d:%02d", hour, mint, sed)
    }

    @SuppressLint("SetTextI18n")
    fun stopRunTimer() {
        runTimer.cancel()
        startMs = 0
        timeHour = 0
        timeMin = 0
        timeSec = 0

        val ms2HMS = ms2HMS(0)
        BroadcastManager.getInstance().sendBroadcast(TIME_ACTION, ms2HMS)
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "$TAG onDestroy")
        startService(Intent(applicationContext, SportService::class.java))
    }

    inner class SportBinder : DaemonConnection.Stub() {
        override fun startRunTimer() {
            [email protected]()
        }

        override fun stopRunTimer() {
            [email protected]()
        }

        override fun getProcessName(): String {
            return "SportService"
        }
    }

    inner class SportServiceConnection : ServiceConnection {
        override fun onServiceDisconnected(name: ComponentName?) {
            [email protected](Intent(this@SportService, DaemonService::class.java))
            [email protected](Intent(this@SportService, DaemonService::class.java), serviceConnection, Context.BIND_IMPORTANT)
        }

        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            val daemonConnection = DaemonConnection.Stub.asInterface(service)
            Log.d(TAG, "连接远程service: ${daemonConnection.processName}")
        }
    }
}

package com.qyh.keepalivekotlin.service

import android.app.Notification
import android.app.NotificationManager
import android.app.Service
import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.IBinder
import android.util.Log
import com.qyh.keepalivekotlin.DaemonConnection
import com.qyh.keepalivekotlin.R

/**
 * @author 邱永恒
 *
 * @time 2018/3/1  8:53
 *
 * @desc 后台守护service, 这个Service尽量要轻，不要占用过多的系统资源，否则系统在资源紧张时，照样会将其杀死
 *
 */
class DaemonService : Service() {
    private val binder : DaemonBinder by lazy { DaemonBinder() }
    private val serviceConnection : DaemonServiceConnection by lazy { DaemonServiceConnection() }
    companion object {
        val TAG = "DaemonService"
        val NOTICE_ID = 100
    }

    override fun onBind(intent: Intent?): IBinder? {
        return binder
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // 绑定本地service
        bindService(Intent(this, SportService::class.java), serviceConnection, Context.BIND_IMPORTANT)
        // 启动前台进程
        startForeground()
        return START_STICKY
    }

    private fun startForeground() {
        val builder = Notification.Builder(this)
                .setSmallIcon(R.mipmap.ic_launcher)
                .setContentTitle("程序保活")
                .setContentText("守护service正在运行中...")
        startForeground(NOTICE_ID, builder.build())
    }

    override fun onDestroy() {
        super.onDestroy()
        // 取消状态栏广播
        val manager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
        manager.cancel(NOTICE_ID)
    }

    class DaemonBinder : DaemonConnection.Stub() {
        override fun startRunTimer() {

        }

        override fun stopRunTimer() {

        }

        override fun getProcessName(): String {
            return "DaemonService"
        }
    }

    inner class DaemonServiceConnection : ServiceConnection {
        override fun onServiceDisconnected(name: ComponentName?) {
            [email protected](Intent(this@DaemonService, SportService::class.java))
            [email protected](Intent(this@DaemonService, SportService::class.java), serviceConnection, Context.BIND_IMPORTANT)
        }

        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            val daemonConnection = DaemonConnection.Stub.asInterface(service)
            Log.d(TAG, "连接本地service: ${daemonConnection.processName}")
        }
    }
}

// DeamonConnection.aidl
package com.qyh.keepalivekotlin;

// Declare any non-default types here with import statements

interface DaemonConnection {
    String getProcessName();
    void startRunTimer();
    void stopRunTimer();
}