Revert "Telephony: Voice mail notification related changes"
[android/platform/frameworks/opt/telephony.git] / src / java / com / android / internal / telephony / InboundSmsHandler.java
1 /*
2  * Copyright (C) 2013 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.android.internal.telephony;
18
19 import android.app.Activity;
20 import android.app.ActivityManagerNative;
21 import android.app.AppOpsManager;
22 import android.app.PendingIntent;
23 import android.app.PendingIntent.CanceledException;
24 import android.content.BroadcastReceiver;
25 import android.content.ComponentName;
26 import android.content.ContentResolver;
27 import android.content.ContentUris;
28 import android.content.ContentValues;
29 import android.content.Context;
30 import android.content.Intent;
31 import android.content.pm.UserInfo;
32 import android.database.Cursor;
33 import android.database.SQLException;
34 import android.net.Uri;
35 import android.os.AsyncResult;
36 import android.os.Binder;
37 import android.os.Build;
38 import android.os.Bundle;
39 import android.os.Message;
40 import android.os.PowerManager;
41 import android.os.RemoteException;
42 import android.os.SystemProperties;
43 import android.os.UserHandle;
44 import android.os.UserManager;
45 import android.provider.Telephony;
46 import android.provider.Telephony.Sms.Intents;
47 import android.telephony.Rlog;
48 import android.telephony.SmsManager;
49 import android.telephony.SmsMessage;
50 import android.telephony.SubscriptionManager;
51 import android.telephony.TelephonyManager;
52 import android.text.TextUtils;
53 import android.util.Log;
54
55 import com.android.internal.telephony.uicc.UiccCard;
56 import com.android.internal.telephony.uicc.UiccController;
57 import com.android.internal.util.HexDump;
58 import com.android.internal.util.State;
59 import com.android.internal.util.StateMachine;
60
61 import java.io.ByteArrayOutputStream;
62 import java.util.Arrays;
63 import java.util.List;
64
65 import static android.telephony.TelephonyManager.PHONE_TYPE_CDMA;
66
67 /**
68  * This class broadcasts incoming SMS messages to interested apps after storing them in
69  * the SmsProvider "raw" table and ACKing them to the SMSC. After each message has been
70  * broadcast, its parts are removed from the raw table. If the device crashes after ACKing
71  * but before the broadcast completes, the pending messages will be rebroadcast on the next boot.
72  *
73  * <p>The state machine starts in {@link IdleState} state. When the {@link SMSDispatcher} receives a
74  * new SMS from the radio, it calls {@link #dispatchNormalMessage},
75  * which sends a message to the state machine, causing the wakelock to be acquired in
76  * {@link #haltedProcessMessage}, which transitions to {@link DeliveringState} state, where the message
77  * is saved to the raw table, then acknowledged via the {@link SMSDispatcher} which called us.
78  *
79  * <p>After saving the SMS, if the message is complete (either single-part or the final segment
80  * of a multi-part SMS), we broadcast the completed PDUs as an ordered broadcast, then transition to
81  * {@link WaitingState} state to wait for the broadcast to complete. When the local
82  * {@link BroadcastReceiver} is called with the result, it sends {@link #EVENT_BROADCAST_COMPLETE}
83  * to the state machine, causing us to either broadcast the next pending message (if one has
84  * arrived while waiting for the broadcast to complete), or to transition back to the halted state
85  * after all messages are processed. Then the wakelock is released and we wait for the next SMS.
86  */
87 public abstract class InboundSmsHandler extends StateMachine {
88     protected static final boolean DBG = true;
89     private static final boolean VDBG = false;  // STOPSHIP if true, logs user data
90
91     /** Query projection for checking for duplicate message segments. */
92     private static final String[] PDU_PROJECTION = {
93             "pdu"
94     };
95
96     /** Query projection for combining concatenated message segments. */
97     private static final String[] PDU_SEQUENCE_PORT_PROJECTION = {
98             "pdu",
99             "sequence",
100             "destination_port"
101     };
102
103     static final int PDU_COLUMN = 0;
104     static final int SEQUENCE_COLUMN = 1;
105     static final int DESTINATION_PORT_COLUMN = 2;
106     static final int DATE_COLUMN = 3;
107     static final int REFERENCE_NUMBER_COLUMN = 4;
108     static final int COUNT_COLUMN = 5;
109     static final int ADDRESS_COLUMN = 6;
110     static final int ID_COLUMN = 7;
111
112     static final String SELECT_BY_ID = "_id=?";
113     static final String SELECT_BY_REFERENCE = "address=? AND reference_number=? AND count=?";
114
115     /** New SMS received as an AsyncResult. */
116     public static final int EVENT_NEW_SMS = 1;
117
118     /** Message type containing a {@link InboundSmsTracker} ready to broadcast to listeners. */
119     static final int EVENT_BROADCAST_SMS = 2;
120
121     /** Message from resultReceiver notifying {@link WaitingState} of a completed broadcast. */
122     static final int EVENT_BROADCAST_COMPLETE = 3;
123
124     /** Sent on exit from {@link WaitingState} to return to idle after sending all broadcasts. */
125     static final int EVENT_RETURN_TO_IDLE = 4;
126
127     /** Release wakelock after a short timeout when returning to idle state. */
128     static final int EVENT_RELEASE_WAKELOCK = 5;
129
130     /** Sent by {@link SmsBroadcastUndelivered} after cleaning the raw table. */
131     static final int EVENT_START_ACCEPTING_SMS = 6;
132
133     /** Update phone object */
134     static final int EVENT_UPDATE_PHONE_OBJECT = 7;
135
136     /** New SMS received as an AsyncResult. */
137     public static final int EVENT_INJECT_SMS = 8;
138
139     /** Wakelock release delay when returning to idle state. */
140     private static final int WAKELOCK_TIMEOUT = 3000;
141
142     /** URI for raw table of SMS provider. */
143     private static final Uri sRawUri = Uri.withAppendedPath(Telephony.Sms.CONTENT_URI, "raw");
144
145     protected final Context mContext;
146     private final ContentResolver mResolver;
147
148     /** Special handler for WAP push messages. */
149     private final WapPushOverSms mWapPush;
150
151     /** Wake lock to ensure device stays awake while dispatching the SMS intents. */
152     final PowerManager.WakeLock mWakeLock;
153
154     /** DefaultState throws an exception or logs an error for unhandled message types. */
155     final DefaultState mDefaultState = new DefaultState();
156
157     /** Startup state. Waiting for {@link SmsBroadcastUndelivered} to complete. */
158     final StartupState mStartupState = new StartupState();
159
160     /** Idle state. Waiting for messages to process. */
161     final IdleState mIdleState = new IdleState();
162
163     /** Delivering state. Saves the PDU in the raw table and acknowledges to SMSC. */
164     final DeliveringState mDeliveringState = new DeliveringState();
165
166     /** Broadcasting state. Waits for current broadcast to complete before delivering next. */
167     final WaitingState mWaitingState = new WaitingState();
168
169     /** Helper class to check whether storage is available for incoming messages. */
170     protected SmsStorageMonitor mStorageMonitor;
171
172     private final boolean mSmsReceiveDisabled;
173
174     protected PhoneBase mPhone;
175
176     protected CellBroadcastHandler mCellBroadcastHandler;
177
178     private UserManager mUserManager;
179
180     /**
181      * Create a new SMS broadcast helper.
182      * @param name the class name for logging
183      * @param context the context of the phone app
184      * @param storageMonitor the SmsStorageMonitor to check for storage availability
185      */
186     protected InboundSmsHandler(String name, Context context, SmsStorageMonitor storageMonitor,
187             PhoneBase phone, CellBroadcastHandler cellBroadcastHandler) {
188         super(name);
189
190         mContext = context;
191         mStorageMonitor = storageMonitor;
192         mPhone = phone;
193         mCellBroadcastHandler = cellBroadcastHandler;
194         mResolver = context.getContentResolver();
195         mWapPush = new WapPushOverSms(context);
196
197         boolean smsCapable = mContext.getResources().getBoolean(
198                 com.android.internal.R.bool.config_sms_capable);
199         mSmsReceiveDisabled = !SystemProperties.getBoolean(
200                 TelephonyProperties.PROPERTY_SMS_RECEIVE, smsCapable);
201
202         PowerManager pm = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
203         mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, name);
204         mWakeLock.acquire();    // wake lock released after we enter idle state
205         mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
206
207         addState(mDefaultState);
208         addState(mStartupState, mDefaultState);
209         addState(mIdleState, mDefaultState);
210         addState(mDeliveringState, mDefaultState);
211             addState(mWaitingState, mDeliveringState);
212
213         setInitialState(mStartupState);
214         if (DBG) log("created InboundSmsHandler");
215     }
216
217     /**
218      * Tell the state machine to quit after processing all messages.
219      */
220     public void dispose() {
221         quit();
222     }
223
224     /**
225      * Update the phone object when it changes.
226      */
227     public void updatePhoneObject(PhoneBase phone) {
228         sendMessage(EVENT_UPDATE_PHONE_OBJECT, phone);
229     }
230
231     /**
232      * Dispose of the WAP push object and release the wakelock.
233      */
234     @Override
235     protected void onQuitting() {
236         mWapPush.dispose();
237
238         while (mWakeLock.isHeld()) {
239             mWakeLock.release();
240         }
241     }
242
243     // CAF_MSIM Is this used anywhere ? if not remove it
244     public PhoneBase getPhone() {
245         return mPhone;
246     }
247
248     /**
249      * This parent state throws an exception (for debug builds) or prints an error for unhandled
250      * message types.
251      */
252     class DefaultState extends State {
253         @Override
254         public boolean processMessage(Message msg) {
255             switch (msg.what) {
256                 case EVENT_UPDATE_PHONE_OBJECT: {
257                     onUpdatePhoneObject((PhoneBase) msg.obj);
258                     break;
259                 }
260                 default: {
261                     String errorText = "processMessage: unhandled message type " + msg.what +
262                         " currState=" + getCurrentState().getName();
263                     if (Build.IS_DEBUGGABLE) {
264                         loge("---- Dumping InboundSmsHandler ----");
265                         loge("Total records=" + getLogRecCount());
266                         for (int i = Math.max(getLogRecSize() - 20, 0); i < getLogRecSize(); i++) {
267                             loge("Rec[%d]: %s\n" + i + getLogRec(i).toString());
268                         }
269                         loge("---- Dumped InboundSmsHandler ----");
270
271                         throw new RuntimeException(errorText);
272                     } else {
273                         loge(errorText);
274                     }
275                     break;
276                 }
277             }
278             return HANDLED;
279         }
280     }
281
282     /**
283      * The Startup state waits for {@link SmsBroadcastUndelivered} to process the raw table and
284      * notify the state machine to broadcast any complete PDUs that might not have been broadcast.
285      */
286     class StartupState extends State {
287         @Override
288         public boolean processMessage(Message msg) {
289             log("StartupState.processMessage:" + msg.what);
290             switch (msg.what) {
291                 case EVENT_NEW_SMS:
292                 case EVENT_INJECT_SMS:
293                 case EVENT_BROADCAST_SMS:
294                     deferMessage(msg);
295                     return HANDLED;
296
297                 case EVENT_START_ACCEPTING_SMS:
298                     transitionTo(mIdleState);
299                     return HANDLED;
300
301                 case EVENT_BROADCAST_COMPLETE:
302                 case EVENT_RETURN_TO_IDLE:
303                 case EVENT_RELEASE_WAKELOCK:
304                 default:
305                     // let DefaultState handle these unexpected message types
306                     return NOT_HANDLED;
307             }
308         }
309     }
310
311     /**
312      * In the idle state the wakelock is released until a new SM arrives, then we transition
313      * to Delivering mode to handle it, acquiring the wakelock on exit.
314      */
315     class IdleState extends State {
316         @Override
317         public void enter() {
318             if (DBG) log("entering Idle state");
319             sendMessageDelayed(EVENT_RELEASE_WAKELOCK, WAKELOCK_TIMEOUT);
320         }
321
322         @Override
323         public void exit() {
324             mWakeLock.acquire();
325             if (DBG) log("acquired wakelock, leaving Idle state");
326         }
327
328         @Override
329         public boolean processMessage(Message msg) {
330             log("IdleState.processMessage:" + msg.what);
331             if (DBG) log("Idle state processing message type " + msg.what);
332             switch (msg.what) {
333                 case EVENT_NEW_SMS:
334                 case EVENT_INJECT_SMS:
335                 case EVENT_BROADCAST_SMS:
336                     deferMessage(msg);
337                     transitionTo(mDeliveringState);
338                     return HANDLED;
339
340                 case EVENT_RELEASE_WAKELOCK:
341                     mWakeLock.release();
342                     if (DBG) {
343                         if (mWakeLock.isHeld()) {
344                             // this is okay as long as we call release() for every acquire()
345                             log("mWakeLock is still held after release");
346                         } else {
347                             log("mWakeLock released");
348                         }
349                     }
350                     return HANDLED;
351
352                 case EVENT_RETURN_TO_IDLE:
353                     // already in idle state; ignore
354                     return HANDLED;
355
356                 case EVENT_BROADCAST_COMPLETE:
357                 case EVENT_START_ACCEPTING_SMS:
358                 default:
359                     // let DefaultState handle these unexpected message types
360                     return NOT_HANDLED;
361             }
362         }
363     }
364
365     /**
366      * In the delivering state, the inbound SMS is processed and stored in the raw table.
367      * The message is acknowledged before we exit this state. If there is a message to broadcast,
368      * transition to {@link WaitingState} state to send the ordered broadcast and wait for the
369      * results. When all messages have been processed, the halting state will release the wakelock.
370      */
371     class DeliveringState extends State {
372         @Override
373         public void enter() {
374             if (DBG) log("entering Delivering state");
375         }
376
377         @Override
378         public void exit() {
379             if (DBG) log("leaving Delivering state");
380         }
381
382         @Override
383         public boolean processMessage(Message msg) {
384             log("DeliveringState.processMessage:" + msg.what);
385             switch (msg.what) {
386                 case EVENT_NEW_SMS:
387                     // handle new SMS from RIL
388                     handleNewSms((AsyncResult) msg.obj);
389                     sendMessage(EVENT_RETURN_TO_IDLE);
390                     return HANDLED;
391
392                 case EVENT_INJECT_SMS:
393                     // handle new injected SMS
394                     handleInjectSms((AsyncResult) msg.obj);
395                     sendMessage(EVENT_RETURN_TO_IDLE);
396                     return HANDLED;
397
398                 case EVENT_BROADCAST_SMS:
399                     // if any broadcasts were sent, transition to waiting state
400                     if (processMessagePart((InboundSmsTracker) msg.obj)) {
401                         transitionTo(mWaitingState);
402                     }
403                     return HANDLED;
404
405                 case EVENT_RETURN_TO_IDLE:
406                     // return to idle after processing all other messages
407                     transitionTo(mIdleState);
408                     return HANDLED;
409
410                 case EVENT_RELEASE_WAKELOCK:
411                     mWakeLock.release();    // decrement wakelock from previous entry to Idle
412                     if (!mWakeLock.isHeld()) {
413                         // wakelock should still be held until 3 seconds after we enter Idle
414                         loge("mWakeLock released while delivering/broadcasting!");
415                     }
416                     return HANDLED;
417
418                 // we shouldn't get this message type in this state, log error and halt.
419                 case EVENT_BROADCAST_COMPLETE:
420                 case EVENT_START_ACCEPTING_SMS:
421                 default:
422                     // let DefaultState handle these unexpected message types
423                     return NOT_HANDLED;
424             }
425         }
426     }
427
428     /**
429      * The waiting state delegates handling of new SMS to parent {@link DeliveringState}, but
430      * defers handling of the {@link #EVENT_BROADCAST_SMS} phase until after the current
431      * result receiver sends {@link #EVENT_BROADCAST_COMPLETE}. Before transitioning to
432      * {@link DeliveringState}, {@link #EVENT_RETURN_TO_IDLE} is sent to transition to
433      * {@link IdleState} after any deferred {@link #EVENT_BROADCAST_SMS} messages are handled.
434      */
435     class WaitingState extends State {
436         @Override
437         public boolean processMessage(Message msg) {
438             log("WaitingState.processMessage:" + msg.what);
439             switch (msg.what) {
440                 case EVENT_BROADCAST_SMS:
441                     // defer until the current broadcast completes
442                     deferMessage(msg);
443                     return HANDLED;
444
445                 case EVENT_BROADCAST_COMPLETE:
446                     // return to idle after handling all deferred messages
447                     sendMessage(EVENT_RETURN_TO_IDLE);
448                     transitionTo(mDeliveringState);
449                     return HANDLED;
450
451                 case EVENT_RETURN_TO_IDLE:
452                     // not ready to return to idle; ignore
453                     return HANDLED;
454
455                 default:
456                     // parent state handles the other message types
457                     return NOT_HANDLED;
458             }
459         }
460     }
461
462     void handleNewSms(AsyncResult ar) {
463         if (ar.exception != null) {
464             loge("Exception processing incoming SMS: " + ar.exception);
465             return;
466         }
467
468         int result;
469         try {
470             SmsMessage sms = (SmsMessage) ar.result;
471             result = dispatchMessage(sms.mWrappedSmsMessage);
472         } catch (RuntimeException ex) {
473             loge("Exception dispatching message", ex);
474             result = Intents.RESULT_SMS_GENERIC_ERROR;
475         }
476
477         // RESULT_OK means that the SMS will be acknowledged by special handling,
478         // e.g. for SMS-PP data download. Any other result, we should ack here.
479         if (result != Activity.RESULT_OK) {
480             boolean handled = (result == Intents.RESULT_SMS_HANDLED);
481             notifyAndAcknowledgeLastIncomingSms(handled, result, null);
482         }
483     }
484
485     /**
486      * This method is called when a new SMS PDU is injected into application framework.
487      * @param ar is the AsyncResult that has the SMS PDU to be injected.
488      */
489     void handleInjectSms(AsyncResult ar) {
490         int result;
491         PendingIntent receivedIntent = null;
492         try {
493             receivedIntent = (PendingIntent) ar.userObj;
494             SmsMessage sms = (SmsMessage) ar.result;
495             if (sms == null) {
496               result = Intents.RESULT_SMS_GENERIC_ERROR;
497             } else {
498               result = dispatchMessage(sms.mWrappedSmsMessage);
499             }
500         } catch (RuntimeException ex) {
501             loge("Exception dispatching message", ex);
502             result = Intents.RESULT_SMS_GENERIC_ERROR;
503         }
504
505         if (receivedIntent != null) {
506             try {
507                 receivedIntent.send(result);
508             } catch (CanceledException e) { }
509         }
510     }
511
512     /**
513      * Process an SMS message from the RIL, calling subclass methods to handle 3GPP and
514      * 3GPP2-specific message types.
515      *
516      * @param smsb the SmsMessageBase object from the RIL
517      * @return a result code from {@link android.provider.Telephony.Sms.Intents},
518      *  or {@link Activity#RESULT_OK} for delayed acknowledgment to SMSC
519      */
520     public int dispatchMessage(SmsMessageBase smsb) {
521         // If sms is null, there was a parsing error.
522         if (smsb == null) {
523             loge("dispatchSmsMessage: message is null");
524             return Intents.RESULT_SMS_GENERIC_ERROR;
525         }
526
527         if (mSmsReceiveDisabled) {
528             // Device doesn't support receiving SMS,
529             log("Received short message on device which doesn't support "
530                     + "receiving SMS. Ignored.");
531             return Intents.RESULT_SMS_HANDLED;
532         }
533
534         return dispatchMessageRadioSpecific(smsb);
535     }
536
537     /**
538      * Process voicemail notification, SMS-PP data download, CDMA CMAS, CDMA WAP push, and other
539      * 3GPP/3GPP2-specific messages. Regular SMS messages are handled by calling the shared
540      * {@link #dispatchNormalMessage} from this class.
541      *
542      * @param smsb the SmsMessageBase object from the RIL
543      * @return a result code from {@link android.provider.Telephony.Sms.Intents},
544      *  or {@link Activity#RESULT_OK} for delayed acknowledgment to SMSC
545      */
546     protected abstract int dispatchMessageRadioSpecific(SmsMessageBase smsb);
547
548     /**
549      * Send an acknowledge message to the SMSC.
550      * @param success indicates that last message was successfully received.
551      * @param result result code indicating any error
552      * @param response callback message sent when operation completes.
553      */
554     protected abstract void acknowledgeLastIncomingSms(boolean success,
555             int result, Message response);
556
557     /**
558      * Called when the phone changes the default method updates mPhone
559      * mStorageMonitor and mCellBroadcastHandler.updatePhoneObject.
560      * Override if different or other behavior is desired.
561      *
562      * @param phone
563      */
564     protected void onUpdatePhoneObject(PhoneBase phone) {
565         mPhone = phone;
566         mStorageMonitor = mPhone.mSmsStorageMonitor;
567         log("onUpdatePhoneObject: phone=" + mPhone.getClass().getSimpleName());
568     }
569
570     /**
571      * Notify interested apps if the framework has rejected an incoming SMS,
572      * and send an acknowledge message to the network.
573      * @param success indicates that last message was successfully received.
574      * @param result result code indicating any error
575      * @param response callback message sent when operation completes.
576      */
577     void notifyAndAcknowledgeLastIncomingSms(boolean success,
578             int result, Message response) {
579         if (!success) {
580             // broadcast SMS_REJECTED_ACTION intent
581             Intent intent = new Intent(Intents.SMS_REJECTED_ACTION);
582             intent.putExtra("result", result);
583             mContext.sendBroadcast(intent, android.Manifest.permission.RECEIVE_SMS);
584         }
585         acknowledgeLastIncomingSms(success, result, response);
586     }
587
588     /**
589      * Return true if this handler is for 3GPP2 messages; false for 3GPP format.
590      * @return true for the 3GPP2 handler; false for the 3GPP handler
591      */
592     protected abstract boolean is3gpp2();
593
594     /**
595      * Dispatch a normal incoming SMS. This is called from {@link #dispatchMessageRadioSpecific}
596      * if no format-specific handling was required. Saves the PDU to the SMS provider raw table,
597      * creates an {@link InboundSmsTracker}, then sends it to the state machine as an
598      * {@link #EVENT_BROADCAST_SMS}. Returns {@link Intents#RESULT_SMS_HANDLED} or an error value.
599      *
600      * @param sms the message to dispatch
601      * @return {@link Intents#RESULT_SMS_HANDLED} if the message was accepted, or an error status
602      */
603     protected int dispatchNormalMessage(SmsMessageBase sms) {
604         SmsHeader smsHeader = sms.getUserDataHeader();
605         InboundSmsTracker tracker;
606
607         if ((smsHeader == null) || (smsHeader.concatRef == null)) {
608             // Message is not concatenated.
609             int destPort = -1;
610             if (smsHeader != null && smsHeader.portAddrs != null) {
611                 // The message was sent to a port.
612                 destPort = smsHeader.portAddrs.destPort;
613                 if (DBG) log("destination port: " + destPort);
614             }
615
616             tracker = new InboundSmsTracker(sms.getPdu(), sms.getTimestampMillis(), destPort,
617                     is3gpp2(), false);
618         } else {
619             // Create a tracker for this message segment.
620             SmsHeader.ConcatRef concatRef = smsHeader.concatRef;
621             SmsHeader.PortAddrs portAddrs = smsHeader.portAddrs;
622             int destPort = (portAddrs != null ? portAddrs.destPort : -1);
623
624             tracker = new InboundSmsTracker(sms.getPdu(), sms.getTimestampMillis(), destPort,
625                     is3gpp2(), sms.getOriginatingAddress(), concatRef.refNumber,
626                     concatRef.seqNumber, concatRef.msgCount, false);
627         }
628
629         if (VDBG) log("created tracker: " + tracker);
630         return addTrackerToRawTableAndSendMessage(tracker);
631     }
632
633     /**
634      * Helper to add the tracker to the raw table and then send a message to broadcast it, if
635      * successful. Returns the SMS intent status to return to the SMSC.
636      * @param tracker the tracker to save to the raw table and then deliver
637      * @return {@link Intents#RESULT_SMS_HANDLED} or {@link Intents#RESULT_SMS_GENERIC_ERROR}
638      * or {@link Intents#RESULT_SMS_DUPLICATED}
639      */
640     protected int addTrackerToRawTableAndSendMessage(InboundSmsTracker tracker) {
641         switch(addTrackerToRawTable(tracker)) {
642         case Intents.RESULT_SMS_HANDLED:
643             sendMessage(EVENT_BROADCAST_SMS, tracker);
644             return Intents.RESULT_SMS_HANDLED;
645
646         case Intents.RESULT_SMS_DUPLICATED:
647             return Intents.RESULT_SMS_HANDLED;
648
649         case Intents.RESULT_SMS_GENERIC_ERROR:
650         default:
651             return Intents.RESULT_SMS_GENERIC_ERROR;
652         }
653     }
654
655     /**
656      * Process the inbound SMS segment. If the message is complete, send it as an ordered
657      * broadcast to interested receivers and return true. If the message is a segment of an
658      * incomplete multi-part SMS, return false.
659      * @param tracker the tracker containing the message segment to process
660      * @return true if an ordered broadcast was sent; false if waiting for more message segments
661      */
662     boolean processMessagePart(InboundSmsTracker tracker) {
663         int messageCount = tracker.getMessageCount();
664         byte[][] pdus;
665         int destPort = tracker.getDestPort();
666
667         if (messageCount == 1) {
668             // single-part message
669             pdus = new byte[][]{tracker.getPdu()};
670         } else {
671             // multi-part message
672             Cursor cursor = null;
673             try {
674                 // used by several query selection arguments
675                 String address = tracker.getAddress();
676                 String refNumber = Integer.toString(tracker.getReferenceNumber());
677                 String count = Integer.toString(tracker.getMessageCount());
678
679                 // query for all segments and broadcast message if we have all the parts
680                 String[] whereArgs = {address, refNumber, count};
681                 cursor = mResolver.query(sRawUri, PDU_SEQUENCE_PORT_PROJECTION,
682                         SELECT_BY_REFERENCE, whereArgs, null);
683
684                 int cursorCount = cursor.getCount();
685                 if (cursorCount < messageCount) {
686                     // Wait for the other message parts to arrive. It's also possible for the last
687                     // segment to arrive before processing the EVENT_BROADCAST_SMS for one of the
688                     // earlier segments. In that case, the broadcast will be sent as soon as all
689                     // segments are in the table, and any later EVENT_BROADCAST_SMS messages will
690                     // get a row count of 0 and return.
691                     return false;
692                 }
693
694                 // All the parts are in place, deal with them
695                 pdus = new byte[messageCount][];
696                 while (cursor.moveToNext()) {
697                     // subtract offset to convert sequence to 0-based array index
698                     int index = cursor.getInt(SEQUENCE_COLUMN) - tracker.getIndexOffset();
699
700                     pdus[index] = HexDump.hexStringToByteArray(cursor.getString(PDU_COLUMN));
701
702                     // Read the destination port from the first segment (needed for CDMA WAP PDU).
703                     // It's not a bad idea to prefer the port from the first segment in other cases.
704                     if (index == 0 && !cursor.isNull(DESTINATION_PORT_COLUMN)) {
705                         int port = cursor.getInt(DESTINATION_PORT_COLUMN);
706                         // strip format flags and convert to real port number, or -1
707                         port = InboundSmsTracker.getRealDestPort(port);
708                         if (port != -1) {
709                             destPort = port;
710                         }
711                     }
712                 }
713             } catch (SQLException e) {
714                 loge("Can't access multipart SMS database", e);
715                 return false;
716             } finally {
717                 if (cursor != null) {
718                     cursor.close();
719                 }
720             }
721         }
722
723         BroadcastReceiver resultReceiver = new SmsBroadcastReceiver(tracker);
724
725         if (destPort == SmsHeader.PORT_WAP_PUSH) {
726             // Build up the data stream
727             ByteArrayOutputStream output = new ByteArrayOutputStream();
728             for (byte[] pdu : pdus) {
729                 // 3GPP needs to extract the User Data from the PDU; 3GPP2 has already done this
730                 if (!tracker.is3gpp2()) {
731                     SmsMessage msg = SmsMessage.createFromPdu(pdu, SmsConstants.FORMAT_3GPP);
732                     pdu = msg.getUserData();
733                 }
734                 output.write(pdu, 0, pdu.length);
735             }
736             int result = mWapPush.dispatchWapPdu(output.toByteArray(), resultReceiver, this);
737             if (DBG) log("dispatchWapPdu() returned " + result);
738             // result is Activity.RESULT_OK if an ordered broadcast was sent
739             return (result == Activity.RESULT_OK);
740         }
741
742         Intent intent = new Intent(Intents.SMS_FILTER_ACTION);
743         List<String> carrierPackages = null;
744         UiccCard card = UiccController.getInstance().getUiccCard();
745         if (card != null) {
746             carrierPackages = card.getCarrierPackageNamesForIntent(
747                     mContext.getPackageManager(), intent);
748         }
749         if (carrierPackages != null && carrierPackages.size() == 1) {
750             intent.setPackage(carrierPackages.get(0));
751             intent.putExtra("destport", destPort);
752         } else {
753             setAndDirectIntent(intent, destPort);
754         }
755
756         intent.putExtra("pdus", pdus);
757         intent.putExtra("format", tracker.getFormat());
758         dispatchIntent(intent, android.Manifest.permission.RECEIVE_SMS,
759                 AppOpsManager.OP_RECEIVE_SMS, resultReceiver, UserHandle.OWNER);
760         return true;
761     }
762
763     /**
764      * Dispatch the intent with the specified permission, appOp, and result receiver, using
765      * this state machine's handler thread to run the result receiver.
766      *
767      * @param intent the intent to broadcast
768      * @param permission receivers are required to have this permission
769      * @param appOp app op that is being performed when dispatching to a receiver
770      * @param user user to deliver the intent to
771      */
772     protected void dispatchIntent(Intent intent, String permission, int appOp,
773             BroadcastReceiver resultReceiver, UserHandle user) {
774         intent.addFlags(Intent.FLAG_RECEIVER_NO_ABORT);
775         SubscriptionManager.putPhoneIdAndSubIdExtra(intent, mPhone.getPhoneId());
776         if (user.equals(UserHandle.ALL)) {
777             // Get a list of currently started users.
778             int[] users = null;
779             try {
780                 users = ActivityManagerNative.getDefault().getRunningUserIds();
781             } catch (RemoteException re) {
782             }
783             if (users == null) {
784                 users = new int[] {user.getIdentifier()};
785             }
786             // Deliver the broadcast only to those running users that are permitted
787             // by user policy.
788             for (int i = users.length - 1; i >= 0; i--) {
789                 UserHandle targetUser = new UserHandle(users[i]);
790                 if (users[i] != UserHandle.USER_OWNER) {
791                     // Is the user not allowed to use SMS?
792                     if (mUserManager.hasUserRestriction(UserManager.DISALLOW_SMS, targetUser)) {
793                         continue;
794                     }
795                     // Skip unknown users and managed profiles as well
796                     UserInfo info = mUserManager.getUserInfo(users[i]);
797                     if (info == null || info.isManagedProfile()) {
798                         continue;
799                     }
800                 }
801                 // Only pass in the resultReceiver when the USER_OWNER is processed.
802                 mContext.sendOrderedBroadcastAsUser(intent, targetUser, permission, appOp,
803                         users[i] == UserHandle.USER_OWNER ? resultReceiver : null,
804                         getHandler(), Activity.RESULT_OK, null, null);
805             }
806         } else {
807             mContext.sendOrderedBroadcastAsUser(intent, user, permission, appOp,
808                     resultReceiver,
809                     getHandler(), Activity.RESULT_OK, null, null);
810         }
811     }
812
813     /**
814      * Helper for {@link SmsBroadcastUndelivered} to delete an old message in the raw table.
815      */
816     void deleteFromRawTable(String deleteWhere, String[] deleteWhereArgs) {
817         int rows = mResolver.delete(sRawUri, deleteWhere, deleteWhereArgs);
818         if (rows == 0) {
819             loge("No rows were deleted from raw table!");
820         } else if (DBG) {
821             log("Deleted " + rows + " rows from raw table.");
822         }
823     }
824
825     /**
826      * Set the appropriate intent action and direct the intent to the default SMS app or the
827      * appropriate port.
828      *
829      * @param intent the intent to set and direct
830      * @param destPort the destination port
831      */
832     void setAndDirectIntent(Intent intent, int destPort) {
833         if (destPort == -1) {
834             intent.setAction(Intents.SMS_DELIVER_ACTION);
835
836             // Direct the intent to only the default SMS app. If we can't find a default SMS app
837             // then sent it to all broadcast receivers.
838             // We are deliberately delivering to the primary user's default SMS App.
839             ComponentName componentName = SmsApplication.getDefaultSmsApplication(mContext, true);
840             if (componentName != null) {
841                 // Deliver SMS message only to this receiver.
842                 intent.setComponent(componentName);
843                 log("Delivering SMS to: " + componentName.getPackageName() +
844                     " " + componentName.getClassName());
845             } else {
846                 intent.setComponent(null);
847             }
848         } else {
849             intent.setAction(Intents.DATA_SMS_RECEIVED_ACTION);
850             Uri uri = Uri.parse("sms://localhost:" + destPort);
851             intent.setData(uri);
852             intent.setComponent(null);
853         }
854     }
855
856     /**
857      * Insert a message PDU into the raw table so we can acknowledge it immediately.
858      * If the device crashes before the broadcast to listeners completes, it will be delivered
859      * from the raw table on the next device boot. For single-part messages, the deleteWhere
860      * and deleteWhereArgs fields of the tracker will be set to delete the correct row after
861      * the ordered broadcast completes.
862      *
863      * @param tracker the tracker to add to the raw table
864      * @return true on success; false on failure to write to database
865      */
866     private int addTrackerToRawTable(InboundSmsTracker tracker) {
867         if (tracker.getMessageCount() != 1) {
868             // check for duplicate message segments
869             Cursor cursor = null;
870             try {
871                 // sequence numbers are 1-based except for CDMA WAP, which is 0-based
872                 int sequence = tracker.getSequenceNumber();
873
874                 // convert to strings for query
875                 String address = tracker.getAddress();
876                 String refNumber = Integer.toString(tracker.getReferenceNumber());
877                 String count = Integer.toString(tracker.getMessageCount());
878
879                 String seqNumber = Integer.toString(sequence);
880
881                 // set the delete selection args for multi-part message
882                 String[] deleteWhereArgs = {address, refNumber, count};
883                 tracker.setDeleteWhere(SELECT_BY_REFERENCE, deleteWhereArgs);
884
885                 // Check for duplicate message segments
886                 cursor = mResolver.query(sRawUri, PDU_PROJECTION,
887                         "address=? AND reference_number=? AND count=? AND sequence=?",
888                         new String[] {address, refNumber, count, seqNumber}, null);
889
890                 // moveToNext() returns false if no duplicates were found
891                 if (cursor.moveToNext()) {
892                     loge("Discarding duplicate message segment, refNumber=" + refNumber
893                             + " seqNumber=" + seqNumber);
894                     String oldPduString = cursor.getString(PDU_COLUMN);
895                     byte[] pdu = tracker.getPdu();
896                     byte[] oldPdu = HexDump.hexStringToByteArray(oldPduString);
897                     if (!Arrays.equals(oldPdu, tracker.getPdu())) {
898                         loge("Warning: dup message segment PDU of length " + pdu.length
899                                 + " is different from existing PDU of length " + oldPdu.length);
900                     }
901                     return Intents.RESULT_SMS_DUPLICATED;   // reject message
902                 }
903                 cursor.close();
904             } catch (SQLException e) {
905                 loge("Can't access multipart SMS database", e);
906                 return Intents.RESULT_SMS_GENERIC_ERROR;    // reject message
907             } finally {
908                 if (cursor != null) {
909                     cursor.close();
910                 }
911             }
912         }
913
914         ContentValues values = tracker.getContentValues();
915
916         if (VDBG) log("adding content values to raw table: " + values.toString());
917         Uri newUri = mResolver.insert(sRawUri, values);
918         if (DBG) log("URI of new row -> " + newUri);
919
920         try {
921             long rowId = ContentUris.parseId(newUri);
922             if (tracker.getMessageCount() == 1) {
923                 // set the delete selection args for single-part message
924                 tracker.setDeleteWhere(SELECT_BY_ID, new String[]{Long.toString(rowId)});
925             }
926             return Intents.RESULT_SMS_HANDLED;
927         } catch (Exception e) {
928             loge("error parsing URI for new row: " + newUri, e);
929             return Intents.RESULT_SMS_GENERIC_ERROR;
930         }
931     }
932
933     /**
934      * Returns whether the default message format for the current radio technology is 3GPP2.
935      * @return true if the radio technology uses 3GPP2 format by default, false for 3GPP format
936      */
937     static boolean isCurrentFormat3gpp2() {
938         int activePhone = TelephonyManager.getDefault().getCurrentPhoneType();
939         return (PHONE_TYPE_CDMA == activePhone);
940     }
941
942     /**
943      * Handler for an {@link InboundSmsTracker} broadcast. Deletes PDUs from the raw table and
944      * logs the broadcast duration (as an error if the other receivers were especially slow).
945      */
946     private final class SmsBroadcastReceiver extends BroadcastReceiver {
947         private final String mDeleteWhere;
948         private final String[] mDeleteWhereArgs;
949         private long mBroadcastTimeNano;
950
951         SmsBroadcastReceiver(InboundSmsTracker tracker) {
952             mDeleteWhere = tracker.getDeleteWhere();
953             mDeleteWhereArgs = tracker.getDeleteWhereArgs();
954             mBroadcastTimeNano = System.nanoTime();
955         }
956
957         @Override
958         public void onReceive(Context context, Intent intent) {
959             String action = intent.getAction();
960             if (action.equals(Intents.SMS_FILTER_ACTION)) {
961                 int rc = getResultCode();
962                 if (rc == Activity.RESULT_OK) {
963                   // Overwrite pdus data if the SMS filter has set it.
964                   Bundle resultExtras = getResultExtras(false);
965                   if (resultExtras != null && resultExtras.containsKey("pdus")) {
966                       intent.putExtra("pdus", (byte[][]) resultExtras.get("pdus"));
967                   }
968                   if (intent.hasExtra("destport")) {
969                       int destPort = intent.getIntExtra("destport", -1);
970                       intent.removeExtra("destport");
971                       setAndDirectIntent(intent, destPort);
972                       if (SmsManager.getDefault().getAutoPersisting()) {
973                           final Uri uri = writeInboxMessage(intent);
974                           if (uri != null) {
975                               // Pass this to SMS apps so that they know where it is stored
976                               intent.putExtra("uri", uri.toString());
977                           }
978                       }
979                       dispatchIntent(intent, android.Manifest.permission.RECEIVE_SMS,
980                                      AppOpsManager.OP_RECEIVE_SMS, this, UserHandle.OWNER);
981                   } else {
982                       loge("destport doesn't exist in the extras for SMS filter action.");
983                   }
984                 } else {
985                   // Drop this SMS.
986                   log("SMS filtered by result code " + rc);
987                   deleteFromRawTable(mDeleteWhere, mDeleteWhereArgs);
988                   sendMessage(EVENT_BROADCAST_COMPLETE);
989                 }
990             } else if (action.equals(Intents.SMS_DELIVER_ACTION)) {
991                 // Now dispatch the notification only intent
992                 intent.setAction(Intents.SMS_RECEIVED_ACTION);
993                 intent.setComponent(null);
994                 // All running users will be notified of the received sms.
995                 dispatchIntent(intent, android.Manifest.permission.RECEIVE_SMS,
996                         AppOpsManager.OP_RECEIVE_SMS, this, UserHandle.ALL);
997             } else if (action.equals(Intents.WAP_PUSH_DELIVER_ACTION)) {
998                 // Now dispatch the notification only intent
999                 intent.setAction(Intents.WAP_PUSH_RECEIVED_ACTION);
1000                 intent.setComponent(null);
1001                 // Only the primary user will receive notification of incoming mms.
1002                 // That app will do the actual downloading of the mms.
1003                 dispatchIntent(intent, android.Manifest.permission.RECEIVE_SMS,
1004                         AppOpsManager.OP_RECEIVE_SMS, this, UserHandle.OWNER);
1005             } else {
1006                 // Now that the intents have been deleted we can clean up the PDU data.
1007                 if (!Intents.DATA_SMS_RECEIVED_ACTION.equals(action)
1008                         && !Intents.SMS_RECEIVED_ACTION.equals(action)
1009                         && !Intents.DATA_SMS_RECEIVED_ACTION.equals(action)
1010                         && !Intents.WAP_PUSH_RECEIVED_ACTION.equals(action)) {
1011                     loge("unexpected BroadcastReceiver action: " + action);
1012                 }
1013
1014                 int rc = getResultCode();
1015                 if ((rc != Activity.RESULT_OK) && (rc != Intents.RESULT_SMS_HANDLED)) {
1016                     loge("a broadcast receiver set the result code to " + rc
1017                             + ", deleting from raw table anyway!");
1018                 } else if (DBG) {
1019                     log("successful broadcast, deleting from raw table.");
1020                 }
1021
1022                 deleteFromRawTable(mDeleteWhere, mDeleteWhereArgs);
1023                 sendMessage(EVENT_BROADCAST_COMPLETE);
1024
1025                 int durationMillis = (int) ((System.nanoTime() - mBroadcastTimeNano) / 1000000);
1026                 if (durationMillis >= 5000) {
1027                     loge("Slow ordered broadcast completion time: " + durationMillis + " ms");
1028                 } else if (DBG) {
1029                     log("ordered broadcast completed in: " + durationMillis + " ms");
1030                 }
1031             }
1032         }
1033     }
1034
1035     /**
1036      * Log with debug level.
1037      * @param s the string to log
1038      */
1039     @Override
1040     protected void log(String s) {
1041         Rlog.d(getName(), s);
1042     }
1043
1044     /**
1045      * Log with error level.
1046      * @param s the string to log
1047      */
1048     @Override
1049     protected void loge(String s) {
1050         Rlog.e(getName(), s);
1051     }
1052
1053     /**
1054      * Log with error level.
1055      * @param s the string to log
1056      * @param e is a Throwable which logs additional information.
1057      */
1058     @Override
1059     protected void loge(String s, Throwable e) {
1060         Rlog.e(getName(), s, e);
1061     }
1062
1063     /**
1064      * Store a received SMS into Telephony provider
1065      *
1066      * @param intent The intent containing the received SMS
1067      * @return The URI of written message
1068      */
1069     private Uri writeInboxMessage(Intent intent) {
1070         final SmsMessage[] messages = Telephony.Sms.Intents.getMessagesFromIntent(intent);
1071         if (messages == null || messages.length < 1) {
1072             loge("Failed to parse SMS pdu");
1073             return null;
1074         }
1075         // Sometimes, SmsMessage.mWrappedSmsMessage is null causing NPE when we access
1076         // the methods on it although the SmsMessage itself is not null. So do this check
1077         // before we do anything on the parsed SmsMessages.
1078         for (final SmsMessage sms : messages) {
1079             try {
1080                 sms.getDisplayMessageBody();
1081             } catch (NullPointerException e) {
1082                 loge("NPE inside SmsMessage");
1083                 return null;
1084             }
1085         }
1086         final ContentValues values = parseSmsMessage(messages);
1087         final long identity = Binder.clearCallingIdentity();
1088         try {
1089             return mContext.getContentResolver().insert(Telephony.Sms.Inbox.CONTENT_URI, values);
1090         } catch (Exception e) {
1091             loge("Failed to persist inbox message", e);
1092         } finally {
1093             Binder.restoreCallingIdentity(identity);
1094         }
1095         return null;
1096     }
1097
1098     /**
1099      * Convert SmsMessage[] into SMS database schema columns
1100      *
1101      * @param msgs The SmsMessage array of the received SMS
1102      * @return ContentValues representing the columns of parsed SMS
1103      */
1104     private static ContentValues parseSmsMessage(SmsMessage[] msgs) {
1105         final SmsMessage sms = msgs[0];
1106         final ContentValues values = new ContentValues();
1107         values.put(Telephony.Sms.Inbox.ADDRESS, sms.getDisplayOriginatingAddress());
1108         values.put(Telephony.Sms.Inbox.BODY, buildMessageBodyFromPdus(msgs));
1109         values.put(Telephony.Sms.Inbox.DATE_SENT, sms.getTimestampMillis());
1110         values.put(Telephony.Sms.Inbox.DATE, System.currentTimeMillis());
1111         values.put(Telephony.Sms.Inbox.PROTOCOL, sms.getProtocolIdentifier());
1112         values.put(Telephony.Sms.Inbox.SEEN, 0);
1113         values.put(Telephony.Sms.Inbox.READ, 0);
1114         final String subject = sms.getPseudoSubject();
1115         if (!TextUtils.isEmpty(subject)) {
1116             values.put(Telephony.Sms.Inbox.SUBJECT, subject);
1117         }
1118         values.put(Telephony.Sms.Inbox.REPLY_PATH_PRESENT, sms.isReplyPathPresent() ? 1 : 0);
1119         values.put(Telephony.Sms.Inbox.SERVICE_CENTER, sms.getServiceCenterAddress());
1120         return values;
1121     }
1122
1123     /**
1124      * Build up the SMS message body from the SmsMessage array of received SMS
1125      *
1126      * @param msgs The SmsMessage array of the received SMS
1127      * @return The text message body
1128      */
1129     private static String buildMessageBodyFromPdus(SmsMessage[] msgs) {
1130         if (msgs.length == 1) {
1131             // There is only one part, so grab the body directly.
1132             return replaceFormFeeds(msgs[0].getDisplayMessageBody());
1133         } else {
1134             // Build up the body from the parts.
1135             StringBuilder body = new StringBuilder();
1136             for (SmsMessage msg: msgs) {
1137                 // getDisplayMessageBody() can NPE if mWrappedMessage inside is null.
1138                 body.append(msg.getDisplayMessageBody());
1139             }
1140             return replaceFormFeeds(body.toString());
1141         }
1142     }
1143
1144     // Some providers send formfeeds in their messages. Convert those formfeeds to newlines.
1145     private static String replaceFormFeeds(String s) {
1146         return s == null ? "" : s.replace('\f', '\n');
1147     }
1148 }