Android 如何在拨出电话后立即结束拨出电话

我正在尝试结束用户拨打的电话。基本上，我会允许一些号码，用户可以拨打和呼叫，否则所有其他呼叫将结束，用户将无法呼叫其他号码，然后这些号码

现在的问题是，我已经尝试了几种方法，但都不起作用

我在做什么：

我有一个广播接收器，当用户拨打这个号码时，它被触发了

在它下面我得到了拨号号码，如果它不是我想要的号码，我会尝试结束它

下面是我在on Receive方法中所做的

以及Endig调用方法

public void disconnectCall(){
    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 = // getDefaults[29];
                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();
        Log.d("Receiver",
                "FATAL ERROR: could not connect to telephony subsystem");
        Log.d("Receiver", "Exception object: " + e);
    }
}



public boolean killCall(Context context) {
    try {
        // Get the boring old TelephonyManager
        TelephonyManager telephonyManager =
                (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);

        // Get the getITelephony() method
        Class classTelephony = Class.forName(telephonyManager.getClass().getName());
        Method methodGetITelephony = classTelephony.getDeclaredMethod("getITelephony");

        // Ignore that the method is supposed to be private
        methodGetITelephony.setAccessible(true);

        // Invoke getITelephony() to get the ITelephony interface
        Object telephonyInterface = methodGetITelephony.invoke(telephonyManager);

        // Get the endCall method from ITelephony
        Class telephonyInterfaceClass =
                Class.forName(telephonyInterface.getClass().getName());
        Method methodEndCall = telephonyInterfaceClass.getDeclaredMethod("endCall");

        // Invoke endCall()
        methodEndCall.invoke(telephonyInterface);

    } catch (Exception ex) { // Many things can go wrong with reflection calls
        Log.d("Receiver","PhoneStateReceiver **" + ex.toString());
        return false;
    }
    return true;
}

public void disconnectCall（）{
试一试{
字符串serviceManagerName=“android.os.ServiceManager”；
字符串serviceManagerNativeName=“android.os.ServiceManagerActive”；
String telephonyName=“com.android.internal.telephony.ITelephony”；
类电话类；
类电话子类；
类serviceManagerClass；
类serviceManagerNativeClass；
方法电话呼叫；
对象电话对象；
对象服务管理对象；
telephonyClass=Class.forName（telephonyName）；
TelephonySubclass=telephonyClass.getClasses（）[0]；
serviceManagerClass=Class.forName（serviceManagerName）；
serviceManagerNativeClass=Class.forName（serviceManagerNativeName）；
方法getService=//getDefaults[29]；
serviceManagerClass.getMethod（“getService”，String.class）；
方法tempInterfaceMethod=ServiceManagerActiveClass.getMethod（“asInterface”，IBinder.class）；
活页夹tmpBinder=新活页夹（）；
tmpBinder.attachInterface（空，“假”）；
serviceManagerObject=tempInterfaceMethod.invoke（null，tmpBinder）；
IBinder retbinder=（IBinder）getService.invoke（serviceManagerObject，“电话”）；
方法serviceMethod=telephonyStubClass.getMethod（“asInterface”，IBinder.class）；
telephonyObject=serviceMethod.invoke（null，retbinder）；
telephonyEndCall=telephonyClass.getMethod（“endCall”）；
调用（telephonyObject）；
}捕获（例外e）{
e、 printStackTrace（）；
Log.d（“接收器”，
“致命错误：无法连接到电话子系统”）；
Log.d（“接收方”，“异常对象：+e”）；
}
}
公共布尔killCall（上下文）{
试一试{
//找个无聊的老电话管理员
电话管理器电话管理器=
（TelephonyManager）context.getSystemService（context.TELEPHONY_服务）；
//获取getITelephony（）方法
Class classTelephony=Class.forName（telephonyManager.getClass（）.getName（））；
方法methodGetITelephony=classTelephony.getDeclaredMethod（“getITelephony”）；
//忽略该方法应该是私有的
methodGetItemPhony.setAccessible（true）；
//调用getITelephony（）以获取ITelephony接口
对象telephonyInterface=methodGetITelephony.invoke（telephonyManager）；
//从ITelephony获取endCall方法
类电话接口类=
类.forName（telephonyInterface.getClass（）.getName（））；
方法methodEndCall=telephonyInterfaceClass.getDeclaredMethod（“endCall”）；
//调用endCall（）
调用（电话接口）；
}catch（Exception ex）{//反射调用可能会出现很多问题
Log.d（“Receiver”、“PhoneStateCeiver**”+ex.toString（））；
返回false；
}
返回true；
}

正如我们所见，我正在使用我在互联网上找到的4种不同的方式来结束通话，但它不起作用。目前，我正在果冻豆上尝试这个代码。但它不起作用。如果有人知道如何结束通话，请帮助我。什么是正确的方法请帮助。

终止通话的代码

 public boolean killCall(Context context) {
        try {
            // Get the boring old TelephonyManager
            TelephonyManager telephonyManager =
                    (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);

            // Get the getITelephony() method
            Class classTelephony = Class.forName(telephonyManager.getClass().getName());
            Method methodGetITelephony = classTelephony.getDeclaredMethod("getITelephony");

            // Ignore that the method is supposed to be private
            methodGetITelephony.setAccessible(true);

            // Invoke getITelephony() to get the ITelephony interface
            Object telephonyInterface = methodGetITelephony.invoke(telephonyManager);

            // Get the endCall method from ITelephony
            Class telephonyInterfaceClass =
                    Class.forName(telephonyInterface.getClass().getName());
            Method methodEndCall = telephonyInterfaceClass.getDeclaredMethod("endCall");

            // Invoke endCall()
            methodEndCall.invoke(telephonyInterface);

        } catch (Exception ex) { // Many things can go wrong with reflection calls
            LogUtil.warn(TAG, "PhoneStateReceiver **" + ex.toString());
            return false;
        }
        return true;

    }

不同州的代码

public abstract class PhoneCallReceiver extends BroadcastReceiver {

    private static final String TAG = "PhoneCallReceiver";

    //The receiver will be recreated whenever android feels like it.  We need a static variable to remember data between instantiations

    private static int lastState = TelephonyManager.CALL_STATE_IDLE;
    private static Date callStartTime;
    private static boolean isIncoming;
    private static String savedNumber;  //because the passed incoming is only valid in ringing


    @Override
    public void onReceive(Context context, Intent intent) {

        //We listen to two intents.  The new outgoing call only tells us of an outgoing call.  We use it to get the number.
        if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL")) {
            savedNumber = intent.getExtras().getString("android.intent.extra.PHONE_NUMBER");
        } else {
            String stateStr = intent.getExtras().getString(TelephonyManager.EXTRA_STATE);
            String number = intent.getExtras().getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
            int state = 0;
            if (stateStr.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
                state = TelephonyManager.CALL_STATE_IDLE;
            } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
                state = TelephonyManager.CALL_STATE_OFFHOOK;
            } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
                state = TelephonyManager.CALL_STATE_RINGING;
            }


            onCallStateChanged(context, state, number);
            // Added this line to remove broadcast from caller application
//            abortBroadcast();
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            telephonyManager.listen(new PhoneStateListener(context), PhoneStateListener.LISTEN_CALL_STATE);

        }
    }

    //Derived classes should override these to respond to specific events of interest
    protected void onIncomingCallStarted(Context ctx, String number, Date start) {
    }

    protected void onOutgoingCallStarted(Context ctx, String number, Date start) {
    }

    protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
    }

    protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
    }

    protected void onMissedCall(Context ctx, String number, Date start) {
    }

    //Deals with actual events

    //Incoming call-  goes from IDLE to RINGING when it rings, to OFFHOOK when it's answered, to IDLE when its hung up
    //Outgoing call-  goes from IDLE to OFFHOOK when it dials out, to IDLE when hung up
    public void onCallStateChanged(Context context, int state, String number) {
        if (lastState == state) {
            //No change, debounce extras
            return;
        }
        switch (state) {
            case TelephonyManager.CALL_STATE_RINGING:
                isIncoming = true;
                callStartTime = new Date();
                savedNumber = number;
                onIncomingCallStarted(context, number, callStartTime);
                break;
            case TelephonyManager.CALL_STATE_OFFHOOK:
                //Transition of ringing->offhook are pickups of incoming calls.  Nothing done on them
                if (lastState != TelephonyManager.CALL_STATE_RINGING) {
                    isIncoming = false;
                    callStartTime = new Date();
                    onOutgoingCallStarted(context, savedNumber, callStartTime);
                }
                break;
            case TelephonyManager.CALL_STATE_IDLE:
                //Went to idle-  this is the end of a call.  What type depends on previous state(s)
                if (lastState == TelephonyManager.CALL_STATE_RINGING) {
                    //Ring but no pickup-  a miss
                    onMissedCall(context, savedNumber, callStartTime);
                } else if (isIncoming) {
                    onIncomingCallEnded(context, savedNumber, callStartTime, new Date());
                } else {
                    onOutgoingCallEnded(context, savedNumber, callStartTime, new Date());
                }
                break;
        }
        lastState = state;
    }

    class PhoneStateListener extends PhoneStateListener {

        //private static final String TAG = "PhoneStateChanged";
        Context context; //Context to make Toast if required

        public PhoneStateListener(Context context) {
            super();
            this.context = context;
        }

        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            super.onCallStateChanged(state, incomingNumber);

            switch (state) {
                case TelephonyManager.DATA_CONNECTED:
                    LogUtil.debug(TAG, "Data connected send broadcast");
                    Intent dataConnectedIntent = new Intent(PhoneCallTimerService.DATA_CONNECTED);
                    context.sendBroadcast(dataConnectedIntent);
                    break;
                case TelephonyManager.DATA_DISCONNECTED:
                    LogUtil.debug(TAG, "Data disconnected send broadcast");
                    Intent dataDisConnectedIntent = new Intent(PhoneCallOutgoingService.DATA_DISCONNECTED);
                    context.sendBroadcast(dataDisConnectedIntent);
                    break;
                default:
                    break;
            }
        }
    }
}

public class CallReceiver extends PhoneCallReceiver {

    private static final String TAG = "CallReceiver";


    @Override
    protected void onIncomingCallStarted(Context ctx, String number, Date start) {
    }

    @Override
    protected void onOutgoingCallStarted(final Context ctx, final String number, Date start) {
        LogUtil.debug(TAG, "Outgoing call  started from  :: " + number);
        final String name = Utils.getContactName(ctx, number);
        Handler outgoingCallHandler = new Handler();
        outgoingCallHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                if (!Utils.isMyServiceRunning(PhoneCallOutgoingService.class, ctx) && !Utils.isMyServiceRunning(PhoneCallTimerService.class, ctx)) {
                    Intent outGoingCallService = new Intent(ctx, PhoneCallOutgoingService.class);
                    if (name != null && name.length() > 0) {
                        outGoingCallService.putExtra(CallReceiver.CALLER_NUMBER, name);
                    } else {
                        outGoingCallService.putExtra(CallReceiver.CALLER_NUMBER, number);
                    }
                    ctx.startService(outGoingCallService);
                } else {
                    LogUtil.error(TAG, "Outgoing call service already started");
                }
            }
        }, 2000);

    }

    @Override
    protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
        LogUtil.debug(TAG, "Incoming call  end from  :: " + number);
        Intent callTerminatedIntent = new Intent(ACTION_CALL_TERMINATED);
        ctx.sendBroadcast(callTerminatedIntent);

    }

    @Override
    protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
        LogUtil.debug(TAG, "Outgoing call ended from  :: " + number);
        Intent dataDisConnectedIntent = new Intent(PhoneCallOutgoingService.DATA_DISCONNECTED);
        ctx.sendBroadcast(dataDisConnectedIntent);
    }

    @Override
    protected void onMissedCall(Context ctx, String number, Date start) {
        LogUtil.debug(TAG, "Missed call  from  :: " + number);
        Intent missedCallIntent = new Intent(ACTION_CALL_MISSED);
        ctx.sendBroadcast(missedCallIntent);
    }

---

当然，有些代码对你的应用程序并不重要，所以请评论或删除该行。

你想禁用手机的基本功能吗。真的吗？那么你就是那个了解历史的人：D耶，哈哈哈，有没有办法把我的答案贴出来

public abstract class PhoneCallReceiver extends BroadcastReceiver {

    private static final String TAG = "PhoneCallReceiver";

    //The receiver will be recreated whenever android feels like it.  We need a static variable to remember data between instantiations

    private static int lastState = TelephonyManager.CALL_STATE_IDLE;
    private static Date callStartTime;
    private static boolean isIncoming;
    private static String savedNumber;  //because the passed incoming is only valid in ringing


    @Override
    public void onReceive(Context context, Intent intent) {

        //We listen to two intents.  The new outgoing call only tells us of an outgoing call.  We use it to get the number.
        if (intent.getAction().equals("android.intent.action.NEW_OUTGOING_CALL")) {
            savedNumber = intent.getExtras().getString("android.intent.extra.PHONE_NUMBER");
        } else {
            String stateStr = intent.getExtras().getString(TelephonyManager.EXTRA_STATE);
            String number = intent.getExtras().getString(TelephonyManager.EXTRA_INCOMING_NUMBER);
            int state = 0;
            if (stateStr.equals(TelephonyManager.EXTRA_STATE_IDLE)) {
                state = TelephonyManager.CALL_STATE_IDLE;
            } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_OFFHOOK)) {
                state = TelephonyManager.CALL_STATE_OFFHOOK;
            } else if (stateStr.equals(TelephonyManager.EXTRA_STATE_RINGING)) {
                state = TelephonyManager.CALL_STATE_RINGING;
            }


            onCallStateChanged(context, state, number);
            // Added this line to remove broadcast from caller application
//            abortBroadcast();
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            telephonyManager.listen(new PhoneStateListener(context), PhoneStateListener.LISTEN_CALL_STATE);

        }
    }

    //Derived classes should override these to respond to specific events of interest
    protected void onIncomingCallStarted(Context ctx, String number, Date start) {
    }

    protected void onOutgoingCallStarted(Context ctx, String number, Date start) {
    }

    protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
    }

    protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
    }

    protected void onMissedCall(Context ctx, String number, Date start) {
    }

    //Deals with actual events

    //Incoming call-  goes from IDLE to RINGING when it rings, to OFFHOOK when it's answered, to IDLE when its hung up
    //Outgoing call-  goes from IDLE to OFFHOOK when it dials out, to IDLE when hung up
    public void onCallStateChanged(Context context, int state, String number) {
        if (lastState == state) {
            //No change, debounce extras
            return;
        }
        switch (state) {
            case TelephonyManager.CALL_STATE_RINGING:
                isIncoming = true;
                callStartTime = new Date();
                savedNumber = number;
                onIncomingCallStarted(context, number, callStartTime);
                break;
            case TelephonyManager.CALL_STATE_OFFHOOK:
                //Transition of ringing->offhook are pickups of incoming calls.  Nothing done on them
                if (lastState != TelephonyManager.CALL_STATE_RINGING) {
                    isIncoming = false;
                    callStartTime = new Date();
                    onOutgoingCallStarted(context, savedNumber, callStartTime);
                }
                break;
            case TelephonyManager.CALL_STATE_IDLE:
                //Went to idle-  this is the end of a call.  What type depends on previous state(s)
                if (lastState == TelephonyManager.CALL_STATE_RINGING) {
                    //Ring but no pickup-  a miss
                    onMissedCall(context, savedNumber, callStartTime);
                } else if (isIncoming) {
                    onIncomingCallEnded(context, savedNumber, callStartTime, new Date());
                } else {
                    onOutgoingCallEnded(context, savedNumber, callStartTime, new Date());
                }
                break;
        }
        lastState = state;
    }

    class PhoneStateListener extends PhoneStateListener {

        //private static final String TAG = "PhoneStateChanged";
        Context context; //Context to make Toast if required

        public PhoneStateListener(Context context) {
            super();
            this.context = context;
        }

        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            super.onCallStateChanged(state, incomingNumber);

            switch (state) {
                case TelephonyManager.DATA_CONNECTED:
                    LogUtil.debug(TAG, "Data connected send broadcast");
                    Intent dataConnectedIntent = new Intent(PhoneCallTimerService.DATA_CONNECTED);
                    context.sendBroadcast(dataConnectedIntent);
                    break;
                case TelephonyManager.DATA_DISCONNECTED:
                    LogUtil.debug(TAG, "Data disconnected send broadcast");
                    Intent dataDisConnectedIntent = new Intent(PhoneCallOutgoingService.DATA_DISCONNECTED);
                    context.sendBroadcast(dataDisConnectedIntent);
                    break;
                default:
                    break;
            }
        }
    }
}

public class CallReceiver extends PhoneCallReceiver {

    private static final String TAG = "CallReceiver";


    @Override
    protected void onIncomingCallStarted(Context ctx, String number, Date start) {
    }

    @Override
    protected void onOutgoingCallStarted(final Context ctx, final String number, Date start) {
        LogUtil.debug(TAG, "Outgoing call  started from  :: " + number);
        final String name = Utils.getContactName(ctx, number);
        Handler outgoingCallHandler = new Handler();
        outgoingCallHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                if (!Utils.isMyServiceRunning(PhoneCallOutgoingService.class, ctx) && !Utils.isMyServiceRunning(PhoneCallTimerService.class, ctx)) {
                    Intent outGoingCallService = new Intent(ctx, PhoneCallOutgoingService.class);
                    if (name != null && name.length() > 0) {
                        outGoingCallService.putExtra(CallReceiver.CALLER_NUMBER, name);
                    } else {
                        outGoingCallService.putExtra(CallReceiver.CALLER_NUMBER, number);
                    }
                    ctx.startService(outGoingCallService);
                } else {
                    LogUtil.error(TAG, "Outgoing call service already started");
                }
            }
        }, 2000);

    }

    @Override
    protected void onIncomingCallEnded(Context ctx, String number, Date start, Date end) {
        LogUtil.debug(TAG, "Incoming call  end from  :: " + number);
        Intent callTerminatedIntent = new Intent(ACTION_CALL_TERMINATED);
        ctx.sendBroadcast(callTerminatedIntent);

    }

    @Override
    protected void onOutgoingCallEnded(Context ctx, String number, Date start, Date end) {
        LogUtil.debug(TAG, "Outgoing call ended from  :: " + number);
        Intent dataDisConnectedIntent = new Intent(PhoneCallOutgoingService.DATA_DISCONNECTED);
        ctx.sendBroadcast(dataDisConnectedIntent);
    }

    @Override
    protected void onMissedCall(Context ctx, String number, Date start) {
        LogUtil.debug(TAG, "Missed call  from  :: " + number);
        Intent missedCallIntent = new Intent(ACTION_CALL_MISSED);
        ctx.sendBroadcast(missedCallIntent);
    }