Android来电监听和去电监听

时间：2023-08-05 12:12:38

我觉得写文章就得写得有用一些的，必须要有自己的思想，关于来电去电监听将按照下面三个问题展开

1、监听来电去电有什么用？

2、怎么监听，来电去电监听方式一样吗？

3、实战，有什么需要特别注意地方？

一、监听来电去电能干什么

1、能够对监听到的电话做个标识，告诉用户这个电话是诈骗、推销、广告什么的

2、能够针对那些特殊的电话进行自动挂断，避免打扰到用户

二、来电去电的监听方式（不一样的方式）

2.1 来去电监听方式一（PhoneStateListener）

　　来电监听是使用PhoneStateListener类，使用方式是，将PhoneStateListener对象（一般是自己继承PhoneStateListener类完成一些封装）注册到系统电话管理服务中去（TelephonyManager）

　　然后通过PhoneStateListener的回调方法onCallStateChanged(int state, String incomingNumber) 实现来电的监听 （详细实现可以参考后面给出的拓展阅读部分）

注册监听

private void registerPhoneStateListener() {

    CustomPhoneStateListener customPhoneStateListener = new CustomPhoneStateListener(this);

    TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

    if (telephonyManager != null) {
telephonyManager.listen(customPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);

    }

}

PhoneStateListener的onCallStateChanged方法监听来电状态

package com.phone.listen;

import android.content.Context;

import android.telephony.PhoneStateListener;

import android.telephony.ServiceState;

import android.telephony.TelephonyManager;

import android.util.Log;

/**

 * 来去电监听

 */

public class CustomPhoneStateListener extends PhoneStateListener {

    private Context mContext;

    public CustomPhoneStateListener(Context context) {

        mContext = context;

    }

    @Override

    public void onServiceStateChanged(ServiceState serviceState) {

        super.onServiceStateChanged(serviceState);

        Log.d(PhoneListenService.TAG, "CustomPhoneStateListener onServiceStateChanged: " + serviceState);

    }

    @Override

    public void onCallStateChanged(int state, String incomingNumber) {

        Log.d(PhoneListenService.TAG, "CustomPhoneStateListener state: " 
              + state + " incomingNumber: " + incomingNumber);

        switch (state) {
case TelephonyManager.CALL_STATE_IDLE:      // 电话挂断

                break;
case TelephonyManager.CALL_STATE_RINGING:   // 电话响铃

                Log.d(PhoneListenService.TAG, "CustomPhoneStateListener onCallStateChanged endCall");

                HangUpTelephonyUtil.endCall(mContext);

                break;
case TelephonyManager.CALL_STATE_OFFHOOK:   // 来电接通 或者 去电，去电接通  但是没法区分

                break;

        }

    }

}

三种状态源码解释

/** Device call state: No activity. */

public static final int CALL_STATE_IDLE = 0;    // 电话挂断

/** Device call state: Ringing. A new call arrived and is

 *  ringing or waiting. In the latter case, another call is

 *  already active. */

public static final int CALL_STATE_RINGING = 1;    // 来电响铃

/** Device call state: Off-hook. At least one call exists

  * that is dialing, active, or on hold, and no calls are ringing

  * or waiting. */

public static final int CALL_STATE_OFFHOOK = 2;    // 来电接通 或者 去电拨号 但是没法区分出来

2.2 来去电方式二（广播监听）

<receiver android:name=".PhoneStateReceiver"

    android:enabled="true"

    android:process=":PhoneListenService">

    <intent-filter>

        <action android:name="android.intent.action.NEW_OUTGOING_CALL" />

        <action android:name="android.intent.action.PHONE_STATE" />

    </intent-filter>

</receiver>
package com.phone.listen;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.telephony.TelephonyManager;

import android.util.Log;

/**

 * Created by popfisher on 2017/11/6.

 */

public class PhoneStateReceiver extends BroadcastReceiver {

    @Override

    public void onReceive(Context context, Intent intent) {

        String action = intent.getAction();

        Log.d(PhoneListenService.TAG, "PhoneStateReceiver action: " + action);

        String resultData = this.getResultData();

        Log.d(PhoneListenService.TAG, "PhoneStateReceiver getResultData: " + resultData);

        if (action.equals(Intent.ACTION_NEW_OUTGOING_CALL)) {

            // 去电，可以用定时挂断

            // 双卡的手机可能不走这个Action

            String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);

            Log.d(PhoneListenService.TAG, "PhoneStateReceiver EXTRA_PHONE_NUMBER: " + phoneNumber);

        } else {

            // 来电去电都会走

            // 获取当前电话状态

            String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);

            Log.d(PhoneListenService.TAG, "PhoneStateReceiver onReceive state: " + state);

            // 获取电话号码

            String extraIncomingNumber = intent.getStringExtra(TelephonyManager.EXTRA_INCOMING_NUMBER);

            Log.d(PhoneListenService.TAG, "PhoneStateReceiver onReceive extraIncomingNumber: " + extraIncomingNumber);

            if (state.equalsIgnoreCase(TelephonyManager.EXTRA_STATE_RINGING)) {

                Log.d(PhoneListenService.TAG, "PhoneStateReceiver onReceive endCall");

                HangUpTelephonyUtil.endCall(context);

            }

        }

    }

}

三、实战，有什么需要特别注意地方

3.1 双卡双待的手机怎么获取

　　对于双卡手机，每张卡都对应一个Service和一个PhoneStateListener，需要给每个服务注册自己的PhoneStateListener，服务的名称还会有点变化，厂商可能会修改

public ArrayList<String> getMultSimCardInfo() {

    // 获取双卡的信息，这个也是经验尝试出来的，不知道其他厂商有什么坑

    ArrayList<String> phoneServerList = new ArrayList<String>();

    for(int i = 1; i < 3; i++) {

        try {

            String phoneServiceName;

            if (MiuiUtils.isMiuiV6()) {

                phoneServiceName = "phone." + String.valueOf(i-1);

            } else {

                phoneServiceName = "phone" + String.valueOf(i);

            }

            // 尝试获取服务看是否能获取到

            IBinder iBinder = ServiceManager.getService(phoneServiceName);

            if(iBinder == null) continue;

            ITelephony iTelephony = ITelephony.Stub.asInterface(iBinder);

            if(iTelephony == null) continue;

            phoneServerList.add(phoneServiceName);

        } catch(Exception e) {

            e.printStackTrace();

        }

    }
// 这个是默认的

    phoneServerList.add(Context.TELEPHONY_SERVICE);
return phoneServerList;

}

3.2 挂断电话

　　挂断电话使用系统服务提供的接口去挂断，但是挂断电话是个并不能保证成功的方法，所以会有多种方式挂断同时使用，下面提供

package com.phone.listen;

import android.content.Context;

import android.os.RemoteException;

import android.telephony.TelephonyManager;

import com.android.internal.telephony.ITelephony;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

/**

 * 封装挂断电话接口

 */

public class HangUpTelephonyUtil {

    public static boolean endCall(Context context) {

        boolean callSuccess = false;

        ITelephony telephonyService = getTelephonyService(context);

        try {

            if (telephonyService != null) {
callSuccess = telephonyService.endCall();

            }

        } catch (RemoteException e) {

            e.printStackTrace();

        } catch (Exception e){

            e.printStackTrace();

        }

        if (callSuccess == false) {

            Executor eS = Executors.newSingleThreadExecutor();

            eS.execute(new Runnable() {

                @Override

                public void run() {

                    disconnectCall();

                }

            });

            callSuccess = true;

        }

        return callSuccess;

    }

    private static ITelephony getTelephonyService(Context context) {

        TelephonyManager telephonyManager = (TelephonyManager) 
　　　　　　　　　　　　　　context.getSystemService(Context.TELEPHONY_SERVICE);

        Class clazz;

        try {
clazz = Class.forName(telephonyManager.getClass().getName());

            Method method = clazz.getDeclaredMethod("getITelephony");

            method.setAccessible(true);

            return (ITelephony) method.invoke(telephonyManager);

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        } catch (NoSuchMethodException e) {

            e.printStackTrace();

        } catch (IllegalArgumentException e) {

            e.printStackTrace();

        } catch (IllegalAccessException e) {

            e.printStackTrace();

        } catch (InvocationTargetException e) {

            e.printStackTrace();

        }

        return null;

    }

    private static boolean disconnectCall() {

        Runtime runtime = Runtime.getRuntime();

        try {

            runtime.exec("service call phone 5 \n");

        } catch (Exception exc) {

            exc.printStackTrace();

            return false;

        }

        return true;

    }

    // 使用endCall挂断不了，再使用killCall反射调用再挂一次

    public static 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

            return false;

        }

        return true;

    }

}

　　ITelephony接口在layoutlib.jar包中，需要导入 android sdk目录\platforms\android-8\data\layoutlib.jar

挂断电话需要权限

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


3.3 监听来去电状态放到后台服务（独立进程）




<service android:name=".PhoneListenService"

            android:label="Android来电监听"

            android:process=":PhoneListenService"/>




来去电监听Service




package com.phone.listen;

import android.app.Service;

import android.content.Context;

import android.content.Intent;

import android.os.IBinder;

import android.telephony.PhoneStateListener;

import android.telephony.TelephonyManager;

import android.util.Log;

/**

 * 来去电监听服务

 */

public class PhoneListenService extends Service {

    public static final String TAG = PhoneListenService.class.getSimpleName();

    public static final String ACTION_REGISTER_LISTENER = "action_register_listener";

    @Override

    public void onCreate() {

        super.onCreate();

        Log.d(TAG, "onCreate");

    }

    @Override

    public int onStartCommand(Intent intent, int flags, int startId) {

        Log.d(TAG, "onStartCommand action: " + intent.getAction() + 
　　　　　　　　　　" flags: " + flags + " startId: " + startId);

        String action = intent.getAction();

        if (action.equals(ACTION_REGISTER_LISTENER)) {

            registerPhoneStateListener();

        }

        return super.onStartCommand(intent, flags, startId);

    }

    private void registerPhoneStateListener() {

        CustomPhoneStateListener customPhoneStateListener = new CustomPhoneStateListener(this);

        TelephonyManager telephonyManager = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);

        if (telephonyManager != null) {

            telephonyManager.listen(customPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);

        }

    }

}




3.4 整体配置文件




<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.phone.listen">

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

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

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

    <application

        android:allowBackup="true"

        android:icon="@mipmap/ic_launcher"

        android:label="@string/app_name"

        android:supportsRtl="true"

        android:theme="@style/AppTheme">

        <activity android:name=".MainActivity">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

        <service android:name=".PhoneListenService"

            android:label="Android来电监听"

            android:process=":PhoneListenService"/>

        <receiver android:name=".PhoneStateReceiver"

            android:enabled="true"

            android:process=":PhoneListenService">

            <intent-filter>

                <action android:name="android.intent.action.NEW_OUTGOING_CALL" />

                <action android:name="android.intent.action.PHONE_STATE" />

            </intent-filter>

        </receiver>

    </application>

</manifest>




3.5 Github示例


https://github.com/PopFisher/PhoneStateListen


拓展阅读：


这篇文章重点从整体框架机制方面来介绍电话监听


http://www.cnblogs.com/bastard/archive/2012/11/23/2784559.html


这篇文章重点介绍一些api方法已经变量的含义


http://blog.csdn.net/skiffloveblue/article/details/7491618
相关文章