Develop Reference

Trying to ID the SMS delivery confirmation

I am currently trying to get the confirmation for each sended SMS. I need to be sure that my SMS are send, so I used a BroadCastReceived to get the information :
Intent sentIntent = new Intent(SMS_SEND);
sentIntent.putExtra("key", idSms);
PendingIntent sentPI = PendingIntent.getBroadcast(getApplicationContext(), 0, sentIntent, PendingIntent.FLAG_UPDATE_CURRENT);
SmsManager manager = SmsManager.getDefault();
try{
manager.sendTextMessage(exp, null, sms, sentPI, null);
put("sending " + sms); //Just a method to print in a textview use has a console
} catch (IllegalArgumentException e){
put("Exception " + e.getMessage());
}
and use a broadcast receiver like this
public void onReceive(Context context, Intent intent){
String idsms = intent.getExtras().getString("key");
switch (getResultCode()) {
case Activity.RESULT_OK:
put("ACK : #" + idsms);
break;
case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
case SmsManager.RESULT_ERROR_RADIO_OFF:
case SmsManager.RESULT_ERROR_NULL_PDU:
case SmsManager.RESULT_ERROR_NO_SERVICE:
put("BOOM " + getResultCode() + "\n\tfrom sms #" + idsms);
break;
}
}
This work like a charm until I try to send multiple messages at the same time, the extra receive is always from the last SMS send, so I can't ID which text are send and which are not.
Here is a simple example of what will happen.
When I use a loop to send 3sms:
id : 1, message : SMS 1
id : 2, message : SMS 2
id : 3, message : SMS 3
And the received will get:
ACK : #3
ACK : #3
ACK : #3
I understand that this come from the PendingIntent.FLAG_UPDATE_CURRENT but I can't find a solution. Anyone can explain to me how I should use the PendingIntent.getBroadcast(..) to be able to manage this or at least to put me on the right track.

Your problem is due the fact that PendingIntents can be reused by the system, if certain things about the requests are not different. In your code, you're passing FLAG_UPDATE_CURRENT, which is causing the stored Intent and its extras to be updated each time a PendingIntent is requested. This is why you're getting id : 3 for each of the messages. To correct this, you can call getBroadcast() with a unique request code (the second parameter) each time, which will create a new PendingIntent for each request, each with a separate Intent with their own extras.
In your case, the fix should be simple, assuming that idSms is unique for each message.
PendingIntent sentPI = PendingIntent.getBroadcast(getApplicationContext(),
Integer.parseInt(idSms),
sentIntent,
PendingIntent.FLAG_UPDATE_CURRENT);

Send SMS leads to Generic Failure

I am sending SMS through my application using a very common way that is explained in pretty much all tutorials. I use sendMultipartTextMessage with "sent Intents" and "delivery Intents", then a Broadcast receiver listen for the results and print things.
But, everytime I try to send a SMS, even with something like 10 characters, I always get a "Generic failure".
My default SMS app is working perfectly and I can send/receive SMS/MMS without any troubles so it can't be a network issue. I don't want my app to become my new default SMS app, I just want it to be able to send a short SMS sometimes.
I tried a lot of things but everything has failed.
What is that issue and what can I do to get rid of it ?
Utils :
public static void sendSMS(Context context, String destination) {
final String srcPhoneNumber = PreferenceManager.getDefaultSharedPreferences(context).getString(OptionsFragment.SMS_SRC_PHONE_NUMBER, null);
final String message = PreferenceManager.getDefaultSharedPreferences(context).getString(OptionsFragment.SMS_MESSAGE, null);
if (message == null || message.isEmpty() || destination == null || destination.isEmpty()) {
Console.log('e', "tag", "sms sending failure");
Intent broadcastIntent = new Intent();
broadcastIntent.setAction("sms");
broadcastIntent.addCategory(Intent.CATEGORY_DEFAULT);
broadcastIntent.putExtra("sms", context.getString(R.string.empty_message));
MyApplication.getInstance().sendBroadcast(broadcastIntent);
return ;
}
final List<String> phoneNumbers = getPhoneNumbers();
removeEmptyElement(phoneNumbers);
SmsManager smsManager = SmsManager.getDefault();
ArrayList<String> parts = smsManager.divideMessage(message);
ArrayList<PendingIntent> deliveryIntents = new ArrayList<PendingIntent>();
ArrayList<PendingIntent> sentIntents = new ArrayList<PendingIntent>();
PendingIntent sentPI = PendingIntent.getBroadcast(MyApplication.getInstance(), 0, new Intent("sms"), 0);
PendingIntent deliveredPI = PendingIntent.getBroadcast(MyApplication.getInstance(), 0, new Intent("sms"), 0);
for (String part : parts) {
sentIntents.add(sentPI);
deliveryIntents.add(deliveredPI);
}
SmsManager.getDefault().sendMultipartTextMessage(destination, srcPhoneNumber, parts, sentIntents, deliveryIntents);
}
Receiver :
#Override
public void onReceive(Context context, Intent intent) {
String s = intent.getAction();
if (s.equals("sms")) {
String message = intent.getStringExtra("sms");
if (message != null) {
if (message.equals("OK")) {
AlertDialog.Builder builder = new AlertDialog.Builder(HomeFragment.this.getActivity());
builder.setMessage(context.getString(R.string.sms_send_success))
.setCancelable(true)
.setTitle("Success");
builder.create().show();
} else {
Utils.makeErrorDialog(HomeFragment.this.getActivity(), message);
}
}
else {
switch (getResultCode())
{
case Activity.RESULT_OK:
break;
case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
Utils.makeErrorDialog(HomeFragment.this.getActivity(),context.getString(R.string.send_error) + "Generic failure");
progressDialog.dismiss();
return;
case SmsManager.RESULT_ERROR_NO_SERVICE:
Utils.makeErrorDialog(HomeFragment.this.getActivity(),context.getString(R.string.send_error) + "No service");
progressDialog.dismiss();
return;
case SmsManager.RESULT_ERROR_NULL_PDU:
Utils.makeErrorDialog(HomeFragment.this.getActivity(),context.getString(R.string.send_error) + "Null PDU");
progressDialog.dismiss();
return;
case SmsManager.RESULT_ERROR_RADIO_OFF:
Utils.makeErrorDialog(HomeFragment.this.getActivity(),context.getString(R.string.send_error) + "Radio off");
progressDialog.dismiss();
return;
}
...

The second parameter in the SmsManager#sendMultipartTextMessage() method (as well as the sendTextMessage() and sendDataMessage() methods) is for the number of your service center, not the sender's number. A service center is the part of your network that handles the storage, routing, and delivery of SMS messages, so passing an invalid number would result in the generic failure status you're getting. You simply need to pass null for this.

Android SMSManager sendTextMessage - I get sentIntent but never get deliveryIntent

We're using the SMSManager on Android to send a text message to someone else from the device.
We've had reports of a user not receiving an SMS that we thought was delivered based on the fact that the sentIntent got called with Activity.RESULT_OK - but that seems to happen when the local SMS service simply queues the message for delivery and not necessarily when it is truly sent.
So I thought we should make use of the deliveryIntent.
The problem here is that I always get the sentIntent callback, but never the deliveryIntent one.
Any ideas?
Code is below, thanks.
// The intent action to be unique so that we can have multiple
// concurrent pending intents.
// http://developer.android.com/reference/android/app/PendingIntent.html
String intentAction = TAG + "-" + callbackId; // callbackId is unique
Intent intent = new Intent(intentAction);
intent.putExtra("phoneNumber", phoneNumber);
intent.putExtra("callbackId", callbackId);
intent.putExtra("message", message);
PendingIntent sentPI = PendingIntent.getBroadcast(
cordova.getActivity(), 0, intent, 0);
cordova.getActivity().registerReceiver(new BroadcastReceiver() {
#Override
public void onReceive(Context ctx, Intent intent) {
String sentToPhoneNumber = intent.getStringExtra("phoneNumber");
String callbackId = intent.getStringExtra("callbackId");
String message = intent.getStringExtra("message");
int resultCode = getResultCode();
int status = -1;
String details = "";
logger.log(Level.INFO, TAG + " SENT intent!! to: " +
sentToPhoneNumber + ", resultCode: " + resultCode);
switch (resultCode) {
case Activity.RESULT_OK:
status = 0;
break;
case SmsManager.RESULT_ERROR_NO_SERVICE:
details = "No service";
case SmsManager.RESULT_ERROR_NULL_PDU:
details = "Null PDU";
case SmsManager.RESULT_ERROR_RADIO_OFF:
details = "Radio off";
status = 1;
break;
}
JSONObject obj = new JSONObject();
try {
obj.put("status", status);
obj.put("details", details);
obj.put("phone_number", sentToPhoneNumber);
obj.put("message", message);
} catch (JSONException e) {
throw new RuntimeException(e);
}
sendAsyncResultStatus(callbackId, obj);
ctx.unregisterReceiver(this);
}
}, new IntentFilter(intentAction));
// The intent action to be unique so that we can have multiple
// concurrent pending intents.
// http://developer.android.com/reference/android/app/PendingIntent.html
String deliveryIntentAction = TAG + "-Delivery-" + callbackId;
Intent deliveryIntent = new Intent(deliveryIntentAction);
deliveryIntent.putExtra("phoneNumber", phoneNumber);
deliveryIntent.putExtra("callbackId", callbackId);
deliveryIntent.putExtra("message", message);
PendingIntent deliveryPI = PendingIntent.getBroadcast(
cordova.getActivity(), 0, deliveryIntent, 0);
cordova.getActivity().registerReceiver(new BroadcastReceiver() {
#Override
public void onReceive(Context ctx, Intent intent) {
logger.log(Level.INFO, TAG + " DELIVERY intent YOYO!!");
String sentToPhoneNumber = intent.getStringExtra("phoneNumber");
String callbackId = intent.getStringExtra("callbackId");
String message = intent.getStringExtra("message");
String pdu = intent.getStringExtra("pdu");
logger.log(Level.INFO, TAG + " DELIVERY intent!! to: " +
sentToPhoneNumber + ", pdu: " + pdu);
JSONObject obj = new JSONObject();
try {
obj.put("pdu", pdu);
obj.put("phone_number", sentToPhoneNumber);
obj.put("message", message);
} catch (JSONException e) {
throw new RuntimeException(e);
}
sendAsyncResultStatus(callbackId, obj);
ctx.unregisterReceiver(this);
}
}, new IntentFilter(deliveryIntentAction));
smsManager.sendTextMessage(phoneNumber, null, message, sentPI, deliveryPI);

DeliveryIntent is dependent on DeliveryReports provided by some carriers.
Some Carriers do provide DeliveryReports and some don't. There are three categories in terms of carriers support of DliveryReports...
Provider does not provide DeliveryReport at all.
Provider always give a fake DeliveryReport (you will get an OK report even for invalid numbers)
Provider does provide the delivery report.
The Complication doesn't stop here... If your provider (sending provider) does support delivery reports, you will get the delivery reports mostly when you are sending messages to subscribers of the same carrier. But when you send the message outside this carrier you may or may not get the delivery report. In most cases you won't.
This can be caused by a verity of reasons e.g.
Destination provider doesn't support delivery reports
Some of the intermediate SMS gateway(s) do not support delivery reports
DeliveryReports of Destination carrier or some intermediate gateways are not compatible with those of Originating Carriers.
Delivery Reports in such case are not a guaranteed information in my knowledge so far.

I could imagine that delivery intents depend on the reception of Return Receipts. The network provider needs to send these in order to make your program work.
You can do this by opening the "settings menu", browse to "SMS settings" and tick the box "Return receipt".

Sending text messages programmatically in android

OK. I am sending text messages through my app. After a text message is sent, it sends a status update to a server. This portion works okay, but the problem I am running into is twofold. I am not sure if they are related, but I assume that they are.
My app has the ability to send a single text to multiple users. Here is a sample of the code...
if(phoneNumbers.length > 0 && message.getText().toString().equals("") == false)
{
for(int i=0;i<phoneNumbers.length;i++)
{
sms = SmsManager.getDefault();
try
{
sms.sendTextMessage(phoneNumbers[i], null, message.getText().toString(), null, null);
sentQuantity++;
}
catch(IllegalArgumentException e)
{
}
}
}
Basically, it just loops through an array of phone numbers, and sends the text one at a time. Here is where part of my issue lies. If I choose 3 or more numbers to send the text to, sometimes not all of the texts actually get sent. It happens very randomly.
I assume it is because there is a delay between sending each individual message, but the code doesn't wait long enough. I reached this assumption because if I step into the program using eclipse and manually go through the app, everything always works just fine.
My other issue is when I send off the text message status update to a web server.
Immediately after the text messages get sent, the app then connects to the internet and tells the server via an http post the number of texts that were sent. Here is my snippet of internet code...
for(int i = 0; i < postNames.length; i++)
{
nameValuePairs.add(new BasicNameValuePair(postNames[i], postValues[i]));
}
//http post
try{
HttpParams httpParameters = new BasicHttpParams();
int timeoutConnection = 10000;
HttpConnectionParams.setConnectionTimeout(httpParameters,timeoutConnection );
HttpClient httpclient = new DefaultHttpClient(httpParameters);
HttpPost httppost = new HttpPost(webAddress);
httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
HttpResponse response = httpclient.execute(httppost);
HttpEntity entity = response.getEntity();
is = entity.getContent();
This section just compiles the items for the post, connects to a web page, and sends the post. The key here is the 10 second connection timeout. Once again, like I said earlier, the internet connection happens immediately after sending the texts. So, if I go into debug mode and manually step through the process, everything works fine. But if I just run the app on my phone, I will get a connection time out error.
Now, I am hoping that if I can reduce the number of text messages to one single text, regardless of the number of recipients, that would be awesome. I have tried separating the phone numbers with a comma, and that didn't work. I also tried separating the numbers with a semi-colon (exactly like how Microsoft Outlook, or GMail lets you add multiple recipients to an email). None of those worked for me. Does anyone have any suggestions? Even if there is a different approach altogether, that would be appreciated. Oh, and I don't want to use the Google Messaging intent to send the messages, I need to use my own app.

You actually need to send the next sms after the previous one is sent, for this you need to check the status of the sms sent, please see this tutorial, it says:
If you need to monitor the status of the SMS message sending process, you can actually use two PendingIntent objects together with two BroadcastReceiver objects, like this:
//---sends an SMS message to another device---
private void sendSMS(String phoneNumber, String message)
{
String SENT = "SMS_SENT";
String DELIVERED = "SMS_DELIVERED";
PendingIntent sentPI = PendingIntent.getBroadcast(this, 0,
new Intent(SENT), 0);
PendingIntent deliveredPI = PendingIntent.getBroadcast(this, 0,
new Intent(DELIVERED), 0);
//---when the SMS has been sent---
registerReceiver(new BroadcastReceiver(){
#Override
public void onReceive(Context arg0, Intent arg1) {
switch (getResultCode())
{
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS sent",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
Toast.makeText(getBaseContext(), "Generic failure",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_NO_SERVICE:
Toast.makeText(getBaseContext(), "No service",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_NULL_PDU:
Toast.makeText(getBaseContext(), "Null PDU",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_RADIO_OFF:
Toast.makeText(getBaseContext(), "Radio off",
Toast.LENGTH_SHORT).show();
break;
}
}
}, new IntentFilter(SENT));
//---when the SMS has been delivered---
registerReceiver(new BroadcastReceiver(){
#Override
public void onReceive(Context arg0, Intent arg1) {
switch (getResultCode())
{
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS delivered",
Toast.LENGTH_SHORT).show();
break;
case Activity.RESULT_CANCELED:
Toast.makeText(getBaseContext(), "SMS not delivered",
Toast.LENGTH_SHORT).show();
break;
}
}
}, new IntentFilter(DELIVERED));
SmsManager sms = SmsManager.getDefault();
sms.sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);
}

I guess this is what u need.
The below snippet provides to to enter long message and divide them into part and send each of it individual to a given contact or even for a group of contacts
public void sendLongSMS() {
String phoneNumber = "0123456789";
String message = "Hello World! Now we are going to demonstrate " +
"how to send a message with more than 160 characters from your Android application.";
SmsManager smsManager = SmsManager.getDefault();
ArrayList<String> parts = smsManager.divideMessage(message);
smsManager.sendMultipartTextMessage(phoneNumber, null, parts, null, null);
}

First you must add permission in AndroidManifest.xml file
<uses-permission android:name="android.permission.SEND_SMS"></uses-permission>
then write this code
try {
String ph="1234568790";
String msg="Haiii friend";
SmsManager smsManager = SmsManager.getDefault();
smsManager.sendTextMessage(ph, null,msg, null, null);
Toast.makeText(MainActivity.this, "Message Sent",
Toast.LENGTH_LONG).show();
}
catch (Exception e)
{
Toast.makeText(MainActivity.this, "Message not Sent",
Toast.LENGTH_LONG).show();
}

You can try this
SmsManager.getDefault().sendTextMessage(phoneNUmber, null, messageToSend, null, null);
Thanks

Sending unique sms and receiving looong sms in android

So i have tried for a long time to find a way to make a app that can send and receive sms in android. That works fine. Here is the code:
For sending:
#SuppressWarnings("deprecation")
public void sendSMS(String phoneNumber, String message) {
String SENT = "SMS_SENT";
String DELIVERED = "SMS_DELIVERED";
int unq = 0;
Intent sent = new Intent(SENT);
sent.putExtra("unq", unq);
Intent delivered = new Intent(DELIVERED);
delivered.putExtra("unq", unq);
PendingIntent sentPI = PendingIntent.getBroadcast(this, 0, sent, 0);
PendingIntent deliveredPI = PendingIntent.getBroadcast(this, 0,delivered, 0);
// ---when the SMS has been sent---
registerReceiver(new BroadcastReceiver() {
#Override
public void onReceive(Context arg0, Intent arg1) {
switch (getResultCode()) {
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS sent",
Toast.LENGTH_SHORT).show();
smsstatus = "0";
smserror = "noError";
//sendSmsStatus();
break;
case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
Toast.makeText(getBaseContext(), "Generic failure",
Toast.LENGTH_SHORT).show();
setSmsstatus("1");
setSmserror("Generic failure");
sendSmsStatus("Generic failure");
break;
case SmsManager.RESULT_ERROR_NO_SERVICE:
Toast.makeText(getBaseContext(), "No service",
Toast.LENGTH_SHORT).show();
setSmsstatus("2");
setSmserror("No service");
sendSmsStatus("No service");
break;
case SmsManager.RESULT_ERROR_NULL_PDU:
Toast.makeText(getBaseContext(), "Null PDU",
Toast.LENGTH_SHORT).show();
setSmsstatus("3");
setSmserror("Null PDU");
sendSmsStatus("Null PDU");
break;
case SmsManager.RESULT_ERROR_RADIO_OFF:
Toast.makeText(getBaseContext(), "Radio off",
Toast.LENGTH_SHORT).show();
setSmsstatus("4");
setSmserror("Radio off");
sendSmsStatus("Radio off");
break;
}
}
}, new IntentFilter(SENT));
// ---when the SMS has been delivered---
registerReceiver(new BroadcastReceiver() {
#Override
public void onReceive(Context arg0, Intent arg1) {
switch (getResultCode()) {
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS delivered",
Toast.LENGTH_SHORT).show();
break;
case Activity.RESULT_CANCELED:
Toast.makeText(getBaseContext(), "SMS not delivered",
Toast.LENGTH_SHORT).show();
break;
}
}
}, new IntentFilter(DELIVERED));
SmsManager sms = SmsManager.getDefault();
sms.sendTextMessage(phoneNumber, null, message, sentPI, deliveredPI);
}
For receiving:
public class SmsReceiver extends BroadcastReceiver {
#SuppressWarnings("deprecation")
#Override
public void onReceive(Context context, Intent intent) {
// ---get the SMS message passed in---
Bundle bundle = intent.getExtras();
SmsMessage[] msgs = null;
String str = "";
Object sms = "";
ArrayList<String> s = new ArrayList<String>();
Manager m = Factory.getInstance().getManager();
if (bundle != null) {
// ---retrieve the SMS message received---
Object[] pdus = (Object[]) bundle.get("pdus");
msgs = new SmsMessage[pdus.length];
for (int i = 0; i < msgs.length; i++) {
msgs[i] = SmsMessage.createFromPdu((byte[]) pdus[i]);
str += " SMS fra " + msgs[i].getOriginatingAddress() + "\n";
str += " Besked: ";
str += msgs[i].getMessageBody().toString();
str += "\n";
sms = "SMS = "+msgs[i].getOriginatingAddress()+","+msgs[i].getMessageBody().toString();
s.add(msgs[i].getOriginatingAddress());
s.add(msgs[i].getMessageBody().toString());
}
// ---display the new SMS message---
Toast.makeText(context, str, Toast.LENGTH_LONG).show();
Manager.toastIt(context, str);
// Send the sms to the server
//Connection.send(new Transmit("SmsReceived",s));
}
}
}
This works great!.
And here comes the question. Is it posible to refactore my code to achive the following:
Have a unique indentifier/flag on my send sms so i can make sure which sms i receive a status on. As you can see i have already tried to put extra on my 2 intents, and maybe that is the right way, but not only do i not now how to check/receive/extract the flag for the status, but also the flag really "unique" right now.
Its nice that I can revieve a sms, but when its more than 160 chars it only shows me the first 160 chars. I had looked at how GTalkSMS does it, but was hoping my code could just be refactored a bit :)
The last problem is, a mix of the 2 above. I cant send a sms thats more than 160 char. I know i have to use sendMultipartTextMessage, but i dont know how. My thought is that i could devide the "String message" by 100 to a Array but i dont know.
So feel free to refactore the code. I'm looking forward to see your replies! :D
Please ask if you need anything explained better or more code! :)

Not Android specific, but read about the "Concatenated SMS" standard. Basically it's multiple messages that each specify they go with the previous one, but it goes over the air as entirely independent SMS.
Most phones hide this fact from the user, of course, but if you're directly receiving SMS it's likely you'll need to deal with it yourself - sending and receiving. Assuming Android uses this standard, which seems like a safe bet.
Since it's so common, I'm sure you can find a library that somebody's already written.
http://en.wikipedia.org/wiki/Concatenated_SMS

Everything you asked for is in the GTalkSMS code (seems you have missed it). :-) But I will point you to the right snippets.
In order to use sendMultipartTextMessage() and distinguish the different sent/delivered notification intents you need first to split the message string via SmsManager.divideMessage(message) and create two, one for sent notifications and one for the delivered notifications, PendingIntents ArrayLists, where, and this is the important part, every PendingIntent has to be created with a a unique request int:
PendingIntent.getBroadcast(context, UNIQUE_ID, deliveredIntent, PendingIntent.FLAG_ONE_SHOT)
This assures that andoird will broadcast an unique intent for every sent delivered notification. You can also add some extras to the intent, which could later tell you for which SMS the notification was.
Code snippets can be found here: sendSMSByPhoneNumber()
Make sure that your SmsReceiver is aware that an incoming intent can contain more that one SMS for multiple senders, but a maximum of nbfOfpdus different senders. The GTalkSMS receiver will sure help you understand how to get this going. :)