这是一个非常简单的示例，演示了可用于所有SmsManager#send*()方法的send和delivery PendingIntent的使用，并将数据附加到这些方法以轻松区分Receiver中的结果。
附加这些数据就像在Intent上放置额外的东西来支持我们传递给send*()方法的PendingIntent一样简单。问题是PendingIntent可能不会像预期的那样工作。系统将仅在其必须时创建新的。如果Intent与Intent#filterEquals()方法不同、请求代码当前未用于相等的Intent或传递了适当的标志，则get*()方法将仅返回不同的PendingIntent。
在具有相同请求代码的相同Intent上的不同extra * 不会 * 导致创建新的PendingIntent。根据在这种情况下传递的标志，这些extra可能会被忽略，或者覆盖当前活动PendingIntent中的extra，这可能会导致不正确的结果。
在我们的示例中，我们基本上为每次发送使用相同的Intent，因此我们将通过传递唯一的请求代码来确保每次发送都使用不同的PendingIntent。这个简单的示例为这些代码使用收缩列表的大小，该大小在单次运行的上下文中是唯一的。请求代码最终可以是任意的int。只要你知道在你要求的时候它还没有被使用。
如果我们在不久的将来再次需要这些PendingIntent，系统将需要缓存它们，因此我们还将传递FLAG_ONE_SHOT以在使用后"清除它们"，并确保在后续运行中获得正确的当前额外内容。

public class SmsActivity extends Activity implements View.OnClickListener {
    private static final String SMS_SENT_ACTION = "com.mycompany.myapp.SMS_SENT";
    private static final String SMS_DELIVERED_ACTION = "com.mycompany.myapp.SMS_DELIVERED";
    private static final String EXTRA_NUMBER = "number";
    private static final String EXTRA_MESSAGE = "message";

    // Initialize our sample numbers list.
    private final List<String> numberList = new ArrayList<String>() {{
                add("111-111-1111");
                add("222-222-2222");
                add("333-333-3333");
    }};

    // Initialize our sample message list.
    private final List<String> messageList = new ArrayList<String>() {{
                add("Hello.");
                add("Howdy.");
                add("Hi.");
    }};

    private SmsManager smsManager;
    private IntentFilter intentFilter;
    private BroadcastReceiver resultsReceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_sms);

        findViewById(R.id.button_send).setOnClickListener(this);

        smsManager = SmsManager.getDefault();
        resultsReceiver = new SmsResultReceiver();

        intentFilter = new IntentFilter(SMS_SENT_ACTION);
        intentFilter.addAction(SMS_DELIVERED_ACTION);
    }

    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver(resultsReceiver, intentFilter);
    }

    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(resultsReceiver);
    }

    public void onClick(View v) {
        v.setEnabled(false);
        sendNextMessage();
    }

    private void sendNextMessage() {
        // We're going to remove numbers and messages from
        // the lists as we send, so if the lists are empty, we're done.
        if (numberList.size() == 0) {
            return;
        }

        // The list size is a sufficiently unique request code,
        // for the PendingIntent since it decrements for each send.
        int requestCode = numberList.size();

        String number = numberList.get(0);
        String message = messageList.get(0);

        // The Intents must be implicit for this example,
        // as we're registering our Receiver dynamically.
        Intent sentIntent = new Intent(SMS_SENT_ACTION);
        Intent deliveredIntent = new Intent(SMS_DELIVERED_ACTION);

        // We attach the recipient's number and message to
        // the Intents for easy retrieval in the Receiver.
        sentIntent.putExtra(EXTRA_NUMBER, number);
        sentIntent.putExtra(EXTRA_MESSAGE, message);
        deliveredIntent.putExtra(EXTRA_NUMBER, number);
        deliveredIntent.putExtra(EXTRA_MESSAGE, message);

        // Construct the PendingIntents for the results.
        // FLAG_ONE_SHOT cancels the PendingIntent after use so we
        // can safely reuse the request codes in subsequent runs.
        PendingIntent sentPI = PendingIntent.getBroadcast(this,
                                                          requestCode,
                                                          sentIntent,
                                                          PendingIntent.FLAG_ONE_SHOT);
        
        PendingIntent deliveredPI = PendingIntent.getBroadcast(this,
                                                               requestCode,
                                                               deliveredIntent,
                                                               PendingIntent.FLAG_ONE_SHOT);

        // Send our message.
        smsManager.sendTextMessage(number, null, message, sentPI, deliveredPI);

        // Remove the number and message we just sent to from the lists.
        numberList.remove(0);
        messageList.remove(0);
    }

    private class SmsResultReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            // A simple result Toast text.
            String result = null;

            // Get the result action.
            String action = intent.getAction();

            // Retrieve the recipient's number and message.
            String number = intent.getStringExtra(EXTRA_NUMBER);
            String message = intent.getStringExtra(EXTRA_MESSAGE);

            // This is the result for a send.
            if (SMS_SENT_ACTION.equals(action)) {
                int resultCode = getResultCode();
                result = "Send result : " + translateSentResult(resultCode);

                // The current send is complete. Send the next one.
                sendNextMessage();
            }
            // This is the result for a delivery.
            else if (SMS_DELIVERED_ACTION.equals(action)) {
                SmsMessage sms = null;

                // A delivery result comes from the service
                // center as a simple SMS in a single PDU.
                byte[] pdu = intent.getByteArrayExtra("pdu");
                String format = intent.getStringExtra("format");

                // Construct the SmsMessage from the PDU.
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && format != null) {
                    sms = SmsMessage.createFromPdu(pdu, format);
                }
                else {
                    sms = SmsMessage.createFromPdu(pdu);
                }

                // getResultCode() is not reliable for delivery results.
                // We need to get the status from the SmsMessage.
                result = "Delivery result : " + translateDeliveryStatus(sms.getStatus());
            }

            result = number + ", " + message + "\n" + result;
            Toast.makeText(context, result, Toast.LENGTH_SHORT).show();
        }

        String translateSentResult(int resultCode) {
            switch (resultCode) {
                case Activity.RESULT_OK:
                    return "Activity.RESULT_OK";
                case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
                    return "SmsManager.RESULT_ERROR_GENERIC_FAILURE";
                case SmsManager.RESULT_ERROR_RADIO_OFF:
                    return "SmsManager.RESULT_ERROR_RADIO_OFF";
                case SmsManager.RESULT_ERROR_NULL_PDU:
                    return "SmsManager.RESULT_ERROR_NULL_PDU";
                case SmsManager.RESULT_ERROR_NO_SERVICE:
                    return "SmsManager.RESULT_ERROR_NO_SERVICE";
                default:
                    return "Unknown error code";
            }
        }

        String translateDeliveryStatus(int status) {
            switch (status) {
                case Telephony.Sms.STATUS_COMPLETE:
                    return "Sms.STATUS_COMPLETE";
                case Telephony.Sms.STATUS_FAILED:
                    return "Sms.STATUS_FAILED";
                case Telephony.Sms.STATUS_PENDING:
                    return "Sms.STATUS_PENDING";
                case Telephony.Sms.STATUS_NONE:
                    return "Sms.STATUS_NONE";
                default:
                    return "Unknown status code";
            }
        }
    }
}

• translateSentResult()方法修改自AOSP旧的默认SMS应用程序中的类似方法。许可证为the Apache License, Version 2.0。*

注：

• 请务必注意我们用于获取交付状态的方法。接收方中的结果代码不是可靠的指示器。我们必须检查从Intent上的PDU extra获取的SmsMessage的getStatus()返回，以获取实际结果。
• 还要注意，并非所有承运人都提供交货结果，在这种情况下，交货PendingIntent s将永远不会触发。不要依赖交货结果。
• 这个例子使用了一个"正确"的方法，尽管很简单，但是它可以连续发送多条消息，因为它会等到当前发送完成后再继续下一条。对于短列表，您可以使用一个循环，在执行时立即触发所有发送，但是如果系统跟不上，这可能会导致一般性的失败。
• 如前所述，这是一个非常简单的示例。它并不真正适合生产，因为动态注册的接收器与Activity的生命周期绑定在一起。理想情况下，您希望实现一个静态接收器类，在清单中注册，并使用显式Intent将其作为目标。还建议使用Service来处理结果。并且那些结果可以通过任何数量的机制被递送到UI;例如LocalBroadcastManager、另一事件总线实现、IntentS、NotificationS等。