¿Cómo bloquear una llamada de número de móvil y la recepción de un mensaje en el desarrollo de aplicaciones de Android?

Question

Me gustaría implementar una aplicación para bloquear un número móvil para recibir o enviar llamadas y mensajes. En mi aplicación, estoy ingresando el número de móvil en el EditText cuadro, luego hago clic en un botón para bloquear el número de teléfono móvil que ingresó el usuario.

he implementado una clase de actividad como sigue:

public class BlockNumberActivity extends Activity { 
    /** Called when the activity is first created. */ 
    @Override 
    public void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.main); 

     ((Button)findViewById(R.id.block)).setOnClickListener(new OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       String mobileNumer = ((EditText)findViewById(R.id.mobileNum)).getText().toString(); 
       //How to block entered mobileNumber 
      } 
     }); 

     ((Button)findViewById(R.id.unblock)).setOnClickListener(new OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       String mobileNumer = ((EditText)findViewById(R.id.mobileNum)).getText().toString(); 
       //How to unblock entered mobileNumber 
      } 
     }); 
    } 
} 

creo que podemos utilizar BroadcastReceiver. Pero no tengo más conocimiento sobre eso. Por favor, dame una idea de cómo implementar el bloqueo o desbloqueo del número de móvil. Por favor, cualquier organismo que me ayude .....

Answer 1

crear PhoneCallReceiver .JAVA

import android.content.BroadcastReceiver; 
import android.content.Context; 
import android.content.Intent; 
import android.telephony.PhoneStateListener; 
import android.telephony.TelephonyManager; 
import android.util.Log; 
import android.widget.Toast; 
public class PhoneCallReceiver extends BroadcastReceiver { 

@Override 
public void onReceive(Context context, Intent intent) { 
    TelephonyManager telephony = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 
    PhoneCallStateListener customPhoneListener = new PhoneCallStateListener(context); 
    telephony.listen(customPhoneListener, PhoneStateListener.LISTEN_CALL_STATE); 



}} 

ahora crear PhoneCallStateListener .java

import java.lang.reflect.Method; 
import android.content.Context; 
import android.content.Intent; 
import android.content.SharedPreferences; 
import android.media.AudioManager; 
import android.os.Bundle; 
import android.preference.PreferenceManager; 
import android.telephony.PhoneStateListener; 
import android.telephony.TelephonyManager; 
import android.widget.Toast; 

import com.android.internal.telephony.ITelephony; 

public class PhoneCallStateListener extends PhoneStateListener {  

private Context context; 
public PhoneCallStateListener(Context context){ 
    this.context = context; 
} 


@Override 
public void onCallStateChanged(int state, String incomingNumber) { 
    SharedPreferences prefs=PreferenceManager.getDefaultSharedPreferences(context); 

    switch (state) { 

     case TelephonyManager.CALL_STATE_RINGING:  

       String block_number = prefs.getString("block_number", null); 
      AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); 
      //Turn ON the mute 
      audioManager.setStreamMute(AudioManager.STREAM_RING, true);     
      TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 
      try { 
       Toast.makeText(context, "in"+block_number, Toast.LENGTH_LONG).show(); 
       Class clazz = Class.forName(telephonyManager.getClass().getName()); 
       Method method = clazz.getDeclaredMethod("getITelephony"); 
       method.setAccessible(true); 
       ITelephony telephonyService = (ITelephony) method.invoke(telephonyManager);  
       //Checking incoming call number 
       System.out.println("Call "+block_number); 

       if (incomingNumber.equalsIgnoreCase("+91"+block_number)) { 
        //telephonyService.silenceRinger();//Security exception problem 
        telephonyService = (ITelephony) method.invoke(telephonyManager); 
        telephonyService.silenceRinger(); 
        System.out.println(" in "+block_number); 
        telephonyService.endCall(); 
       } 
      } catch (Exception e) { 
       Toast.makeText(context, e.toString(), Toast.LENGTH_LONG).show(); 
      } 
      //Turn OFF the mute  
      audioManager.setStreamMute(AudioManager.STREAM_RING, false); 
      break; 
     case PhoneStateListener.LISTEN_CALL_STATE: 

    } 
    super.onCallStateChanged(state, incomingNumber); 
}} 

Ahora en src crear esta paquetecom.android.internal.telephonyahora en este paquete Haga clic derecho -> Nuevo -> Archivo ahora dan nombre ITelephony.aidl y pega este código

package com.android.internal.telephony; 

interface ITelephony {  

    boolean endCall();  

    void answerRingingCall();  

    void silenceRinger(); 
} 

NOTA: Código es probado en Android 2.2 (Froyo), 2.3 (GingerBread)

Answer 2

para bloquear el uso de llamadas entrantes y también esta http://androidsourcecode.blogspot.in/2010/10/blocking-incoming-call-android.html este http://www.codeproject.com/Questions/333253/Block-Incoming-calls-in-android-without-single-rin, http://www.anddev.org/post52643.html?hilit=incoming%20call#p52643 o para bloquear el saliente ver How to Block outgoing calls and Text SMS y Blocking outgoing calls and texts (BroadcastReceiver or Service?), Android: Taking complete control of phone(kiosk mode), is it possible? How?

Answer 3

Para bloquear una llamada de un contacto específico no, entonces este tutorial wil Te ayudo a resolver tu problema. http://androiddesk.wordpress.com/2012/08/02/blocking-a-call-without-user-intervention-in-android/

Answer 4

este código está trabajando ...

primera descarga esta clase ITelephony

if ((state != null) 
       && (state.equals(TelephonyManager.EXTRA_STATE_RINGING))) { 
      CallLogReceiver.phoneNo = intent.getExtras().getString(
        "incoming_number"); 

      if (CallLogReceiver.blockNo.equals(CallLogReceiver.phoneNo)) { 

       Intent blockCallIntent = new Intent(); 
       blockCallIntent.setClassName("com.example.calllogdemo", 
         "com.example.calllogdemo.BlockCallActivity"); 
       blockCallIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
       blockCallIntent 
         .putExtra("blockNo", CallLogReceiver.phoneNo); 
       context.startActivity(blockCallIntent); 
       try { 
        TelephonyManager telephonyManager = (TelephonyManager) context 
          .getSystemService(Context.TELEPHONY_SERVICE); 

        Class<?> classTelephony = Class 
          .forName(telephonyManager.getClass().getName()); 
        Method methodGetITelephony = classTelephony 
          .getDeclaredMethod("getITelephony"); 

        methodGetITelephony.setAccessible(true); 

        ITelephony telephonyService = (ITelephony)   methodGetITelephony 
          .invoke(telephonyManager); 

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

y utilizar este permiso en el archivo de manifiesto

<uses-permission android:name="android.permission.CALL_PHONE" /> 

Answer 5

Este código funciona para mí

try { 

      String serviceManagerName = "android.os.ServiceManager"; 
      String serviceManagerNativeName = "android.os.ServiceManagerNative"; 
      String telephonyName = "com.android.internal.telephony.ITelephony"; 
      Class<?> telephonyClass; 
      Class<?> telephonyStubClass; 
      Class<?> serviceManagerClass; 
      Class<?> serviceManagerNativeClass; 
      Method telephonyEndCall; 
      Object telephonyObject; 
      Object serviceManagerObject; 
      telephonyClass = Class.forName(telephonyName); 
      telephonyStubClass = telephonyClass.getClasses()[0]; 
      serviceManagerClass = Class.forName(serviceManagerName); 
      serviceManagerNativeClass = Class.forName(serviceManagerNativeName); 
      Method getService = 
        serviceManagerClass.getMethod("getService", String.class); 
      Method tempInterfaceMethod = serviceManagerNativeClass.getMethod(
        "asInterface", IBinder.class); 
      Binder tmpBinder = new Binder(); 
      tmpBinder.attachInterface(null, "fake"); 
      serviceManagerObject = tempInterfaceMethod.invoke(null, tmpBinder); 
      IBinder retbinder = (IBinder) getService.invoke(
        serviceManagerObject, "phone"); 
      Method serviceMethod = telephonyStubClass.getMethod("asInterface", 
        IBinder.class); 
      telephonyObject = serviceMethod.invoke(null, retbinder); 
      telephonyEndCall = telephonyClass.getMethod("endCall"); 
      telephonyEndCall.invoke(telephonyObject); 

     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
     Toast.makeText(context, "Unable to Block Call", Toast.LENGTH_SHORT).show(); 


    }