| /* |
| * Copyright (C) 2009 Qualcomm Innovation Center, Inc. All Rights Reserved. |
| * Copyright (C) 2009 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 android.telephony; |
| |
| import android.os.Bundle; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.util.Log; |
| |
| /** |
| * Contains phone signal strength related information. |
| */ |
| public class SignalStrength implements Parcelable { |
| |
| private static final String LOG_TAG = "SignalStrength"; |
| private static final boolean DBG = false; |
| |
| /** @hide */ |
| public static final int SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0; |
| /** @hide */ |
| public static final int SIGNAL_STRENGTH_POOR = 1; |
| /** @hide */ |
| public static final int SIGNAL_STRENGTH_MODERATE = 2; |
| /** @hide */ |
| public static final int SIGNAL_STRENGTH_GOOD = 3; |
| /** @hide */ |
| public static final int SIGNAL_STRENGTH_GREAT = 4; |
| /** @hide */ |
| public static final int NUM_SIGNAL_STRENGTH_BINS = 5; |
| /** @hide */ |
| public static final String[] SIGNAL_STRENGTH_NAMES = { |
| "none", "poor", "moderate", "good", "great" |
| }; |
| |
| private int mGsmSignalStrength; // Valid values are (0-31, 99) as defined in TS 27.007 8.5 |
| private int mGsmBitErrorRate; // bit error rate (0-7, 99) as defined in TS 27.007 8.5 |
| private int mCdmaDbm; // This value is the RSSI value |
| private int mCdmaEcio; // This value is the Ec/Io |
| private int mEvdoDbm; // This value is the EVDO RSSI value |
| private int mEvdoEcio; // This value is the EVDO Ec/Io |
| private int mEvdoSnr; // Valid values are 0-8. 8 is the highest signal to noise ratio |
| private int mLteSignalStrength; |
| private int mLteRsrp; |
| private int mLteRsrq; |
| private int mLteRssnr; |
| private int mLteCqi; |
| |
| private boolean isGsm; // This value is set by the ServiceStateTracker onSignalStrengthResult |
| |
| /** |
| * Create a new SignalStrength from a intent notifier Bundle |
| * |
| * This method is used by PhoneStateIntentReceiver and maybe by |
| * external applications. |
| * |
| * @param m Bundle from intent notifier |
| * @return newly created SignalStrength |
| * |
| * @hide |
| */ |
| public static SignalStrength newFromBundle(Bundle m) { |
| SignalStrength ret; |
| ret = new SignalStrength(); |
| ret.setFromNotifierBundle(m); |
| return ret; |
| } |
| |
| /** |
| * Empty constructor |
| * |
| * @hide |
| */ |
| public SignalStrength() { |
| mGsmSignalStrength = 99; |
| mGsmBitErrorRate = -1; |
| mCdmaDbm = -1; |
| mCdmaEcio = -1; |
| mEvdoDbm = -1; |
| mEvdoEcio = -1; |
| mEvdoSnr = -1; |
| mLteSignalStrength = -1; |
| mLteRsrp = -1; |
| mLteRsrq = -1; |
| mLteRssnr = -1; |
| mLteCqi = -1; |
| isGsm = true; |
| } |
| |
| /** |
| * Constructor |
| * |
| * @hide |
| */ |
| public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate, |
| int cdmaDbm, int cdmaEcio, |
| int evdoDbm, int evdoEcio, int evdoSnr, |
| int lteSignalStrength, int lteRsrp, int lteRsrq, int lteRssnr, int lteCqi, |
| boolean gsm) { |
| mGsmSignalStrength = gsmSignalStrength; |
| mGsmBitErrorRate = gsmBitErrorRate; |
| mCdmaDbm = cdmaDbm; |
| mCdmaEcio = cdmaEcio; |
| mEvdoDbm = evdoDbm; |
| mEvdoEcio = evdoEcio; |
| mEvdoSnr = evdoSnr; |
| mLteSignalStrength = lteSignalStrength; |
| mLteRsrp = lteRsrp; |
| mLteRsrq = lteRsrq; |
| mLteRssnr = lteRssnr; |
| mLteCqi = lteCqi; |
| isGsm = gsm; |
| } |
| |
| /** |
| * Constructor |
| * |
| * @hide |
| */ |
| public SignalStrength(int gsmSignalStrength, int gsmBitErrorRate, |
| int cdmaDbm, int cdmaEcio, |
| int evdoDbm, int evdoEcio, int evdoSnr, |
| boolean gsm) { |
| this(gsmSignalStrength, gsmBitErrorRate, cdmaDbm, cdmaEcio, |
| evdoDbm, evdoEcio, evdoSnr, -1, -1, -1, -1, -1, gsm); |
| } |
| |
| /** |
| * Copy constructors |
| * |
| * @param s Source SignalStrength |
| * |
| * @hide |
| */ |
| public SignalStrength(SignalStrength s) { |
| copyFrom(s); |
| } |
| |
| /** |
| * @hide |
| */ |
| protected void copyFrom(SignalStrength s) { |
| mGsmSignalStrength = s.mGsmSignalStrength; |
| mGsmBitErrorRate = s.mGsmBitErrorRate; |
| mCdmaDbm = s.mCdmaDbm; |
| mCdmaEcio = s.mCdmaEcio; |
| mEvdoDbm = s.mEvdoDbm; |
| mEvdoEcio = s.mEvdoEcio; |
| mEvdoSnr = s.mEvdoSnr; |
| mLteSignalStrength = s.mLteSignalStrength; |
| mLteRsrp = s.mLteRsrp; |
| mLteRsrq = s.mLteRsrq; |
| mLteRssnr = s.mLteRssnr; |
| mLteCqi = s.mLteCqi; |
| isGsm = s.isGsm; |
| } |
| |
| /** |
| * Construct a SignalStrength object from the given parcel. |
| * |
| * @hide |
| */ |
| public SignalStrength(Parcel in) { |
| mGsmSignalStrength = in.readInt(); |
| mGsmBitErrorRate = in.readInt(); |
| mCdmaDbm = in.readInt(); |
| mCdmaEcio = in.readInt(); |
| mEvdoDbm = in.readInt(); |
| mEvdoEcio = in.readInt(); |
| mEvdoSnr = in.readInt(); |
| mLteSignalStrength = in.readInt(); |
| mLteRsrp = in.readInt(); |
| mLteRsrq = in.readInt(); |
| mLteRssnr = in.readInt(); |
| mLteCqi = in.readInt(); |
| isGsm = (in.readInt() != 0); |
| } |
| |
| /** |
| * {@link Parcelable#writeToParcel} |
| */ |
| public void writeToParcel(Parcel out, int flags) { |
| out.writeInt(mGsmSignalStrength); |
| out.writeInt(mGsmBitErrorRate); |
| out.writeInt(mCdmaDbm); |
| out.writeInt(mCdmaEcio); |
| out.writeInt(mEvdoDbm); |
| out.writeInt(mEvdoEcio); |
| out.writeInt(mEvdoSnr); |
| out.writeInt(mLteSignalStrength); |
| out.writeInt(mLteRsrp); |
| out.writeInt(mLteRsrq); |
| out.writeInt(mLteRssnr); |
| out.writeInt(mLteCqi); |
| out.writeInt(isGsm ? 1 : 0); |
| } |
| |
| /** |
| * {@link Parcelable#describeContents} |
| */ |
| public int describeContents() { |
| return 0; |
| } |
| |
| /** |
| * {@link Parcelable.Creator} |
| * |
| * @hide |
| */ |
| public static final Parcelable.Creator<SignalStrength> CREATOR = new Parcelable.Creator() { |
| public SignalStrength createFromParcel(Parcel in) { |
| return new SignalStrength(in); |
| } |
| |
| public SignalStrength[] newArray(int size) { |
| return new SignalStrength[size]; |
| } |
| }; |
| |
| /** |
| * Get the GSM Signal Strength, valid values are (0-31, 99) as defined in TS 27.007 8.5 |
| */ |
| public int getGsmSignalStrength() { |
| return this.mGsmSignalStrength; |
| } |
| |
| /** |
| * Get the GSM bit error rate (0-7, 99) as defined in TS 27.007 8.5 |
| */ |
| public int getGsmBitErrorRate() { |
| return this.mGsmBitErrorRate; |
| } |
| |
| /** |
| * Get the CDMA RSSI value in dBm |
| */ |
| public int getCdmaDbm() { |
| return this.mCdmaDbm; |
| } |
| |
| /** |
| * Get the CDMA Ec/Io value in dB*10 |
| */ |
| public int getCdmaEcio() { |
| return this.mCdmaEcio; |
| } |
| |
| /** |
| * Get the EVDO RSSI value in dBm |
| */ |
| public int getEvdoDbm() { |
| return this.mEvdoDbm; |
| } |
| |
| /** |
| * Get the EVDO Ec/Io value in dB*10 |
| */ |
| public int getEvdoEcio() { |
| return this.mEvdoEcio; |
| } |
| |
| /** |
| * Get the signal to noise ratio. Valid values are 0-8. 8 is the highest. |
| */ |
| public int getEvdoSnr() { |
| return this.mEvdoSnr; |
| } |
| |
| /** |
| * Get signal level as an int from 0..4 |
| * |
| * @hide |
| */ |
| public int getLevel() { |
| int level; |
| |
| if (isGsm) { |
| if ((mLteSignalStrength == -1) |
| && (mLteRsrp == -1) |
| && (mLteRsrq == -1) |
| && (mLteRssnr == -1) |
| && (mLteCqi == -1)) { |
| level = getGsmLevel(); |
| } else { |
| level = getLteLevel(); |
| } |
| } else { |
| int cdmaLevel = getCdmaLevel(); |
| int evdoLevel = getEvdoLevel(); |
| if (evdoLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) { |
| /* We don't know evdo, use cdma */ |
| level = getCdmaLevel(); |
| } else if (cdmaLevel == SIGNAL_STRENGTH_NONE_OR_UNKNOWN) { |
| /* We don't know cdma, use evdo */ |
| level = getEvdoLevel(); |
| } else { |
| /* We know both, use the lowest level */ |
| level = cdmaLevel < evdoLevel ? cdmaLevel : evdoLevel; |
| } |
| } |
| if (DBG) log("getLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get the signal level as an asu value between 0..31, 99 is unknown |
| * |
| * @hide |
| */ |
| public int getAsuLevel() { |
| int asuLevel; |
| if (isGsm) { |
| if ((mLteSignalStrength == -1) |
| && (mLteRsrp == -1) |
| && (mLteRsrq == -1) |
| && (mLteRssnr == -1) |
| && (mLteCqi == -1)) { |
| asuLevel = getGsmAsuLevel(); |
| } else { |
| asuLevel = getLteAsuLevel(); |
| } |
| } else { |
| int cdmaAsuLevel = getCdmaAsuLevel(); |
| int evdoAsuLevel = getEvdoAsuLevel(); |
| if (evdoAsuLevel == 0) { |
| /* We don't know evdo use, cdma */ |
| asuLevel = cdmaAsuLevel; |
| } else if (cdmaAsuLevel == 0) { |
| /* We don't know cdma use, evdo */ |
| asuLevel = evdoAsuLevel; |
| } else { |
| /* We know both, use the lowest level */ |
| asuLevel = cdmaAsuLevel < evdoAsuLevel ? cdmaAsuLevel : evdoAsuLevel; |
| } |
| } |
| if (DBG) log("getAsuLevel=" + asuLevel); |
| return asuLevel; |
| } |
| |
| /** |
| * Get the signal strength as dBm |
| * |
| * @hide |
| */ |
| public int getDbm() { |
| int dBm; |
| |
| if(isGsm()) { |
| if ((mLteSignalStrength == -1) |
| && (mLteRsrp == -1) |
| && (mLteRsrq == -1) |
| && (mLteRssnr == -1) |
| && (mLteCqi == -1)) { |
| dBm = getGsmDbm(); |
| } else { |
| dBm = getLteDbm(); |
| } |
| } else { |
| dBm = getCdmaDbm(); |
| } |
| if (DBG) log("getDbm=" + dBm); |
| return dBm; |
| } |
| |
| /** |
| * Get Gsm signal strength as dBm |
| * |
| * @hide |
| */ |
| public int getGsmDbm() { |
| int dBm; |
| |
| int gsmSignalStrength = getGsmSignalStrength(); |
| int asu = (gsmSignalStrength == 99 ? -1 : gsmSignalStrength); |
| if (asu != -1) { |
| dBm = -113 + (2 * asu); |
| } else { |
| dBm = -1; |
| } |
| if (DBG) log("getGsmDbm=" + dBm); |
| return dBm; |
| } |
| |
| /** |
| * Get gsm as level 0..4 |
| * |
| * @hide |
| */ |
| public int getGsmLevel() { |
| int level; |
| |
| // ASU ranges from 0 to 31 - TS 27.007 Sec 8.5 |
| // asu = 0 (-113dB or less) is very weak |
| // signal, its better to show 0 bars to the user in such cases. |
| // asu = 99 is a special case, where the signal strength is unknown. |
| int asu = getGsmSignalStrength(); |
| if (asu <= 2 || asu == 99) level = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; |
| else if (asu >= 12) level = SIGNAL_STRENGTH_GREAT; |
| else if (asu >= 8) level = SIGNAL_STRENGTH_GOOD; |
| else if (asu >= 5) level = SIGNAL_STRENGTH_MODERATE; |
| else level = SIGNAL_STRENGTH_POOR; |
| if (DBG) log("getGsmLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get the gsm signal level as an asu value between 0..31, 99 is unknown |
| * |
| * @hide |
| */ |
| public int getGsmAsuLevel() { |
| // ASU ranges from 0 to 31 - TS 27.007 Sec 8.5 |
| // asu = 0 (-113dB or less) is very weak |
| // signal, its better to show 0 bars to the user in such cases. |
| // asu = 99 is a special case, where the signal strength is unknown. |
| int level = getGsmSignalStrength(); |
| if (DBG) log("getGsmAsuLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get cdma as level 0..4 |
| * |
| * @hide |
| */ |
| public int getCdmaLevel() { |
| final int cdmaDbm = getCdmaDbm(); |
| final int cdmaEcio = getCdmaEcio(); |
| int levelDbm; |
| int levelEcio; |
| |
| if (cdmaDbm >= -75) levelDbm = SIGNAL_STRENGTH_GREAT; |
| else if (cdmaDbm >= -85) levelDbm = SIGNAL_STRENGTH_GOOD; |
| else if (cdmaDbm >= -95) levelDbm = SIGNAL_STRENGTH_MODERATE; |
| else if (cdmaDbm >= -100) levelDbm = SIGNAL_STRENGTH_POOR; |
| else levelDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; |
| |
| // Ec/Io are in dB*10 |
| if (cdmaEcio >= -90) levelEcio = SIGNAL_STRENGTH_GREAT; |
| else if (cdmaEcio >= -110) levelEcio = SIGNAL_STRENGTH_GOOD; |
| else if (cdmaEcio >= -130) levelEcio = SIGNAL_STRENGTH_MODERATE; |
| else if (cdmaEcio >= -150) levelEcio = SIGNAL_STRENGTH_POOR; |
| else levelEcio = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; |
| |
| int level = (levelDbm < levelEcio) ? levelDbm : levelEcio; |
| if (DBG) log("getCdmaLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get the cdma signal level as an asu value between 0..31, 99 is unknown |
| * |
| * @hide |
| */ |
| public int getCdmaAsuLevel() { |
| final int cdmaDbm = getCdmaDbm(); |
| final int cdmaEcio = getCdmaEcio(); |
| int cdmaAsuLevel; |
| int ecioAsuLevel; |
| |
| if (cdmaDbm >= -75) cdmaAsuLevel = 16; |
| else if (cdmaDbm >= -82) cdmaAsuLevel = 8; |
| else if (cdmaDbm >= -90) cdmaAsuLevel = 4; |
| else if (cdmaDbm >= -95) cdmaAsuLevel = 2; |
| else if (cdmaDbm >= -100) cdmaAsuLevel = 1; |
| else cdmaAsuLevel = 99; |
| |
| // Ec/Io are in dB*10 |
| if (cdmaEcio >= -90) ecioAsuLevel = 16; |
| else if (cdmaEcio >= -100) ecioAsuLevel = 8; |
| else if (cdmaEcio >= -115) ecioAsuLevel = 4; |
| else if (cdmaEcio >= -130) ecioAsuLevel = 2; |
| else if (cdmaEcio >= -150) ecioAsuLevel = 1; |
| else ecioAsuLevel = 99; |
| |
| int level = (cdmaAsuLevel < ecioAsuLevel) ? cdmaAsuLevel : ecioAsuLevel; |
| if (DBG) log("getCdmaAsuLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get Evdo as level 0..4 |
| * |
| * @hide |
| */ |
| public int getEvdoLevel() { |
| int evdoDbm = getEvdoDbm(); |
| int evdoSnr = getEvdoSnr(); |
| int levelEvdoDbm; |
| int levelEvdoSnr; |
| |
| if (evdoDbm >= -65) levelEvdoDbm = SIGNAL_STRENGTH_GREAT; |
| else if (evdoDbm >= -75) levelEvdoDbm = SIGNAL_STRENGTH_GOOD; |
| else if (evdoDbm >= -90) levelEvdoDbm = SIGNAL_STRENGTH_MODERATE; |
| else if (evdoDbm >= -105) levelEvdoDbm = SIGNAL_STRENGTH_POOR; |
| else levelEvdoDbm = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; |
| |
| if (evdoSnr >= 7) levelEvdoSnr = SIGNAL_STRENGTH_GREAT; |
| else if (evdoSnr >= 5) levelEvdoSnr = SIGNAL_STRENGTH_GOOD; |
| else if (evdoSnr >= 3) levelEvdoSnr = SIGNAL_STRENGTH_MODERATE; |
| else if (evdoSnr >= 1) levelEvdoSnr = SIGNAL_STRENGTH_POOR; |
| else levelEvdoSnr = SIGNAL_STRENGTH_NONE_OR_UNKNOWN; |
| |
| int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr; |
| if (DBG) log("getEvdoLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get the evdo signal level as an asu value between 0..31, 99 is unknown |
| * |
| * @hide |
| */ |
| public int getEvdoAsuLevel() { |
| int evdoDbm = getEvdoDbm(); |
| int evdoSnr = getEvdoSnr(); |
| int levelEvdoDbm; |
| int levelEvdoSnr; |
| |
| if (evdoDbm >= -65) levelEvdoDbm = 16; |
| else if (evdoDbm >= -75) levelEvdoDbm = 8; |
| else if (evdoDbm >= -85) levelEvdoDbm = 4; |
| else if (evdoDbm >= -95) levelEvdoDbm = 2; |
| else if (evdoDbm >= -105) levelEvdoDbm = 1; |
| else levelEvdoDbm = 99; |
| |
| if (evdoSnr >= 7) levelEvdoSnr = 16; |
| else if (evdoSnr >= 6) levelEvdoSnr = 8; |
| else if (evdoSnr >= 5) levelEvdoSnr = 4; |
| else if (evdoSnr >= 3) levelEvdoSnr = 2; |
| else if (evdoSnr >= 1) levelEvdoSnr = 1; |
| else levelEvdoSnr = 99; |
| |
| int level = (levelEvdoDbm < levelEvdoSnr) ? levelEvdoDbm : levelEvdoSnr; |
| if (DBG) log("getEvdoAsuLevel=" + level); |
| return level; |
| } |
| |
| /** |
| * Get LTE as dBm |
| * |
| * @hide |
| */ |
| public int getLteDbm() { |
| return mLteRsrp; |
| } |
| |
| /** |
| * Get LTE as level 0..4 |
| * |
| * @hide |
| */ |
| public int getLteLevel() { |
| int levelLteRsrp = 0; |
| |
| if (mLteRsrp == -1) levelLteRsrp = 0; |
| else if (mLteRsrp >= -85) levelLteRsrp = SIGNAL_STRENGTH_GREAT; |
| else if (mLteRsrp >= -95) levelLteRsrp = SIGNAL_STRENGTH_GOOD; |
| else if (mLteRsrp >= -105) levelLteRsrp = SIGNAL_STRENGTH_MODERATE; |
| else if (mLteRsrp >= -115) levelLteRsrp = SIGNAL_STRENGTH_POOR; |
| else levelLteRsrp = 0; |
| |
| if (DBG) log("Lte level: "+levelLteRsrp); |
| return levelLteRsrp; |
| } |
| |
| /** |
| * Get the LTE signal level as an asu value between 0..97, 99 is unknown |
| * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69 |
| * |
| * @hide |
| */ |
| public int getLteAsuLevel() { |
| int lteAsuLevel = 99; |
| int lteDbm = getLteDbm(); |
| if (lteDbm <= -140) lteAsuLevel = 0; |
| else if (lteDbm >= -43) lteAsuLevel = 97; |
| else lteAsuLevel = lteDbm + 140; |
| if (DBG) log("Lte Asu level: "+lteAsuLevel); |
| return lteAsuLevel; |
| } |
| |
| /** |
| * @return true if this is for GSM |
| */ |
| public boolean isGsm() { |
| return this.isGsm; |
| } |
| |
| /** |
| * @return hash code |
| */ |
| @Override |
| public int hashCode() { |
| int primeNum = 31; |
| return ((mGsmSignalStrength * primeNum) |
| + (mGsmBitErrorRate * primeNum) |
| + (mCdmaDbm * primeNum) + (mCdmaEcio * primeNum) |
| + (mEvdoDbm * primeNum) + (mEvdoEcio * primeNum) + (mEvdoSnr * primeNum) |
| + (mLteSignalStrength * primeNum) + (mLteRsrp * primeNum) |
| + (mLteRsrq * primeNum) + (mLteRssnr * primeNum) + (mLteCqi * primeNum) |
| + (isGsm ? 1 : 0)); |
| } |
| |
| /** |
| * @return true if the signal strengths are the same |
| */ |
| @Override |
| public boolean equals (Object o) { |
| SignalStrength s; |
| |
| try { |
| s = (SignalStrength) o; |
| } catch (ClassCastException ex) { |
| return false; |
| } |
| |
| if (o == null) { |
| return false; |
| } |
| |
| return (mGsmSignalStrength == s.mGsmSignalStrength |
| && mGsmBitErrorRate == s.mGsmBitErrorRate |
| && mCdmaDbm == s.mCdmaDbm |
| && mCdmaEcio == s.mCdmaEcio |
| && mEvdoDbm == s.mEvdoDbm |
| && mEvdoEcio == s.mEvdoEcio |
| && mEvdoSnr == s.mEvdoSnr |
| && mLteSignalStrength == s.mLteSignalStrength |
| && mLteRsrp == s.mLteRsrp |
| && mLteRsrq == s.mLteRsrq |
| && mLteRssnr == s.mLteRssnr |
| && mLteCqi == s.mLteCqi |
| && isGsm == s.isGsm); |
| } |
| |
| /** |
| * @return string representation. |
| */ |
| @Override |
| public String toString() { |
| return ("SignalStrength:" |
| + " " + mGsmSignalStrength |
| + " " + mGsmBitErrorRate |
| + " " + mCdmaDbm |
| + " " + mCdmaEcio |
| + " " + mEvdoDbm |
| + " " + mEvdoEcio |
| + " " + mEvdoSnr |
| + " " + mLteSignalStrength |
| + " " + mLteRsrp |
| + " " + mLteRsrq |
| + " " + mLteRssnr |
| + " " + mLteCqi |
| + " " + (isGsm ? "gsm|lte" : "cdma")); |
| } |
| |
| /** |
| * Set SignalStrength based on intent notifier map |
| * |
| * @param m intent notifier map |
| * @hide |
| */ |
| private void setFromNotifierBundle(Bundle m) { |
| mGsmSignalStrength = m.getInt("GsmSignalStrength"); |
| mGsmBitErrorRate = m.getInt("GsmBitErrorRate"); |
| mCdmaDbm = m.getInt("CdmaDbm"); |
| mCdmaEcio = m.getInt("CdmaEcio"); |
| mEvdoDbm = m.getInt("EvdoDbm"); |
| mEvdoEcio = m.getInt("EvdoEcio"); |
| mEvdoSnr = m.getInt("EvdoSnr"); |
| mLteSignalStrength = m.getInt("LteSignalStrength"); |
| mLteRsrp = m.getInt("LteRsrp"); |
| mLteRsrq = m.getInt("LteRsrq"); |
| mLteRssnr = m.getInt("LteRssnr"); |
| mLteCqi = m.getInt("LteCqi"); |
| isGsm = m.getBoolean("isGsm"); |
| } |
| |
| /** |
| * Set intent notifier Bundle based on SignalStrength |
| * |
| * @param m intent notifier Bundle |
| * @hide |
| */ |
| public void fillInNotifierBundle(Bundle m) { |
| m.putInt("GsmSignalStrength", mGsmSignalStrength); |
| m.putInt("GsmBitErrorRate", mGsmBitErrorRate); |
| m.putInt("CdmaDbm", mCdmaDbm); |
| m.putInt("CdmaEcio", mCdmaEcio); |
| m.putInt("EvdoDbm", mEvdoDbm); |
| m.putInt("EvdoEcio", mEvdoEcio); |
| m.putInt("EvdoSnr", mEvdoSnr); |
| m.putInt("LteSignalStrength", mLteSignalStrength); |
| m.putInt("LteRsrp", mLteRsrp); |
| m.putInt("LteRsrq", mLteRsrq); |
| m.putInt("LteRssnr", mLteRssnr); |
| m.putInt("LteCqi", mLteCqi); |
| m.putBoolean("isGsm", Boolean.valueOf(isGsm)); |
| } |
| |
| /** |
| * log |
| */ |
| private static void log(String s) { |
| Log.w(LOG_TAG, s); |
| } |
| } |
