Android STK APP流程

STK是英文SIM Tool Kit的缩写，简称“用户识别应用发展工具”，是在GSM手机使用超大容量SIM卡中开发的应用菜单。

STK（SIM TOOL KIT），简称“用户识别应用发展工具”，可以理解为一组开发增值业务的命令，一种小型编程语言，它允许基于智能卡的用户身份识别模块SIM运行自己的应用软件。

STK卡不是一般的通常使用的SIM卡，而是基于Java语言平台的Simera32K卡片。STK是一种小型编程语言的软件，可以固化在SIM卡中。它能够接收和发送GSM的短消息数据，起到SIM卡与短消息之间的接口的作用，同时它还允许SIM卡运行自己的应用软件。这些功能经常被用于在可通过软件激活的电话显示屏上，用友好的文本菜单代替机械的“拨号-收听-应答”方式，从而允许用户通过按键轻松进行复杂的信息检索操作或交易。SIM卡技术,\"空中下载\"业务,实现基于SIM卡的服务业务,例如移动的"移动梦网"SIM卡,"动感地带"等都是基于STK技术的SIM卡,该技术可以使SIM卡拥有大的存储容量和内置运营商提供的各项服务。

STK可以理解为一组开发增值业务的命令，一种小型编程语言，它允许基于智能卡的用户身份识别模块（SIM卡）运行自己的应用软件。

STK菜单点击处理流程

1、引言
对于sim卡的stk这块，其处理逻辑十分复杂，在此以点击其菜单为例，来分析其整个处理逻辑，对于modem侧在此不作分析，重点解析rild以上的事务和数据流向。

2、时序图
2.1 点击处理流程

注意：流程仅仅是当点击某一个menu的一系列操作，此将对应的内容传递到rild中，显然该流程仅仅是开始，这边厢modem根据传递过来的命令将数据返回在第二个流程里。
2.2 rild返回数据流程

注意：该流程是指rild返回数据给stk中间对这些数据的解析过程，解析之后的rildMessage就会传到stk，通过接受广播的形式

3、流程简析
3.1 STK 的处理

1）开启会话，超时结束
对于stk，当我们点击其某个menu后，会向下汇报数据，这时stk界面上会等待，这个等待不是说一直等待，你不会返回数据我就一直等到死为止，那肯定不可能，大家也知道这点，所以在这里有一个10秒的延迟时间，到时还没有数据更新此时就直接结束当前会话。

2）将请求发送到rild
上图2.1就是发送请求到rild
这里将我们需要的请求打包成rilMessage然后通过rild发送到modem侧；

3.2 rild返回数据给stk
rild接受到发送的请求后将对应数据给modem侧，modem得知后根据相关的命令，将对应数据返回，中间层做了一大堆的逻辑处理，主要是解析modem侧发送过来的数据，将对应数据解析后通过广播发送到stk，stk更新ui，如果之间stk没有接收到数据则超时，就会回到主界面去。

应用层：
packages\apps\stk\src\com\android\stk\BootCompletedReceived.java

是一个广播接收类，它只负责接收一个广播:Intent.ACTION_BOOT_COMPLETED，即开机启动完成的广播，当接收到开机启动完成后，开启服务StkAppService,传递参数StkAppService.OPCODE,为StkAppService.OP_BOOT_COMPLETED。

packages\apps\stk\src\com\android\stk\StkCmdReceiver.java

广播接收类，主要接收来自framework层的CatService发送的针对RIL层上报上来的处理结果的响应信息（详见CatService的handleProactiveCommand（）方法），它接收两种广播：
一种是AppInterface.STK_CMD_ACTION：处理从CatService服务上报上来的cmd回

复信息，调用handleCommandMessage（）方法，该方法中新建一个启动

StkAppService 服务的Intent，intent中装载参数StkAppService.OPCODE为

StkAppService.OP_CMD，OP_CMD 所作的具体处理详见StkAppService的onStart()

方法。

另一种是AppInterface.STK_SESSION_END_ACTION：处理从RIL层上报上来的

cmd回复信息，调用handleSessionEnd（）方法，与handleCommandMessage（）

方法作用相同，启动StkAppService服务，但是Intent对象传递的参数

StkAppService.OPCODE为StkAppService.OP_END_SESSION ,结束会话的响应信

息，上层具体操作详见StkAppService的onStart()方法。

packages\apps\stk\src\com\android\stk\StkAppService.java

由开机后通过开机广播接收器第一次启动该服务（详见BootCompletedReceiver类说明）。
onCreate（）方法：通过调用StkService.getInstance()获取了StkService的实例（该实例的创建详见StkService类说明）;
onStart（）方法：对接收到得intent传递的参数进行解析，通过mServiceHandler.obtainMessage()创建一个消息msg,匹配intent传递的参数OPCODE的值，对每一种值进行相应的处理，然后通过mServiceHandler.sendMessage(msg)发送（传递）消息，进行处理响应;

ServiceHandler类：是一个Handle类，处理onStart（）方法传递过来的消息，这个类是StkAppService的内部类
OP_LAUNCH_APP：传递menu消息，将menu装载到Intent里，启动StkMenuActivity
OP_CMD：来自底层AT指令响应后的处理，消息来自于StkCmdReceiver发送的上报信息，创建一个StkCmdMessage 消息，调用handleCmd方法（详见handleCmd方法的说明）
OP_RESPONSE：处理上层的请求，主要来自于ToneDialog、StkInputActivity、StkMenuActivity的操作请求，然后调用handleCmdResponse方法（详见该方法说明）
OP_END_SESSION：处理会话结束，调用handleSessionEnd()方法（详见该方法说明）
OP_BOOT_COMPLETED：处理开机启动完成消息，通过调mStkService.stkResponse()给StkService发响应通知。StkService中会给Ril层下发一个请求RIL_REQUEST_STK_RESPONSE，告诉modem已经开机并要求启动STK，没有返回的响应信息。
OP_DELAYED_MSG：处理延时消息，调用handleDelayedCmd()

handleCmd（）方法：这个方法主要通过对底层上报上来的消息的处理，在应用层执行相应的UI显示，获取的StkCmdMessage消息，根据不同的type的响应操作：

DISPLAY_TEXT：在屏幕上显示文字或图片,文字编码有三种格式
SELECT_ITEM：启动StkMenuActivity
SET_UP_MENU：建立一个菜单
GET_INPUT：
GET_INKEY：
SET_UP_IDLE_MODE_TEXT：
SEND_DTMF：
SEND_SMS：
SEND_SS：发送补充业务
SEND_USSD：发送USSD
LAUNCH_BROWSER：启动StkDialogActivity,显示一个确认Dialog
SET_UP_CALL：
PLAY_TONE：播放一个audio tone

handleCmdResponse（）方法：这个方法，是对上层的请求的下发处理，根据接收到得消息，创建新的响应信息StkResponseMessage，通过mStkService.onCmdResponse(resMsg)下发消息到StkService，被StkService的handleMessage接收消息，调用handleCmdResponse((StkResponseMessage) msg.obj)处理响应（详见StkService的 handleCmdResponse()方法说明）。
StkMenuActivity:主要是装载title、ListView、dialog

StkMenuActivity中下边的每一个视图的装载，都是通过在onCreate()中向StkAppService发Intent,StkAppService接收到StkMenuActivity发送过来的Intent，Intent中绑定了Bundle对象，通过Bundle对象中的OPCODE值，决定需要装载哪个ListView的数据。装载数据成功后，StkMenuActivity中的onResume()获取StkAppService中的Menu数据，并通过适配器显示出来。

framework层：

frameworks/opt/telephony/src/java/com/android/internal/telephony/cat/CatService.java

getInstance（）方法：遵循单例模式的原则创建创建StckService实例，如果该实例没有被初始化，则初始化，否则直接返回。此方法在GSMPhone的构造函数中被初始调用进行创建实例，在StkAppService的onCreate（）方法中调用的StkService.getInstance()获取了已经初始化了的CatService实例。
CatService（）方法：CatService的构造方法，在getInstance()初始化CatService实例时被调用，new CatService(ci, sr, context, fh, sc); 同时获取RilMessageDecoder传来的处理消息，然后通过CommandsInterface的接口对象注册对RIL事件的处理，这些注册方法是在BaseCommands类中实现，注册后，能接收到来自RIL层的通知，详见RIL类的说明，注册的事件包括：

MSG_ID_SESSION_END，
MSG_ID_PROACTIVE_COMMAND，
MSG_ID_EVENT_NOTIFY，
MSG_ID_CALL_SETUP，

然后调用函数reportStkServiceIsRunning函数通知RIL层（详见RIL类说明），CatService服务已经启动。
handleMessage（）：CatService接收RIL层上报信息的重要消息处理方法，它接收的消息种类有：
MSG_ID_SESSION_END：此消息在CatService（）构造函数中注册，当RIL层接收到上报消息RIL_UNSOL_STK_SESSION_END时，通知发送此消息，通知CatService会话结束

MSG_ID_PROACTIVE_COMMAND：此消息在CatService（）构造函数中注册，当RIL层接收到上报消息RIL_UNSOL_STK_PROACTIVE_COMMAND时，通知发送此消息，发送来自modem的主动上报

MSG_ID_EVENT_NOTIFY：此消息在StkService（）构造函数中注册，当RIL层接收到上报消息RIL_UNSOL_STK_EVENT_NOTIFY时，通知发送此消息，
MSG_ID_REFRESH：
MSG_ID_CALL_SETUP：此消息在StkService（）构造函数中注册，当RIL层接收到上报消息RIL_UNSOL_STK_CALL_SETUP时，通知发送此消息，发送来自modem的拨打电话的主动上报消息

MSG_ID_SIM_LOADED：此消息在CatService()构造函数中注册，当Sim卡loaded完成，在SimRecords.java中会通知发送此消息，具体详见SimRecords.java中的onAllRecordsLoaded()方法

MSG_ID_RIL_MSG_DECODED：在RilMessageDecoder.java中对Ril上报消息进行解析后，将解析后的结果通过此消息发送回来，被StkService接收执行处理，接收此消息后，调用handleRilMsg((RilMessage) msg.obj)处理消息，详见handleRilMsg（）方法说明

MSG_ID_RESPONSE：处理上层发过来的请求消息，调用handleCmdResponse((StkResponseMessage) msg.obj)，详见handleCmdResponse（）方法说明
handleRilMsg（）方法:对各种消息进行解析处理后，调用此方法，具体处理各种消息：
MSG_ID_EVENT_NOTIFY：调用handleProactiveCommand（）方法，详见handleProactiveCommand（）方法说明
MSG_ID_PROACTIVE_COMMAND：调用handleProactiveCommand（）方法，详见handleProactiveCommand（）方法说明
MSG_ID_REFRESH：调用handleProactiveCommand（）方法，详见handleProactiveCommand（）方法说明
MSG_ID_SESSION_END：结束会话，调用handleSessionEnd()方法，创建一个Intent发送会话结束广播AppInterface.STK_SESSION_END_ACTION,此广播会被上层的StkCmdReceiver广播接收器接收，详见StkCmdReceiver类说明
MSG_ID_CALL_SETUP：
 
handleCmdResponse（）方法：接收来自上层的处理要求，往RIL下发终端请求，除几种特殊请求外，最终均调用sendTerminalResponse()方法，在该方法中通过调用CommandsInterface的sendTerminalResponse（）方法，将请求下发到RIL层，Ril实现了接口CommandsInterface，的类，sendTerminalResponse（）的具体实现，详见Ril.java，其中文件请求类型有：
HELP_INFO_REQUIRED:
OK:
PRFRMD_WITH_PARTIAL_COMPREHENSION:
PRFRMD_WITH_MISSING_INFO:
PRFRMD_WITH_ADDITIONAL_EFS_READ:
PRFRMD_ICON_NOT_DISPLAYED:
PRFRMD_MODIFIED_BY_NAA:
PRFRMD_LIMITED_SERVICE:
PRFRMD_WITH_MODIFICATION:
PRFRMD_NAA_NOT_ACTIVE:
PRFRMD_TONE_NOT_PLAYED:根据请求类型，做往RIL发相应的请求，请求类型有:
SET_UP_MENU：装载menu的请求，调用sendMenuSelection（）方法，将请求信息创   建为ByteArrayOutputStream字节数组输出流，通过调用CommandsInterface的sendEnvelope（）方法，将请求下发到RIL层，RIL类是实现了CommandsInterface的类，sendEnvelope（）的具体实现，详见RIL.java文件。
SELECT_ITEM：选中item的请求
GET_INPUT：在屏幕上显示文字或图片,文字编码有三种格式,并获取用户输入的字符串
GET_INKEY：在屏幕上显示文字或图片,文字编码有三种格式,并获取用户输入的一个字符
DISPLAY_TEXT：
LAUNCH_BROWSER：
SET_UP_CALL：打电话的请求，通过调用CommandsInterface的handleCallSetupRequestFromSim（）方法，将请求下发到RIL层，RIL类是实现了CommandsInterface的类，handleCallSetupRequestFromSim（）的具体实现，详见RIL.java文件
DISPLAY_TEXT：
LAUNCH_BROWSER
SET_UP_CALL
NO_RESPONSE_FROM_USER
UICC_SESSION_TERM_BY_USER
BACKWARD_MOVE_BY_USER

handleProactiveCommand（）方法：在这个方法中，处理一批请求，请求的处理均是调用sendTerminalResponse（）终端响应方法，sendTerminalResponse（）的说明详见handleCmdResponse（）方法，最后创建一个Intent，发一条广播：AppInterface.STK_CMD_ACTION到上层， AppInterface.STK_CMD_ACTION的处理详见StkCmdReceiver类的说明。

sendTerminalResponse（）方法：此方法在StkService接收到底层上报上来的消息时，会被调用，往RIL层下发请求，告诉modem终端已响应，modem稍后会主动上报会话结束通知回来，同时，StkService会启动上层的StkAppService去处理UI显示。

RIL层：

reportStkServiceIsRunning()方法：通知modem请求，StkService已经启动，转换为一条REQUEST: RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING ，无响应返回信息
stkRefresh（）方法：通知modem请求刷新，转换为一条REQUEST: RIL_REQUEST_STK_REFRESH，无返回响应信息

stkResponse（）方法：通知modem，开机完成，启动Stk工具包，转换为一条REQUEST: RIL_REQUEST_STK_RESPONSE ，无返回响应信息

sendTerminalResponse（）方法：处理StkService发过来的终端操作的响应请求，转换为一条REQUEST: RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE,具体AT指令详见reference-sc8800s.c文件说明，无返回的响应信息，在

processSolicited（）方法中有相应的处理

sendEnvelope（）方法：处理StkService发过来的

handleCallSetupRequestFromSim（）方法：处理Stk拨打电话请求，转换为REQUEST: RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM, 具体AT指令详见reference-sc8800s.c文件说明，

返回的响应信息，在processSolicited（）方法中有相应的处理

processUnsolicited()方法：stk请求modem未响应处理，通知StkService

RIL_UNSOL_STK_SESSION_END:
RIL_UNSOL_STK_PROACTIVE_COMMAND
RIL_UNSOL_STK_EVENT_NOTIFY
RIL_UNSOL_STK_CALL_SETUP

RIL的处理：

********************上报************************
RIL_UNSOL_STK_SESSION_END
RIL_UNSOL_STK_PROACTIVE_COMMAND
RIL_UNSOL_STK_EVENT_NOTIFY
RIL_UNSOL_STK_CALL_SETUP
RIL_UNSOL_SIM_REFRESH
********************命令************************
RIL_REQUEST_STK_GET_PROFILE
RIL_REQUEST_STK_SET_PROFILE
RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND
RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE
RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM

Stk开机后操作流程：
概况（参考详细流程）：开机启动后，由BootCompletedReceiver接收到开机启动广播，开启StkAppService服务，然后给下层发RIL_REQUEST_STK_RESPONSE响应请求通知Modem，稍后，Modem会主动上报RIL_UNSOL_STK_PROACTIVE_COMMAND的消息，并由StkService接收该消息，然后通过RilMessageDecoder解析接收消息类型，由CommandParamsFactory解析消息响应内容的类型（启机后第一条消息为SET_UP_MENU），获取类型响应类型后发消息给RilMessageDecoder，RilMessageDecoder再转发发解析后的结果消息给StkService,StkService接收到消息后，立即做出响应，启机后的第一条消息响应操作为SET_UP_MENU，此时，StkService会往底层发终端已响应的通知请求，同时将消息内容转发出去，由StkCmdReceiver 接收到，再调用上层的StkAppService，去具体处理消息内容的UI显示，
然后，Modem接收到终端响应的请求后会上报第二条消息，同理，由StkService接收，由RilMessageDecoder解析和转发反馈消息，CommandParamsFactory解析消息类型，返回消息，此时的消息为SET_UP_ENVENT_LIST，StkService下发终端响应请求结束。此时，Modem上报上来的会话结束的RIL层消息RIL_UNSOL_STK_SESSION_END，通知StkService接收到，消息为会话结束消息，同理经过依次解析消息，响应消息上层响应会话结束的消息处理。
接着，Modem继续上报两条消息，这两条消息均为DISPLAY_TEXT,即通知显示开机导航提示语（如：动感地带SIM/USIM卡没错，我就是M-Zone人），有的卡只有一条，有的有卡有两条

另外，如果SIM卡未被PIN码锁定，开机之后，在BootCompletedReceiver接收到开机响应之前StkService会接收到一条SIM卡loaded的消息：MSG_ID_SIM_LOADED，通知StkService SIM卡装载成功，但当Sim卡被Pin码锁定，开机之后会弹出PIN码解锁SIM卡的Screen，只有当成功输入PIN码解锁SIM卡后，StkService才能接收到MSG_ID_SIM_LOADED的消息。

所以此时会导致一个Bug，PIN码锁定SIM卡时，开机后，会弹出解锁界面，Modem此时会上报三条DISPLAY_TEXT的消息，其中前两条是重复的身份验证提示语，所以解锁后，你会看到界面接连弹出重复的两个Dialog，这是Android的一个小Bug，但不是致命的Bug,解决这个问题的方法，可以在StkService修改一下代码，不要刚接收到开机启动消息后就向底层发送RIL_REQUEST_STK_RESPONSE请求，而是等到MSG_ID_SIM_LOADED这条消息到来，同时开机消息也到来时才往Modem发此通知请求
详细流程：

注解：注解：“—>”流程标志
     “【】”内代码为本方法体内重要代码摘录
     “（）”跟在【】后的“（）”为本段流程解释，【】前的“（）”为本方法体传参数
      “：”之前为类名，“：”后紧跟本类中的方法名或者本类中的内部类名称

StkService ：handleMessage()【case:MSG_ID_SIM_LOADED】(接收Sim卡装载成功的消息)
 
BootCompletedReceiver：onReceive（）【context.startService（）  】—&gt;
StkAppService：onStart()【case OP_BOOT_COMPLETED: mServiceHandler.sendMessage(msg)】—&gt; ServiceHandler【case OP_BOOT_COMPLETED: mStkService.stkResponse(); 】—&gt;
StkService: StkService()【mCmdIf.stkResponse(null);】—&gt;
RIL: stkResponse(Message result)【RIL_REQUEST_STK_RESPONSE 】—&gt;
hardware/ril/reference-ril/reference-sc8800s.c:【
case RIL_REQUEST_STK_RESPONSE:
at_send_command_multiline("AT+SPUSATPROFILE?", "+SPUSATPROFILE:", &amp;p_response);
RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);】 (往modem发的AT指令为：“AT+SPUSATPROFILE？”)
 
RIL:processUnsolicited（）【case RIL_UNSOL_STK_PROACTIVE_COMMAND: mStkProCmdRegistrant.notifyRegistrant】（RIL层接收到底层的消息，主动上报，通知上层接收消息mStkProCmdRegistrant在StkService初始化时被注册，详见StkService()）—&gt

第一条消息：SET_UP_MENU

收到RIL层的主动上报：RIL_UNSOL_STK_PROACTIVE_COMMAND后

StkService ：handleMessage()【case:MSG_ID_PROACTIVE_COMMAND (接收消息)
mMsgDecoder.sendStartDecodingMessageParams(new RilMessage(msg.what, data)】
RilMessageDecoder：sendStartDecodingMessageParams（）【Message msg = obtainMessage(CMD_START);】（发送消息）—&gt;
RilMessageDecoder：StateStart：processMessage（）【if(msg.what == CMD_START){ if (decodeMessageParams((RilMessage)msg.obj)){} }】（接收消息）—&gt;
decodeMessageParams()【case StkService.MSG_ID_PROACTIVE_COMMAND:   mCmdParamsFactory.make(BerTlv.decode(rawData));】—&gt;
CommandParamsFactory：make（）【if (!cmdPending) {sendCmdParams（）；}】—&gt;
sendCmdParams（）【mCaller.sendMsgParamsDecoded(resCode, mCmdParams);】
 
RilMessageDecoder：sendMsgParamsDecoded（）【Message msg = obtainMessage(RilMessageDecoder.CMD_PARAMS_READY);】（发送消息）—&gt;
RilMessageDecoder ：StateCmdParamsReady：processMessage（）【msg.what == CMD_PARAMS_READY{ sendCmdForExecution(mCurrentRilMessage);}】（接收到消息）
RilMessageDecoder： sendCmdForExecution（）【StkService.MSG_ID_RIL_MSG_DECODED】（发送消息StkService .MSG_ID_RIL_MSG_DECODED）—&gt;
StkService :handleMessage()【case MSG_ID_RIL_MSG_DECODED:
            handleRilMsg((RilMessage) msg.obj);】（接收MSG_ID_RIL_MSG_DECODED消息，同时调用handleRilMsg()发送消息MSG_ID_PROACTIVE_COMMAND）—&gt;
handleRilMsg（）【case MSG_ID_PROACTIVE_COMMAND: handleProactiveCommand（）】（接收消息MSG_ID_PROACTIVE_COMMAND，同时发送消息SET_UP_MENU）—&gt;
handleProactiveCommand（）【case SET_UP_MENU:
sendTerminalResponse(cmdParams.cmdDet, ResultCode.OK, false, 0,
                    null);
Intent intent = new Intent(AppInterface.STK_CMD_ACTION);
        intent.putExtra("STK CMD", cmdMsg);】（接收消息SET_UP_MENU，调用sendTerminalResponse（）下发终端响应请求，同时发送广播STK_CMD_ACTION）—&gt;
StkCmdReceiver：onReceive（）【
if (action.equals(AppInterface.STK_CMD_ACTION)) {
            handleCommandMessage(context, intent); }】（接收广播STK_CMD_ACTION，调用handleCommandMessage（））—&gt;
handleCommandMessage（）【args.putInt(StkAppService.OPCODE, StkAppService.OP_CMD);】（启动StkAppService,发送标签opcode为OP_CMD）—&gt;
StkAppService:onStart()【case OP_CMD: msg.obj = args.getParcelable(CMD_MSG); mServiceHandler.sendMessage(msg);】（接收消息OP_CMD，并装载新的消息为CMD_MSG发送）—&gt;
StkAppService:ServiceHandler ：handleMessage（）【case OP_CMD: handleCmd（）】（接收OP_CMD的消息，处理发送消息）—&gt;
handleCmd（）【case SET_UP_MENU: launchMenuActivity（）】（接收消息SET_UP_MENU,并启动MenuActivity）—&gt;
launchMenuActivity()【newIntent.setClassName(PACKAGE_NAME, MENU_ACTIVITY_NAME);】（启动MenuActivity显示）

第二条消息：SET_UP_ENVENT_LIST

StkService ：handleMessage()【case:MSG_ID_PROACTIVE_COMMAND (接收消息)
mMsgDecoder.sendStartDecodingMessageParams(new RilMessage(msg.what, data)】）—&gt;
RilMessageDecoder：sendStartDecodingMessageParams（）【Message msg = obtainMessage(CMD_START);】（发送消息）—&gt;
RilMessageDecoder：StateStart：processMessage（）【if(msg.what == CMD_START){ if (decodeMessageParams((RilMessage)msg.obj)){} }】（接收消息）—&gt;
decodeMessageParams()【case StkService.MSG_ID_PROACTIVE_COMMAND:   mCmdParamsFactory.make(BerTlv.decode(rawData));】—&gt;
CommandParamsFactory：make()
【default: sendCmdParams(ResultCode.CMD_TYPE_NOT_UNDERSTOOD);】—&gt;
sendCmdParams（）【mCaller.sendMsgParamsDecoded(resCode, mCmdParams);】—&gt;
RilMessageDecoder：sendMsgParamsDecoded（）【Message msg = obtainMessage(RilMessageDecoder.CMD_PARAMS_READY);】（发送消息）—&gt;
RilMessageDecoder ：StateCmdParamsReady：
processMessage（）【msg.what == CMD_PARAMS_READY{ sendCmdForExecution(mCurrentRilMessage);}】（接收到消息）—&gt;
RilMessageDecoder：
sendCmdForExecution（）【StkService.MSG_ID_RIL_MSG_DECODED】（发送消息StkService .MSG_ID_RIL_MSG_DECODED）—&gt;
 
StkService：
handleMessage()【case MSG_ID_RIL_MSG_DECODED
handleRilMsg((RilMessage) msg.obj);】(接收从RilMessageDecoder发送过来的解析消息并处理) —&gt;
 
handleRilMsg（）【case MSG_ID_PROACTIVE_COMMAND：
else {sendTerminalResponse(cmdParams.cmdDet,rilMsg.mResCode,false, 0, null);  }】（接收MSG_ID_PROACTIVE_COMMAND消息，由于此时的rilMsg.mResCode ！= ResultCode.OK）应调用sendTerminalResponse（），发送终端响应请求。—&gt;
 
sendTerminalResponse（）【mCmdIf.sendTerminalResponse(hexString, null);】（发送终端响应）—&gt;
 
RIL: sendTerminalResponse()【RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE】（下发消息请求）—&gt;

第三条消息：MSG_ID_SESSION_END

RIL: processUnsolicited()【case RIL_UNSOL_STK_SESSION_END:
mStkSessionEndRegistrant.notifyRegistrant】（上报会话结束）—&gt;
 
StkService :handleMessage()【case MSG_ID_SESSION_END：
mMsgDecoder.sendStartDecodingMessageParams(new RilMessage(msg.what, data));】（接收MSG_ID_SESSION_END消息，同时调用sendStartDecodingMessageParams ()解析消息）—&gt;
 
RilMessageDecoder：sendStartDecodingMessageParams（）【Message msg = obtainMessage(CMD_START);】（发送消息）—&gt;
 
RilMessageDecoder：StateStart：processMessage（）【if(msg.what == CMD_START){ if (decodeMessageParams((RilMessage)msg.obj)){} }】（接收消息）—&gt;
decodeMessageParams()【case StkService.MSG_ID_SESSION_END:   sendCmdForExecution(mCurrentRilMessage);】—&gt;
 
sendCmdForExecution（）【StkService.MSG_ID_RIL_MSG_DECODED】（发送消息StkService .MSG_ID_RIL_MSG_DECODED）—&gt;
 
StkService :handleMessage()【case MSG_ID_RIL_MSG_DECODED:
            handleRilMsg((RilMessage) msg.obj);】（接收MSG_ID_RIL_MSG_DECODED消息，同时调用handleRilMsg()发送消息MSG_ID_SESSION_END）—&gt;
 
handleRilMsg（）【case MSG_ID_SESSION_END: handleSessionEnd();】（接收消息MSG_ID_SESSION_END，调用handleSessionEnd()）—&gt;
 
handleSessionEnd()
【Intent intent = new Intent(AppInterface.STK_SESSION_END_ACTION);
        mContext.sendBroadcast(intent);】（发送广播STK_SESSION_END_ACTION）—&gt;
StkCmdReceiver：onReceive（）【
else if (action.equals(AppInterface.STK_SESSION_END_ACTION)) {
            handleSessionEnd(context, intent);】
（接收广播STK_SESSION_END_ACTION，调用handleSessionEnd（））—&gt;
handleSessionEnd（）【args.putInt(StkAppService.OPCODE, StkAppService.OP_END_SESSION);】（启动StkAppService,发送标签opcode为OP_END_SESSION）—&gt;
StkAppService:onStart()【case OP_END_SESSION: mServiceHandler.sendMessage(msg);】（接收消息OP_END_SESSION，转发消息OP_END_SESSION）—&gt;
StkAppService:ServiceHandler ：handleMessage（）【case OP_END_SESSION: handleSessionEnd();（）】（接收OP_END_SESSION的消息，处理发送消息）—&gt;
handleSessionEnd()【launchMenuActivity（）和launchBrowser（）】（）—&gt;
launchMenuActivity()【newIntent.setClassName(PACKAGE_NAME, MENU_ACTIVITY_NAME);】（启动MenuActivity显示）
launchBrowser（）

猜你喜欢