src/android/support/v7/mms/MmsService.java - platform/packages/apps/Messaging - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * 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 android.support.v7.mms;

 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.PowerManager;
 import android.os.Process;
 import android.telephony.SmsManager;
 import android.util.Log;

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.RejectedExecutionException;

 /**
  * Service to execute MMS requests using deprecated legacy APIs on older platform (prior to L)
  */
 public class MmsService extends Service {
     static final String TAG = "MmsLib";

     //The default number of threads allowed to run MMS requests
     private static final int DEFAULT_THREAD_POOL_SIZE = 4;
     // Delay before stopping the service
     private static final int SERVICE_STOP_DELAY_MILLIS = 2000;

     private static final String EXTRA_REQUEST = "request";
     private static final String EXTRA_MYPID = "mypid";

     private static final String WAKELOCK_ID = "mmslib_wakelock";

     /**
      * Thread pool size for each request queue
      */
     private static volatile int sThreadPoolSize = DEFAULT_THREAD_POOL_SIZE;

     /**
      * Optional wake lock to use
      */
     private static volatile boolean sUseWakeLock = true;
     private static volatile PowerManager.WakeLock sWakeLock = null;
     private static final Object sWakeLockLock = new Object();

     /**
      * Carrier configuration values loader
      */
     private static volatile CarrierConfigValuesLoader sCarrierConfigValuesLoader = null;

     /**
      * APN loader
      */
     private static volatile ApnSettingsLoader sApnSettingsLoader = null;

     /**
      * UserAgent and UA Prof URL loader
      */
     private static volatile UserAgentInfoLoader sUserAgentInfoLoader = null;

     /**
      * Set the size of thread pool for request execution.
      * Default is DEFAULT_THREAD_POOL_SIZE
      *
      * @param size thread pool size
      */
     static void setThreadPoolSize(final int size) {
         sThreadPoolSize = size;
     }

     /**
      * Set whether to use wake lock
      *
      * @param useWakeLock true to use wake lock, false otherwise
      */
     static void setUseWakeLock(final boolean useWakeLock) {
         sUseWakeLock = useWakeLock;
     }

     /**
      * Set the optional carrier config values
      *
      * @param loader the carrier config values loader
      */
     static void setCarrierConfigValuesLoader(final CarrierConfigValuesLoader loader) {
         sCarrierConfigValuesLoader = loader;
     }

     /**
      * Get the current carrier config values loader
      *
      * @return the carrier config values loader currently set
      */
     static CarrierConfigValuesLoader getCarrierConfigValuesLoader() {
         return sCarrierConfigValuesLoader;
     }

     /**
      * Set APN settings loader
      *
      * @param loader the APN settings loader
      */
     static void setApnSettingsLoader(final ApnSettingsLoader loader) {
         sApnSettingsLoader = loader;
     }

     /**
      * Get the current APN settings loader
      *
      * @return the APN settings loader currently set
      */
     static ApnSettingsLoader getApnSettingsLoader() {
         return sApnSettingsLoader;
     }

     /**
      * Set user agent info loader
      *
      * @param loader the user agent info loader
      */
     static void setUserAgentInfoLoader(final UserAgentInfoLoader loader) {
         sUserAgentInfoLoader = loader;
     }

     /**
      * Get the current user agent info loader
      *
      * @return the user agent info loader currently set
      */
     static UserAgentInfoLoader getUserAgentInfoLoader() {
         return sUserAgentInfoLoader;
     }

     /**
      * Make sure loaders are not null. Set to default if that's the case
      *
      * @param context the Context to use
      */
     private static void ensureLoaders(final Context context) {
         if (sUserAgentInfoLoader == null) {
             sUserAgentInfoLoader = new DefaultUserAgentInfoLoader(context);
         }
         if (sCarrierConfigValuesLoader == null) {
             sCarrierConfigValuesLoader = new DefaultCarrierConfigValuesLoader(context);
         }
         if (sApnSettingsLoader == null) {
             sApnSettingsLoader = new DefaultApnSettingsLoader(context);
         }
     }

     /**
      * Acquire the wake lock
      *
      * @param context the context to use
      */
     private static void acquireWakeLock(final Context context) {
         synchronized (sWakeLockLock) {
             if (sWakeLock == null) {
                 final PowerManager pm =
                         (PowerManager) context.getSystemService(Context.POWER_SERVICE);
                 sWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_ID);
             }
             sWakeLock.acquire();
         }
     }

     /**
      * Release the wake lock
      */
     private static void releaseWakeLock() {
         boolean releasedEmptyWakeLock = false;
         synchronized (sWakeLockLock) {
             if (sWakeLock != null) {
                 sWakeLock.release();
             } else {
                 releasedEmptyWakeLock = true;
             }
         }
         if (releasedEmptyWakeLock) {
             Log.w(TAG, "Releasing empty wake lock");
         }
     }

     /**
      * Check if wake lock is not held (e.g. when service stops)
      */
     private static void verifyWakeLockNotHeld() {
         boolean wakeLockHeld = false;
         synchronized (sWakeLockLock) {
             wakeLockHeld = sWakeLock != null && sWakeLock.isHeld();
         }
         if (wakeLockHeld) {
             Log.e(TAG, "Wake lock still held!");
         }
     }

     // Remember my PID to discard restarted intent
     private static volatile int sMyPid = -1;

     /**
      * Get the current PID
      *
      * @return the current PID
      */
     private static int getMyPid() {
         if (sMyPid < 0) {
             sMyPid = Process.myPid();
         }
         return sMyPid;
     }

     /**
      * Check if the intent is coming from this process
      *
      * @param intent the incoming intent for the service
      * @return true if the intent is from the current process
      */
     private static boolean fromThisProcess(final Intent intent) {
         final int pid = intent.getIntExtra(EXTRA_MYPID, -1);
         return pid == getMyPid();
     }

     // Request execution thread pools. One thread pool for sending and one for downloading.
     // The size of the thread pool controls the parallelism of request execution.
     // See {@link setThreadPoolSize}
     private ExecutorService[] mExecutors = new ExecutorService[2];

     // Active request count
     private int mActiveRequestCount;
     // The latest intent startId, used for safely stopping service
     private int mLastStartId;

     private MmsNetworkManager mNetworkManager;

     // Handler for scheduling service stop
     private final Handler mHandler = new Handler();
     // Service stop task
     private final Runnable mServiceStopRunnable = new Runnable() {
         @Override
         public void run() {
             tryStopService();
         }
     };

     /**
      * Start the service with a request
      *
      * @param context the Context to use
      * @param request the request to start
      */
     public static void startRequest(final Context context, final MmsRequest request) {
         final boolean useWakeLock = sUseWakeLock;
         request.setUseWakeLock(useWakeLock);
         final Intent intent = new Intent(context, MmsService.class);
         intent.putExtra(EXTRA_REQUEST, request);
         intent.putExtra(EXTRA_MYPID, getMyPid());
         if (useWakeLock) {
             acquireWakeLock(context);
         }
         if (context.startService(intent) == null) {
             if (useWakeLock) {
                 releaseWakeLock();
             }
         }
     }

     @Override
     public void onCreate() {
         super.onCreate();

         ensureLoaders(this);

         for (int i = 0; i < mExecutors.length; i++) {
             mExecutors[i] = Executors.newFixedThreadPool(sThreadPoolSize);
         }

         mNetworkManager = new MmsNetworkManager(this);

         synchronized (this) {
             mActiveRequestCount = 0;
             mLastStartId = -1;
         }
     }

     @Override
     public void onDestroy() {
         super.onDestroy();

         for (ExecutorService executor : mExecutors) {
             executor.shutdown();
         }
     }

     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         // Always remember the latest startId for use when we try releasing the service
         synchronized (this) {
             mLastStartId = startId;
         }
         boolean scheduled = false;
         if (intent != null) {
             // There is a rare situation that right after a intent is started,
             // the service gets killed. Then the service will restart with
             // the old intent which we don't want it to run since it will
             // break our assumption for wake lock. Check the process ID
             // embedded in the intent to make sure it is indeed from the
             // the current life of this service.
             if (fromThisProcess(intent)) {
                 final MmsRequest request = intent.getParcelableExtra(EXTRA_REQUEST);
                 if (request != null) {
                     try {
                         retainService(request, new Runnable() {
                             @Override
                             public void run() {
                                 try {
                                     request.execute(
                                             MmsService.this,
                                             mNetworkManager,
                                             getApnSettingsLoader(),
                                             getCarrierConfigValuesLoader(),
                                             getUserAgentInfoLoader());
                                 } catch (Exception e) {
                                     Log.w(TAG, "Unexpected execution failure", e);
                                 } finally {
                                     if (request.getUseWakeLock()) {
                                         releaseWakeLock();
                                     }
                                     releaseService();
                                 }
                             }
                         });
                         scheduled = true;
                     } catch (RejectedExecutionException e) {
                         // Rare thing happened. Send back failure using the pending intent
                         // and also release the wake lock.
                         Log.w(TAG, "Executing request failed " + e);
                         request.returnResult(this, SmsManager.MMS_ERROR_UNSPECIFIED,
                                 null/*response*/, 0/*httpStatusCode*/);
                         if (request.getUseWakeLock()) {
                             releaseWakeLock();
                         }
                     }
                 } else {
                     Log.w(TAG, "Empty request");
                 }
             } else {
                 Log.w(TAG, "Got a restarted intent from previous incarnation");
             }
         } else {
             Log.w(TAG, "Empty intent");
         }
         if (!scheduled) {
             // If the request is not started successfully, we need to try shutdown the service
             // if nobody is using it.
             tryScheduleStop();
         }
         return START_NOT_STICKY;
     }

     /**
      * Retain the service for executing the request in service thread pool
      *
      * @param request The request to execute
      * @param runnable The runnable to run the request in thread pool
      */
     private void retainService(final MmsRequest request, final Runnable runnable) {
         final ExecutorService executor = getRequestExecutor(request);
         synchronized (this) {
             executor.execute(runnable);
             mActiveRequestCount++;
         }
     }

     /**
      * Release the service from the request. If nobody is using it, schedule service stop.
      */
     private void releaseService() {
         synchronized (this) {
             mActiveRequestCount--;
             if (mActiveRequestCount <= 0) {
                 mActiveRequestCount = 0;
                 rescheduleServiceStop();
             }
         }
     }

     /**
      * Schedule the service stop if there is no active request
      */
     private void tryScheduleStop() {
         synchronized (this) {
             if (mActiveRequestCount == 0) {
                 rescheduleServiceStop();
             }
         }
     }

     /**
      * Reschedule service stop task
      */
     private void rescheduleServiceStop() {
         mHandler.removeCallbacks(mServiceStopRunnable);
         mHandler.postDelayed(mServiceStopRunnable, SERVICE_STOP_DELAY_MILLIS);
     }

     /**
      * Really try to stop the service if there is not active request
      */
     private void tryStopService() {
         Boolean stopped = null;
         synchronized (this) {
             if (mActiveRequestCount == 0) {
                 stopped = stopSelfResult(mLastStartId);
             }
         }
         logServiceStop(stopped);
     }

     /**
      * Log the result of service stopping. Also check wake lock status when service stops.
      *
      * @param stopped Not empty if service stop is performed: true if really stopped, false
      *                if cancelled.
      */
     private void logServiceStop(final Boolean stopped) {
         if (stopped != null) {
             if (stopped) {
                 Log.i(TAG, "Service successfully stopped");
                 verifyWakeLockNotHeld();
             } else {
                 Log.i(TAG, "Service stopping cancelled");
             }
         }
     }

     private ExecutorService getRequestExecutor(final MmsRequest request) {
         if (request instanceof SendRequest) {
             // Send
             return mExecutors[0];
         } else {
             // Download
             return mExecutors[1];
         }
     }

     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* 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 android.support.v7.mms;

	import android.app.Service;
	import android.content.Context;
	import android.content.Intent;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.PowerManager;
	import android.os.Process;
	import android.telephony.SmsManager;
	import android.util.Log;

	import java.util.concurrent.ExecutorService;
	import java.util.concurrent.Executors;
	import java.util.concurrent.RejectedExecutionException;

	/**
	* Service to execute MMS requests using deprecated legacy APIs on older platform (prior to L)
	*/
	public class MmsService extends Service {
	static final String TAG = "MmsLib";

	//The default number of threads allowed to run MMS requests
	private static final int DEFAULT_THREAD_POOL_SIZE = 4;
	// Delay before stopping the service
	private static final int SERVICE_STOP_DELAY_MILLIS = 2000;

	private static final String EXTRA_REQUEST = "request";
	private static final String EXTRA_MYPID = "mypid";

	private static final String WAKELOCK_ID = "mmslib_wakelock";

	/**
	* Thread pool size for each request queue
	*/
	private static volatile int sThreadPoolSize = DEFAULT_THREAD_POOL_SIZE;

	/**
	* Optional wake lock to use
	*/
	private static volatile boolean sUseWakeLock = true;
	private static volatile PowerManager.WakeLock sWakeLock = null;
	private static final Object sWakeLockLock = new Object();

	/**
	* Carrier configuration values loader
	*/
	private static volatile CarrierConfigValuesLoader sCarrierConfigValuesLoader = null;

	/**
	* APN loader
	*/
	private static volatile ApnSettingsLoader sApnSettingsLoader = null;

	/**
	* UserAgent and UA Prof URL loader
	*/
	private static volatile UserAgentInfoLoader sUserAgentInfoLoader = null;

	/**
	* Set the size of thread pool for request execution.
	* Default is DEFAULT_THREAD_POOL_SIZE
	*
	* @param size thread pool size
	*/
	static void setThreadPoolSize(final int size) {
	sThreadPoolSize = size;
	}

	/**
	* Set whether to use wake lock
	*
	* @param useWakeLock true to use wake lock, false otherwise
	*/
	static void setUseWakeLock(final boolean useWakeLock) {
	sUseWakeLock = useWakeLock;
	}

	/**
	* Set the optional carrier config values
	*
	* @param loader the carrier config values loader
	*/
	static void setCarrierConfigValuesLoader(final CarrierConfigValuesLoader loader) {
	sCarrierConfigValuesLoader = loader;
	}

	/**
	* Get the current carrier config values loader
	*
	* @return the carrier config values loader currently set
	*/
	static CarrierConfigValuesLoader getCarrierConfigValuesLoader() {
	return sCarrierConfigValuesLoader;
	}

	/**
	* Set APN settings loader
	*
	* @param loader the APN settings loader
	*/
	static void setApnSettingsLoader(final ApnSettingsLoader loader) {
	sApnSettingsLoader = loader;
	}

	/**
	* Get the current APN settings loader
	*
	* @return the APN settings loader currently set
	*/
	static ApnSettingsLoader getApnSettingsLoader() {
	return sApnSettingsLoader;
	}

	/**
	* Set user agent info loader
	*
	* @param loader the user agent info loader
	*/
	static void setUserAgentInfoLoader(final UserAgentInfoLoader loader) {
	sUserAgentInfoLoader = loader;
	}

	/**
	* Get the current user agent info loader
	*
	* @return the user agent info loader currently set
	*/
	static UserAgentInfoLoader getUserAgentInfoLoader() {
	return sUserAgentInfoLoader;
	}

	/**
	* Make sure loaders are not null. Set to default if that's the case
	*
	* @param context the Context to use
	*/
	private static void ensureLoaders(final Context context) {
	if (sUserAgentInfoLoader == null) {
	sUserAgentInfoLoader = new DefaultUserAgentInfoLoader(context);
	}
	if (sCarrierConfigValuesLoader == null) {
	sCarrierConfigValuesLoader = new DefaultCarrierConfigValuesLoader(context);
	}
	if (sApnSettingsLoader == null) {
	sApnSettingsLoader = new DefaultApnSettingsLoader(context);
	}
	}

	/**
	* Acquire the wake lock
	*
	* @param context the context to use
	*/
	private static void acquireWakeLock(final Context context) {
	synchronized (sWakeLockLock) {
	if (sWakeLock == null) {
	final PowerManager pm =
	(PowerManager) context.getSystemService(Context.POWER_SERVICE);
	sWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_ID);
	}
	sWakeLock.acquire();
	}
	}

	/**
	* Release the wake lock
	*/
	private static void releaseWakeLock() {
	boolean releasedEmptyWakeLock = false;
	synchronized (sWakeLockLock) {
	if (sWakeLock != null) {
	sWakeLock.release();
	} else {
	releasedEmptyWakeLock = true;
	}
	}
	if (releasedEmptyWakeLock) {
	Log.w(TAG, "Releasing empty wake lock");
	}
	}

	/**
	* Check if wake lock is not held (e.g. when service stops)
	*/
	private static void verifyWakeLockNotHeld() {
	boolean wakeLockHeld = false;
	synchronized (sWakeLockLock) {
	wakeLockHeld = sWakeLock != null && sWakeLock.isHeld();
	}
	if (wakeLockHeld) {
	Log.e(TAG, "Wake lock still held!");
	}
	}

	// Remember my PID to discard restarted intent
	private static volatile int sMyPid = -1;

	/**
	* Get the current PID
	*
	* @return the current PID
	*/
	private static int getMyPid() {
	if (sMyPid < 0) {
	sMyPid = Process.myPid();
	}
	return sMyPid;
	}

	/**
	* Check if the intent is coming from this process
	*
	* @param intent the incoming intent for the service
	* @return true if the intent is from the current process
	*/
	private static boolean fromThisProcess(final Intent intent) {
	final int pid = intent.getIntExtra(EXTRA_MYPID, -1);
	return pid == getMyPid();
	}

	// Request execution thread pools. One thread pool for sending and one for downloading.
	// The size of the thread pool controls the parallelism of request execution.
	// See {@link setThreadPoolSize}
	private ExecutorService[] mExecutors = new ExecutorService[2];

	// Active request count
	private int mActiveRequestCount;
	// The latest intent startId, used for safely stopping service
	private int mLastStartId;

	private MmsNetworkManager mNetworkManager;

	// Handler for scheduling service stop
	private final Handler mHandler = new Handler();
	// Service stop task
	private final Runnable mServiceStopRunnable = new Runnable() {
	@Override
	public void run() {
	tryStopService();
	}
	};

	/**
	* Start the service with a request
	*
	* @param context the Context to use
	* @param request the request to start
	*/
	public static void startRequest(final Context context, final MmsRequest request) {
	final boolean useWakeLock = sUseWakeLock;
	request.setUseWakeLock(useWakeLock);
	final Intent intent = new Intent(context, MmsService.class);
	intent.putExtra(EXTRA_REQUEST, request);
	intent.putExtra(EXTRA_MYPID, getMyPid());
	if (useWakeLock) {
	acquireWakeLock(context);
	}
	if (context.startService(intent) == null) {
	if (useWakeLock) {
	releaseWakeLock();
	}
	}
	}

	@Override
	public void onCreate() {
	super.onCreate();

	ensureLoaders(this);

	for (int i = 0; i < mExecutors.length; i++) {
	mExecutors[i] = Executors.newFixedThreadPool(sThreadPoolSize);
	}

	mNetworkManager = new MmsNetworkManager(this);

	synchronized (this) {
	mActiveRequestCount = 0;
	mLastStartId = -1;
	}
	}

	@Override
	public void onDestroy() {
	super.onDestroy();

	for (ExecutorService executor : mExecutors) {
	executor.shutdown();
	}
	}

	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
	// Always remember the latest startId for use when we try releasing the service
	synchronized (this) {
	mLastStartId = startId;
	}
	boolean scheduled = false;
	if (intent != null) {
	// There is a rare situation that right after a intent is started,
	// the service gets killed. Then the service will restart with
	// the old intent which we don't want it to run since it will
	// break our assumption for wake lock. Check the process ID
	// embedded in the intent to make sure it is indeed from the
	// the current life of this service.
	if (fromThisProcess(intent)) {
	final MmsRequest request = intent.getParcelableExtra(EXTRA_REQUEST);
	if (request != null) {
	try {
	retainService(request, new Runnable() {
	@Override
	public void run() {
	try {
	request.execute(
	MmsService.this,
	mNetworkManager,
	getApnSettingsLoader(),
	getCarrierConfigValuesLoader(),
	getUserAgentInfoLoader());
	} catch (Exception e) {
	Log.w(TAG, "Unexpected execution failure", e);
	} finally {
	if (request.getUseWakeLock()) {
	releaseWakeLock();
	}
	releaseService();
	}
	}
	});
	scheduled = true;
	} catch (RejectedExecutionException e) {
	// Rare thing happened. Send back failure using the pending intent
	// and also release the wake lock.
	Log.w(TAG, "Executing request failed " + e);
	request.returnResult(this, SmsManager.MMS_ERROR_UNSPECIFIED,
	null/response/, 0/httpStatusCode/);
	if (request.getUseWakeLock()) {
	releaseWakeLock();
	}
	}
	} else {
	Log.w(TAG, "Empty request");
	}
	} else {
	Log.w(TAG, "Got a restarted intent from previous incarnation");
	}
	} else {
	Log.w(TAG, "Empty intent");
	}
	if (!scheduled) {
	// If the request is not started successfully, we need to try shutdown the service
	// if nobody is using it.
	tryScheduleStop();
	}
	return START_NOT_STICKY;
	}

	/**
	* Retain the service for executing the request in service thread pool
	*
	* @param request The request to execute
	* @param runnable The runnable to run the request in thread pool
	*/
	private void retainService(final MmsRequest request, final Runnable runnable) {
	final ExecutorService executor = getRequestExecutor(request);
	synchronized (this) {
	executor.execute(runnable);
	mActiveRequestCount++;
	}
	}

	/**
	* Release the service from the request. If nobody is using it, schedule service stop.
	*/
	private void releaseService() {
	synchronized (this) {
	mActiveRequestCount--;
	if (mActiveRequestCount <= 0) {
	mActiveRequestCount = 0;
	rescheduleServiceStop();
	}
	}
	}

	/**
	* Schedule the service stop if there is no active request
	*/
	private void tryScheduleStop() {
	synchronized (this) {
	if (mActiveRequestCount == 0) {
	rescheduleServiceStop();
	}
	}
	}

	/**
	* Reschedule service stop task
	*/
	private void rescheduleServiceStop() {
	mHandler.removeCallbacks(mServiceStopRunnable);
	mHandler.postDelayed(mServiceStopRunnable, SERVICE_STOP_DELAY_MILLIS);
	}

	/**
	* Really try to stop the service if there is not active request
	*/
	private void tryStopService() {
	Boolean stopped = null;
	synchronized (this) {
	if (mActiveRequestCount == 0) {
	stopped = stopSelfResult(mLastStartId);
	}
	}
	logServiceStop(stopped);
	}

	/**
	* Log the result of service stopping. Also check wake lock status when service stops.
	*
	* @param stopped Not empty if service stop is performed: true if really stopped, false
	* if cancelled.
	*/
	private void logServiceStop(final Boolean stopped) {
	if (stopped != null) {
	if (stopped) {
	Log.i(TAG, "Service successfully stopped");
	verifyWakeLockNotHeld();
	} else {
	Log.i(TAG, "Service stopping cancelled");
	}
	}
	}

	private ExecutorService getRequestExecutor(final MmsRequest request) {
	if (request instanceof SendRequest) {
	// Send
	return mExecutors[0];
	} else {
	// Download
	return mExecutors[1];
	}
	}

	@Override
	public IBinder onBind(Intent intent) {
	return null;
	}
	}