短信接收--短信的接收流程应用层

短信的接收流程应用层

一、源文件

这部分代码在packages/apps/Mms下，涉及的主要类：

[plain]  view plain copy

1. com.android.mms.transaction.PrivilegedSmsReceiver  
2. com.android.mms.transaction.SmsReceiver  
3. com.android.mms.transaction.SmsReceiverService  
4. com.android.mms.transaction.MessagingNotification  

二、图解

短信接收的时序图：

注意：SeviceHandler是SmsReceiverService的内部类，SmsReceiver是PrivlegedSmsReceiver的父类；

三、详细分析

3.1 PrivilegedSmsReceiver到SmsReceiverService

1） PrivilegedSmsReceiver这个接收器从中间才能获取数据

      PrivilegedSmsReceiver是一个广播接收器而且继承自SmsReceiver，在AndroidManifest.xml 中有以下声明：

[plain]  view plain copy

1. <intent-filter>  
2.             <action android:name="android.provider.Telephony.SMS_RECEIVED" />  
3.         </intent-filter>  

android.provider.Telephony.SMS_RECEIVED该action在那被使用到了？若是你们有看过度析中间层的接收流程的童鞋就很清楚了，中间层处理接收到的短信的时侯最后会调用到SMSDispatcher的protected void dispatchPdus(byte[][] pdus) 方法，让咱们回眸一下：

[plain]  view plain copy

1. protected void dispatchPdus(byte[][] pdus) {  
2.      Intent intent = new Intent(Intents.SMS_RECEIVED_ACTION);  
3.      intent.putExtra("pdus", pdus);  
4.      intent.putExtra("encoding", getEncoding());  
5.      intent.putExtra("sub_id", mPhone.getSubscription()); //Subscription information to be passed in an intent  
6.      dispatch(intent, "android.permission.RECEIVE_SMS");  
7.  }  

你们确定会问dispatch又干了些什么了？ 请看下面：

[plain]  view plain copy

1. void dispatch(Intent intent, String permission) {  
2.      mWakeLock.acquire(WAKE_LOCK_TIMEOUT);  
3.      mContext.sendOrderedBroadcast(intent, permission, mResultReceiver,  
4.              this, Activity.RESULT_OK, null, null);  
5.  }  

看到这就不用我多说了吧，很显然是发送了一个叫作Intents.SMS_RECEIVED_ACTION的广播，那又有人刨根问底儿了，上面两个值同样吗？请看intent中对该变量的定义：

[plain]  view plain copy

1. @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)  
2.         public static final String SMS_RECEIVED_ACTION =  
3.                 "android.provider.Telephony.SMS_RECEIVED";  

到这你们应该明白PrivilegedSmsReceiver会接收到中间层的广播，而且该广播很不通常它承载了短信的内容，它从中间层接过接力棒继续向上传递。

2） PrivilegedSmsReceiver传递数据

     PrivilegedSmsReceiver从中间层获取到短信的数据后会调用onReceiveWithPrivilege（）方法，该方法定义在它的父类SmsReceiver中。该方法没有作太多的操做，仅仅是传递消息，一下是其核心代码：

[plain]  view plain copy

1. protected void onReceiveWithPrivilege(Context context, Intent intent, boolean privileged) {  
2.       if (!privileged && (intent.getAction().equals(Intents.SMS_RECEIVED_ACTION)  
3.               || intent.getAction().equals(Intents.SMS_CB_RECEIVED_ACTION))) {  
4.           return;  
5.       }  
6.   
7.       intent.setClass(context, SmsReceiverService.class);  
8.       intent.putExtra("result", getResultCode());  
9.       beginStartingService(context, intent);  
10.   }  

它将处理短信的任务交到SmsReceiverService的手中，SmsReceiverService才是真正干活的家伙。

3）SmsReceiverService处理

SmsReceiverService它是一个服务，当它开启的时候：首先是在onCreate中初始化，其中初始化最重要的工做就是实例化ServiceHandler对象，ServiceHandler该类是SmsReceiverService的一个内部类，继承自Handler，如下是它的定义代码：

[plain]  view plain copy

1. private final class ServiceHandler extends Handler {  
2.         public ServiceHandler(Looper looper) {  
3.             super(looper);  
4.         }  
5.         /**  
6.          * Handle incoming transaction requests.  
7.          * The incoming requests are initiated by the MMSC Server or by the MMS Client itself.  
8.          */  
9.         @Override  
10.         public void handleMessage(Message msg) {  
11.             int serviceId = msg.arg1;  
12.             Intent intent = (Intent)msg.obj;  
13.             if (intent != null) {  
14.                 String action = intent.getAction();  
15.   
16.                 int error = intent.getIntExtra("errorCode", 0);  
17.   
18.                 if (MESSAGE_SENT_ACTION.equals(intent.getAction())) {  
19.                     handleSmsSent(intent, error);  
20.                 } else if (SMS_RECEIVED_ACTION.equals(action)) {  
21.                     handleSmsReceived(intent, error);  
22.                 } else if (SMS_CB_RECEIVED_ACTION.equals(action)) {  
23.                     handleCbSmsReceived(intent, error);  
24.                 } else if (ACTION_BOOT_COMPLETED.equals(action)) {  
25.                     handleBootCompleted();  
26.                 } else if (TelephonyIntents.ACTION_SERVICE_STATE_CHANGED.equals(action)) {  
27.                     handleServiceStateChanged(intent);  
28.                 } else if (ACTION_SEND_MESSAGE.endsWith(action)) {  
29.                     handleSendMessage(intent);  
30.                 }  
31.             }  
32.             // NOTE: We MUST not call stopSelf() directly, since we need to  
33.             // make sure the wake lock acquired by AlertReceiver is released.  
34.             SmsReceiver.finishStartingService(SmsReceiverService.this, serviceId);  
35.         }  
36.     }  

走到这咱们能够看出该对象的重要性，便是处理短信真正的苦力，咱们继续看是怎么调用到这的。

onCreate走完请看  onStartCommand方法：

   

[plain]  view plain copy

1. @Override  
2. public int onStartCommand(Intent intent, int flags, int startId) {  
3.     mResultCode = intent != null ? intent.getIntExtra("result", 0) : 0;  
4.     Message msg = mServiceHandler.obtainMessage();  
5.     msg.arg1 = startId;  
6.     msg.obj = intent;  
7.     mServiceHandler.sendMessage(msg);  
8.     return Service.START_NOT_STICKY;  
9. }  

看到吗，到这它已经顺利脱手交给 ServiceHandler对象去异步处理。

4）ServiceHandler处理接收到的短信

  根据不一样的action处理，因为这里是短信的接收SMS_RECEIVED_ACTION，因此调用 handleSmsReceived(intent, error)方法，该方法的处理逻辑以下所示：

 说明在insertMessage方法时会判断当前是替换仍是插入，对于替换短信，笔者不是很清楚在什么状况下会走这条路。blockingUpdateNewMessageIndicator方法会用notification提醒用户，而且在方法内会判断当前用户是否须要显示发送报告。

3.2 刷新会话列表

        走到上面的代码，短信已经入库，但界面的刷新是如何实现的了？

1）会话列表的初始化

        ConversationList继承自ListActivity，用于显示短信的会话列表，在该类的onStart方法里有调用了一个重要的方法startAsyncQuery（）方法：

[plain]  view plain copy

1. private void startAsyncQuery() {  
2.     try {  
3.         setTitle(getString(R.string.refreshing));  
4.         setProgressBarIndeterminateVisibility(true);  
5.   
6.         Conversation.startQueryForAll(mQueryHandler, THREAD_LIST_QUERY_TOKEN);  
7.     } catch (SQLiteException e) {  
8.         SqliteWrapper.checkSQLiteException(this, e);  
9.     }  
10. }  

解析：

startQueryForAll方法定义：

[plain]  view plain copy

1. public static void startQueryForAll(AsyncQueryHandler handler, int token) {  
2.     handler.cancelOperation(token);  
3.     handler.startQuery(token, null, sAllThreadsUri,  
4.             ALL_THREADS_PROJECTION, null, null, Conversations.DEFAULT_SORT_ORDER);  
5. }  

这里会使用mQueryHandler去查询数据库，查询完后会回调该对象的onQueryComplete方法，在该方法里填充了mListAdapter，使得会话列表得以显示到界面上。如下代码是其定义：

[plain]  view plain copy

1. private final class ThreadListQueryHandler extends AsyncQueryHandler {  
2.         public ThreadListQueryHandler(ContentResolver contentResolver) {  
3.             super(contentResolver);  
4.         }  
5.         @Override  
6.         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {  
7.             switch (token) {  
8.             case THREAD_LIST_QUERY_TOKEN:  
9.                 mListAdapter.changeCursor(cursor);  
10.                 setTitle(mTitle);  
11.                 setProgressBarIndeterminateVisibility(false);  
12.   
13.                 if (mNeedToMarkAsSeen) {  
14.                     mNeedToMarkAsSeen = false;  
15.                     Conversation.markAllConversationsAsSeen(getApplicationContext());  
16.                     // Database will be update at this time in some conditions.  
17.                     // Wait 1s and ensure update complete.  
18.                     mQueryHandler.postDelayed(new Runnable() {  
19.                         public void run() {  
20.                             // Delete any obsolete threads. Obsolete threads are threads that aren't  
21.                             // referenced by at least one message in the pdu or sms tables.  
22.                             Conversation.asyncDeleteObsoleteThreads(mQueryHandler,  
23.                                     DELETE_OBSOLETE_THREADS_TOKEN);  
24.                         }  
25.                     }, 1000);  
26.                 }  
27.                 break;  
28.                        default:  
29.                 Log.e(TAG, "onQueryComplete called with unknown token " + token);  
30.             }  
31.         }  
32.   
33.            }  

这里为何要特别提到该对象了，后面更新的操做与它有着密不可分的关系。 mListAdapter该对象是ConversationListAdapter的对象，该对象在ConversationList的oncreate方法里调用 initListAdapter()进行的初始化。 initListAdapter()对adapter进行初始化：

[plain]  view plain copy

1. private void initListAdapter() {  
2.        mListAdapter = new ConversationListAdapter(this, null);  
3.        mListAdapter.setOnContentChangedListener(mContentChangedListener);  
4.        setListAdapter(mListAdapter);  
5.        getListView().setRecyclerListener(mListAdapter);  
6.    }  

mListAdapter.setOnContentChangedListener(mContentChangedListener);是当adapter的内容发生变化，会去执行监听器的onContentChanged的方法。那为了弄清楚 mContentChangedListener的定义，查看如下代码：

[plain]  view plain copy

1. private final ConversationListAdapter.OnContentChangedListener mContentChangedListener =  
2.      new ConversationListAdapter.OnContentChangedListener() {  
3.      public void onContentChanged(ConversationListAdapter adapter) {  
4.          startAsyncQuery();  
5.      }  
6.  };  

从新调用startAsyncQuery() 该方法刷新。

 2）会话列表的更新
         看到上面监听器所作的工做你们应该明白啦，会话列表的更新靠的就是这个监听器，当内容发生改变就会从新查询，界面进行刷新，到此为止 短信的界面刷新完成。

特别注意：该状况是用户在短信会话列表这个界面，若是不在这个界面大概还有其余两种状况：  一、在某个会话中；二、没有进入mms程序。对于前一种状况会在下面继续分析，对于后一种状况我想也不用多说在这种状况下会走activity的声明周期函数，在onstart方法里进行查询显示前面已经提到。那还有一种特殊的状况就是在从某个会话中返回到会话列表时的处理。下面请看ConversationList的声明：

[plain]  view plain copy

1. <activity android:name=".ui.ConversationList"  
2.             android:label="@string/app_label"  
3.             android:configChanges="orientation|keyboardHidden"  
4.             android:launchMode="singleTop">  

属性是singleTop，你们都知道这种状况会去调用onNewIntent方法：

[plain]  view plain copy

1. @Override  
2.   protected void onNewIntent(Intent intent) {  
3.       // Handle intents that occur after the activity has already been created.  
4.       startAsyncQuery();  
5.   }  

该方法又会去从新查询刷新界面。

3.23刷新会话内容

刷新ui除了刷新会话列表以外，还有一种状况就是当用户在某个会话时，这时该会话接收到新的消息，这时须要刷新会话的内容，这是怎么实现的？

 用于会话显示的activity：ComposeMessageActivity；用于显示会话的短信内容组件： MessageListView；填充listview的adapter是：MessageListAdapter

1）初始化

ComposeMessageActivity的onCreate方法调用initialize方法，initialize方法再调用initMessageList（）完成初始化

[plain]  view plain copy

1. private void initMessageList() {  
2.     if (mMsgListAdapter != null) {  
3.         return;  
4.     }  
5.     String highlightString = getIntent().getStringExtra("highlight");  
6.     Pattern highlight = highlightString == null  
7.         ? null  
8.         : Pattern.compile("\\b" + Pattern.quote(highlightString), Pattern.CASE_INSENSITIVE);  
9.     // Initialize the list adapter with a null cursor.  
10.     mMsgListAdapter = new MessageListAdapter(this, null, mMsgListView, true, highlight);  
11.     mMsgListAdapter.setOnDataSetChangedListener(mDataSetChangedListener);  
12.     mMsgListAdapter.setMsgListItemHandler(mMessageListItemHandler);  
13.     mMsgListView.setAdapter(mMsgListAdapter);  
14.     mMsgListView.setItemsCanFocus(false);  
15.     mMsgListView.setVisibility(View.VISIBLE);  
16.     mMsgListView.setOnCreateContextMenuListener(mMsgListMenuCreateListener);  
17.     mMsgListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {  
18.         public void onItemClick(AdapterView<?> parent, View view, int position, long id) {  
19.             if (view != null) {  
20.                 ((MessageListItem) view).onMessageListItemClick();  
21.             }  
22.         }  
23.     });  
24. }  

说明：MessageListAdapter定义了一个监听器当数据发生变化的时候回调监听器的onContentChanged的方法，该方法会从新查询该会话相关的内容并刷新显示，如下是其定义：

[plain]  view plain copy

1. private final MessageListAdapter.OnDataSetChangedListener  
2.                 mDataSetChangedListener = new MessageListAdapter.OnDataSetChangedListener() {  
3.     public void onDataSetChanged(MessageListAdapter adapter) {  
4.         mPossiblePendingNotification = true;  
5.     }  
6.     public void onContentChanged(MessageListAdapter adapter) {  
7.         startMsgListQuery();  
8.     }  
9. };  

2） MessageListAdapter内容的初始化

ComposeMessageActivity的onStart函数里面调用一个重要的方法loadMessageContent();该方法会继续调用startMsgListQuery()，在上面的adapter的监听器里当内容有变更时回调函数也会调用该方法，如下代码是该方法作的具体工做：

[plain]  view plain copy

1. private void startMsgListQuery() {  
2.     Uri conversationUri = mConversation.getUri();  
3.     if (conversationUri == null) {  
4.         return;  
5.     }  
6.     if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {  
7.         log("for " + conversationUri);  
8.     }  
9.     // Cancel any pending queries  
10.     mBackgroundQueryHandler.cancelOperation(MESSAGE_LIST_QUERY_TOKEN);  
11.     try {  
12.         // Kick off the new query  
13.         mBackgroundQueryHandler.startQuery(  
14.                 MESSAGE_LIST_QUERY_TOKEN, null, conversationUri,  
15.                 PROJECTION, null, null, null);  
16.     } catch (SQLiteException e) {  
17.         SqliteWrapper.checkSQLiteException(this, e);  
18.     }  
19. }  

分析：该方法所作的工做就是使用mBackgroundQueryHandler查询数据库（ mBackgroundQueryHandler是一个AsyncQueryHandler的对象），查询完成后会回调 mBackgroundQueryHandler该对象的onQueryComplete方法，如下是其核心代码：

[plain]  view plain copy

1. @Override  
2.         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {  
3.             switch(token) {  
4.                 case MESSAGE_LIST_QUERY_TOKEN:  
5.                     // Set last sub used in this conversation thread.  
6.                     if (cursor.getCount() > 0) {  
7.                         cursor.moveToLast();  
8.                         mLastSubInConv = cursor.getInt(COLUMN_SUB_ID); //TODO: ADD SUBSCRIPION HERE  
9.                         cursor.moveToPosition(-1);  
10.                     } else {  
11.                         mLastSubInConv = SUBSCRIPTION_ID_INVALID;  
12.                     }  
13.                     int newSelectionPos = -1;  
14.                     long targetMsgId = getIntent().getLongExtra("select_id", -1);  
15.                     if (targetMsgId != -1) {  
16.                         cursor.moveToPosition(-1);  
17.                         while (cursor.moveToNext()) {  
18.                             long msgId = cursor.getLong(COLUMN_ID);  
19.                             if (msgId == targetMsgId) {  
20.                                 newSelectionPos = cursor.getPosition();  
21.                                 break;  
22.                             }  
23.                         }  
24.                     }  
25.                     mMsgListAdapter.changeCursor(cursor);  
26.                     if (newSelectionPos != -1) {  
27.                         mMsgListView.setSelection(newSelectionPos);  
28.                     }  
29.                     if (cursor.getCount() == 0 && !isRecipientsEditorVisible() && !mSentMessage) {  
30.                         initRecipientsEditor();  
31.                     }  
32.                     mTextEditor.requestFocus();  
33.                     mConversation.blockMarkAsRead(false);  
34.                     mConversation.setMessageCount(cursor.getCount());  
35.                     return;  
36.   
37.             }  
38.         }  

代码虽多，但其核心就是对mMsgListAdapter的内容从新赋值刷新界面完毕。

3）刷新

    刷新就很简单啦，当数据有变化的时候会触发OnDataSetChangedListener这个监听器，这个监听器会调用onContentChanged函数从新查询达到刷新的效果。