Intercepting Outgoing SMS

Question

Is it possible to intercept outgoing SMS before it is actually sent, get its contents then ignore / send it according to some criteria?

eg. block all international t

Answer 1

This is what i have done to make an OutgoingSMSReceiver hope it helps some one some dya!

public final class OutgoingSMSReceiver extends Service {


    private static final String CONTENT_SMS = "content://sms/";
    private CallerHistoryDataSource  database =  new  CallerHistoryDataSource(UCDGlobalContextProvider.getContext());
    static String messageId="";


    private class MyContentObserver extends ContentObserver {



        public MyContentObserver() {
            super(null);
        }

        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);


            Uri uriSMSURI = Uri.parse(CONTENT_SMS);
            Cursor cur = UCDGlobalContextProvider.getContext().getContentResolver().query(uriSMSURI, null, null, null, null);
             // this will make it point to the first record, which is the last SMS sent
            cur.moveToNext();

            String message_id = cur.getString(cur.getColumnIndex("_id"));
            String type = cur.getString(cur.getColumnIndex("type"));

            if(type.equals(Constants.SMS_TYPE_OUTGOING)){

                /**
                 *  onChange is fired multiple times for a single SMS, this is to prevent multiple entries in db.
                 * 
                 */
                if(!message_id.equals(messageId))
                {
                    String content = cur.getString(cur.getColumnIndex("body"));
                    String msisdnWithCountryCodeOrPrefix = cur.getString(cur.getColumnIndex("address"));
                    String msisdn = MSISDNPreFixHandler.fixMsisdn(msisdnWithCountryCodeOrPrefix);

                    Sms sms = new Sms();
                    sms.setType(Constants.SMS_TYPE_OUTGOING);
                    sms.setMsisdn(msisdn);
                    sms.setContent(content);



        Log.i("MyContentObserver", "Sent SMS saved: "+content);                                     

                }
                messageId = message_id;

            }

    }


        @Override
        public boolean deliverSelfNotifications() {
            return false;
        }
    }




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

    @Override
    public void onCreate() {
        MyContentObserver contentObserver = new MyContentObserver();
        ContentResolver contentResolver = getBaseContext().getContentResolver();
        contentResolver.registerContentObserver(Uri.parse(CONTENT_SMS),true, contentObserver);
        //Log.v("Caller History: Service Started.", "OutgoingSMSReceiverService");
    }

    @Override
    public void onDestroy() {
        //Log.v("Caller History: Service Stopped.", "OutgoingSMSReceiverService");    
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //Log.v("Caller History: Service Started.", "OutgoingSMSReceiverService");
        /**
         *   Constant to return from onStartCommand(Intent, int, int): if this service's process is killed while it is started 
         *   (after returning from onStartCommand(Intent, int, int)), then leave it in the started state but don't retain this delivered intent. 
         *   Later the system will try to re-create the service. Because it is in the started state, it will guarantee to call 
         *   onStartCommand(Intent, int, int) after creating the new service instance; if there are not any pending start commands to be 
         *   delivered to the service, it will be called with a null intent object, so you must take care to check for this.
         *   This mode makes sense for things that will be explicitly started and stopped to run for arbitrary periods of time, such as a 
         *   service performing background music playback.
         */
        return START_STICKY;

    }

    @Override
    public void onStart(Intent intent, int startid) {
        Log.v("Caller History: Service Started.", "OutgoingSMSReceiverService");
    }
}