Android开发中如何实现自动挂断电话的代码

实现方法一代码

1、准备AIDL文件

挂断电话的AIDL文件都是Android自带的文件，我们可以从Android的源代码中找到这两个文件，它们分别是NeighboringCellInfo.aidl和ITelephony.aidl

我把NeighboringCellInfo.aidl放在项目的android.telephony包下，将ITelephony.aidl放在com.android.internal.telephony包下

NeighboringCellInfo.aid具体内容如下:

/* //device/java/android/android/content/Intent.aidl 
** 
** Copyright 2007, The Android Open Source Project 
** 
** Licensed under the Apache License, Version 2.0 (the "License"); 
** you may not use this file except in compliance with the License. 
** You may obtain a copy of the License at 
** 
**     http://www.apache.org/licenses/LICENSE-2.0 
** 
** Unless required by applicable law or agreed to in writing, software 
** distributed under the License is distributed on an "AS IS" BASIS, 
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
** See the License for the specific language governing permissions and 
** limitations under the License. 
*/  
  
package android.telephony;  
  
parcelable NeighboringCellInfo;

ITelephony.aidl具体内容如下：

/* 
 * Copyright (C) 2007 The Android Open Source Project 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */  
  
package com.android.internal.telephony;  
  
import android.os.Bundle;  
import java.util.List;  
import android.telephony.NeighboringCellInfo;  
  
/** 
 * Interface used to interact with the phone.  Mostly this is used by the 
 * TelephonyManager class.  A few places are still using this directly. 
 * Please clean them up if possible and use TelephonyManager insteadl. 
 * 
 * {@hide} 
 */  
interface ITelephony {  
  
    /** 
     * Dial a number. This doesn't place the call. It displays 
     * the Dialer screen. 
     * @param number the number to be dialed. If null, this 
     * would display the Dialer screen with no number pre-filled. 
     */  
    void dial(String number);  
  
    /** 
     * Place a call to the specified number. 
     * @param number the number to be called. 
     */  
    void call(String number);  
  
    /** 
     * If there is currently a call in progress, show the call screen. 
     * The DTMF dialpad may or may not be visible initially, depending on 
     * whether it was up when the user last exited the InCallScreen. 
     * 
     * @return true if the call screen was shown. 
     */  
    boolean showCallScreen();  
  
    /** 
     * Variation of showCallScreen() that also specifies whether the 
     * DTMF dialpad should be initially visible when the InCallScreen 
     * comes up. 
     * 
     * @param showDialpad if true, make the dialpad visible initially, 
     *                    otherwise hide the dialpad initially. 
     * @return true if the call screen was shown. 
     * 
     * @see showCallScreen 
     */  
    boolean showCallScreenWithDialpad(boolean showDialpad);  
  
    /** 
     * End call or go to the Home screen 
     * 
     * @return whether it hung up 
     */  
    boolean endCall();  
  
    /** 
     * Answer the currently-ringing call. 
     * 
     * If there's already a current active call, that call will be 
     * automatically put on hold.  If both lines are currently in use, the 
     * current active call will be ended. 
     * 
     * TODO: provide a flag to let the caller specify what policy to use 
     * if both lines are in use.  (The current behavior is hardwired to 
     * "answer incoming, end ongoing", which is how the CALL button 
     * is specced to behave.) 
     * 
     * TODO: this should be a oneway call (especially since it's called 
     * directly from the key queue thread). 
     */  
    void answerRingingCall();  
  
    /** 
     * Silence the ringer if an incoming call is currently ringing. 
     * (If vibrating, stop the vibrator also.) 
     * 
     * It's safe to call this if the ringer has already been silenced, or 
     * even if there's no incoming call.  (If so, this method will do nothing.) 
     * 
     * TODO: this should be a oneway call too (see above). 
     *       (Actually *all* the methods here that return void can 
     *       probably be oneway.) 
     */  
    void silenceRinger();  
  
    /** 
     * Check if we are in either an active or holding call 
     * @return true if the phone state is OFFHOOK. 
     */  
    boolean isOffhook();  
  
    /** 
     * Check if an incoming phone call is ringing or call waiting. 
     * @return true if the phone state is RINGING. 
     */  
    boolean isRinging();  
  
    /** 
     * Check if the phone is idle. 
     * @return true if the phone state is IDLE. 
     */  
    boolean isIdle();  
  
    /** 
     * Check to see if the radio is on or not. 
     * @return returns true if the radio is on. 
     */  
    boolean isRadioOn();  
  
    /** 
     * Check if the SIM pin lock is enabled. 
     * @return true if the SIM pin lock is enabled. 
     */  
    boolean isSimPinEnabled();  
  
    /** 
     * Cancels the missed calls notification. 
     */  
    void cancelMissedCallsNotification();  
  
    /** 
     * Supply a pin to unlock the SIM.  Blocks until a result is determined. 
     * @param pin The pin to check. 
     * @return whether the operation was a success. 
     */  
    boolean supplyPin(String pin);  
  
    /** 
     * Handles PIN MMI commands (PIN/PIN2/PUK/PUK2), which are initiated 
     * without SEND (so <code>dial</code> is not appropriate). 
     * 
     * @param dialString the MMI command to be executed. 
     * @return true if MMI command is executed. 
     */  
    boolean handlePinMmi(String dialString);  
  
    /** 
     * Toggles the radio on or off. 
     */  
    void toggleRadioOnOff();  
  
    /** 
     * Set the radio to on or off 
     */  
    boolean setRadio(boolean turnOn);  
  
    /** 
     * Request to update location information in service state 
     */  
    void updateServiceLocation();  
  
    /** 
     * Enable location update notifications. 
     */  
    void enableLocationUpdates();  
  
    /** 
     * Disable location update notifications. 
     */  
    void disableLocationUpdates();  
  
    /** 
     * Enable a specific APN type. 
     */  
    int enableApnType(String type);  
  
    /** 
     * Disable a specific APN type. 
     */  
    int disableApnType(String type);  
  
    /** 
     * Allow mobile data connections. 
     */  
    boolean enableDataConnectivity();  
  
    /** 
     * Disallow mobile data connections. 
     */  
    boolean disableDataConnectivity();  
  
    /** 
     * Report whether data connectivity is possible. 
     */  
    boolean isDataConnectivityPossible();  
  
    Bundle getCellLocation();  
  
    /** 
     * Returns the neighboring cell information of the device. 
     */  
    List<NeighboringCellInfo> getNeighboringCellInfo();  
  
     int getCallState();  
     int getDataActivity();  
     int getDataState();  
  
    /** 
     * Returns the current active phone type as integer. 
     * Returns TelephonyManager.PHONE_TYPE_CDMA if RILConstants.CDMA_PHONE 
     * and TelephonyManager.PHONE_TYPE_GSM if RILConstants.GSM_PHONE 
     */  
    int getActivePhoneType();  
  
    /** 
     * Returns the CDMA ERI icon index to display 
     */  
    int getCdmaEriIconIndex();  
  
    /** 
     * Returns the CDMA ERI icon mode, 
     * 0 - ON 
     * 1 - FLASHING 
     */  
    int getCdmaEriIconMode();  
  
    /** 
     * Returns the CDMA ERI text, 
     */  
    String getCdmaEriText();  
  
    /** 
     * Returns true if CDMA provisioning needs to run. 
     */  
    boolean getCdmaNeedsProvisioning();  
  
    /** 
      * Returns the unread count of voicemails 
      */  
    int getVoiceMessageCount();  
  
    /** 
      * Returns the network type 
      */  
    int getNetworkType();  
      
    /** 
     * Return true if an ICC card is present 
     */  
    boolean hasIccCard();  
}

准备好文件后，会在项目的gen目录下自动生成与两个文件所在包一样的包，同时会自动生成ITelephony.java文件

如下图:

开发中如何实现自动挂断电话的代码-android 录屏实现代码">

2、新建PhoneUtils类，并写一个方法endCall()

这个方法就是挂断电话的方法，具体实现如下

//挂断电话  
public void endCall(String incomingNumber){  
    try {  
            Class<?> clazz = Class.forName("android.os.ServiceManager");  
            Method method = clazz.getMethod("getService", String.class);  
            IBinder ibinder = (IBinder) method.invoke(null, Context.TELEPHONY_SERVICE);  
            ITelephony iTelephony = ITelephony.Stub.asInterface(ibinder);  
            iTelephony.endCall();  
        }catch(Exception e){  
            e.printStrackTrace();  
        }  
}

3、注册权限

最后别忘了在AndroidManifest.xml文件中注册权限

具体实现如下:

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

实现方法二代码

Android自动挂断电话

android的新版本已经把Phone类给隐藏起来了，想要用代码实现挂断电话，就必须通过AIDL才行，

第一步：在程序中新建一个包，包名必须为：com.android.internal.telephony，因为要使用aidl，

第二步：在这个包里面新建一个名为ITelephony.aidl的文件，然后在文件里面写入代码：

package com.android.internal.telephony;
interface ITelephony{
boolean endCall();
void answerRingingCall();
}

然后保存，eclipse会自动在gen文件夹下生成一个ITelephony.java的类。

主程序的代码如下：

package ling.Phonemanager;
import java.lang.reflect.Method;
import android.app.Activity;
import android.os.Bundle;
import android.os.RemoteException;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import com.android.internal.telephony.ITelephony;
public class Phonemanager extends Activity {
    /** Called when the activity is first created. */
    private ITelephony  iTelephony;
    private TelephonyManager manager;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        phoner();
        manager.listen(new PhoneStateListener(){
   @Override
   public void onCallStateChanged(int state, String incomingNumber) {
    // TODO Auto-generated method stub
    super.onCallStateChanged(state, incomingNumber);
    switch(state){
    //判断是否有电话接入
    case 1:
     try {
      //当电话接入时，自动挂断。
      iTelephony.endCall();
      System.out.println("uncall");
     } catch (RemoteException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
    }
   }
         
        }, PhoneStateListener.LISTEN_CALL_STATE);
    }
    public void phoner(){
     manager = (TelephonyManager)getSystemService(TELEPHONY_SERVICE);
        Class <TelephonyManager> c = TelephonyManager.class; 
         Method getITelephonyMethod = null; 
         try { 
                getITelephonyMethod = c.getDeclaredMethod("getITelephony", (Class[])null); 
                getITelephonyMethod.setAccessible(true); 
          iTelephony = (ITelephony) getITelephonyMethod.invoke(manager, (Object[])null); 
         } catch (IllegalArgumentException e) { 
               e.printStackTrace(); 
         } catch (Exception e) { 
              e.printStackTrace(); 
         }
    }
}

只要在电话接入时，再加上一个判断电话号码是否是黑名单的功能，就可以做成一个黑名单的程序了，获取电话号码的函数是：getLine1Number()；

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索android
， int
， 文件
this
android 录屏实现代码、android 截屏代码实现、android 代码实现布局、android vpn 代码实现、android 代码实现圆角，以便于您获取更多的相关知识。