Change MMS network request pattern.

Currently we're flipping the radio in "MMS" mode, and connecting through
any proxies specified in the APN.  This always work, or at least doesn't
seem to work on Sprint, since the configured mms proxy rejects proxy
requests.

Instead we try the following in this order:

1) Connect over normal data connection directly to MMSC.
2) Connect over MMS radio connection to MMSC.
3) Connect over MMS radio connection with any configured proxy to MMSC.

Hopefully this doesn't fuck up shit on other unknown networks.

res/values/strings.xml

@@ -104,6 +104,11 @@
     <!-- KeyScanningActivity -->
     <string name="KeyScanningActivity_no_scanned_key_found_exclamation">No scanned key found!</string>
 
+    <!-- MmsDownloader -->
+    <string name="MmsDownloader_no_connectivity_available_for_mms_download_try_again_later">No connectivity available for MMS download, try again later...</string>
+    <string name="MmsDownloader_error_storing_mms">Error storing MMS!</string>
+    <string name="MmsDownloader_error_connecting_to_mms_provider">Error connecting to MMS provider...</string>  
+    
     <!-- PassphraseChangeActivity -->
     <string name="PassphraseChangeActivity_passphrases_dont_match_exclamation">Passphrases Don\'t Match!</string>
     <string name="PassphraseChangeActivity_incorrect_old_passphrase_exclamation">Incorrect old passphrase!</string>

src/org/thoughtcrime/securesms/mms/MmsCommunication.java

@@ -63,7 +63,8 @@ public class MmsCommunication {
     throw new ApnUnavailableException("No locally configured parameters available");
   }
 
-  protected static MmsConnectionParameters getMmsConnectionParameters(Context context, String apn)
+  protected static MmsConnectionParameters getMmsConnectionParameters(Context context, String apn,
+                                                                      boolean proxyIfPossible)
       throws ApnUnavailableException
   {
     Cursor cursor = null;
@@ -76,8 +77,13 @@ public class MmsCommunication {
 
       do {
         String mmsc  = cursor.getString(cursor.getColumnIndexOrThrow("mmsc"));
-        String proxy = cursor.getString(cursor.getColumnIndexOrThrow("mmsproxy"));
+        String proxy = null;
-        String port  = cursor.getString(cursor.getColumnIndexOrThrow("mmsport"));
+        String port  = null;
+
+        if (proxyIfPossible) {
+          proxy = cursor.getString(cursor.getColumnIndexOrThrow("mmsproxy"));
+          port  = cursor.getString(cursor.getColumnIndexOrThrow("mmsport"));
+        }
 
         if (mmsc != null && !mmsc.equals(""))
           return new MmsConnectionParameters(mmsc, proxy, port);
@@ -97,15 +103,29 @@ public class MmsCommunication {
     }
   }
 
-  protected static void checkRouteToHost(Context context, MmsConnectionParameters parameters, String url) throws IOException {
+  protected static void checkRouteToHost(Context context, MmsConnectionParameters parameters,
+                                         String url, boolean usingMmsRadio)
+    throws IOException
+  {
     if (parameters == null || !parameters.hasProxy())
-      checkRouteToHost(context, Uri.parse(url).getHost());
+      checkRouteToHost(context, Uri.parse(url).getHost(), usingMmsRadio);
     else
-      checkRouteToHost(context, parameters.getProxy());
+      checkRouteToHost(context, parameters.getProxy(), usingMmsRadio);
   }
 
-  private static void checkRouteToHost(Context context, String host) throws IOException {
+  private static void checkRouteToHost(Context context, String host, boolean usingMmsRadio)
+      throws IOException
+  {
     InetAddress inetAddress = InetAddress.getByName(host);
+
+    if (!usingMmsRadio) {
+      if (inetAddress.isSiteLocalAddress()) {
+        throw new IOException("RFC1918 address in non-MMS radio situation!");
+      }
+
+      return;
+    }
+
     byte[] ipAddressBytes       = inetAddress.getAddress();
     int ipAddress               = Conversions.byteArrayToIntLittleEndian(ipAddressBytes, 0);
     ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);

src/org/thoughtcrime/securesms/mms/MmsDownloadHelper.java

@@ -26,6 +26,9 @@ import org.apache.http.StatusLine;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.methods.HttpGet;
 
+import ws.com.google.android.mms.pdu.PduParser;
+import ws.com.google.android.mms.pdu.RetrieveConf;
+
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -46,15 +49,6 @@ public class MmsDownloadHelper extends MmsCommunication {
       request.setParams(client.getParams());
       request.addHeader("Accept", "*/*, application/vnd.wap.mms-message, application/vnd.wap.sic");
 
-//      java.util.logging.Logger.getLogger("org.apache.http.wire").setLevel(java.util.logging.Level.FINEST);
-//      java.util.logging.Logger.getLogger("org.apache.http.headers").setLevel(java.util.logging.Level.FINEST);
-//
-//      System.setProperty("org.apache.commons.logging.Log", "org.apache.commons.logging.impl.SimpleLog");
-//      System.setProperty("org.apache.commons.logging.simplelog.showdatetime", "true");
-//      System.setProperty("org.apache.commons.logging.simplelog.log.httpclient.wire", "debug");
-//      System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http", "debug");
-//      System.setProperty("org.apache.commons.logging.simplelog.log.org.apache.http.headers", "debug");
-
       HttpResponse response = client.execute(target, request);
       StatusLine status     = response.getStatusLine();
 
@@ -71,17 +65,29 @@ public class MmsDownloadHelper extends MmsCommunication {
     }
   }
 
-  public static byte[] retrieveMms(Context context, String url, String apn) throws IOException {
+  public static RetrieveConf retrieveMms(Context context, String url, String apn,
+                                         boolean usingMmsRadio, boolean proxyIfPossible)
+      throws IOException
+  {
     MmsConnectionParameters connectionParameters;
 
     try {
-      connectionParameters = getMmsConnectionParameters(context, apn);
+      connectionParameters = getMmsConnectionParameters(context, apn, proxyIfPossible);
     } catch (ApnUnavailableException aue) {
       Log.w("MmsDownloadHelper", aue);
       connectionParameters = new MmsConnectionParameters(null, null, null);
     }
 
-    checkRouteToHost(context, connectionParameters, url);
+    checkRouteToHost(context, connectionParameters, url, usingMmsRadio);
-    return makeRequest(context, connectionParameters, url);
+
+    byte[] pdu = makeRequest(context, connectionParameters, url);
+
+    RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse();
+
+    if (retrieved == null) {
+      throw new IOException("Bad retrieved PDU");
+    }
+
+    return retrieved;
   }
 }

src/org/thoughtcrime/securesms/mms/MmsSendHelper.java

@@ -27,6 +27,9 @@ import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.entity.ByteArrayEntity;
 
+import ws.com.google.android.mms.pdu.PduParser;
+import ws.com.google.android.mms.pdu.SendConf;
+
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
@@ -66,12 +69,16 @@ public class MmsSendHelper extends MmsCommunication {
     }
   }
 
-  public static byte[] sendMms(Context context, byte[] mms, String apn) throws IOException {
+  public static SendConf sendMms(Context context, byte[] mms, String apn,
+                                 boolean usingMmsRadio, boolean useProxyIfAvailable)
+    throws IOException
+  {
     Log.w("MmsSender", "Sending MMS of length: " + mms.length);
     try {
-      MmsConnectionParameters parameters = getMmsConnectionParameters(context, apn);
+      MmsConnectionParameters parameters = getMmsConnectionParameters(context, apn, useProxyIfAvailable);
-      checkRouteToHost(context, parameters, parameters.getMmsc());
+      checkRouteToHost(context, parameters, parameters.getMmsc(), usingMmsRadio);
-      return makePost(context, parameters, mms);
+      byte[] response = makePost(context, parameters, mms);
+      return (SendConf) new PduParser(response).parse();
     } catch (ApnUnavailableException aue) {
       Log.w("MmsSender", aue);
       throw new IOException("Failed to get MMSC information...");

src/org/thoughtcrime/securesms/service/MmsDownloader.java

@@ -20,6 +20,7 @@ import android.content.Context;
 import android.content.Intent;
 import android.util.Log;
 
+import org.thoughtcrime.securesms.R;
 import org.thoughtcrime.securesms.crypto.DecryptingQueue;
 import org.thoughtcrime.securesms.crypto.MasterSecret;
 import org.thoughtcrime.securesms.database.DatabaseFactory;
@@ -28,7 +29,6 @@ import org.thoughtcrime.securesms.mms.MmsDownloadHelper;
 import org.thoughtcrime.securesms.protocol.WirePrefix;
 
 import ws.com.google.android.mms.MmsException;
-import ws.com.google.android.mms.pdu.PduParser;
 import ws.com.google.android.mms.pdu.RetrieveConf;
 
 import java.io.IOException;
@@ -44,73 +44,105 @@ public class MmsDownloader extends MmscProcessor {
     this.toastHandler = toastHandler;
   }
 
-  private void handleDownloadMms(DownloadItem item) {
+  public void process(MasterSecret masterSecret, Intent intent) {
+    if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_ACTION)) {
+      DownloadItem item = new DownloadItem(masterSecret, false, false,
+                                           intent.getLongExtra("message_id", -1),
+                                           intent.getLongExtra("thread_id", -1),
+                                           intent.getStringExtra("content_location"),
+                                           intent.getByteArrayExtra("transaction_id"));
+
+      handleDownloadMmsAction(item);
+    } else if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_CONNECTIVITY_ACTION)) {
+      handleConnectivityChange();
+    }
+  }
+
+  private void handleDownloadMmsAction(DownloadItem item) {
     if (!isConnectivityPossible()) {
+      Log.w("MmsDownloader", "No MMS connectivity available!");
       DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY);
-      toastHandler.makeToast("No connectivity available for MMS download, try again later...");
+      toastHandler.makeToast(context.getString(R.string.MmsDownloader_no_connectivity_available_for_mms_download_try_again_later));
-      Log.w("MmsDownloadService", "Unable to download MMS, please try again later.");
+      return;
-    } else {
+    }
+
     DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_CONNECTING);
+
+    if (item.useMmsRadioMode()) downloadMmsWithRadioChange(item);
+    else                        downloadMms(item);
+  }
+
+  private void downloadMmsWithRadioChange(DownloadItem item) {
+    Log.w("MmsDownloader", "Handling MMS download with radio change...");
     pendingMessages.add(item);
     issueConnectivityRequest();
   }
-  }
 
-  private void handleDownloadMmsContinued(DownloadItem item) {
+  private void downloadMms(DownloadItem item) {
-    Log.w("MmsDownloadService", "Handling MMS download continuation...");
+    Log.w("MmsDownloadService", "Handling actual MMS download...");
     MmsDatabase mmsDatabase;
 
-    if (item.getMasterSecret() == null)
+    if (item.getMasterSecret() == null) {
       mmsDatabase = DatabaseFactory.getMmsDatabase(context);
-    else
+    } else {
       mmsDatabase = DatabaseFactory.getEncryptingMmsDatabase(context, item.getMasterSecret());
-
+    }
 
     try {
-      byte[] pdu             = MmsDownloadHelper.retrieveMms(context, item.getContentLocation(),
+      RetrieveConf retrieved = MmsDownloadHelper.retrieveMms(context, item.getContentLocation(),
-                                                             getApnInformation());
+                                                             getApnInformation(),
-      RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse();
+                                                             item.useMmsRadioMode(),
-
+                                                             item.proxyRequestIfPossible());
-      if (retrieved == null)
-        throw new IOException("Bad retrieved PDU");
 
       for (int i=0;i<retrieved.getBody().getPartsNum();i++) {
-        Log.w("MmsDownloader", "Sent MMS part of content-type: " +
+        Log.w("MmsDownloader", "Got MMS part of content-type: " +
               new String(retrieved.getBody().getPart(i).getContentType()));
       }
 
+      storeRetrievedMms(mmsDatabase, item, retrieved);
+
+      //			NotifyRespInd notifyResponse = new NotifyRespInd(PduHeaders.CURRENT_MMS_VERSION, item.getTransactionId(), PduHeaders.STATUS_RETRIEVED);
+      //			MmsSendHelper.sendMms(context, new PduComposer(context, notifyResponse).make());
+
+    } catch (IOException e) {
+      Log.w("MmsDownloader", e);
+      if (!item.useMmsRadioMode() && !item.proxyRequestIfPossible()) {
+        scheduleDownloadWithRadioMode(item);
+      } else if (!item.proxyRequestIfPossible()) {
+        scheduleDownloadWithRadioModeAndProxy(item);
+      } else {
+        DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_SOFT_FAILURE);
+        toastHandler.makeToast(context.getString(R.string.MmsDownloader_error_connecting_to_mms_provider));
+      }
+    } catch (MmsException e) {
+      Log.w("MmsDownloader", e);
+      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_HARD_FAILURE);
+      toastHandler.makeToast(context.getString(R.string.MmsDownloader_error_storing_mms));
+    }
+  }
+
+  private void storeRetrievedMms(MmsDatabase mmsDatabase, DownloadItem item, RetrieveConf retrieved)
+      throws MmsException
+  {
     if (retrieved.getSubject() != null && WirePrefix.isEncryptedMmsSubject(retrieved.getSubject().getString())) {
       long messageId = mmsDatabase.insertSecureMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
+
       if (item.getMasterSecret() != null)
         DecryptingQueue.scheduleDecryption(context, item.getMasterSecret(), messageId, item.getThreadId(), retrieved);
+
     } else {
       mmsDatabase.insertMessageReceived(retrieved, item.getContentLocation(), item.getThreadId());
     }
 
     mmsDatabase.delete(item.getMessageId());
-
-      //			NotifyRespInd notifyResponse = new NotifyRespInd(PduHeaders.CURRENT_MMS_VERSION, item.getTransactionId(), PduHeaders.STATUS_RETRIEVED);
-      //			MmsSendHelper.sendMms(context, new PduComposer(context, notifyResponse).make());
-
-      if (this.pendingMessages.isEmpty())
-        finishConnectivity();
-
-    } catch (IOException e) {
-      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_SOFT_FAILURE);
-      toastHandler.makeToast("Error connecting to MMS provider...");
-      Log.w("MmsDownloader", e);
-    } catch (MmsException e) {
-      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_HARD_FAILURE);
-      toastHandler.makeToast("Error downloading MMS!");
-      Log.w("MmsDownloader", e);
-    }
   }
 
   protected void handleConnectivityChange() {
     if (!isConnected()) {
       if (!isConnectivityPossible() && !pendingMessages.isEmpty()) {
         DatabaseFactory.getMmsDatabase(context).markDownloadState(pendingMessages.remove().getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY);
-        toastHandler.makeToast("No connectivity available for MMS download, try again later...");
+        toastHandler.makeToast(context
+            .getString(R.string.MmsDownloader_no_connectivity_available_for_mms_download_try_again_later));
         Log.w("MmsDownloadService", "Unable to download MMS, please try again later.");
         finishConnectivity();
       }
@@ -118,37 +150,45 @@ public class MmsDownloader extends MmscProcessor {
       return;
     }
 
-    if   (!pendingMessages.isEmpty()) handleDownloadMmsContinued(pendingMessages.remove());
+    for (DownloadItem item : pendingMessages) {
-    else                              finishConnectivity();
+      downloadMms(item);
     }
 
-  public void process(MasterSecret masterSecret, Intent intent) {
+    pendingMessages.clear();
-    if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_ACTION)) {
+    finishConnectivity();
-      DownloadItem item = new DownloadItem(intent.getLongExtra("message_id", -1),
-                                           intent.getLongExtra("thread_id", -1),
-                                           intent.getStringExtra("content_location"),
-                                           intent.getByteArrayExtra("transaction_id"),
-                                           masterSecret);
-
-      handleDownloadMms(item);
-    } else if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_CONNECTIVITY_ACTION)) {
-      handleConnectivityChange();
-    }
   }
 
 
-  private class DownloadItem {
+  private void scheduleDownloadWithRadioMode(DownloadItem item) {
+    item.mmsRadioMode = true;
+    handleDownloadMmsAction(item);
+  }
+
+  private void scheduleDownloadWithRadioModeAndProxy(DownloadItem item) {
+    item.mmsRadioMode    = true;
+    item.proxyIfPossible = true;
+    handleDownloadMmsAction(item);
+  }
+
+  private static class DownloadItem {
+    private final MasterSecret masterSecret;
+    private boolean            mmsRadioMode;
+    private boolean            proxyIfPossible;
+
     private long threadId;
     private long messageId;
     private byte[] transactionId;
     private String contentLocation;
-    private MasterSecret masterSecret;
 
-    public DownloadItem(long messageId, long threadId, String contentLocation, byte[] transactionId, MasterSecret masterSecret) {
+    public DownloadItem(MasterSecret masterSecret, boolean mmsRadioMode, boolean proxyIfPossible,
+                        long messageId, long threadId, String contentLocation, byte[] transactionId)
+    {
+      this.masterSecret    = masterSecret;
+      this.mmsRadioMode    = mmsRadioMode;
+      this.proxyIfPossible = proxyIfPossible;
       this.threadId        = threadId;
       this.messageId       = messageId;
       this.contentLocation = contentLocation;
-      this.masterSecret    = masterSecret;
       this.transactionId   = transactionId;
     }
 
@@ -171,6 +211,14 @@ public class MmsDownloader extends MmscProcessor {
     public MasterSecret getMasterSecret() {
       return masterSecret;
     }
+
+    public boolean proxyRequestIfPossible() {
+      return proxyIfPossible;
+    }
+
+    public boolean useMmsRadioMode() {
+      return mmsRadioMode;
+    }
   }
 
   @Override

src/org/thoughtcrime/securesms/service/MmsSender.java

@@ -18,7 +18,6 @@ package org.thoughtcrime.securesms.service;
 
 import android.content.Context;
 import android.content.Intent;
-import android.os.Handler;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 
@@ -33,6 +32,7 @@ import org.thoughtcrime.securesms.notifications.MessageNotifier;
 import org.thoughtcrime.securesms.protocol.WirePrefix;
 import org.thoughtcrime.securesms.recipients.Recipient;
 import org.thoughtcrime.securesms.recipients.Recipients;
+import org.thoughtcrime.securesms.service.SendReceiveService.ToastHandler;
 import org.thoughtcrime.securesms.util.Hex;
 
 import ws.com.google.android.mms.ContentType;
@@ -41,21 +41,22 @@ import ws.com.google.android.mms.pdu.EncodedStringValue;
 import ws.com.google.android.mms.pdu.PduBody;
 import ws.com.google.android.mms.pdu.PduComposer;
 import ws.com.google.android.mms.pdu.PduHeaders;
-import ws.com.google.android.mms.pdu.PduParser;
 import ws.com.google.android.mms.pdu.PduPart;
 import ws.com.google.android.mms.pdu.SendConf;
 import ws.com.google.android.mms.pdu.SendReq;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
+import java.util.List;
 
 public class MmsSender extends MmscProcessor {
 
-  private final LinkedList<SendReq[]> pendingMessages = new LinkedList<SendReq[]>();
+  private final LinkedList<SendItem> pendingMessages = new LinkedList<SendItem>();
-  private final Handler toastHandler;
+  private final ToastHandler toastHandler;
 
-  public MmsSender(Context context, Handler toastHandler) {
+  public MmsSender(Context context, ToastHandler toastHandler) {
     super(context);
     this.toastHandler = toastHandler;
   }
@@ -66,49 +67,137 @@ public class MmsSender extends MmscProcessor {
       MmsDatabase database = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret);
 
       try {
-        SendReq[] sendRequests;
+        List<SendReq> sendRequests = getOutgoingMessages(masterSecret, messageId);
 
-        if (messageId == -1) {
+        for (SendReq sendRequest : sendRequests) {
-          sendRequests = database.getOutgoingMessages();
+          handleSendMmsAction(new SendItem(masterSecret, sendRequest, messageId != -1, false, false));
-        } else {
-          sendRequests    = new SendReq[1];
-          sendRequests[0] = database.getSendRequest(messageId);
         }
 
-        if (sendRequests != null && sendRequests.length > 0)
-          handleSendMms(sendRequests, messageId != -1);
-
       } catch (MmsException me) {
         Log.w("MmsSender", me);
         if (messageId != -1)
           database.markAsSentFailed(messageId);
         }
     } else if (intent.getAction().equals(SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION)) {
-      handleConnectivityChange(masterSecret);
+      handleConnectivityChange();
     }
   }
 
-  protected void handleConnectivityChange(MasterSecret masterSecret) {
+  private void handleSendMmsAction(SendItem item) {
-    if (!isConnected())
-      return;
-
-    if   (!pendingMessages.isEmpty()) handleSendMmsContinued(masterSecret, pendingMessages.remove());
-    else                              finishConnectivity();
-  }
-
-  private void handleSendMms(SendReq[] sendRequests, boolean targeted) {
     if (!isConnectivityPossible()) {
-      if (targeted) {
+      if (item.targeted) {
         toastHandler
           .obtainMessage(0, context.getString(R.string.MmsSender_currently_unable_to_send_your_mms_message))
           .sendToTarget();
       }
-//      for (int i=0;i<sendRequests.length;i++)
+
-//        DatabaseFactory.getMmsDatabase(context).markAsSentFailed(sendRequests[i].getDatabaseMessageId());
+      return;
-    } else {
+    }
-      pendingMessages.add(sendRequests);
+
+    if (item.useMmsRadio) sendMmsMessageWithRadioChange(item);
+    else                  sendMmsMessage(item);
+  }
+
+  private void sendMmsMessageWithRadioChange(SendItem item) {
+    Log.w("MmsSender", "Sending MMS with radio change..");
+    pendingMessages.add(item);
     issueConnectivityRequest();
   }
+
+  private void sendMmsMessage(SendItem item) {
+    Log.w("MmsSender", "Sending MMS SendItem...");
+    MmsDatabase db  = DatabaseFactory.getEncryptingMmsDatabase(context, item.masterSecret);
+    String number   = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number();
+    long messageId  = item.request.getDatabaseMessageId();
+    long messageBox = item.request.getDatabaseMessageBox();
+    SendReq request = item.request;
+
+
+    if (MmsDatabase.Types.isSecureMmsBox(messageBox)) {
+      request = getEncryptedMms(item.masterSecret, request, messageId);
+    }
+
+    if (number != null && number.trim().length() != 0) {
+      request.setFrom(new EncodedStringValue(number));
+    }
+
+    try {
+      SendConf conf = MmsSendHelper.sendMms(context, new PduComposer(context, request).make(),
+                                            getApnInformation(), item.useMmsRadio, item.useProxyIfAvailable);
+
+      for (int i=0;i<request.getBody().getPartsNum();i++) {
+        Log.w("MmsSender", "Sent MMS part of content-type: " + new String(request.getBody().getPart(i).getContentType()));
+      }
+
+      long threadId         = DatabaseFactory.getMmsDatabase(context).getThreadIdForMessage(messageId);
+      Recipients recipients = DatabaseFactory.getThreadDatabase(context).getRecipientsForThreadId(context, threadId);
+
+      if (conf == null) {
+        db.markAsSentFailed(messageId);
+        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
+        Log.w("MmsSender", "No M-Send.conf received in response to send.");
+        return;
+      } else if (conf.getResponseStatus() != PduHeaders.RESPONSE_STATUS_OK) {
+        Log.w("MmsSender", "Got bad response: " + conf.getResponseStatus());
+        db.updateResponseStatus(messageId, conf.getResponseStatus());
+        db.markAsSentFailed(messageId);
+        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
+        return;
+      } else if (isInconsistentResponse(request, conf)) {
+        db.markAsSentFailed(messageId);
+        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
+        Log.w("MmsSender", "Got a response for the wrong transaction?");
+        return;
+      } else {
+        Log.w("MmsSender", "Successful send! " + messageId);
+        if (!MmsDatabase.Types.isSecureMmsBox(messageBox)) {
+          db.markAsSent(messageId, conf.getMessageId(), conf.getResponseStatus());
+        } else {
+          db.markAsSecureSent(messageId, conf.getMessageId(), conf.getResponseStatus());
+        }
+      }
+    } catch (IOException ioe) {
+      Log.w("MmsSender", ioe);
+      if      (!item.useMmsRadio)         scheduleSendWithMmsRadio(item);
+      else if (!item.useProxyIfAvailable) scheduleSendWithMmsRadioAndProxy(item);
+      else                                db.markAsSentFailed(messageId);
+    }
+  }
+
+  private List<SendReq> getOutgoingMessages(MasterSecret masterSecret, long messageId)
+      throws MmsException
+  {
+    MmsDatabase database = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret);
+    List<SendReq> sendRequests;
+
+    if (messageId == -1) {
+      sendRequests = Arrays.asList(database.getOutgoingMessages());
+    } else {
+      sendRequests    = new ArrayList<SendReq>(1);
+      sendRequests.add(database.getSendRequest(messageId));
+    }
+
+    return sendRequests;
+  }
+
+  protected void handleConnectivityChange() {
+    if (!isConnected()) {
+      if (!isConnectivityPossible() && !pendingMessages.isEmpty()) {
+        DatabaseFactory.getMmsDatabase(context).markAsSentFailed(pendingMessages.remove().request.getDatabaseMessageId());
+        toastHandler.makeToast(context.getString(R.string.MmsSender_currently_unable_to_send_your_mms_message));
+        Log.w("MmsSender", "Unable to send MMS.");
+        finishConnectivity();
+      }
+
+      return;
+    }
+
+    for (SendItem item : pendingMessages) {
+      sendMmsMessage(item);
+    }
+
+    pendingMessages.clear();
+    finishConnectivity();
   }
 
   private boolean isInconsistentResponse(SendReq send, SendConf response) {
@@ -145,69 +234,15 @@ public class MmsSender extends MmscProcessor {
     return pdu;
   }
 
-  private void sendMms(MmsDatabase db, SendReq pdu, String number, long messageId, boolean secure) {
+  private void scheduleSendWithMmsRadioAndProxy(SendItem item) {
-    try {
+    item.useMmsRadio = true;
-      if (number != null && number.trim().length() != 0)
+    handleSendMmsAction(item);
-        pdu.setFrom(new EncodedStringValue(number));
-
-      byte[] response = MmsSendHelper.sendMms(context, new PduComposer(context, pdu).make(), getApnInformation());
-      SendConf conf   = (SendConf) new PduParser(response).parse();
-
-      for (int i=0;i<pdu.getBody().getPartsNum();i++) {
-        Log.w("MmsSender", "Sent MMS part of content-type: " + new String(pdu.getBody().getPart(i).getContentType()));
   }
 
-      long threadId         = DatabaseFactory.getMmsDatabase(context).getThreadIdForMessage(messageId);
+  private void scheduleSendWithMmsRadio(SendItem item) {
-      Recipients recipients = DatabaseFactory.getThreadDatabase(context).getRecipientsForThreadId(context, threadId);
+    item.useMmsRadio         = true;
-
+    item.useProxyIfAvailable = true;
-      if (conf == null) {
+    handleSendMmsAction(item);
-        db.markAsSentFailed(messageId);
-        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
-        Log.w("MmsSender", "No M-Send.conf received in response to send.");
-        return;
-      } else if (conf.getResponseStatus() != PduHeaders.RESPONSE_STATUS_OK) {
-        Log.w("MmsSender", "Got bad response: " + conf.getResponseStatus());
-        db.updateResponseStatus(messageId, conf.getResponseStatus());
-        db.markAsSentFailed(messageId);
-        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
-        return;
-      } else if (isInconsistentResponse(pdu, conf)) {
-        db.markAsSentFailed(messageId);
-        MessageNotifier.notifyMessageDeliveryFailed(context, recipients, threadId);
-        Log.w("MmsSender", "Got a response for the wrong transaction?");
-        return;
-      } else {
-        Log.w("MmsSender", "Successful send! " + messageId);
-        if (!secure)
-          db.markAsSent(messageId, conf.getMessageId(), conf.getResponseStatus());
-        else
-          db.markAsSecureSent(messageId, conf.getMessageId(), conf.getResponseStatus());
-        }
-    } catch (IOException ioe) {
-      Log.w("MmsSender", ioe);
-      db.markAsSentFailed(messageId);
-    }
-  }
-
-  private void handleSendMmsContinued(MasterSecret masterSecret, SendReq[] requests) {
-    Log.w("MmsSenderService", "Handling MMS send continuation...");
-
-    MmsDatabase db = DatabaseFactory.getEncryptingMmsDatabase(context, masterSecret);
-    String number  = ((TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE)).getLine1Number();
-
-    for (int i=0;i<requests.length;i++) {
-      SendReq request = requests[i];
-      long messageId  = request.getDatabaseMessageId();
-      long messageBox = request.getDatabaseMessageBox();
-
-      if (MmsDatabase.Types.isSecureMmsBox(messageBox))
-        request = getEncryptedMms(masterSecret, request, messageId);
-
-      sendMms(db, request, number, messageId, MmsDatabase.Types.isSecureMmsBox(messageBox));
-    }
-
-    if (this.pendingMessages.isEmpty())
-      finishConnectivity();
   }
 
   @Override
@@ -215,4 +250,24 @@ public class MmsSender extends MmscProcessor {
     return SendReceiveService.SEND_MMS_CONNECTIVITY_ACTION;
   }
 
+  private static class SendItem {
+    private final MasterSecret masterSecret;
+
+    private boolean useMmsRadio;
+    private boolean useProxyIfAvailable;
+    private SendReq request;
+    private boolean targeted;
+
+    public SendItem(MasterSecret masterSecret, SendReq request,
+                    boolean targeted, boolean useMmsRadio,
+                    boolean useProxyIfAvailable)
+    {
+      this.masterSecret        = masterSecret;
+      this.request             = request;
+      this.targeted            = targeted;
+      this.useMmsRadio         = useMmsRadio;
+      this.useProxyIfAvailable = useProxyIfAvailable;
+    }
+  }
+
 }