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