723 lines
21 KiB
Java
723 lines
21 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|