AR 眼镜之-普通电话-实现方案

目录

📂 前言

AR 眼镜之-蓝牙电话-实现方案

AR 眼镜系统版本

Android 手机系统版本

1. 🔱 技术方案

1.1 结构框图

1.2 方案介绍

1.3 实现方案

步骤一：手机 App 申请权限

步骤二：手机来电状态监听并推送给 AR 眼镜

步骤三：AR 眼镜显示来电信息并操作挂断/接听

步骤四：手机 App 执行挂断/接听操作

2. ⚛️ 自定义电话实现

2.1 自定义电话时序图

2.2 实现细节

1、手机 App 申请权限

2、手机来电状态监听并推送给 AR 眼镜

3、查询最近来电信息

4、手机 App 执行挂断/接听操作

5、API 监听电话状态调用

3. 💠 来电实现帮助类 TelephonyManagerHelper

4. ✅ 小结

📂 前言

AR 眼镜之-蓝牙电话-实现方案

AR 眼镜之-蓝牙电话-实现方案

AR 眼镜系统版本

        FreeRTOS。

Android 手机系统版本

        Android 15。

1. 🔱 技术方案

1.1 结构框图

1.2 方案介绍

• 主要通过 BLE 定义私有协议，实现手机来电状态监听并推送给 AR 眼镜显示、以及在眼镜上实现接听和挂断电话的功能；

• 与 BT 蓝牙电话不同的是，BLE 只能实现电话显示和控制功能，不能将通话音频传给 AR 眼镜，所以用户如果要接听电话，则需要通过手机扬声器或其他蓝牙耳机进行音频输出。

1.3 实现方案

步骤一：手机 App 申请权限

        申请手机来电状态权限 READ_PHONE_STATE、获取手机来电号码权限 READ_CALL_LOG、查询联系人名字权限 READ_CONTACTS、以及接/挂电话权限 ANSWER_PHONE_CALLS；

步骤二：手机来电状态监听并推送给 AR 眼镜

1. 手机 App 监听到来电后，查询来电信息，包括：来电的电话号码以及联系人名字；

2. 通过 BLE 定义的私有协议，将来电的电话号码以及联系人名字，推送给 AR 眼镜。

步骤三：AR 眼镜显示来电信息并操作挂断/接听

1. RTOS AR 眼镜收到 BLE 私有协议命令后，调起来电 UI 界面，显示来电电话号码和名字；

2. AR 眼镜将用户挂断或接听电话的操作，通过 BLE 命令发给手机 App。

步骤四：手机 App 执行挂断/接听操作

        手机 App 收到挂断/接听命令后，调用系统电话的挂断/接听接口。

2. ⚛️ 自定义电话实现

2.1 自定义电话时序图

2.2 实现细节

1、手机 App 申请权限

        1）在 Manifest 中申明权限

        申请手机来电状态权限 READ_PHONE_STATE、获取手机来电号码权限 READ_CALL_LOG、查询联系人名字权限 READ_CONTACTS、以及接/挂电话权限 ANSWER_PHONE_CALLS。

    <!--Phone Call Start-->
    <!--手机来电状态-->
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <!--获取手机来电号码-->
    <uses-permission android:name="android.permission.READ_CALL_LOG" />
    <!--查询联系人名字-->
    <uses-permission android:name="android.permission.READ_CONTACTS" />
    <!--接/挂电话-->
    <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
    <!--Phone Call End-->

        2）检查权限

        如果权限缺失会发起请求，并在 Activity 的 onRequestPermissionsResult 中调用权限授予结果；否则，直接启动手机来电状态监听。

    private const val PERMISSIONS_REQUEST_CODE = 1000
    private val permissions = arrayOf(
        Manifest.permission.READ_PHONE_STATE,
        Manifest.permission.READ_CALL_LOG,
        Manifest.permission.READ_CONTACTS,
        Manifest.permission.ANSWER_PHONE_CALLS
    )
    private var applicationContext: Context? = null


    /** 检查权限，如果缺失会发起请求，否则直接启动监听 */
    fun checkPermissionsAndStart(context: Activity) {
        applicationContext = context.applicationContext
        val missingPermissions = permissions.filter {
            ContextCompat.checkSelfPermission(context, it) != PackageManager.PERMISSION_GRANTED
        }
        if (missingPermissions.isNotEmpty()) {
            ActivityCompat.requestPermissions(
                context, missingPermissions.toTypedArray(), PERMISSIONS_REQUEST_CODE
            )
        } else {
            startListener(context)
        }
    }

    /** 在 Activity 的 onRequestPermissionsResult 中调用 */
    fun onRequestPermissionsResult(requestCode: Int, grantResults: IntArray, context: Activity) {
        if (requestCode == PERMISSIONS_REQUEST_CODE) {
            if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                startListener(context)
            } else {
                Toast.makeText(
                    context,
                    "Phone, call log, and call answer permissions are needed.",
                    Toast.LENGTH_LONG
                ).show()
            }
        }
    }

2、手机来电状态监听并推送给 AR 眼镜

1. 手机 App 监听到来电后，查询来电信息，包括：来电的电话号码以及联系人名字；

2. 通过 BLE 定义的私有协议，将来电的电话号码以及联系人名字，推送给 AR 眼镜。

    private var telephonyManager: TelephonyManager? = null

    private val mPhoneListener = object : PhoneStateListener() {
        override fun onCallStateChanged(state: Int, phoneNumber: String?) {
            super.onCallStateChanged(state, phoneNumber)
            when (state) {
                TelephonyManager.CALL_STATE_IDLE -> {
                    // 在注册监听的时候就会走一次回调，后面通话状态改变时也会走，如：在启动服务时如果手机没有通话相关动作，就会直接走一次TelephonyManager.CALL_STATE_IDLE。
                    Log.i(TAG, "onCallStateChanged: 挂断 $phoneNumber")
                }

                TelephonyManager.CALL_STATE_OFFHOOK -> {
                    Log.i(TAG, "onCallStateChanged: 接听 $phoneNumber")
                }

                TelephonyManager.CALL_STATE_RINGING -> {
                    Log.i(TAG, "onCallStateChanged: 响铃 $phoneNumber")

                    Log.e(TAG, "${getIncomingCallInfo(applicationContext?.contentResolver)}")
                }
            }
        }
    }

    /** 启动电话状态监听 */
    private fun startListener(context: Context) {
        Log.i(TAG, "startListener: ")
        telephonyManager =
            context.applicationContext.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
        telephonyManager?.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE)
    }
    
    /** 停止监听 */
    fun stopListener() {
        Log.i(TAG, "stopListener: ")
        telephonyManager?.listen(mPhoneListener, PhoneStateListener.LISTEN_NONE)
    }

3、查询最近来电信息

    data class CallInfo(val number: String, val name: String = "")

    private fun getIncomingCallInfo(contentResolver: ContentResolver?): CallInfo? {
        var phoneNumber: String? = null
        var contactName = ""
        var cursor: Cursor? = null
        var nameCursor: Cursor? = null

        try {
            if (contentResolver != null) {
                // 查询最近一次来电号码
                cursor = contentResolver.query(
                    CallLog.Calls.CONTENT_URI,
                    arrayOf(CallLog.Calls.NUMBER),
                    "${CallLog.Calls.TYPE} = ${CallLog.Calls.INCOMING_TYPE}",
                    null,
                    "${CallLog.Calls.DATE} DESC"
                )
                cursor?.use {
                    if (it.moveToFirst()) {
                        phoneNumber = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
                    }
                }

                // 查询联系人名字
                if (!phoneNumber.isNullOrEmpty()) {
                    val uri: Uri = Uri.withAppendedPath(
                        ContactsContract.PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phoneNumber)
                    )
                    nameCursor = contentResolver.query(
                        uri, arrayOf(ContactsContract.PhoneLookup.DISPLAY_NAME), null, null, null
                    )
                    nameCursor?.use {
                        if (it.moveToFirst()) {
                            contactName =
                                it.getString(it.getColumnIndexOrThrow(ContactsContract.PhoneLookup.DISPLAY_NAME))
                        }
                    }
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            cursor?.close()
            nameCursor?.close()
        }

        return phoneNumber?.let { CallInfo(it, contactName) }
    }

4、手机 App 执行挂断/接听操作

        手机 App 收到挂断/接听命令后，调用系统电话的挂断/接听接口。

        1）接听电话

    /** 接听电话，内部自动检查权限 */
    fun answerCall(context: Context) {
        Log.i(TAG, "answerCall: ")
        if (ContextCompat.checkSelfPermission(
                context, Manifest.permission.ANSWER_PHONE_CALLS
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            try {
                (context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager).acceptRingingCall()
            } catch (e: Exception) {
                Log.e(TAG, "answerCall: 接听电话失败: ${e.message}")
            }
        } else {
            Log.e(TAG, "answerCall: 缺少 ANSWER_PHONE_CALLS 权限，无法接听!")
        }
    }

        2）挂断电话

    /** 挂断电话，内部自动检查权限 */
    fun endCall(context: Context): Boolean {
        Log.i(TAG, "endCall: ")
        var callSuccess = false
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                if (ActivityCompat.checkSelfPermission(
                        context, Manifest.permission.ANSWER_PHONE_CALLS
                    ) == PackageManager.PERMISSION_GRANTED
                ) {
                    (context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager).endCall()
                    callSuccess = true
                } else {
                    Log.e(TAG, "endCall: 缺少 ANSWER_PHONE_CALLS 权限，无法挂断!")
                }
            } else {
                val tm = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
                val m: Method = Class.forName(tm.javaClass.name).getDeclaredMethod("getITelephony")
                m.isAccessible = true
                val telephonyService: ITelephony = m.invoke(tm) as ITelephony
                callSuccess = telephonyService.endCall()
                Log.i(TAG, "endCall: 挂断电话成功 (低版本)!")
            }
        } catch (e: Exception) {
            Log.e(TAG, "endCall: ${e.printStackTrace()}")
            callSuccess = disconnectCall()
            e.printStackTrace()
        }
        return callSuccess
    }

        3）挂断电话（Android 9以下版本）

internal interface ITelephony {
    fun endCall(): Boolean
    fun answerRingingCall()
    fun silenceRinger()
}

         4）挂断电话（KeyEvent 兜底方案）

    /** 挂断兜底方法，通过输入 keyevent */
    private fun disconnectCall(): Boolean {
        return try {
            Log.i(TAG, "disconnectCall: input keyevent " + KeyEvent.KEYCODE_ENDCALL)
            Runtime.getRuntime().exec("input keyevent " + KeyEvent.KEYCODE_ENDCALL.toString())
            true
        } catch (e: Exception) {
            Log.e(TAG, "disconnectCall: ${e.printStackTrace()}")
            false
        }
    }

5、API 监听电话状态调用

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    // 启动电话监听（会自动检查权限）
    TelephonyManagerHelper.checkPermissionsAndStart(this)
}

override fun onRequestPermissionsResult(
    requestCode: Int, permissions: Array<out String>, grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    TelephonyManagerHelper.onRequestPermissionsResult(requestCode, grantResults, this)
}

override fun onDestroy() {
    super.onDestroy()

    // 停止电话监听，释放资源
    TelephonyManagerHelper.stopListener()
}

// 示例：来电时接听
fun answerIncomingCall() {
    TelephonyManagerHelper.answerCall(this)
}

// 示例：挂断电话
fun hangupCall() {
    TelephonyManagerHelper.endCall(this)
}

3. 💠 来电实现帮助类 TelephonyManagerHelper

object TelephonyManagerHelper {

    data class CallInfo(val number: String, val name: String = "")

    private val TAG = TelephonyManagerHelper::class.java.simpleName
    private const val PERMISSIONS_REQUEST_CODE = 1000
    private val permissions = arrayOf(
        Manifest.permission.READ_PHONE_STATE,
        Manifest.permission.READ_CALL_LOG,
        Manifest.permission.READ_CONTACTS,
        Manifest.permission.ANSWER_PHONE_CALLS
    )
    private var applicationContext: Context? = null
    private var telephonyManager: TelephonyManager? = null

    private val mPhoneListener = object : PhoneStateListener() {
        override fun onCallStateChanged(state: Int, phoneNumber: String?) {
            super.onCallStateChanged(state, phoneNumber)
            when (state) {
                TelephonyManager.CALL_STATE_IDLE -> {
                    // 在注册监听的时候就会走一次回调，后面通话状态改变时也会走，如：在启动服务时如果手机没有通话相关动作，就会直接走一次TelephonyManager.CALL_STATE_IDLE。
                    Log.i(TAG, "onCallStateChanged: 挂断 $phoneNumber")
                }

                TelephonyManager.CALL_STATE_OFFHOOK -> {
                    Log.i(TAG, "onCallStateChanged: 接听 $phoneNumber")
                }

                TelephonyManager.CALL_STATE_RINGING -> {
                    Log.i(TAG, "onCallStateChanged: 响铃 $phoneNumber")

                    Log.e(TAG, "${getIncomingCallInfo(applicationContext?.contentResolver)}")
                }
            }
        }
    }

    /** 检查权限，如果缺失会发起请求，否则直接启动监听 */
    fun checkPermissionsAndStart(context: Activity) {
        applicationContext = context.applicationContext
        val missingPermissions = permissions.filter {
            ContextCompat.checkSelfPermission(context, it) != PackageManager.PERMISSION_GRANTED
        }
        if (missingPermissions.isNotEmpty()) {
            ActivityCompat.requestPermissions(
                context, missingPermissions.toTypedArray(), PERMISSIONS_REQUEST_CODE
            )
        } else {
            startListener(context)
        }
    }

    /** 在 Activity 的 onRequestPermissionsResult 中调用 */
    fun onRequestPermissionsResult(requestCode: Int, grantResults: IntArray, context: Activity) {
        if (requestCode == PERMISSIONS_REQUEST_CODE) {
            if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                startListener(context)
            } else {
                Toast.makeText(
                    context,
                    "Phone, call log, and call answer permissions are needed.",
                    Toast.LENGTH_LONG
                ).show()
            }
        }
    }

    /** 启动电话状态监听 */
    private fun startListener(context: Context) {
        Log.i(TAG, "startListener: ")
        telephonyManager =
            context.applicationContext.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
        telephonyManager?.listen(mPhoneListener, PhoneStateListener.LISTEN_CALL_STATE)
    }

    /** 停止监听 */
    fun stopListener() {
        Log.i(TAG, "stopListener: ")
        telephonyManager?.listen(mPhoneListener, PhoneStateListener.LISTEN_NONE)
    }

    /** 接听电话，内部自动检查权限 */
    fun answerCall(context: Context) {
        Log.i(TAG, "answerCall: ")
        if (ContextCompat.checkSelfPermission(
                context, Manifest.permission.ANSWER_PHONE_CALLS
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            try {
                (context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager).acceptRingingCall()
            } catch (e: Exception) {
                Log.e(TAG, "answerCall: 接听电话失败: ${e.message}")
            }
        } else {
            Log.e(TAG, "answerCall: 缺少 ANSWER_PHONE_CALLS 权限，无法接听!")
        }
    }

    /** 挂断电话，内部自动检查权限 */
    fun endCall(context: Context): Boolean {
        Log.i(TAG, "endCall: ")
        var callSuccess = false
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                if (ActivityCompat.checkSelfPermission(
                        context, Manifest.permission.ANSWER_PHONE_CALLS
                    ) == PackageManager.PERMISSION_GRANTED
                ) {
                    (context.getSystemService(Context.TELECOM_SERVICE) as TelecomManager).endCall()
                    callSuccess = true
                } else {
                    Log.e(TAG, "endCall: 缺少 ANSWER_PHONE_CALLS 权限，无法挂断!")
                }
            } else {
                val tm = context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
                val m: Method = Class.forName(tm.javaClass.name).getDeclaredMethod("getITelephony")
                m.isAccessible = true
                val telephonyService: ITelephony = m.invoke(tm) as ITelephony
                callSuccess = telephonyService.endCall()
                Log.i(TAG, "endCall: 挂断电话成功 (低版本)!")
            }
        } catch (e: Exception) {
            Log.e(TAG, "endCall: ${e.printStackTrace()}")
            callSuccess = disconnectCall()
            e.printStackTrace()
        }
        return callSuccess
    }

    /** 挂断兜底方法，通过输入 keyevent */
    private fun disconnectCall(): Boolean {
        return try {
            Log.i(TAG, "disconnectCall: input keyevent " + KeyEvent.KEYCODE_ENDCALL)
            Runtime.getRuntime().exec("input keyevent " + KeyEvent.KEYCODE_ENDCALL.toString())
            true
        } catch (e: Exception) {
            Log.e(TAG, "disconnectCall: ${e.printStackTrace()}")
            false
        }
    }

    /** 查询最近来电信息 */
    private fun getIncomingCallInfo(contentResolver: ContentResolver?): CallInfo? {
        var phoneNumber: String? = null
        var contactName = ""
        var cursor: Cursor? = null
        var nameCursor: Cursor? = null

        try {
            if (contentResolver != null) {
                // 查询最近一次来电号码
                cursor = contentResolver.query(
                    CallLog.Calls.CONTENT_URI,
                    arrayOf(CallLog.Calls.NUMBER),
                    "${CallLog.Calls.TYPE} = ${CallLog.Calls.INCOMING_TYPE}",
                    null,
                    "${CallLog.Calls.DATE} DESC"
                )
                cursor?.use {
                    if (it.moveToFirst()) {
                        phoneNumber = it.getString(it.getColumnIndexOrThrow(CallLog.Calls.NUMBER))
                    }
                }

                // 查询联系人名字
                if (!phoneNumber.isNullOrEmpty()) {
                    val uri: Uri = Uri.withAppendedPath(
                        ContactsContract.PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phoneNumber)
                    )
                    nameCursor = contentResolver.query(
                        uri, arrayOf(ContactsContract.PhoneLookup.DISPLAY_NAME), null, null, null
                    )
                    nameCursor?.use {
                        if (it.moveToFirst()) {
                            contactName =
                                it.getString(it.getColumnIndexOrThrow(ContactsContract.PhoneLookup.DISPLAY_NAME))
                        }
                    }
                }
            }
        } catch (e: Exception) {
            e.printStackTrace()
        } finally {
            cursor?.close()
            nameCursor?.close()
        }

        return phoneNumber?.let { CallInfo(it, contactName) }
    }

}

4. ✅ 小结

        对于手机来电显示以及接听/挂断这块，本文只是一个基础实现方案，更多业务细节请参考产品逻辑去实现。

        另外，由于本人能力有限，如有错误，敬请批评指正，谢谢。