一.简介

      STK 或者 UTK 就是 Sim Tool Kit （sim卡工具包）,定制了一系列与运营商相关的应用（查询天气，话费，彩铃等），可以理解为安装在SIM卡上的应用。运营商将相关应用信息保存在SIM卡中，STK应用需要从SIM卡中读取相关应用信息，SIM卡也会向STK应用主动上报应用信息。

     我们知道SIM卡是插在Modem中的，要读取SIM卡的内容，就必须要经过Modem层，而与Modem层进行交互离不开AT指令。在framework中，发送AT指令主要是在RIL中完成的。所以读取SIM卡的内容的流程可以归结为：STK应用---->RILJ---->RILC---->Modem---->运营商的基站。而这里只需要跟踪一下STK应用到RIL的RILJ层就可以了，以后有空可以研究一下RILC层的代码。

      既然最后到达的是RIL层，那么我们从RIL层往STK应用层反推它的流程。看看从SIM卡中读取的信息是怎样到达STK应用的。在我们插卡开机的时候，Modem检测到有卡插入，这时候它会读取SIM中的相关信息，并把消息上报给RIL层。Modem上报消息的过程这里先不管。我们只研究RIL，要研究RIL层，我们需要先了解一下RIL层的消息分类。

二.RIL中的消息类型

RIL中的消息类型主要分为两种：
solicited response message: 比如拨号，接听，挂断等这些做主动请求的操作的消息
unsolicited response message：GSM/GPRS Modem硬件模块主动上报的，例如来电，接收短信，基站信息等消息。是从硬件来的消息，RIL层被动接收。

STK应用在RIL中的消息有：
solicited：
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
RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING
RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS
UnSolicited：
RIL_UNSOL_STK_SESSION_END
RIL_UNSOL_STK_PROACTIVE_COMMAND  // 显示菜单
RIL_UNSOL_STK_EVENT_NOTIFY
RIL_UNSOL_STK_CALL_SETUP

无论是哪一种消息，从Modem处上传上来的信息，它的处理过程大体一致。我们只需要沿着具体一个消息的进行追踪，就可以弄清楚它的流程走向。这里我们研究一下UnSolicited的这个消息RIL_UNSOL_STK_PROACTIVE_COMMAND。

三.流程分析

      在插卡开机的时候，Modem读取此SIM卡中STK显示的菜单，并向RIL层发送RIL_UNSOL_STK_PROACTIVE_COMMAND消息。这个消息被RILReceiver捕获并处理，从这里开始。流程分三个部分，分别是：1.RILJ部分。2.Framework部分。3.STK部分（应用层）

1.RILJ部分

RILReceiver是RIL的内部类，负责监听Socket消息，从Socket中接收并处理RILC上报的消息。（RILJ与RILC的通信主要通过Socket）其逻辑是：
一．    维护Socket的连接。
二．    把从Socket中读取到的消息交给RIL中processResponse()方法处理。

这个方法主要是根据消息的两种类型，做分别的处理。Parcel存储着从Socket中读取的信息。
Parcel：Parcel就是一个存放读取数据的容器， Android系统中的binder进程间通信(IPC)就使用了Parcel类来进行客户端与服务端数据的交互，而且AIDL的数据也是通过Parcel来交互的。在Java空间和C++都实现了Parcel，由于它在C/C++中，直接使用了内存来读取数据，因此，它更有效率。

 private void processResponse (Parcel p) {
        int type;
        type = p.readInt();
        if (type == RESPONSE_UNSOLICITED) {
            processUnsolicited (p);
        } else if (type == RESPONSE_SOLICITED) {
            RILRequest rr = processSolicited (p);
            if (rr != null) {
                rr.release();
                decrementWakeLock();
            }
        }
}

主要研究UnSolicited消息，所以来看看processUnsolicited做了什么。

protected void processUnsolicited (Parcel p) {
        int response;
        Object ret;
        response = p.readInt(); //获取UnSolicited Response消息类型
        try {switch(response) {  //根据UnSolicited Response消息类型获取不同的ret对象
....
case RIL_UNSOL_STK_SESSION_END: ret = responseVoid(p); break;
   case RIL_UNSOL_STK_PROACTIVE_COMMAND: ret = responseString(p); break;
   case RIL_UNSOL_STK_EVENT_NOTIFY: ret = responseString(p); break;
   case RIL_UNSOL_STK_CALL_SETUP: ret = responseInts(p); break;
...
}
       switch(response) { //根据UnSolicited Response消息类型发出不同的消息通知
...
            case RIL_UNSOL_STK_PROACTIVE_COMMAND:
                if (RILJ_LOGD) unsljLogRet(response, ret);
                if (mCatProCmdRegistrant != null) {
                    mCatProCmdRegistrant.notifyRegistrant(
                                        new AsyncResult (null, ret, null));
                }
                break;
...
   }
}

2.Framework部分

这个notifyRegistrant()方法是调用的哪个类里边的呢。我们来看看mCatProCmdRegistrant这个变量：protected Registrant mCatProCmdRegistrant;

Registrant.java
    public void notifyRegistrant(AsyncResult ar) {
        internalNotifyRegistrant (ar.result, ar.exception);
    }
    void internalNotifyRegistrant (Object result, Throwable exception) {
        Handler h = getHandler();
        if (h == null) {
            clear();
        } else {
            Message msg = Message.obtain();
            msg.what = what;
            msg.obj = new AsyncResult(userObj, result, exception);
            h.sendMessage(msg);
        }
    } 

很明显，这个Registrant.java是Android里的消息处理机制，用一个类把Handler发送消息的操作封装起来，并做了异步的处理。当需要此Handler发送消息时，只需要调用这个消息通知的方法notifyRegistrant()即可。
那么，mCatProCmdRegistrant这个变量是怎么初始化的呢？由于RIL.java继承了BaseCommands.java，在这个方法中，定义了mCatProCmdRegistrant变量并提供了set方法。

BaseCommands.java
protected Registrant mCatProCmdRegistrant;
    @Override
    public void setOnCatProactiveCmd(Handler h, int what, Object obj) {
        mCatProCmdRegistrant = new Registrant (h, what, obj);
    }

而调用这个setOnCatProactiveCmd()方法的，在CatService.java中，如下：CatService.java的构造方法不仅仅设置了MSG_ID_PROACTIVE_COMMAND这个消息的Handler，还设置了其他消息的Handler。

CatService.java
构造方法：
 mCmdIf.setOnCatSessionEnd(this, MSG_ID_SESSION_END, null);
 mCmdIf.setOnCatProactiveCmd(this, MSG_ID_PROACTIVE_COMMAND, null);//Handler的what标示是MSG_ID_PROACTIVE_COMMAND
  mCmdIf.setOnCatEvent(this, MSG_ID_EVENT_NOTIFY, null);
  mCmdIf.setOnCatCallSetUp(this, MSG_ID_CALL_SETUP, null);
好了，到这里我们先整理一下：
插卡开机，Medem读取SIM卡信息，上报RIL_UNSOL_STK_PROACTIVE_COMMAND消息。RIlJ中的RILReceiver类进行接收并交给processUnsolicited()方法处理。processUnsolicited()方法根据消息类型通知对应的Handler处理（）。而这些Handler的处理在CatService.java的handleMessage()方法中，如下：

    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) { 
        case MSG_ID_PROACTIVE_COMMAND:
            String data = null;
            if (msg.obj != null) {
                AsyncResult ar = (AsyncResult) msg.obj;
                if (ar != null && ar.result != null) {
                    try {
                        data = (String) ar.result;
                    } catch (ClassCastException e) {
                        break;
                    }
                }
            }
            if (lastCmd != null && data != null && lastCmd.equals(data)) {
                CatLog.d(this, "<" + mPhoneId + ">" + "duplicate command, ignored !!");
                break;
            }
            if (data != null) {
                lastCmd = new String(data);
            } else {
                lastCmd = null;
            }
            if(MSG_ID_PROACTIVE_COMMAND == msg.what && null != data) {
                if((mSetupMenuFlag&(1<<mPhoneId))==0 && isSetupMenuCMD(data)) {
                    saveSetupMenuData(data);
                }
            }
            mMsgDecoder.sendStartDecodingMessageParams(new RilMessage(msg.what, data));
            break;
        case MSG_ID_RIL_MSG_DECODED:
            handleRilMsg((RilMessage) msg.obj);
            break;
}

查看HandleMessage()方法中的MSG_ID_PROACTIVE_COMMAND消息处理。最后会调用mMsgDecoder.sendStartDecodingMessageParams(new RilMessage(msg.what, data))这个方法：

RilMessageDecoder.java
    public void sendStartDecodingMessageParams(RilMessage rilMsg) {
        Message msg = obtainMessage(CMD_START);
        msg.obj = rilMsg;
        sendMessage(msg);
    }

    private class StateStart extends State {
        @Override
        public boolean processMessage(Message msg) {
            if (msg.what == CMD_START) {
                if (decodeMessageParams((RilMessage)msg.obj)) {
                    transitionTo(mStateCmdParamsReady);
                }
            } else {
                CatLog.d(this, "StateStart unexpected expecting START=" +
                         CMD_START + " got " + msg.what);
            }
            return true;
        }
    }

这个方法最后也是通过发送CMD_START消息，交给StateStart.java处理，decodeMessageParams()这个方法主要是解码，具体的解码过程需要查看Bertlv.java里的代码。从CMD_START消息的发送到解码结束这个过程，流程有点复杂，这里就不做具体的分析了，解码结束后，会发送MSG_ID_RIL_MSG_DECODED消息，查看CatService.java的handleMessage()方法，是的，它又回到了CatService.java中。在这个类中，频繁的使用了Handler的消息机制，我们只要关注好Handler的what标识就可以了。接下来会执行handleRilMsg()方法：

private void handleRilMsg(RilMessage rilMsg) {
       case MSG_ID_PROACTIVE_COMMAND:
            try {
                cmdParams = (CommandParams) rilMsg.mData;
            } catch (ClassCastException e) {
                // for error handling : cast exception
                CatLog.d(this, "Fail to parse proactive command");
                sendTerminalResponse(mCurrntCmd.mCmdDet, ResultCode.CMD_DATA_NOT_UNDERSTOOD,
                                     false, 0x00, null);
                break;
            }
            if (cmdParams != null) {
                if (rilMsg.mResCode == ResultCode.OK ||
                    // ignore icon problem
                    rilMsg.mResCode == ResultCode.PRFRMD_ICON_NOT_DISPLAYED) {
                    handleProactiveCommand(cmdParams);
                } else {
                    // for proactive commands that couldn't be decoded
                    // successfully respond with the code generated by the
                    // message decoder.
                    sendTerminalResponse(cmdParams.mCmdDet, rilMsg.mResCode,
                            false, 0, null);
                }
            }
            break;
}

查看handleProactiveCommand()最后的一段代码，发现它发送一个广播，那这个广播是谁接收的呢？查看AppInterface.CAT_CMD_ACTION这个变量存储的包名是：android.intent.action.stk.command。

private void handleProactiveCommand(CommandParams cmdParams) { 
       Intent intent = new Intent(AppInterface.CAT_CMD_ACTION);
        intent.putExtra("STK CMD", cmdMsg);
        intent.putExtra("phone_id", mPhoneId);
        intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
        mContext.sendBroadcast(intent);
}

通过搜索这个包名，我们可以追溯到了STK应用中的AndroidManifest.xml中，看看这里，定义了一个receiver来接收来自framework中的广播。至此，流程跟踪到了STk应用层。

3.STK部分（应用层）

AndroidManifest.xml：

 <receiver android:name="com.android.stk.StkCmdReceiver" >
            <intent-filter>
                <action android:name="android.intent.action.stk.command" />
                <action android:name="android.intent.action.stk.session_end" />
                <action android:name="android.intent.action.stk.event" />
                <action android:name="android.intent.action.LOCALE_CHANGED" />
            </intent-filter>
 </receiver>

StkCmdReceiver主要负责从接收来自framework中的广播，并启动StkAppService服务。

public class StkCmdReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        int phoneId = intent.getIntExtra(StkAppService.PHONE_ID, 0);
        if(action.equals(AppInterface.CAT_CMD_EVENT) || Intent.ACTION_LOCALE_CHANGED.equals(action)) {
            handleEventDownload(context, intent);
            return;
        }
        if (phoneId == StkAppService.PHONE_ID_NUM) {
            if (action.equals(AppInterface.CAT_CMD_ACTION)) {
                handleCommandMessage(context, intent);
            } else if (action.equals(AppInterface.CAT_SESSION_END_ACTION)) {
                handleSessionEnd(context, intent);
            }
        }
    }
    private void handleCommandMessage(Context context, Intent intent) {
        Bundle args = new Bundle();
        args.putInt(StkAppService.OPCODE, StkAppService.OP_CMD);
        args.putParcelable(StkAppService.CMD_MSG, intent
                .getParcelableExtra("STK CMD"));
        context.startService(new Intent(context, StkAppService.class)
                .putExtras(args));
    }
}

这个StkAppService是STK中的核心服务，它主要负责调度各个显示层显示相应的数据。

StkAppService.java
  public void onStart(Intent intent, int startId) {
        Bundle args = intent.getExtras();
        if (args == null) {
            return;
        }
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = args.getInt(OPCODE);
        switch(msg.arg1) {
        case OP_CMD:
            msg.obj = args.getParcelable(CMD_MSG);
            break;
        }
...
mServiceHandler.sendMessage(msg);
}

    private final class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            int opcode = msg.arg1;
            switch (opcode) {
            case OP_CMD:
                CatCmdMessage cmdMsg = (CatCmdMessage) msg.obj;
                if (!isCmdInteractive(cmdMsg)) {
                    handleCmd(cmdMsg);
                } else {
                    if (!mCmdInProgress) {
                        mCmdInProgress = true;
                        handleCmd((CatCmdMessage) msg.obj);
                    } else {
                        mCmdsQ.addLast(new DelayedCmd(OP_CMD,
                                (CatCmdMessage) msg.obj));
                    }
                }
                break;
                }
       }
}

onStart()方法经过简单的处理，然后交给内部类ServiceHandler进行处理，根据类型的不同，交由不同的Activity显示。比如，这里交由handleCmd()方法：

private void handleCmd(CatCmdMessage cmdMsg) {
        if (cmdMsg == null) {
            return;
        }
        // save local reference for state tracking.
        mCurrentCmd = cmdMsg;
        CommandDetails cmddet = cmdMsg.getCmdDet();
        boolean waitForUsersResponse = true;

        CatLog.d(this, cmdMsg.getCmdType().name());
        switch (cmdMsg.getCmdType()) {
        case DISPLAY_TEXT:
            ….
        case SELECT_ITEM:
            mCurrentMenu = cmdMsg.getMenu();
            isSendSS = false;
            //launchMenuActivity(cmdMsg.getMenu());
            if (phoneIsIdle()) {
                launchMenuActivity(cmdMsg.getMenu());
                CatLog.d(this,"SELECT_ITEM start StkMenuActivity");
            } else {
                CatLog.d(this, "SELECT_ITEM is on call, mMenuIsVisibile = " + mMenuIsVisibile);
                if (mMenuIsVisibile) {
                    launchMenuActivity(cmdMsg.getMenu());
                    CatLog.d(this,"mMenuIsVisibile start StkMenuActivity");
                }
                return;
            }
            break;
       }
}

启动某个Activity显示：

private void launchMenuActivity(Menu menu) {
        Intent newIntent = new Intent(Intent.ACTION_VIEW);
        newIntent.setClassName(PACKAGE_NAME, MENU_ACTIVITY_NAME);
        int intentFlags = Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_CLEAR_TOP;
        if (menu == null) {
            // We assume this was initiated by the user pressing the tool kit icon
            intentFlags |= getFlagActivityNoUserAction(InitiatedByUserAction.yes);

            newIntent.putExtra("STATE", StkMenuActivity.STATE_MAIN);
        } else {
            // We don't know and we'll let getFlagActivityNoUserAction decide.
            intentFlags |= getFlagActivityNoUserAction(InitiatedByUserAction.unknown);

            newIntent.putExtra("STATE", StkMenuActivity.STATE_SECONDARY);
        }
        newIntent.setFlags(intentFlags);
        CatLog.d(this, "launchMenuActivity: intent=" + newIntent + ", mCurrentMenu="+ mCurrentMenu);
        mContext.startActivity(newIntent);
        mStkMenuRef = true;
}

至此，开机显示STK信息的流程就追踪结束了。当然STK应用层面的东西还是很多的，在这一章就不打算再分析了，如果后面有时间，再继续看看。
StkLauncherActivity.java：入口类
StkMenuActivity.java  主页面（信息列表）
StkInputActivity.java   输入页面
StkDialogActivity.java  对话框页面
StkAppInstaller.java    这个类主要用来设置是否在桌面上显示这个STK图标
StkCmdReceiver.java   接收广播