1/*
2** Copyright 2007, 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
17package com.android.internal.telephony;
18
19import android.app.PendingIntent;
20import android.net.Uri;
21import com.android.internal.telephony.SmsRawData;
22
23/** Interface for applications to access the ICC phone book.
24 *
25 * <p>The following code snippet demonstrates a static method to
26 * retrieve the ISms interface from Android:</p>
27 * <pre>private static ISms getSmsInterface()
28            throws DeadObjectException {
29    IServiceManager sm = ServiceManagerNative.getDefault();
30    ISms ss;
31    ss = ISms.Stub.asInterface(sm.getService("isms"));
32    return ss;
33}
34 * </pre>
35 */
36
37interface ISms {
38    /**
39     * Retrieves all messages currently stored on ICC.
40     * @param subId the subId id.
41     * @return list of SmsRawData of all sms on ICC
42     */
43    List<SmsRawData> getAllMessagesFromIccEfForSubscriber(in int subId, String callingPkg);
44
45    /**
46     * Update the specified message on the ICC.
47     *
48     * @param messageIndex record index of message to update
49     * @param newStatus new message status (STATUS_ON_ICC_READ,
50     *                  STATUS_ON_ICC_UNREAD, STATUS_ON_ICC_SENT,
51     *                  STATUS_ON_ICC_UNSENT, STATUS_ON_ICC_FREE)
52     * @param pdu the raw PDU to store
53     * @param subId the subId id.
54     * @return success or not
55     *
56     */
57     boolean updateMessageOnIccEfForSubscriber(in int subId, String callingPkg,
58             int messageIndex, int newStatus, in byte[] pdu);
59
60    /**
61     * Copy a raw SMS PDU to the ICC.
62     *
63     * @param pdu the raw PDU to store
64     * @param status message status (STATUS_ON_ICC_READ, STATUS_ON_ICC_UNREAD,
65     *               STATUS_ON_ICC_SENT, STATUS_ON_ICC_UNSENT)
66     * @param subId the subId id.
67     * @return success or not
68     *
69     */
70    boolean copyMessageToIccEfForSubscriber(in int subId, String callingPkg, int status,
71            in byte[] pdu, in byte[] smsc);
72
73    /**
74     * Send a data SMS.
75     *
76     * @param smsc the SMSC to send the message through, or NULL for the
77     *  default SMSC
78     * @param data the body of the message to send
79     * @param sentIntent if not NULL this <code>PendingIntent</code> is
80     *  broadcast when the message is sucessfully sent, or failed.
81     *  The result code will be <code>Activity.RESULT_OK<code> for success,
82     *  or one of these errors:<br>
83     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
84     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
85     *  <code>RESULT_ERROR_NULL_PDU</code><br>
86     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
87     *  the extra "errorCode" containing a radio technology specific value,
88     *  generally only useful for troubleshooting.<br>
89     *  The per-application based SMS control checks sentIntent. If sentIntent
90     *  is NULL the caller will be checked against all unknown applicaitons,
91     *  which cause smaller number of SMS to be sent in checking period.
92     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
93     *  broadcast when the message is delivered to the recipient.  The
94     *  raw pdu of the status report is in the extended data ("pdu").
95     * @param subId the subId id.
96     */
97    void sendDataForSubscriber(int subId, String callingPkg, in String destAddr,
98            in String scAddr, in int destPort, in byte[] data, in PendingIntent sentIntent,
99            in PendingIntent deliveryIntent);
100
101    /**
102     * Send a data SMS. Only for use internally.
103     *
104     * @param smsc the SMSC to send the message through, or NULL for the
105     *  default SMSC
106     * @param data the body of the message to send
107     * @param sentIntent if not NULL this <code>PendingIntent</code> is
108     *  broadcast when the message is sucessfully sent, or failed.
109     *  The result code will be <code>Activity.RESULT_OK<code> for success,
110     *  or one of these errors:<br>
111     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
112     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
113     *  <code>RESULT_ERROR_NULL_PDU</code><br>
114     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
115     *  the extra "errorCode" containing a radio technology specific value,
116     *  generally only useful for troubleshooting.<br>
117     *  The per-application based SMS control checks sentIntent. If sentIntent
118     *  is NULL the caller will be checked against all unknown applicaitons,
119     *  which cause smaller number of SMS to be sent in checking period.
120     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
121     *  broadcast when the message is delivered to the recipient.  The
122     *  raw pdu of the status report is in the extended data ("pdu").
123     * @param subId the subId id.
124     */
125    void sendDataForSubscriberWithSelfPermissions(int subId, String callingPkg, in String destAddr,
126            in String scAddr, in int destPort, in byte[] data, in PendingIntent sentIntent,
127            in PendingIntent deliveryIntent);
128
129    /**
130     * Send an SMS.
131     *
132     * @param smsc the SMSC to send the message through, or NULL for the
133     *  default SMSC
134     * @param text the body of the message to send
135     * @param sentIntent if not NULL this <code>PendingIntent</code> is
136     *  broadcast when the message is sucessfully sent, or failed.
137     *  The result code will be <code>Activity.RESULT_OK<code> for success,
138     *  or one of these errors:<br>
139     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
140     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
141     *  <code>RESULT_ERROR_NULL_PDU</code><br>
142     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
143     *  the extra "errorCode" containing a radio technology specific value,
144     *  generally only useful for troubleshooting.<br>
145     *  The per-application based SMS control checks sentIntent. If sentIntent
146     *  is NULL the caller will be checked against all unknown applications,
147     *  which cause smaller number of SMS to be sent in checking period.
148     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
149     *  broadcast when the message is delivered to the recipient.  The
150     *  raw pdu of the status report is in the extended data ("pdu").
151     * @param subId the subId on which the SMS has to be sent.
152     * @param persistMessageForNonDefaultSmsApp whether the sent message should
153     *   be automatically persisted in the SMS db. It only affects messages sent
154     *   by a non-default SMS app. Currently only the carrier app can set this
155     *   parameter to false to skip auto message persistence.
156     */
157    void sendTextForSubscriber(in int subId, String callingPkg, in String destAddr,
158            in String scAddr, in String text, in PendingIntent sentIntent,
159            in PendingIntent deliveryIntent, in boolean persistMessageForNonDefaultSmsApp);
160
161    /**
162     * Send an SMS. Internal use only.
163     *
164     * @param smsc the SMSC to send the message through, or NULL for the
165     *  default SMSC
166     * @param text the body of the message to send
167     * @param sentIntent if not NULL this <code>PendingIntent</code> is
168     *  broadcast when the message is sucessfully sent, or failed.
169     *  The result code will be <code>Activity.RESULT_OK<code> for success,
170     *  or one of these errors:<br>
171     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
172     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
173     *  <code>RESULT_ERROR_NULL_PDU</code><br>
174     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
175     *  the extra "errorCode" containing a radio technology specific value,
176     *  generally only useful for troubleshooting.<br>
177     *  The per-application based SMS control checks sentIntent. If sentIntent
178     *  is NULL the caller will be checked against all unknown applications,
179     *  which cause smaller number of SMS to be sent in checking period.
180     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
181     *  broadcast when the message is delivered to the recipient.  The
182     *  raw pdu of the status report is in the extended data ("pdu").
183     * @param subId the subId on which the SMS has to be sent.
184     */
185    void sendTextForSubscriberWithSelfPermissions(in int subId, String callingPkg,
186            in String destAddr, in String scAddr, in String text, in PendingIntent sentIntent,
187            in PendingIntent deliveryIntent, in boolean persistMessage);
188
189    /**
190     * Send an SMS with options using Subscription Id.
191     *
192     * @param subId the subId on which the SMS has to be sent.
193     * @param destAddr the address to send the message to
194     * @param scAddr the SMSC to send the message through, or NULL for the
195     *  default SMSC
196     * @param text the body of the message to send
197     * @param sentIntent if not NULL this <code>PendingIntent</code> is
198     *  broadcast when the message is sucessfully sent, or failed.
199     *  The result code will be <code>Activity.RESULT_OK<code> for success,
200     *  or one of these errors:<br>
201     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
202     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
203     *  <code>RESULT_ERROR_NULL_PDU</code><br>
204     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
205     *  the extra "errorCode" containing a radio technology specific value,
206     *  generally only useful for troubleshooting.<br>
207     *  The per-application based SMS control checks sentIntent. If sentIntent
208     *  is NULL the caller will be checked against all unknown applications,
209     *  which cause smaller number of SMS to be sent in checking period.
210     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
211     *  broadcast when the message is delivered to the recipient.  The
212     *  raw pdu of the status report is in the extended data ("pdu").
213     * @param persistMessageForNonDefaultSmsApp whether the sent message should
214     *   be automatically persisted in the SMS db. It only affects messages sent
215     *   by a non-default SMS app. Currently only the carrier app can set this
216     *   parameter to false to skip auto message persistence.
217     * @param priority Priority level of the message
218     *  Refer specification See 3GPP2 C.S0015-B, v2.0, table 4.5.9-1
219     *  ---------------------------------
220     *  PRIORITY      | Level of Priority
221     *  ---------------------------------
222     *      '00'      |     Normal
223     *      '01'      |     Interactive
224     *      '10'      |     Urgent
225     *      '11'      |     Emergency
226     *  ----------------------------------
227     *  Any Other values included Negative considered as Invalid Priority Indicator of the message.
228     * @param expectMore is a boolean to indicate the sending message is multi segmented or not.
229     * @param validityPeriod Validity Period of the message in mins.
230     *  Refer specification 3GPP TS 23.040 V6.8.1 section 9.2.3.12.1.
231     *  Validity Period(Minimum) -> 5 mins
232     *  Validity Period(Maximum) -> 635040 mins(i.e.63 weeks).
233     *  Any Other values included Negative considered as Invalid Validity Period of the message.
234     */
235    void sendTextForSubscriberWithOptions(in int subId, String callingPkg, in String destAddr,
236            in String scAddr, in String text, in PendingIntent sentIntent,
237            in PendingIntent deliveryIntent, in boolean persistMessageForNonDefaultSmsApp,
238            in int priority, in boolean expectMore, in int validityPeriod);
239
240    /**
241     * Inject an SMS PDU into the android platform.
242     *
243     * @param subId the subId on which the SMS has to be injected.
244     * @param pdu is the byte array of pdu to be injected into android application framework
245     * @param format is the format of SMS pdu (android.telephony.SmsMessage.FORMAT_3GPP or
246     * android.telephony.SmsMessage.FORMAT_3GPP2)
247     * @param receivedIntent if not NULL this <code>PendingIntent</code> is
248     *  broadcast when the message is successfully received by the
249     *  android application framework. This intent is broadcasted at
250     *  the same time an SMS received from radio is acknowledged back.
251     */
252    void injectSmsPduForSubscriber(
253            int subId, in byte[] pdu, String format, in PendingIntent receivedIntent);
254
255    /**
256     * Send a multi-part text based SMS.
257     *
258     * @param destinationAddress the address to send the message to
259     * @param scAddress is the service center address or null to use
260     *   the current default SMSC
261     * @param parts an <code>ArrayList</code> of strings that, in order,
262     *   comprise the original message
263     * @param sentIntents if not null, an <code>ArrayList</code> of
264     *   <code>PendingIntent</code>s (one for each message part) that is
265     *   broadcast when the corresponding message part has been sent.
266     *   The result code will be <code>Activity.RESULT_OK<code> for success,
267     *   or one of these errors:
268     *   <code>RESULT_ERROR_GENERIC_FAILURE</code>
269     *   <code>RESULT_ERROR_RADIO_OFF</code>
270     *   <code>RESULT_ERROR_NULL_PDU</code>.
271     * @param deliveryIntents if not null, an <code>ArrayList</code> of
272     *   <code>PendingIntent</code>s (one for each message part) that is
273     *   broadcast when the corresponding message part has been delivered
274     *   to the recipient.  The raw pdu of the status report is in the
275     *   extended data ("pdu").
276     * @param subId the subId on which the SMS has to be sent.
277     * @param persistMessageForNonDefaultSmsApp whether the sent message should
278     *   be automatically persisted in the SMS db. It only affects messages sent
279     *   by a non-default SMS app. Currently only the carrier app can set this
280     *   parameter to false to skip auto message persistence.
281     */
282    void sendMultipartTextForSubscriber(in int subId, String callingPkg,
283            in String destinationAddress, in String scAddress,
284            in List<String> parts, in List<PendingIntent> sentIntents,
285            in List<PendingIntent> deliveryIntents, in boolean persistMessageForNonDefaultSmsApp);
286
287    /**
288     * Send a multi-part text based SMS with options using Subscription Id.
289     *
290     * @param subId the subId on which the SMS has to be sent.
291     * @param destinationAddress the address to send the message to
292     * @param scAddress is the service center address or null to use
293     *   the current default SMSC
294     * @param parts an <code>ArrayList</code> of strings that, in order,
295     *   comprise the original message
296     * @param sentIntents if not null, an <code>ArrayList</code> of
297     *   <code>PendingIntent</code>s (one for each message part) that is
298     *   broadcast when the corresponding message part has been sent.
299     *   The result code will be <code>Activity.RESULT_OK<code> for success,
300     *   or one of these errors:
301     *   <code>RESULT_ERROR_GENERIC_FAILURE</code>
302     *   <code>RESULT_ERROR_RADIO_OFF</code>
303     *   <code>RESULT_ERROR_NULL_PDU</code>.
304     * @param deliveryIntents if not null, an <code>ArrayList</code> of
305     *   <code>PendingIntent</code>s (one for each message part) that is
306     *   broadcast when the corresponding message part has been delivered
307     *   to the recipient.  The raw pdu of the status report is in the
308     *   extended data ("pdu").
309     * @param persistMessageForNonDefaultSmsApp whether the sent message should
310     *   be automatically persisted in the SMS db. It only affects messages sent
311     *   by a non-default SMS app. Currently only the carrier app can set this
312     *   parameter to false to skip auto message persistence.
313     * @param priority Priority level of the message
314     *  Refer specification See 3GPP2 C.S0015-B, v2.0, table 4.5.9-1
315     *  ---------------------------------
316     *  PRIORITY      | Level of Priority
317     *  ---------------------------------
318     *      '00'      |     Normal
319     *      '01'      |     Interactive
320     *      '10'      |     Urgent
321     *      '11'      |     Emergency
322     *  ----------------------------------
323     *  Any Other values included Negative considered as Invalid Priority Indicator of the message.
324     * @param expectMore is a boolean to indicate the sending message is multi segmented or not.
325     * @param validityPeriod Validity Period of the message in mins.
326     *  Refer specification 3GPP TS 23.040 V6.8.1 section 9.2.3.12.1.
327     *  Validity Period(Minimum) -> 5 mins
328     *  Validity Period(Maximum) -> 635040 mins(i.e.63 weeks).
329     *  Any Other values included Negative considered as Invalid Validity Period of the message.
330     */
331    void sendMultipartTextForSubscriberWithOptions(in int subId, String callingPkg,
332            in String destinationAddress, in String scAddress, in List<String> parts,
333            in List<PendingIntent> sentIntents, in List<PendingIntent> deliveryIntents,
334            in boolean persistMessageForNonDefaultSmsApp, in int priority, in boolean expectMore,
335            in int validityPeriod);
336
337    /**
338     * Enable reception of cell broadcast (SMS-CB) messages with the given
339     * message identifier and RAN type. The RAN type specify this message ID
340     * belong to 3GPP (GSM) or 3GPP2(CDMA). Note that if two different clients
341     * enable the same message identifier, they must both disable it for the
342     * device to stop receiving those messages.
343     *
344     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP) or
345     *   C.R1001-G (3GPP2)
346     * @param subId for which the broadcast has to be enabled
347     * @param ranType as defined in class SmsManager, the value can be one of these:
348     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_GSM
349     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_CDMA
350     * @return true if successful, false otherwise
351     *
352     * @see #disableCellBroadcastForSubscriber(int, int, int)
353     */
354    boolean enableCellBroadcastForSubscriber(int subId, int messageIdentifier, int ranType);
355
356    /**
357     * Disable reception of cell broadcast (SMS-CB) messages with the given
358     * message identifier and RAN type. The RAN type specify this message ID
359     * belong to 3GPP (GSM) or 3GPP2(CDMA). Note that if two different clients
360     * enable the same message identifier, they must both disable it for the
361     * device to stop receiving those messages.
362     *
363     * @param messageIdentifier Message identifier as specified in TS 23.041 (3GPP) or
364     *   C.R1001-G (3GPP2)
365     * @param subId for which the broadcast has to be disabled
366     * @param ranType as defined in class SmsManager, the value can be one of these:
367     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_GSM
368     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_CDMA
369     * @return true if successful, false otherwise
370     *
371     * @see #enableCellBroadcastForSubscriber(int, int, int)
372     */
373    boolean disableCellBroadcastForSubscriber(int subId, int messageIdentifier, int ranType);
374
375    /*
376     * Enable reception of cell broadcast (SMS-CB) messages with the given
377     * message identifier range and RAN type. The RAN type specify this message ID range
378     * belong to 3GPP (GSM) or 3GPP2(CDMA). Note that if two different clients enable
379     * a message identifier range, they must both disable it for the device
380     * to stop receiving those messages.
381     *
382     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP) or
383     *   C.R1001-G (3GPP2)
384     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP) or
385     *   C.R1001-G (3GPP2)
386     * @param subId for which the broadcast has to be enabled
387     * @param ranType as defined in class SmsManager, the value can be one of these:
388     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_GSM
389     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_CDMA
390     * @return true if successful, false otherwise
391     *
392     * @see #disableCellBroadcastRangeForSubscriber(int, int, int, int)
393     */
394    boolean enableCellBroadcastRangeForSubscriber(int subId, int startMessageId, int endMessageId,
395            int ranType);
396
397    /**
398     * Disable reception of cell broadcast (SMS-CB) messages with the given
399     * message identifier range and RAN type. The RAN type specify this message ID range
400     * belong to 3GPP (GSM) or 3GPP2(CDMA). Note that if two different clients enable
401     * a message identifier range, they must both disable it for the device
402     * to stop receiving those messages.
403     *
404     * @param startMessageId first message identifier as specified in TS 23.041 (3GPP) or
405     *   C.R1001-G (3GPP2)
406     * @param endMessageId last message identifier as specified in TS 23.041 (3GPP) or
407     *   C.R1001-G (3GPP2)
408     * @param subId for which the broadcast has to be disabled
409     * @param ranType as defined in class SmsManager, the value can be one of these:
410     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_GSM
411     *    android.telephony.SmsMessage.CELL_BROADCAST_RAN_TYPE_CDMA
412     * @return true if successful, false otherwise
413     *
414     * @see #enableCellBroadcastRangeForSubscriber(int, int, int, int)
415     */
416    boolean disableCellBroadcastRangeForSubscriber(int subId, int startMessageId,
417            int endMessageId, int ranType);
418
419    /**
420     * Returns the premium SMS send permission for the specified package.
421     * Requires system permission.
422     */
423    int getPremiumSmsPermission(String packageName);
424
425    /**
426     * Returns the premium SMS send permission for the specified package.
427     * Requires system permission.
428     */
429    int getPremiumSmsPermissionForSubscriber(int subId, String packageName);
430
431    /**
432     * Set the SMS send permission for the specified package.
433     * Requires system permission.
434     */
435    void setPremiumSmsPermission(String packageName, int permission);
436
437     /**
438     * Set the SMS send permission for the specified package.
439     * Requires system permission.
440     */
441    void setPremiumSmsPermissionForSubscriber(int subId, String packageName, int permission);
442
443    /**
444     * SMS over IMS is supported if IMS is registered and SMS is supported
445     * on IMS.
446     * @param subId for subId which isImsSmsSupported is queried
447     * @return true if SMS over IMS is supported, false otherwise
448     *
449     * @see #getImsSmsFormatForSubscriber(int)
450     */
451    boolean isImsSmsSupportedForSubscriber(int subId);
452
453    /**
454     * User needs to pick SIM for SMS if multiple SIMs present and if current subId passed in is not
455     * active/valid.
456     * @param subId current subId for sending SMS
457     * @return true if SIM for SMS sending needs to be chosen
458     */
459    boolean isSmsSimPickActivityNeeded(int subId);
460
461    /*
462     * get user prefered SMS subId
463     * @return subId id
464     */
465    int getPreferredSmsSubscription();
466
467    /**
468     * Gets SMS format supported on IMS.  SMS over IMS format is
469     * either 3GPP or 3GPP2.
470     * @param subId for subId which getImsSmsFormat is queried
471     * @return android.telephony.SmsMessage.FORMAT_3GPP,
472     *         android.telephony.SmsMessage.FORMAT_3GPP2
473     *      or android.telephony.SmsMessage.FORMAT_UNKNOWN
474     *
475     * @see #isImsSmsSupportedForSubscriber(int)
476     */
477    String getImsSmsFormatForSubscriber(int subId);
478
479    /*
480     * Get SMS prompt property,  enabled or not
481     * @return true if enabled, false otherwise
482     */
483    boolean isSMSPromptEnabled();
484
485    /**
486     * Send a system stored text message.
487     *
488     * This is used for sending a previously sent, but failed-to-send, message or
489     * for sending a text message that has been stored as a draft.
490     *
491     * @param subId the SIM id.
492     * @param callingPkg the package name of the calling app
493     * @param messageUri the URI of the stored message
494     * @param scAddress is the service center address or null to use the current default SMSC
495     * @param sentIntent if not NULL this <code>PendingIntent</code> is
496     *  broadcast when the message is successfully sent, or failed.
497     *  The result code will be <code>Activity.RESULT_OK</code> for success,
498     *  or one of these errors:<br>
499     *  <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
500     *  <code>RESULT_ERROR_RADIO_OFF</code><br>
501     *  <code>RESULT_ERROR_NULL_PDU</code><br>
502     *  For <code>RESULT_ERROR_GENERIC_FAILURE</code> the sentIntent may include
503     *  the extra "errorCode" containing a radio technology specific value,
504     *  generally only useful for troubleshooting.<br>
505     *  The per-application based SMS control checks sentIntent. If sentIntent
506     *  is NULL the caller will be checked against all unknown applications,
507     *  which cause smaller number of SMS to be sent in checking period.
508     * @param deliveryIntent if not NULL this <code>PendingIntent</code> is
509     *  broadcast when the message is delivered to the recipient.  The
510     *  raw pdu of the status report is in the extended data ("pdu").
511     */
512    void sendStoredText(int subId, String callingPkg, in Uri messageUri, String scAddress,
513            in PendingIntent sentIntent, in PendingIntent deliveryIntent);
514
515    /**
516     * Send a system stored multi-part text message.
517     *
518     * This is used for sending a previously sent, but failed-to-send, message or
519     * for sending a text message that has been stored as a draft.
520     * The provided <code>PendingIntent</code> lists should match the part number of the
521     * divided text of the stored message by using <code>divideMessage</code>
522     *
523     * @param subId the SIM id.
524     * @param callingPkg the package name of the calling app
525     * @param messageUri the URI of the stored message
526     * @param scAddress is the service center address or null to use
527     *   the current default SMSC
528     * @param sentIntents if not null, an <code>ArrayList</code> of
529     *   <code>PendingIntent</code>s (one for each message part) that is
530     *   broadcast when the corresponding message part has been sent.
531     *   The result code will be <code>Activity.RESULT_OK</code> for success,
532     *   or one of these errors:<br>
533     *   <code>RESULT_ERROR_GENERIC_FAILURE</code><br>
534     *   <code>RESULT_ERROR_RADIO_OFF</code><br>
535     *   <code>RESULT_ERROR_NULL_PDU</code><br>
536     *   For <code>RESULT_ERROR_GENERIC_FAILURE</code> each sentIntent may include
537     *   the extra "errorCode" containing a radio technology specific value,
538     *   generally only useful for troubleshooting.<br>
539     *   The per-application based SMS control checks sentIntent. If sentIntent
540     *   is NULL the caller will be checked against all unknown applications,
541     *   which cause smaller number of SMS to be sent in checking period.
542     * @param deliveryIntents if not null, an <code>ArrayList</code> of
543     *   <code>PendingIntent</code>s (one for each message part) that is
544     *   broadcast when the corresponding message part has been delivered
545     *   to the recipient.  The raw pdu of the status report is in the
546     *   extended data ("pdu").
547     */
548    void sendStoredMultipartText(int subId, String callingPkg, in Uri messageUri,
549                String scAddress, in List<PendingIntent> sentIntents,
550                in List<PendingIntent> deliveryIntents);
551
552    /**
553     * Create an app-only incoming SMS request for the calling package.
554     *
555     * If an incoming text contains the token returned by this method the provided
556     * <code>PendingIntent</code> will be sent containing the SMS data.
557     *
558     * @param subId the SIM id.
559     * @param callingPkg the package name of the calling app.
560     * @param intent PendingIntent to be sent when an SMS is received containing the token.
561     */
562    String createAppSpecificSmsToken(int subId, String callingPkg, in PendingIntent intent);
563}
564