CellSignalStrengthLte.java revision b208a24cf521401912cfce16fce550a995cf1250 
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.util.Log;
22
23/**
24 * LTE signal strength related information.
25 *
26 * @hide
27 */
28public class CellSignalStrengthLte extends CellSignalStrength implements Parcelable {
29
30    private static final String LOG_TAG = "CellSignalStrengthLte";
31    private static final boolean DBG = false;
32
33    private int mSignalStrength;
34    private int mRsrp;
35    private int mRsrq;
36    private int mRssnr;
37    private int mCqi;
38    private int mTimingAdvance;
39
40    /**
41     * Empty constructor
42     *
43     * @hide
44     */
45    public CellSignalStrengthLte() {
46        setDefaultValues();
47    }
48
49    /**
50     * Constructor
51     *
52     * @hide
53     */
54    public CellSignalStrengthLte(int signalStrength, int rsrp, int rsrq, int rssnr, int cqi,
55            int timingAdvance) {
56        initialize(signalStrength, rsrp, rsrq, rssnr, cqi, timingAdvance);
57    }
58
59    /**
60     * Copy constructors
61     *
62     * @param s Source SignalStrength
63     *
64     * @hide
65     */
66    public CellSignalStrengthLte(CellSignalStrengthLte s) {
67        copyFrom(s);
68    }
69
70    /**
71     * Initialize all the values
72     *
73     * @param lteSignalStrength
74     * @param rsrp
75     * @param rsrq
76     * @param rssnr
77     * @param cqi
78     *
79     * @hide
80     */
81    public void initialize(int lteSignalStrength, int rsrp, int rsrq, int rssnr, int cqi,
82            int timingAdvance) {
83        mSignalStrength = lteSignalStrength;
84        mRsrp = rsrp;
85        mRsrq = rsrq;
86        mRssnr = rssnr;
87        mCqi = cqi;
88        mTimingAdvance = timingAdvance;
89    }
90
91    /**
92     * @hide
93     */
94    protected void copyFrom(CellSignalStrengthLte s) {
95        mSignalStrength = s.mSignalStrength;
96        mRsrp = s.mRsrp;
97        mRsrq = s.mRsrq;
98        mRssnr = s.mRssnr;
99        mCqi = s.mCqi;
100        mTimingAdvance = s.mTimingAdvance;
101    }
102
103    /**
104     * @hide
105     */
106    @Override
107    public CellSignalStrengthLte copy() {
108        return new CellSignalStrengthLte(this);
109    }
110
111    /** @hide */
112    @Override
113    public void setDefaultValues() {
114        mSignalStrength = Integer.MAX_VALUE;
115        mRsrp = Integer.MAX_VALUE;
116        mRsrq = Integer.MAX_VALUE;
117        mRssnr = Integer.MAX_VALUE;
118        mCqi = Integer.MAX_VALUE;
119        mTimingAdvance = Integer.MAX_VALUE;
120    }
121
122    /**
123     * Get LTE as level 0..4
124     *
125     * @hide
126     */
127    @Override
128    public int getLevel() {
129        int levelRsrp = 0;
130        int levelRssnr = 0;
131
132        if (mRsrp == Integer.MAX_VALUE) levelRsrp = 0;
133        else if (mRsrp >= -95) levelRsrp = SIGNAL_STRENGTH_GREAT;
134        else if (mRsrp >= -105) levelRsrp = SIGNAL_STRENGTH_GOOD;
135        else if (mRsrp >= -115) levelRsrp = SIGNAL_STRENGTH_MODERATE;
136        else levelRsrp = SIGNAL_STRENGTH_POOR;
137
138        // See RIL_LTE_SignalStrength in ril.h
139        if (mRssnr == Integer.MAX_VALUE) levelRssnr = 0;
140        else if (mRssnr >= 45) levelRssnr = SIGNAL_STRENGTH_GREAT;
141        else if (mRssnr >= 10) levelRssnr = SIGNAL_STRENGTH_GOOD;
142        else if (mRssnr >= -30) levelRssnr = SIGNAL_STRENGTH_MODERATE;
143        else levelRssnr = SIGNAL_STRENGTH_POOR;
144
145        int level;
146        if (mRsrp == Integer.MAX_VALUE)
147            level = levelRssnr;
148        else if (mRssnr == Integer.MAX_VALUE)
149            level = levelRsrp;
150        else
151            level = (levelRssnr < levelRsrp) ? levelRssnr : levelRsrp;
152
153        if (DBG) log("Lte rsrp level: " + levelRsrp
154                + " snr level: " + levelRssnr + " level: " + level);
155        return level;
156    }
157
158    /**
159     * Get LTE as dBm
160     *
161     * @hide
162     */
163    @Override
164    public int getDbm() {
165        return mRsrp;
166    }
167
168    /**
169     * Get the LTE signal level as an asu value between 0..97, 99 is unknown
170     * Asu is calculated based on 3GPP RSRP. Refer to 3GPP 27.007 (Ver 10.3.0) Sec 8.69
171     *
172     * @hide
173     */
174    @Override
175    public int getAsuLevel() {
176        int lteAsuLevel = 99;
177        int lteDbm = getDbm();
178        if (lteDbm <= -140) lteAsuLevel = 0;
179        else if (lteDbm >= -43) lteAsuLevel = 97;
180        else lteAsuLevel = lteDbm + 140;
181        if (DBG) log("Lte Asu level: "+lteAsuLevel);
182        return lteAsuLevel;
183    }
184
185    /**
186     * Get the timing advance value for LTE.
187     * See 3GPP xxxx
188     */
189    public int getTimingAdvance() {
190        return mTimingAdvance;
191    }
192
193    @Override
194    public int hashCode() {
195        int primeNum = 31;
196        return (mSignalStrength * primeNum) + (mRsrp * primeNum)
197                + (mRsrq * primeNum) + (mRssnr * primeNum) + (mCqi * primeNum)
198                + (mTimingAdvance * primeNum);
199    }
200
201    @Override
202    public boolean equals (Object o) {
203        CellSignalStrengthLte s;
204
205        try {
206            s = (CellSignalStrengthLte) o;
207        } catch (ClassCastException ex) {
208            return false;
209        }
210
211        if (o == null) {
212            return false;
213        }
214
215        return mSignalStrength == s.mSignalStrength
216                && mRsrp == s.mRsrp
217                && mRsrq == s.mRsrq
218                && mRssnr == s.mRssnr
219                && mCqi == s.mCqi
220                && mTimingAdvance == s.mTimingAdvance;
221    }
222
223    /**
224     * @return string representation.
225     */
226    @Override
227    public String toString() {
228        return "CellSignalStrengthLte:"
229                + " ss=" + mSignalStrength
230                + " rsrp=" + mRsrp
231                + " rsrq=" + mRsrq
232                + " rssnr=" + mRssnr
233                + " cqi=" + mCqi
234                + " ta=" + mTimingAdvance;
235    }
236
237    /** Implement the Parcelable interface */
238    @Override
239    public void writeToParcel(Parcel dest, int flags) {
240        if (DBG) log("writeToParcel(Parcel, int): " + toString());
241        dest.writeInt(CellSignalStrength.TYPE_LTE);
242        dest.writeInt(mSignalStrength);
243        dest.writeInt(mRsrp);
244        dest.writeInt(mRsrq);
245        dest.writeInt(mRssnr);
246        dest.writeInt(mCqi);
247        dest.writeInt(mTimingAdvance);
248    }
249
250    /**
251     * Construct a SignalStrength object from the given parcel
252     * where the token is already been processed.
253     */
254    private CellSignalStrengthLte(Parcel in) {
255        mSignalStrength = in.readInt();
256        mRsrp = in.readInt();
257        mRsrq = in.readInt();
258        mRssnr = in.readInt();
259        mCqi = in.readInt();
260        mTimingAdvance = in.readInt();
261        if (DBG) log("CellSignalStrengthLte(Parcel): " + toString());
262    }
263
264    /** Implement the Parcelable interface */
265    @Override
266    public int describeContents() {
267        return 0;
268    }
269
270    /** Implement the Parcelable interface */
271    @SuppressWarnings("hiding")
272    public static final Parcelable.Creator<CellSignalStrengthLte> CREATOR =
273            new Parcelable.Creator<CellSignalStrengthLte>() {
274        @Override
275        public CellSignalStrengthLte createFromParcel(Parcel in) {
276            if (in.readInt() != CellSignalStrength.TYPE_LTE) {
277                throw new RuntimeException("Expecting TYPE_LTE");
278            }
279            return createFromParcelBody(in);
280        }
281
282        @Override
283        public CellSignalStrengthLte[] newArray(int size) {
284            return new CellSignalStrengthLte[size];
285        }
286    };
287
288    /** @hide */
289    public static CellSignalStrengthLte createFromParcelBody(Parcel in) {
290        return new CellSignalStrengthLte(in);
291    }
292
293    /**
294     * log
295     */
296    private static void log(String s) {
297        Log.w(LOG_TAG, s);
298    }
299}
300