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

Swuagg2025-11-07 8:20

目录

[📂 前言](#📂 前言)

[AR 眼镜之-蓝牙电话-实现方案](#AR 眼镜之-蓝牙电话-实现方案)

[AR 眼镜系统版本](#AR 眼镜系统版本)

[Android 手机系统版本](#Android 手机系统版本)

[1. 🔱 技术方案](#1. 🔱 技术方案)

[1.1 结构框图](#1.1 结构框图)

[1.2 方案介绍](#1.2 方案介绍)

[1.3 实现方案](#1.3 实现方案)

[步骤一：手机 App 申请权限](#步骤一：手机 App 申请权限)

[步骤二：手机来电状态监听并推送给 AR 眼镜](#步骤二：手机来电状态监听并推送给 AR 眼镜)

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

[步骤四：手机 App 执行挂断/接听操作](#步骤四：手机 App 执行挂断/接听操作)

[2. ⚛️ 自定义电话实现](#2. ⚛️ 自定义电话实现)

[2.1 自定义电话时序图](#2.1 自定义电话时序图)

[2.2 实现细节](#2.2 实现细节)

[1、手机 App 申请权限](#1、手机 App 申请权限)

[2、手机来电状态监听并推送给 AR 眼镜](#2、手机来电状态监听并推送给 AR 眼镜)

3、查询最近来电信息

[4、手机 App 执行挂断/接听操作](#4、手机 App 执行挂断/接听操作)

[5、API 监听电话状态调用](#5、API 监听电话状态调用)

[3. 💠 来电实现帮助类 TelephonyManagerHelper](#3. 💠 来电实现帮助类 TelephonyManagerHelper)

[4. ✅ 小结](#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
    }

    /** 挂断兜底方法，通过输入 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 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. ✅ 小结

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

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

相关推荐
Eric.Lee20211 年前
2024 Snap 新款ar眼镜介绍
人工智能·ar·ar 眼镜·手势交互
Swuagg1 年前
AR 眼镜之-蓝牙电话-实现方案
ar 眼镜·蓝牙电话·hfp
热门推荐
01GitHub 镜像站点02综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件03UV安装并设置国内源04Linux下V2Ray安装配置指南05npm使用国内淘宝镜像的方法06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07BongoCat - 跨平台键盘猫动画工具08《大数据技术原理与应用》实验报告三 熟悉HBase常用操作09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程