Java 类android.provider.Telephony.Sms 实例源码

@TargetApi(19)
public static String getSMSAppPackageName(Context context) {
    if (VERSION.SDK_INT >= 19) {
        return Sms.getDefaultSmsPackage(context);
    }
    Intent intent = new Intent("android.intent.action.MAIN");
    intent.addCategory("android.intent.category.DEFAULT");
    intent.setType("vnd.android-dir/mms-sms");
    ComponentName componentName = intent.resolveActivity(context.getPackageManager());
    if (componentName != null) {
        return componentName.getPackageName();
    }
    return null;
}

/**
 * Add an SMS to the given URI with the specified thread ID.
 *
 * @param resolver       the content resolver to use
 * @param uri            the URI to add the message to
 * @param address        the address of the sender
 * @param body           the body of the message
 * @param subject        the pseudo-subject of the message
 * @param date           the timestamp for the message
 * @param read           true if the message has been read, false if not
 * @param deliveryReport true if a delivery report was requested, false if not
 * @param threadId       the thread_id of the message
 * @return the URI for the new message
 * @hide
 */
public static Uri addMessageToUri(ContentResolver resolver,
                                  Uri uri, String address, String body, String subject,
                                  Long date, boolean read, boolean deliveryReport, long threadId) {
    ContentValues values = new ContentValues(7);

    values.put(Sms.ADDRESS, address);
    if (date != null) {
        values.put(Sms.DATE, date);
    }
    values.put(Sms.READ, read ? Integer.valueOf(1) : Integer.valueOf(0));
    values.put(Sms.SUBJECT, subject);
    values.put(Sms.BODY, body);
    if (deliveryReport) {
        values.put(Sms.STATUS, Sms.STATUS_PENDING);
    }
    if (threadId != -1L) {
        values.put(Sms.THREAD_ID, threadId);
    }
    return resolver.insert(uri, values);
}

public static void dumpSmsTable(Context context) {
    LogTag.debug("**** Dump of sms table ****");
    Cursor c = context.getContentResolver().query(Sms.CONTENT_URI,
            SMS_PROJECTION, null, null, "_id DESC");
    try {
        // Only dump the latest 20 messages
        c.moveToPosition(-1);
        while (c.moveToNext() && c.getPosition() < 20) {
            String body = c.getString(COLUMN_SMS_BODY);
            LogTag.debug("dumpSmsTable " + BaseColumns._ID + ": " + c.getLong(COLUMN_ID) +
                    " " + Sms.THREAD_ID + " : " + c.getLong(DATE) +
                    " " + Sms.ADDRESS + " : " + c.getString(COLUMN_SMS_ADDRESS) +
                    " " + Sms.BODY + " : " + body.substring(0, Math.min(body.length(), 8)) +
                    " " + Sms.DATE + " : " + c.getLong(COLUMN_SMS_DATE) +
                    " " + Sms.TYPE + " : " + c.getInt(COLUMN_SMS_TYPE));
        }
    } finally {
        c.close();
    }
}

public static void lockMessage(Context context, MessageItem msgItem, boolean locked) {
    Uri uri;
    if ("sms".equals(msgItem.mType)) {
        uri = Sms.CONTENT_URI;
    } else {
        uri = Mms.CONTENT_URI;
    }
    final Uri lockUri = ContentUris.withAppendedId(uri, msgItem.mMsgId);

    final ContentValues values = new ContentValues(1);
    values.put("locked", locked ? 1 : 0);

    new Thread(() -> {
        context.getContentResolver().update(lockUri,
                values, null, null);
    }, "MainActivity.lockMessage").start();
}

/**
 * Get the thread ID of the SMS message with the given URI
 * @param context The context
 * @param uri The URI of the SMS message
 * @return The thread ID, or THREAD_NONE if the URI contains no entries
 */
public static long getSmsThreadId(Context context, Uri uri) {
    Cursor cursor = SqliteWrapper.query(
        context,
        context.getContentResolver(),
        uri,
        SMS_THREAD_ID_PROJECTION,
        null,
        null,
        null);

    if (cursor == null) {
        return THREAD_NONE;
    }

    try {
        if (cursor.moveToFirst()) {
            return cursor.getLong(cursor.getColumnIndex(Sms.THREAD_ID));
        } else {
            return THREAD_NONE;
        }
    } finally {
        cursor.close();
    }
}

/**
 * Move all messages that are in the outbox to the failed state and set them to unread.
 * @return The number of messages that were actually moved
 */
private int moveOutboxMessagesToFailedBox() {
    ContentValues values = new ContentValues(3);

    values.put(Sms.TYPE, Sms.MESSAGE_TYPE_FAILED);
    values.put(Sms.ERROR_CODE, SmsManager.RESULT_ERROR_GENERIC_FAILURE);
    values.put(Sms.READ, Integer.valueOf(0));

    int messageCount = SqliteWrapper.update(
            getApplicationContext(), getContentResolver(), Outbox.CONTENT_URI,
            values, "type = " + Sms.MESSAGE_TYPE_OUTBOX, null);
    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE) || LogTag.DEBUG_SEND) {
        Log.v(TAG, "moveOutboxMessagesToFailedBox messageCount: " + messageCount);
    }
    return messageCount;
}

@Override
protected void onHandleIntent(Intent intent) {
    // This method is called on a worker thread.

    Uri messageUri = intent.getData();
    byte[] pdu = intent.getByteArrayExtra("pdu");
    String format = intent.getStringExtra("format");

    SmsMessage message = updateMessageStatus(this, messageUri, pdu, format);

    // Called on a background thread, so it's OK to block.
    if (message != null && message.getStatus() < Sms.STATUS_PENDING) {
        MessagingNotification.blockingUpdateNewMessageIndicator(this,
                MessagingNotification.THREAD_NONE, message.isStatusReportMessage());
    }
}

public static void dumpSmsTable(Context context) {
    LogTag.debug("**** Dump of sms table ****");
    Cursor c = context.getContentResolver().query(Sms.CONTENT_URI,
            SMS_PROJECTION, null, null, "_id DESC");
    try {
        // Only dump the latest 20 messages
        c.moveToPosition(-1);
        while (c.moveToNext() && c.getPosition() < 20) {
            String body = c.getString(COLUMN_SMS_BODY);
            LogTag.debug("dumpSmsTable " + BaseColumns._ID + ": "
                    + c.getLong(COLUMN_ID) + " " + Sms.THREAD_ID + " : "
                    + c.getLong(DATE) + " " + Sms.ADDRESS + " : "
                    + c.getString(COLUMN_SMS_ADDRESS) + " " + Sms.BODY
                    + " : " + body.substring(0, Math.min(body.length(), 8))
                    + " " + Sms.DATE + " : " + c.getLong(COLUMN_SMS_DATE)
                    + " " + Sms.TYPE + " : " + c.getInt(COLUMN_SMS_TYPE));
        }
    } finally {
        c.close();
    }
}

private void updateDraftSmsMessage(final Conversation conv, String contents) {
    final long threadId = conv.getThreadId();
    if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
        LogTag.debug("updateDraftSmsMessage tid=%d, contents=\"%s\"",
                threadId, contents);
    }

    // If we don't have a valid thread, there's nothing to do.
    if (threadId <= 0) {
        return;
    }

    ContentValues values = new ContentValues(3);
    values.put(Sms.THREAD_ID, threadId);
    values.put(Sms.BODY, contents);
    values.put(Sms.TYPE, Sms.MESSAGE_TYPE_DRAFT);
    SqliteWrapper.insert(mActivity, mContentResolver, Sms.CONTENT_URI,
            values);
    asyncDeleteDraftMmsMessage(conv);
    mMessageUri = null;
}

private void lockMessage(MessageItem msgItem, boolean locked) {
    Uri uri;
    if ("sms".equals(msgItem.mType)) {
        uri = Sms.CONTENT_URI;
    } else {
        uri = Mms.CONTENT_URI;
    }
    final Uri lockUri = ContentUris.withAppendedId(uri, msgItem.mMsgId);

    final ContentValues values = new ContentValues(1);
    values.put("locked", locked ? 1 : 0);

    new Thread(new Runnable() {
        @Override
        public void run() {
            getContentResolver().update(lockUri, values, null, null);
        }
    }, "ComposeMessageActivity.lockMessage").start();
}

@TargetApi(19)
public void checkIfDefault() {
    final String myPackageName = getPackageName();
    if (android.os.Build.VERSION.SDK_INT >= 19) {
        if (!Telephony.Sms.getDefaultSmsPackage(this).equals(myPackageName)) {
            // App is not default.
            // Show the "not currently set as the default SMS app" dialog
            System.out.println(" setting false");
            isDefault = false;
            Intent intent = new Intent(Sms.Intents.ACTION_CHANGE_DEFAULT);
            intent.putExtra(Sms.Intents.EXTRA_PACKAGE_NAME,
                    getApplicationContext().getPackageName());
            startActivityForResult(intent,99);
        }
        else{
            System.out.println(" setting true");
            isDefault = true;
        }

    }
    else
        isDefault = true;
}

/**
 * Move all messages that are in the outbox to the failed state and set them to unread.
 * @return The number of messages that were actually moved
 */
private int moveOutboxMessagesToFailedBox() {
    ContentValues values = new ContentValues(3);

    values.put(Sms.TYPE, Sms.MESSAGE_TYPE_FAILED);
    values.put(Sms.ERROR_CODE, SmsManager.RESULT_ERROR_GENERIC_FAILURE);
    values.put(Sms.READ, Integer.valueOf(0));

    int messageCount = SqliteWrapper.update(
            getApplicationContext(), getContentResolver(), Outbox.CONTENT_URI,
            values, "type = " + Sms.MESSAGE_TYPE_OUTBOX, null);
    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE) || LogTag.DEBUG_SEND) {
        Log.v(TAG, "moveOutboxMessagesToFailedBox messageCount: " + messageCount);
    }
    return messageCount;
}

@Override
protected void onHandleIntent(Intent intent) {
    // This method is called on a worker thread.

    Uri messageUri = intent.getData();
    byte[] pdu = intent.getByteArrayExtra("pdu");
    String format = intent.getStringExtra("format");

    SmsMessage message = updateMessageStatus(this, messageUri, pdu, format);

    // Called on a background thread, so it's OK to block.
    if (message != null && message.getStatus() < Sms.STATUS_PENDING) {
        MessagingNotification.blockingUpdateNewMessageIndicator(this,
                MessagingNotification.THREAD_NONE, message.isStatusReportMessage());
    }
}

public static void dumpSmsTable(Context context) {
    LogTag.debug("**** Dump of sms table ****");
    Cursor c = context.getContentResolver().query(Sms.CONTENT_URI,
            SMS_PROJECTION, null, null, "_id DESC");
    try {
        // Only dump the latest 20 messages
        c.moveToPosition(-1);
        while (c.moveToNext() && c.getPosition() < 20) {
            String body = c.getString(COLUMN_SMS_BODY);
            LogTag.debug("dumpSmsTable " + BaseColumns._ID + ": " + c.getLong(COLUMN_ID) +
                    " " + Sms.THREAD_ID + " : " + c.getLong(DATE) +
                    " " + Sms.ADDRESS + " : " + c.getString(COLUMN_SMS_ADDRESS) +
                    " " + Sms.BODY + " : " + body.substring(0, Math.min(body.length(), 8)) +
                    " " + Sms.DATE + " : " + c.getLong(COLUMN_SMS_DATE) +
                    " " + Sms.TYPE + " : " + c.getInt(COLUMN_SMS_TYPE));
        }
    } finally {
        c.close();
    }
}

private void updateDraftSmsMessage(final Conversation conv, String contents) {
    final long threadId = conv.getThreadId();
    if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
        LogTag.debug("updateDraftSmsMessage tid=%d, contents=\"%s\"", threadId, contents);
    }

    // If we don't have a valid thread, there's nothing to do.
    if (threadId <= 0) {
        return;
    }

    ContentValues values = new ContentValues(3);
    values.put(Sms.THREAD_ID, threadId);
    values.put(Sms.BODY, contents);
    values.put(Sms.TYPE, Sms.MESSAGE_TYPE_DRAFT);
    SqliteWrapper.insert(mActivity, mContentResolver, Sms.CONTENT_URI, values);
    asyncDeleteDraftMmsMessage(conv);
    mMessageUri = null;
}

private void editSmsMessageItem(MessageItem msgItem) {
    // When the message being edited is the only message in the conversation, the delete
    // below does something subtle. The trigger "delete_obsolete_threads_pdu" sees that a
    // thread contains no messages and silently deletes the thread. Meanwhile, the mConversation
    // object still holds onto the old thread_id and code thinks there's a backing thread in
    // the DB when it really has been deleted. Here we try and notice that situation and
    // clear out the thread_id. Later on, when Conversation.ensureThreadId() is called, we'll
    // create a new thread if necessary.
    synchronized(mConversation) {
        if (mConversation.getMessageCount() <= 1) {
            mConversation.clearThreadId();
            MessagingNotification.setCurrentlyDisplayedThreadId(
                MessagingNotification.THREAD_NONE);
        }
    }
    // Delete the old undelivered SMS and load its content.
    Uri uri = ContentUris.withAppendedId(Sms.CONTENT_URI, msgItem.mMsgId);
    SqliteWrapper.delete(ComposeMessageActivity.this,
            mContentResolver, uri, null, null);

    mWorkingMessage.setText(msgItem.mBody);
}

private void lockMessage(MessageItem msgItem, boolean locked) {
    Uri uri;
    if ("sms".equals(msgItem.mType)) {
        uri = Sms.CONTENT_URI;
    } else {
        uri = Mms.CONTENT_URI;
    }
    final Uri lockUri = ContentUris.withAppendedId(uri, msgItem.mMsgId);

    final ContentValues values = new ContentValues(1);
    values.put("locked", locked ? 1 : 0);

    new Thread(new Runnable() {
        @Override
        public void run() {
            getContentResolver().update(lockUri,
                    values, null, null);
        }
    }, "ComposeMessageActivity.lockMessage").start();
}

private void copyToPhoneMemory(Cursor cursor) {
    String address = cursor.getString(
            cursor.getColumnIndexOrThrow("address"));
    String body = cursor.getString(cursor.getColumnIndexOrThrow("body"));
    Long date = cursor.getLong(cursor.getColumnIndexOrThrow("date"));

    try {
        if (isIncomingMessage(cursor)) {
            Sms.Inbox.addMessage(mContentResolver, address, body, null, date, true /* read */);
        } else {
            Sms.Sent.addMessage(mContentResolver, address, body, null, date);
        }
    } catch (SQLiteException e) {
        SqliteWrapper.checkSQLiteException(this, e);
    }
}

private static void blockingMarkAllSmsMessagesAsSeen(final Context context) {
    ContentResolver resolver = context.getContentResolver();
    Cursor cursor = resolver.query(Sms.Inbox.CONTENT_URI,
            SEEN_PROJECTION,
            "seen=0",
            null,
            null);

    int count = 0;

    if (cursor != null) {
        try {
            count = cursor.getCount();
        } finally {
            cursor.close();
        }
    }

    if (count == 0) {
        return;
    }

    if (DELETEDEBUG || Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
        Log.d(TAG, "mark " + count + " SMS msgs as seen");
    }

    ContentValues values = new ContentValues(1);
    values.put("seen", 1);

    resolver.update(Sms.Inbox.CONTENT_URI,
            values,
            "seen=0",
            null);
}

public boolean isMe() {
    // Logic matches MessageListAdapter.getItemViewType which is used to decide which
    // type of MessageListItem to create: a left or right justified item depending on whether
    // the message is incoming or outgoing.
    boolean isIncomingMms = isMms()
                                && (mBoxId == Mms.MESSAGE_BOX_INBOX
                                        || mBoxId == Mms.MESSAGE_BOX_ALL);
    boolean isIncomingSms = isSms()
                                && (mBoxId == Sms.MESSAGE_TYPE_INBOX
                                        || mBoxId == Sms.MESSAGE_TYPE_ALL);
    return !(isIncomingMms || isIncomingSms);
}

public boolean isOutgoingMessage() {
    boolean isOutgoingMms = isMms() && (mBoxId == Mms.MESSAGE_BOX_OUTBOX);
    boolean isOutgoingSms = isSms()
                                && ((mBoxId == Sms.MESSAGE_TYPE_FAILED)
                                        || (mBoxId == Sms.MESSAGE_TYPE_OUTBOX)
                                        || (mBoxId == Sms.MESSAGE_TYPE_QUEUED));
    return isOutgoingMms || isOutgoingSms;
}

public boolean isFailedMessage() {
    boolean isFailedMms = isMms()
                        && (mErrorType >= MmsSms.ERR_TYPE_GENERIC_PERMANENT);
    boolean isFailedSms = isSms()
                        && (mBoxId == Sms.MESSAGE_TYPE_FAILED);
    return isFailedMms || isFailedSms;
}

private List<DeliveryReportItem> getSmsReportItems() {
    String selection = "_id = " + mMessageId;
    Cursor c = SqliteWrapper.query(mContext, mContext.getContentResolver(), Sms.CONTENT_URI,
                          SMS_REPORT_STATUS_PROJECTION, selection, null, null);
    if (c == null) {
        return null;
    }

    try {
        if (c.getCount() <= 0) {
            return null;
        }

        List<DeliveryReportItem> items = new ArrayList<>();
        while (c.moveToNext()) {
            // For sent messages with delivery reports, we stick the delivery time in the
            // date_sent column (see MessageStatusReceiver).
            String deliveryDateString = null;
            long deliveryDate = c.getLong(COLUMN_DATE_SENT);
            int messageType = c.getInt(COLUMN_MESSAGE_TYPE);
            if (messageType == Sms.MESSAGE_TYPE_SENT && deliveryDate > 0) {
                deliveryDateString = mContext.getString(R.string.delivered_label) +
                        MessageUtils.formatTimeStampString(mContext, deliveryDate, true);
            }

            items.add(new DeliveryReportItem(
                            mContext.getString(R.string.recipient_label) + c.getString(COLUMN_RECIPIENT),
                            mContext.getString(R.string.status_label) +
                                    getSmsStatusText(c.getInt(COLUMN_DELIVERY_STATUS)),
                                    deliveryDateString));
        }
        return items;
    } finally {
        c.close();
    }
}

private String getSmsStatusText(int status) {
    if (status == Sms.STATUS_NONE) {
        // No delivery report requested
        return mContext.getString(R.string.status_none);
    } else if (status >= Sms.STATUS_FAILED) {
        // Failure
        return mContext.getString(R.string.status_failed);
    } else if (status >= Sms.STATUS_PENDING) {
        // Pending
        return mContext.getString(R.string.status_pending);
    } else {
        // Success
        return mContext.getString(R.string.status_received);
    }
}

private boolean queueMessage(long token) throws MmsException {
    if ((mMessageText == null) || (mNumberOfDests == 0)) {
        // Don't try to send an empty message.
        throw new MmsException("Null message body or dest.");
    }

    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext);
    boolean requestDeliveryReport = prefs.getBoolean(
            MessagingPreferenceActivity.SMS_DELIVERY_REPORT_MODE,
            DEFAULT_DELIVERY_REPORT_MODE);

    for (int i = 0; i < mNumberOfDests; i++) {
        try {
            if (LogTag.DEBUG_SEND) {
                Log.v(TAG, "queueMessage mDests[i]: " + mDests[i] + " mThreadId: " + mThreadId);
            }
            log("updating Database with sub = " + mSubscription);
            Sms.addMessageToUri(mContext.getContentResolver(),
                    Uri.parse("content://sms/queued"), mDests[i],
                    mMessageText, null, mTimestamp,
                    true /* read */,
                    requestDeliveryReport,
                    mThreadId, mSubscription);
        } catch (SQLiteException e) {
            if (LogTag.DEBUG_SEND) {
                Log.e(TAG, "queueMessage SQLiteException", e);
            }
            SqliteWrapper.checkSQLiteException(mContext, e);
        }
    }
    // Notify the SmsReceiverService to send the message out
    mContext.sendBroadcast(new Intent(SmsReceiverService.ACTION_SEND_MESSAGE,
            null,
            mContext,
            SmsReceiver.class));
    return false;
}

private static final MmsSmsDeliveryInfo getSmsNewDeliveryInfo(Context context) {
    ContentResolver resolver = context.getContentResolver();
    Cursor cursor = SqliteWrapper.query(context, resolver, Sms.CONTENT_URI,
                SMS_STATUS_PROJECTION, NEW_DELIVERY_SM_CONSTRAINT,
                null, Sms.DATE);

    if (cursor == null) {
        return null;
    }

    try {
        if (!cursor.moveToLast()) {
            return null;
        }

        String address = cursor.getString(COLUMN_SMS_ADDRESS);
        long timeMillis = 3000;

        Contact contact = Contact.get(address, false);
        String name = contact.getNameAndNumber();

        return new MmsSmsDeliveryInfo(context.getString(R.string.delivery_toast_body, name),
            timeMillis);

    } finally {
        cursor.close();
    }
}

private void messageFailedToSend(Uri uri, int error) {
    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE) || LogTag.DEBUG_SEND) {
        Log.v(TAG, "messageFailedToSend msg failed uri: " + uri + " error: " + error);
    }
    Sms.moveMessageToFolder(this, uri, Sms.MESSAGE_TYPE_FAILED, error);
    MessagingNotification.notifySendFailed(getApplicationContext(), true);
}

private SmsMessage updateMessageStatus(Context context, Uri messageUri, byte[] pdu,
        String format) {
    SmsMessage message = SmsMessage.createFromPdu(pdu, format);
    if (message == null) {
        return null;
    }
    // Create a "status/#" URL and use it to update the
    // message's status in the database.
    Cursor cursor = SqliteWrapper.query(context, context.getContentResolver(),
                        messageUri, ID_PROJECTION, null, null, null);

    try {
        if (cursor.moveToFirst()) {
            int messageId = cursor.getInt(0);

            Uri updateUri = ContentUris.withAppendedId(STATUS_URI, messageId);
            int status = message.getStatus();
            boolean isStatusReport = message.isStatusReportMessage();
            ContentValues contentValues = new ContentValues(2);

            if (Log.isLoggable(LogTag.TAG, Log.DEBUG)) {
                log("updateMessageStatus: msgUrl=" + messageUri + ", status=" + status +
                        ", isStatusReport=" + isStatusReport);
            }

            contentValues.put(Sms.STATUS, status);
            contentValues.put(Inbox.DATE_SENT, System.currentTimeMillis());
            SqliteWrapper.update(context, context.getContentResolver(),
                                updateUri, contentValues, null, null);
        } else {
            error("Can't find message for status update: " + messageUri);
        }
    } finally {
        cursor.close();
    }
    return message;
}

private static void blockingMarkAllSmsMessagesAsSeen(final Context context) {
    ContentResolver resolver = context.getContentResolver();
    Cursor cursor = resolver.query(Sms.Inbox.CONTENT_URI, SEEN_PROJECTION,
            "seen=0", null, null);

    int count = 0;

    if (cursor != null) {
        try {
            count = cursor.getCount();
        } finally {
            cursor.close();
        }
    }

    if (count == 0) {
        return;
    }

    if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
        Log.d(TAG, "mark " + count + " SMS msgs as seen");
    }

    ContentValues values = new ContentValues(1);
    values.put("seen", 1);

    resolver.update(Sms.Inbox.CONTENT_URI, values, "seen=0", null);
}

public void asyncDeleteDraftSmsMessage(Conversation conv) {
    mHasSmsDraft = false;

    final long threadId = conv.getThreadId();
    if (threadId > 0) {
        asyncDelete(ContentUris.withAppendedId(
                Sms.Conversations.CONTENT_URI, threadId), SMS_DRAFT_WHERE,
                null);
    }
}

public boolean isOutgoingMessage() {
    boolean isOutgoingMms = isMms() && (mBoxId == Mms.MESSAGE_BOX_OUTBOX);
    boolean isOutgoingSms = isSms()
                                && ((mBoxId == Sms.MESSAGE_TYPE_FAILED)
                                        || (mBoxId == Sms.MESSAGE_TYPE_OUTBOX)
                                        || (mBoxId == Sms.MESSAGE_TYPE_QUEUED));
    return isOutgoingMms || isOutgoingSms;
}

public boolean isFailedMessage() {
    boolean isFailedMms = isMms()
                        && (mErrorType >= MmsSms.ERR_TYPE_GENERIC_PERMANENT);
    boolean isFailedSms = isSms()
                        && (mBoxId == Sms.MESSAGE_TYPE_FAILED);
    return isFailedMms || isFailedSms;
}

private void editSmsMessageItem(MessageItem msgItem) {
    // When the message being edited is the only message in the
    // conversation, the delete
    // below does something subtle. The trigger
    // "delete_obsolete_threads_pdu" sees that a
    // thread contains no messages and silently deletes the thread.
    // Meanwhile, the mConversation
    // object still holds onto the old thread_id and code thinks there's a
    // backing thread in
    // the DB when it really has been deleted. Here we try and notice that
    // situation and
    // clear out the thread_id. Later on, when Conversation.ensureThreadId()
    // is called, we'll
    // create a new thread if necessary.
    synchronized (mConversation) {
        if (mConversation.getMessageCount() <= 1) {
            mConversation.clearThreadId();
            MessagingNotification
                    .setCurrentlyDisplayedThreadId(MessagingNotification.THREAD_NONE);
        }
    }
    // Delete the old undelivered SMS and load its content.
    Uri uri = ContentUris.withAppendedId(Sms.CONTENT_URI, msgItem.mMsgId);
    SqliteWrapper.delete(ComposeMessageActivity.this, mContentResolver,
            uri, null, null);

    mWorkingMessage.setText(msgItem.mBody);
}

private Uri replaceMessage(SmsMessage sms) {
    ContentValues values = extractContentValues(sms);

    values.put(Inbox.BODY, sms.getMessageBody());

    ContentResolver resolver = getContentResolver();
    String originatingAddress = sms.getOriginatingAddress();
    int protocolIdentifier = sms.getProtocolIdentifier();
    String selection = Sms.ADDRESS + " = ? AND " + Sms.PROTOCOL + " = ?";
    String[] selectionArgs = new String[] { originatingAddress,
            Integer.toString(protocolIdentifier) };

    Cursor cursor = SqliteWrapper.query(this, resolver, Inbox.CONTENT_URI,
            REPLACE_PROJECTION, selection, selectionArgs, null);

    try {
        if (cursor.moveToFirst()) {
            long messageId = cursor.getLong(REPLACE_COLUMN_ID);
            Uri messageUri = ContentUris.withAppendedId(
                    Sms.CONTENT_URI, messageId);

            SqliteWrapper.update(this, resolver, messageUri, values,
                    null, null);
            return messageUri;
        }
    } finally {
        cursor.close();
    }
    return storeMessage(sms);
}

private List<DeliveryReportItem> getSmsReportItems() {
    String selection = "_id = " + mMessageId;
    Cursor c = SqliteWrapper.query(this, getContentResolver(), Sms.CONTENT_URI,
                          SMS_REPORT_STATUS_PROJECTION, selection, null, null);
    if (c == null) {
        return null;
    }

    try {
        if (c.getCount() <= 0) {
            return null;
        }

        List<DeliveryReportItem> items = new ArrayList<DeliveryReportItem>();
        while (c.moveToNext()) {
            // For sent messages with delivery reports, we stick the delivery time in the
            // date_sent column (see MessageStatusReceiver).
            String deliveryDateString = null;
            long deliveryDate = c.getLong(COLUMN_DATE_SENT);
            int messageType = c.getInt(COLUMN_MESSAGE_TYPE);
            if (messageType == Sms.MESSAGE_TYPE_SENT && deliveryDate > 0) {
                deliveryDateString = getString(R.string.delivered_label) +
                        MessageUtils.formatTimeStampString(this,
                                deliveryDate, true);
            }

            items.add(new DeliveryReportItem(
                            getString(R.string.recipient_label) + c.getString(COLUMN_RECIPIENT),
                            getString(R.string.status_label) +
                                    getSmsStatusText(c.getInt(COLUMN_DELIVERY_STATUS)),
                                    deliveryDateString));
        }
        return items;
    } finally {
        c.close();
    }
}

private String getSmsStatusText(int status) {
    if (status == Sms.STATUS_NONE) {
        // No delivery report requested
        return getString(R.string.status_none);
    } else if (status >= Sms.STATUS_FAILED) {
        // Failure
        return getString(R.string.status_failed);
    } else if (status >= Sms.STATUS_PENDING) {
        // Pending
        return getString(R.string.status_pending);
    } else {
        // Success
        return getString(R.string.status_received);
    }
}

protected Cursor getAllThreads(Context context) {
    ContentResolver resolver = context.getContentResolver();
    Cursor cursor = SqliteWrapper.query(context, resolver,
            Telephony.Sms.Conversations.CONTENT_URI,
            ALL_SMS_THREADS_PROJECTION, null, null, Conversations.DEFAULT_SORT_ORDER);

    return cursor;
}

@Override
protected boolean anyThreadOverLimit(Context context) {
    Cursor cursor = getAllThreads(context);
    if (cursor == null) {
        return false;
    }
    int limit = getMessageLimit(context);
    try {
        while (cursor.moveToNext()) {
            long threadId = getThreadId(cursor);
            ContentResolver resolver = context.getContentResolver();
            Cursor msgs = SqliteWrapper.query(context, resolver,
                    ContentUris.withAppendedId(Sms.Conversations.CONTENT_URI, threadId),
                    SMS_MESSAGE_PROJECTION,
                    "locked=0",
                    null, "date DESC");     // get in newest to oldest order
            if (msgs == null) {
                return false;
            }
            try {
                if (msgs.getCount() >= limit) {
                    return true;
                }
            } finally {
                msgs.close();
            }
        }
    } finally {
        cursor.close();
    }
    return false;
}

public String toRealType(int type) {
    switch (type) {
        case Sms.MESSAGE_TYPE_INBOX:
            return INBOX_MESSAGE;
        case Sms.MESSAGE_TYPE_OUTBOX:
            return  OUTBOX_MESSAGE;
        case Sms.MESSAGE_TYPE_DRAFT:
            return DRAFT_MESSAGE;
        case Sms.MESSAGE_TYPE_SENT:
            return SENT_MESSAGE;
        default:
            return "";
    }
}

@TargetApi(Build.VERSION_CODES.KITKAT)
private static void setupSMSAppPreference(Preference smsPreference) {
    String summary = "Set the SMS app in use";
    PackageManager packageManager = smsPreference.getContext().getPackageManager();
    String smsAppPackageName = Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT ? smsPreference.getSharedPreferences().getString(smsPreference.getKey(), null)
            : Sms.getDefaultSmsPackage(smsPreference.getContext());
    if (smsAppPackageName != null) {
        try {
            CharSequence smsAppLabel = packageManager.getApplicationLabel(packageManager.getApplicationInfo(smsAppPackageName, 0));
            summary = "Launching " + smsAppLabel + " if Contact Notifier notification is tapped";
        } catch (NameNotFoundException e) {
            e.printStackTrace();
        }
    }
    smsPreference.setSummary(summary);
    smsPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {

        @Override
        public boolean onPreferenceClick(Preference preference) {
            preference.getContext().startActivity(new Intent(preference.getContext(), SMSAppChooserContainer.class));
            return false;
        }
    });

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        smsPreference.setEnabled(false);
    }
}