基于Linphone android sdk开发Android软话机

这篇具有很好参考价值的文章主要介绍了基于Linphone android sdk开发Android软话机。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

org.linphone:linphone-sdk-android,Android,android,音视频

1.Linphone简介

1.1 简介

LinPhone是一个遵循GPL协议的开源网络电话或者IP语音电话(VOIP)系统,其主要如下。使用linphone,开发者可以在互联网上随意的通信,包括语音、视频、即时文本消息。linphone使用SIP协议,是一个标准的开源网络电话系统,能将linphone与任何基于SIP的VoIP运营商连接起来,包括我们自己开发的免费的基于SIP的Audio/Video服务器。

LinPhone是一款自由软件(或者开源软件),你可以随意的下载和在LinPhone的基础上二次开发。LinPhone是可用于Linux, Windows, MacOSX 桌面电脑以及Android, iPhone, Blackberry移动设备。

学习LinPhone的源码,开源从以下几个部分着手: Java层框架实现的SIP三层协议架构: 传输层,事务层,语法编解码层; linphone动态库C源码实现的SIP功能: 注册,请求,请求超时,邀请会话,挂断电话,邀请视频,收发短信... linphone动态库C源码实现的音视频编解码功能; Android平台上的音视频捕获,播放功能;

1.2 基本使用

如果是Android系统用户,可以从谷歌应用商店安装或者从这个链接下载Linphone 。安装完成后,点击左上角的菜单按钮,选择进入助手界面。在助手界面,可以设定SIP账户或者Linphone账号,如下图:图片来自网路
org.linphone:linphone-sdk-android,Android,android,音视频

org.linphone:linphone-sdk-android,Android,android,音视频 

2.基于linphone android sdk开发linphone

  • 引入sdk依赖 

dependencies {
    //linphone
    debugImplementation "org.linphone:linphone-sdk-android-debug:5.0.0"
    releaseImplementation "org.linphone:linphone-sdk-android:5.0.0"

为了方便调用,我们需要对Linphone进行简单的封装。首先,按照官方文档的介绍,创建一个CoreManager类,此类是sdk里面的管理类,用来控制来电铃声和启动CoreService,无特殊需求不需调用。需要注意的是,启动来电铃声需要导入media包,否则不会有来电铃声,如下

implementation 'androidx.media:media:1.2.0'
  • 基本代码开发 
package com.matt.linphonelibrary.core

import android.annotation.SuppressLint
import android.content.Context
import android.os.Handler
import android.os.Looper
import android.telephony.PhoneStateListener
import android.telephony.TelephonyManager
import android.util.Log
import android.view.TextureView
import com.matt.linphonelibrary.R
import com.matt.linphonelibrary.callback.PhoneCallback
import com.matt.linphonelibrary.callback.RegistrationCallback
import com.matt.linphonelibrary.utils.AudioRouteUtils
import com.matt.linphonelibrary.utils.LinphoneUtils
import com.matt.linphonelibrary.utils.VideoZoomHelper
import org.linphone.core.*
import java.io.File
import java.util.*


class LinphoneManager private constructor(private val context: Context) {
    private val TAG = javaClass.simpleName

    private var core: Core
    private var corePreferences: CorePreferences
    private var coreIsStart = false
    var registrationCallback: RegistrationCallback? = null
    var phoneCallback: PhoneCallback? = null


    init {
        //日志收集
        Factory.instance().setLogCollectionPath(context.filesDir.absolutePath)
        Factory.instance().enableLogCollection(LogCollectionState.Enabled)

        corePreferences = CorePreferences(context)
        corePreferences.copyAssetsFromPackage()
        val config = Factory.instance().createConfigWithFactory(
            corePreferences.configPath,
            corePreferences.factoryConfigPath
        )
        corePreferences.config = config

        val appName = context.getString(R.string.app_name)
        Factory.instance().setDebugMode(corePreferences.debugLogs, appName)

        core = Factory.instance().createCoreWithConfig(config, context)
    }

    private var previousCallState = Call.State.Idle

    private val coreListener = object : CoreListenerStub() {
        override fun onGlobalStateChanged(core: Core, state: GlobalState?, message: String) {
            if (state === GlobalState.On) {
            }
        }

        //登录状态回调
        override fun onRegistrationStateChanged(
            core: Core,
            cfg: ProxyConfig,
            state: RegistrationState,
            message: String
        ) {
            when (state) {
                RegistrationState.None -> registrationCallback?.registrationNone()
                RegistrationState.Progress -> registrationCallback?.registrationProgress()
                RegistrationState.Ok -> registrationCallback?.registrationOk()
                RegistrationState.Cleared -> registrationCallback?.registrationCleared()
                RegistrationState.Failed -> registrationCallback?.registrationFailed()
            }
        }

        //电话状态回调
        override fun onCallStateChanged(
            core: Core,
            call: Call,
            state: Call.State,
            message: String
        ) {
            Log.i(TAG, "[Context] Call state changed [$state]")

            when (state) {
                Call.State.IncomingReceived, Call.State.IncomingEarlyMedia -> {
                    if (gsmCallActive) {
                        Log.w(
                            TAG,
                            "[Context] Refusing the call with reason busy because a GSM call is active"
                        )
                        call.decline(Reason.Busy)
                        return
                    }

                    phoneCallback?.incomingCall(call)
                    gsmCallActive = true

                    //自动接听
                    if (corePreferences.autoAnswerEnabled) {
                        val autoAnswerDelay = corePreferences.autoAnswerDelay
                        if (autoAnswerDelay == 0) {
                            Log.w(TAG, "[Context] Auto answering call immediately")
                            answerCall(call)
                        } else {
                            Log.i(
                                TAG,
                                "[Context] Scheduling auto answering in $autoAnswerDelay milliseconds"
                            )
                            val mainThreadHandler = Handler(Looper.getMainLooper())
                            mainThreadHandler.postDelayed({
                                Log.w(TAG, "[Context] Auto answering call")
                                answerCall(call)
                            }, autoAnswerDelay.toLong())
                        }
                    }
                }

                Call.State.OutgoingInit -> {
                    phoneCallback?.outgoingInit(call)
                    gsmCallActive = true
                }

                Call.State.OutgoingProgress -> {
                    if (core.callsNb == 1 && corePreferences.routeAudioToBluetoothIfAvailable) {
                        AudioRouteUtils.routeAudioToBluetooth(core, call)
                    }
                }

                Call.State.Connected -> phoneCallback?.callConnected(call)

                Call.State.StreamsRunning -> {
                    // Do not automatically route audio to bluetooth after first call
                    if (core.callsNb == 1) {
                        // Only try to route bluetooth / headphone / headset when the call is in StreamsRunning for the first time
                        if (previousCallState == Call.State.Connected) {
                            Log.i(
                                TAG,
                                "[Context] First call going into StreamsRunning state for the first time, trying to route audio to headset or bluetooth if available"
                            )
                            if (AudioRouteUtils.isHeadsetAudioRouteAvailable(core)) {
                                AudioRouteUtils.routeAudioToHeadset(core, call)
                            } else if (corePreferences.routeAudioToBluetoothIfAvailable && AudioRouteUtils.isBluetoothAudioRouteAvailable(
                                    core
                                )
                            ) {
                                AudioRouteUtils.routeAudioToBluetooth(core, call)
                            }
                        }
                    }

                    if (corePreferences.routeAudioToSpeakerWhenVideoIsEnabled && call.currentParams.videoEnabled()) {
                        // Do not turn speaker on when video is enabled if headset or bluetooth is used
                        if (!AudioRouteUtils.isHeadsetAudioRouteAvailable(core) &&
                            !AudioRouteUtils.isBluetoothAudioRouteCurrentlyUsed(core, call)
                        ) {
                            Log.i(
                                TAG,
                                "[Context] Video enabled and no wired headset not bluetooth in use, routing audio to speaker"
                            )
                            AudioRouteUtils.routeAudioToSpeaker(core, call)
                        }
                    }
                }
                Call.State.End, Call.State.Released, Call.State.Error -> {
                    if (core.callsNb == 0) {
                        when (state) {
                            Call.State.End -> phoneCallback?.callEnd(call)

                            Call.State.Released -> phoneCallback?.callReleased(call)

                            Call.State.Error -> {
                                val id = when (call.errorInfo.reason) {
                                    Reason.Busy -> R.string.call_error_user_busy
                                    Reason.IOError -> R.string.call_error_io_error
                                    Reason.NotAcceptable -> R.string.call_error_incompatible_media_params
                                    Reason.NotFound -> R.string.call_error_user_not_found
                                    Reason.Forbidden -> R.string.call_error_forbidden
                                    else -> R.string.call_error_unknown
                                }
                                phoneCallback?.error(context.getString(id))
                            }
                        }
                        gsmCallActive = false
                    }
                }
            }
            previousCallState = state
        }
    }

    /**
     * 启动linphone
     */
    fun start() {
        if (!coreIsStart) {
            coreIsStart = true
            Log.i(TAG, "[Context] Starting")
            core.addListener(coreListener)
            core.start()

            initLinphone()

            val telephonyManager =
                context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
            Log.i(TAG, "[Context] Registering phone state listener")
            telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE)
        }
    }

    /**
     * 停止linphone
     */
    fun stop() {
        coreIsStart = false
        val telephonyManager =
            context.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager

        Log.i(TAG, "[Context] Unregistering phone state listener")
        telephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE)

        core.removeListener(coreListener)
        core.stop()
    }


    /**
     * 注册到服务器
     *
     * @param username     账号名
     * @param password      密码
     * @param domain     IP地址:端口号
     */
    fun createProxyConfig(
        username: String,
        password: String,
        domain: String,
        type: TransportType? = TransportType.Udp
    ) {
        core.clearProxyConfig()

        val accountCreator = core.createAccountCreator(corePreferences.xmlRpcServerUrl)
        accountCreator.language = Locale.getDefault().language
        accountCreator.reset()

        accountCreator.username = username
        accountCreator.password = password
        accountCreator.domain = domain
        accountCreator.displayName = username
        accountCreator.transport = type

        accountCreator.createProxyConfig()
    }


    /**
     * 取消注册
     */
    fun removeInvalidProxyConfig() {
        core.clearProxyConfig()

    }


    /**
     * 拨打电话
     * @param to String
     * @param isVideoCall Boolean
     */
    fun startCall(to: String, isVideoCall: Boolean) {
        try {
            val addressToCall = core.interpretUrl(to)
            addressToCall?.displayName = to
            val params = core.createCallParams(null)
            //启用通话录音
//            params?.recordFile = LinphoneUtils.getRecordingFilePathForAddress(context, addressToCall!!)
            //启动低宽带模式
            if (LinphoneUtils.checkIfNetworkHasLowBandwidth(context)) {
                Log.w(TAG, "[Context] Enabling low bandwidth mode!")
                params?.enableLowBandwidth(true)
            }
            if (isVideoCall) {
                params?.enableVideo(true)
                core.enableVideoCapture(true)
                core.enableVideoDisplay(true)
            } else {
                params?.enableVideo(false)
            }
            if (params != null) {
                core.inviteAddressWithParams(addressToCall!!, params)
            } else {
                core.inviteAddress(addressToCall!!)
            }

        } catch (e: Exception) {
            e.printStackTrace()
        }

    }


    /**
     * 接听来电
     *
     */
    fun answerCall(call: Call) {
        Log.i(TAG, "[Context] Answering call $call")
        val params = core.createCallParams(call)
        //启用通话录音
//        params?.recordFile = LinphoneUtils.getRecordingFilePathForAddress(context, call.remoteAddress)
        if (LinphoneUtils.checkIfNetworkHasLowBandwidth(context)) {
            Log.w(TAG, "[Context] Enabling low bandwidth mode!")
            params?.enableLowBandwidth(true)
        }
        params?.enableVideo(isVideoCall(call))
        call.acceptWithParams(params)
    }

    /**
     * 谢绝电话
     * @param call Call
     */
    fun declineCall(call: Call) {
        val voiceMailUri = corePreferences.voiceMailUri
        if (voiceMailUri != null && corePreferences.redirectDeclinedCallToVoiceMail) {
            val voiceMailAddress = core.interpretUrl(voiceMailUri)
            if (voiceMailAddress != null) {
                Log.i(TAG, "[Context] Redirecting call $call to voice mail URI: $voiceMailUri")
                call.redirectTo(voiceMailAddress)
            }
        } else {
            Log.i(TAG, "[Context] Declining call $call")
            call.decline(Reason.Declined)
        }
    }

    /**
     * 挂断电话
     */
    fun terminateCall(call: Call) {
        Log.i(TAG, "[Context] Terminating call $call")
        call.terminate()
    }

    fun micEnabled() = core.micEnabled()

    fun speakerEnabled() = core.outputAudioDevice?.type == AudioDevice.Type.Speaker

    /**
     * 启动麦克风
     * @param micEnabled Boolean
     */
    fun enableMic(micEnabled: Boolean) {
        core.enableMic(micEnabled)
    }

    /**
     * 扬声器或听筒
     * @param SpeakerEnabled Boolean
     */
    fun enableSpeaker(SpeakerEnabled: Boolean) {
        if (SpeakerEnabled) {
            AudioRouteUtils.routeAudioToEarpiece(core)
        } else {
            AudioRouteUtils.routeAudioToSpeaker(core)
        }
    }


    /**
     * 是否是视频电话
     * @return Boolean
     */
    fun isVideoCall(call: Call): Boolean {
        val remoteParams = call.remoteParams
        return remoteParams != null && remoteParams.videoEnabled()
    }


    /**
     * 设置视频界面
     * @param videoRendering TextureView 对方界面
     * @param videoPreview CaptureTextureView 自己界面
     */
    fun setVideoWindowId(videoRendering: TextureView, videoPreview: TextureView) {
        core.nativeVideoWindowId = videoRendering
        core.nativePreviewWindowId = videoPreview
    }

    /**
     * 设置视频电话可缩放
     * @param context Context
     * @param videoRendering TextureView
     */
    fun setVideoZoom(context: Context, videoRendering: TextureView) {
        VideoZoomHelper(context, videoRendering, core)
    }

    fun switchCamera() {
        val currentDevice = core.videoDevice
        Log.i(TAG, "[Context] Current camera device is $currentDevice")

        for (camera in core.videoDevicesList) {
            if (camera != currentDevice && camera != "StaticImage: Static picture") {
                Log.i(TAG, "[Context] New camera device will be $camera")
                core.videoDevice = camera
                break
            }
        }

//        val conference = core.conference
//        if (conference == null || !conference.isIn) {
//            val call = core.currentCall
//            if (call == null) {
//                Log.w(TAG, "[Context] Switching camera while not in call")
//                return
//            }
//            call.update(null)
//        }
    }


    //初始化一些操作
    private fun initLinphone() {

        configureCore()

        initUserCertificates()
    }


    private fun configureCore() {
        // 来电铃声
        core.isNativeRingingEnabled = false
        // 来电振动
        core.isVibrationOnIncomingCallEnabled = true
        core.enableEchoCancellation(true) //回声消除
        core.enableAdaptiveRateControl(true) //自适应码率控制

    }

    private var gsmCallActive = false
    private val phoneStateListener = object : PhoneStateListener() {
        override fun onCallStateChanged(state: Int, phoneNumber: String?) {
            gsmCallActive = when (state) {
                TelephonyManager.CALL_STATE_OFFHOOK -> {
                    Log.i(TAG, "[Context] Phone state is off hook")
                    true
                }
                TelephonyManager.CALL_STATE_RINGING -> {
                    Log.i(TAG, "[Context] Phone state is ringing")
                    true
                }
                TelephonyManager.CALL_STATE_IDLE -> {
                    Log.i(TAG, "[Context] Phone state is idle")
                    false
                }
                else -> {
                    Log.i(TAG, "[Context] Phone state is unexpected: $state")
                    false
                }
            }
        }
    }


    //设置存放用户x509证书的目录路径
    private fun initUserCertificates() {
        val userCertsPath = corePreferences!!.userCertificatesPath
        val f = File(userCertsPath)
        if (!f.exists()) {
            if (!f.mkdir()) {
                Log.e(TAG, "[Context] $userCertsPath can't be created.")
            }
        }
        core.userCertificatesPath = userCertsPath
    }


    companion object {

        // For Singleton instantiation
        @SuppressLint("StaticFieldLeak")
        @Volatile
        private var instance: LinphoneManager? = null
        fun getInstance(context: Context) =
            instance ?: synchronized(this) {
                instance ?: LinphoneManager(context).also { instance = it }
            }

    }

}

3.封装好的源码 

网上已经有对linphone android sdk开发好的产品

LinphoneCall封装linphone android sdk的软话机

4.优化的配置

对于部分设备可能存在啸叫、噪音的问题,可以修改assets/linphone_factory 文件下的语音参数,默认已经配置了一些,如果不能满足你的要求,可以添加下面的一些参数。文章来源地址https://www.toymoban.com/news/detail-839299.html

回声消除
  • echocancellation=1:回声消除这个必须=1,否则会听到自己说话的声音
  • ec_tail_len= 100:尾长表示回声时长,越长需要cpu处理能力越强
  • ec_delay=0:延时,表示回声从话筒到扬声器时间,默认不写
  • ec_framesize=128:采样数,肯定是刚好一个采样周期最好,默认不写
回声抑制
  • echolimiter=0:等于0时不开会有空洞的声音,建议不开
  • el_type=mic:这个选full 和 mic 表示抑制哪个设备
  • eq_location=hp:这个表示均衡器用在哪个设备
  • speaker_agc_enabled=0:这个表示是否启用扬声器增益
  • el_thres=0.001:系统响应的阈值 意思在哪个阈值以上系统有响应处理
  • el_force=600 :控制收音范围 值越大收音越广,意思能否收到很远的背景音
  • el_sustain=50:控制发声到沉默时间,用于控制声音是否拉长,意思说完一个字是否被拉长丢包时希望拉长避免断断续续
降噪
  • noisegate=1 :这个表示开启降噪音,不开会有背景音
  • ng_thres=0.03:这个表示声音这个阈值以上都可以通过,用于判断哪些是噪音
  • ng_floorgain=0.03:这个表示低于阈值的声音进行增益,用于补偿声音太小被吃掉
网络抖动延时丢包
  • audio_jitt_comp=160:这个参数用于抖动处理,值越大处理抖动越好,但声音延时较大 理论值是80根据实际调整160
  • nortp_timeout=20:这个参数用于丢包处理,值越小丢包越快声音不会断很长时间,同时要跟el_sustain配合声音才好听

到了这里,关于基于Linphone android sdk开发Android软话机的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Android 1.2.1 使用Eclipse + ADT + SDK开发Android APP

      这里我们有两条路可以选,直接使用封装好的用于开发Android的ADT Bundle,或者自己进行配置 因为谷歌已经放弃了ADT的更新,官网上也取消的下载链接,这里提供谷歌放弃更新前最新版本的 ADT Bundle供大家下载! 32位版: adt-bundle-windows-x86-20140702.zip(百度网盘) 64位版: adt

    2024年02月09日
    浏览(34)
  • Android NDK开发详解之编写C/C++代码中的Android SDK 版本属性)

    本部分将讨论如何使用 NDK 提供的库。 注意:有关导入预构建库(未包含在 NDK 中的库)的指南已移至各个构建系统的相关部分。请根据您的项目需求参阅 CMake 或 ndk-build 指南。 文中说明了 NDK 提供的 C ++ 运行时,并介绍了 NDK 提供的其他库(例如 OpenGL ES 和 OpenSL ES)以及支持

    2024年02月07日
    浏览(51)
  • Android源码解析--享元设计模式,handler消息传递机制(基于Android API 33 SDK分析)

    使用共享对象可有效地支持大量的细粒度的对象 核心:对象复用。 1.1 享元模式Demo 火车票购票Demo 缓存对象在一个Map中。下面我们还会分析 用法 跟进去 这就是最明显的一个享元设计模式。 Android 开发一个知识点:UI 不能够在子线程中更新。 我们跟进post函数 Handler 传递了一个

    2024年02月11日
    浏览(33)
  • Android Studio 导入项目时遇到sdk location not found 安卓开发 导入工程 不能运行、

    sdk location not found:找不到sdk的位置、  参考情况:可能导入工程的sdk路径与你本机的sdk路径不同、导致sdk无法正常运转。 解决方法:找到本机存放sdk的路径、然后到local.properties目录修改 你存放sdk的路径即可解决问题。 eg:  修改好之后、后续导入工程出现sdk不一样的情况、

    2024年02月07日
    浏览(50)
  • 基于Android的学生信息管理App设计(Android studio开发)

    目 录 一、 题目选择(题目、选题意义) 3 二、 设计目的 3 1、 初衷 3 2、 结合实际 3 3、 使用工具 3 三、 最终页面效果展示 4 1、 登陆界面 4 2、 主界面 5 3、 各个功能模块 6 四、 各部分设计 11 1、活动页面Activity布局文件 11 2、Activity的编程 13 五、 总结 17 题目:基于Android的

    2024年02月08日
    浏览(96)
  • Android毕业设计-------基于 Android 剧院购票APP的开发与设计

    摘要:近年来,随着社会的发展和科技方面的创新,越来越多的人选择使用手机应用程序来购买剧场票。本文将探讨基于 Android 平台的剧院购票应用程序的开发和设计。该应用程序将为用户提供浏览剧场列表、查看剧场详情、选择座位并购买剧场票的功能。在开发方面,我们

    2024年01月24日
    浏览(45)
  • 基于android studio开发的火车票购票系统app,android移动开发课设,毕业设计

    基于android studio开发实现火车票购票系统app 适用于android移动开发学习项目,课程设计,毕业设计等 开发工具:android studio 或者intellij idea专业版 操作系统:windows10 java: JDK11 构建工具Gradle : gradle-7.0.0 模拟器AVD:pixel 3XL API 30 具体AVD配置详情如下 APP功能 该APP包含17个Activity,每

    2024年02月09日
    浏览(52)
  • Android Studio与 Android SDK的安装和配置

    Android Studio与 Android SDK的安装和配置 Android Studio是开发Android应用程序的官方集成开发环境(IDE),它提供了丰富的工具和功能,使开发者能够方便地创建、调试和部署Android应用。Android SDK(Software Development Kit)是一组开发Android应用所需的软件包集合,包含了Android平台的工具

    2024年02月08日
    浏览(46)
  • Android中的SDK以及利用Android Studio生成aar

    广义上的SDK: 指的是为特定的软件包、软件框架、硬件平台、操作系统等建立应用程序时所使用的开发工具的集合。 比如你在编辑器里敲代码的时候它会自动补全代码,自动错误检查,你点一下Run,它会调用编译器来自动编译,编译完它会调用iPhone的模拟器来运行,这就是

    2024年02月12日
    浏览(44)
  • Android SDK原生下载

    第一步:下载SDK-Manager 在AndroidDevTools网站下载,链接: https://www.androiddevtools.cn/ 点击Android SDK 工具➡SDK Tools➡选择需要的版本下载: 第二步:安装SDK-Manager 下载完成后运行exe文件,一直跳过,其中如下需要选择 第三步:下载SDK相关Tools 打开SDK-Manager并选择如下选项: 点击Ins

    2024年02月16日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包