最近在做一个wifi相关的项目，因此去了解了官方文档和相关技术资料，整理了一下目前wifi连接的可行性和办法，包括扫描、连接、状态监听。

二、使用方法

目前安卓10开始官方已经弃用原来的连接wifi了，改用对等连接： developer.android.com/guide/topic… 而这个对等连接其实就是APP内部连接到该wifi，但是手机本身是保持原来连接的wifi的，所以原来那种修改系统wifi连接的已经弃用了，想继续使用，需要把项目targetSdkVersion修改为小于29。

1.wifi管理类

    object WifiUtils {
      val mWifiManager by lazy {
          WiFiMoneyApplication.getApplication ()?.applicationContext?.getSystemService(Context.WIFI_SERVICE) as WifiManager
开启wifi
    fun openWifi() {
        mWifiManager.isWifiEnabled = true
连接wifi
    @SuppressLint("MissingPermission")
    fun connectWifi(context: Context, scanResults: List<ScanResult>,  ssid: String, connect: (success: Boolean, scanResult: ScanResult) -> Unit) {
        if (!mWifiManager.isWifiEnabled) {
            return
        val scanResult = scanResults.singleOrNull { it.SSID == ssid }
        if (scanResult != null) {
            val config = mWifiManager.configuredNetworks.singleOrNull { it.SSID.replace("\"", "") == ssid }
            if (config != null && config.status != WifiConfiguration.Status.DISABLED) {
                if (BuildConfig.LOG_DEBUG) {
                    Log.d(TAG, "找到了历史wifi:${scanResult.SSID}")
                connect.invoke(mWifiManager.enableNetwork(config.networkId, true), scanResult)
            } else {
                val type = getCipherType(scanResult.capabilities)
                if (type == WifiCapability.WIFI_CIPHER_NO_PASS) {
                    // 没找到历史wifi
                    val padWifiNetwork =
                            createWifiConfig(
                                scanResult.SSID,
                                type = getCipherType(scanResult.capabilities))
                    val netId = mWifiManager.addNetwork(padWifiNetwork)
                    if (BuildConfig.LOG_DEBUG) {
                        Log.d(TAG, "不需要密码连接wifi:${scanResult.SSID}")
                    connect.invoke(mWifiManager.enableNetwork(netId, true), scanResult)
                } else {
                    if (BuildConfig.LOG_DEBUG) {
                        Log.d(TAG, "需要密码连接wifi:${scanResult.SSID}")
                    connect.invoke(false, scanResult)
        } else {
            if (BuildConfig.LOG_DEBUG) {
                Log.d(TAG, "connectWifi 没有找到")
    @SuppressLint("MissingPermission")
    fun createWifiConfig(
        ssid: String,
        password: String = "",
        type: WifiCapability
                                ): WifiConfiguration {
        //初始化WifiConfiguration
        val config = WifiConfiguration()
        config.allowedAuthAlgorithms.clear()
        config.allowedGroupCiphers.clear()
        config.allowedKeyManagement.clear()
        config.allowedPairwiseCiphers.clear()
        config.allowedProtocols.clear()
        //指定对应的SSID
        config.SSID = "\"" + ssid + "\""
        //如果之前有类似的配置
        val tempConfig = mWifiManager.configuredNetworks.singleOrNull { it.BSSID == "\"$ssid\"" }
        if (tempConfig != null) {
            //则清除旧有配置  不是自己创建的network 这里其实是删不掉的
            val isDisable = mWifiManager.disableNetwork(tempConfig.networkId)
            val isRemove = mWifiManager.removeNetwork(tempConfig.networkId)
            val isSave = mWifiManager.saveConfiguration()
            if (BuildConfig.LOG_DEBUG) {
                Log.d(TAG, "清除wifi配置:${tempConfig.SSID + (isDisable && isRemove && isSave)}")
        //不需要密码的场景
        if (type == WifiCapability.WIFI_CIPHER_NO_PASS) {
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
            //以WEP加密的场景
        } else if (type == WifiCapability.WIFI_CIPHER_WEP) {
            config.hiddenSSID = true
            config.wepKeys[0] = "\"" + password + "\""
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED)
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
            config.wepTxKeyIndex = 0
            //以WPA加密的场景
        } else if (type == WifiCapability.WIFI_CIPHER_WPA) {
            config.preSharedKey = "\"" + password + "\""
            config.hiddenSSID = true
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP)
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
            config.status = WifiConfiguration.Status.ENABLED
        return config
    fun getCipherType(capabilities: String): WifiCapability {
        return when {
            capabilities.contains("WEB") -> {
                WifiCapability.WIFI_CIPHER_WEP
            capabilities.contains("PSK") -> {
                WifiCapability.WIFI_CIPHER_WPA
            capabilities.contains("WPS") -> {
                WifiCapability.WIFI_CIPHER_NO_PASS
            else -> {
                WifiCapability.WIFI_CIPHER_NO_PASS
    enum class WifiCapability {
        WIFI_CIPHER_WEP, WIFI_CIPHER_WPA, WIFI_CIPHER_NO_PASS
    fun connectWifi(item: ScanResult) {
        if (item.BSSID == WifiUtils.mWifiManager.connectionInfo.bssid) {
            ToastUtils.showToast(context, getString(R.string.wifi_home_connect_error))
            return
        if (BuildConfig.LOG_DEBUG) {
            Log.d(TAG, "开始切换wifi")
        WifiUtils.connectWifi(context!!, mWifiList, item.SSID) { success, scanResult ->
            if (success) {
                // 这个时候找到wifi，开始连接
            } else {
                // 未成功找到wifi添加，尝试输入密码
                activity?.let { activity ->
                    InputPasswordDialog(activity, scanResult.SSID) { password ->
                        val padWifiNetwork =
                            WifiUtils.createWifiConfig(
                                scanResult.SSID,
                                password,
                                WifiUtils.getCipherType(scanResult.capabilities)
                        val netId = WifiUtils.mWifiManager.addNetwork(padWifiNetwork)
                        val success2 = WifiUtils.mWifiManager.enableNetwork(netId, true)
                        if (success2) {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "这个时候找到wifi，开始连接：${success2}")
                            startConnectAni(item)
                        } else {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "创建连接失败")
                            ToastUtils.showToast(context!!, "创建连接失败")
                }?.show()
wifi强度获取
    fun getNetworkWifiLevel(wifiInfo: ScanResult): Int {
        //获得信号强度值
        val level = wifiInfo.level
        //根据获得信号的强度发送信息
        return if (level <= 0 && level >= -50) { //最强
        else if (level < -50 && level >= -70) { //较强
        else if (level < -70 && level >= -80) { //较弱
        else if (level < -80 && level >= -100) { //微弱
        else {
2.wifi连接状态监听
    private fun registerWifiStatusListener() {
        val filter = IntentFilter()
        filter.addAction(SUPPLICANT_STATE_CHANGED_ACTION)// wifi连接结果
        filter.addAction(WIFI_STATE_CHANGED_ACTION) // wifi开启关闭状态
        filter.addAction(NETWORK_STATE_CHANGED_ACTION)// wifi连接状态
        filter.addAction(SCAN_RESULTS_AVAILABLE_ACTION)// 监听wifi列表变化（开启一个热点或者关闭一个热点）
        filter.addAction("android.net.conn.CONNECTIVITY_CHANGE")// 网络类型切换
        activity?.application?.registerReceiver(mWifiReceiver, filter)
    private val mWifiReceiver: BroadcastReceiver by lazy {
        object : BroadcastReceiver() {
            override fun onReceive(context: Context?, intent: Intent) {
                if (intent.action === WIFI_STATE_CHANGED_ACTION) {
                    when (intent.getIntExtra(EXTRA_WIFI_STATE, WIFI_STATE_UNKNOWN)) {
                        // 已关闭
                        WIFI_STATE_DISABLED -> {
                            updateWifiStatus(6)
                        // 关闭中
                        WIFI_STATE_DISABLING -> {}
                        // 可用
                        WIFI_STATE_ENABLED -> {}
                        // 正在开启
                        WIFI_STATE_ENABLING -> {
                            updateWifiStatus(5)
                        // 未知
                        WIFI_STATE_UNKNOWN -> {
                            updateWifiStatus(1)
                } else if (NETWORK_STATE_CHANGED_ACTION == intent.getAction()) {
                    val info: NetworkInfo = intent.getParcelableExtra(EXTRA_NETWORK_INFO)
                    if (NetworkInfo.State.DISCONNECTED == info.state) { // wifi没连接上,连接已断开
                        if (BuildConfig.LOG_DEBUG) {
                            Log.d(TAG, "连接已断开")
                    } else if (NetworkInfo.State.CONNECTED == info.state) { //wifi连接上了
                        if (BuildConfig.LOG_DEBUG) {
                            Log.d("TAG, "wifi连接上了")
                        refreshWifiList()
                    } else if (NetworkInfo.State.CONNECTING == info.state) { // 正在连接
                        if (BuildConfig.LOG_DEBUG) {
                            Log.d(TAG, "wifi正在连接")
                } else if (SCAN_RESULTS_AVAILABLE_ACTION == intent.action) {
                    val success = intent.getBooleanExtra(WifiManager.EXTRA_RESULTS_UPDATED, false)
                    if (success) {
                      scanSuccess()
                    } else {
                      scanFailure()
                    // wifi连接结果通知   WIFI连接请求状态发生改变
                } else if (SUPPLICANT_STATE_CHANGED_ACTION == intent.action) {
                    // 密码错误
                    val error = intent.getIntExtra(EXTRA_SUPPLICANT_ERROR, -1)
                    if (error == ERROR_AUTHENTICATING) {
                        if (BuildConfig.LOG_DEBUG) {
                            Log.d(TAG, "获取连接状态：密码错误")
                        // todo 连接失败
                        return
                    // 获取连接状态
                    val supplicantState: SupplicantState =
                        intent.getParcelableExtra(EXTRA_NEW_STATE)
                    when (supplicantState) {
                        // 成功
                        SupplicantState.COMPLETED




    
 -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：成功")
                        	// todo 连接成功
                        // 不活跃的
                        SupplicantState.INACTIVE -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：不活跃的")
                        	// todo 连接失败
                        // 接口禁用
                        SupplicantState.INTERFACE_DISABLED -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：接口禁用")
                        SupplicantState.DISCONNECTED -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：断开连接")
                        SupplicantState.SCANNING -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：正在扫描")
                        SupplicantState.AUTHENTICATING -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：正在验证")
                        SupplicantState.ASSOCIATING -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：正在关联")
                        SupplicantState.ASSOCIATED -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：已经关联")
                        SupplicantState.FOUR_WAY_HANDSHAKE -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：四次握手")
                        SupplicantState.GROUP_HANDSHAKE -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：组握手")
                        SupplicantState.DORMANT -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：休眠")
                        SupplicantState.UNINITIALIZED -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：未初始化")
                        SupplicantState.INVALID -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "获取连接状态：无效的")
                        else -> {
                            if (BuildConfig.LOG_DEBUG) {
                                Log.d(TAG, "wifi连接结果通知")
                } else if ("android.net.conn.CONNECTIVITY_CHANGE" == intent.action) {
                    if (BuildConfig.LOG_DEBUG) {
                        Log.d(TAG, "网络类型切换了")
                    updateNetWorkType()
3.wifi相关权限申请
    RxPermissions(this).request(
                Manifest.permission.ACCESS_FINE_LOCATION,
                Manifest.permission.CHANGE_WIFI_STATE,
                Manifest.permission.ACCESS_WIFI_STATE
            ).subscribe {
                if (!it) {
                    //没权限
4.wifi列表更新
    fun refreshWifiList() {
        if (!WifiUtils.mWifiManager.isWifiEnabled) {
            return
        mWifiList.clear()
        // 原始wifi列表
        val originList = WifiUtils.mWifiManager.scanResults
        // 当前wifi
        val currentWifi = originList.singleOrNull {
            it.BSSID == WifiUtils.mWifiManager.connectionInfo.bssid &&
                    WifiUtils.mWifiManager.connectionInfo.supplicantState == SupplicantState.COMPLETED
        // 添加wifi到列表
        for ((i, _) in originList.withIndex()) {
            // 该热点SSID是否已在列表中
            val position: Int = getItemPosition(mWifiList, originList[i])
            // 过滤没有名字的，没有意义
            if (originList[i].SSID.isNotEmpty()) {
                if (position != -1) { // 已在列表
                    // 相同SSID热点，取信号强的
                    if (mWifiList[position].level < originList[i].level) {
                        mWifiList.removeAt(position)
                        mWifiList.add(position, originList[i])
                } else {
                    mWifiList.add(originList[i])
            // 按信号强度排序
            mWifiList.sortWith(Comparator { t1, t2 -> t2.level - t1.level })
        // 置顶当前连接的wifi
        var p = -1
        currentWifi?.let {
            for ((i, value) in mWifiList.withIndex()) {
                if (currentWifi.BSSID == value.BSSID) {
                    p = i
            updateWifiName()
        if (p != -1 && currentWifi != null) {
            mWifiList.removeAt(p)
            mWifiList.add(0, currentWifi)
            mWifiAdapter.connectPosition = 0
        } else {
            mWifiAdapter.connectPosition = -1
        mWifiAdapter.notifyDataSetChanged()
        // 处于连接中的wifi，成功了才切换状态
        if (mLastStatus != 2 || (mLastStatus == 2 && currentWifi != null)) {
            if (mWifiList.isNotEmpty()) {
                updateWifiStatus(1)
            } else {
                updateWifiStatus(4)
        // 刷新列表
        updateListOpenOrNot()
5.正在使用的网络类型判断（在监听关闭wifi网络的时候，调用这个依然返回有网络）
object NetworkUtils {
    const val NETWORK_NOT_DEFINE = -2 // 没有定义
    const val NETWORK_NONE = -1 // 没有网络连接
    const val NETWORK_WIFI = 1 // wifi连接
    const val NETWORK_2G = 2 // 2G
    const val NETWORK_3G = 3 // 3G
    const val NETWORK_4G = 4 // 4G
    const val NETWORK_5G = 5 // 5G
    const val NETWORK_MOBILE = 0 // 手机流量
     * 获取当前网络连接的类型
     * @param context context
     * @return int
    fun getNetworkState(context: Context): Int {
        val connManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        // 获取网络类型，如果为空，返回无网络
        val activeNetInfo = connManager.activeNetworkInfo
        if (activeNetInfo == null || !activeNetInfo.isAvailable) {
            return NETWORK_NONE
        // 判断是否为WIFI
        val wifiInfo = connManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
        if (null != wifiInfo) {
            val state = wifiInfo.state
            if (null != state) {
                if (state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING) {
                    return NETWORK_WIFI
        // 若不是WIFI，则去判断是2G、3G、4G网
        val telephonyManager = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
        val networkType = telephonyManager.networkType
        return when (networkType) {
            TelephonyManager.NETWORK_TYPE_GPRS, TelephonyManager.NETWORK_TYPE_CDMA, TelephonyManager.NETWORK_TYPE_EDGE, TelephonyManager.NETWORK_TYPE_1xRTT, TelephonyManager.NETWORK_TYPE_IDEN -> NETWORK_2G
            TelephonyManager.NETWORK_TYPE_EVDO_A, TelephonyManager.NETWORK_TYPE_UMTS, TelephonyManager.NETWORK_TYPE_EVDO_0, TelephonyManager.NETWORK_TYPE_HSDPA, TelephonyManager.NETWORK_TYPE_HSUPA, TelephonyManager.NETWORK_TYPE_HSPA, TelephonyManager.NETWORK_TYPE_EVDO_B, TelephonyManager.NETWORK_TYPE_EHRPD, TelephonyManager.NETWORK_TYPE_HSPAP -> NETWORK_3G
            TelephonyManager.NETWORK_TYPE_LTE -> NETWORK_4G
            TelephonyManager.NETWORK_TYPE_NR -> NETWORK_5G
            else -> NETWORK_MOBILE
     * 是否正在用手机流量
    fun isMobileNetwork (context: Context): Boolean {
        val a = getNetworkState(context)
        if (BuildConfig.LOG_DEBUG) {
            Log.d(TAG, "是否正在用手机流量 getNetworkState:${a}")
        return a != NETWORK_NONE && a != NETWORK_NOT_DEFINE && a != NETWORK_WIFI
6.wifi相关api需要定位功能，需要判断用户有没有开定位
     * 手机是否开启位置服务
    fun isLocServiceEnable(context: Context): Boolean {
        val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
        val gps = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
        val network = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)
        return gps || network
7.android10以上新功能，也列出来吧。
P2P连接Wifi就是对等连接，在APP内部会出现对话框，请求某个wifi连接，仅APP内部使用
    // Android10以上 通过P2P连接Wifi
    @RequiresApi(Build.VERSION_CODES.Q)
    fun connectByP2P(context: Context, scanResult: ScanResult, password: String, successListener: ((Network?) -> Unit)? = null,  failListener: (() -> Unit)? = null) {
        val specifier = WifiNetworkSpecifier.Builder()
                .setSsidPattern(PatternMatcher(scanResult.SSID, PatternMatcher.PATTERN_PREFIX))
                .setWpa2Passphrase(password)
                .build()
        val request =
                NetworkRequest.Builder()
                        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                        .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                        .setNetworkSpecifier(specifier)
                        .build()
        val connectivityManager =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val networkCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network?) {
                connectivityManager.bindProcessToNetwork(network)
                successListener?.invoke(network)
            override fun onUnavailable() {
                failListener?.invoke()
        connectivityManager.requestNetwork(request, networkCallback)
//        使用完毕后调用这个方法 connectivityManager.unregisterNetworkCallback(networkCallback)
这个是给系统提建议，个人感觉非常鸡肋
    // Android10以上，通过suggestion连接WIFI
    @RequiresApi(Build.VERSION_CODES.Q)
    private fun connectBySug(ssid: String, password: String) {
        val suggestion = WifiNetworkSuggestion.Builder()
                .setSsid(ssid)
                .setWpa2Passphrase(password)
                .setIsAppInteractionRequired(true) // Optional (Needs location permission)
                .build()
        val suggestionsList = listOf(suggestion)
        //wifiManager.removeNetworkSuggestions(suggestionsList)
        val status = wifiManager.addNetworkSuggestions(suggestionsList)
        if (status != WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS) {
        val intentFilter = IntentFilter(WifiManager.ACTION_WIFI_NETWORK_SUGGESTION_POST_CONNECTION);
        val broadcastReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context




    
, intent: Intent) {
                if (!intent.action.equals(WifiManager.ACTION_WIFI_NETWORK_SUGGESTION_POST_CONNECTION)) {
                    return
        context.registerReceiver(broadcastReceiver, intentFilter);
总结：在开发过程中发现wifi的监听真的非常多，估计并没有列出完全监听，欢迎大家可以补充，有问题可以评论讨论。
  
 
   
相关推荐
 
  
        VIjolie
        Android
      
 
   Android设备wifi开发
 
三月份新入职的公司，公司的主要业务是只能电视应用，由于公司战略需要，准备做一个tvos,里面包含有设置的系统应用，本人分到的任务是wifi这一块开发。由于之前接手的都是移动端的开发，对于wifi这一块几乎没有接触过，所以分享出来，希望我踩过的坑，大家能避免。 的广播。通过Lis…
 
 3748
 
 
        西瓜king
        Android
        Kotlin
      
 
   协程(14) | 让你的代码支持Flow
 
前言 协程到现在，我们已经差不多学完了所有基础知识，包括协程启动方式、挂起函数、结构化并发、异常处理、Channel以及Flow等，而关于Flow的进阶使用以及协程更多进阶使用，在后面还需要继续探索。
 
 4522
 
 
        小余的自习室
        Android
        掘金·金石计划
      
 
   “一文读懂”系列：ARouter用法以及原理AGP/APT/AOP
 
最近组里需要进行组件化框架的改造，用到了Arouter这个开源框架，为了更好的对项目进行改造，笔者花了一些时间去了解了下Arouter ARouter是阿里巴巴团队在17年初发布的一款针对组件
 
 1207
 
 
        西瓜king
        Android
        Kotlin
      
 
   framework | 一文搞定JNI原理
 
JNI技术打通了Java世界和native世界，让代码可以互相调用，核心由虚拟机实现，表现形式为多了一层JNI的C++代码层。
 
 2257
 
 
        TechMerger
        Android
        Kotlin
        Android Studio
      
 
   从 internal 修饰符一探 kotlin 的可见性控制
 
前言 之前探讨过的 sealed class 和 sealed interface 存在 module 的限制，但其主要用于密封 class 的扩展和 interface 的实现。 如果没有这个需求只
 
 1799




    
 
 
        Kotlin
        Android
      
 
   一起掌握Kotlin协程基础
 
今天让我们一起掌握Kotlin协程的基础，为后面对协程的使用打下扎实的基础。之后对它的使用会更加灵活。
 
 1092
 
 
        zeroXuan
        Android
      
 
   Android 轻松解决内存泄漏
 
方法区（non-heap）：编译时就分配好，在程序整个运行期间都存在。它主要存放静态数据和常量； 堆区（heap）：通常用来存放 new 出来的对象。由 GC 负责回收。 强引用（Strong Reference）:JVM 宁愿抛出 OOM，也不会让 GC 回收存在强引用的对象…
 
 4224
 
 
        Android
      
 
   ViewPager中Fragment的懒加载和可见状态监听
 
一. 前言 在Android开发中经常会使用到ViewPager, ViewPager如果和Fragment一起使用的话, 就要考虑懒加载和预加载的问题. ViewPager有个方法setOffscreenPageLimit 这个方法可以配置缓存数量. 那是不是直接设置0就可以…
 
 4300
 
 
        路遥在路上
        Kotlin
      
 
   重学 Kotlin —— inline，包治百病的性能良药？
 
今天的主角是 inline ，这不是一个 Kotlin 特有的概念，大多数编程语言都支持内联。 内联函数 的语义很简单： 把函数体复制粘贴到函数调用处 。使用起来也毫无困难，用 inline关键字修饰函数即可。 今天，我们就一起来刨根挖底，寻找一下答案。 前面已经说过 inli…
 
 1.5w
 





    
 
        cofbro
        Android
      
 
   一篇文章带你深刻认识不一样的setContentView()
 
setContentView() 方法在我们 onCreate() 方法的第二行，我们经常使用这段代码，但是似乎并没有真正的了解过这个方法，今天我们来一起看看它内部是怎么实现的吧。 setConten
 
 1135
 
 
        Android
      
 
   [Android]从零开始的内核编译
 
本教程将基于小米 10S 的内核源码进行实例，其他型号的手机请自行寻找内核源码。 基本的Kernel编译流程。
 
 1778
 
 
        RainyJiang
        Android
        Glide
      
 
   探寻Glide,你应该要知道的用法
 
我正在参加「掘金·启航计划」 前言 对于Glide，相信各位同学都不陌生，作为最常用的图片加载框架，它广泛应用大大小小的项目当中,一般我们常规用法就是使用链式调用就可以给组件设置图片了，非常便捷高效,
 
 1135
 
 
        Android
        Retrofit
      
 
   Retrofit源码精析
 
目前主流APP对网络交互部分的实现基本上都是RxJava（或协程）+Retrofit+OkHttp架构，可见Retrofit已经广为人知。本文主要介绍Retrofit主线源码实现机制，及其包含思想等等
 
 881
 
 
        DuBetter
        Android
      
 
   Android源码—Handler
 
前言 Handler是Android开发中使用常用的机制，自然也是面试中的高频考点，大家都清楚，在问到Handler时，都会供出他的好伙伴Message、MessageQuene、Looper。 在H
 
 736
 
 
    团长1874
        android工程师
      
 
 关注  
私信