In part 3 I've looked at the entry method of my app that is called whenever the app is started and how it registers a listener object to network status events. In this part I'll take a look at the listener object itself.
The code for the listener object is part of my app and is a private class that is only visible to my app but not to the outside world. Here's a code snippet that shows how it looks like:
private class MyPhoneStateListener extends PhoneStateListener {
/* Get the Signal strength from the provider,
each time there is an update */
@Override
public void onSignalStrengthsChanged(SignalStrength signalStrength) {
[…]
try {
/* output signal strength value directly on canvas of
the main activity */
outputText = "v7, number of updates: " +
String.valueOf(NumberOfSignalStrengthUpdates);
NumberOfSignalStrengthUpdates += 1;
outputText += "rnrnNetwork Operator: " +
Tel.getNetworkOperator() +
" "+ Tel.getNetworkOperatorName() + "rn";
outputText += "Network Type: " +
String.valueOf(Tel.getNetworkType()) +
"rnrn";
[…]
To keep things simple the app only uses one listener method in the listener object, "onSignalStrengthsChanges". As the name implies this method is called whenever the signal strength of the current cell changes. It is "overridden" as I don't want Android to execute the default actions of this method but I want to do my own things in my instance of the class. When this method is called I also get other network status information and compare it to previously received values. If, for example, the cell-id has changed, I increase a corresponding counter variable accordingly.
Reading network status information seems to be a dangerous thing. If network coverage is lost and the method is called for whatever reason, one of the status query methods throws an error, known as an "exception" in Java. If that exception is not handled, the application will be terminated with an error message presented to the user. To prevent that from happening, all network status querries are performed in a "try – catch" construct. If an exception occurs in the "try" part of the code, execution continues in the "catch" part where the exception can be handled. In the case of this app, the code for the "catch" part is rather short as it doesn't do anything with the exception and just hopes for a better day when the device finds the network again.
To retrieve the network status information I am interested in, I call the following methods provided by the Android API:
- TelephonyManager.getNetworkOperator()
- TelephonyManager.getNetworkOperatorName()
- TelephonyManager.getNetworkOperatorType()
- SignalStrength.getGsmSignalStrength() –> works for UMTS as well…
- GsmCellLocation.getCid()
- GsmLellLocation.getLac()
There's also objects and methods in the API to get information about neighboring cells. However, this doesn't seem to be implemented consistently accross different devices and network technologies. In fact I tried this on several different types and models and only one would give me neighboring cell information and then only for GSM but not for UMTS. Here's the code for it:
/* Neighbor Cell Stuff */
List<NeighboringCellInfo> nbcell = Tel.getNeighboringCellInfo ();
outputText += "Number of Neighbors: " +
String.valueOf(nbcell.size()) + "rn";
Iterator<NeighboringCellInfo> it = nbcell.iterator();
while (it.hasNext()) {
outputText += String.valueOf((it.next()getCid())) + "rn";
}
And finally, the output text I've generated needs to end up on the screen. There are several ways to do it and I've decided to go for the straight forward approach:
/* And finally, output the generated string with all the
info retrieved */
TextView tv = new TextView(getApplicationContext());
tv.setText(outputText);
setContentView(tv);
There we go, this is the core of the app to get network status information via the Android API. I guess one more part in this series is necessary to describe some bells and whistles for smooth user interaction and of course the release of the complete code so you can play around with it as well if you like.