smsreceiver.java

package com.texter.messenger;

import java.util.List;

import android.app.Activity;
import android.app.PendingIntent;
import android.app.PendingIntent.CanceledException;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.PowerManager;
import android.os.Process;
import android.telephony.SmsManager;
import android.telephony.SmsMessage;
import android.telephony.SmsMessage.MessageClass;
import android.telephony.TelephonyManager;
import android.util.Log;

import com.texter.common.TexterConstants;
import com.texter.common.TexterNotification;
import com.texter.common.Utils;
import com.texter.data.TexterDB;
import com.texter.data.TexterDB.Schedule;
import com.texter.preferences.TexterPreferenceManager;
import com.texterpro.app.ConversationList;
import com.texterpro.app.R;
import com.texterpro.app.SmsPopupView;

public class SmsReceiverService extends Service {

    private static final String LOG_TAG = TexterConstants.COMMON_TAG;

    private static final String ACTION_SMS_RECEIVED = "android.provider.Telephony.SMS_RECEIVED";
    private static final String ACTION_MMS_RECEIVED = "android.provider.Telephony.WAP_PUSH_RECEIVED";
    private static final String ACTION_MESSAGE_RECEIVED = "net.everythingandroid.smspopup.MESSAGE_RECEIVED";
    private static final String MMS_DATA_TYPE = "application/vnd.wap.mms-message";

    // http://android.git.kernel.org/?p=platform/packages/apps/Mms.git;a=blob;f=src/com/android/mms/transaction/SmsReceiverService.java
    public static final String MESSAGE_SENT_ACTION = "com.android.mms.transaction.MESSAGE_SENT";

    /*
     * This is the number of retries and pause between retries that we will keep
     * checking the system message database for the latest incoming message
     */
    private static final int MESSAGE_RETRY = 8;
    private static final int MESSAGE_RETRY_PAUSE = 1000;

    private Context context;
    private ServiceHandler mServiceHandler;
    private Looper mServiceLooper;
    private int mResultCode;

    private static final Object mStartingServiceSync = new Object();
    private static PowerManager.WakeLock mStartingService;

    private static final int TOAST_HANDLER_MESSAGE_SENT = 0;
    private static final int TOAST_HANDLER_MESSAGE_SEND_LATER = 1;
    private static final int TOAST_HANDLER_MESSAGE_FAILED = 2;

    @Override
    public void onCreate() {
        HandlerThread thread = new HandlerThread("Log.LOGTAG",
                Process.THREAD_PRIORITY_BACKGROUND);
        thread.start();
        context = getApplicationContext();
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
        Log.v(LOG_TAG, "Oncreate");
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.v(LOG_TAG, "OnStart");
        mResultCode = intent != null ? intent.getIntExtra("result", 0) : 0;

        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

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

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            Log.v(LOG_TAG, "handlemessage:");
            Log.v(LOG_TAG, msg.toString());
            int serviceId = msg.arg1;
            Intent intent = (Intent) msg.obj;
            String action = intent.getAction();
            String dataType = intent.getType();

            if (ACTION_SMS_RECEIVED.equals(action)) {
                handleSmsReceived(intent);
            } else if (ACTION_MMS_RECEIVED.equals(action)
                    && MMS_DATA_TYPE.equals(dataType)) {
                handleMmsReceived(intent);
            } else if (MESSAGE_SENT_ACTION.equals(action)) {
                handleSmsSent(intent);
            } else if (ACTION_MESSAGE_RECEIVED.equals(action)) {
                handleMessageReceived(intent);
            }

            // NOTE: We MUST not call stopSelf() directly, since we need to
            // make sure the wake lock acquired by AlertReceiver is released.
            finishStartingService(SmsReceiverService.this, serviceId);
        }
    }

    /**
     * Handle receiving a SMS message
     */
    private void handleSmsReceived(Intent intent) {

        Bundle bundle = intent.getExtras();
        if (bundle != null) {
            SmsMessage[] messages = Utils.getMessagesFromIntent(intent);
            if (messages != null) {
                notifyMessageReceived(new SmsMmsMessage(context, messages,
                        System.currentTimeMillis()));
            }
        }
    }

    private void notifyMessageReceived(SmsMmsMessage message) {

        // Class 0 SMS, let the system handle this
        if (message.getMessageType() == SmsMmsMessage.MESSAGE_TYPE_SMS
                && message.getMessageClass() == MessageClass.CLASS_0) {
            return;
        }

        TelephonyManager mTM = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        boolean callStateIdle = mTM.getCallState() == TelephonyManager.CALL_STATE_IDLE;

        /*
         * If popup is enabled for this user -AND- the user is not in a call
         * -AND- -AND- phone is not docked -AND- (screen is locked -OR- (setting
         * is OFF to only show on keyguard -AND- user is not in messaging app:
         * then show the popup activity, otherwise check if notifications are on
         * and just use the standard notification))
         */

        boolean isApp = TexterPreferenceManager.getInstance(this)
                .isAppEnabled();
        boolean showPop = TexterPreferenceManager.getInstance(this)
                .isPopupEnabled();
        boolean showNotify = TexterPreferenceManager.getInstance(this)
                .isNotifyEnabled();

        // Log.v(LOG_TAG," App = "+ isApp );
        // Log.v(LOG_TAG," pop = "+showPop );
        // Log.v(LOG_TAG," notify = "+showNotify );

        // if conversationList is visible then do not show pop
        if (!ConversationList.isVisible()) {
            if (isApp && callStateIdle && showPop) {
                // Log.v(LOG_TAG," showing popup = " );
                if (!SmsPopupView.isPopupVisible())
                    context.startActivity(message.getPopupIntent());
            }
        }

        if (isApp && showNotify) {
            TexterNotification.ShowMessageNotification(this, message);
        }

    }

    /**
     * Handle receiving a MMS message
     */
    private void handleMmsReceived(Intent intent) {

    }

    /**
     * Handle receiving an arbitrary message (potentially coming from a 3rd
     * party app)
     */
    private void handleMessageReceived(Intent intent) {

        Bundle bundle = intent.getExtras();
        if (bundle != null) {
        }
    }

    /*
     * Handler to deal with showing Toast messages for message sent status
     */
    public Handler mToastHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {

            if (msg != null) {
                switch (msg.what) {
                case TOAST_HANDLER_MESSAGE_SENT:
                    // TexterNotification.showToast(SmsReceiverService.this,R.string.quickreply_sent_toast);
                    break;
                case TOAST_HANDLER_MESSAGE_SEND_LATER:
                    TexterNotification.showToast(SmsReceiverService.this,
                            R.string.quickreply_failed_send_later);
                    break;
                case TOAST_HANDLER_MESSAGE_FAILED:
                    TexterNotification.showToast(SmsReceiverService.this,
                            R.string.quickreply_failed);
                    break;
                }
            }
        }
    };

    /*
     * Handle the result of a sms being sent
     */
    private void handleSmsSent(Intent intent) {

        Log.v(LOG_TAG, "HandleSMSSent called");
        PackageManager pm = getPackageManager();
        Intent sysIntent = null;
        Intent tempIntent;
        List<ResolveInfo> receiverList;
        boolean forwardToSystemApp = true;

        // Search for system messaging app that will receive our
        // "message sent complete" type intent
        tempIntent = intent.setClassName(
                SmsMessageSender.MESSAGING_PACKAGE_NAME,
                SmsMessageSender.MESSAGING_RECEIVER_CLASS_NAME);

        tempIntent.setAction(SmsReceiverService.MESSAGE_SENT_ACTION);

        receiverList = pm.queryBroadcastReceivers(tempIntent, 0);

        if (receiverList.size() > 0) {
            sysIntent = tempIntent;
        }

        Bundle b = intent.getExtras();
        long rowid = 0;

        rowid = b == null ? 0 : b.getLong("ROWID");

        /*
         * No system messaging app was found to forward this intent to,
         * therefore we will need to do the final piece of this ourselves which
         * is basically moving the message to the correct folder depending on
         * the result.
         */
        // TexterNotification.showToast(SmsReceiverService.this,
        // "before moving folder");
        if (sysIntent == null) {

            forwardToSystemApp = false;
            Uri uri = intent.getData();
            Log.v(LOG_TAG, "id = " + rowid);
            if (mResultCode == Activity.RESULT_OK) {
                SmsMessageSender.moveMessageToFolder(this, uri,
                        SmsMessageSender.MESSAGE_TYPE_SENT);
            } else if ((mResultCode == SmsManager.RESULT_ERROR_RADIO_OFF)
                    || (mResultCode == SmsManager.RESULT_ERROR_NO_SERVICE)) {
                SmsMessageSender.moveMessageToFolder(this, uri,
                        SmsMessageSender.MESSAGE_TYPE_QUEUED);
            } else {
                SmsMessageSender.moveMessageToFolder(this, uri,
                        SmsMessageSender.MESSAGE_TYPE_FAILED);
            }
        }

        // Check the result and notify the user using a toast
        if (mResultCode == Activity.RESULT_OK) {
            mToastHandler.sendEmptyMessage(TOAST_HANDLER_MESSAGE_SENT);
            TexterDB.getInstance().updateStatus(rowid,
                    Schedule.STATUS_SCHEDULED_SENT, 0);
        } else if ((mResultCode == SmsManager.RESULT_ERROR_RADIO_OFF)
                || (mResultCode == SmsManager.RESULT_ERROR_NO_SERVICE)) {
            TexterDB.getInstance().updateStatus(rowid,
                    Schedule.STATUS_NOT_SENT, -1);
        } else {
            mToastHandler.sendEmptyMessage(TOAST_HANDLER_MESSAGE_FAILED);
            TexterDB.getInstance().updateStatus(rowid,
                    Schedule.STATUS_NOT_SENT, mResultCode);
        }

        if (forwardToSystemApp) {
            try {
                PendingIntent.getBroadcast(this, 0, sysIntent, 0).send(
                        mResultCode);
            } catch (CanceledException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * Start the service to process the current event notifications, acquiring
     * the wake lock before returning to ensure that the service will run.
     */
    public static void beginStartingService(Context context, Intent intent) {
        synchronized (mStartingServiceSync) {
            if (mStartingService == null) {
                PowerManager pm = (PowerManager) context
                        .getSystemService(Context.POWER_SERVICE);
                mStartingService = pm.newWakeLock(
                        PowerManager.PARTIAL_WAKE_LOCK,
                        "Texter.SmsReceiverService");
                mStartingService.setReferenceCounted(false);
            }
            mStartingService.acquire();
            context.startService(intent);
            Log.v(LOG_TAG, "service started");
        }
    }

    /**
     * Called back by the service when it has finished processing notifications,
     * releasing the wake lock if the service is now stopping.
     */
    public static void finishStartingService(Service service, int startId) {
        synchronized (mStartingServiceSync) {
            if (mStartingService != null) {
                if (service.stopSelfResult(startId)) {
                    mStartingService.release();
                }
            }
        }
    }

}