@RequiresApi(api = Build.VERSION_CODES.KITKAT)
@Override
public boolean test() throws Throwable {
    String[] projection = new String[] {Telephony.Sms._ID, Telephony.Sms.ADDRESS, Telephony.Sms.PERSON,
        Telephony.Sms.BODY};
    Cursor cursor = mResolver.query(Telephony.Sms.CONTENT_URI, projection, null, null, null);
    if (cursor != null) {
        try {
            CursorTest.read(cursor);
        } finally {
            cursor.close();
        }
        return true;
    } else {
        return false;
    }
}
 

@RequiresApi(api = Build.VERSION_CODES.KITKAT)
@Override
public boolean test() throws Throwable {
    String[] projection = new String[] {Telephony.Sms._ID, Telephony.Sms.ADDRESS, Telephony.Sms.PERSON,
        Telephony.Sms.BODY};
    Cursor cursor = mResolver.query(Telephony.Sms.CONTENT_URI, projection, null, null, null);
    if (cursor != null) {
        try {
            CursorTest.read(cursor);
        } finally {
            cursor.close();
        }
        return true;
    } else {
        return false;
    }
}
 

private void beforeDispatchIntentHandler(XC_MethodHook.MethodHookParam param, int receiverIndex) {
    Intent intent = (Intent) param.args[0];
    String action = intent.getAction();

    // We only care about the initial SMS_DELIVER intent,
    // the rest are irrelevant
    if (!Telephony.Sms.Intents.SMS_DELIVER_ACTION.equals(action)) {
        return;
    }

    ParseResult parseResult = new CodeWorker(mAppContext, mPhoneContext, intent).parse();
    if (parseResult != null) {// parse succeed
        if (parseResult.isBlockSms()) {
            XLog.d("Blocking code SMS...");
            deleteRawTableAndSendMessage(param.thisObject, param.args[receiverIndex]);
            param.setResult(null);
        }
    }
}
 

/**
 * 包访问级别:提高性能
 * 从接收者中得到短信验证码
 *
 * @param intent
 */
void getSmsCodeFromReceiver(Intent intent) {
    SmsMessage[] messages = null;
    if (Build.VERSION.SDK_INT >= 19) {
        messages = android.provider.Telephony.Sms.Intents.getMessagesFromIntent(intent);
        if (messages == null) return;
    } else {
        messages = getSmsUnder19(intent);
        if (messages == null) return;
    }

    if (messages.length > 0) {
        for (int i = 0; i < messages.length; i++) {
            SmsMessage sms = messages[i];
            String smsSender = sms.getOriginatingAddress();
            String smsBody = sms.getMessageBody();
            if (checkSmsSender(smsSender) && checkSmsBody(smsBody)) {
                String smsCode = parseSmsBody(smsBody);
                sendMsg2Register(OBSERVER_SMS_CODE_MSG, smsCode);
                break;
            }
        }
    }
}
 

/**
 * 包访问级别:提高性能
 * 从内容观察者得到短信验证码
 *
 * @param cursor
 */
void getSmsCodeFromObserver(Cursor cursor) {
    if (cursor == null) return;

    while (cursor.moveToNext()) {
        String address = cursor.getString(cursor.getColumnIndex(Telephony.Sms.ADDRESS));
        String smsBody = cursor.getString(cursor.getColumnIndex(Telephony.Sms.BODY));
        if (checkSmsSender(address) && checkSmsBody(smsBody)) {
            String smsCode = parseSmsBody(smsBody);
            sendMsg2Register(RECEIVER_SMS_CODE_MSG, smsCode);
            break;
        }
    }

    closeCursor(cursor);
}
 

/**
 * read sms, {@link android.Manifest.permission#READ_SMS}
 * in MEIZU 5.0~6.0, just according normal phone request
 * in XIAOMI 6.0~, need force judge
 * in XIAOMI 5.0~6.0, not test!!!
 *
 * @param activity
 * @return true if success
 * @throws Exception
 */
private static boolean checkReadSms(Activity activity) throws Exception {
    Cursor cursor = activity.getContentResolver().query(Uri.parse("content://sms/"), null, null,
            null, null);
    if (cursor != null) {
        if (ManufacturerSupportUtil.isForceManufacturer()) {
            if (isNumberIndexInfoIsNull(cursor, cursor.getColumnIndex(Telephony.Sms.DATE))) {
                cursor.close();
                return false;
            }
        }
        cursor.close();
        return true;
    } else {
        return false;
    }
}
 

/**
 * 新增短信记录代理信息
 **/
private void insertSmsLog() {
    Cursor cursor = mContext.getContentResolver().query(
            Uri.parse(PhoneContactUtils.SMS_URI_ALL), new String[]{Telephony.Sms._ID, "read"}, null, null, "date DESC");
    if (cursor == null || cursor.getCount() <= 0)
        return;
    while (cursor.moveToNext()) {
        long id = cursor.getLong(cursor.getColumnIndex(Telephony.Sms._ID));
        SmsProxy msg = findSmsById(id);
        if (msg == null) {
            msg = new SmsProxy();
            msg.setId(id);
            mSmsDao.insert(msg);
        }
    }
    cursor.close();
}
 

public static HashMap getSMSAppsContent(Context context) {
    PackageManager packageManager = context.getPackageManager();
    Intent intent = new Intent(Telephony.Sms.Intents.SMS_DELIVER_ACTION);
    List<ResolveInfo> smsReceivers = packageManager.queryBroadcastReceivers(intent, 0);
    HashMap<String, String> receivers = new HashMap<>();
    for (ResolveInfo resolveInfo : smsReceivers) {
        final ActivityInfo activityInfo = resolveInfo.activityInfo;
        if (activityInfo == null) {
            continue;
        }
        if (!Manifest.permission.BROADCAST_SMS.equals(activityInfo.permission)) {
            continue;
        }
        final String packageName = activityInfo.packageName;
        if (!receivers.containsKey(packageName)) {
            final String applicationName = resolveInfo.loadLabel(packageManager).toString();
            receivers.put(packageName, applicationName);
        }
    }
    return receivers;
}
 

void startSMSWork(View view) {
    DEF_PKG = Telephony.Sms.getDefaultSmsPackage(getApplicationContext());

    boolean tic = messageMain.getText().length() > 0;
    boolean tac = contactView.getText().length() >= 3;

    if (!tic) {
        Toast.makeText(getBaseContext(), "You need a message to save " + new String(Character.toChars(128530)), Toast.LENGTH_SHORT).show();
        return;
    }
    if (!tac) {
        Toast.makeText(getBaseContext(), "Invalid Phone Number " + new String(Character.toChars(128530)), Toast.LENGTH_SHORT).show();
        return;
    }
    Snackbar.make(view, "Crafting SMS using given details " + new String(Character.toChars(128517)), Snackbar.LENGTH_SHORT).show();
    // can't write toe :-(
    if (Telephony.Sms.getDefaultSmsPackage(getApplicationContext()).equals(getPackageName())) {
        doCreateSmsAndChangeDef();
    } else {
        Intent localIntent = new Intent("android.provider.Telephony.ACTION_CHANGE_DEFAULT");
        localIntent.putExtra("package", getPackageName());
        startActivityForResult(localIntent, CHANGE_FROM_DEF);
    }
}
 

void startSMSWork() {
    DEF_PKG = Telephony.Sms.getDefaultSmsPackage(getApplicationContext());

    boolean tic = messageMain.getText().length() > 0;
    boolean tac = contactView.getText().length() >= 3;

    if (!tic) {
        Toast.makeText(getBaseContext(), "You need a message to save " + new String(Character.toChars(128530)), Toast.LENGTH_SHORT).show();
        return;
    }
    if (!tac) {
        Toast.makeText(getBaseContext(), "Invalid Phone Number " + new String(Character.toChars(128530)), Toast.LENGTH_SHORT).show();
        return;
    }
    // can't write toe :-(
    if (Telephony.Sms.getDefaultSmsPackage(getApplicationContext()).equals(getPackageName())) {
        doCreateSmsAndChangeDef();
    } else {
        Intent localIntent = new Intent("android.provider.Telephony.ACTION_CHANGE_DEFAULT");
        localIntent.putExtra("package", getPackageName());
        startActivityForResult(localIntent, CHANGE_FROM_DEF);
    }
}
 

public static HashMap getSMSAppsContent(Context context) {
    PackageManager packageManager = context.getPackageManager();
    Intent intent = new Intent(Telephony.Sms.Intents.SMS_DELIVER_ACTION);
    List<ResolveInfo> smsReceivers = packageManager.queryBroadcastReceivers(intent, 0);
    HashMap<String, String> receivers = new HashMap<>();
    for (ResolveInfo resolveInfo : smsReceivers) {
        final ActivityInfo activityInfo = resolveInfo.activityInfo;
        if (activityInfo == null) {
            continue;
        }
        if (!Manifest.permission.BROADCAST_SMS.equals(activityInfo.permission)) {
            continue;
        }
        final String packageName = activityInfo.packageName;
        if (!receivers.containsKey(packageName)) {
            final String applicationName = resolveInfo.loadLabel(packageManager).toString();
            receivers.put(packageName, applicationName);
        }
    }
    return receivers;
}
 

@TargetApi(19)
public static void askForDefaultAppChange(Fragment fragment, int requestCode) {
    if (!isAvailable()) return;
    Context context = fragment.getContext().getApplicationContext();
    String packageName;
    // current app package is already set as default
    if (isDefault(context)) {
        // get previously saved app package as default
        packageName = Settings.getStringValue(context, Settings.DEFAULT_SMS_APP_NATIVE_PACKAGE);
    } else {
        // get blacklist app package as default
        packageName = context.getPackageName();
        // save current default sms app package to the settings
        String nativePackage = Telephony.Sms.getDefaultSmsPackage(context);
        if (nativePackage != null) {
            Settings.setStringValue(context, Settings.DEFAULT_SMS_APP_NATIVE_PACKAGE, nativePackage);
        }
    }
    // start sms app change dialog
    askForDefaultAppChange(fragment, packageName, requestCode);
}
 

@Override
public boolean test() throws Throwable {
    String[] projection = new String[] {Telephony.Sms._ID, Telephony.Sms.ADDRESS, Telephony.Sms.PERSON,
        Telephony.Sms.BODY};
    Cursor cursor = mResolver.query(Telephony.Sms.CONTENT_URI, projection, null, null, null);
    if (cursor != null) {
        try {
            CursorTest.read(cursor);
        } finally {
            cursor.close();
        }
        return true;
    } else {
        return false;
    }
}
 

private void registerReceiverIfNecessary(BroadcastReceiver receiver) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && getCurrentActivity() != null) {
        getCurrentActivity().registerReceiver(
            receiver,
            new IntentFilter(Telephony.Sms.Intents.SMS_RECEIVED_ACTION)
        );
        isReceiverRegistered = true;
        return;
    }

    if (getCurrentActivity() != null) {
        getCurrentActivity().registerReceiver(
                receiver,
                new IntentFilter("android.provider.Telephony.SMS_RECEIVED")
        );
        isReceiverRegistered = true;
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        for (SmsMessage message : Telephony.Sms.Intents.getMessagesFromIntent(intent)) {
            receiveMessage(message);
        }

        return;
    }

    try {
        final Bundle bundle = intent.getExtras();

        if (bundle == null || ! bundle.containsKey("pdus")) {
            return;
        }

        final Object[] pdus = (Object[]) bundle.get("pdus");

        for (Object pdu : pdus) {
            receiveMessage(SmsMessage.createFromPdu((byte[]) pdu));
        }
    } catch (Exception e) {
        Log.e(SmsListenerPackage.TAG, e.getMessage());
    }
}
 

@Override
  public void onReceive(Context context, Intent intent) {
  Log.w(TAG, "Got MMS broadcast..." + intent.getAction());

  if ((Telephony.Sms.Intents.WAP_PUSH_DELIVER_ACTION.equals(intent.getAction())  &&
      Util.isDefaultSmsProvider(context))                                        ||
      (Telephony.Sms.Intents.WAP_PUSH_RECEIVED_ACTION.equals(intent.getAction()) &&
       isRelevant(context, intent)))
  {
    Log.w(TAG, "Relevant!");
    int subscriptionId = intent.getExtras().getInt("subscription", -1);

    ApplicationContext.getInstance(context)
                      .getJobManager()
                      .add(new MmsReceiveJob(context, intent.getByteArrayExtra("data"), subscriptionId));

    abortBroadcast();
  }
}
 

private static ContentValues serializeMessage(SmsMessageData messageData) {
    ContentValues values = MapUtils.contentValuesForSize(7);
    values.put(Telephony.Sms.ADDRESS, messageData.getSender());
    values.put(Telephony.Sms.BODY, messageData.getBody());
    values.put(Telephony.Sms.DATE, messageData.getTimeReceived());
    values.put(Telephony.Sms.DATE_SENT, messageData.getTimeSent());
    values.put(Telephony.Sms.READ, messageData.isRead() ? 1 : 0);
    values.put(Telephony.Sms.SEEN, 1); // Always mark messages as seen

    // Also write subscription ID (aka SIM card number) on Android 5.1+
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
        values.put(Telephony.Sms.SUBSCRIPTION_ID, messageData.getSubId());
    }

    return values;
}
 

public static void inviteSMSContact (Activity context, String phoneNumber, String message)
{

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) // At least KitKat
    {
        String defaultSmsPackageName = Telephony.Sms.getDefaultSmsPackage(context); // Need to change the build to API 19

        Intent sendIntent = new Intent(Intent.ACTION_SEND);
        sendIntent.setType("text/plain");
        sendIntent.putExtra(Intent.EXTRA_TEXT, message);

        if (defaultSmsPackageName != null)// Can be null in case that there is no default, then the user would be able to choose
        // any app that support this intent.
        {
            sendIntent.setPackage(defaultSmsPackageName);
        }
        context.startActivity(sendIntent);

    }
    else // For early versions, do what worked for you before.
    {
        Intent smsIntent = new Intent(Intent.ACTION_VIEW);
        smsIntent.setType("vnd.android-dir/mms-sms");

        if (phoneNumber != null)
        smsIntent.putExtra("address",phoneNumber);
        smsIntent.putExtra("sms_body",message);

        context.startActivity(smsIntent);
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {
    final Set<String> packagesSet = new HashSet<>(intent.getStringArrayListExtra("packages"));
    if (!viewsToApps.containsValue(bt_whatsapp))
        bt_whatsapp.setBadgeVisibility(packagesSet.contains(D.WHATSAPP_PACKAGE_NAME));
    if (!viewsToApps.containsValue(bt_recent))
        bt_recent.setBadgeVisibility(!CallLogsHelper.isAllReadSafe(getContext().getContentResolver()));
    if (!viewsToApps.containsValue(bt_messages))
        bt_messages.setBadgeVisibility(packagesSet.contains(Telephony.Sms.getDefaultSmsPackage(context)));
    for (final App app : viewsToApps.keySet()) {
        viewsToApps.get(app).setBadgeVisibility(packagesSet.contains(ComponentName.unflattenFromString(app.getFlattenComponentName()).getPackageName()));
    }

}
 

public static long getOrCreateThreadId(Context context, String recipient) {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    return Telephony.Threads.getOrCreateThreadId(context, recipient);
  } else {
    return getOrCreateThreadIdInternal(context, recipient);
  }
}
 

@TargetApi(Build.VERSION_CODES.KITKAT)
@Override
public void onListen(Object arguments, EventSink events) {
  receiver = createSmsReceiver(events);
  registrar.context().registerReceiver(receiver, new IntentFilter(Telephony.Sms.Intents.SMS_RECEIVED_ACTION));
  sink = events;
  permissions.checkAndRequestPermission(permissionsList, Permissions.RECV_SMS_ID_REQ);
}
 

private void registerObserver() {
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECEIVE_SMS)
            == PackageManager.PERMISSION_GRANTED) {
        if (mSmsObserver == null) {
            mSmsObserver = new SmsObserver(new Handler(Looper.getMainLooper()));
        }
        // register SMS content observer
        getContentResolver().registerContentObserver(Telephony.Sms.CONTENT_URI,
                true, mSmsObserver);
    } else {
        XLog.d("RECEIVE_SMS permission denied");
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {
    if (Build.VERSION.SDK_INT >= 24) {
        if (intent.getAction() != null && intent.getAction().equals(Telephony.Sms.Intents.ACTION_DEFAULT_SMS_PACKAGE_CHANGED)) {
            if (MmsManager.isDefaultSmsApp()){
                weMessage.get().enableSmsMode(true);
            }else {
                weMessage.get().disableSmsMode();
            }
        }
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {
    try {
        if (intent.getAction().equals(Telephony.Sms.Intents.SMS_DELIVER_ACTION)) {
            Bundle bundle = intent.getExtras();

            if (weMessage.get().getCurrentSession().getSmsHandle() == null){
                LocalBroadcastManager.getInstance(weMessage.get()).sendBroadcast(new Intent(weMessage.BROADCAST_NEW_MESSAGE_ERROR));
                return;
            }

            if (bundle != null) {
                Object[] smsExtra = (Object[]) bundle.get("pdus");
                MmsMessage message = weMessage.get().getMmsManager().addSmsMessage(smsExtra);

                if (message == null) throw new NullPointerException("Could not receive message because SMS built from URI was null");

                PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);

                if (!powerManager.isInteractive()) {
                    PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP | PowerManager.ON_AFTER_RELEASE, "WeMessageNotificationWakeLock");
                    wakeLock.acquire(5 * 1000);
                }

                weMessage.get().getMessageManager().setHasUnreadMessages(message.getChat(), true, false);
                weMessage.get().getNotificationManager().showMmsNotification(message);
            }
        }
    }catch (Exception ex){
        AppLogger.error("An error occurred while receiving an SMS message", ex);
        LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent(weMessage.BROADCAST_NEW_MESSAGE_ERROR));
    }
}
 

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == SMS_CHOSEN_ACTIVITY_RESULT){
        if (weMessage.get().getPackageName().equals(Telephony.Sms.getDefaultSmsPackage(weMessage.get()))){
            new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    setDefaultSmsApp(true);
                }
            }, 250L);
        }else {
            DialogDisplayer.generateAlertDialog(getString(R.string.permissions_error_title), getString(R.string.set_default_sms_not_chosen)).show(getSupportFragmentManager(), "SmsAppNotChosenAlert");
        }
    }
}
 

@Override
public void onReceive(Context context, Intent intent) {
  if (intent.getAction().equals(Telephony.Sms.Intents.SMS_RECEIVED_ACTION )) {
    String queryString = getString(R.string.querystring).toLowerCase();
    Bundle bundle = intent.getExtras();

    if (bundle != null) {
      SmsMessage[] messages = getMessagesFromIntent(intent);
      for (SmsMessage message : messages) {
        if (message.getMessageBody().toLowerCase().contains(queryString))
          requestReceived(message.getOriginatingAddress());
      }
    }
  }
}
 

@Override
public void onResume() {
  super.onResume();
  IntentFilter filter = new IntentFilter(Telephony.Sms.Intents.SMS_RECEIVED_ACTION);
  registerReceiver(emergencyResponseRequestReceiver, filter);

  IntentFilter attemptedDeliveryFilter = new IntentFilter(SENT_SMS);
  registerReceiver(attemptedSendReceiver, attemptedDeliveryFilter);
}
 

public void setDefaultSms(String packageName)
{

       Intent intent = new Intent(Telephony.Sms.Intents.ACTION_CHANGE_DEFAULT);
       intent.putExtra(Telephony.Sms.Intents.EXTRA_PACKAGE_NAME, packageName);
       startActivity(intent);

   }
 

@Override
public void onChange(boolean selfChange) {
    super.onChange(selfChange);
            Cursor cursor = getContentResolver().query(Uri.parse(SMS_INBOX_URI), PROJECTION,
            Telephony.Sms.READ + "=?", new String[]{"0"}, Telephony.Sms.Inbox.DEFAULT_SORT_ORDER);
    getSmsCodeFromObserver(cursor);
}
 

@TargetApi(19)
public static boolean isDefault(Context context) {
    if (!isAvailable()) return true;
    String myPackage = context.getPackageName();
    String smsPackage = Telephony.Sms.getDefaultSmsPackage(context);
    return (smsPackage != null && smsPackage.equals(myPackage));
}