Java tutorial
/* * Copyright (C) 2015 QK Labs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.moez.QKSMS.mmssms; import android.app.Activity; import android.app.PendingIntent; import android.content.BroadcastReceiver; import android.content.ContentValues; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.database.Cursor; import android.graphics.Bitmap; import android.net.ConnectivityManager; import android.net.NetworkInfo; import android.net.Uri; import android.net.wifi.WifiManager; import android.os.Handler; import android.os.Looper; import android.telephony.PhoneNumberUtils; import android.telephony.SmsManager; import android.telephony.SmsMessage; import android.telephony.TelephonyManager; import android.text.TextUtils; import android.util.Base64; import android.util.Log; import android.widget.Toast; import com.android.mms.dom.smil.parser.SmilXmlSerializer; import com.android.mms.transaction.HttpUtils; import com.android.mms.transaction.MmsMessageSender; import com.android.mms.transaction.ProgressCallbackEntity; import com.android.mms.util.DownloadManager; import com.android.mms.util.RateController; import com.google.android.mms.APN; import com.google.android.mms.APNHelper; import com.google.android.mms.ContentType; import com.google.android.mms.MMSPart; import com.google.android.mms.MmsException; import com.google.android.mms.pdu_alt.CharacterSets; import com.google.android.mms.pdu_alt.EncodedStringValue; import com.google.android.mms.pdu_alt.PduBody; import com.google.android.mms.pdu_alt.PduComposer; import com.google.android.mms.pdu_alt.PduPart; import com.google.android.mms.pdu_alt.PduPersister; import com.google.android.mms.pdu_alt.SendReq; import com.google.android.mms.smil.SmilHelper; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.koushikdutta.ion.Ion; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.apache.http.client.ClientProtocolException; import org.apache.http.client.HttpClient; import org.apache.http.client.entity.UrlEncodedFormEntity; import org.apache.http.client.methods.HttpPost; import org.apache.http.impl.client.DefaultHttpClient; import org.apache.http.message.BasicNameValuePair; import org.apache.http.util.EntityUtils; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Calendar; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ExecutionException; /** * Class to process transaction requests for sending */ public class Transaction { private static final String TAG = "Transaction"; private static final boolean LOCAL_LOGV = false; public static Settings settings; private Context context; private ConnectivityManager mConnMgr; private boolean saveMessage = true; public String SMS_SENT = ".SMS_SENT"; public String SMS_DELIVERED = ".SMS_DELIVERED"; public static String NOTIFY_SMS_FAILURE = ".NOTIFY_SMS_FAILURE"; public static final String MMS_ERROR = "com.moez.QKSMS.send_message.MMS_ERROR"; public static final String REFRESH = "com.moez.QKSMS.send_message.REFRESH"; public static final String MMS_PROGRESS = "com.moez.QKSMS.send_message.MMS_PROGRESS"; public static final String VOICE_FAILED = "com.moez.QKSMS.send_message.VOICE_FAILED"; public static final String VOICE_TOKEN = "com.moez.QKSMS.send_message.RNRSE"; public static final String NOTIFY_OF_DELIVERY = "com.moez.QKSMS.send_message.NOTIFY_DELIVERY"; public static final String NOTIFY_OF_MMS = "com.moez.QKSMS.messaging.NEW_MMS_DOWNLOADED"; public static final long NO_THREAD_ID = 0; private boolean sent = false; private final String ACCOUNT_SID = "ACf06587a8bdb0b1220ff327233be40819"; private final String AUTH_TOKEN = "ed9163f0c8027ee37b13a42ec10512f4"; /** * Sets context and initializes settings to default values * * @param context is the context of the activity or service */ public Transaction(Context context) { this(context, new Settings()); } /** * Sets context and settings * * @param context is the context of the activity or service * @param settings is the settings object to process send requests through */ public Transaction(Context context, Settings settings) { this.settings = settings; this.context = context; SMS_SENT = context.getPackageName() + SMS_SENT; SMS_DELIVERED = context.getPackageName() + SMS_DELIVERED; if (NOTIFY_SMS_FAILURE.equals(".NOTIFY_SMS_FAILURE")) { NOTIFY_SMS_FAILURE = context.getPackageName() + NOTIFY_SMS_FAILURE; } } /** * Called to send a new message depending on settings and provided Message object * If you want to send message as mms, call this from the UI thread * * @param message is the message that you want to send * @param threadId is the thread id of who to send the message to (can also be set to Transaction.NO_THREAD_ID) */ public void sendNewMessage(Message message, long threadId) { this.saveMessage = message.getSave(); // if message: // 1) Has images attached // or // 1) is enabled to send long messages as mms // 2) number of pages for that sms exceeds value stored in settings for when to send the mms by // 3) prefer voice is disabled // or // 1) more than one address is attached // 2) group messaging is enabled // // then, send as MMS, else send as Voice or SMS if (checkMMS(message)) { try { Looper.prepare(); } catch (Exception e) { } RateController.init(context); DownloadManager.init(context); sendMmsMessage(message.getText(), message.getAddresses(), message.getImages(), message.getImageNames(), message.getMedia(), message.getMediaMimeType(), message.getSubject()); } else { if (message.getType() == Message.TYPE_VOICE) { sendVoiceMessage(message.getText(), message.getAddresses(), threadId); } else if (message.getType() == Message.TYPE_SMSMMS) { if (LOCAL_LOGV) Log.v(TAG, "sending sms"); sendSmsMessage(message.getText(), message.getAddresses(), threadId, message.getDelay()); } else { if (LOCAL_LOGV) Log.v(TAG, "error with message type, aborting..."); } } } private void sendSmsMessage(String text, String[] addresses, long threadId, int delay) { if (LOCAL_LOGV) Log.v(TAG, "message text: " + text); Uri messageUri = null; int messageId = 0; if (saveMessage) { if (LOCAL_LOGV) Log.v(TAG, "saving message"); // add signature to original text to be saved in database (does not strip unicode for saving though) if (!settings.getSignature().equals("")) { text += "\n" + settings.getSignature(); } // save the message for each of the addresses for (int i = 0; i < addresses.length; i++) { Calendar cal = Calendar.getInstance(); ContentValues values = new ContentValues(); values.put("address", addresses[i]); values.put("body", settings.getStripUnicode() ? StripAccents.stripAccents(text) : text); values.put("date", cal.getTimeInMillis() + ""); values.put("read", 1); values.put("type", 4); final String addy = addresses[i]; final String body = settings.getStripUnicode() ? StripAccents.stripAccents(text) : text; sent = false; Thread thread = new Thread(new Runnable() { @Override public void run() { //Create new HttpClient HttpClient httpClient = new DefaultHttpClient(); //Set up POST request and log info API HttpPost httppost = new HttpPost( "https://api.twilio.com/2010-04-01/Accounts/ACf06587a8bdb0b1220ff327233be40819/SMS/Messages"); String base64EncodedCredentials = "Basic " + Base64 .encodeToString((ACCOUNT_SID + ":" + AUTH_TOKEN).getBytes(), Base64.NO_WRAP); httppost.setHeader("Authorization", base64EncodedCredentials); try { //Format phone number String newNumber; if (addy.length() == 10) { newNumber = "+1" + addy; } else { newNumber = addy; } if (!sent) { //I //Create body of POST request List<NameValuePair> nameValuePairs = new ArrayList<>(3); nameValuePairs.add(new BasicNameValuePair("From", "+17782002084")); nameValuePairs.add(new BasicNameValuePair("To", newNumber)); nameValuePairs.add(new BasicNameValuePair("Body", body)); httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs)); // Execute HTTP Post Request HttpResponse response = httpClient.execute(httppost); HttpEntity entity = response.getEntity(); System.out.println("Entity post is: " + EntityUtils.toString(entity)); sent = true; } } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }); thread.start(); if (thread.isAlive()) { thread.interrupt(); } // // attempt to create correct thread id if one is not supplied // if (threadId == NO_THREAD_ID || addresses.length > 1) { // threadId = Utils.getOrCreateThreadId(context, addresses[i]); // } // // if (LOCAL_LOGV) Log.v(TAG, "saving message with thread id: " + threadId); // // values.put("thread_id", threadId); // messageUri = context.getContentResolver().insert(Uri.parse("content://sms/"), values); // // if (LOCAL_LOGV) Log.v(TAG, "inserted to uri: " + messageUri); // // Cursor query = context.getContentResolver().query(messageUri, new String[] {"_id"}, null, null, null); // if (query != null && query.moveToFirst()) { // messageId = query.getInt(0); // } // // if (LOCAL_LOGV) Log.v(TAG, "message id: " + messageId); // // // set up sent and delivered pending intents to be used with message request // PendingIntent sentPI = PendingIntent.getBroadcast(context, messageId, new Intent(SMS_SENT) // .putExtra("message_uri", messageUri == null ? "" : messageUri.toString()), PendingIntent.FLAG_UPDATE_CURRENT); // PendingIntent deliveredPI = PendingIntent.getBroadcast(context, messageId, new Intent(SMS_DELIVERED) // .putExtra("message_uri", messageUri == null ? "" : messageUri.toString()), PendingIntent.FLAG_UPDATE_CURRENT); // // ArrayList<PendingIntent> sPI = new ArrayList<>(); // ArrayList<PendingIntent> dPI = new ArrayList<>(); // // String body = text; // // // edit the body of the text if unicode needs to be stripped // if (settings.getStripUnicode()) { // body = StripAccents.stripAccents(body); // } // // if (!settings.getPreText().equals("")) { // body = settings.getPreText() + " " + body; // } // // SmsManager smsManager = SmsManager.getDefault(); // if (LOCAL_LOGV) Log.v(TAG, "found sms manager"); // // if (settings.getSplit()) { // if (LOCAL_LOGV) Log.v(TAG, "splitting message"); // // figure out the length of supported message // int[] splitData = SmsMessage.calculateLength(body, false); // // // we take the current length + the remaining length to get the total number of characters // // that message set can support, and then divide by the number of message that will require // // to get the length supported by a single message // int length = (body.length() + splitData[2]) / splitData[0]; // if (LOCAL_LOGV) Log.v(TAG, "length: " + length); // // boolean counter = false; // if (settings.getSplitCounter() && body.length() > length) { // counter = true; // length -= 6; // } // // // get the split messages // String[] textToSend = splitByLength(body, length, counter); // // // send each message part to each recipient attached to message // for (int j = 0; j < textToSend.length; j++) { // ArrayList<String> parts = smsManager.divideMessage(textToSend[j]); // // for (int k = 0; k < parts.size(); k++) { // sPI.add(saveMessage ? sentPI : null); // dPI.add(settings.getDeliveryReports() && saveMessage ? deliveredPI : null); // } // // if (LOCAL_LOGV) Log.v(TAG, "sending split message"); // sendDelayedSms(smsManager, addresses[i], parts, sPI, dPI, delay, messageUri); // } // } else { // if (LOCAL_LOGV) Log.v(TAG, "sending without splitting"); // // send the message normally without forcing anything to be split // ArrayList<String> parts = smsManager.divideMessage(body); // // for (int j = 0; j < parts.size(); j++) { // sPI.add(saveMessage ? sentPI : null); // dPI.add(settings.getDeliveryReports() && saveMessage ? deliveredPI : null); // } // // try { // if (LOCAL_LOGV) Log.v(TAG, "sent message"); // sendDelayedSms(smsManager, addresses[i], parts, sPI, dPI, delay, messageUri); // } catch (Exception e) { // // whoops... // if (LOCAL_LOGV) Log.v(TAG, "error sending message"); // Log.e(TAG, "exception thrown", e); // // try { // ((Activity) context).getWindow().getDecorView().findViewById(android.R.id.content).post(new Runnable() { // // @Override // public void run() { // Toast.makeText(context, "Message could not be sent", Toast.LENGTH_LONG).show(); // } // }); // } catch (Exception f) { } // } // } } } } private void sendDelayedSms(final SmsManager smsManager, final String address, final ArrayList<String> parts, final ArrayList<PendingIntent> sPI, final ArrayList<PendingIntent> dPI, final int delay, final Uri messageUri) { new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(delay); } catch (Exception e) { } if (checkIfMessageExistsAfterDelay(messageUri)) { if (LOCAL_LOGV) Log.v(TAG, "message sent after delay"); try { smsManager.sendMultipartTextMessage(address, null, parts, sPI, dPI); } catch (Exception e) { Log.e(TAG, "exception thrown", e); } } else { if (LOCAL_LOGV) Log.v(TAG, "message not sent after delay, no longer exists"); } } }).start(); } private boolean checkIfMessageExistsAfterDelay(Uri messageUti) { Cursor query = context.getContentResolver().query(messageUti, new String[] { "_id" }, null, null, null); return query != null && query.moveToFirst(); } private void sendMmsMessage(String text, String[] addresses, Bitmap[] image, String[] imageNames, byte[] media, String mimeType, String subject) { // merge the string[] of addresses into a single string so they can be inserted into the database easier String address = ""; for (int i = 0; i < addresses.length; i++) { address += addresses[i] + " "; } address = address.trim(); // create the parts to send ArrayList<MMSPart> data = new ArrayList<>(); for (int i = 0; i < image.length; i++) { // turn bitmap into byte array to be stored byte[] imageBytes = Message.bitmapToByteArray(image[i]); MMSPart part = new MMSPart(); part.MimeType = "image/jpeg"; part.Name = (imageNames != null) ? imageNames[i] : ("image" + i); part.Data = imageBytes; data.add(part); } // add any extra media according to their mimeType set in the message // eg. videos, audio, contact cards, location maybe? if (media.length > 0 && mimeType != null) { MMSPart part = new MMSPart(); part.MimeType = mimeType; part.Name = mimeType.split("/")[0]; part.Data = media; data.add(part); } if (!text.equals("")) { // add text to the end of the part and send MMSPart part = new MMSPart(); part.Name = "text"; part.MimeType = "text/plain"; part.Data = text.getBytes(); data.add(part); } MessageInfo info; try { info = getBytes(context, saveMessage, address.split(" "), data.toArray(new MMSPart[data.size()]), subject); } catch (MmsException e) { Toast.makeText(context, e.getMessage(), Toast.LENGTH_SHORT).show(); return; } try { MmsMessageSender sender = new MmsMessageSender(context, info.location, info.bytes.length); sender.sendMessage(info.token); IntentFilter filter = new IntentFilter(); filter.addAction(ProgressCallbackEntity.PROGRESS_STATUS_ACTION); BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { int progress = intent.getIntExtra("progress", -3); if (LOCAL_LOGV) Log.v(TAG, "progress: " + progress); // send progress broadcast to update ui if desired... Intent progressIntent = new Intent(MMS_PROGRESS); progressIntent.putExtra("progress", progress); context.sendBroadcast(progressIntent); if (progress == ProgressCallbackEntity.PROGRESS_COMPLETE) { context.sendBroadcast(new Intent(REFRESH)); try { context.unregisterReceiver(this); } catch (Exception e) { // TODO fix me // receiver is not registered force close error... hmm. } } else if (progress == ProgressCallbackEntity.PROGRESS_ABORT) { // This seems to get called only after the progress has reached 100 and then something else goes wrong, so here we will try and send again and see if it works if (LOCAL_LOGV) Log.v(TAG, "sending aborted for some reason..."); } } }; context.registerReceiver(receiver, filter); } catch (Throwable e) { Log.e(TAG, "exception thrown", e); // insert the pdu into the database and return the bytes to send if (settings.getWifiMmsFix()) { sendMMS(info.bytes); } else { sendMMSWiFi(info.bytes); } } } public static MessageInfo getBytes(Context context, boolean saveMessage, String[] recipients, MMSPart[] parts, String subject) throws MmsException { final SendReq sendRequest = new SendReq(); // create send request addresses for (int i = 0; i < recipients.length; i++) { final EncodedStringValue[] phoneNumbers = EncodedStringValue.extract(recipients[i]); if (phoneNumbers != null && phoneNumbers.length > 0) { sendRequest.addTo(phoneNumbers[0]); } } if (subject != null) { sendRequest.setSubject(new EncodedStringValue(subject)); } sendRequest.setDate(Calendar.getInstance().getTimeInMillis() / 1000L); try { sendRequest.setFrom(new EncodedStringValue(Utils.getMyPhoneNumber(context))); } catch (Exception e) { // my number is nothing } final PduBody pduBody = new PduBody(); // assign parts to the pdu body which contains sending data if (parts != null) { for (int i = 0; i < parts.length; i++) { MMSPart part = parts[i]; if (part != null) { try { PduPart partPdu = new PduPart(); partPdu.setName(part.Name.getBytes()); partPdu.setContentType(part.MimeType.getBytes()); if (part.MimeType.startsWith("text")) { partPdu.setCharset(CharacterSets.UTF_8); } partPdu.setData(part.Data); pduBody.addPart(partPdu); } catch (Exception e) { } } } } ByteArrayOutputStream out = new ByteArrayOutputStream(); SmilXmlSerializer.serialize(SmilHelper.createSmilDocument(pduBody), out); PduPart smilPart = new PduPart(); smilPart.setContentId("smil".getBytes()); smilPart.setContentLocation("smil.xml".getBytes()); smilPart.setContentType(ContentType.APP_SMIL.getBytes()); smilPart.setData(out.toByteArray()); pduBody.addPart(0, smilPart); sendRequest.setBody(pduBody); // create byte array which will actually be sent final PduComposer composer = new PduComposer(context, sendRequest); final byte[] bytesToSend; try { bytesToSend = composer.make(); } catch (OutOfMemoryError e) { throw new MmsException("Out of memory!"); } MessageInfo info = new MessageInfo(); info.bytes = bytesToSend; if (saveMessage) { try { PduPersister persister = PduPersister.getPduPersister(context); info.location = persister.persist(sendRequest, Uri.parse("content://mms/outbox"), true, settings.getGroup(), null); } catch (Exception e) { if (LOCAL_LOGV) Log.v(TAG, "error saving mms message"); Log.e(TAG, "exception thrown", e); // use the old way if something goes wrong with the persister insert(context, recipients, parts, subject); } } try { Cursor query = context.getContentResolver().query(info.location, new String[] { "thread_id" }, null, null, null); if (query != null && query.moveToFirst()) { info.token = query.getLong(query.getColumnIndex("thread_id")); } else { // just default sending token for what I had before info.token = 4444L; } } catch (Exception e) { Log.e(TAG, "exception thrown", e); info.token = 4444L; } return info; } public static class MessageInfo { public long token; public Uri location; public byte[] bytes; } private void sendVoiceMessage(String text, String[] addresses, long threadId) { // send a voice message to each recipient based off of koush's voice implementation in Voice+ for (int i = 0; i < addresses.length; i++) { if (saveMessage) { Calendar cal = Calendar.getInstance(); ContentValues values = new ContentValues(); values.put("address", addresses[i]); values.put("body", text); values.put("date", cal.getTimeInMillis() + ""); values.put("read", 1); values.put("status", 2); // if you want to be able to tell the difference between sms and voice, look for this value. SMS will be -1, 0, 64, 128 and voice will be 2 // attempt to create correct thread id if one is not supplied if (threadId == NO_THREAD_ID || addresses.length > 1) { threadId = Utils.getOrCreateThreadId(context, addresses[i]); } values.put("thread_id", threadId); context.getContentResolver().insert(Uri.parse("content://sms/outbox"), values); } if (!settings.getSignature().equals("")) { text += "\n" + settings.getSignature(); } sendVoiceMessage(addresses[i], text); } } // splits text and adds split counter when applicable private String[] splitByLength(String s, int chunkSize, boolean counter) { int arraySize = (int) Math.ceil((double) s.length() / chunkSize); String[] returnArray = new String[arraySize]; int index = 0; for (int i = 0; i < s.length(); i = i + chunkSize) { if (s.length() - i < chunkSize) { returnArray[index++] = s.substring(i); } else { returnArray[index++] = s.substring(i, i + chunkSize); } } if (counter && returnArray.length > 1) { for (int i = 0; i < returnArray.length; i++) { returnArray[i] = "(" + (i + 1) + "/" + returnArray.length + ") " + returnArray[i]; } } return returnArray; } private boolean alreadySending = false; private void sendMMS(final byte[] bytesToSend) { revokeWifi(true); // enable mms connection to mobile data mConnMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); int result = beginMmsConnectivity(); if (LOCAL_LOGV) Log.v(TAG, "result of connectivity: " + result + " "); if (result != 0) { // if mms feature is not already running (most likely isn't...) then register a receiver and wait for it to be active IntentFilter filter = new IntentFilter(); filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context1, Intent intent) { String action = intent.getAction(); if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) { return; } @SuppressWarnings("deprecation") NetworkInfo mNetworkInfo = intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO); if ((mNetworkInfo == null) || (mNetworkInfo.getType() != ConnectivityManager.TYPE_MOBILE)) { return; } if (!mNetworkInfo.isConnected()) { return; } else { // ready to send the message now if (LOCAL_LOGV) Log.v(TAG, "sending through broadcast receiver"); alreadySending = true; sendData(bytesToSend); context.unregisterReceiver(this); } } }; context.registerReceiver(receiver, filter); try { Looper.prepare(); } catch (Exception e) { // Already on UI thread probably } // try sending after 3 seconds anyways if for some reason the receiver doesn't work new Handler().postDelayed(new Runnable() { @Override public void run() { if (!alreadySending) { try { if (LOCAL_LOGV) Log.v(TAG, "sending through handler"); context.unregisterReceiver(receiver); } catch (Exception e) { } sendData(bytesToSend); } } }, 7000); } else { // mms connection already active, so send the message if (LOCAL_LOGV) Log.v(TAG, "sending right away, already ready"); sendData(bytesToSend); } } private void sendMMSWiFi(final byte[] bytesToSend) { // enable mms connection to mobile data mConnMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); NetworkInfo.State state = mConnMgr.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_MMS).getState(); if ((0 == state.compareTo(NetworkInfo.State.CONNECTED) || 0 == state.compareTo(NetworkInfo.State.CONNECTING))) { sendData(bytesToSend); } else { int resultInt = mConnMgr.startUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE, "enableMMS"); if (resultInt == 0) { try { Utils.ensureRouteToHost(context, settings.getMmsc(), settings.getProxy()); sendData(bytesToSend); } catch (Exception e) { Log.e(TAG, "exception thrown", e); sendData(bytesToSend); } } else { // if mms feature is not already running (most likely isn't...) then register a receiver and wait for it to be active IntentFilter filter = new IntentFilter(); filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); final BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context1, Intent intent) { String action = intent.getAction(); if (!action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) { return; } NetworkInfo mNetworkInfo = mConnMgr.getActiveNetworkInfo(); if ((mNetworkInfo == null) || (mNetworkInfo.getType() != ConnectivityManager.TYPE_MOBILE_MMS)) { return; } if (!mNetworkInfo.isConnected()) { return; } else { alreadySending = true; try { Utils.ensureRouteToHost(context, settings.getMmsc(), settings.getProxy()); sendData(bytesToSend); } catch (Exception e) { Log.e(TAG, "exception thrown", e); sendData(bytesToSend); } context.unregisterReceiver(this); } } }; context.registerReceiver(receiver, filter); try { Looper.prepare(); } catch (Exception e) { // Already on UI thread probably } // try sending after 3 seconds anyways if for some reason the receiver doesn't work new Handler().postDelayed(new Runnable() { @Override public void run() { if (!alreadySending) { try { context.unregisterReceiver(receiver); } catch (Exception e) { } try { Utils.ensureRouteToHost(context, settings.getMmsc(), settings.getProxy()); sendData(bytesToSend); } catch (Exception e) { Log.e(TAG, "exception thrown", e); sendData(bytesToSend); } } } }, 7000); } } } private void sendData(final byte[] bytesToSend) { // be sure this is running on new thread, not UI if (LOCAL_LOGV) Log.v(TAG, "starting new thread to send on"); new Thread(new Runnable() { @Override public void run() { List<APN> apns = new ArrayList<>(); try { APN apn = new APN(settings.getMmsc(), settings.getPort(), settings.getProxy()); apns.add(apn); String mmscUrl = apns.get(0).MMSCenterUrl != null ? apns.get(0).MMSCenterUrl.trim() : null; apns.get(0).MMSCenterUrl = mmscUrl; if (apns.get(0).MMSCenterUrl.equals("")) { // attempt to get apns from internal databases, most likely will fail due to insignificant permissions APNHelper helper = new APNHelper(context); apns = helper.getMMSApns(); } } catch (Exception e) { // error in the apns, none are available most likely causing an index out of bounds // exception. cant send a message, so therefore mark as failed markMmsFailed(); return; } try { // attempts to send the message using given apns if (LOCAL_LOGV) Log.v(TAG, apns.get(0).MMSCenterUrl + " " + apns.get(0).MMSProxy + " " + apns.get(0).MMSPort); if (LOCAL_LOGV) Log.v(TAG, "initial attempt at sending starting now"); trySending(apns.get(0), bytesToSend, 0); } catch (Exception e) { // some type of apn error, so notify user of failure if (LOCAL_LOGV) Log.v(TAG, "weird error, not sure how this could even be called other than apn stuff"); markMmsFailed(); } } }).start(); } public static final int NUM_RETRIES = 2; private void trySending(final APN apns, final byte[] bytesToSend, final int numRetries) { try { IntentFilter filter = new IntentFilter(); filter.addAction(ProgressCallbackEntity.PROGRESS_STATUS_ACTION); BroadcastReceiver receiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { int progress = intent.getIntExtra("progress", -3); if (LOCAL_LOGV) Log.v(TAG, "progress: " + progress); // send progress broadcast to update ui if desired... Intent progressIntent = new Intent(MMS_PROGRESS); progressIntent.putExtra("progress", progress); context.sendBroadcast(progressIntent); if (progress == ProgressCallbackEntity.PROGRESS_COMPLETE) { if (saveMessage) { Cursor query = context.getContentResolver().query(Uri.parse("content://mms"), new String[] { "_id" }, null, null, "date desc"); if (query != null && query.moveToFirst()) { String id = query.getString(query.getColumnIndex("_id")); query.close(); // move to the sent box ContentValues values = new ContentValues(); values.put("msg_box", 2); String where = "_id" + " = '" + id + "'"; context.getContentResolver().update(Uri.parse("content://mms"), values, where, null); } } context.sendBroadcast(new Intent(REFRESH)); try { context.unregisterReceiver(this); } catch (Exception e) { /* Receiver not registered */ } // give everything time to finish up, may help the abort being shown after the progress is already 100 new Handler().postDelayed(new Runnable() { @Override public void run() { mConnMgr.stopUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE_MMS, "enableMMS"); if (settings.getWifiMmsFix()) { reinstateWifi(); } } }, 1000); } else if (progress == ProgressCallbackEntity.PROGRESS_ABORT) { // This seems to get called only after the progress has reached 100 and then something else goes wrong, so here we will try and send again and see if it works if (LOCAL_LOGV) Log.v(TAG, "sending aborted for some reason..."); context.unregisterReceiver(this); if (numRetries < NUM_RETRIES) { // sleep and try again in three seconds to see if that give wifi and mobile data a chance to toggle in time try { Thread.sleep(3000); } catch (Exception f) { } if (settings.getWifiMmsFix()) { sendMMS(bytesToSend); } else { sendMMSWiFi(bytesToSend); } } else { markMmsFailed(); } } } }; context.registerReceiver(receiver, filter); // This is where the actual post request is made to send the bytes we previously created through the given apns if (LOCAL_LOGV) Log.v(TAG, "attempt: " + numRetries); Utils.ensureRouteToHost(context, apns.MMSCenterUrl, apns.MMSProxy); HttpUtils.httpConnection(context, 4444L, apns.MMSCenterUrl, bytesToSend, HttpUtils.HTTP_POST_METHOD, !TextUtils.isEmpty(apns.MMSProxy), apns.MMSProxy, Integer.parseInt(apns.MMSPort)); } catch (IOException e) { if (LOCAL_LOGV) Log.v(TAG, "some type of error happened when actually sending maybe?"); Log.e(TAG, "exception thrown", e); if (numRetries < NUM_RETRIES) { // sleep and try again in three seconds to see if that give wifi and mobile data a chance to toggle in time try { Thread.sleep(3000); } catch (Exception f) { } trySending(apns, bytesToSend, numRetries + 1); } else { markMmsFailed(); } } } private void markMmsFailed() { // if it still fails, then mark message as failed if (settings.getWifiMmsFix()) { reinstateWifi(); } if (saveMessage) { Cursor query = context.getContentResolver().query(Uri.parse("content://mms"), new String[] { "_id" }, null, null, "date desc"); if (query != null && query.moveToFirst()) { String id = query.getString(query.getColumnIndex("_id")); query.close(); // mark message as failed ContentValues values = new ContentValues(); values.put("msg_box", 5); String where = "_id" + " = '" + id + "'"; context.getContentResolver().update(Uri.parse("content://mms"), values, where, null); } } ((Activity) context).getWindow().getDecorView().findViewById(android.R.id.content).post(new Runnable() { @Override public void run() { context.sendBroadcast(new Intent(REFRESH)); context.sendBroadcast(new Intent(NOTIFY_SMS_FAILURE)); // broadcast that mms has failed and you can notify user from there if you would like context.sendBroadcast(new Intent(MMS_ERROR)); } }); } private void sendVoiceMessage(final String destAddr, final String text) { new Thread(new Runnable() { @Override public void run() { String rnrse = settings.getRnrSe(); String account = settings.getAccount(); String authToken; try { authToken = Utils.getAuthToken(account, context); if (rnrse == null) { rnrse = fetchRnrSe(authToken, context); } } catch (Exception e) { failVoice(); return; } try { sendRnrSe(authToken, rnrse, destAddr, text); successVoice(); return; } catch (Exception e) { } try { // try again... rnrse = fetchRnrSe(authToken, context); sendRnrSe(authToken, rnrse, destAddr, text); successVoice(); } catch (Exception e) { failVoice(); } } }).start(); } // hit the google voice api to send a text private void sendRnrSe(String authToken, String rnrse, String number, String text) throws Exception { JsonObject json = Ion.with(context).load("https://www.google.com/voice/sms/send/") .setHeader("Authorization", "GoogleLogin auth=" + authToken).setBodyParameter("phoneNumber", number) .setBodyParameter("sendErrorSms", "0").setBodyParameter("text", text) .setBodyParameter("_rnr_se", rnrse).asJsonObject().get(); if (!json.get("ok").getAsBoolean()) throw new Exception(json.toString()); } private void failVoice() { if (saveMessage) { Cursor query = context.getContentResolver().query(Uri.parse("content://sms/outbox"), null, null, null, null); // mark message as failed if (query.moveToFirst()) { String id = query.getString(query.getColumnIndex("_id")); ContentValues values = new ContentValues(); values.put("type", "5"); values.put("read", true); context.getContentResolver().update(Uri.parse("content://sms/outbox"), values, "_id=" + id, null); } query.close(); } context.sendBroadcast(new Intent(REFRESH)); context.sendBroadcast(new Intent(VOICE_FAILED)); } private void successVoice() { if (saveMessage) { Cursor query = context.getContentResolver().query(Uri.parse("content://sms/outbox"), null, null, null, null); // mark message as sent successfully if (query.moveToFirst()) { String id = query.getString(query.getColumnIndex("_id")); ContentValues values = new ContentValues(); values.put("type", "2"); values.put("read", true); context.getContentResolver().update(Uri.parse("content://sms/outbox"), values, "_id=" + id, null); } query.close(); } context.sendBroadcast(new Intent(REFRESH)); } private String fetchRnrSe(String authToken, Context context) throws ExecutionException, InterruptedException { JsonObject userInfo = Ion.with(context).load("https://www.google.com/voice/request/user") .setHeader("Authorization", "GoogleLogin auth=" + authToken).asJsonObject().get(); String rnrse = userInfo.get("r").getAsString(); try { TelephonyManager tm = (TelephonyManager) context.getSystemService(Activity.TELEPHONY_SERVICE); String number = tm.getLine1Number(); if (number != null) { JsonObject phones = userInfo.getAsJsonObject("phones"); for (Map.Entry<String, JsonElement> entry : phones.entrySet()) { JsonObject phone = entry.getValue().getAsJsonObject(); if (!PhoneNumberUtils.compare(number, phone.get("phoneNumber").getAsString())) continue; if (!phone.get("smsEnabled").getAsBoolean()) break; Ion.with(context).load("https://www.google.com/voice/settings/editForwardingSms/") .setHeader("Authorization", "GoogleLogin auth=" + authToken) .setBodyParameter("phoneId", entry.getKey()).setBodyParameter("enabled", "0") .setBodyParameter("_rnr_se", rnrse).asJsonObject(); break; } } } catch (Exception e) { } // broadcast so you can save it to your shared prefs or something so that it doesn't need to be retrieved every time Intent intent = new Intent(VOICE_TOKEN); intent.putExtra("_rnr_se", rnrse); context.sendBroadcast(intent); return rnrse; } private static Uri insert(Context context, String[] to, MMSPart[] parts, String subject) { try { Uri destUri = Uri.parse("content://mms"); Set<String> recipients = new HashSet<>(); recipients.addAll(Arrays.asList(to)); long thread_id = Utils.getOrCreateThreadId(context, recipients); // Create a dummy sms ContentValues dummyValues = new ContentValues(); dummyValues.put("thread_id", thread_id); dummyValues.put("body", " "); Uri dummySms = context.getContentResolver().insert(Uri.parse("content://sms/sent"), dummyValues); // Create a new message entry long now = System.currentTimeMillis(); ContentValues mmsValues = new ContentValues(); mmsValues.put("thread_id", thread_id); mmsValues.put("date", now / 1000L); mmsValues.put("msg_box", 4); //mmsValues.put("m_id", System.currentTimeMillis()); mmsValues.put("read", true); mmsValues.put("sub", subject != null ? subject : ""); mmsValues.put("sub_cs", 106); mmsValues.put("ct_t", "application/vnd.wap.multipart.related"); long imageBytes = 0; for (MMSPart part : parts) { imageBytes += part.Data.length; } mmsValues.put("exp", imageBytes); mmsValues.put("m_cls", "personal"); mmsValues.put("m_type", 128); // 132 (RETRIEVE CONF) 130 (NOTIF IND) 128 (SEND REQ) mmsValues.put("v", 19); mmsValues.put("pri", 129); mmsValues.put("tr_id", "T" + Long.toHexString(now)); mmsValues.put("resp_st", 128); // Insert message Uri res = context.getContentResolver().insert(destUri, mmsValues); String messageId = res.getLastPathSegment().trim(); // Create part for (MMSPart part : parts) { if (part.MimeType.startsWith("image")) { createPartImage(context, messageId, part.Data, part.MimeType); } else if (part.MimeType.startsWith("text")) { createPartText(context, messageId, new String(part.Data, "UTF-8")); } } // Create addresses for (String addr : to) { createAddr(context, messageId, addr); } //res = Uri.parse(destUri + "/" + messageId); // Delete dummy sms context.getContentResolver().delete(dummySms, null, null); return res; } catch (Exception e) { if (LOCAL_LOGV) Log.v(TAG, "still an error saving... :("); Log.e(TAG, "exception thrown", e); } return null; } // create the image part to be stored in database private static Uri createPartImage(Context context, String id, byte[] imageBytes, String mimeType) throws Exception { ContentValues mmsPartValue = new ContentValues(); mmsPartValue.put("mid", id); mmsPartValue.put("ct", mimeType); mmsPartValue.put("cid", "<" + System.currentTimeMillis() + ">"); Uri partUri = Uri.parse("content://mms/" + id + "/part"); Uri res = context.getContentResolver().insert(partUri, mmsPartValue); // Add data to part OutputStream os = context.getContentResolver().openOutputStream(res); ByteArrayInputStream is = new ByteArrayInputStream(imageBytes); byte[] buffer = new byte[256]; for (int len = 0; (len = is.read(buffer)) != -1;) { os.write(buffer, 0, len); } os.close(); is.close(); return res; } // create the text part to be stored in database private static Uri createPartText(Context context, String id, String text) throws Exception { ContentValues mmsPartValue = new ContentValues(); mmsPartValue.put("mid", id); mmsPartValue.put("ct", "text/plain"); mmsPartValue.put("cid", "<" + System.currentTimeMillis() + ">"); mmsPartValue.put("text", text); Uri partUri = Uri.parse("content://mms/" + id + "/part"); Uri res = context.getContentResolver().insert(partUri, mmsPartValue); return res; } // add address to the request private static Uri createAddr(Context context, String id, String addr) throws Exception { ContentValues addrValues = new ContentValues(); addrValues.put("address", addr); addrValues.put("charset", "106"); addrValues.put("type", 151); // TO Uri addrUri = Uri.parse("content://mms/" + id + "/addr"); Uri res = context.getContentResolver().insert(addrUri, addrValues); return res; } /** * A method for checking whether or not a certain message will be sent as mms depending on its contents and the settings * * @param message is the message that you are checking against * @return true if the message will be mms, otherwise false */ public boolean checkMMS(Message message) { return message.getImages().length != 0 || (message.getMedia().length != 0 && message.getMediaMimeType() != null) || (settings.getSendLongAsMms() && Utils.getNumPages(settings, message.getText()) > settings.getSendLongAsMmsAfter() && message.getType() != Message.TYPE_VOICE) || (message.getAddresses().length > 1 && settings.getGroup()) || message.getSubject() != null; } /** * @deprecated */ private void reinstateWifi() { try { context.unregisterReceiver(settings.discon); } catch (Exception f) { } WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); wifi.setWifiEnabled(false); wifi.setWifiEnabled(settings.currentWifiState); wifi.reconnect(); Utils.setMobileDataEnabled(context, settings.currentDataState); } /** * @deprecated */ private void revokeWifi(boolean saveState) { WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); if (saveState) { settings.currentWifi = wifi.getConnectionInfo(); settings.currentWifiState = wifi.isWifiEnabled(); wifi.disconnect(); settings.discon = new DisconnectWifi(); context.registerReceiver(settings.discon, new IntentFilter(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)); settings.currentDataState = Utils.isMobileDataEnabled(context); Utils.setMobileDataEnabled(context, true); } else { wifi.disconnect(); wifi.disconnect(); settings.discon = new DisconnectWifi(); context.registerReceiver(settings.discon, new IntentFilter(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION)); Utils.setMobileDataEnabled(context, true); } } /** * @deprecated */ private int beginMmsConnectivity() { if (LOCAL_LOGV) Log.v(TAG, "starting mms service"); return mConnMgr.startUsingNetworkFeature(ConnectivityManager.TYPE_MOBILE, "enableMMS"); } }