实现android手机来电拦截系统页面弹出自定义页面特效

如何实现android手机来电拦截系统页面弹出自定义页面特效，

首先：
    我们需要注册一个监听来电的广播PhoneStateReceiver 类：
其次：
    在onReceive里面我们获取android 电话状态的监听(来电和去电）
实现手机电话状态的监听，主要依靠两个类：TelephoneManger和PhoneStateListener。
TelephonseManger提供了取得手机基本服务的信息的一种方式。
因此应用程序可以使用TelephonyManager来探测手机基本服务的情况。
应用程序可以注册listener来监听电话状态的改变。我们不能对TelephonyManager进行实例化，
只能通过获取服务的形式：Context.getSystemService(Context.TELEPHONY_SERVICE);
特别注意来去电需要添加权限：

我在项目中主要监听
Intent.ACTION_NEW_OUTGOING_CALL  //去电广播意图

Intent.ACTION_NEW_OUTGOING_CALL  //拨打电话广播

android.intent.action.PHONE_STATE  //电话状态改变是会发送action

通过：numbers = intent.getStringExtra("incoming_number");获取number

最后：我主要的实现方法
CallTask(states,numbers);//去电处理， 启动ExhaleAnimation 类，在广播页面不宜处理很耗时的
操作，因为广播的生命周期很短，挂电话的时候可以监听挂电动作，然后把自己自定义的页面销毁。

public class PhoneStateReceiver extends BroadcastReceiver {
    public Context mContext;
    private AudioManager mAudioManager;
    int ringerMode;
    boolean isSystemRingtone;
    public String numbers;
     String outgoing_call;
      boolean outcall_value = false;
     @Override                
    public void onReceive(final Context context, Intent intent) {        
            
             mContext = context;
            mAudioManager = (AudioManager) context
                    .getSystemService(Context.AUDIO_SERVICE);
            ringerMode = mAudioManager.getRingerMode();
            TelephonyManager tm = (TelephonyManager) context
                    .getSystemService(Service.TELEPHONY_SERVICE);
            int states = tm.getCallState();
            String action = intent.getAction();
            isSystemRingtone = getRingMode();
            setMute(true);
            numbers = intent.getStringExtra("incoming_number");
            
        if (action.equals("android.intent.action.PHONE_STATE")) {        
            
            CallTask(states,numbers);
        }else if(intent.getAction().equals(Intent.ACTION_NEW_OUTGOING_CALL)){
             outcall_value = true;
             outgoing_call = this.getResultData();  
               ExhaledTask(outgoing_call);
         }         
    
    }

/**
      * 去电处理：
      * 读取数据库中去电规则，
      * 显示数据库中去电动漫
      * */
    
     private void ExhaledTask(String outgoing_number) {
            
           Intent i = new Intent(mContext,ExhaleAnimation.class);
           i.putExtra("number", outgoing_number);                    
           i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);                    
           mContext.startActivity(i);  
            
    }
    
     /**
      * 来电处理：
      * 判断来电的 状态，
      * 加载数据库中来电的规则
      * 显示来电动漫*/
    public void CallTask(int state,final String number){
        switch (state) {
        case TelephonyManager.CALL_STATE_IDLE:
            
            ToastUtil.alertLong(mContext, "空闲阶段");
            Log.i("IDLE", "ExhaleAnimation.EXHALEANIMATION ="+ ExhaleAnimation.EXHALEANIMATION );
//            if(ExhaleAnimation.EXHALEANIMATION != null){  
//                Log.i("IDLE", "if(ExhaleAnimation.EXHALEANIMATION != null)");
//            //    ExhaleAnimation.EXHALEANIMATION.releasePic();
//                endRinger();
//            }else
                if (AndroidInCallActivity.INSTANCE != null){
                new Thread(new Runnable() {
                    @Override
                    public void run() {  
                        saveInCall(false);
                        saveCallRinging(false);
                        setMute(false);
                      
                        AndroidInCallActivity.INSTANCE.pause();
                        AndroidInCallActivity.INSTANCE.onEnd();
                        AndroidInCallActivity.INSTANCE.finish();
                        
                    }
                }).start();
            }
             endRinger();
            break;
        case TelephonyManager.CALL_STATE_OFFHOOK:
            new Thread(new Runnable() {
                @Override
                public void run() {
                    saveInCall(true);
                    if (AndroidInCallActivity.INSTANCE != null) {
                        AndroidInCallActivity.INSTANCE.pause();
                        AndroidInCallActivity.INSTANCE.onAnswer();
                        AndroidInCallActivity.INSTANCE.finish();
                    }
                }
            }).start();
            break;
        case TelephonyManager.CALL_STATE_RINGING:
        
            saveCallRinging(true);
            new Thread(new Runnable() {
                @Override
                public void run() {
                    if (isInCall()) {
                        return;
                    }
                    if (isSystemRingtone) {
                        startIntent(mContext, true, number);
                    } else {
                        startIntent(mContext, false, number);
                    }
                }
            }).start();
            break;
        }
        
     }

private void setMute(boolean isRingtone) {
        if (ringerMode == AudioManager.RINGER_MODE_NORMAL) {
            mAudioManager.setStreamMute(AudioManager.STREAM_RING, isRingtone);
        }
    }

public void endRinger() {
        ActivityManager activityManager = (ActivityManager) mContext
                .getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningAppProcessInfo> p = activityManager
                .getRunningAppProcesses();
        for (RunningAppProcessInfo r : p) {
            if (r.processName.equalsIgnoreCase("com.andhat.outcall")) {
                android.os.Process.killProcess(r.pid);
                Log.e("Goo", "endRinger()");
                return;
            }
        }
    }

private void startIntent(Context context, boolean isSystemRinger,
            final String number) {
        Intent i = new Intent(context, BlankActivity.class);
        i.putExtra("number", number);
        i.putExtra("isSystemRinger", isSystemRinger);
        i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        context.startActivity(i);
    }

/**
     * 获取铃声设置
     *
     * @return
     */
    private boolean getRingMode() {
        SharedPreferences p = mContext.getSharedPreferences(
                Settings.SHARED_PREFS_NAME, 0);
        if (p == null)
            return false;
        boolean mode = p.getBoolean("ring_mode", false);
        return mode;
    }

private boolean isInCall() {
        UserPreference.ensureIntializePreference(mContext);
        boolean state = UserPreference.read("incall", false);
        return state;
    }

private void saveInCall(boolean b) {
        UserPreference.ensureIntializePreference(mContext);
        UserPreference.save("incall", b);
    }

private void saveCallRinging(boolean b) {
        UserPreference.ensureIntializePreference(mContext);
        UserPreference.save("isCallRinging", b);
    }
}

///记得
com.android.internal.telephony 引入包添加 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();
}

文章开源《IT蓝豹》www.itlanbao.com