Android RIL&IMS源码分析

一、需求

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

    <application android:name="PhoneApp"
            android:persistent="true"
            ...
            android:directBootAware="true">

（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<ApplicationInfo> 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\telephony
telephony-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\telecomm
android提供的phone的一些sdk的代码，最终编译完成打包进framework.jar
LINUX\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\telephony
android提供的phone的一些sdk的代码，最终编译完成打包进framework.jar
LINUX\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\ril
RIL模块由rild守护进程、libril.so、librefrence.so三部分组成：

4.2.7.1 RILD守护进程

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

4.2.7.1.1 RILD启动

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

@LINUX\android\hardware\ril\rild\rild.rc
service 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.c
int 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\libril
libril.so是共享库，主要负责同上层的通信工作，接收ril的请求，并传递给librefrence_ril.so，同时将librefrence_ril.so返回的消息送给调用进程

4.2.7.3 librefrence共享库

源码： LINUX\android\hardware\ril\reference-ril
librefrence_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.java
static 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<Call> 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）绑定InCallService
InCallServiceImpl是InCallService的子类，在Dialer进程，而TelecomService进程与InCallServiceImpl也是通过bind实现跨进程通信。

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\InCallController.java
public 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.java
public 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）绑定TeleService
binder绑定TeleService服务，实现跨进程通信，同时将将拨号请求分发给TeleService进程，由TeleService进程继续处理

@LINUX\android\packages\services\Telecomm\src\com\android\server\telecom\ConnectionServiceWrapper.java
public 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.java
public 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
        <service
                android:singleUser="true"
                android:name="com.android.services.telephony.TelephonyConnectionService"
                android:label="@string/pstn_connection_service_label"
                android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE" >
            <intent-filter>
                <action android:name="android.telecom.ConnectionService" />
            </intent-filter>
        </service>

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#dial()中，判断是否支持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<void> 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.cpp
extern "C" void
RIL_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.cpp
void 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.c
static 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.c
static 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.c
static 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.c
const 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.c
int 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-cn
http://www.taodudu.cc/news/show-3144813.html?action=onClick
http://baike.jld5.cn/news/51009.html
https://wiki.mbalib.com/wiki/IMS
https://blog.csdn.net/guyuewangyue/article/details/122866358
电路交换和分组交换区别：
https://www.elecfans.com/d/1308634.html
TeleComService介绍：
https://blog.csdn.net/qq_40587575/article/details/113753895
TeleService介绍：
https://www.jianshu.com/p/ff51295b84a1
Rild介绍：
https://www.freesion.com/article/21011164222/
https://blog.csdn.net/u014386544/article/details/52594400
RIL指令:
https://www.mianshigee.com/note/detail/23890yjg/
https://blog.csdn.net/iteye_6233/article/details/82230745
https://blog.csdn.net/u010961631/article/details/9446377/
https://blog.csdn.net/sjz4860402/article/details/51182078
http://www.2sim.cn/article/13
https://zhuanlan.zhihu.com/p/117218424
https://blog.csdn.net/u014386544/article/details/56851616文章来源地址https://www.toymoban.com/news/detail-485188.html

到了这里，关于Android RIL&IMS源码分析的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！