Android短信发送流程

插入卡后的初始化流程：

插卡 --〉modem sms 初始化 --〉读卡里的SMSC--〉AP 下AT来查询SMSC --〉AP 下AT发送SMS --〉modem 返回SMS 发送的结果

 

基本流程：

短信始发和短消息的终结是两个完全独立的过程

 

短信发送AP代码流程：

  

短信发送的modem日志：

(UE->NW)CP-DATA[包含SMS的文本内容；包含RP-DATA]     

(UE<-NW)CP-ACK [简单响应收到上一个CP-DATA；不包含RP]

(UE<-NW)CP-DATA[如果短信有什么异常或网络拒绝等异常cause会携带在里面；包含RP-ACK或者是RP-ERROR，响应上面的RP-DATA]

(UE->NW)CP-ACK [简单响应NW收到了上一个CP-DATA；不包含RP]

 

AP详细代码流程：

@RIL.java
case RIL_UNSOL_RESPONSE_NEW_SMS: {
        if (RILJ_LOGD) unsljLog(response);

        mEventLog.writeRilNewSms(response);

        // FIXME this should move up a layer
        String a[] = new String[2];

        a[1] = (String)ret;

        SmsMessage sms;

        sms = SmsMessage.newFromCMT(a);
        if (mGsmSmsRegistrant != null) {
            mGsmSmsRegistrant
                .notifyRegistrant(new AsyncResult(null, sms, null));
        }
    break;
    }

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

@GsmInboundSmsHandler.java
  private GsmInboundSmsHandler(Context context, SmsStorageMonitor storageMonitor,
          Phone phone) {
      super("GsmInboundSmsHandler", context, storageMonitor, phone,
              GsmCellBroadcastHandler.makeGsmCellBroadcastHandler(context, phone));
      phone.mCi.setOnNewGsmSms(getHandler(), EVENT_NEW_SMS, null);
      mDataDownloadHandler = new UsimDataDownloadHandler(phone.mCi);
  }

@GsmSMSDispatcher.java
public GsmSMSDispatcher(Phone phone, SmsUsageMonitor usageMonitor,
       ImsSMSDispatcher imsSMSDispatcher,
          GsmInboundSmsHandler gsmInboundSmsHandler) {
                super(phone, usageMonitor, imsSMSDispatcher);
                mCi.setOnSmsStatus(this, EVENT_NEW_SMS_STATUS_REPORT, null);
                mGsmInboundSmsHandler = gsmInboundSmsHandler;
                mUiccController = UiccController.getInstance();
                mUiccController.registerForIccChanged(this, EVENT_ICC_CHANGED, null);
                Rlog.d(TAG, "GsmSMSDispatcher created");
}

@InboundSmsHandler.java
        private class IdleState extends State {
                public boolean processMessage(Message msg) {
            log("IdleState.processMessage:" + msg.what);
            if (DBG) log("Idle state processing message type " + msg.what);
            switch (msg.what) {
                case EVENT_NEW_SMS:
                    deferMessage(msg);
                    transitionTo(mDeliveringState);
                    return HANDLED;
                                       
        private class DeliveringState extends State {
                @Override
        public boolean processMessage(Message msg) {
            log("DeliveringState.processMessage:" + msg.what);
            switch (msg.what) {
                case EVENT_NEW_SMS:
                    // handle new SMS from RIL
                    handleNewSms((AsyncResult) msg.obj);
                    sendMessage(EVENT_RETURN_TO_IDLE);
                    return HANDLED;
                                       
        private void handleNewSms(AsyncResult ar) {
           SmsMessage sms = (SmsMessage) ar.result;
           result = dispatchMessage(sms.mWrappedSmsMessage);
                  
                  
        private int dispatchMessage(SmsMessageBase smsb) {
                dispatchMessageRadioSpecific

@GsmInboundSmsHandler.java
        protected int dispatchMessageRadioSpecific(SmsMessageBase smsb) {
                 dispatchNormalMessage(smsb);

@InboundSmsHandler.java
        protected int dispatchNormalMessage(SmsMessageBase sms) {
                //获取短信的PDU包，然后把pdu包放在一个tracker实例
                 tracker = TelephonyComponentFactory.getInstance().makeInboundSmsTracker(sms.getPdu(),
                   sms.getTimestampMillis(), destPort, is3gpp2(),
                   sms.getDisplayOriginatingAddress(), concatRef.refNumber, concatRef.seqNumber,
                   concatRef.msgCount, false, sms.getMessageBody());
                       
                return addTrackerToRawTableAndSendMessage(tracker,
                        tracker.getDestPort() == -1 /* de-dup if text message */);

                       
        protected int addTrackerToRawTableAndSendMessage(InboundSmsTracker tracker, boolean deDup) {
           switch(addTrackerToRawTable(tracker, deDup)) {
               case Intents.RESULT_SMS_HANDLED:
                   sendMessage(EVENT_BROADCAST_SMS, tracker);
                   return Intents.RESULT_SMS_HANDLED;

               case Intents.RESULT_SMS_DUPLICATED:
                   return Intents.RESULT_SMS_HANDLED;

               case Intents.RESULT_SMS_GENERIC_ERROR:
               default:
               return Intents.RESULT_SMS_GENERIC_ERROR;
           }
        }
       
         private int addTrackerToRawTable(InboundSmsTracker tracker, boolean deDup) {
                //把消息添加到数据库中


        private class DeliveringState extends State {  //处理EVENT_BROADCAST_SMS事件
           case EVENT_BROADCAST_SMS:
               // if any broadcasts were sent, transition to waiting state
               InboundSmsTracker inboundSmsTracker = (InboundSmsTracker) msg.obj;
               if (processMessagePart(inboundSmsTracker)) {
                   transitionTo(mWaitingState);
               } else {
               // if event is sent from SmsBroadcastUndelivered.broadcastSms(), and
               //processMessagePart() returns false, the state machine will be stuck in
               // DeliveringState until next message is received. Send message to
               // transition to idle to avoid that so that wakelock can be released
               log("No broadcast sent on processing EVENT_BROADCAST_SMS in Delivering " +
                       "state. Return to Idle state");
               sendMessage(EVENT_RETURN_TO_IDLE);
           }
           return HANDLED;

        private boolean processMessagePart(InboundSmsTracker tracker) {  //把track解析出PDU包
                //单条短信
                if (messageCount == 1) {
                                // single-part message
                                pdus = new byte[][]{tracker.getPdu()};
                } else { //多条短信
                        ......
                }
                //创建广播接收者
                SmsBroadcastReceiver resultReceiver = new SmsBroadcastReceiver(tracker);
                //彩信的情况
                if (destPort == SmsHeader.PORT_WAP_PUSH) {
                }
                dispatchSmsDeliveryIntent(pdus, tracker.getFormat(), destPort, resultReceiver);

        private void dispatchSmsDeliveryIntent(byte[][] pdus, String format, int destPort,
                BroadcastReceiver resultReceiver) {
                //说明Framework完成对SMS的解析并要求发送广播给上层APP
                log("Delivering SMS to: " + componentName.getPackageName() +
                    " " + componentName.getClassName());
                //定义接收的action
                intent.setAction(Intents.DATA_SMS_RECEIVED_ACTION);
                dispatchIntent(intent, android.Manifest.permission.RECEIVE_SMS,
                                        AppOpsManager.OP_RECEIVE_SMS, options, resultReceiver, UserHandle.SYSTEM);
                                       
                                       
        public void dispatchIntent(Intent intent, String permission, int appOp,
                Bundle opts, BroadcastReceiver resultReceiver, UserHandle user) {
                //把pdu通过intent广播出去，后续只要定义接收器，action是DATA_SMS_RECEIVED_ACTION就可以了
                mContext.sendOrderedBroadcastAsUser(intent, targetUser, permission, appOp, opts,
                                                        users[i] == UserHandle.USER_SYSTEM ? resultReceiver : null,
                                                        getHandler(), Activity.RESULT_OK, null, null);