In this tutorial I would show how to measure the signal strengths in Android. Since Android is a mobile operating system, therefore measuring signal strengths from device itself would be a very easy task. Android onSignalStrengthsChanged is a method in Android PhoneStateListener class which observes the changes in telephony states of a device. In my previous tutorials I utilized the power of Android PhoneStateListener class to determine the changes in message waiting indicator, service state, data activity and also to monitor the change in cell info. If you wish to read the full series, links are below:

1) Android PhoneStateListener Example
2) Android onDataConnectionStateChanged – Detect Network Type
3) Android onSignalStrengthsChanged – LTE Strength Measurement

To listen the change in signal strengths a flag PhoneStateListener.LISTEN_SIGNAL_STRENGTHS is used in the listen method of TelphonyManager class. By using this flag we will start getting the callbacks in onSignalStrengthsChanged(SignalStrength signalStrength) method whenever the signal strength of network changes.

No Permissions needed

Now the interesting part here is that, to use the Android onSignalStrengthsChanged method we don’t need to add any permissions in our manifest. I tested this on a Kitkat 4.4.4 device.

Lets start with PhoneStateListener Activity:

package com.truiton.phonestatelistener;

import android.support.v7.app.ActionBarActivity;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.annotation.TargetApi;
import android.os.Build;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class PhoneStateListenerActivity extends ActionBarActivity {
 TelephonyManager tManager;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_phone_state_listener);

 tManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
 tManager.listen(new CustomPhoneStateListener(this),
 PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 getMenuInflater().inflate(R.menu.phone_state_listener, menu);
 return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 int id = item.getItemId();
 if (id == R.id.action_settings) {
 return true;
 }
 return super.onOptionsItemSelected(item);
 }
}

As you can see in the above class, a custom Android PhoneStateListener is used to capture the updates of signal strengths with the help of TelephonyManager class. as soon as the listener is registered, we start receiving callbacks in Android PhoneStateListener onSignalStrengthsChanged method.

Android onSignalStrengthsChanged LTE measurement

LTE (Long-Term Evolution) is a new emerging standard for wireless communication. LTE is an upgrade for both GSM/UMTS and CDMA2000 Networks. Here the good part is, android supports LTE standard. With the help of PhoneStateListener and Android onSignalStrengthsChanged method we can measure LTE signal strengths. In this Android onSignalStrengthsChanged – LTE Strength Measurement tutorial I would show how to measure the signal strength for LTE network by using the Java Reflection APIs. Lets define the custom PhoneStateListener:

package com.truiton.phonestatelistener;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import android.content.Context;
import android.telephony.PhoneStateListener;
import android.telephony.SignalStrength;
import android.util.Log;

public class CustomPhoneStateListener extends PhoneStateListener {
 Context mContext;
 public static String LOG_TAG = "CustomPhoneStateListener";

 public CustomPhoneStateListener(Context context) {
 mContext = context;
 }

 /**
  * In this method Java Reflection API is being used please see link before
  * using.
  * 
  * @see <a
  *      href="http://docs.oracle.com/javase/tutorial/reflect/">http://docs.oracle.com/javase/tutorial/reflect/</a>
  * 
  */
 @Override
 public void onSignalStrengthsChanged(SignalStrength signalStrength) {
 super.onSignalStrengthsChanged(signalStrength);
 Log.i(LOG_TAG, "onSignalStrengthsChanged: " + signalStrength);
 if (signalStrength.isGsm()) {
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getGsmBitErrorRate "
 + signalStrength.getGsmBitErrorRate());
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getGsmSignalStrength "
 + signalStrength.getGsmSignalStrength());
 } else if (signalStrength.getCdmaDbm() > 0) {
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getCdmaDbm "
 + signalStrength.getCdmaDbm());
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getCdmaEcio "
 + signalStrength.getCdmaEcio());
 } else {
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getEvdoDbm "
 + signalStrength.getEvdoDbm());
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getEvdoEcio "
 + signalStrength.getEvdoEcio());
 Log.i(LOG_TAG, "onSignalStrengthsChanged: getEvdoSnr "
 + signalStrength.getEvdoSnr());
 }

 // Reflection code starts from here
 try {
 Method[] methods = android.telephony.SignalStrength.class
 .getMethods();
 for (Method mthd : methods) {
 if (mthd.getName().equals("getLteSignalStrength")
 || mthd.getName().equals("getLteRsrp")
 || mthd.getName().equals("getLteRsrq")
 || mthd.getName().equals("getLteRssnr")
 || mthd.getName().equals("getLteCqi")) {
 Log.i(LOG_TAG,
 "onSignalStrengthsChanged: " + mthd.getName() + " "
 + mthd.invoke(signalStrength));
 }
 }
 } catch (SecurityException e) {
 e.printStackTrace();
 } catch (IllegalArgumentException e) {
 e.printStackTrace();
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 } catch (InvocationTargetException e) {
 e.printStackTrace();
 }
 // Reflection code ends here
 }
}

Before moving forward let me give a brief intro to Java Reflection API. Reflection API is used to examine or modify the run-time behavior of any application in running in virtual machine (DVM or ART). Since this is a very powerful API, it is advised to use this only if you know what you are doing. To read more about reflection API, please go here. Coming back to this tutorial, here we are using the reflection APIs to invoke following methods which are not included in Android APIs:

1. getLteSignalStrength – Returns LTE signal strength
2. getLteRsrp – Returns LTE Reference Signal Received Power
3. getLteRsrq – Returns LTE Reference Signal Received Quality
4. getLteRssnr – Returns LTE rssnr
5. getLteCqi – Returns LTE Channel Quality Indication

Android Signal Strength

Although if we go by standard Android APIs, whenever Android onSignalStrengthsChanged method is invoked an object of SignalStrength is passed as an argument. As its shown in the above code, with this object we can determine the type of signal being receiving on device. It could be any type of network like GSM, CDMA or EVDO, hence one can get signal strength as well. Hope this helped you out, if it did please share it with your friends.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android onSignalStrengthsChanged – LTE Strength Measurement appeared first on Truiton.

While playing with network and phone states in android there could always be a situation where one would like to detect the network type and monitor the changes of data connection state. Both of these situations can be taken care off, with the help of Android PhoneStateListener onDataConnectionStateChanged method. As I mentioned in my previous tutorial that PhoneStateListener class works as an interface along with TelephonyManager class. Although this tutorial is focused on Android onDataConnectionStateChanged if you wish to read in detail about these classes please go through my complete series on PhoneStateListener.

1) Android PhoneStateListener Example
2) Android onDataConnectionStateChanged – Detect Network Type
3) Android onSignalStrengthsChanged – LTE Strength Measurement

Android onDataConnectionStateChanged

This is a method in PhoneStateListener class of Android, which is used to monitor the data connection state changes (only for network not wifi). Although if you want to monitor the changes in overall data connectivity you could go for the  ConnectivityManager class and use ConnectivityManager.CONNECTIVITY_ACTION. Since the connectivity manager can monitor the changes in both wifi and data, obviously its a better option. But at times there are situations when one needs to monitor several network related things and this can be done only through Android PhoneStateListener class. Threfore in such situation one can definitely use Android onDataConnectionStateChanged method to monitor network data changes.

Another situation when this Android onDataConnectionStateChanged method could be used is when, device is connected to the wifi network and you need to detect operator data connection state. To use this method we need to define following permission in the manifest:

<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

Lets define an activity where PhoneStateListener class can be initialized:

package com.truiton.phonestatelistener;

import android.support.v7.app.ActionBarActivity;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class PhoneStateListenerActivity extends ActionBarActivity {
 TelephonyManager tManager;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_phone_state_listener);

 tManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
 tManager.listen(new CustomPhoneStateListener(this),
 PhoneStateListener.LISTEN_DATA_CONNECTION_STATE);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 getMenuInflater().inflate(R.menu.phone_state_listener, menu);
 return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 int id = item.getItemId();
 if (id == R.id.action_settings) {
 return true;
 }
 return super.onOptionsItemSelected(item);
 }
}

In the above class we created an instance of TelephonyManager and used its method listen(PhoneStateListener listener, int events) to listen the specified PhoneStateListener LISTEN_ flags. Now if we closely observe the listen method, we passed new object of our custom PhoneStateListener and specified the PhoneStateListener.LISTEN_DATA_CONNECTION_STATE flag. Meaning that the specified object of PhoneStateListener would get callbacks of onDataConnectionStateChanged(int state, int networkType) method, which would solve our purpose here.

Lets define custom Android PhoneStateListener onDataConnectionStateChanged method:

package com.truiton.phonestatelistener;

import android.content.Context;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.util.Log;

public class CustomPhoneStateListener extends PhoneStateListener {
 Context mContext;
 public static String LOG_TAG = "CustomPhoneStateListener";

 public CustomPhoneStateListener(Context context) {
 mContext = context;
 }

 @Override
 public void onDataConnectionStateChanged(int state, int networkType) {
 super.onDataConnectionStateChanged(state, networkType);
 switch (state) {
 case TelephonyManager.DATA_DISCONNECTED:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: DATA_DISCONNECTED");
 break;
 case TelephonyManager.DATA_CONNECTING:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: DATA_CONNECTING");
 break;
 case TelephonyManager.DATA_CONNECTED:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: DATA_CONNECTED");
 break;
 case TelephonyManager.DATA_SUSPENDED:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: DATA_SUSPENDED");
 break;
 default:
 Log.w(LOG_TAG, "onDataConnectionStateChanged: UNKNOWN " + state);
 break;
 }

 switch (networkType) {
 case TelephonyManager.NETWORK_TYPE_CDMA:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_CDMA");
 break;
 case TelephonyManager.NETWORK_TYPE_EDGE:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_EDGE");
 break;
 case TelephonyManager.NETWORK_TYPE_EVDO_0:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_EVDO_0");
 break;
 case TelephonyManager.NETWORK_TYPE_GPRS:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_GPRS");
 break;
 case TelephonyManager.NETWORK_TYPE_HSDPA:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_HSDPA");
 break;
 case TelephonyManager.NETWORK_TYPE_HSPA:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_HSPA");
 break;
 case TelephonyManager.NETWORK_TYPE_IDEN:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_IDEN");
 break;
 case TelephonyManager.NETWORK_TYPE_LTE:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_LTE");
 break;
 case TelephonyManager.NETWORK_TYPE_UMTS:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_UMTS");
 break;
 case TelephonyManager.NETWORK_TYPE_UNKNOWN:
 Log.i(LOG_TAG, "onDataConnectionStateChanged: NETWORK_TYPE_UNKNOWN");
 break;
 default:
 Log.w(LOG_TAG, "onDataConnectionStateChanged: Undefined Network: "
 + networkType);
 break;
 }
 }
}

After running this piece of code, you would observe that whenever there is a change in the of data connection, a callback is received in the Android PhoneStateListener onDataConnectionStateChanged(int state, int networkType) method.

With this method we can monitor two things

1. Data Connection State (int state) – This parameter would give us the current state of data connection, it could range from TelephonyManager.DATA_DISCONNECTED to TelephonyManager.DATA_SUSPENDED.
2. Network Type (int networkType) – This parameter would tell the us the type of device’s network connection. At present there are a total of 16 network types and it can range from TelephonyManager.NETWORK_TYPE_1xRTT to TelephonyManager.NETWORK_TYPE_UNKNOWN.

To conclude I would say that with this Android onDataConnectionStateChanged – Detect Network Type tutorial one can monitor changes in the data connection state and cell network type.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android onDataConnectionStateChanged – Detect Network Type appeared first on Truiton.

While searching through some documentation I found an interesting class of android through which we can listen to some basic network related events, called Android PhoneStateListener which lead to this tutorial Android PhoneStateListener Example. Another class which needs an introduction is TelephonyManager, as this is the class which uses the Android PhoneStateListener to listen telephony service updates. This tutorial is the first one in the series of exploring Android PhoneStateListener and TelephonyManager classes at Truiton.com. Links to complete series are:

1) Android PhoneStateListener Example
2) Android onDataConnectionStateChanged – Detect Network Type
3) Android onSignalStrengthsChanged – LTE Strength Measurement

To start off let me give a brief intro about what all things I’ll be covering in this tutorial. Here I would be instantiating an object of Android TelephonyManager and listening to the updates of Context.TELEPHONY_SERVICE. To monitor the changes of specific telephony states like PhoneStateListener.LISTEN_CELL_INFO, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS, PhoneStateListener.LISTEN_DATA_CONNECTION_STATE and many more, I will be declaring a class CustomPhoneStateListener which will extend Android PhoneStateListener and override all of its methods.

Android TelephonyManager

This class of android is the main class through which one can access the telephony services of a device. All the information in this class is accessed through a system-level service called Context.TELEPHONY_SERVICE. Since this tutorial is focused on Android PhoneStateListener lets not get in depth of this class. The only relevant method for us in this class is TelephonyManager.listen(PhoneStateListener listener, int events). And for this method I will be declaring a custom PhoneStateListener.

Android PhoneStateListener

This is the actual class which gets callbacks, whenever some change is observed in TELEPHONY_SERVICE. Android PhoneStateListener has many callback methods which are called if we register for their specific LISTEN_ flag in the TelephonyManager’s listen method. Have a look at the listing below to correlate LISTEN_ flags with Android PhoneStateListener’s callback methods:

ANDROID PHONESTATELISTENER CALLBACK METHODS

Now since we are dealing here with phone states and locations we would require to declare some permissions in manifest:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.truiton.phonestatelistener"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="21" />

    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".PhoneStateListenerActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Next lets define our PhoneStateListenerActivity

package com.truiton.phonestatelistener;

import android.support.v7.app.ActionBarActivity;
import android.telephony.PhoneStateListener;
import android.telephony.TelephonyManager;
import android.annotation.TargetApi;
import android.os.Build;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;

public class PhoneStateListenerActivity extends ActionBarActivity {
 TelephonyManager tManager;

 @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
 // Added because of PhoneStateListener.LISTEN_CELL_INFO
 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_phone_state_listener);

 tManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
 tManager.listen(new CustomPhoneStateListener(this),
 PhoneStateListener.LISTEN_CALL_STATE
 | PhoneStateListener.LISTEN_CELL_INFO // Requires API 17
 | PhoneStateListener.LISTEN_CELL_LOCATION
 | PhoneStateListener.LISTEN_DATA_ACTIVITY
 | PhoneStateListener.LISTEN_DATA_CONNECTION_STATE
 | PhoneStateListener.LISTEN_SERVICE_STATE
 | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS
 | PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR
 | PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 getMenuInflater().inflate(R.menu.phone_state_listener, menu);
 return true;
 }

 @Override
 public boolean onOptionsItemSelected(MenuItem item) {
 int id = item.getItemId();
 if (id == R.id.action_settings) {
 return true;
 }
 return super.onOptionsItemSelected(item);
 }
}

In this class one can see that in the tManager.listen method a new object for CustomPhoneStateListener is defined and in the events parameter a bitwise-OR combination of Android PhoneStateListener LISTEN_ flags is passed. Now lets have a look at some of the main methods of CustomPhoneStateListener.

package com.truiton.phonestatelistener;

import java.util.List;

import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build;
import android.telephony.CellInfo;
import android.telephony.CellLocation;
import android.telephony.PhoneStateListener;
import android.telephony.ServiceState;
import android.telephony.TelephonyManager;
import android.telephony.cdma.CdmaCellLocation;
import android.telephony.gsm.GsmCellLocation;
import android.util.Log;

public class CustomPhoneStateListener extends PhoneStateListener {
 Context mContext;
 public static String LOG_TAG = "CustomPhoneStateListener";

 public CustomPhoneStateListener(Context context) {
 mContext = context;
 }

 @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
 @Override
 public void onCellInfoChanged(List<CellInfo> cellInfo) {
 super.onCellInfoChanged(cellInfo);
 Log.i(LOG_TAG, "onCellInfoChanged: " + cellInfo);
 }

 @Override
 public void onDataActivity(int direction) {
 super.onDataActivity(direction);
 switch (direction) {
 case TelephonyManager.DATA_ACTIVITY_NONE:
 Log.i(LOG_TAG, "onDataActivity: DATA_ACTIVITY_NONE");
 break;
 case TelephonyManager.DATA_ACTIVITY_IN:
 Log.i(LOG_TAG, "onDataActivity: DATA_ACTIVITY_IN");
 break;
 case TelephonyManager.DATA_ACTIVITY_OUT:
 Log.i(LOG_TAG, "onDataActivity: DATA_ACTIVITY_OUT");
 break;
 case TelephonyManager.DATA_ACTIVITY_INOUT:
 Log.i(LOG_TAG, "onDataActivity: DATA_ACTIVITY_INOUT");
 break;
 case TelephonyManager.DATA_ACTIVITY_DORMANT:
 Log.i(LOG_TAG, "onDataActivity: DATA_ACTIVITY_DORMANT");
 break;
 default:
 Log.w(LOG_TAG, "onDataActivity: UNKNOWN " + direction);
 break;
 }
 }

 @Override
 public void onServiceStateChanged(ServiceState serviceState) {
 super.onServiceStateChanged(serviceState);
 Log.i(LOG_TAG, "onServiceStateChanged: " + serviceState.toString());
 Log.i(LOG_TAG, "onServiceStateChanged: getOperatorAlphaLong "
 + serviceState.getOperatorAlphaLong());
 Log.i(LOG_TAG, "onServiceStateChanged: getOperatorAlphaShort "
 + serviceState.getOperatorAlphaShort());
 Log.i(LOG_TAG, "onServiceStateChanged: getOperatorNumeric "
 + serviceState.getOperatorNumeric());
 Log.i(LOG_TAG, "onServiceStateChanged: getIsManualSelection "
 + serviceState.getIsManualSelection());
 Log.i(LOG_TAG,
 "onServiceStateChanged: getRoaming "
 + serviceState.getRoaming());

 switch (serviceState.getState()) {
 case ServiceState.STATE_IN_SERVICE:
 Log.i(LOG_TAG, "onServiceStateChanged: STATE_IN_SERVICE");
 break;
 case ServiceState.STATE_OUT_OF_SERVICE:
 Log.i(LOG_TAG, "onServiceStateChanged: STATE_OUT_OF_SERVICE");
 break;
 case ServiceState.STATE_EMERGENCY_ONLY:
 Log.i(LOG_TAG, "onServiceStateChanged: STATE_EMERGENCY_ONLY");
 break;
 case ServiceState.STATE_POWER_OFF:
 Log.i(LOG_TAG, "onServiceStateChanged: STATE_POWER_OFF");
 break;
 }
 }

 @Override
 public void onCallStateChanged(int state, String incomingNumber) {
 super.onCallStateChanged(state, incomingNumber);
 switch (state) {
 case TelephonyManager.CALL_STATE_IDLE:
 Log.i(LOG_TAG, "onCallStateChanged: CALL_STATE_IDLE");
 break;
 case TelephonyManager.CALL_STATE_RINGING:
 Log.i(LOG_TAG, "onCallStateChanged: CALL_STATE_RINGING");
 break;
 case TelephonyManager.CALL_STATE_OFFHOOK:
 Log.i(LOG_TAG, "onCallStateChanged: CALL_STATE_OFFHOOK");
 break;
 default:
 Log.i(LOG_TAG, "UNKNOWN_STATE: " + state);
 break;
 }
 }

 @TargetApi(Build.VERSION_CODES.GINGERBREAD)
 @Override
 public void onCellLocationChanged(CellLocation location) {
 super.onCellLocationChanged(location);
 if (location instanceof GsmCellLocation) {
 GsmCellLocation gcLoc = (GsmCellLocation) location;
 Log.i(LOG_TAG,
 "onCellLocationChanged: GsmCellLocation "
 + gcLoc.toString());
 Log.i(LOG_TAG, "onCellLocationChanged: GsmCellLocation getCid "
 + gcLoc.getCid());
 Log.i(LOG_TAG, "onCellLocationChanged: GsmCellLocation getLac "
 + gcLoc.getLac());
 Log.i(LOG_TAG, "onCellLocationChanged: GsmCellLocation getPsc"
 + gcLoc.getPsc()); // Requires min API 9
 } else if (location instanceof CdmaCellLocation) {
 CdmaCellLocation ccLoc = (CdmaCellLocation) location;
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation "
 + ccLoc.toString());
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation getBaseStationId "
 + ccLoc.getBaseStationId());
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation getBaseStationLatitude "
 + ccLoc.getBaseStationLatitude());
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation getBaseStationLongitude"
 + ccLoc.getBaseStationLongitude());
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation getNetworkId "
 + ccLoc.getNetworkId());
 Log.i(LOG_TAG,
 "onCellLocationChanged: CdmaCellLocation getSystemId "
 + ccLoc.getSystemId());
 } else {
 Log.i(LOG_TAG, "onCellLocationChanged: " + location.toString());
 }
 }

 @Override
 public void onCallForwardingIndicatorChanged(boolean cfi) {
 super.onCallForwardingIndicatorChanged(cfi);
 Log.i(LOG_TAG, "onCallForwardingIndicatorChanged: " + cfi);
 }

 @Override
 public void onMessageWaitingIndicatorChanged(boolean mwi) {
 super.onMessageWaitingIndicatorChanged(mwi);
 Log.i(LOG_TAG, "onMessageWaitingIndicatorChanged: " + mwi);
 }
}

Here in the above class I extended the Android PhoneStateListener class and I am overriding some of its key methods. Through these overridden methods we can access the telephony states, cell locations, network types, incoming call number and much more network carrier related information. In this Android PhoneStateListener Example I’ll be explaining all key methods in short except two key callback methods as they have separate tutorials. First one onDataConnectionStateChanged and second one onSignalStrengthsChanged. To keep it simple and self explanatory I am just using logs to display the all the states. Now lets start with first overridden method:

Android PhoneStateListener onDataActivity

This method is called when some data activity is observed like upload or download or both. Whenever there is a change in network data you would receive a callback here.

Android PhoneStateListener onServiceStateChanged

This method is called when something changes in network operator service. It could be a change in service when phone goes from in service to out of service or to emergency only. In this callback method, along with states some other parameters are returned like operator name from getOperatorAlphaLong method. To detect if phone is in roaming getRoaming method can be used.

Android PhoneStateListener onCallStateChanged

Well this method is one of the most used method of this class as this method listens to the call state changes. Like when phone starts ringing, call is put on hold or a call is ended.

Android PhoneStateListener onCellLocationChanged

This method is called when your device switches operator cell location. This method can provide great amounts of information regarding the location of device as its object can be cast to GsmCellLocation or CdmaCellLocation. Once we have location area code through GsmCellLocation.getLac() method and cell id through GsmCellLocation.getCid() method we can query and get actual latitude and longitude of that location by any web-service freely available on internet. Also would like to mention here that in case of CDMA device this process is not required as CdmaCellLocation class contains the latitude and longitude parameters in itself.

Concluding this tutorial I would like to mention separate tutorials are available for more methods like onSignalStrengthsChanged and onDataConnectionStateChanged. Please share this tutorial if it helped you.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android PhoneStateListener Example appeared first on Truiton.