안드로이드 PhoneProxy.java 소스 분석 및 기능 (What is PhoneProxy?)

안드로이드 PhoneProxy.java 소스 분석 및 기능 (What is PhoneProxy?)

2014. 4. 16. 14:17ㆍPrograming/Android / Java

우리가 사용하고 있는 통신방식은 크게 3GPP에서 제정한 방식과 3GPP2에서 재정한 방식으로 구분 할 수가 있다.

3GPP에서 제정한 방식은 우리가 흔히 알고 있는, GSM / WCDMA / LTE 를 이야기하고,

3GPP에서 제정한 방식은 IMT-2000 / CDMA 등을 이야기 한다.

이를 Android에서는 GSMPhone과 CDMAPhone으로 구분지어 사용하고 있다.

왜 이이야기를 먼저 논했나?

PhoneProxy를 만든 이유가 요놈들 때문이기 때문이다.

PhoneProxy의 주요 역할은 Phone 제어를 위한 API를 이러한 RAT (Radio Access Technology)에 상관없이 제어하기 위한 방법은 제공하는 것 이다.

다시 말하면, RAT에 따라서 Phone 제어 동작이 상이하기 때문에, 모두 지원을 하기 위해서 중간에서 조율을 해줘야 하는 놈이 필요해서 Proxy라는 놈을 도입한 것이다.

만일, PhoneProxy라는 놈이 없다면?

위 쪽에서는 3GPP 통신인 경우와 3GPP2 통신인 경우 다른 구조를 각각 가지고 있어야 하니, 덩치도 커지고 복잡성만 갖게 되기 때문이다.

또한, 사용하다가 잘 못 접근을 하게되면, 정상적으로 전화가 되고, 문자가가 가고, 인터넷이 되지 않을 것은 분명하다.

소스 측면서에서 이야기를 하면,

3GPP인 경우에는 GSMPhone을 생성하고, CDMAPhone을 죽임으로써 Phone에서 GSMPhone을 통해 3GPP 통신 방식으로 Telephony Framework을 Control 하기 위함이며, 3GPP2인 경우에는 반대의 동작을 하게 되는 것이다.

아래는 2.3 버전의 소스 코드 일부분을 발췌한 것이다.

현재 버전과는 동떨어지나 이해하는데는 더 좋다고 판단되어 아래 코드를 사용하였다.

if(mOutgoingPhone.equals("GSM")) {
                logd("Make a new CDMAPhone and destroy the old GSMPhone.");

((GSMPhone)mActivePhone).dispose();
                Phone oldPhone = mActivePhone;

//Give the garbage collector a hint to start the garbage collection asap
                // NOTE this has been disabled since radio technology change could happen during
                //   e.g. a multimedia playing and could slow the system. Tests needs to be done
                //   to see the effects of the GC call here when system is busy.
                //System.gc();

mActivePhone = PhoneFactory.getCdmaPhone();
                ((GSMPhone)oldPhone).removeReferences();
                oldPhone = null;
            } else {
                logd("Make a new GSMPhone and destroy the old CDMAPhone.");

((CDMAPhone)mActivePhone).dispose();
                //mActivePhone = null;
                Phone oldPhone = mActivePhone;

// Give the GC a hint to start the garbage collection asap
                // NOTE this has been disabled since radio technology change could happen during
                //   e.g. a multimedia playing and could slow the system. Tests needs to be done
                //   to see the effects of the GC call here when system is busy.
                //System.gc();

mActivePhone = PhoneFactory.getGsmPhone();
                ((CDMAPhone)oldPhone).removeReferences();
                oldPhone = null;
            }

난 해외 나갈일도 없어서, 로밍 할 일도 없으니까 굳이 이런거 필요 없다고 하는 사람들도 간혹 있을 수도 있다.

근데, 그건 본인 사정이고, 전 세계 모든 사람들이 사용하는 폰에 적용되어야 하는 기술이기 때문에, 이는 필수 불가결한 것 인 것이다.

RAT에 의존하지 않고, 위에서는 아무것도 모른다는 것 처럼 분신을 만들어 내 할일만 하면,,,,,, 끝!!!

그럼 왜 하필 PhoneProxy라고 이름을 지었을까?

Proxy란 실제 객체를 위한 일종의 대리자이며 일반적으로 자신이 대리하는 객체에 대한 참조를 가지고 있는 놈이며,

Client의 요청을 모두 받아 실제 객체로 전달하는 역을을 한다.

Proxy의 장점은 실제 객체와 동일한 인터페이스를 구현한 프록시를 통해 접근하여 Client로 부터 최적화와 세부적인 구현 내용을 감추어 코드를 단순화하게 한다는 것에 있다.

반면에 단점은, 바로 접근을 하지 않고, 하나의 객체를 더 거쳐야 하기 때문에 약간의 오보헤드가 발생한다는 것이다.

하지만 단점에 비해, 장점이 더 많기에 나라도 Proxy를 도입했을 것 같다.

부팅 시점에 RILJ 로부터 PhoneApp까지 전달되는 EVENT 흐름은 아래와 같다.

/*
 * Copyright (C) 2008 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.app.ActivityManagerNative;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Handler;
import android.os.Message;
import android.os.SystemProperties;
import android.preference.PreferenceManager;
import android.telephony.CellLocation;
import android.telephony.PhoneStateListener;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.util.Log;

import com.android.internal.telephony.cdma.CDMAPhone;
import com.android.internal.telephony.gsm.GSMPhone;
import com.android.internal.telephony.gsm.NetworkInfo;
import com.android.internal.telephony.gsm.GsmDataConnection;
import com.android.internal.telephony.test.SimulatedRadioControl;

import java.util.List;

public class PhoneProxy extends Handler implements Phone {
    public final static Object lockForRadioTechnologyChange = new Object();

private Phone mActivePhone;
    private String mOutgoingPhone;
    private CommandsInterface mCommandsInterface;
    private IccSmsInterfaceManagerProxy mIccSmsInterfaceManagerProxy;
    private IccPhoneBookInterfaceManagerProxy mIccPhoneBookInterfaceManagerProxy;
    private PhoneSubInfoProxy mPhoneSubInfoProxy;

private boolean mResetModemOnRadioTechnologyChange = false;

private static final int EVENT_RADIO_TECHNOLOGY_CHANGED = 1;
    private static final String LOG_TAG = "PHONE";

//***** Class Methods
    public PhoneProxy(Phone phone) {
        mActivePhone = phone;
        mResetModemOnRadioTechnologyChange = SystemProperties.getBoolean(
                TelephonyProperties.PROPERTY_RESET_ON_RADIO_TECH_CHANGE, false);
        mIccSmsInterfaceManagerProxy = new IccSmsInterfaceManagerProxy(
                phone.getIccSmsInterfaceManager());
        mIccPhoneBookInterfaceManagerProxy = new IccPhoneBookInterfaceManagerProxy(
                phone.getIccPhoneBookInterfaceManager());
        mPhoneSubInfoProxy = new PhoneSubInfoProxy(phone.getPhoneSubInfo());
        mCommandsInterface = ((PhoneBase)mActivePhone).mCM;
        mCommandsInterface.registerForRadioTechnologyChanged(
                this, EVENT_RADIO_TECHNOLOGY_CHANGED, null);
    }

@Override
    public void handleMessage(Message msg) {
        switch(msg.what) {
        case EVENT_RADIO_TECHNOLOGY_CHANGED:
            //switch Phone from CDMA to GSM or vice versa
            mOutgoingPhone = ((PhoneBase)mActivePhone).getPhoneName();
            logd("Switching phone from " + mOutgoingPhone + "Phone to " +
                    (mOutgoingPhone.equals("GSM") ? "CDMAPhone" : "GSMPhone") );
            boolean oldPowerState = false; // old power state to off
            if (mResetModemOnRadioTechnologyChange) {
                if (mCommandsInterface.getRadioState().isOn()) {
                    oldPowerState = true;
                    logd("Setting Radio Power to Off");
                    mCommandsInterface.setRadioPower(false, null);
                }
            }

if(mOutgoingPhone.equals("GSM")) {
                logd("Make a new CDMAPhone and destroy the old GSMPhone.");

((GSMPhone)mActivePhone).dispose();
                Phone oldPhone = mActivePhone;

((CDMAPhone)mActivePhone).dispose();
                //mActivePhone = null;
                Phone oldPhone = mActivePhone;

mActivePhone = PhoneFactory.getGsmPhone();
                ((CDMAPhone)oldPhone).removeReferences();
                oldPhone = null;
            }

if (mResetModemOnRadioTechnologyChange) {
                logd("Resetting Radio");
                mCommandsInterface.setRadioPower(oldPowerState, null);
            }

//Set the new interfaces in the proxy's
            mIccSmsInterfaceManagerProxy.setmIccSmsInterfaceManager(
                    mActivePhone.getIccSmsInterfaceManager());
            mIccPhoneBookInterfaceManagerProxy.setmIccPhoneBookInterfaceManager(
                    mActivePhone.getIccPhoneBookInterfaceManager());
            mPhoneSubInfoProxy.setmPhoneSubInfo(this.mActivePhone.getPhoneSubInfo());
            mCommandsInterface = ((PhoneBase)mActivePhone).mCM;

//Send an Intent to the PhoneApp that we had a radio technology change
            Intent intent = new Intent(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
            intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
            intent.putExtra(Phone.PHONE_NAME_KEY, mActivePhone.getPhoneName());
            ActivityManagerNative.broadcastStickyIntent(intent, null);
            break;
        default:
            Log.e(LOG_TAG,"Error! This handler was not registered for this message type. Message: "
                    + msg.what);
        break;
        }
        super.handleMessage(msg);
    }

private void logv(String msg) {
        Log.v(LOG_TAG, "[PhoneProxy] " + msg);
    }

private void logd(String msg) {
        Log.d(LOG_TAG, "[PhoneProxy] " + msg);
    }

private void logw(String msg) {
        Log.w(LOG_TAG, "[PhoneProxy] " + msg);
    }

private void loge(String msg) {
        Log.e(LOG_TAG, "[PhoneProxy] " + msg);
    }

public ServiceState getServiceState() {
        return mActivePhone.getServiceState();
    }

public CellLocation getCellLocation() {
        return mActivePhone.getCellLocation();
    }

public DataState getDataConnectionState() {
        return mActivePhone.getDataConnectionState();
    }

public DataActivityState getDataActivityState() {
        return mActivePhone.getDataActivityState();
    }

public Context getContext() {
        return mActivePhone.getContext();
    }

public void disableDnsCheck(boolean b) {
        mActivePhone.disableDnsCheck(b);
    }

public boolean isDnsCheckDisabled() {
        return mActivePhone.isDnsCheckDisabled();
    }

public State getState() {
        return mActivePhone.getState();
    }

public String getPhoneName() {
        return mActivePhone.getPhoneName();
    }

public int getPhoneType() {
        return mActivePhone.getPhoneType();
    }

public String[] getActiveApnTypes() {
        return mActivePhone.getActiveApnTypes();
    }

public String getActiveApn() {
        return mActivePhone.getActiveApn();
    }

public SignalStrength getSignalStrength() {
        return mActivePhone.getSignalStrength();
    }

public void registerForUnknownConnection(Handler h, int what, Object obj) {
        mActivePhone.registerForUnknownConnection(h, what, obj);
    }

public void unregisterForUnknownConnection(Handler h) {
        mActivePhone.unregisterForUnknownConnection(h);
    }

public void registerForPreciseCallStateChanged(Handler h, int what, Object obj) {
        mActivePhone.registerForPreciseCallStateChanged(h, what, obj);
    }

public void unregisterForPreciseCallStateChanged(Handler h) {
        mActivePhone.unregisterForPreciseCallStateChanged(h);
    }

public void registerForNewRingingConnection(Handler h, int what, Object obj) {
        mActivePhone.registerForNewRingingConnection(h, what, obj);
    }

public void unregisterForNewRingingConnection(Handler h) {
        mActivePhone.unregisterForNewRingingConnection(h);
    }

public void registerForIncomingRing(Handler h, int what, Object obj) {
        mActivePhone.registerForIncomingRing(h, what, obj);
    }

public void unregisterForIncomingRing(Handler h) {
        mActivePhone.unregisterForIncomingRing(h);
    }

public void registerForDisconnect(Handler h, int what, Object obj) {
        mActivePhone.registerForDisconnect(h, what, obj);
    }

public void unregisterForDisconnect(Handler h) {
        mActivePhone.unregisterForDisconnect(h);
    }

public void registerForMmiInitiate(Handler h, int what, Object obj) {
        mActivePhone.registerForMmiInitiate(h, what, obj);
    }

public void unregisterForMmiInitiate(Handler h) {
        mActivePhone.unregisterForMmiInitiate(h);
    }

public void registerForMmiComplete(Handler h, int what, Object obj) {
        mActivePhone.registerForMmiComplete(h, what, obj);
    }

public void unregisterForMmiComplete(Handler h) {
        mActivePhone.unregisterForMmiComplete(h);
    }

public List<? extends MmiCode> getPendingMmiCodes() {
        return mActivePhone.getPendingMmiCodes();
    }

public void sendUssdResponse(String ussdMessge) {
        mActivePhone.sendUssdResponse(ussdMessge);
    }

public void registerForServiceStateChanged(Handler h, int what, Object obj) {
        mActivePhone.registerForServiceStateChanged(h, what, obj);
    }

public void unregisterForServiceStateChanged(Handler h) {
        mActivePhone.unregisterForServiceStateChanged(h);
    }

public void registerForSuppServiceNotification(Handler h, int what, Object obj) {
        mActivePhone.registerForSuppServiceNotification(h, what, obj);
    }

public void unregisterForSuppServiceNotification(Handler h) {
        mActivePhone.unregisterForSuppServiceNotification(h);
    }

public void registerForSuppServiceFailed(Handler h, int what, Object obj) {
        mActivePhone.registerForSuppServiceFailed(h, what, obj);
    }

public void unregisterForSuppServiceFailed(Handler h) {
        mActivePhone.unregisterForSuppServiceFailed(h);
    }

public void registerForInCallVoicePrivacyOn(Handler h, int what, Object obj){
        mActivePhone.registerForInCallVoicePrivacyOn(h,what,obj);
    }

public void unregisterForInCallVoicePrivacyOn(Handler h){
        mActivePhone.unregisterForInCallVoicePrivacyOn(h);
    }

public void registerForInCallVoicePrivacyOff(Handler h, int what, Object obj){
        mActivePhone.registerForInCallVoicePrivacyOff(h,what,obj);
    }

public void unregisterForInCallVoicePrivacyOff(Handler h){
        mActivePhone.unregisterForInCallVoicePrivacyOff(h);
    }

public void registerForCdmaOtaStatusChange(Handler h, int what, Object obj) {
        mActivePhone.registerForCdmaOtaStatusChange(h,what,obj);
    }

public void unregisterForCdmaOtaStatusChange(Handler h) {
         mActivePhone.unregisterForCdmaOtaStatusChange(h);
    }

public void registerForSubscriptionInfoReady(Handler h, int what, Object obj) {
        mActivePhone.registerForSubscriptionInfoReady(h, what, obj);
    }

public void unregisterForSubscriptionInfoReady(Handler h) {
        mActivePhone.unregisterForSubscriptionInfoReady(h);
    }

public void registerForEcmTimerReset(Handler h, int what, Object obj) {
        mActivePhone.registerForEcmTimerReset(h,what,obj);
    }

public void unregisterForEcmTimerReset(Handler h) {
        mActivePhone.unregisterForEcmTimerReset(h);
    }

public void registerForRingbackTone(Handler h, int what, Object obj) {
        mActivePhone.registerForRingbackTone(h,what,obj);
    }

public void unregisterForRingbackTone(Handler h) {
        mActivePhone.unregisterForRingbackTone(h);
    }

public void registerForResendIncallMute(Handler h, int what, Object obj) {
        mActivePhone.registerForResendIncallMute(h,what,obj);
    }

public void unregisterForResendIncallMute(Handler h) {
        mActivePhone.unregisterForResendIncallMute(h);
    }

public boolean getIccRecordsLoaded() {
        return mActivePhone.getIccRecordsLoaded();
    }

public IccCard getIccCard() {
        return mActivePhone.getIccCard();
    }

public void acceptCall() throws CallStateException {
        mActivePhone.acceptCall();
    }

public void rejectCall() throws CallStateException {
        mActivePhone.rejectCall();
    }

public void switchHoldingAndActive() throws CallStateException {
        mActivePhone.switchHoldingAndActive();
    }

public boolean canConference() {
        return mActivePhone.canConference();
    }

public void conference() throws CallStateException {
        mActivePhone.conference();
    }

public void enableEnhancedVoicePrivacy(boolean enable, Message onComplete) {
        mActivePhone.enableEnhancedVoicePrivacy(enable, onComplete);
    }

public void getEnhancedVoicePrivacy(Message onComplete) {
        mActivePhone.getEnhancedVoicePrivacy(onComplete);
    }

public boolean canTransfer() {
        return mActivePhone.canTransfer();
    }

public void explicitCallTransfer() throws CallStateException {
        mActivePhone.explicitCallTransfer();
    }

public void clearDisconnected() {
        mActivePhone.clearDisconnected();
    }

public Call getForegroundCall() {
        return mActivePhone.getForegroundCall();
    }

public Call getBackgroundCall() {
        return mActivePhone.getBackgroundCall();
    }

public Call getRingingCall() {
        return mActivePhone.getRingingCall();
    }

public Connection dial(String dialString) throws CallStateException {
        return mActivePhone.dial(dialString);
    }

public Connection dial(String dialString, UUSInfo uusInfo) throws CallStateException {
        return mActivePhone.dial(dialString, uusInfo);
    }

public boolean handlePinMmi(String dialString) {
        return mActivePhone.handlePinMmi(dialString);
    }

public boolean handleInCallMmiCommands(String command) throws CallStateException {
        return mActivePhone.handleInCallMmiCommands(command);
    }

public void sendDtmf(char c) {
        mActivePhone.sendDtmf(c);
    }

public void startDtmf(char c) {
        mActivePhone.startDtmf(c);
    }

public void stopDtmf() {
        mActivePhone.stopDtmf();
    }

public void setRadioPower(boolean power) {
        mActivePhone.setRadioPower(power);
    }

public boolean getMessageWaitingIndicator() {
        return mActivePhone.getMessageWaitingIndicator();
    }

public boolean getCallForwardingIndicator() {
        return mActivePhone.getCallForwardingIndicator();
    }

public String getLine1Number() {
        return mActivePhone.getLine1Number();
    }

public String getCdmaMin() {
        return mActivePhone.getCdmaMin();
    }

public boolean isMinInfoReady() {
        return mActivePhone.isMinInfoReady();
    }

public String getCdmaPrlVersion() {
        return mActivePhone.getCdmaPrlVersion();
    }

public String getLine1AlphaTag() {
        return mActivePhone.getLine1AlphaTag();
    }

public void setLine1Number(String alphaTag, String number, Message onComplete) {
        mActivePhone.setLine1Number(alphaTag, number, onComplete);
    }

public String getVoiceMailNumber() {
        return mActivePhone.getVoiceMailNumber();
    }

/** @hide */
    public int getVoiceMessageCount(){
        return mActivePhone.getVoiceMessageCount();
    }

public String getVoiceMailAlphaTag() {
        return mActivePhone.getVoiceMailAlphaTag();
    }

public void setVoiceMailNumber(String alphaTag,String voiceMailNumber,
            Message onComplete) {
        mActivePhone.setVoiceMailNumber(alphaTag, voiceMailNumber, onComplete);
    }

public void getCallForwardingOption(int commandInterfaceCFReason,
            Message onComplete) {
        mActivePhone.getCallForwardingOption(commandInterfaceCFReason,
                onComplete);
    }

public void setCallForwardingOption(int commandInterfaceCFReason,
            int commandInterfaceCFAction, String dialingNumber,
            int timerSeconds, Message onComplete) {
        mActivePhone.setCallForwardingOption(commandInterfaceCFReason,
            commandInterfaceCFAction, dialingNumber, timerSeconds, onComplete);
    }

public void getOutgoingCallerIdDisplay(Message onComplete) {
        mActivePhone.getOutgoingCallerIdDisplay(onComplete);
    }

public void setOutgoingCallerIdDisplay(int commandInterfaceCLIRMode,
            Message onComplete) {
        mActivePhone.setOutgoingCallerIdDisplay(commandInterfaceCLIRMode,
                onComplete);
    }

public void getCallWaiting(Message onComplete) {
        mActivePhone.getCallWaiting(onComplete);
    }

public void setCallWaiting(boolean enable, Message onComplete) {
        mActivePhone.setCallWaiting(enable, onComplete);
    }

public void getAvailableNetworks(Message response) {
        mActivePhone.getAvailableNetworks(response);
    }

public void setNetworkSelectionModeAutomatic(Message response) {
        mActivePhone.setNetworkSelectionModeAutomatic(response);
    }

public void selectNetworkManually(NetworkInfo network, Message response) {
        mActivePhone.selectNetworkManually(network, response);
    }

public void setPreferredNetworkType(int networkType, Message response) {
        mActivePhone.setPreferredNetworkType(networkType, response);
    }

public void getPreferredNetworkType(Message response) {
        mActivePhone.getPreferredNetworkType(response);
    }

public void getNeighboringCids(Message response) {
        mActivePhone.getNeighboringCids(response);
    }

public void setOnPostDialCharacter(Handler h, int what, Object obj) {
        mActivePhone.setOnPostDialCharacter(h, what, obj);
    }

public void setMute(boolean muted) {
        mActivePhone.setMute(muted);
    }

public boolean getMute() {
        return mActivePhone.getMute();
    }

public void setEchoSuppressionEnabled(boolean enabled) {
        mActivePhone.setEchoSuppressionEnabled(enabled);
    }

public void invokeOemRilRequestRaw(byte[] data, Message response) {
        mActivePhone.invokeOemRilRequestRaw(data, response);
    }

public void invokeOemRilRequestStrings(String[] strings, Message response) {
        mActivePhone.invokeOemRilRequestStrings(strings, response);
    }

public void getDataCallList(Message response) {
        mActivePhone.getDataCallList(response);
    }

public List<DataConnection> getCurrentDataConnectionList() {
        return mActivePhone.getCurrentDataConnectionList();
    }

public void updateServiceLocation() {
        mActivePhone.updateServiceLocation();
    }

public void enableLocationUpdates() {
        mActivePhone.enableLocationUpdates();
    }

public void disableLocationUpdates() {
        mActivePhone.disableLocationUpdates();
    }

public void setUnitTestMode(boolean f) {
        mActivePhone.setUnitTestMode(f);
    }

public boolean getUnitTestMode() {
        return mActivePhone.getUnitTestMode();
    }

public void setBandMode(int bandMode, Message response) {
        mActivePhone.setBandMode(bandMode, response);
    }

public void queryAvailableBandMode(Message response) {
        mActivePhone.queryAvailableBandMode(response);
    }

public boolean getDataRoamingEnabled() {
        return mActivePhone.getDataRoamingEnabled();
    }

public void setDataRoamingEnabled(boolean enable) {
        mActivePhone.setDataRoamingEnabled(enable);
    }

public void queryCdmaRoamingPreference(Message response) {
        mActivePhone.queryCdmaRoamingPreference(response);
    }

public void setCdmaRoamingPreference(int cdmaRoamingType, Message response) {
        mActivePhone.setCdmaRoamingPreference(cdmaRoamingType, response);
    }

public void setCdmaSubscription(int cdmaSubscriptionType, Message response) {
        mActivePhone.setCdmaSubscription(cdmaSubscriptionType, response);
    }

public SimulatedRadioControl getSimulatedRadioControl() {
        return mActivePhone.getSimulatedRadioControl();
    }

public boolean enableDataConnectivity() {
        return mActivePhone.enableDataConnectivity();
    }

public boolean disableDataConnectivity() {
        return mActivePhone.disableDataConnectivity();
    }

public int enableApnType(String type) {
        return mActivePhone.enableApnType(type);
    }

public int disableApnType(String type) {
        return mActivePhone.disableApnType(type);
    }

public boolean isDataConnectivityEnabled() {
        return mActivePhone.isDataConnectivityEnabled();
    }

public boolean isDataConnectivityPossible() {
        return mActivePhone.isDataConnectivityPossible();
    }

public String getInterfaceName(String apnType) {
        return mActivePhone.getInterfaceName(apnType);
    }

public String getIpAddress(String apnType) {
        return mActivePhone.getIpAddress(apnType);
    }

public String getGateway(String apnType) {
        return mActivePhone.getGateway(apnType);
    }

public String[] getDnsServers(String apnType) {
        return mActivePhone.getDnsServers(apnType);
    }

public String getDeviceId() {
        return mActivePhone.getDeviceId();
    }

public String getDeviceSvn() {
        return mActivePhone.getDeviceSvn();
    }

public String getSubscriberId() {
        return mActivePhone.getSubscriberId();
    }

public String getIccSerialNumber() {
        return mActivePhone.getIccSerialNumber();
    }

public String getEsn() {
        return mActivePhone.getEsn();
    }

public String getMeid() {
        return mActivePhone.getMeid();
    }

public PhoneSubInfo getPhoneSubInfo(){
        return mActivePhone.getPhoneSubInfo();
    }

public IccSmsInterfaceManager getIccSmsInterfaceManager(){
        return mActivePhone.getIccSmsInterfaceManager();
    }

public IccPhoneBookInterfaceManager getIccPhoneBookInterfaceManager(){
        return mActivePhone.getIccPhoneBookInterfaceManager();
    }

public void setTTYMode(int ttyMode, Message onComplete) {
        mActivePhone.setTTYMode(ttyMode, onComplete);
    }

public void queryTTYMode(Message onComplete) {
        mActivePhone.queryTTYMode(onComplete);
    }

public void activateCellBroadcastSms(int activate, Message response) {
        mActivePhone.activateCellBroadcastSms(activate, response);
    }

public void getCellBroadcastSmsConfig(Message response) {
        mActivePhone.getCellBroadcastSmsConfig(response);
    }

public void setCellBroadcastSmsConfig(int[] configValuesArray, Message response) {
        mActivePhone.setCellBroadcastSmsConfig(configValuesArray, response);
    }

public void notifyDataActivity() {
         mActivePhone.notifyDataActivity();
    }

public void getSmscAddress(Message result) {
        mActivePhone.getSmscAddress(result);
    }

public void setSmscAddress(String address, Message result) {
        mActivePhone.setSmscAddress(address, result);
    }

public int getCdmaEriIconIndex() {
         return mActivePhone.getCdmaEriIconIndex();
    }

public String getCdmaEriText() {
         return mActivePhone.getCdmaEriText();
     }

public int getCdmaEriIconMode() {
         return mActivePhone.getCdmaEriIconMode();
    }

public void sendBurstDtmf(String dtmfString, int on, int off, Message onComplete){
        mActivePhone.sendBurstDtmf(dtmfString, on, off, onComplete);
    }

public void exitEmergencyCallbackMode(){
        mActivePhone.exitEmergencyCallbackMode();
    }

public boolean isOtaSpNumber(String dialStr){
        return mActivePhone.isOtaSpNumber(dialStr);
    }

public void registerForCallWaiting(Handler h, int what, Object obj){
        mActivePhone.registerForCallWaiting(h,what,obj);
    }

public void unregisterForCallWaiting(Handler h){
        mActivePhone.unregisterForCallWaiting(h);
    }

public void registerForSignalInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForSignalInfo(h,what,obj);
    }

public void unregisterForSignalInfo(Handler h) {
        mActivePhone.unregisterForSignalInfo(h);
    }

public void registerForDisplayInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForDisplayInfo(h,what,obj);
    }

public void unregisterForDisplayInfo(Handler h) {
        mActivePhone.unregisterForDisplayInfo(h);
    }

public void registerForNumberInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForNumberInfo(h, what, obj);
    }

public void unregisterForNumberInfo(Handler h) {
        mActivePhone.unregisterForNumberInfo(h);
    }

public void registerForRedirectedNumberInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForRedirectedNumberInfo(h, what, obj);
    }

public void unregisterForRedirectedNumberInfo(Handler h) {
        mActivePhone.unregisterForRedirectedNumberInfo(h);
    }

public void registerForLineControlInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForLineControlInfo( h, what, obj);
    }

public void unregisterForLineControlInfo(Handler h) {
        mActivePhone.unregisterForLineControlInfo(h);
    }

public void registerFoT53ClirlInfo(Handler h, int what, Object obj) {
        mActivePhone.registerFoT53ClirlInfo(h, what, obj);
    }

public void unregisterForT53ClirInfo(Handler h) {
        mActivePhone.unregisterForT53ClirInfo(h);
    }

public void registerForT53AudioControlInfo(Handler h, int what, Object obj) {
        mActivePhone.registerForT53AudioControlInfo( h, what, obj);
    }

public void unregisterForT53AudioControlInfo(Handler h) {
        mActivePhone.unregisterForT53AudioControlInfo(h);
    }

public void setOnEcbModeExitResponse(Handler h, int what, Object obj){
        mActivePhone.setOnEcbModeExitResponse(h,what,obj);
    }

public void unsetOnEcbModeExitResponse(Handler h){
        mActivePhone.unsetOnEcbModeExitResponse(h);
    }
}

저작자표시

'Programing > Android / Java' 카테고리의 다른 글

안드로이드 BroadcastReceiver에서 Intent로 전화걸기 (Android BroadcastReceiver Intent Make Call) (0)	2014.04.18
안드로이드 PhoneBase.java (What is PhoneBase in android?) (0)	2014.04.16
안드로이드 PhoneApp.java / PhoneGlobals.java 소스 및 기능 설명 (Whait is PhoneApp?) (0)	2014.04.16
안드로이드 텔레포니 프레임워크 (Android Telephony Framework) - 개요 (2)	2014.04.16
안드로이드 Message 소스 분석 (Android Message.java) (0)	2014.04.15

Bareum

Bareum

태그

최근글

댓글

공지사항

아카이브

'Programing > Android / Java' 카테고리의 다른 글

관련글

티스토리툴바