Android学习小记-----拦截电话/拒接电话，规避拒接电话前响一声或者两声的问题

　　前段时间做了一个简单的Demo，拦截电话并拒接。其中遇到一个小问题，拦截会有延迟，偶尔会响一声或者两声，之后才能拒接成功。那么怎么解决响一两声的问题呢？确实还费了点时间呢！谁叫咱的技术不行呢？这里记录一下拦截来电并拒接以及响铃声的问题的处理。

　　1，拦截电话需要接收来电的广播，android.intent.action.PHONE_STATE。写一个Receiver来接收广播。

import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;

public class PhoneBroadcastReceiver  extends BroadcastReceiver{ 
       
    private static final String TAG = "PhoneBroadcastReceiver"; 
    
    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        Log.i(TAG, "zjq action:"+ action);
        String phoneNumber = intent.getStringExtra(Intent.EXTRA_PHONE_NUMBER);
        //如果是去电 
        if((Intent.ACTION_NEW_OUTGOING_CALL).equals(action)){
            Log.i(TAG, "call out:"+ phoneNumber);  
            Intent i = new Intent(Intent.ACTION_CALL,Uri.parse("tel:" + phoneNumber));
            i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startActivity(i);
        }else if("android.intent.action.PHONE_STATE".equals(action)){ 
            //ACTION_PHONE_STATE_CHANGED
            //监听电话状态的改变
            Log.i(TAG, "phone state changed");
            
            //来电，判定是否拒接等操作，在这里处理：
            Intent inte = new Intent();
            inte.setComponent(new ComponentName("com.zjq.calldemo"
                    ,"com.zjq.calldemo.PhoneHangUpService"));
            inte.setAction("yd.calldemo.action.PhoneHangUpService");
            context.startService(inte);
        }
    }    
}

2，广播需要在Manifest.xml中注册：

<receiver android:name=".PhoneBroadcastReceiver">
            <intent-filter >
                <action android:name="android.intent.action.BOOT_COMPLETED" />
                <action android:name="android.intent.action.NEW_OUTGOING_CALL"/>
                <action android:name="android.intent.action.PHONE_STATE"/> 
            </intent-filter>
        </receiver>

增加权限：

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

3，接下来处理广播，拦截到的来电，放在service中处理，监听来电的三种状态：

CALL_STATE_RINGING   正在响铃，电话进来时

CALL_STATE_IDLE   已挂断，无任何状态时

CALL_STATE_OFFHOOK  接听，接起电话时

延时导致的响一声问题，通过切换声音模式来处理，当判断来电为需要拒接的电话时，将铃声设置为静音，不让其响铃，待成功拒接后，回复为普通模式（回复声音）这样就规避了铃声的问题。当然方法有很多，可能我这种比较投机，通过尝试来看，这种相对简单一些。代码如下：

import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.media.AudioManager;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.telephony.PhoneStateListener;
import android.telephony.SmsManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;

import com.android.internal.telephony.ITelephony;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;

public class PhoneHangUpService extends Service {
    private static final String TAG = "PhoneHangUpService";
    private static final int MSG_DELETE_CALL_LOG = 1;

    private MyPhoneStateListener mPhoneStateListener;
    private TelephonyManager mTelephonyManager;
    private Context context;
    public AudioManager am ;
    private Handler mHandler = new Handler() {
        @Override
        public void dispatchMessage(Message msg) {
            switch (msg.what) {
                case MSG_DELETE_CALL_LOG:
                    String number = (String) msg.obj;
//
                    break;
            }
        }

    };

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate");
        context = this;
        //声明监听类，在监听类中实现具体处理
        mPhoneStateListener = new MyPhoneStateListener();
        mTelephonyManager = (TelephonyManager) getSystemService(Service.TELEPHONY_SERVICE);
        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
        
        am = (AudioManager)context.getSystemService(Context.AUDIO_SERVICE);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        mTelephonyManager.listen(mPhoneStateListener, 0);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    //挂断电话方法
    private boolean hangUp() {
        Class<TelephonyManager> c = TelephonyManager.class;
        ITelephony iTelephony = null;
        Method getITelephonyMethod = null;
        try {
            getITelephonyMethod = c.getDeclaredMethod("getITelephony", (Class[]) null);
            getITelephonyMethod.setAccessible(true);
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        try {
            iTelephony = (ITelephony)
                    getITelephonyMethod.invoke(mTelephonyManager, (Object[]) null);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        if (iTelephony != null) {
            boolean isSuccess = false;
            try {
                isSuccess = iTelephony.endCall();
                am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);//恢复会普通模式，恢复声音
                
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            return isSuccess;
        }
        return true;
    }
    
    //监听类，监听来电
    private final class MyPhoneStateListener extends android.telephony.PhoneStateListener {
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            super.onCallStateChanged(state, incomingNumber);
            Log.i(TAG, "zjq Number:" + incomingNumber);
            if (TelephonyManager.CALL_STATE_RINGING == state) {
                Log.i(TAG, "zhangjieqiong state:CALL_STATE_RINGING:" + incomingNumber);
                if (!TextUtils.isEmpty(incomingNumber) && PhoneUtils.isPhoneNumber(incomingNumber)) {
                    //拒接电话 当号码为135*****182时拒接
                    if ("135*****182".equals(incomingNumber)) {
                        am.setRingerMode(AudioManager.RINGER_MODE_SILENT);//设置为静音模式，解决延迟导致的响铃问题
                        Log.i(TAG, "zjq:the number is endcallnumber:"+incomingNumber);
                        if (hangUp()) {
                            Log.i(TAG, "zjq end call success ");
                            Message msg = mHandler.obtainMessage(MSG_DELETE_CALL_LOG);
                            msg.obj = incomingNumber;
                            mHandler.sendMessageDelayed(msg, 2000);
                            //发送一条短信，提示拒接成功
                            handleSetSystemParamSms(incomingNumber, incomingNumber +" endcall success");
                        }
                    }
                }
            }else if(TelephonyManager.CALL_STATE_IDLE == state){
                //挂断
                //挂断电话可以在这里处理
                Log.i(TAG, "zjq state: hang up(endcall)");
            }else if(TelephonyManager.CALL_STATE_OFFHOOK == state){
                //接听
                Log.i(TAG, "zjq state: answer:"+ incomingNumber);
            }
        }

    }

    
    //发送短信方法
    private void handleSetSystemParamSms(String phone, String body) {
        Log.d(TAG, "user get location");
        String msg = body ;
        if (msg != null) {
            Log.d(TAG, "msgBody lenth = " + msg.length());
            SmsManager sms = SmsManager.getDefault();
            List<String> texts = sms.divideMessage(msg);
            for (String text : texts) {
                Log.d(TAG, "zjq send sms to:" + phone);
                sms.sendTextMessage(phone, null, text, null, null);
            }
        }
    }
}

4,不能忘记增加aidl，通过调用系统接口来拒接电话，方法：iTelephony.endCall()：

其中ITelephony.aidl中内容如下（加入常用的几种方法即可，这个不是自己写的，手机系统的接口类，直接拿来用了，嘿嘿）

package com.android.internal.telephony;

import android.os.Bundle;
import java.util.List;

/**
 * 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 {

    /**
     * End call or go to the Home screen
     *
     * @return whether it hung up
     */
    boolean endCall();
    
     /**
     * Check if the phone is idle.
     * @return true if the phone state is IDLE.
     */
    boolean isIdle();
}

网上这种方法介绍的有很多，我这里记录一下，方便以后自己查找。有不足之处，欢迎指正！