Android网络状态变化监听 -- 结合registerNetworkCallback和广播(kotlin)

已于 2022-12-30 14:47:56 修改
阅读量3.9k 收藏 4
点赞数 5
分类专栏： android 文章标签： android 网络
于 2022-12-30 14:16:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36162336/article/details/128494247
版权

如图

218416259a5147a4971f27e6518401e7.png

 

 

说明
  AndroidAndroid针对网络状态变化的监听，在应用内我们通用需要监听设备网络状态的变化，作出相应的业务处理，需要一个方便的、全局的监听实现。。
  针对不同设备的系统版本，使用不同的API方法实现；
  注意使用广播监听网络状态在高版本的适配问题；

  1、Build.VERSION.SDK_INT >= Build.VERSION_CODES.N，使用connectivityManager.registerDefaultNetworkCallback()方法；
  2、Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP，使用connectivityManager.registerNetworkCallback(networkRequest, new MyNetworkCallback());方法；
  3、其它系统版本使用广播监听；
  4、NetworkListenerHelper可以添加多个页面的监听，当某个页面需要监听网络时，就可以添加到监听者集合中，页面关闭时移除这个监听者，也可以使用事件总线；

核心实现

NetworkListenerHelper

package com.let.networkstatusmonitor

import android.annotation.SuppressLint
import android.content.Context
import android.content.IntentFilter
import android.net.ConnectivityManager
import android.net.ConnectivityManager.NetworkCallback
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import android.os.Build
import com.let.networkstatusmonitor.NetworkBroadcastReceiver.NetworkBroadcastCallback
import com.let.networkstatusmonitor.NetworkUtils.getNetWorkState
import java.util.concurrent.CopyOnWriteArrayList

/**
 * @Author: let
 * @date: 2022/11/15 17:29
 * @description: 网络状态变化的监听类，根据android不同版本的系统，有 [ConnectivityManager.registerNetworkCallback]和注册广播两种实现方式；
 */
object NetworkListenerHelper {
    private val TAG = "NetworkListenerHelper"
    private var mContext: Context? = null

    @Volatile
    private var mListenerList: CopyOnWriteArrayList<NetworkConnectedListener>? = null

    /**
     * 注册网络状态的监听；
     */
    @SuppressLint("MissingPermission")
    fun registerNetworkListener() {
        when {
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.N -> {
                val connectivityManager =
                    mContext!!.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
                if (connectivityManager == null) {
                    LogUtils.el(
                        TAG,
                        "registerNetworkListener#return#connectivityManager=$connectivityManager"
                    )
                    return
                }
                connectivityManager.registerDefaultNetworkCallback(MyNetworkCallback())
            }
            Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP -> {
                val connectivityManager = mContext
                    .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
                if (connectivityManager == null) {
                    LogUtils.el(
                        TAG,
                        "registerNetworkListener#return#connectivityManager=$connectivityManager"
                    )
                    return
                }
                val builder: NetworkRequest.Builder
                builder = NetworkRequest.Builder()
                builder.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
                    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
                val networkRequest = builder.build()
                connectivityManager.registerNetworkCallback(networkRequest, MyNetworkCallback())
            }
            else -> {
                // 通过广播的方式监听网络；
                val mNetworkBroadcastReceiver = NetworkBroadcastReceiver()
                val filter = IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)
                mContext!!.registerReceiver(mNetworkBroadcastReceiver, filter)
                mNetworkBroadcastReceiver.setBroadcastCallback(object : NetworkBroadcastCallback {
                    override fun onNetworkBroadcastCallback(
                        isConnected: Boolean,
                        networkStatus: NetworkStatus?
                    ) {
                        //
                        notifyAllListeners(isConnected, networkStatus!!)
                    }
                })
            }
        }
    }

    /**
     * 通知所有接收者；
     *
     * @param isConnected
     * @param networkStatus
     */
    private fun notifyAllListeners(
        isConnected: Boolean,
        networkStatus: NetworkStatus
    ) {
        if (CollectionUtils.isNotEmpty(mListenerList)) {
//            mListenerList.stream().forEach(networkConnectedListener -> {
//                networkConnectedListener.onNetworkConnected(isConnected, networdStatus);
//            });
            for (listener in mListenerList!!) {
                listener?.onNetworkConnected(isConnected, networkStatus)
            }
        }
    }

    /**
     * 添加回调的监听者；
     */
    @Synchronized
    fun addListener(listener: NetworkConnectedListener?) {
        if (listener == null) {
            return
        }
        if (mListenerList == null) {
            mListenerList = CopyOnWriteArrayList()
        }
        // 防止重复添加；
        if (!mListenerList!!.contains(listener)) {
            mListenerList!!.add(listener)
        }
    }

    /**
     * 移除某个回调实例；
     *
     * @param listener
     */
    @Synchronized
    fun removeListener(listener: NetworkConnectedListener?) {
        if (listener != null && CollectionUtils.isNotEmpty(mListenerList)) {
            mListenerList!!.remove(listener)
        }
    }

    fun unregisterNetworkCallback() {
        if (mContext == null) {
            return
        }
        val connectivityManager = mContext
            .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        if (connectivityManager == null) {
            LogUtils.el(
                TAG,
                "registerNetworkListener#return#connectivityManager=$connectivityManager"
            )
            return
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            connectivityManager.unregisterNetworkCallback(NetworkCallback())
        }
    }

    interface NetworkConnectedListener {
        /**
         * @param isConnected
         * @param networkStatus
         */
        fun onNetworkConnected(
            isConnected: Boolean,
            networkStatus: NetworkStatus?
        )
    }

    @SuppressLint("NewApi") My
    private class MyNetworkCallback : NetworkCallback() {
        //当用户与网络连接（或断开连接）（可以是WiFi或蜂窝网络）时，这两个功能均作为默认回调;
        override fun onAvailable(network: Network) {
            super.onAvailable(network)
            LogUtils.d(TAG, "onAvailable#network=$network")
            // 需要同步获取一次网络状态；
            val netWorkState = getNetWorkState(mContext!!)
            LogUtils.d(TAG, "onAvailable#netWorkState=$netWorkState")
            //
            notifyAllListeners(true, netWorkState)
        }

        override fun onLost(network: Network) {
            super.onLost(network)
            LogUtils.d(TAG, "onLost#network=$network")
            // 需要同步获取一次网络状态；
            val netWorkState = getNetWorkState(mContext!!)
            LogUtils.d(TAG, "onLost#netWorkState=$netWorkState")
            //
            notifyAllListeners(false, netWorkState)
        }

        override fun onCapabilitiesChanged(
            network: Network,
            networkCapabilities: NetworkCapabilities
        ) {
            super.onCapabilitiesChanged(network, networkCapabilities)
            LogUtils.d(TAG, "onCapabilitiesChanged#network=$network")
            //            LogUtils.d(TAG, "onCapabilitiesChanged#network=" + network + ", networkCapabilities=" + networkCapabilities);
            // 表示能够和互联网通信（这个为true表示能够上网）
            if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
                when {
                    networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> {
                        LogUtils.d(TAG, "onCapabilitiesChanged#网络类型为wifi")
                    }
                    networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> {
                        LogUtils.d(TAG, "onCapabilitiesChanged#蜂窝网络")
                    }
                    else -> {
                        LogUtils.d(TAG, "onCapabilitiesChanged#其他网络")
                    }
                }
            }
        }
    }

    fun init(context: Context): NetworkListenerHelper {
        mContext = context
        return this
    }
}

MainActivity

package com.let.networkstatusmonitor

import android.os.Bundle
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import com.let.networkstatusmonitor.NetworkListenerHelper.NetworkConnectedListener

/**
 * @Author: let
 * @date: 2021/11/15 17:29
 * @description:
 */
class MainActivity : AppCompatActivity(), NetworkConnectedListener {
    private val TAG = "MainActivity"
    private var mTvResult: TextView? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        mTvResult = findViewById(R.id.tv_result)

        // 网络状态回调；
        NetworkListenerHelper.addListener(this@MainActivity)
    }


    override fun onDestroy() {
        super.onDestroy()
        NetworkListenerHelper.removeListener(this@MainActivity)
    }

    override fun onNetworkConnected(isConnected: Boolean, networkStatus: NetworkStatus?) {
        LogUtils.d(TAG, "onNetworkConnected#isConnected=$isConnected")
        val trim = mTvResult!!.text.toString()
        val status = networkStatus.status
        val desc = networkStatus.desc
        mTvResult!!.post { mTvResult!!.text = "\n网络变化通知：status=$status, desc=$desc\n$trim" }
    }
}

NetworkStatus

package com.let.networkstatusmonitor;

/**
 * @Author: let
 * @date: 2022/11/15 17:30
 * @description: 网络连接状态的枚举
 */
public enum NetworkStatus {

    /**
     * ；
     */
    NONE(-1, "无网络连接"),
    /**
     * 解析数据内容失败
     */
    MOBILE(0, "移动网络连接"),
    /**
     * 网络问题
     */
    WIFI(1, "WIFI连接");

    private int status;
    private String desc;

    NetworkStatus(int code, String msg) {
        this.status = code;
        this.desc = msg;
    }

    public int getStatus() {
        return status;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "NetwordStatus{" +
                "status=" + status +
                ", desc='" + desc + '\'' +
                "} " + super.toString();
    }
}

NetworkUtils

package com.let.networkstatusmonitor

import android.annotation.SuppressLint
import android.content.Context
import android.net.ConnectivityManager
import android.net.NetworkCapabilities
import android.os.Build

/**
 * @Author: let
 * @date: 2022/11/15 17:31
 * @description:
 */
object NetworkUtils {
    @JvmStatic
    @SuppressLint("MissingPermission")
    fun getNetWorkState(context: Context): NetworkStatus {
        return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            val connectivityManager =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val mobileNetInfo =
                connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
            val wifiNetInfo =
                connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
            if (mobileNetInfo != null && mobileNetInfo.isAvailable) {
                //WIFI和移动网络均未连接
                NetworkStatus.MOBILE
            } else if (wifiNetInfo != null && wifiNetInfo.isAvailable) {
                //WIFI和移动网络均未连接
                NetworkStatus.WIFI
            } else {
                NetworkStatus.NONE
            }
        } else {
            when {
                isMobileConnected(context) -> {
                    NetworkStatus.MOBILE
                }
                isWifiConnected(context) -> {
                    NetworkStatus.WIFI
                }
                else -> {
                    NetworkStatus.NONE
                }
            }
        }

//            //获取所有网络连接的信息
//            Network[] networks = connMgr.getAllNetworks();
//            //通过循环将网络信息逐个取出来
//            for (int i = 0; i < networks.length; i++) {
//                //获取ConnectivityManager对象对应的NetworkInfo对象
//                NetworkInfo networkInfo = connMgr.getNetworkInfo(networks[i]);
//                if (networkInfo.isConnected()) {
//                    if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
//                        return NetwordStatus.WIFI;
//                    } else if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
//                        return NetwordStatus.MOBILE;
//                    }
//                }
//            }
    }

    /**
     * 判断网络是否连接
     *
     * @param context
     * @return
     */
    @SuppressLint("MissingPermission")
    fun isOnline(context: Context?): Boolean {
        if (context == null) {
            return false
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            val connMgr =
                context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networkInfo = connMgr.activeNetworkInfo
            return networkInfo != null && networkInfo.isAvailable
        } else {
            val connectivityManager = context
                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeNetwork = connectivityManager.activeNetwork ?: return false
            val networkCapabilities =
                connectivityManager.getNetworkCapabilities(activeNetwork)
            if (networkCapabilities != null) {
                return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
            }
        }
        return false
    }

    @SuppressLint("MissingPermission")
    fun isWifiConnected(context: Context?): Boolean {
        if (context == null) {
            return false
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            val connectivityManager = context
                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networkInfo = connectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_WIFI)
            if (networkInfo != null) {
                return networkInfo.isAvailable
            }
        } else {
            val connectivityManager = context
                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeNetwork = connectivityManager.activeNetwork ?: return false
            val networkCapabilities =
                connectivityManager.getNetworkCapabilities(activeNetwork)
            if (networkCapabilities != null) {
                return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)
            }
        }
        return false
    }

    @SuppressLint("MissingPermission")
    fun isMobileConnected(context: Context?): Boolean {
        if (context == null) {
            return false
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            val connectivityManager = context
                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val networkInfo = connectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_MOBILE)
            if (networkInfo != null) {
                return networkInfo.isAvailable
            }
        } else {
            val connectivityManager = context
                .getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
            val activeNetwork = connectivityManager.activeNetwork ?: return false
            val networkCapabilities =
                connectivityManager.getNetworkCapabilities(activeNetwork)
            if (networkCapabilities != null) {
                return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)
            }
        }
        return false
    }
}
NetworkBroadcastReceiver
package com.let.networkstatusmonitor

import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.net.ConnectivityManager
import android.text.TextUtils

/**
 * @Author: let
 * @date: 2021/11/15 17:28
 * @description: 网络状态的监听广播
 */
class NetworkBroadcastReceiver : BroadcastReceiver() {
    private val TAG = "NetworkBroadcastReceiver"
    private var mBroadcastCallback: NetworkBroadcastCallback? = null
    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == null) {
            LogUtils.el(TAG, "onReceive#intent=$intent")
            return
        }
        val action = intent.action
        LogUtils.d(TAG, "onReceive#action=$action")
        if (TextUtils.equals(intent.action, ConnectivityManager.CONNECTIVITY_ACTION)) {
            // 申请权限；
//        if (!XXPermissions.isGrantedPermission(context, Permission.WRITE_EXTacERNAL_STORAGE,
//                Permission.READ_EXTERNAL_STORAGE)) {
//        }
//        NetworkInfo mobNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
//        NetworkInfo wifiNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
//        if (!mobNetInfo.isConnected() && !wifiNetInfo.isConnected()) {
//            //WIFI和移动网络均未连接
//            netContentListener.netContent(false);
//        } else {
//            //WIFI连接或者移动网络连接
//            netContentListener.netContent(true);
//        }
            val isOnline = NetworkUtils.isOnline(context)
            val networkStatus = NetworkUtils.getNetWorkState(context)
            LogUtils.d(TAG, "onReceive#isOnline=$isOnline, networdStatus=$networkStatus")
            if (mBroadcastCallback != null) {
                mBroadcastCallback!!.onNetworkBroadcastCallback(isOnline, networkStatus)
            }
        }
    }

    fun setBroadcastCallback(broadcastCallback: NetworkBroadcastCallback?) {
        mBroadcastCallback = broadcastCallback
    }

    interface NetworkBroadcastCallback {
        /**
         * 根据监听的结果返回连接状态和网络状态；
         *
         * @param isConnected
         * @param networkStatus
         */
        fun onNetworkBroadcastCallback(
            isConnected: Boolean,
            networkStatus: NetworkStatus?
        )
    }
}

ApplicationSupporter

package com.let.networkstatusmonitor

import android.app.Application

/**
 * @Author: let
 * @date: 2022/11/15 17:28
 * @description:
 */
class ApplicationSupporter : Application() {
    private val TAG = "ApplicationSupporter"
    override fun onCreate() {
        super.onCreate()
        instance = this
        BaseApplicationHelper.getInstance()
            .initApplicationContext(this)
        // 注册网络状态监听；
        NetworkListenerHelper.init(this).registerNetworkListener()
    }

    companion object {
        var instance: ApplicationSupporter? = null
    }
}

 

 

刻舟求jian
关注
专栏目录
Android 监听网络状态变化（无切换中间态版）
qq_17105113的博客
07-01 2620
ConnectivityManager#registerNetworkCallback() 是监听所有网络变换的，监听范围广，但无法得知当前“系统默认网络”是什么，可以实现判断网络状态，但无法判断网络类型。广播监听 与 ConnectivityManager#registerDefaultNetworkCallback() 都是监听“系统默认网络”，所以可以实现网络状态与类型的判断，但都存在重复回调的情况，所以要做过滤处理，以及“系统默认网络”切换到普通网络时会有偶现短暂“无网络”状态，需要做延迟处理。
android 监听网络状态的变化及实战
热门推荐
徐公，微信公众号同名
11-02 4万+
今天这篇博客主要阐述以下问题 怎样监听网络状态的变化，包括是否打开WiFi，否打开数据网络，当前连接的网络是否可用 网络没有打开情况下的处理,如弹出对话框，跳转到 打开 WiFi设置的界面等 非WiFi情况下是否 非WiFi情况下是否加载图片，是否播放视频等
Android 发送广播及监听接收
最新发布
wydaicls的博客
09-28 817
需求：写一个Demo，监听开机广播事件需要创建一个继承自的类，用于处理开机广播。
Android 实时监测（监听）网络连接状态变化
01-06
看了网上的很多，都不是自己想要的。所以自己就参考着写了一个。 实现这个的方法很多，我是想的这种，如果哪有不足，有bug的地方希望大家指出，共同进步。。。。 先简单说一下思路：网络变化时系统会发出广播。所以我们监听这个广播，利用接口回调通知activity做相应的操作就好了。。 步骤：            1、写个判断网络的工具类.            2、先写个类继承BroadcastReceiver。（不要忘记在清单文件中注册）           （谢谢ITzxl的提醒）需要在清单文件中添加权限<uses-permission android:name=”android.permis
Android 监听网络状态变化
徐师兄的博客
05-13 2263
Google在Android7.0时虽已对广播添加了限制，但是Android8.0后基于安全原因又一次加强了限制，且已声明：应用无法使用其清单的大部分隐式广播（即，并非专门针对此应用的广播）此注册方式即使退出应用后，仍然能够收到相应的广播。知道问题的原因之后的解决方案就简单了，既然CHANGE_NETWORK_STATE权限获取不到，那只好想办法打开WRITE_SETTINGS这个权限了。此处就是本文的核心内容了，网络的实时动态监听指的是全局实时监听网络状态，针对的对象非一个事件而是整个APP应用项目 ~
Android studio Kotlin kotlin-compiler-embeddable-1.6-M1.jar
02-24
otlin-compiler-embeddable-1.6-M1 下载慢 otlin-compiler-embeddable 下载慢 直接复制到 C:\Users\xxx\.gradle\caches\modules-2\files-2.1\org.jetbrains.kotlin\kotlin-compiler-embeddable\1.6.0-M1
Android-Awesome-kotlin-android一个很棒的KotlinAndroid项目包文件和其它资源的列表
08-13
本资源“Android-Awesome-kotlin-android”汇集了众多优秀的Kotlin在Android平台上的应用实例、库、工具和教程，旨在帮助开发者提升开发效率和代码质量。 首先，这个列表中的项目展示了Kotlin在Android开发中的最佳...
kotlin-compiler-1.9.22
05-06
此外，Kotlin还支持Android Jetpack库，提供了许多预构建的组件和最佳实践，简化了Android应用开发。 四、Kotlin与Java的比较 相比Java，Kotlin提供了更简洁的语法，减少了冗余代码。它的空安全特性、扩展函数、高...
Android使用BroadcastReceiver监听网络连接状态的改变
08-27
主要为大家详细介绍了Android使用BroadcastReceiver监听网络连接状态的改变，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android-Architecture-Components-Kotlin：用于练习Kotlin和Android体系结构组件的示例
02-04
本项目"Android-Architecture-Components-Kotlin"正是一个专门用于练习和理解这两种技术结合的实例，旨在帮助开发者更好地掌握Android开发的最佳实践。 首先，Kotlin是一种现代的、类型安全的编程语言，它为Java...
Android-Android-Kotlin-Clean-Architecture.zip
09-17
Android-Android-Kotlin-Clean-Architecture.zip,用kotlin编写的android示例清洁架构应用程序,安卓系统是谷歌在2008年设计和制造的。操作系统主要写在爪哇，C和C 的核心组件。它是在linux内核之上构建的，具有安全性...
Android 网络状态变化的监听
weixin_34106122的博客
02-14 155
1.在流量网页，时实现断网，提醒等功能。 　需要权限 <uses-permission android:name="android.permission.INTERNET"/> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> 2.注册一个BroadcastRe...
android监听网络变化
weixin_34233618的博客
03-28 258
class NetCheckReceiver extends BroadcastReceiver{ //android 中网络变化时所发的Intent的名字 public static final String netACTION = "android.net.conn.CONNECTIVITY_CHANGE"; ...
Android开发技巧：实时监听网络状态变化
陆业聪
07-20 1207
本文详细介绍了如何在Android应用中监听网络状态变化，包括创建广播接收器、动态注册广播接收器和处理网络变化事件。掌握这些技巧，可以帮助开发者更好地适应不同的网络环境，提升应用的用户体验。
Android 监听网络连接状态的改变 编程
CodeWWWCode的博客
09-27 275
在上述示例中，我们在MainActivity的onCreate()方法中创建了NetworkChangeReceiver的实例，并通过registerReceiver()方法将其注册为广播接收器。如今，移动设备的用户通常在使用Wi-Fi、移动数据网络或其他网络连接方式之间切换，因此及时了解网络连接状态的改变对于提供良好的用户体验至关重要。接下来，注册广播接收器。最后，根据你的需求，在网络连接状态改变时执行相应的操作。这样，当设备的网络连接状态发生改变时，你的应用程序将能够实时接收到通知，并执行相应的操作。
android studio download kotlin-gradle-plugin-
09-03
Android Studio下载kotlin-gradle-plugin可以通过以下步骤完成： 1. 打开Android Studio，确保已经连接到互联网。 2. 在欢迎界面，点击"配置"按钮。 3. 选择"设置"选项。 4. 在设置窗口中，选择"Build, Execution, Deployment"。 5. 在侧边栏中，点击"Gradle"选项。 6. 在右侧的"Gradle设置"部分，找到"Android Gradle Plugin版本"选项。 7. 下拉菜单中选择"Kotlin"选项，然后点击"Apply"按钮。 8. Android Studio将会下载所需的kotlin-gradle-plugin插件。 9. 下载完成后，点击"OK"按钮以关闭设置窗口。 10. 现在你可以在你的Android项目中使用Kotlin语言进行开发了。 请注意，下载kotlin-gradle-plugin可能需要一些时间，具体取决于你的互联网连接速度。确保在下载过程中不要中断互联网连接，以免导致下载失败。 希望这个回答对你有所帮助！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值