diff --git a/api/current.xml b/api/current.xml index d5f3f4640b750..37fb3a8bace12 100644 --- a/api/current.xml +++ b/api/current.xml @@ -122805,7 +122805,7 @@ type="android.telephony.NeighboringCellInfo" static="false" final="false" - deprecated="not deprecated" + deprecated="deprecated" visibility="public" > @@ -122813,7 +122813,7 @@ type="android.telephony.NeighboringCellInfo" static="false" final="false" - deprecated="not deprecated" + deprecated="deprecated" visibility="public" > @@ -122853,6 +122853,39 @@ visibility="public" > + + + + + + @@ -122884,7 +122917,7 @@ synchronized="false" static="false" final="false" - deprecated="not deprecated" + deprecated="deprecated" visibility="public" > diff --git a/telephony/java/android/telephony/NeighboringCellInfo.java b/telephony/java/android/telephony/NeighboringCellInfo.java index f492abd88aee1..d698169033872 100644 --- a/telephony/java/android/telephony/NeighboringCellInfo.java +++ b/telephony/java/android/telephony/NeighboringCellInfo.java @@ -18,6 +18,15 @@ package android.telephony; import android.os.Parcel; import android.os.Parcelable; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN; +import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE; +import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSDPA; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSUPA; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSPA; + + /** * Represents the neighboring cell information, including @@ -34,60 +43,202 @@ public class NeighboringCellInfo implements Parcelable */ static final public int UNKNOWN_CID = -1; + /** + * In GSM, mRssi is the Received RSSI; + * In UMTS, mRssi is the Level index of CPICH Received Signal Code Power + */ private int mRssi; + /** + * CID in 16 bits format in GSM. Return UNKNOWN_CID in UMTS and CMDA. + */ private int mCid; + /** + * LAC in 16 bits format in GSM. Return UNKNOWN_CID in UMTS and CMDA. + */ + private int mLac; + /** + * Primary Scrambling Code in 9 bits format in UMTS + * Return UNKNOWN_CID in GSM and CMDA. + */ + private int mPsc; + /** + * Radio network type, value is one of following + * TelephonyManager.NETWORK_TYPE_XXXXXX. + */ + private int mNetworkType; /** + * @deprecated * Empty constructor. Initializes the RSSI and CID. + * + * NeighboringCellInfo is one time shot for the neighboring cells based on + * the radio network type at that moment. Its constructor needs radio network + * type. */ public NeighboringCellInfo() { mRssi = UNKNOWN_RSSI; + mLac = UNKNOWN_CID; mCid = UNKNOWN_CID; + mPsc = UNKNOWN_CID; + mNetworkType = NETWORK_TYPE_UNKNOWN; } /** + * @deprecated * Initialize the object from rssi and cid. + * + * NeighboringCellInfo is one time shot for the neighboring cells based on + * the radio network type at that moment. Its constructor needs radio network + * type. */ public NeighboringCellInfo(int rssi, int cid) { mRssi = rssi; mCid = cid; } + /** + * @hide + * Initialize the object from rssi, location string, and radioType + * radioType is one of following + * {@link TelephonyManager#NETWORK_TYPE_GPRS TelephonyManager.NETWORK_TYPE_GPRS}, + * {@link TelephonyManager#NETWORK_TYPE_EDGE TelephonyManager.NETWORK_TYPE_EDGE}, + * {@link TelephonyManager#NETWORK_TYPE_UMTS TelephonyManager.NETWORK_TYPE_UMTS}, + * {@link TelephonyManager#NETWORK_TYPE_HSDPA TelephonyManager.NETWORK_TYPE_HSDPA}, + * {@link TelephonyManager#NETWORK_TYPE_HSUPA TelephonyManager.NETWORK_TYPE_HSUPA}, + * and {@link TelephonyManager#NETWORK_TYPE_HSPA TelephonyManager.NETWORK_TYPE_HSPA}. + */ + public NeighboringCellInfo(int rssi, String location, int radioType) { + // set default value + mRssi = rssi; + mNetworkType = NETWORK_TYPE_UNKNOWN; + mPsc = UNKNOWN_CID; + mLac = UNKNOWN_CID; + mCid = UNKNOWN_CID; + + + // pad location string with leading "0" + int l = location.length(); + if (l > 8) return; + if (l < 8) { + for (int i = 0; i < (8-l); i++) { + location = "0" + location; + } + } + + try {// set LAC/CID or PSC based on radioType + switch (radioType) { + case NETWORK_TYPE_GPRS: + case NETWORK_TYPE_EDGE: + mNetworkType = radioType; + mLac = Integer.valueOf(location.substring(0, 4), 16); + mCid = Integer.valueOf(location.substring(4), 16); + break; + case NETWORK_TYPE_UMTS: + case NETWORK_TYPE_HSDPA: + case NETWORK_TYPE_HSUPA: + case NETWORK_TYPE_HSPA: + mNetworkType = radioType; + mPsc = Integer.valueOf(location, 16); + break; + } + } catch (NumberFormatException e) { + // parsing location error + mPsc = UNKNOWN_CID; + mLac = UNKNOWN_CID; + mCid = UNKNOWN_CID; + mNetworkType = NETWORK_TYPE_UNKNOWN; + } + } + /** * Initialize the object from a parcel. */ public NeighboringCellInfo(Parcel in) { mRssi = in.readInt(); + mLac = in.readInt(); mCid = in.readInt(); + mPsc = in.readInt(); + mNetworkType = in.readInt(); } /** - * @return received signal strength in "asu", ranging from 0 - 31, - * or UNKNOWN_RSSI if unknown + * @return received signal strength or UNKNOWN_RSSI if unknown * - * For GSM, dBm = -113 + 2*asu, + * For GSM, it is in "asu" ranging from 0 to 31 (dBm = -113 + 2*asu) * 0 means "-113 dBm or less" and 31 means "-51 dBm or greater" + * For UMTS, it is the Level index of CPICH RSCP defined in TS 25.125 */ public int getRssi() { return mRssi; } /** - * @return cell id, UNKNOWN_CID if unknown, 0xffffffff max legal value + * @return LAC in GSM, 0xffff max legal value + * UNKNOWN_CID if in UMTS or CMDA or unknown + */ + public int getLac() { + return mLac; + } + + /** + * @return cell id in GSM, 0xffff max legal value + * UNKNOWN_CID if in UMTS or CDMA or unknown */ public int getCid() { return mCid; } /** + * @return Primary Scrambling Code in 9 bits format in UMTS, 0x1ff max value + * UNKNOWN_CID if in GSM or CMDA or unknown + */ + public int getPsc() { + return mPsc; + } + + /** + * @return Radio network type while neighboring cell location is stored. + * + * Return {@link TelephonyManager#NETWORK_TYPE_UNKNOWN TelephonyManager.NETWORK_TYPE_UNKNOWN} + * means that the location information is unavailable. + * + * Return {@link TelephonyManager#NETWORK_TYPE_GPRS TelephonyManager.NETWORK_TYPE_GPRS} or + * {@link TelephonyManager#NETWORK_TYPE_EDGE TelephonyManager.NETWORK_TYPE_EDGE} + * means that Neighboring Cell information is stored for GSM network, in + * which {@link NeighboringCellInfo#getLac NeighboringCellInfo.getLac} and + * {@link NeighboringCellInfo#getCid NeighboringCellInfo.getCid} should be + * called to access location. + * + * Return {@link TelephonyManager#NETWORK_TYPE_UMTS TelephonyManager.NETWORK_TYPE_UMTS}, + * {@link TelephonyManager#NETWORK_TYPE_HSDPA TelephonyManager.NETWORK_TYPE_HSDPA}, + * {@link TelephonyManager#NETWORK_TYPE_HSUPA TelephonyManager.NETWORK_TYPE_HSUPA}, + * or {@link TelephonyManager#NETWORK_TYPE_HSPA TelephonyManager.NETWORK_TYPE_HSPA} + * means that Neighboring Cell information is stored for UMTS network, in + * which {@link NeighboringCellInfo#getPsc NeighboringCellInfo.getPsc} + * should be called to access location. + */ + public int getNetworkType() { + return mNetworkType; + } + /** + * @deprecated * Set the cell id. + * + * NeighboringCellInfo is a one time shot for the neighboring cells based on + * the radio network type at that moment. It shouldn't be changed after + * creation. */ public void setCid(int cid) { mCid = cid; } /** + * @deprecated * Set the signal strength of the cell. + * + * NeighboringCellInfo is a one time shot for the neighboring cells based on + * the radio network type at that moment. It shouldn't be changed after + * creation. */ public void setRssi(int rssi) { mRssi = rssi; @@ -95,8 +246,20 @@ public class NeighboringCellInfo implements Parcelable @Override public String toString() { - return "["+ ((mCid == UNKNOWN_CID) ? "/" : Integer.toHexString(mCid)) - + " at " + ((mRssi == UNKNOWN_RSSI)? "/" : mRssi) + "]"; + StringBuilder sb = new StringBuilder(); + + sb.append("["); + if (mPsc != UNKNOWN_CID) { + sb.append(Integer.toHexString(mPsc)) + .append("@").append(((mRssi == UNKNOWN_RSSI)? "-" : mRssi)); + } else if(mLac != UNKNOWN_CID && mCid != UNKNOWN_CID) { + sb.append(Integer.toHexString(mLac)) + .append(Integer.toHexString(mCid)) + .append("@").append(((mRssi == UNKNOWN_RSSI)? "-" : mRssi)); + } + sb.append("]"); + + return sb.toString(); } public int describeContents() { @@ -105,7 +268,10 @@ public class NeighboringCellInfo implements Parcelable public void writeToParcel(Parcel dest, int flags) { dest.writeInt(mRssi); + dest.writeInt(mLac); dest.writeInt(mCid); + dest.writeInt(mPsc); + dest.writeInt(mNetworkType); } public static final Parcelable.Creator CREATOR @@ -118,6 +284,4 @@ public class NeighboringCellInfo implements Parcelable return new NeighboringCellInfo[size]; } }; -} - - +} \ No newline at end of file diff --git a/telephony/java/android/telephony/TelephonyManager.java b/telephony/java/android/telephony/TelephonyManager.java index 6664b089c93fd..fb96b2aee5b8c 100644 --- a/telephony/java/android/telephony/TelephonyManager.java +++ b/telephony/java/android/telephony/TelephonyManager.java @@ -254,13 +254,13 @@ public class TelephonyManager { * (@link android.Manifest.permission#ACCESS_COARSE_UPDATES} */ public List getNeighboringCellInfo() { - try { - return getITelephony().getNeighboringCellInfo(); - } catch (RemoteException ex) { - return null; - } catch (NullPointerException ex) { - return null; - } + try { + return getITelephony().getNeighboringCellInfo(); + } catch (RemoteException ex) { + return null; + } catch (NullPointerException ex) { + return null; + } } /** No phone radio. */ diff --git a/telephony/java/com/android/internal/telephony/RIL.java b/telephony/java/com/android/internal/telephony/RIL.java index d1b446be81b79..f3b59a81c2442 100644 --- a/telephony/java/com/android/internal/telephony/RIL.java +++ b/telephony/java/com/android/internal/telephony/RIL.java @@ -17,6 +17,14 @@ package com.android.internal.telephony; import static com.android.internal.telephony.RILConstants.*; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN; +import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE; +import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSDPA; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSUPA; +import static android.telephony.TelephonyManager.NETWORK_TYPE_HSPA; + import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; @@ -30,6 +38,7 @@ import android.os.Looper; import android.os.Message; import android.os.Parcel; import android.os.PowerManager; +import android.os.SystemProperties; import android.os.PowerManager.WakeLock; import android.telephony.NeighboringCellInfo; import android.telephony.PhoneNumberUtils; @@ -2876,21 +2885,44 @@ public final class RIL extends BaseCommands implements CommandsInterface { private Object responseCellList(Parcel p) { - int num; + int num, rssi; + String location; ArrayList response; NeighboringCellInfo cell; num = p.readInt(); - response = new ArrayList(num); + response = new ArrayList(); - for (int i = 0 ; i < num ; i++) { - int rssi = p.readInt(); - int cid = Integer.valueOf(p.readString(), 16); - cell = new NeighboringCellInfo(rssi, cid); - response.add(cell); + // Determine the radio access type + String radioString = SystemProperties.get( + TelephonyProperties.PROPERTY_DATA_NETWORK_TYPE, "unknown"); + int radioType; + if (radioString.equals("GPRS")) { + radioType = NETWORK_TYPE_GPRS; + } else if (radioString.equals("EDGE")) { + radioType = NETWORK_TYPE_EDGE; + } else if (radioString.equals("UMTS")) { + radioType = NETWORK_TYPE_UMTS; + } else if (radioString.equals("HSDPA")) { + radioType = NETWORK_TYPE_HSDPA; + } else if (radioString.equals("HSUPA")) { + radioType = NETWORK_TYPE_HSUPA; + } else if (radioString.equals("HSPA")) { + radioType = NETWORK_TYPE_HSPA; + } else { + radioType = NETWORK_TYPE_UNKNOWN; } - return response; + // Interpret the location based on radio access type + if (radioType != NETWORK_TYPE_UNKNOWN) { + for (int i = 0 ; i < num ; i++) { + rssi = p.readInt(); + location = p.readString(); + cell = new NeighboringCellInfo(rssi, location, radioType); + response.add(cell); + } + } + return response; } private Object responseGmsBroadcastConfig(Parcel p) { diff --git a/tests/AndroidTests/src/com/android/unit_tests/NeighboringCellInfoTest.java b/tests/AndroidTests/src/com/android/unit_tests/NeighboringCellInfoTest.java index 2bdf1dd6122ee..7252aa95fabf2 100644 --- a/tests/AndroidTests/src/com/android/unit_tests/NeighboringCellInfoTest.java +++ b/tests/AndroidTests/src/com/android/unit_tests/NeighboringCellInfoTest.java @@ -15,41 +15,65 @@ */ package com.android.unit_tests; +import android.os.Parcel; import android.test.AndroidTestCase; import android.telephony.NeighboringCellInfo; import android.test. suitebuilder.annotation.SmallTest; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UNKNOWN; +import static android.telephony.TelephonyManager.NETWORK_TYPE_EDGE; +import static android.telephony.TelephonyManager.NETWORK_TYPE_GPRS; +import static android.telephony.TelephonyManager.NETWORK_TYPE_UMTS; + public class NeighboringCellInfoTest extends AndroidTestCase { @SmallTest public void testConstructor() { - NeighboringCellInfo empty = new NeighboringCellInfo(); - assertEquals(NeighboringCellInfo.UNKNOWN_RSSI, empty.getRssi()); - assertEquals(NeighboringCellInfo.UNKNOWN_CID, empty.getCid()); - int rssi = 31; - int cid = 0xffffffff; - NeighboringCellInfo max = new NeighboringCellInfo(rssi, cid); - assertEquals(rssi, max.getRssi()); - assertEquals(cid, max.getCid()); - } + NeighboringCellInfo nc; - @SmallTest - public void testGetAndSet() { - int rssi = 16; - int cid = 0x12345678; - NeighboringCellInfo nc = new NeighboringCellInfo(); - nc.setRssi(rssi); - nc.setCid(cid); + nc = new NeighboringCellInfo(rssi, "FFFFFFF", NETWORK_TYPE_EDGE); + assertEquals(NETWORK_TYPE_EDGE, nc.getNetworkType()); assertEquals(rssi, nc.getRssi()); - assertEquals(cid, nc.getCid()); + assertEquals(0xfff, nc.getLac()); + assertEquals(0xffff, nc.getCid()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getPsc()); + + nc = new NeighboringCellInfo(rssi, "1FF", NETWORK_TYPE_UMTS); + assertEquals(NETWORK_TYPE_UMTS, nc.getNetworkType()); + assertEquals(rssi, nc.getRssi()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getCid()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getLac()); + assertEquals(0x1ff, nc.getPsc()); + + nc = new NeighboringCellInfo(rssi, "1FF", NETWORK_TYPE_UNKNOWN); + assertEquals(NETWORK_TYPE_UNKNOWN, nc.getNetworkType()); + assertEquals(rssi, nc.getRssi()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getCid()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getLac()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getPsc()); } @SmallTest - public void testToString() { - NeighboringCellInfo empty = new NeighboringCellInfo(); - assertEquals("[/ at /]", empty.toString()); + public void testParcel() { + int rssi = 20; - NeighboringCellInfo nc = new NeighboringCellInfo(16, 0x12345678); - assertEquals("[12345678 at 16]", nc.toString()); - } + NeighboringCellInfo nc = new NeighboringCellInfo(rssi, "12345678", NETWORK_TYPE_GPRS); + assertEquals(NETWORK_TYPE_GPRS, nc.getNetworkType()); + assertEquals(rssi, nc.getRssi()); + assertEquals(0x1234, nc.getLac()); + assertEquals(0x5678, nc.getCid()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nc.getPsc()); + + Parcel p = Parcel.obtain(); + p.setDataPosition(0); + nc.writeToParcel(p, 0); + + p.setDataPosition(0); + NeighboringCellInfo nw = new NeighboringCellInfo(p); + assertEquals(NETWORK_TYPE_GPRS, nw.getNetworkType()); + assertEquals(rssi, nw.getRssi()); + assertEquals(0x1234, nw.getLac()); + assertEquals(0x5678, nw.getCid()); + assertEquals(NeighboringCellInfo.UNKNOWN_CID, nw.getPsc()); + } }