Wie blockiere ich eine Mobiltelefonnummer Anruf und Nachrichtenempfang in Android-Anwendungsentwicklung?

Question

Ich möchte eine Anwendung zum Blockieren einer Handynummer zum Empfangen oder Senden von Anrufen und Nachrichten implementieren. In meiner Anwendung gebe ich Handynummer bei EditText ein, dann klicke ich auf einen Knopf, um die Handynummer zu blockieren, die vom Benutzer eingegeben worden ist.

ich eine Aktivitätsklasse umgesetzt haben, wie folgt:

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

Ich denke, wir BroadcastReceiver verwenden. Aber ich weiß nicht mehr darüber. Bitte geben Sie mir eine Idee, wie Sie die Mobiltelefonnummer sperren oder entsperren können. Bitte jede Stelle mir helfen .....

Answer 1

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



}} 

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

Jetzt in src erstellen, um dieses Paketcom.android.internal.telephonyjetzt in diesem Paket Rechtsklick -> Neu -> Datei jetzt Namen geben ITelephony.aidl und fügen Sie diesen Code

package com.android.internal.telephony; 

interface ITelephony {  

    boolean endCall();  

    void answerRingingCall();  

    void silenceRinger(); 
} 

HINWEIS:-Code ist getestet in Android 2.2 (Froyo), 2.3 (GingerBread)

Answer 2

Verwendung eingehenden Anruf dieses http://androidsourcecode.blogspot.in/2010/10/blocking-incoming-call-android.html zu blockieren und auch diese http://www.codeproject.com/Questions/333253/Block-Incoming-calls-in-android-without-single-rin, http://www.anddev.org/post52643.html?hilit=incoming%20call#p52643 oder abgehend zu blockieren sehen How to Block outgoing calls and Text SMS und Blocking outgoing calls and texts (BroadcastReceiver or Service?), Android: Taking complete control of phone(kiosk mode), is it possible? How?

Answer 3

Um einen Anruf eines bestimmten Kontakts no bloop, dann wird dieses Tutorial wil Ich helfe Ihnen bei der Lösung Ihres Problems. http://androiddesk.wordpress.com/2012/08/02/blocking-a-call-without-user-intervention-in-android/

Answer 4

dieser Code arbeitet ...

ersten Download dieser Klasse 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(); 
       } 
      } 
     } 

und diese Erlaubnis in Manifest-Datei verwenden

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

Answer 5

Dieser Kodex für mich arbeitet

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


    }