How to Block outgoing calls and Text SMS

I am developing an App in which I need to block the teenager from using mobile while driving, I need to block the call and sms. pleas开发者_如何学JAVAe help . any small hints and clues will do. please help me!

This code will block your all call (INCOMING AND OUTGOING)

import java.lang.reflect.Method;

import android.content.Context;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;

import com.CallLogApp.helper.BlockNumberHelper;
import com.CallLogApp.util.UDF;
import com.android.internal.telephony.ITelephony;

public class CustomPhoneStateListener extends PhoneStateListener {

    //private static final String TAG = "PhoneStateChanged";
    Context context;
    public CustomPhoneStateListener(Context context) {
        super();
        this.context = context;
    }

    @Override
    public void onCallStateChanged(int state, String outGoingNumber) {
        super.onCallStateChanged(state, outGoingNumber);

        switch (state) {
            case TelephonyManager.CALL_STATE_IDLE:
                break;
            case TelephonyManager.CALL_STATE_OFFHOOK:
                endCallIfBlocked(outGoingNumber);
                break;
            case TelephonyManager.CALL_STATE_RINGING:
                break;
            default:
                break;
        }

     }

     private void endCallIfBlocked(String outGoingNumber) {
        try {
            // Java reflection to gain access to TelephonyManager's
            // ITelephony getter
            TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            Class<?> c = Class.forName(tm.getClass().getName());
            Method m = c.getDeclaredMethod("getITelephony");
            m.setAccessible(true);
            com.android.internal.telephony.ITelephony telephonyService = (ITelephony) m.invoke(tm);  

            if (new BlockNumberHelper(context).isBlocked(outGoingNumber))
            {
                telephonyService = (ITelephony) m.invoke(tm);
                telephonyService.silenceRinger();
                telephonyService.endCall();
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Here CALL_STATE_OFFHOOK state will call each time when your call going to connect and when you received incoming call

There is no any method that you can know weather it is incoming call or outgoing call

But you can end call which is going to connect in both scenario

http://code.google.com/p/krvarma-android-samples/source/browse/trunk/DetectCalls/src/com/varma/samples/detectcalls/receivers/OutgoingCallReceiver.java

To add the answer by Dharmendra saying that:

There is no any method that you can know whether it is incoming call or outgoing call

In fact, there is.

To distinguish incoming calls from outgoing calls, you have to listen to Intent.ACTION_NEW_OUTGOING_CALL as well. Now:

when you see first Intent.ACTION_NEW_OUTGOING_CALL and then CALL_STATE_OFFHOOK, it's an outgoing call;

when you first see CALL_STATE_RINGING and then CALL_STATE_OFFHOOK, it's an incoming call.

At second, you could either use a PhoneStateListener or listen to TelephonyManager.ACTION_PHONE_STATE_CHANGED. From what I could see, first the intent gets received by the BroadcastReceiver, then the PhoneStateListener gets notified.

final IntentFilter theFilter = new IntentFilter();
theFilter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
theFilter.addAction(Intent.ACTION_NEW_OUTGOING_CALL);
mBroadcastReceiver = new MyBroadcastReceiver();
mService.registerReceiver(mBroadcastReceiver, theFilter);

class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        ...
    }
}

To block outgoing calls, you need to register a PhoneStateListener like:

telephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
telephonyManager.listen(new MyListener(), PhoneStateListener.LISTEN_CALL_STATE);

Then define your MyListener class like:

private class Test extends PhoneStateListener {
    @Override
    public void onCallStateChanged(int state, String incomingNumber) {
        super.onCallStateChanged(state, incomingNumber);


        switch(state)
        {
        case TelephonyManager.CALL_STATE_IDLE:
            break;
        case TelephonyManager.CALL_STATE_OFFHOOK://this case is for outgoing call 
            break;
        case TelephonyManager.CALL_STATE_RINGING://this case is for incoming call
            break;
        default:
            break;
        }

    }
}