CellSignalStrengthLte.java revision 211c1c2ca815b101ed9bc65a9ab0407c3ce97836 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.telephony;
18
19import android.os.Parcel;
20import android.os.Parcelable;
21import android.telephony.Rlog;
22
23/**
24 * LTE signal strength related information.
25 */
26public final class CellSignalStrengthLte extends CellSignalStrength implements Parcelable {
27
28    private static final String LOG_TAG = "CellSignalStrengthLte";
29    private static final boolean DBG = false;
30
31    private int mSignalStrength;
32    private int mRsrp;
33    private int mRsrq;
34    private int mRssnr;
35    private int mCqi;
36    private int mTimingAdvance;
37
38    /**
39     * Empty constructor
40     *
41     * @hide
42     */
43    public CellSignalStrengthLte() {
44        setDefaultValues();
45    }
46
47    /**
48     * Constructor
49     *
50     * @hide
51     */
52    public CellSignalStrengthLte(int signalStrength, int rsrp, int rsrq, int rssnr, int cqi,
53            int timingAdvance) {
54        initialize(signalStrength, rsrp, rsrq, rssnr, cqi, timingAdvance);
55    }
56
57    /**
58     * Copy constructors
59     *
60     * @param s Source SignalStrength
61     *
62     * @hide
63     */
64    public CellSignalStrengthLte(CellSignalStrengthLte s) {
65        copyFrom(s);
66    }
67
68    /**
69     * Initialize all the values
70     *
71     * @param lteSignalStrength
72     * @param rsrp
73     * @param rsrq
74     * @param rssnr
75     * @param cqi
76     *
77     * @hide
78     */
79    public void initialize(int lteSignalStrength, int rsrp, int rsrq, int rssnr, int cqi,
80            int timingAdvance) {
81        mSignalStrength = lteSignalStrength;
82        mRsrp = rsrp;
83        mRsrq = rsrq;
84        mRssnr = rssnr;
85        mCqi = cqi;
86        mTimingAdvance = timingAdvance;
87    }
88
89    /**
90     * Initialize from the SignalStrength structure.
91     *
92     * @param ss
93     *
94     * @hide
95     */
96    public void initialize(SignalStrength ss, int timingAdvance) {
97        mSignalStrength = ss.getLteSignalStrength();
98        mRsrp = ss.getLteRsrp();
99        mRsrq = ss.getLteRsrq();
100        mRssnr = ss.getLteRssnr();
101        mCqi = ss.getLteCqi();
102        mTimingAdvance = timingAdvance;
103    }
104
105    /**
106     * @hide
107     */
108    protected void copyFrom(CellSignalStrengthLte s) {
109        mSignalStrength = s.mSignalStrength;
110        mRsrp = s.mRsrp;
111        mRsrq = s.mRsrq;
112        mRssnr = s.mRssnr;
113        mCqi = s.mCqi;
114        mTimingAdvance = s.mTimingAdvance;
115    }
116
117    /**
118     * @hide
119     */
120    @Override
121    public CellSignalStrengthLte copy() {
122        return new CellSignalStrengthLte(this);
123    }
124
125    /** @hide */
126    @Override
127    public void setDefaultValues() {
128        mSignalStrength = Integer.MAX_VALUE;
129        mRsrp = Integer.MAX_VALUE;
130        mRsrq = Integer.MAX_VALUE;
131        mRssnr = Integer.MAX_VALUE;
132        mCqi = Integer.MAX_VALUE;
133        mTimingAdvance = Integer.MAX_VALUE;
134    }
135
136    /**
137     * Get signal level as an int from 0..4
138     */
139    @Override
140    public int getLevel() {
141        int levelRsrp = 0;
142        int levelRssnr = 0;
143
144        if (mRsrp == Integer.MAX_VALUE) levelRsrp = 0;
145        else if (mRsrp >= -95) levelRsrp = SIGNAL_STRENGTH_GREAT;
146        else if (mRsrp >= -105) levelRsrp = SIGNAL_STRENGTH_GOOD;
147        else if (mRsrp >= -115) levelRsrp = SIGNAL_STRENGTH_MODERATE;
148        else levelRsrp = SIGNAL_STRENGTH_POOR;
149
150        // See RIL_LTE_SignalStrength in ril.h
151        if (mRssnr == Integer.MAX_VALUE) levelRssnr = 0;
152        else if (mRssnr >= 45) levelRssnr = SIGNAL_STRENGTH_GREAT;
153        else if (mRssnr >= 10) levelRssnr = SIGNAL_STRENGTH_GOOD;
154        else if (mRssnr >= -30) levelRssnr = SIGNAL_STRENGTH_MODERATE;
155        else levelRssnr = SIGNAL_STRENGTH_POOR;
156
157        int level;
158        if (mRsrp == Integer.MAX_VALUE)
159            level = levelRssnr;
160        else if (mRssnr == Integer.MAX_VALUE)
161            level = levelRsrp;
162        else
163            level = (levelRssnr < levelRsrp) ? levelRssnr : levelRsrp;
164
165        if (DBG) log("Lte rsrp level: " + levelRsrp
166                + " snr level: " + levelRssnr + " level: " + level);
167        return level;
168    }
169
170    /**
171     * Get reference signal received quality
172     */
173    public int getRsrq() {
174        return mRsrq;
175    }
176
177    /**
178     * Get reference signal signal-to-noise ratio
179     */
180    public int getRssnr() {
181        return mRssnr;
182    }
183
184    /**
185     * Get reference signal received power
186     */
187    public int getRsrp() {
188        return mRsrp;
189    }
190
191    /**
192     * Get channel quality indicator
193     */
194    public int getCqi() {
195        return mCqi;
196    }
197
198    /**
199     * Get signal strength as dBm
200     */
201    @Override
202    public int getDbm() {
203        return mRsrp;
204    }
205
206    /**
207     * Get the LTE signal level as an asu value between 0..97, 99 is unknown
208     * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69
209     */
210    @Override
211    public int getAsuLevel() {
212        int lteAsuLevel = 99;
213        int lteDbm = getDbm();
214        if (lteDbm == Integer.MAX_VALUE) lteAsuLevel = 99;
215        else if (lteDbm <= -140) lteAsuLevel = 0;
216        else if (lteDbm >= -43) lteAsuLevel = 97;
217        else lteAsuLevel = lteDbm + 140;
218        if (DBG) log("Lte Asu level: "+lteAsuLevel);
219        return lteAsuLevel;
220    }
221
222    /**
223     * Get the timing advance value for LTE.
224     * See 3GPP xxxx
225     */
226    public int getTimingAdvance() {
227        return mTimingAdvance;
228    }
229
230    @Override
231    public int hashCode() {
232        int primeNum = 31;
233        return (mSignalStrength * primeNum) + (mRsrp * primeNum)
234                + (mRsrq * primeNum) + (mRssnr * primeNum) + (mCqi * primeNum)
235                + (mTimingAdvance * primeNum);
236    }
237
238    @Override
239    public boolean equals (Object o) {
240        CellSignalStrengthLte s;
241
242        try {
243            s = (CellSignalStrengthLte) o;
244        } catch (ClassCastException ex) {
245            return false;
246        }
247
248        if (o == null) {
249            return false;
250        }
251
252        return mSignalStrength == s.mSignalStrength
253                && mRsrp == s.mRsrp
254                && mRsrq == s.mRsrq
255                && mRssnr == s.mRssnr
256                && mCqi == s.mCqi
257                && mTimingAdvance == s.mTimingAdvance;
258    }
259
260    /**
261     * @return string representation.
262     */
263    @Override
264    public String toString() {
265        return "CellSignalStrengthLte:"
266                + " ss=" + mSignalStrength
267                + " rsrp=" + mRsrp
268                + " rsrq=" + mRsrq
269                + " rssnr=" + mRssnr
270                + " cqi=" + mCqi
271                + " ta=" + mTimingAdvance;
272    }
273
274    /** Implement the Parcelable interface */
275    @Override
276    public void writeToParcel(Parcel dest, int flags) {
277        if (DBG) log("writeToParcel(Parcel, int): " + toString());
278        dest.writeInt(mSignalStrength);
279        // Need to multiply rsrp and rsrq by -1
280        // to ensure consistency when reading values written here
281        // unless the values are invalid
282        dest.writeInt(mRsrp * (mRsrp != Integer.MAX_VALUE ? -1 : 1));
283        dest.writeInt(mRsrq * (mRsrq != Integer.MAX_VALUE ? -1 : 1));
284        dest.writeInt(mRssnr);
285        dest.writeInt(mCqi);
286        dest.writeInt(mTimingAdvance);
287    }
288
289    /**
290     * Construct a SignalStrength object from the given parcel
291     * where the token is already been processed.
292     */
293    private CellSignalStrengthLte(Parcel in) {
294        mSignalStrength = in.readInt();
295        // rsrp and rsrq are written into the parcel as positive values.
296        // Need to convert into negative values unless the values are invalid
297        mRsrp = in.readInt();
298        if (mRsrp != Integer.MAX_VALUE) mRsrp *= -1;
299        mRsrq = in.readInt();
300        if (mRsrq != Integer.MAX_VALUE) mRsrq *= -1;
301        mRssnr = in.readInt();
302        mCqi = in.readInt();
303        mTimingAdvance = in.readInt();
304        if (DBG) log("CellSignalStrengthLte(Parcel): " + toString());
305    }
306
307    /** Implement the Parcelable interface */
308    @Override
309    public int describeContents() {
310        return 0;
311    }
312
313    /** Implement the Parcelable interface */
314    @SuppressWarnings("hiding")
315    public static final Parcelable.Creator<CellSignalStrengthLte> CREATOR =
316            new Parcelable.Creator<CellSignalStrengthLte>() {
317        @Override
318        public CellSignalStrengthLte createFromParcel(Parcel in) {
319            return new CellSignalStrengthLte(in);
320        }
321
322        @Override
323        public CellSignalStrengthLte[] newArray(int size) {
324            return new CellSignalStrengthLte[size];
325        }
326    };
327
328    /**
329     * log
330     */
331    private static void log(String s) {
332        Rlog.w(LOG_TAG, s);
333    }
334}
335