一、需求

1、了解IMS相关知识体系2、RILD 与 RILJ、IMS回调消息的机制

二、相关概念

2.1 IMS

IMS全称是IP Multimedia Subsystem，中文意义为IP多媒体子系统。IMS是一种基于IP基础结构，能够融合数据、话音和移动等网络技术的系统。 IP= 基于IP 的传输，基于IP的会话控制，基于IP的业务实现Multimedia= 语音、视频、图片、文本等多种媒体组合，在多种接入基础之上具有不同能力的终端组合Subsvstem= 依赖于现有网络技术和网络设备发展的网络，最大程度重用现有网络系统（我个人理解IMS是一个很大的概念，它不单单特指:IMS服务、IMS PDN等。它类似GSM，WCDMA，LTE一样，是一种体系结构，包含了好多内容）

2.2 Volte

VoLTE是Voice over LTE的缩写，是基于 IMS 的语音业务。VoLTE基于IP多媒体子系统（IMS）网络，在LTE上使用为控制层面和语音服务的媒体层面特制的配置文件，使语音服务作为数据流在LTE数据承载网络中进行传输，而不再需要维护和依赖传统的电路交换语音网络。通俗的来讲，就是语音通话建立在4G流量之上，无需再依托于2G/3G网，全部承载于4G网络中，最终实现数据与语音业务在同一网络下的统一，使4G网络不再仅仅提供流量数据业务支撑，还提供语音及视频通话支持，让4G网络利用最大化。移动用户肯定都遇到过这个问题，在玩网络游戏时一则电话打进来，游戏就断网了，这并非手机硬件问题，而是移动4G手机是通过2G信号进行语音通讯，所以通话过程中系统会自动将网络从4G切换到2G。

(相关资料图)

2.3 CS域与PS域

我们了解到的数据传输有两个域，分别是CS域和PS域。我们常说的CS域就是电路交换域，通常用于语音通话，在2G和3G中都有应用到；我们常说的PS域就是分组交换域，通常用于数据业务，在3G、4G和5G中都有应用到。而还有一个IMS（IP多媒体子系统），相当于是PS域上的一个子系统，IMS的存在可以让用户在PS域上同时使用语音通话和数据业务

2.3.1 CS域

CS（Circuit Switched）域，即电路交换域。首先需要建立一条传输数据的连接，建立完成之后开始数据的传输，此连接不会断开，直到数据传输完毕，才可以释放掉连接。所以一条链路只电路交换的特点是独占一条链路，一直用于数据传输。可靠性很高，但不高效。这就相当于是小时候玩的听筒游戏，两个纸杯子之间连着一条线，两个人通话过程中，这条链路是不能断开的，直到通话结束。

2.3.2 PS域

PS域（Packet Switch）表面意思就是分组交换。PS 域不能直接进行语音业务，PS业务就是常见的数据业务，也包括流媒体业务、VOIP等等。具有高效的传输效率，但可靠性没有CS域那么高。

2.4 VOIP

VOIP是一个很宽泛的概念，VOIP（Voice over IP）的缩写，只要是通过IP传输的语音电话，都可以称为VOIP。如互联网提供商提供（Skype、微信、teams等）、运营商提供的IMS（LTE时代公认的语音解决方案（VoLTE）。因为VoLTE是运营商在LTE层上附着IMS-PDN进行传输的，相对于纯IP网络的skype、微信网络电话，通话质量会好很多。

2.5 URC消息

URC 是Unsolicited Result Code，即"非请求结果码"。 一般的 AT命令 流程都是控制端发出 命令 ，被控端响应结果码。 但当被控端有事件需要通知控制端时，就会主动发出 URC ，例如有呼叫打入、收到新短信息、自动关机等。

2.6 HIDL

HIDL的全称是HAL interface definition language(硬件抽象层接口定义语言) ，是AndroidFramework 与Android HAL之间的接口。HIDL 旨在用于进程间通信(IPC)。Android O(8.0) 之前系统的升级牵扯多方协作，极为麻烦，HIDL机制的推出就是将 framework 与 hal 层分开，使得框架部分可以直接被覆盖、更新，而不需要重新对 HAL 进行编译，这样在系统升级时，OEM 厂商 跳过 SoC厂商，先对 framework 进行升级。

三、环境

1. 芯片：高通Qcm2290
2. 版本：Android 11

四、设计思路

4.1 RIL结构图

4.2 RIL相关模块介绍

4.2.1 Dialer模块

源码：LINUX\android\packages\apps\Dialer

4.2.2 TeleService模块

源码：LINUX\android\packages\services\Telephony

4.2.2.1 TeleService启动

（1）设置persistent标记，此标记AMS会持续保证进程(com.android.phone)存活，意外挂掉也会自动重启。LINUX\android\packages\services\Telephony/AndroidManifest.xml

（2）SystemServer启动后，ActivityManqgerService服务初始化完成后，启动persistent进程，即Phone模块被启动。LINUX\android\frameworks\base\services\core\java\com\android\server\am\ActivityManagerService.java

void startPersistentApps(int matchFlags) {        ...        synchronized (this) {            try {                final List apps = AppGlobals.getPackageManager()                        .getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();                for (ApplicationInfo app : apps) {                    if (!"android".equals(app.packageName)) {                        addAppLocked(app, null, false, null /* ABI override */,                                ZYGOTE_POLICY_FLAG_BATCH_LAUNCH);                    }                }            } catch (RemoteException ex) {            }        }    }

4.2.3 TelecomService模块

源码：LINUX\android\packages\services\Telecomm

4.2.3.1 TelecomService启动

Android设备刚开机，SystemServer进程初始化完成启动完系统的核心服务如AMS、PMS后，就会加载系统其它服务，这其中就包含了一个与Telecom服务启动相关的系统服务专门用于加载Telecom：LINUX\android\frameworks\base\services\java\com\android\server\SystemServer.java

private void run() {    ...    startBootstrapServices(t);    startCoreServices(t);    startOtherServices(t);    ...}private void startOtherServices(@NonNull TimingsTraceAndSlog t)    ...        //启动Telecom服务的加载类        t.traceBegin("StartTelecomLoaderService");        mSystemServiceManager.startService(TelecomLoaderService.class);=        t.traceEnd();        //启动telephony注册服务，用于注册监听telephony状态的接口        t.traceBegin("StartTelephonyRegistry");        telephonyRegistry = new TelephonyRegistry(context, new TelephonyRegistry.ConfigurationProvider());        ServiceManager.addService("telephony.registry", telephonyRegistry);        t.traceEnd();        ...        //AMS初始化完成，启动Telecom服务        mActivityManagerService.systemReady(() -> {            ...            mSystemServiceManager.startBootPhase(t, SystemService.PHASE_ACTIVITY_MANAGER_READY);            ...        }, t);    ...}

在TelecomLoaderService类实现Telecom服务的bind工作，完成Telecom的启动LINUX\android\frameworks\base\services\core\java\com\android\server\telecom\TelecomLoaderService.java

private static final ComponentName SERVICE_COMPONENT = new ComponentName(            "com.android.server.telecom",            "com.android.server.telecom.components.TelecomService");    private static final String SERVICE_ACTION = "com.android.ITelecomService";    @Override    public void onBootPhase(int phase) {        if (phase == PHASE_ACTIVITY_MANAGER_READY) {            ...            connectToTelecom();        }    }    //连接Telecom服务    private void connectToTelecom() {        synchronized (mLock) {            ...            TelecomServiceConnection serviceConnection = new TelecomServiceConnection();            Intent intent = new Intent(SERVICE_ACTION);            intent.setComponent(SERVICE_COMPONENT);            int flags = Context.BIND_IMPORTANT | Context.BIND_FOREGROUND_SERVICE                    | Context.BIND_AUTO_CREATE;            // Bind to Telecom and register the service            if (mContext.bindServiceAsUser(intent, serviceConnection, flags, UserHandle.SYSTEM)) {                mServiceConnection = serviceConnection;            }        }    }     private class TelecomServiceConnection implements ServiceConnection {        @Override        public void onServiceConnected(ComponentName name, IBinder service) {            try {                ITelecomLoader telecomLoader = ITelecomLoader.Stub.asInterface(service);//返回TelecomService代理对象                ITelecomService telecomService = telecomLoader.createTelecomService(mServiceRepo);//返回TelecomService实现类                SmsApplication.getDefaultMmsApplication(mContext, false);                ServiceManager.addService(Context.TELECOM_SERVICE, telecomService.asBinder());//将TelecomService实现类注册到serviceManager，以便后续方便引用            ...            }        ...    }

4.2.3.2 TeleComService消息处理模型

Telecom是Android的一个系统服务，其主要作用是管理Android系统当前的通话,如来电显示，接听电话，挂断电话等功能，在Telephony模块与上层UI之间起到了一个桥梁的作用。比如，Telephony有接收到新的来电时，首先会告知Telecom,然后由Telecom服务通知上层应用来电信息，并显示来电界面。

4.2.4 telephony-common模块

源码：LINUX\android\frameworks\opt\telephonytelephony-common模块最终编译会生成一个java library，主要是phone模块在引用，hal层对应的java层客户端的代码RILJ，这个模块的代码就是跟hal下面的C/C++服务进行通信的。LINUX\android\frameworks\opt\telephony\Android.bp

java_library {    name: "telephony-common",    installable: true,    ...}

4.2.5 Telecom_Framewrok模块

源码：LINUX\android\frameworks\base\telecommandroid提供的phone的一些sdk的代码，最终编译完成打包进framework.jarLINUX\android\frameworks\base\Android.bp

filegroup {    name: "framework-telecomm-sources",    srcs: [        "telecomm/java/**/*.java",        "telecomm/java/**/*.aidl",    ],    path: "telecomm/java",}framework-telecomm-sources => framework-non-updatable-sources => framework-non-updatable-sources => framework-minus-apex => framework

4.2.6 Telephony_Framewrok模块

源码：LINUX\android\frameworks\base\telephonyandroid提供的phone的一些sdk的代码，最终编译完成打包进framework.jarLINUX\android\frameworks\base\Android.bp

filegroup {    name: "framework-telephony-sources",    srcs: [        "telephony/java/**/*.java",        "telephony/java/**/*.aidl",    ],    path: "telephony/java",}framework-telephony-sources => framework-non-updatable-sources => framework-non-updatable-sources => framework-minus-apex => framework

4.2.7 RIL模块

源码：LINUX\android\hardware\rilRIL模块由rild守护进程、libril.so、librefrence.so三部分组成：

4.2.7.1 RILD守护进程

源码：LINUX\android\hardware\ril\rildRILD主要起到承上启下的作用，作为modem和RILJ的通信的中转站。RILD可分为两部分，一是负责与RILJ通讯的部分，主要通过HIDL通信；另一个是负责与modem交互，主要通过AT指令。

4.2.7.1.1 RILD启动

（1）开机时，通过RC文件启动RILD进程

@LINUX\android\hardware\ril\rild\rild.rcservice vendor.ril-daemon /vendor/bin/hw/rild    class main    user radio    disabled    group radio cache inet misc audio log readproc wakelock    capabilities BLOCK_SUSPEND NET_ADMIN NET_RAW

（2）RILD启动后，会执行main啊方法，初始化RILD相关操作

@LINUX\android\hardware\ril\rild\rild.cint main(int argc, char **argv) {    ...    rilInit =        (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))        dlsym(dlHandle, "RIL_Init");    ...    //初始化reference，轮询modem指令    funcs = rilInit(&s_rilEnv, argc, rilArgv);    RLOGD("RIL_Init rilInit completed");    //在rild注册reference的回调函数    RIL_register(funcs);    ...}

4.2.7.2 libril共享库

源码：LINUX\android\hardware\ril\librillibril.so是共享库，主要负责同上层的通信工作，接收ril的请求，并传递给librefrence_ril.so，同时将librefrence_ril.so返回的消息送给调用进程

4.2.7.3 librefrence共享库

源码：LINUX\android\hardware\ril\reference-rillibrefrence_ril.so是共享库，是由各手机厂商自己实现，在rild进程运行中通过dlopen方式加载，主要负责跟modem硬件通信，转换来自libril的请求为AT命令，同时监听Modem的反馈信息给libril

4.3 RIL相关模块通讯

4.3.1 通讯架构图

五、详细设计

5.1 Dialer拨号

5.1.1 Dialer应用拨号时序图

5.1.2 Dialer拨号界面显示

Dialer应用为拨号提供了界面显示，同时也是拨号请求的触发点

@LINUX\android\packages\apps\Dialer\java\com\android\dialer\dialpadview\DialpadFragment.java  public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {    ...    View fragmentView = inflater.inflate(R.layout.dialpad_fragment, container, false);//拨号界面布局加载    ...    return fragmentView;  }    @Override  public void onClick(View view) {    int resId = view.getId();    if (resId == R.id.dialpad_floating_action_button) {      view.performHapticFeedback(HapticFeedbackConstants.VIRTUAL_KEY);      handleDialButtonPressed();//拨号按钮点击事件    }     ...  }

5.1.3 Dialer权限检查

Dialer应用会进行权限检查，判断当前是否为默认拨号盘，且当前应用是否声明CALL_PHONE权限。

public static boolean placeCall(Context context, Intent intent) {    if (hasCallPhonePermission(context)) {//权限检查      getTelecomManager(context).placeCall(intent.getData(), intent.getExtras());      return true;    }    return false;  }  @Deprecated  public static boolean hasCallPhonePermission(Context context) {    return isDefaultDialer(context) || hasPermission(context, Manifest.permission.CALL_PHONE);//判断当前是否为默认拨号盘，且当前应用是否声明CALL_PHONE权限  }

5.1.4 与TelecomService通信

Dialer应用通过TelecomManager对象，将拨号请求消息，通过binder的方式，通知TelecomService进程。

@LINUX\android\frameworks\base\telecomm\java\android\telecom\TelecomManager.java    @RequiresPermission(anyOf = {android.Manifest.permission.CALL_PHONE,            android.Manifest.permission.MANAGE_OWN_CALLS})    public void placeCall(Uri address, Bundle extras) {        ITelecomService service = getTelecomService();//获取服务端代理对象        if (service != null) {            if (address == null) {                Log.w(TAG, "Cannot place call to empty address.");            }            try {                service.placeCall(address, extras == null ? new Bundle() : extras,                        mContext.getOpPackageName(), mContext.getAttributionTag());//通过binder实现跨进程通信，将拨号请求发给TelecomService进程            } catch (RemoteException e) {                Log.e(TAG, "Error calling ITelecomService#placeCall", e);            }        }    }

5.2 TelecomService处理拨号流程

5.2.1 TelecomService处理拨号时序图

5.2.2 往InCallService发送请求

（1）startOutgoingCall开始呼叫请求Dialer进程的拨号请求传递到TelecomService进程后，通过startOutgoingCall方法开始请求打开呼叫界面

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\CallIntentProcessor.javastatic void processOutgoingCallIntent(            Context context,            CallsManager callsManager,            Intent intent,            String callingPackage,            DefaultDialerCache defaultDialerCache) {        ...        // Send to CallsManager to ensure the InCallUI gets kicked off before the broadcast returns        CompletableFuture callFuture = callsManager                .startOutgoingCall(handle, phoneAccountHandle, clientExtras, initiatingUser,                        intent, callingPackage);//开始呼叫请求        final Session logSubsession = Log.createSubsession();        callFuture.thenAccept((call) -> {            if (call != null) {                Log.continueSession(logSubsession, "CIP.sNOCI");                try {                    broadcaster.processCall(call, disposition);//发送广播，切换成异步请求                } finally {                    Log.endSession();                }            }        });    }

（2）绑定InCallServiceInCallServiceImpl是InCallService的子类，在Dialer进程，而TelecomService进程与InCallServiceImpl也是通过bind实现跨进程通信。

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\InCallController.javapublic static final String SERVICE_INTERFACE = "android.telecom.InCallService";public int connect(Call call) {            ...            Intent intent = new Intent(InCallService.SERVICE_INTERFACE);            intent.setComponent(mInCallServiceInfo.getComponentName());            ...            //绑定InCallService类型服务，最终绑定InCallServiceImpl            if (!mContext.bindServiceAsUser(intent, mServiceConnection,                        Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE |                        Context.BIND_ALLOW_BACKGROUND_ACTIVITY_STARTS |                        Context.BIND_ABOVE_CLIENT,                        UserHandle.CURRENT)) {                Log.w(this, "Failed to connect.");                mIsConnected = false;            }            ...        }

（3）启动InCallActivity呼叫界面当InCallServiceImpl被TelecomService进程绑定后，会调用onBind函数，接着启动InCallActivity呼叫界面

@LINUX\android\packages\apps\Dialer\java\com\android\incallui\InCallServiceImpl.java  public IBinder onBind(Intent intent) {    ...    InCallPresenter.getInstance().onServiceBind();    InCallPresenter.getInstance().maybeStartRevealAnimation(intent);//开启显示动画    TelecomAdapter.getInstance().setInCallService(this);    ...    return iBinder;  }@LINUX\android\packages\apps\Dialer\java\com\android\incallui\InCallPresenter.java   public void maybeStartRevealAnimation(Intent intent) {    ...    //启动InCallActivity呼叫界面    final Intent activityIntent =        InCallActivity.getIntent(context, false, true, false /* forFullScreen */);    activityIntent.putExtra(TouchPointManager.TOUCH_POINT, touchPoint);    context.startActivity(activityIntent);  }

5.2.3 广播下发消息

TelecomService进程发出一个定向广播，由TelecomService进程中的NewOutgoingCallBroadcastIntentReceiver对象接收。（1）TelecomService进程发送广播

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\NewOutgoingCallIntentBroadcaster.java    private void broadcastIntent(            Intent originalCallIntent,            String number,            boolean receiverRequired,            UserHandle targetUser) {        Intent broadcastIntent = new Intent(Intent.ACTION_NEW_OUTGOING_CALL);        ...        //发送广播        mContext.sendOrderedBroadcastAsUser(                broadcastIntent,                targetUser,                android.Manifest.permission.PROCESS_OUTGOING_CALLS,                AppOpsManager.OP_PROCESS_OUTGOING_CALLS,                options.toBundle(),                receiverRequired ? new NewOutgoingCallBroadcastIntentReceiver() : null,                null,  // scheduler                Activity.RESULT_OK,  // initialCode                number,  // initialData: initial value for the result data (number to be modified)                null);  // initialExtras    }

（2）TelecomService进程接收广播

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\NewOutgoingCallIntentBroadcaster.javapublic class NewOutgoingCallBroadcastIntentReceiver extends BroadcastReceiver {        @Override        public void onReceive(Context context, Intent intent) {            ...                    placeOutgoingCallImmediately(mCall, resultHandleUri, gatewayInfo,                            mIntent.getBooleanExtra(                                    TelecomManager.EXTRA_START_CALL_WITH_SPEAKERPHONE, false),                            mIntent.getIntExtra(TelecomManager.EXTRA_START_CALL_WITH_VIDEO_STATE,                                    VideoProfile.STATE_AUDIO_ONLY));//继续下发呼叫请求            ...        }    }

同一个应用中为什么要使用广播来传递消息呢？因为Dialer进程发起拨号请求后，会将消息发给TelecomService进程，通过该进程的placeCall方法层层调用，此时方法是同步调用。直到调用了broadcastIntent，通过广播方式将同步方法转换成异步处理，即当前的呼叫请求下发给TelecomService进程处理，同Dialer进程的呼叫请求结束。

5.2.4 往TeleService下发请求

（1）placeOutgoingCall 下发呼叫请求接收广播后，通过placeOutgoingCall方法继续下发拨号请求

private void placeOutgoingCallImmediately(Call call, Uri handle, GatewayInfo gatewayInfo,            boolean speakerphoneOn, int videoState) {        ...        mCall.setNewOutgoingCallIntentBroadcastIsDone();        mCallsManager.placeOutgoingCall(call, handle, gatewayInfo, speakerphoneOn, videoState);    }

（2）绑定TeleServicebinder绑定TeleService服务，实现跨进程通信，同时将将拨号请求分发给TeleService进程，由TeleService进程继续处理

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\ConnectionServiceWrapper.javapublic void createConnection(final Call call, final CreateConnectionResponse response) {        BindCallback callback = new BindCallback() {            @Override            public void onSuccess() {                ...                    mServiceInterface.createConnection(...);//与TeleService绑定成功后，发起创建通话连接请求                ...            }            @Override            public void onFailure() {                ...            }        };        mBinder.bind(callback, call);//绑定TeleService    }}@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\ServiceBinder.javapublic static final String SERVICE_INTERFACE = "android.telecom.ConnectionService";void bind(BindCallback callback, Call call) {            ...            if (mServiceConnection == null) {                Intent serviceIntent = new Intent(mServiceAction).setComponent(mComponentName);//该对象为SERVICE_INTERFACE                ...                if (mUserHandle != null) {                    isBound = mContext.bindServiceAsUser(serviceIntent, connection, bindingFlags,                            mUserHandle);//绑定TeleService                }                ...             }         }

5.3 TeleService下发拨号请求

5.3.1 TeleService下发拨号请求时序图

5.3.2 TeleService类图

5.3.3 TelephonyConnectionService启动

@LINUX\android\packages\services\Telephony\AndroidManifest.xml                                                        

5.3.4 TeleService拨号请求下发（GsmCdmaPhone）

在teleService会获取当前呼叫的phone对象，如GsmCdmaPhone、ImsPhone、SipPhone，来决定要从用哪一种通讯方式进行呼叫。

@LINUX\android\packages\services\Telephony\src\com\android\services\telephony\TelephonyConnectionService.java    public Connection onCreateOutgoingConnection(            PhoneAccountHandle connectionManagerPhoneAccount,            final ConnectionRequest request) {        ...        if (PhoneAccount.SCHEME_VOICEMAIL.equals(scheme)) {            // TODO: We don"t check for SecurityException here (requires            // CALL_PRIVILEGED permission).            final Phone phone = getPhoneForAccount(request.getAccountHandle(),                    false /* isEmergencyCall */, null /* not an emergency call */);//获取Phone对象，决定采用的通讯方式            ...        }         ...        if (!isEmergencyNumber) {            ...                return placeOutgoingConnection(request, resultConnection, phone);//往RILD继续下发消息        }          ...    }

5.3.5 TeleService拨号请求下发（ImsPhone）

Android 9 引入了一个名为 ImsService 的新 SystemApi 接口，可以帮助实现IP多媒体子系统。ImsService API 是在 Android 平台与供应商或运营商提供的 IMS 实现之间明确定义的接口。即IMS的具体实现是由供应商或运营商实现。 android提供了相关的系统SystemApi接口。

5.3.5.1 时序图

5.3.5.2 IMS与CDMA、GSM时序切换

与普通的CS通话一致,由Dialer拨号应用,到Telecom,TeleService。区别在于,在GsmCdmaPhone#diale()中，判断是否支持ims通话。

public Connection dial(String dialString, @NonNull DialArgs dialArgs)            throws CallStateException {        ...        boolean useImsForCall = useImsForCall(dialArgs)                && !shallDialOnCircuitSwitch(dialArgs.intentExtras)                && (isWpsCall ? allowWpsOverIms : true);//是否使用IMS通讯方式        ...        if ((useImsForCall && (!isMmiCode || isPotentialUssdCode))                || (isMmiCode && useImsForUt)                || useImsForEmergency) {            try {                if (DBG) logd("Trying IMS PS call");                return imsPhone.dial(dialString, dialArgs);//使用IMS通话            } ...        }        ...        if (isPhoneTypeGsm()) {            return dialInternal(dialString, new DialArgs.Builder<>()                    .setIntentExtras(dialArgs.intentExtras)                    .build());//使用GSM通话        } else {            return dialInternal(dialString, dialArgs);//其他通话方式        }    }

5.4 RILD处理拨号请求

5.4.1 RILD拨号请求消息下发时序图

5.4.2 RILJ往RILD发送指令

RILJ往RILD发送指令,请求拨号的消息下发如下：

@LINUX\android\frameworks\opt\telephony\src\java\com\android\internal\telephony\RIL.java    @Override    public void dial(String address, boolean isEmergencyCall, EmergencyNumber emergencyNumberInfo,                     boolean hasKnownUserIntentEmergency, int clirMode, UUSInfo uusInfo,                     Message result) {        ...        IRadio radioProxy = getRadioProxy(result);        if (radioProxy != null) {            RILRequest rr = obtainRequest(RIL_REQUEST_DIAL, result,                    mRILDefaultWorkSource);            ...            try {                radioProxy.dial(rr.mSerial, dialInfo);//请求拨号            } catch (RemoteException | RuntimeException e) {                handleRadioProxyExceptionForRR(rr, "dial", e);            }        }    }

5.4.3 RILD接收到RILJ指令

RILD接收到RILJ指令，JAVA层与HAL层通过HIDL方式绑定，即HAL也会有对应的dial映射方法。

@LINUX\android\hardware\ril\libril\ril_service.cpp#define CALL_ONREQUEST(a, b, c, d, e) \        s_vendorFunctions->onRequest((a), (b), (c), (d), ((RIL_SOCKET_ID)(e)))Return RadioImpl::dial(int32_t serial, const Dial& dialInfo) {    ...    CALL_ONREQUEST(RIL_REQUEST_DIAL, &dial, sizeOfDial, pRI, mSlotId);    memsetAndFreeStrings(2, dial.address, uusInfo.uusData);    return Void();}

5.4.4 RILD和reference侧消息传递

onRequest方法是在哪里被实现的？我们需要关注下s_vendorFunctions是在哪个地方赋值的。关于s_vendorFunctions全局变量，当我们调用reference中的RIL_Init完成初始化时，就会得到reference返回当前链接库提供的接口函数，通过该接口函数我们便可实现rild侧与reference侧的通讯(reference侧也是跑在rild进程，但是考虑到reference一般由modem厂商客制化，不清楚其内部实现，故以下将其称为reference侧，以便更好地区分该模块)。

@LINUX\android\hardware\ril\libril\ril.cppextern "C" voidRIL_register (const RIL_RadioFunctions *callbacks) {    ...    memcpy(&s_callbacks, callbacks, sizeof (RIL_RadioFunctions));//对象拷贝    ...    radio::registerService(&s_callbacks, s_commands);//注册回调函数    ...}@LINUX\android\hardware\ril\libril\ril_service.cppvoid radio::registerService(RIL_RadioFunctions *callbacks, CommandInfo *commands) {    ...    s_vendorFunctions = callbacks;//将回调函数对象赋值，以实现rild侧与reference侧的引用    s_commands = commands;    ...}

5.4.5 reference侧接收到消息

reference层接收到消息， 从onRequest可以看出，reference中对所有的命令请求进行判别，然后选择不同的处理方式。

@LINUX\android\hardware\ril\reference-ril\reference-ril.cstatic void onRequest (int request, void *data, size_t datalen, RIL_Token t){    ...    switch (request) {        ...        case RIL_REQUEST_DIAL:            requestDial(data, datalen, t);//拨号请求            break;        case RIL_REQUEST_HANGUP://挂断电话请求            requestHangup(data, datalen, t);            break;        ...           }}static void requestDial(void *data, size_t datalen __unused, RIL_Token t){    ...    ret = at_send_command(cmd, NULL);//往modem层发送指令    ...    /* success or failure is ignored by the upper layer here.       it will call GET_CURRENT_CALLS and determine success that way */    RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);}

5.4.6 reference侧将消息发送至modem侧

reference侧将消息发送至modem侧，at_send_command() -> at_send_command_full() -> at_send_command_full_nolock()，经过上面的操作，就将一条命令通过串口方式传输到了Modem侧。其间，完成了两个重要动作：1、通过writeline发送数据到Modem；2、阻塞当前线程，等待Modem回应。

@LINUX\android\hardware\ril\reference-ril\atchannel.cstatic int at_send_command_full_nolock (const char *command, ATCommandType type,                    const char *responsePrefix, const char *smspdu,                    long long timeoutMsec, ATResponse **pp_outResponse){    ...    err = writeline (command);//将命令通过AT指令方式写入modem侧    if (err < 0) {        goto error;    }    ...    while (sp_response->finalResponse == NULL && s_readerClosed == 0) {        if (timeoutMsec != 0) {            err = pthread_cond_timedwait(&s_commandcond, &s_commandmutex, &ts);//阻塞线程，直到modem侧消息返回        }         ...    }    ...    return err;}

5.4.7 modem侧发送消息至reference侧

modem侧发送消息至reference侧，我们需要如何唤醒阻塞的线程呢？当我们发送数据或命令给Modem的时候，阻塞了当前的线程，阻塞的目的就是等待Modem的回应，而如果Modem有数据上来，那么肯定是先被reference的ReaderLoop检测到并处理，因此，也应该是在ReaderLoop的消息处理中去唤醒当前阻塞的线程，而且应该把Modem的反馈传输给阻塞线程。

@LINUX\android\hardware\ril\reference-ril\atchannel.cstatic void *readerLoop(void *arg __unused){    for (;;) {        ...        line = readline();//读取modem返回数据        ...        if(isSMSUnsolicited(line)) {            ...        } else {            processLine(line);//解析消息        }    }    ...    return NULL;}static void processLine(const char *line){    ...    if (sp_response == NULL) {        /* no command pending */        handleUnsolicited(line);//处理URC消息    } else if (isFinalResponseSuccess(line)) {        sp_response->success = 1;        handleFinalResponse(line);//发送回应消息    }    ...}static void handleFinalResponse(const char *line){    sp_response->finalResponse = strdup(line);    pthread_cond_signal(&s_commandcond);//发送一个信号给另外一个正在处于阻塞等待状态的线程,使其脱离阻塞状态}

5.4.8 reference侧轮询modem指令

reference侧轮询modem指令，ReaderLoop轮询modem消息又是在哪里实现的呢？RILD进程被创建后，会通过RIL_Init初始化相关的reference相关准备工作，其中涉及到打开与modem侧的AT通道，监听modem上报消息。

@LINUX\android\hardware\ril\reference-ril\atchannel.cconst RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv){    ...    ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL);//创建mainLoop线程    ...}static void *mainLoop(void *param __unused){    ...    for (;;) {        ...        ret = at_open(fd, onUnsolicited);//打开AT通道并把处理URC消息的方法onUnsolicited传进去         ...    }}@LINUX\android\hardware\ril\reference-ril\atchannel.cint at_open(int fd, ATUnsolHandler h){    ...    ret = pthread_create(&s_tid_reader, &attr, readerLoop, &attr);//创建readerLooper线程，读取AT指令并处理modem侧消息    ...}

六、RIL指令

6.1 RILJ主动发送指令

源码：android\hardware\ril\libril\ril_commands.h

6.2 RILJ被动接收指令

源码：android\hardware\ril\libril\ril_unsol_commands.h

七、参考资料

https://source.android.google.cn/docs/core/connect/ims?hl=zh-cnhttp://www.taodudu.cc/news/show-3144813.html?action=onClickhttp://baike.jld5.cn/news/51009.htmlhttps://wiki.mbalib.com/wiki/IMShttps://blog.csdn.net/guyuewangyue/article/details/122866358电路交换和分组交换区别：https://www.elecfans.com/d/1308634.htmlTeleComService介绍：https://blog.csdn.net/qq_40587575/article/details/113753895TeleService介绍：https://www.jianshu.com/p/ff51295b84a1Rild介绍：https://www.freesion.com/article/21011164222/https://blog.csdn.net/u014386544/article/details/52594400RIL指令:https://www.mianshigee.com/note/detail/23890yjg/https://blog.csdn.net/iteye_6233/article/details/82230745https://blog.csdn.net/u010961631/article/details/9446377/https://blog.csdn.net/sjz4860402/article/details/51182078http://www.2sim.cn/article/13https://zhuanlan.zhihu.com/p/117218424https://blog.csdn.net/u014386544/article/details/56851616