Wie blockiere ich einen Handyruf und den Empfang von Nachrichten in der Entwicklung von Android-Anwendungen?

Ich möchte eine Anwendung zum Sperren einer Mobiltelefonnummer zum Empfangen oder Senden von Anrufen und Nachrichten implementieren. In meiner Bewerbung trage ich die Handynummer ein EditText Box, dann klicke ich auf eine Schaltfläche, um die vom Benutzer eingegebene Handynummer zu blockieren.

Ich habe eine Aktivitätsklasse wie folgt implementiert:

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 können verwenden BroadcastReceiver. Aber mehr Wissen habe ich da nicht. Bitte geben Sie mir eine Idee, wie ich die Sperrung oder Entsperrung der Handynummer implementieren kann. Bitte jeder Körper hilf mir…..

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



}}

Erstellen Sie nun 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 Paket com.android.internal.telephony jetzt in diesem Paket Rechtsklick -> Neu -> Datei jetzt Namen geben ITelephony.aidl und fügen Sie diesen Code ein

package com.android.internal.telephony; 

interface ITelephony {      

  boolean endCall();     

  void answerRingingCall();      

  void silenceRinger(); 
}

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

Verwenden Sie dies, um eingehende Anrufe zu blockieren http://androidsourcecode.blogspot.in/2010/10/blocking-incoming-call-android.html und auch dies 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 um ausgehende Anrufe zu blockieren, siehe So blockieren Sie ausgehende Anrufe und Text-SMS und Blockieren ausgehender Anrufe und Texte (BroadcastReceiver oder Service?). Wie?

Dieser Code funktioniert bei mir

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


    }

Um einen Anruf einer bestimmten Kontaktnummer zu blockieren, hilft Ihnen dieses Tutorial bei der Lösung Ihres Problems.
http://androiddesk.wordpress.com/2012/08/02/blockieren-eines-anrufs-ohne-benutzereingriff-in-android/

dieser code funktioniert…

Laden Sie zuerst diese Klasse herunter ITelefonie

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 verwenden Sie diese Berechtigung in der Manifestdatei

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