diff --git a/res/values/strings.xml b/res/values/strings.xml
index 48a2d8eadb..eacd477392 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -103,6 +103,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>
diff --git a/src/org/thoughtcrime/securesms/mms/MmsCommunication.java b/src/org/thoughtcrime/securesms/mms/MmsCommunication.java
index da150c6352..4174ff34e0 100644
--- a/src/org/thoughtcrime/securesms/mms/MmsCommunication.java
+++ b/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 port  = cursor.getString(cursor.getColumnIndexOrThrow("mmsport"));
+        String proxy = null;
+        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 {
-    InetAddress inetAddress     = InetAddress.getByName(host);
+  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);
diff --git a/src/org/thoughtcrime/securesms/mms/MmsDownloadHelper.java b/src/org/thoughtcrime/securesms/mms/MmsDownloadHelper.java
index 0e380a911b..c32227cbb5 100644
--- a/src/org/thoughtcrime/securesms/mms/MmsDownloadHelper.java
+++ b/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);
-    return makeRequest(context, connectionParameters, url);
+    checkRouteToHost(context, connectionParameters, url, usingMmsRadio);
+
+    byte[] pdu = makeRequest(context, connectionParameters, url);
+
+    RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse();
+
+    if (retrieved == null) {
+      throw new IOException("Bad retrieved PDU");
+    }
+
+    return retrieved;
   }
 }
diff --git a/src/org/thoughtcrime/securesms/mms/MmsSendHelper.java b/src/org/thoughtcrime/securesms/mms/MmsSendHelper.java
index 8197629365..225b61f671 100644
--- a/src/org/thoughtcrime/securesms/mms/MmsSendHelper.java
+++ b/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);
-      checkRouteToHost(context, parameters, parameters.getMmsc());
-      return makePost(context, parameters, mms);
+      MmsConnectionParameters parameters = getMmsConnectionParameters(context, apn, useProxyIfAvailable);
+      checkRouteToHost(context, parameters, parameters.getMmsc(), usingMmsRadio);
+      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...");
diff --git a/src/org/thoughtcrime/securesms/service/MmsDownloader.java b/src/org/thoughtcrime/securesms/service/MmsDownloader.java
index ef9981ed78..668831c420 100644
--- a/src/org/thoughtcrime/securesms/service/MmsDownloader.java
+++ b/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) {
-    if (!isConnectivityPossible()) {
-      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_NO_CONNECTIVITY);
-      toastHandler.makeToast("No connectivity available for MMS download, try again later...");
-      Log.w("MmsDownloadService", "Unable to download MMS, please try again later.");
-    } else {
-      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_CONNECTING);
-      pendingMessages.add(item);
-      issueConnectivityRequest();
+  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 handleDownloadMmsContinued(DownloadItem item) {
-    Log.w("MmsDownloadService", "Handling MMS download continuation...");
+  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(context.getString(R.string.MmsDownloader_no_connectivity_available_for_mms_download_try_again_later));
+      return;
+    }
+
+    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 downloadMms(DownloadItem item) {
+    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(),
-                                                             getApnInformation());
-      RetrieveConf retrieved = (RetrieveConf)new PduParser(pdu).parse();
-
-      if (retrieved == null)
-        throw new IOException("Bad retrieved PDU");
+      RetrieveConf retrieved = MmsDownloadHelper.retrieveMms(context, item.getContentLocation(),
+                                                             getApnInformation(),
+                                                             item.useMmsRadioMode(),
+                                                             item.proxyRequestIfPossible());
 
       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()));
       }
 
-      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());
+      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());
 
-      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);
+      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) {
-      DatabaseFactory.getMmsDatabase(context).markDownloadState(item.getMessageId(), MmsDatabase.Types.DOWNLOAD_HARD_FAILURE);
-      toastHandler.makeToast("Error downloading MMS!");
       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());
+  }
+
   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());
-    else                              finishConnectivity();
-  }
-
-  public void process(MasterSecret masterSecret, Intent intent) {
-    if (intent.getAction().equals(SendReceiveService.DOWNLOAD_MMS_ACTION)) {
-      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();
+    for (DownloadItem item : pendingMessages) {
+      downloadMms(item);
     }
+
+    pendingMessages.clear();
+    finishConnectivity();
   }
 
 
-  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
diff --git a/src/org/thoughtcrime/securesms/service/MmsSender.java b/src/org/thoughtcrime/securesms/service/MmsSender.java
index 5a13f76a4e..1aab057898 100644
--- a/src/org/thoughtcrime/securesms/service/MmsSender.java
+++ b/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 Handler toastHandler;
+  private final LinkedList<SendItem> pendingMessages = new LinkedList<SendItem>();
+  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) {
-          sendRequests = database.getOutgoingMessages();
-        } else {
-          sendRequests    = new SendReq[1];
-          sendRequests[0] = database.getSendRequest(messageId);
+        for (SendReq sendRequest : sendRequests) {
+          handleSendMmsAction(new SendItem(masterSecret, sendRequest, messageId != -1, false, false));
         }
 
-        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) {
-    if (!isConnected())
-      return;
-
-    if   (!pendingMessages.isEmpty()) handleSendMmsContinued(masterSecret, pendingMessages.remove());
-    else                              finishConnectivity();
-  }
-
-  private void handleSendMms(SendReq[] sendRequests, boolean targeted) {
+  private void handleSendMmsAction(SendItem item) {
     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());
-    } else {
-      pendingMessages.add(sendRequests);
-      issueConnectivityRequest();
+
+      return;
     }
+
+    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) {
-    try {
-      if (number != null && number.trim().length() != 0)
-        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);
-      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(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 scheduleSendWithMmsRadioAndProxy(SendItem item) {
+    item.useMmsRadio = true;
+    handleSendMmsAction(item);
   }
 
-  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();
+  private void scheduleSendWithMmsRadio(SendItem item) {
+    item.useMmsRadio         = true;
+    item.useProxyIfAvailable = true;
+    handleSendMmsAction(item);
   }
 
   @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;
+    }
+  }
+
 }