android 电话监听和拦截

一、首先在manifest.xml文件中获取监听电话权限，注册监听电话的Activity

 <receiver android:name=".PhoneReceiver">
             <intent-filter android:priority="1000">
                 <action android:name="android.intent.action.PHONE_STATE"/>
                 <action android:name="android.intent.action.NEW_OUTGOING_CALL" />
             </intent-filter>
         </receiver>

1 <!-- 添加访问手机电话状态的权限 --> 2 <uses-permission android:name="android.permission.READ_PHONE_STATE" />

二、实现过程中主要问题为接口ITelephony，是Android系统Phone类中TelephonyManager提供给上层应用程序用户与telephony进行操作交互的接口。，必须通过AIDL（Android Interface Definition Language,即Android接口定义语言）。

　　具体操作就是在src文件在新建一个包，包名为：com.android.internal.telephony，在这个包里面新建一个名为ITelephony.aidl ，本文主要通过接口获得endCall()函数来拦截电话。最后rebuild project一下，在android studio 本工程的packets同目录下自动生成ITelephony.java文件

 /*
 * 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();
 }

三、主要实现代码

在Activity中import com.android.internal.telephony.ITelephony;就可以使用ITelephony接口

 package com.example.administrator.locker2;

 import java.lang.reflect.Method;

 import android.app.Service;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
 import android.telephony.PhoneStateListener;
 import android.telephony.TelephonyManager;
 import android.util.Log;

 import com.android.internal.telephony.ITelephony;

 public class PhoneReceiver extends BroadcastReceiver {
     String TAG = "PhoneReceiver";

     @Override
     public void onReceive(Context context, Intent intent) {
         if (intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)) {
             // 如果是去电（拨出）
         } else {
             TelephonyManager tm = (TelephonyManager) context.getSystemService(Service.TELEPHONY_SERVICE);
             // 设置一个监听器
             tm.listen(listener, PhoneStateListener.LISTEN_CALL_STATE);
         }
     }

     PhoneStateListener listener = new PhoneStateListener() {

         @Override
         public void onCallStateChanged(int state, String incomingNumber) {
             // state 当前状态 incomingNumber,貌似没有去电的API
             super.onCallStateChanged(state, incomingNumber);
             switch (state) {
                 //手机空闲了
                 case TelephonyManager.CALL_STATE_IDLE:
                     break;
                 //电话被挂起
                 case TelephonyManager.CALL_STATE_OFFHOOK:
                     break;
                 // 当电话呼入时
                 case TelephonyManager.CALL_STATE_RINGING:
                     Log.e(TAG, "来电号码是："+ incomingNumber);
                     // 如果该号码属于黑名单
                     if (incomingNumber.equals("*********")) {
                         // TODO:如果是黑名单，就进行屏蔽
                         stopCall();
 　　　　　　　　　　　　　}
                     break;
             }
         }
     };

     public void stopCall() {

         try {
             Method method = Class.forName("android.os.ServiceManager").getMethod("getService", String.class);
             // 获取远程TELEPHONY_SERVICE的IBinder对象的代理
             IBinder binder = (IBinder) method.invoke(null, new Object[] { "phone" });
             // 将IBinder对象的代理转换为ITelephony对象
             ITelephony telephony = ITelephony.Stub.asInterface(binder);
             // 挂断电话
             telephony.endCall();
             //telephony.cancelMissedCallsNotification();

         } catch (Exception e) {
         }

     }

 }

四、真机测试，当本机开启该应用时，拦截号码拨号方显示您所拨打的电话正在通话中