HandlerThread使用

1.简介

2.使用方法

// 创建HandlerThread实体对象
val handlerThread = HandlerThread("handlerThread")
// 启动线程
handlerThread.start()
// 创建工作线程Handler
val workHandler = Handler(handlerThread.lopper) {
    // 消息处理 耗时操作
    val online = isNetOnline()
    Log.i(TAG, "online: $online")
    true
}
// 工作线程发送延时消息
workHandler.sendEmptyMessageDelayed(1,1000)
// 结束线程
handlerThread.quit()

    // 网络判断 查询是否有网络
    @RequiresPermission(Manifest.permission.INTERNET)
    fun isNetOnline(): Boolean {
        // Android 4.0 之后不能在主线程中请求HTTP请求
        var isNetsOnline: Boolean
        try {
            val url = URL("www.baidu.com")
            val con = url.openConnection() as HttpURLConnection
            val state = con.responseCode
            isNetsOnline = state == HttpURLConnection.HTTP_OK
            Log.d(TAG, "isNetOnline: $state,$isNetsOnline")
        } catch (ex: Exception) {
            isNetsOnline = false
            Log.w(TAG, "isNetOnline false: ${ex.message}")
        }
        return isNetsOnline
    }

class NetworkStateManager {
    @Volatile
    private var isInit: Boolean = false

    private val connectivityManager: ConnectivityManager = GlobalContext.context.getSystemService(
        Context.CONNECTIVITY_SERVICE
    ) as ConnectivityManager

    private val networkStateObservers: CopyOnWriteArrayList<INetworkStateObserver> = CopyOnWriteArrayList()

    @Volatile
    private var isConnected = true

    private var networkChangeReceiver: NetworkChangeReceiver? = null

    // 线程池
    private val netHandlerThread = HandlerThread(NETWORK_HANDLER_THREAD_NAME)

    // 主线程handler
    var mainHandler: Handler? = null

    // 网络查询线程 处理耗时操作
    var netHandler: Handler? = null

    class NetworkChangeReceiver(
        private val connectivityManager: ConnectivityManager,
        val networkStateManager: NetworkStateManager
    ) : BroadcastReceiver() {
        private val weakReference = WeakReference(networkStateManager)
        override fun onReceive(context: Context?, intent: Intent?) {
            if (intent?.action == ConnectivityManager.CONNECTIVITY_ACTION) {
                val isConnected = connectivityManager.activeNetworkInfo?.isConnected ?: false
                if (isConnected) {
                    Log.i(TAG, "NetworkChangeReceiver network connect")
                    weakReference.get()?.startCheckNet()
                } else {
                    Log.i(TAG, "NetworkChangeReceiver network disconnect")
                    weakReference.get()?.netOffline()
                }
            }
        }
    }

    @RequiresPermission(Manifest.permission.ACCESS_NETWORK_STATE)
    fun init() {
        if (isInit) return
        isInit = true
        isConnected = isNetworkAvailable()
        Log.i(TAG, "network init: $isConnected")
        netHandlerThread.start()
        initNetHandler()
        initMainHandler()
        registerNetWorkReceiver()
    }

    fun initNetHandler() {
        netHandler = Handler(netHandlerThread.looper) {
            val online = isNetOnline()
            Log.i(TAG, "netHandler online: $online")
            val message = Message()
            message.what = MAIN_WHAT
            message.obj = online
            mainHandler?.sendMessage(message)
            true
        }
    }

    fun initMainHandler() {
        mainHandler = object : Handler(Looper.getMainLooper()) {
            override fun handleMessage(msg: Message) {
                if (msg.what == MAIN_WHAT) {
                    val online = msg.obj as Boolean
                    Log.i(TAG, "mainHandler online: $online")
                    checkNetwork(online)
                }
            }
        }
    }

    fun checkNetwork(online: Boolean) {
        val openPrivacy = FactorySettingUtils.getPrivacySetting()
        Log.i(TAG, "checkNetwork online: $online,openPrivacy: $openPrivacy")
        if (online && openPrivacy) {
            netHandler?.sendEmptyMessageDelayed(NETWORK_WHAT, NETWORK_TIMER)
            if (isConnected) return
            isConnected = true
            val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
            capabilities?.let { netWork ->
                networkStateObservers.forEach {
                    it.onNetworkConnected()
                    it.onCapabilitiesChanged(netWork)
                }
            }
        } else {
            isConnected = false
            netHandler?.sendEmptyMessageDelayed(NETWORK_WHAT, NETWORK_RECONNECT_TIMER)
        }
    }

    fun unInit() {
        isInit = false
        networkChangeReceiver?.let {
            GlobalContext.context.unregisterReceiver(it)
        }
        netOffline()
        netHandlerThread.quit()
    }

    private fun registerNetWorkReceiver() {
        networkChangeReceiver = NetworkChangeReceiver(connectivityManager, this)
        val intentFilter = IntentFilter()
        intentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION)
        GlobalContext.context.registerReceiver(networkChangeReceiver, intentFilter)
    }

    /**
     * 发起网络定时任务 启动网络判断查询
     */
    fun startCheckNet() {
        mainHandler?.post {
            netHandler?.removeMessages(NETWORK_WHAT)
            netHandler?.sendEmptyMessageDelayed(NETWORK_WHAT, DELAY_MILLS)
        }
    }

    /**
     * 网络断开连接 remove掉网络message
     */
    fun netOffline() {
        mainHandler?.post {
            isConnected = false
            netHandler?.removeMessages(NETWORK_WHAT)
            networkStateObservers.forEach {
                it.onNetworkDisconnected()
            }
        }
    }

    fun registerNetworkObserver(observer: INetworkStateObserver) {
        if (!networkStateObservers.contains(observer)) {
            networkStateObservers.add(observer)
        }
    }

    fun unRegisterNetworkObserver(observer: INetworkStateObserver) {
        networkStateObservers.remove(observer)
    }

    /**
     * 获取当前网络状态
     */
    fun getNetworkStatus(): Boolean {
        return isConnected
    }

    @RequiresPermission(Manifest.permission.ACCESS_NETWORK_STATE)
    fun isNetworkAvailable(): Boolean {
        try {
            val network = connectivityManager.activeNetworkInfo?.isConnected ?: false
            Log.d(TAG, "Network activeNetworkInfo network: $network")
            val capabilities = connectivityManager.getNetworkCapabilities(connectivityManager.activeNetwork)
            capabilities?.let { net ->
                networkStateObservers.forEach { it.onCapabilitiesChanged(net) }
            }

            return network
        } catch (e: Exception) {
            Log.e(TAG, "isNetworkAvailable: " + e.message)
        }
        return false
    }

    /**
     * 功能：检测当前URL是否可连接或是否有效,
     * @return true是可以上网，false是不能上网
     */
    @RequiresPermission(Manifest.permission.INTERNET)
    fun isNetOnline(): Boolean {
        var isNetsOnline: Boolean
        try {
            val url = URL(GD_URL)
            val con = url.openConnection() as HttpURLConnection
            con.readTimeout = 6000
            con.connectTimeout = 6000
            val state = con.responseCode
            isNetsOnline = state == HttpURLConnection.HTTP_OK
            Log.d(TAG, "isNetOnline: $state,$isNetsOnline")
        } catch (ex: Exception) {
            isNetsOnline = false
            Log.w(TAG, "isNetOnline false: ${ex.message}")
        }
        return isNetsOnline
    }

    companion object {
        private val TAG = NetworkStateManager::class.java.simpleName

        const val GD_URL = "http://baidu.com"

        // handlerThread name
        const val NETWORK_HANDLER_THREAD_NAME = "networkStateThread"

        /**
         * 1分钟查一次网络
         */
        const val NETWORK_TIMER = 60 * 1000L

        /**
         * 网络连接 无法上网 6s check一下网络
         */
        const val NETWORK_RECONNECT_TIMER = 6 * 1000L
        const val NETWORK_WHAT = 10001
        const val MAIN_WHAT = 10002

        // 网络打开 发起网络检查时间
        const val DELAY_MILLS = 100L

        @JvmStatic
        val instance: NetworkStateManager by lazy { NetworkStateManager() }
    }
}

上诉源码功能为定时检查网络 HandlerThread + Handler的实例化运用,实体项目中使用部分代码

interface INetworkStateObserver {

    /**
     * 网络连接断开
     */
    fun onNetworkDisconnected() = Unit

    /**
     * 网络已连接
     */
    fun onNetworkConnected() = Unit

    // 网络状态变化
    fun onCapabilitiesChanged(networkCapabilities: NetworkCapabilities) = Unit
}