与Kotlin的Android网络信号

Question

我有一个问题，必须在应用程序中显示信号强度。就像我们的移动塔以较差的信号强度显示塔一样，它仅显示一个塔，并显示出良好的信号强度，它也显示了所有塔。

以同样的方式，我还想计算信号强度。

谢谢

Answer 1

您可以使用电话状态侦听器，从而为您提供信号强度。首先，在全球定义。

var telephonyManager: TelephonyManager? = null
var psListener: MyPhoneStateListener? = null

然后初始化电话管理器并聆听网络中的更改。

psListener = MyPhoneStateListener()
            telephonyManager = requireActivity().getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
            telephonyManager!!.listen(psListener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS)

创建了扩展PhonEstateListener的类后，您可以将此类作为Kotlin的内心。如下下方，

inner  class MyPhoneStateListener : PhoneStateListener() {
            var signalSupport = 0
            override fun onSignalStrengthsChanged(signalStrength: SignalStrength) {
                super.onSignalStrengthsChanged(signalStrength)
    
                if (signalStrength.isGsm()) {
                    signalSupport = signalStrength.gsmSignalStrength
                    Log.d("signal", "------ gsm signal --> $signalSupport")
                    if (signalSupport > 30) {
                        Log.d("signal", "Signal GSM : Good")
                    } else if (signalSupport in 21..29) {
                        Log.d("signal", "Signal GSM : Avarage")
                    } else if (signalSupport in 4..19) {
                        Log.d("signal", "Signal GSM : Weak")
                    } else if (signalSupport < 3) {
                        Log.d("signal", "Signal GSM : Very weak")
                    }
                } else {
                    signalSupport = signalStrength.getCdmaDbm();
                }
                signalStrengthValue = signalSupport.toString()
            }
        }

该信号强度值变量是持有信号强度的数据

Answer 2

改编自一些来源 [1] [2] [3] （也 uservani 和 ramesh r 的答案上述），我认为这也将使用较新的Android版本。我只在模拟器上对此进行了测试，因此，如果有人在物理设备上部署在方法论或任何问题上的任何缺陷，请随时提议编辑或澄清评论中的某些内容。

首先，我们创建一个专门确定信号强度的课程：

@file:Suppress("DEPRECATION") //<-- Otherwise You'll Probably Get Warnings For The Pre-"Android Snow Cone" Section
package com.example.YOUR_PROJECT_NAME_HERE

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.os.Build
import android.telephony.CellInfo
import android.telephony.PhoneStateListener
import android.telephony.SignalStrength
import android.telephony.TelephonyManager
import androidx.core.app.ActivityCompat

class ClassSignalStrength (private val mvContext : Context) {
    private val mvTelephonyManager = mvContext.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
    private var mvTechnology = ""
    private var mvSignalStrengthDbm = 0 //<-- Initialize
    init {
        //Get Signal Strength Data (Pre-"Android Snow Cone")
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
                mvTelephonyManager.listen(object : PhoneStateListener() {
                    @Deprecated("Deprecated in Java")
                    override fun onSignalStrengthsChanged(mvSignalStrength: SignalStrength) {
                        super.onSignalStrengthsChanged(mvSignalStrength)
                        mvTechnology = if (mvSignalStrength.isGsm) "GSM" else "CDMA"
                        mvSignalStrengthDbm = if (mvTechnology == "GSM") {
                                                  2 * mvSignalStrength.gsmSignalStrength - 113 //Convert ASU To dBm
                                              } else {
                                                  mvSignalStrength.cdmaDbm //<-- Should Already Be Converted To dBm
                                              }
                    }
                }, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS)
            }
    }
    fun mmGetSignalStrength()
    {
        //Get Signal Strength
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                //Get Signal Strength Data (Android Snow Cone+)
                //Note: The Following Requests An Up-To-Date Rundown Of The Cell Info
                if (ActivityCompat.checkSelfPermission(mvContext, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
                    //Note: requestCellInfoUpdate()'s Updates Are Rate-Limited, Please Be Advised
                        mvTelephonyManager.requestCellInfoUpdate(mvContext.mainExecutor, object : TelephonyManager.CellInfoCallback() {
                            override fun onCellInfo(mvCellInfoList: MutableList<CellInfo>) {
                                mmParseSignalStrength(mvCellInfoList)
                            }
                        })
                }
            }
            else {
                //Alert User To The Status
                //(Explanation: Pre-"Android Snow Cone", The Listener (Which We Declared In The init Block) Should Already Be Updating This Info Automatically)
                    mmShowUser()
            }
    }
    private fun mmParseSignalStrength(mvCellInfoList : MutableList<CellInfo>)
    {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
        {
            //Find The Minimum Signal Strength Value Of All Returned Instances
                mvSignalStrengthDbm = 1000000 //<- Create A Large Value To Begin With So We Have A Point Of Reference For Choosing The Next Minimum
                for (mvCellInfo in mvCellInfoList) {
                    if (mvCellInfo.cellSignalStrength.dbm < mvSignalStrengthDbm) {
                        mvSignalStrengthDbm = mvCellInfo.cellSignalStrength.dbm
                        mvTechnology = mvCellInfo.javaClass.kotlin.toString()
                    }
                }
            //Alert User As To The Status
                mmShowUser()
        }
    }
    private fun mmShowUser()
    {
        //How's The Signal?
            val mvSignalQuality= if (mvSignalStrengthDbm < -120) {
                                    "Very Low"
                                 } else if (mvSignalStrengthDbm <= -100) {
                                    "Low"
                                 } else if (mvSignalStrengthDbm <= -90) {
                                    "Normal"
                                 } else if (mvSignalStrengthDbm < 0) {
                                    "Above Average"
                                 } else {
                                    "No Signal Information" //<-- This Condition Can Be Simulated By Turning On "Airplane Mode" In The Emulator, But Only For Snowcone+ (Pre-Snowcone, Emulators Do Seem To Change To Signal Strength 0 IFF The Emulator Is Cold Booted In Airplane Mode. Incidentally, dBm Of 0 Is Likewise Just About The Theoretical Asymptote Of Signal Strength, Hence Why We Consider Anything 0 Or Higher To Be The "No Information" State - Source: https://www.reddit.com/r/HomeNetworking/comments/17kq3nz/the_highest_possible_rssi_for_lte/)
                                 }
            println("Signal: $mvSignalStrengthDbm ($mvSignalQuality) [$mvTechnology]")
    }
}

其次，我们在需要时请求此信息：

private val mvClassSignalStrength = ClassSignalStrength(applicationContext)
…
mvClassSignalStrength.mmGetSignalStrength()