Come bloccare una chiamata di numero di cellulare e la ricezione di messaggi nello sviluppo di applicazioni Android?

Question

Vorrei implementare un'applicazione per bloccare un numero di cellulare per ricevere o inviare chiamate e messaggi. Nella mia domanda sto inserendo il numero di cellulare nel box EditText, quindi clicco su un pulsante per bloccare il numero di cellulare che è stato inserito dall'utente.

ho implementato una classe di attività come segue:

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

penso che possiamo usare BroadcastReceiver. Ma non ho più conoscenza su di esso. Per favore, mi dia un'idea di come implementare il blocco o lo sblocco del numero di cellulare. Si prega di qualsiasi organismo mi aiuti .....

Answer 1

creare 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); 



}} 

ora creare PhoneCallStateListener .java

012.

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

Ora, in src creare questa pacchettocom.android.internal.telephonyora in questo pacchetto Fare clic destro -> Nuovo -> File ora dare nome ITelephony.aidl e incolla questo codice

package com.android.internal.telephony; 

interface ITelephony {  

    boolean endCall();  

    void answerRingingCall();  

    void silenceRinger(); 
} 

NOTA: codice è testato in Android 2.2 (Froyo), 2.3 (GingerBread)

Answer 2

per bloccare l'utilizzo chiamata in arrivo questo http://androidsourcecode.blogspot.in/2010/10/blocking-incoming-call-android.html e anche questo 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 il blocco in uscita vedere How to Block outgoing calls and Text SMS e Blocking outgoing calls and texts (BroadcastReceiver or Service?), Android: Taking complete control of phone(kiosk mode), is it possible? How?

Answer 3

Per rispondere a una chiamata di un contatto specifico no, allora questo tutorial sarà Ti aiuterò a risolvere il tuo problema. http://androiddesk.wordpress.com/2012/08/02/blocking-a-call-without-user-intervention-in-android/

Answer 4

questo codice sta lavorando ...

primo download questa classe 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(); 
       } 
      } 
     } 

e utilizzare questa autorizzazione nel file manifesto

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

Answer 5

Questo codice funziona per me

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(); 


    }