一、需求

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#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<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

標籤：其他

上一篇：WWDC2023 Session系列：探索XCode15新特性

下一篇：返回列表