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

@TargetApi(Build.VERSION_CODES.KITKAT)
@Override
public void onReceive(Context receivedContext, Intent intent) {
    if (Intents.SMS_RECEIVED_ACTION.equals(intent.getAction())) {
        SnippetEvent event = new SnippetEvent(mCallbackId, SMS_RECEIVED_EVENT_NAME);
        Bundle extras = intent.getExtras();
        if (extras != null) {
            SmsMessage[] msgs = Intents.getMessagesFromIntent(intent);
            StringBuilder smsMsg = new StringBuilder();

            SmsMessage sms = msgs[0];
            String sender = sms.getOriginatingAddress();
            event.getData().putString("OriginatingAddress", sender);

            for (SmsMessage msg : msgs) {
                smsMsg.append(msg.getMessageBody());
            }
            event.getData().putString("MessageBody", smsMsg.toString());
            mEventCache.postEvent(event);
            mContext.unregisterReceiver(this);
        }
    }
}

public final void onReceive(Context paramContext, Intent paramIntent)
{
  if (!"android.provider.Telephony.SMS_RECEIVED".equals(paramIntent.getAction()))
  {
    Log.d("SmsReceiver", "Received intent with action: " + paramIntent.getAction());
    return;
  }
  if (this.mListener == null)
  {
    Log.v("SmsReceiver", "No listener to handle SMS broadcasts");
    return;
  }
  if (Build.VERSION.SDK_INT >= 19)
  {
    this.mListener.onSmsReceived(Telephony.Sms.Intents.getMessagesFromIntent(paramIntent));
    return;
  }
  Object[] arrayOfObject = (Object[])paramIntent.getExtras().get("pdus");
  int i = arrayOfObject.length;
  SmsMessage[] arrayOfSmsMessage = new SmsMessage[i];
  for (int j = 0; j < i; j++) {
    arrayOfSmsMessage[j] = SmsMessage.createFromPdu((byte[])(byte[])arrayOfObject[j]);
  }
  this.mListener.onSmsReceived(arrayOfSmsMessage);
}

private void handleSmsReceived(Intent intent, int error) {
    SmsMessage[] msgs = Intents.getMessagesFromIntent(intent);
    String format = intent.getStringExtra("format");
    Uri messageUri = insertMessage(this, msgs, error, format);

    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE) || LogTag.DEBUG_SEND) {
        SmsMessage sms = msgs[0];
        Log.v(TAG, "handleSmsReceived" + (sms.isReplace() ? "(replace)" : "") +
                " messageUri: " + messageUri +
                ", address: " + sms.getOriginatingAddress() +
                ", body: " + sms.getMessageBody());
    }

    if (messageUri != null) {
        long threadId = MessagingNotification.getSmsThreadId(this, messageUri);
        // Called off of the UI thread so ok to block.
        MessagingNotification.blockingUpdateNewMessageIndicator(this, threadId, false);
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    String action = (intent == null ? null : intent.getAction());
    if (Intents.SMS_DELIVER_ACTION.equals(action) || Intents.SMS_RECEIVED_ACTION.equals(action)) {
        Bundle bundle = intent.getExtras();
        if (bundle == null)
            Toast.makeText(context, action, Toast.LENGTH_LONG).show();
        else {
            Object[] pdusObj = (Object[]) bundle.get("pdus");
            for (Object currentObj : pdusObj) {
                SmsMessage message = SmsMessage.createFromPdu((byte[]) currentObj);
                String origin = message.getDisplayOriginatingAddress();
                Toast.makeText(context, action + ": " + origin, Toast.LENGTH_LONG).show();
            }
        }
    }
}

private void handleSmsReceived(Intent intent, int error) {
    SmsMessage[] msgs = Intents.getMessagesFromIntent(intent);
    String format = intent.getStringExtra("format");
    Uri messageUri = insertMessage(this, msgs, error, format);

    if (Log.isLoggable(LogTag.TRANSACTION, Log.VERBOSE) || LogTag.DEBUG_SEND) {
        SmsMessage sms = msgs[0];
        Log.v(TAG, "handleSmsReceived" + (sms.isReplace() ? "(replace)" : "") +
                " messageUri: " + messageUri +
                ", address: " + sms.getOriginatingAddress() +
                ", body: " + sms.getMessageBody());
    }

    if (messageUri != null) {
        long threadId = MessagingNotification.getSmsThreadId(this, messageUri);
        // Called off of the UI thread so ok to block.
        Log.d(TAG, "handleSmsReceived messageUri: " + messageUri + " threadId: " + threadId);
        MessagingNotification.blockingUpdateNewMessageIndicator(this, threadId, false);
    }
}

@TargetApi(Build.VERSION_CODES.KITKAT)
@Rpc(description = "Wait for incoming SMS message.")
public JSONObject waitForSms() throws Throwable {
    String callbackId = SMS_CALLBACK_ID_PREFIX + (++mCallbackCounter);
    SmsReceiver receiver = new SmsReceiver(mContext, callbackId);
    mContext.registerReceiver(receiver, new IntentFilter(Intents.SMS_RECEIVED_ACTION));
    return Utils.waitForSnippetEvent(
                    callbackId, SMS_RECEIVED_EVENT_NAME, DEFAULT_TIMEOUT_MILLISECOND)
            .toJson();
}

/**
 * Retrieve any SmsMessage objects encoded in the SMS_RECEIVED intent.
 *
 * @param intent An intent passed by Android to the SMS_RECEIVED receiver.
 * @return A list of SmsMessages. The list will be non-null but zero length if the intent lacks
 *   SMS content.
 */
public static List<SmsMessage> getMessagesFromIntent(Intent intent) {
  List<SmsMessage> result = new ArrayList<SmsMessage>();
  SmsMessage[] messages = Intents.getMessagesFromIntent(intent);
  if (messages != null && messages.length >= 0) {
    Collections.addAll(result, messages);
  }
  return result;
}

@Override
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
    Intent intent = (Intent) param.args[1];
    String action = intent.getAction();
    if (action.equals(Intents.SMS_DELIVER_ACTION)
            || action.equals(Intents.WAP_PUSH_DELIVER_ACTION)) {
        // already send, treat as anther action
        Log.i(TAG, "received deliver action");

        intent.setAction("czbix.sms.deliver.finish");
    }
}

private void updateDefaultSmsReceiver(Context context, ComponentName componentName, boolean isMms) {
    SmsReceiver receiver = isMms ? mmsReceiver : smsReceiver;
    if (receiver != null) {
        if (receiver.getComponentName().equals(componentName)) {
            return;
        }
        context.unregisterReceiver(receiver);

        if (isMms) {
            mmsReceiver = null;
        } else {
            smsReceiver = null;
        }
    }

    if (componentName == null) {
        return;
    }

    receiver = new SmsReceiver(componentName);
    context.registerReceiver(receiver, new IntentFilter(isMms
            ? Intents.WAP_PUSH_RECEIVED_ACTION : Intents.SMS_RECEIVED_ACTION));
    if (isMms) {
        mmsReceiver = receiver;
    } else {
        smsReceiver = receiver;
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (intent.getAction().equals(Intents.SMS_RECEIVED_ACTION)) {
        intent.setAction(Intents.SMS_DELIVER_ACTION);
    } else if (intent.getAction().equals(Intents.WAP_PUSH_RECEIVED_ACTION)) {
        intent.setAction(Intents.WAP_PUSH_DELIVER_ACTION);
    }
    intent.setComponent(componentName);

    context.sendBroadcast(intent);
}

protected void onReceiveWithPrivilege(Context context, Intent intent, boolean privileged) {
    // If 'privileged' is false, it means that the intent was delivered to the base
    // no-permissions receiver class.  If we get an SMS_RECEIVED message that way, it
    // means someone has tried to spoof the message by delivering it outside the normal
    // permission-checked route, so we just ignore it.
    if (!privileged && intent.getAction().equals(Intents.SMS_RECEIVED_ACTION)) {
        return;
    }

    intent.setClass(context, SmsReceiverService.class);
    intent.putExtra("result", getResultCode());
    beginStartingService(context, intent);
}

protected void onReceiveWithPrivilege(Context context, Intent intent, boolean privileged) {
    // If 'privileged' is false, it means that the intent was delivered to the base
    // no-permissions receiver class.  If we get an SMS_RECEIVED message that way, it
    // means someone has tried to spoof the message by delivering it outside the normal
    // permission-checked route, so we just ignore it.
    if (!privileged && intent.getAction().equals(Intents.SMS_DELIVER_ACTION)) {
        return;
    }

    intent.setClass(context, SmsReceiverService.class);
    intent.putExtra("result", getResultCode());
    beginStartingService(context, intent);
}

@TargetApi(Build.VERSION_CODES.KITKAT)
@AsyncRpc(description = "Async wait for incoming SMS message.")
public void asyncWaitForSms(String callbackId) {
    SmsReceiver receiver = new SmsReceiver(mContext, callbackId);
    mContext.registerReceiver(receiver, new IntentFilter(Intents.SMS_RECEIVED_ACTION));
}

@Override
protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
    Intent intent = (Intent) param.args[0];
    final String action = intent.getAction();

    boolean isMms = false;
    switch (action) {
        case Intents.SMS_DELIVER_ACTION:
            intent.setAction(Intents.SMS_RECEIVED_ACTION);
            break;
        case Intents.WAP_PUSH_DELIVER_ACTION:
            isMms = true;
            intent.setAction(Intents.WAP_PUSH_RECEIVED_ACTION);
            break;
        default:
            // not interesting
            return;
    }

    Context context = (Context) XposedHelpers.getObjectField(param.thisObject, "mContext");
    updateDefaultSmsReceiver(context, intent.getComponent(), isMms);
    intent.setComponent(null);

    Log.d(TAG, "received sms, send broadcast to sms blocker");

    String perm = (String) param.args[1];
    int appOp = ((Integer) param.args[2]);
    BroadcastReceiver receiver = (BroadcastReceiver) param.args[Utils.isMmOrLater ? 4 : 3];

    if (Utils.isMmOrLater) {
        final Bundle opts = (Bundle) param.args[3];
        handleForMm(param, context, intent, perm, appOp, opts, receiver);
    } else if (Utils.isLpOrLater) {
        handleForLp(param, context, intent, perm, appOp, receiver);
    } else {
        callSendBroadcast(param.thisObject, context, intent, perm, appOp, receiver);
    }

    // skip original method
    param.setResult(null);
}