Android拒绝来电的实现--ITelephony类的反射(结束电话)

 

NeighboringCellInfo.aidl

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

 

PhoneCallActivity .java

 package com.geolo.pcp.android;
 import java.lang.reflect.Method;
 import com.android.internal.telephony.ITelephony;
 import android.app.Activity;
 import android.content.Context;
 import android.media.AudioManager;
 import android.os.Bundle;
 import android.telephony.PhoneStateListener;
 import android.telephony.ServiceState;
 import android.telephony.SignalStrength;
 import android.telephony.TelephonyManager;
 import android.util.Log;
 public class PhoneCallActivity extends Activity{
     private PhoneCallListener mPhoneCallListener;
     private TelephonyManager mTelephonyManager;
     //private PhoneStateListener mPhoneStateListener;
     private AudioManager mAudioManager;
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         mPhoneCallListener = new PhoneCallListener();
         mTelephonyManager = (TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE);
         mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
         mTelephonyManager.listen(mPhoneCallListener, PhoneCallListener.LISTEN_CALL_STATE);
         //mTelephonyManager.listen(mPhoneCallListener, PhoneCallListener.LISTEN_SERVICE_STATE);
         //mTelephonyManager.listen(mPhoneCallListener, PhoneCallListener.LISTEN_DATA_CONNECTION_STATE);
     }
     /**
      * 利用JAVA反射机制调用ITelephony的endCall()结束通话。
      */
     private void endCall() {
         // 初始化iTelephony
         Class c = TelephonyManager.class;
         Method getITelephonyMethod = null;
         try {
             // 获取所有public/private/protected/默认
             // 方法的函数，如果只需要获取public方法，则可以调用getMethod.
             getITelephonyMethod = c.getDeclaredMethod("getITelephony",(Class[]) null);
             // 将要执行的方法对象设置是否进行访问检查，也就是说对于public/private/protected/默认
             // 我们是否能够访问。值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。值为 false
             // 则指示反射的对象应该实施 Java 语言访问检查。
             getITelephonyMethod.setAccessible(true);
             ITelephony iTelephony = (ITelephony) getITelephonyMethod.invoke(mTelephonyManager, (Object[]) null);
             iTelephony.endCall();
             Log.v(this.getClass().getName(), "endCall......");
         } catch (Exception e) {
             Log.e(this.getClass().getName(), "endCallError", e);
         }
     }
     public class PhoneCallListener extends PhoneStateListener{
         @Override
         public void onCallStateChanged(int state, String incomingNumber) {
             mAudioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
             Log.v(this.getClass().getName(), "onCallStateChanged-state: " + state);
             Log.v(this.getClass().getName(), "onCallStateChanged-incomingNumber: " + incomingNumber);
             switch (state)  {
             case TelephonyManager.CALL_STATE_IDLE:
                 mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
                 break;
             case TelephonyManager.CALL_STATE_OFFHOOK:
                 //CALL_STATE_OFFHOOK;
                 break;
             case TelephonyManager.CALL_STATE_RINGING:
                 if ("123456".equals(incomingNumber)){
                     //mTelephonyService.endCall();
                     endCall();
                 }else{
                     mAudioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
                 }
                 break;
             default:
                 break;
             }
             super.onCallStateChanged(state, incomingNumber);
         }
         @Override
         public void onDataConnectionStateChanged(int state) {
             Log.v(this.getClass().getName(), "onDataConnectionStateChanged-state: " + state);
             super.onDataConnectionStateChanged(state);
         }
         @Override
         public void onDataConnectionStateChanged(int state, int networkType) {
             Log.v(this.getClass().getName(), "onDataConnectionStateChanged-state: " + state);
             Log.v(this.getClass().getName(), "onDataConnectionStateChanged-networkType: " + networkType);
             super.onDataConnectionStateChanged(state, networkType);
         }
         @Override
         public void onServiceStateChanged(ServiceState serviceState) {
             Log.v(this.getClass().getName(), "onServiceStateChanged-ServiceState: " + serviceState);
             super.onServiceStateChanged(serviceState);
         }
         @Override
         public void onSignalStrengthChanged(int asu) {
             Log.v(this.getClass().getName(), "onSignalStrengthChanged-asu: " + asu);
             super.onSignalStrengthChanged(asu);
         }
         @Override
         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
             Log.v(this.getClass().getName(), "onSignalStrengthsChanged-signalStrength: " + signalStrength);
             super.onSignalStrengthsChanged(signalStrength);
         }
     }
 }

 

 "1.0" encoding="utf-8"?>
 "http://schemas.android.com/apk/res/android"
     package="com.geolo.pcp.android" android:versionCode="1"
     android:versionName="1.0">
     "@drawable/icon" android:label="@string/app_name">
         ".PhoneCallActivity" android:label="@string/app_name">

                 "android.intent.action.MAIN" />
                 "android.intent.category.LAUNCHER" />



     "android.permission.READ_PHONE_STATE" />
     "android.permission.CALL_PHONE" />
     "android.permission.MODIFY_PHONE_STATE" />
     "android.permission.ACCESS_WIFI_STATE">
     "android.permission.CHANGE_WIFI_STATE">
     "android.permission.WAKE_LOCK">

 

 

原理请看：http://blog.csdn.net/GEOLO/archive/2010/12/21/6090264.aspx

 

项目源码：http://download.csdn.net/source/2927291