CODEWITHSUNDEEP
android
Thiru
Thiru

Reputation: 526

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. please help . any small hints and clues will do. please help me!

Upvotes: 6

Views: 21536

Answers (4)

Vijay
Vijay

Reputation: 2005

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;
        }

    }
}

Upvotes: 0

18446744073709551615
18446744073709551615

Reputation: 16832

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) {
        ...
    }
}

Upvotes: 0

Dharmendra
Dharmendra

Reputation: 33996

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

Upvotes: 11

Hiren Dabhi
Hiren Dabhi

Reputation: 3713

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

Upvotes: 1

Related Questions