java类android.telephony.ServiceState的实例源码

/**
 * Start FemtoCell detection tracking (For CDMA Devices ONLY!)
 */
public void startTrackingFemto() {

    /* Check if it is a CDMA phone */
    if (device.getPhoneId() != TelephonyManager.PHONE_TYPE_CDMA) {
        Helpers.msgShort(context, context.getString(R.string.femtocell_only_on_cdma_devices));
        return;
    }

    trackingFemtocell = true;
    mPhoneStateListener = new PhoneStateListener() {
        public void onServiceStateChanged(ServiceState s) {
            log.debug(context.getString(R.string.service_state_changed));
            getServiceStateInfo(s);
        }
    };
    tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CELL_LOCATION);
    tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_SERVICE_STATE);
    setNotification();
}

public String getServiceStateName (int state)
{
    String name = "";
    if (state >= 10)
    {
        name = "roam ";
        if (state == 10)
            return name;
        else
            state = state - 10;
    }
    switch (state)
    {
        case ServiceState.STATE_OUT_OF_SERVICE:
            name += "no service"; break;
        case ServiceState.STATE_EMERGENCY_ONLY:
            name += "911 only"; break;
        case PhoneState.SERVICE_STATE_AIRPLANE:
            name += "airplane"; break;
        case ServiceState.STATE_IN_SERVICE:
            name += "in service"; break;
        case ServiceState.STATE_POWER_OFF:
            name += "power off"; break;
    }
    return name;
}

public static int getVoiceNetworkType (ServiceState serviceState)
{
    Method m = null;
    try {
        // Java reflection to gain access to TelephonyManager's
        // ITelephony getter
        Class c = Class.forName(serviceState.getClass().getName());
        Method mI = c.getDeclaredMethod("getRilVoiceRadioTechnology");
        mI.setAccessible(true);
        int voiceTechRil = (Integer)mI.invoke(serviceState);
        int voiceTech = PhoneState.rilRadioTechnologyToNetworkType(voiceTechRil);
        return voiceTech;
    }
    catch (Exception e)
    {
        String s = e.toString();
        //LoggerUtil.logToFile(LoggerUtil.Level.ERROR, TAG, "getVoiceNetworkType", "exception", e);
    }
    return -1;
}

@Override
public void onServiceStateChanged (ServiceState serviceState) {
    super.onServiceStateChanged(serviceState);

    PPApplication.logE("PhoneStateScanner.onServiceStateChanged", "telephonyManager=" + telephonyManager);
    CallsCounter.logCounter(context, "PhoneStateScanner.onServiceStateChanged", "PhoneStateScanner_onServiceStateChanged");

    getRegisteredCell();

    if (registeredCell != Integer.MAX_VALUE) {
        DatabaseHandler db = DatabaseHandler.getInstance(context);
        db.updateMobileCellLastConnectedTime(registeredCell, lastConnectedTime);
    }

    doAutoRegistration();
    sendBroadcast();
}

@Override
public void onServiceStateChanged(ServiceState serviceState)
{
    switch (serviceState.getState())
    {
        case ServiceState.STATE_EMERGENCY_ONLY:
        case ServiceState.STATE_OUT_OF_SERVICE:
            NetworkStateService.setMobileOutOfService(true);
            LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent(Constants.ACTION_SERVICE_STATE_CHANGED));
            break;

        default:
            {
                NetworkStateService.setMobileOutOfService(false);

                // If the device is network roaming but mobile data roaming is disabled, this
                // broadcast is necessary to properly update the widget on service state changes.
                if ((serviceState.getState() == ServiceState.STATE_IN_SERVICE) && serviceState.getRoaming())
                    LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent(Constants.ACTION_SERVICE_STATE_CHANGED));
            }
            break;
    }
}

/**
 * Get the service state
 * 
 * @see ServiceState#STATE_EMERGENCY_ONLY
 * @see ServiceState#STATE_IN_SERVICE
 * @see ServiceState#STATE_OUT_OF_SERVICE
 * @see ServiceState#STATE_POWER_OFF
 * @return service state
 */
public String getServiceState() {
    if (DBG)
        Log.d(Config.TAG, TAG + "getServiceState called");
    switch (mServiceStage) {
    case ServiceState.STATE_EMERGENCY_ONLY:
        return "Emergency Only";
    case ServiceState.STATE_IN_SERVICE:
        return "In Service";
    case ServiceState.STATE_POWER_OFF:
        return "Power Off";
    case ServiceState.STATE_OUT_OF_SERVICE:
        return "Out Of Service";
    default:
        return "Unknown";
    }
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
    Logs.d("# PhoneStateListener - onServiceStateChanged();");
    int state = serviceState.getState();

    switch (state) {
    case ServiceState.STATE_IN_SERVICE:
        Logs.d("# PhoneStateListener - onServiceStateChanged(); - reserve update");
        reserveRemoteUpdate(DEFAULT_UPDATE_DELAY);
        break;
    case ServiceState.STATE_OUT_OF_SERVICE:
    case ServiceState.STATE_EMERGENCY_ONLY:
    case ServiceState.STATE_POWER_OFF:
        ContentObject co = mContentManager.addRFStateObject(state);
        if(mActivityHandler != null)
            mActivityHandler.obtainMessage(Constants.MESSAGE_RF_STATE_RECEIVED, co).sendToTarget();
        // send to device
        if(co != null)
            sendContentsToDevice(co);
        else
            deleteEmergencyOfDevice(EmergencyObject.EMERGENCY_TYPE_RF_STATE);
        break;
    }
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
    int state = serviceState.getState();

    switch (state) {
    case ServiceState.STATE_IN_SERVICE:
    case ServiceState.STATE_OUT_OF_SERVICE:
    case ServiceState.STATE_EMERGENCY_ONLY:
    case ServiceState.STATE_POWER_OFF:
        ContentObject co = mContentManager.addRFStateObject(state);
        if(mActivityHandler != null)
            mActivityHandler.obtainMessage(Constants.MESSAGE_RF_STATE_RECEIVED, co).sendToTarget();
        // send to device
        if(co != null)
            sendContentsToDevice(co);
        else
            deleteEmergencyOfDevice(EmergencyObject.EMERGENCY_TYPE_RF_STATE);
        break;
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (TelephonyIntents.ACTION_SERVICE_STATE_CHANGED.equals(intent.getAction())) {
        if (LOCAL_LOGV) {
            Log.v(TAG, "Service state changed: " + intent.getExtras());
        }

        ServiceState state = ServiceState.newFromBundle(intent.getExtras());
        boolean isRoaming = state.getRoaming();
        if (LOCAL_LOGV) {
            Log.v(TAG, "roaming ------> " + isRoaming);
        }
        synchronized (sInstance) {
            mAutoDownload = getAutoDownloadState(mPreferences, isRoaming);
            if (LOCAL_LOGV) {
                Log.v(TAG, "mAutoDownload ------> " + mAutoDownload);
            }
        }
    }
}

public void listenRoamingState() {
    if (phoneStateListener == null) {
        phoneStateListener = new PhoneStateListener() {
            @Override
            public void onServiceStateChanged(ServiceState serviceState) {
                super.onServiceStateChanged(serviceState);

                final int state = serviceState.getState();
                if (state == ServiceState.STATE_IN_SERVICE
                        || state == ServiceState.STATE_POWER_OFF) {
                    final boolean roamingState = serviceState
                            .getRoaming();
                    if (roamingState != isRoamingOn()) {
                        setRoamingOn(roamingState);
                    }
                }
            }
        };
    }

    TelephonyManager telMgr = (TelephonyManager) context
            .getSystemService(Context.TELEPHONY_SERVICE);
    telMgr.listen(phoneStateListener,
            PhoneStateListener.LISTEN_SERVICE_STATE);
}

public void startTracking(){
       mTelephonyManager = (TelephonyManager) getBaseContext().getSystemService(Context.TELEPHONY_SERVICE);

       /* Check if it is a CDMA phone */
       if(mTelephonyManager.getPhoneType() != TelephonyManager.PHONE_TYPE_CDMA) {
        tv1 = (TextView) findViewById(R.id.err_msg);
        tv1.setText("This application can detect a femtocell on a CDMA phone only.");
        return;
       }

       mListener = new PhoneStateListener() {
         public void onServiceStateChanged(ServiceState s){
             Log.d(TAG, "Service State changed!");
             getServiceStateInfo(s);
         }
    };
    mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_CELL_LOCATION);
    mTelephonyManager.listen(mListener, PhoneStateListener.LISTEN_SERVICE_STATE);
}

@Override
public void onReceive(Context context, Intent intent) {
    if (TelephonyIntents.ACTION_SERVICE_STATE_CHANGED.equals(intent.getAction())) {
        if (LOCAL_LOGV) {
            Log.v(TAG, "Service state changed: " + intent.getExtras());
        }

        ServiceState state = ServiceState.newFromBundle(intent.getExtras());
        boolean isRoaming = state.getRoaming();
        if (LOCAL_LOGV) {
            Log.v(TAG, "roaming ------> " + isRoaming);
        }
        synchronized (sInstance) {
            mAutoDownload = getAutoDownloadState(mPreferences, isRoaming);
            if (LOCAL_LOGV) {
                Log.v(TAG, "mAutoDownload ------> " + mAutoDownload);
            }
        }
    }
}

public String getOperatorState() {
    if (!mHasTelephony) {
        return null;
    }
    if (mServiceState == null || mServiceState.getState() == ServiceState.STATE_OUT_OF_SERVICE) {
        return mGbResources.getString(R.string.pie_phone_status_no_service);
    }
    if (mServiceState.getState() == ServiceState.STATE_POWER_OFF) {
        return mGbResources.getString(R.string.pie_phone_status_airplane_mode);
    }
    if ((Boolean)XposedHelpers.callMethod(mServiceState, "isEmergencyOnly")) {
        return mGbResources.getString(R.string.pie_phone_status_emergency_only);
    }
    return mServiceState.getOperatorAlphaLong();
}

@Override
public void onServiceStateChanged(ServiceState serviceState){      
  if (serviceState.getState() == ServiceState.STATE_IN_SERVICE ) {
    Intent intent = new Intent(ServiceAvailableEvent.ACTION_NAME);
    context.sendBroadcast(intent);
    serviceAvailable = true;
  } else {
    serviceAvailable = false;
  }
}

public static SubjectFactory<ServiceStateSubject, ServiceState> type() {
  return new SubjectFactory<ServiceStateSubject, ServiceState>() {
    @Override
    public ServiceStateSubject getSubject(FailureStrategy fs, ServiceState that) {
      return new ServiceStateSubject(fs, that);
    }
  };
}

private void getServiceStateInfo(ServiceState s) {
    if (s != null) {
        if (IsConnectedToCdmaFemto(s)) {
            Helpers.msgShort(context, context.getString(R.string.alert_femtocell_tracking_detected));
            femtoDetected = true;
            setNotification();
            //toggleRadio();
        } else {
            femtoDetected = false;
            setNotification();
        }
    }
}

public void onServiceStateChanged(ServiceState serviceState)
{
    TextView myservicestate = (TextView)findViewById(R.id.myservicestate);
    int state = serviceState.getState();
    switch(state){
        case ServiceState.STATE_EMERGENCY_ONLY: myservicestate.setText("EMERGENCY ONLY"); break;
        case ServiceState.STATE_IN_SERVICE: myservicestate.setText("IN SERVICE"); break;
        case ServiceState.STATE_OUT_OF_SERVICE: myservicestate.setText("OUT OF SERVICE"); break;
        case ServiceState.STATE_POWER_OFF: myservicestate.setText("POWER OFF"); break;
    }
}

private void initUI()
{
    tm = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);  
    tv_mobile = (TextView)findViewById(R.id.textView_mobile);
    tv_mobile.setTextColor(Color.RED);
    tv_mobile.setTextSize(30);
    findViewById(R.id.button_pass).setOnClickListener(this);
    findViewById(R.id.button_fail).setOnClickListener(this);
    findViewById(R.id.button_pass).setEnabled(false);

       updateViews(tm);  
        //����SIM��״̬��������Ϣ��ʱ�����ܷ����仯�������Ҫע��PhoneStateListener   
        //��ʵʱ���½�����ʾ����Ϣ��������������¼���LISTEN_SERVICE_STATE��LISTEN_DATA_CONNECTION_STATE   
        //���Ƿֱ��Ӧ�ص�����onServiceStateChanged��onDataConnectionStateChanged   
        tm.listen(new PhoneStateListener() {  

            @Override  
            public void onDataConnectionStateChanged(int state, int networkType) {  
                //��������״̬�ı���ܵ����������͵ĸı�   
                updateViews(tm);  
            }  

            @Override  
            public void onServiceStateChanged(ServiceState serviceState) {  
                updateViews(tm);  
            }

            @Override
            public void onSignalStrengthsChanged(SignalStrength signalStrength) {
                // TODO Auto-generated method stub
                Stren=String.valueOf(-113+2*signalStrength.getGsmSignalStrength())+" dBm  "+String.valueOf(signalStrength.getGsmSignalStrength())+" asu";
                updateViews(tm);
                super.onSignalStrengthsChanged(signalStrength);
            } 


        }, PhoneStateListener.LISTEN_SERVICE_STATE   
                | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE|PhoneStateListener.LISTEN_SIGNAL_STRENGTHS); 
 }

/**
 * Callback invoked when device service state changes.
 * 
 * @see ServiceState#STATE_EMERGENCY_ONLY
 * @see ServiceState#STATE_IN_SERVICE
 * @see ServiceState#STATE_OUT_OF_SERVICE
 * @see ServiceState#STATE_POWER_OFF
 */
@Override
public void onServiceStateChanged(ServiceState serviceState) {
    if (DBG)
        Log.d(Config.TAG, TAG + "onServiceStateChanged called");
    if (mServiceStage != serviceState.getState()) {
        mServiceStage = serviceState.getState();
        isRoaming = serviceState.getRoaming();
    }
}

@Override
   public void onServiceStateChanged(ServiceState serviceState) {
    super.onServiceStateChanged(serviceState);
    int state = serviceState.getState();
    int cmState = CallMonitorService.MSG_SERVER_STATE_OUTSERVICE;
    if(state == ServiceState.STATE_IN_SERVICE) {
        cmState = CallMonitorService.MSG_SERVER_STATE_INSERVICE;
    }
    mCmIf.csmif_ServiceState(cmState);
}

@Override
public void onServiceStateChanged(ServiceState state) {
  if (state.getState() == ServiceState.STATE_IN_SERVICE) {
    Log.w("SystemStateListener", "In service, sending sms/mms outboxes...");
    sendSmsOutbox(context);
    sendMmsOutbox(context);
  }
}

private void handleServiceStateChanged(Intent intent) {
    // If service just returned, start sending out the queued messages
    ServiceState serviceState = ServiceState.newFromBundle(intent.getExtras());
    int subscription = intent.getIntExtra(SUBSCRIPTION_KEY, 0);
    int prefSubscription = MSimSmsManager.getDefault().getPreferredSmsSubscription();
    // if service state is IN_SERVICE & current subscription is same as
    // preferred SMS subscription.i.e.as set under MultiSIM Settings,then
    // sendFirstQueuedMessage.
    if (serviceState.getState() == ServiceState.STATE_IN_SERVICE &&
        subscription == prefSubscription) {
        sendFirstQueuedMessage();
    }
}

public void onServiceStateChanged(ServiceState serviceState)
{
    TextView myservicestate = (TextView)findViewById(R.id.myservicestate);
    int state = serviceState.getState();
    switch(state){
        case ServiceState.STATE_EMERGENCY_ONLY: myservicestate.setText("EMERGENCY ONLY"); break;
        case ServiceState.STATE_IN_SERVICE: myservicestate.setText("IN SERVICE"); break;
        case ServiceState.STATE_OUT_OF_SERVICE: myservicestate.setText("OUT OF SERVICE"); break;
        case ServiceState.STATE_POWER_OFF: myservicestate.setText("POWER OFF"); break;
    }
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
    super.onServiceStateChanged(serviceState);
    String phonestate = "";
    // set the state of the service - serviceState according to the value in
    // serviceState
    switch (serviceState.getState()) {
    case ServiceState.STATE_EMERGENCY_ONLY:
        if (PhoneNumberUtils.isEmergencyNumber(this.number))
            phonestate = context.getResources().getString(
                    R.string.state_in_service);
        else
            phonestate = context.getResources().getString(
                    R.string.emergency_calls_only);
        setServiceState(phonestate);
        break;
    case ServiceState.STATE_OUT_OF_SERVICE:
        phonestate = context.getResources().getString(R.string.no_service);
        setServiceState(phonestate);
        break;
    case ServiceState.STATE_POWER_OFF:
        phonestate = context.getResources().getString(R.string.power_off);
        setServiceState(phonestate);
        break;
    case ServiceState.STATE_IN_SERVICE:
        phonestate = context.getResources().getString(
                R.string.state_in_service);
        setServiceState(phonestate);
        break;
    default:
        phonestate = context.getResources().getString(
                R.string.service_unknown_reason);
        setServiceState(phonestate);
    }
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
    synchronized (lock) {
        lastServiceState = serviceState;
              lastServiceStateTime = System.currentTimeMillis();
           if(listening)
               ptimulusService.telephonyEvent(serviceState);
    }
}

public void onServiceStateChanged(ServiceState serviceState) {
    switch (serviceState.getState()) {
    case ServiceState.STATE_EMERGENCY_ONLY:
        powerEstimator.writeToLog("phone-service emergency-only\n");
        break;
    case ServiceState.STATE_IN_SERVICE:
        powerEstimator.writeToLog("phone-service in-service\n");
        switch (phoneManager.getNetworkType()) {
        case (TelephonyManager.NETWORK_TYPE_EDGE):
            powerEstimator.writeToLog("phone-network edge\n");
            break;
        case (TelephonyManager.NETWORK_TYPE_GPRS):
            powerEstimator.writeToLog("phone-network GPRS\n");
            break;
        case 8:
            powerEstimator.writeToLog("phone-network HSDPA\n");
            break;
        case (TelephonyManager.NETWORK_TYPE_UMTS):
            powerEstimator.writeToLog("phone-network UMTS\n");
            break;
        default:
            powerEstimator.writeToLog("phone-network "
                    + phoneManager.getNetworkType() + "\n");
        }
        break;
    case ServiceState.STATE_OUT_OF_SERVICE:
        powerEstimator.writeToLog("phone-service out-of-service\n");
        break;
    case ServiceState.STATE_POWER_OFF:
        powerEstimator.writeToLog("phone-service power-off\n");
        break;
    }
}

public void getServiceStateInfo(ServiceState s) {
    if(s!= null && IsConnectedToCdmaFemto(s)) {
        sendNotification();
        toggleRadio();
    }

}

private void handleServiceStateChanged(Intent intent) {
    // If service just returned, start sending out the queued messages
    ServiceState serviceState = ServiceState.newFromBundle(intent.getExtras());
    if (serviceState.getState() == ServiceState.STATE_IN_SERVICE) {
        sendFirstQueuedMessage();
    }
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
  this.connected = (serviceState.getState() == ServiceState.STATE_IN_SERVICE);
  looper.quit();
}

@Override
public void onServiceStateChanged(ServiceState serviceState) {
  if (serviceState.getState() == ServiceState.STATE_IN_SERVICE) {
    handleInService();
  }
}