Spinner with "re-select" functionality

This is an advanced tutorial: I'll cover custom views, the Android source code and Java reflection.

A simple Spinner

As you probably already know, when the user selects an item from a Spinner the event onItemSelected is triggered.
To define the selection event handler for a Spinner, you have to implement the AdapterView.OnItemSelectedListener interface and the corresponding onItemSelected() callback method:

public class SpinnerActivity extends Activity implements OnItemSelectedListener {
 //...
 
    public void onItemSelected(AdapterView<?> parent, View view,
            int pos, long id) {
        // An item was selected. You can retrieve the selected item using
        // parent.getItemAtPosition(pos)
    }

    public void onNothingSelected(AdapterView<?> parent) {
        // Another interface callback
    }
}

However, if the Spinner is set to a specific item and the user re-selects the same item, no callback method is invoked. The reason is that the default implementation of the Spinner class uses an internal variable to keep track of the currently selected item: if the user re-selects the same item, no callback method is triggered.

To be more precise, to understand exactly what happens we have to look at the source code of the Spinner class, using AndroidXRef:

By examining the source code you can discover that when the user selects an item the method setSelection is invoked (check the methods onClick and show) . The method setSelection is defined in the superclass AbsSpinner (Spinner infact extends AbsSpinner).

As you can see the method setSelection calls setSelectionInt, which checks if the currently selected item is equal to the item already selected: in this case no event is triggered.

From the source code of setSelectionInt we discover that the class uses the variable mOldSelectedPosition to keep track of the already selected item of the Spinner. However, the AbsSpinner class contains no definition of this variable, so we have to check the superclasses.

After a brief search you can discover that mOldSelectedPosition is defined in the class AdapterView (superclass of AbsSpinner):

Now we have all the elements to create our custom Spinner with "re-select" functionality:

import java.lang.reflect.Field;

import android.content.Context;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.Spinner;


public class SpinnerReselect extends Spinner {
 
 public SpinnerReselect(Context context) {
     super(context);
     // TODO Auto-generated constructor stub
 }
 
 public SpinnerReselect(Context context, AttributeSet attrs) {
     super(context, attrs);
     // TODO Auto-generated constructor stub
 }
 
 public SpinnerReselect(Context context, AttributeSet attrs, int defStyle) {
     super(context, attrs, defStyle);
     // TODO Auto-generated constructor stub
 }

  @Override
 public void setSelection(int position, boolean animate) {
     ignoreOldSelectionByReflection();
     super.setSelection(position, animate);
 }

  private void ignoreOldSelectionByReflection() {
     try {
         Class<?> c = this.getClass().getSuperclass().getSuperclass().getSuperclass();
         Field reqField = c.getDeclaredField("mOldSelectedPosition");
         reqField.setAccessible(true);
         reqField.setInt(this, -1);
     } catch (Exception e) {
         Log.d("Exception Private", "ex", e);
         // TODO: handle exception
     }
 }

  @Override
 public void setSelection(int position) {
     ignoreOldSelectionByReflection();
     super.setSelection(position);
 }
}

By implementing our custom Spinner we have to override the default implementation of the setSelection methods. To do so, we simply call the method ignoreOldSelectionByReflection before calling the default methods (defined in the class AbsSpinner: that's why we use super.setSelection...).

In the method ignoreOldSelectionByReflection we make use of Java reflection. Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. This is a relatively advanced feature and should be used only by developers who have a strong grasp of the fundamentals of the language. With that caveat in mind, reflection is a powerful technique and can enable applications to perform operations which would otherwise be impossible.

Let's examine the code:

Class<?> c = this.getClass().getSuperclass().getSuperclass().getSuperclass();

As we already saw the variable mOldSelectedPosition is defined the class AdapterView (superclass of AbsSpinner). So we have to get a reference to this class by calling getClass and getSuperclass respectively.

Field reqField = c.getDeclaredField("mOldSelectedPosition");

reqField.setAccessible(true);

The secondo step is to get access to the field mOldSelectedPosition. By calling reqField.setAccessible(true) we make sure that the reflected object should suppress Java language access checking when it is used.

reqField.setInt(this, -1);

The trick is quite clear: we set the value of mOldSelectedPosition to -1 to make sure that the currently selected item of the Spinner is always different from the previously selected item, even if the user re-selectes the same item.
This way the method setSelection is always triggered!

ListPreference: how to load data dinamically

In this tutorial I'll explain how to populate a ListPreference programmatically. It is easier than you might expect; however I haven't found any official tutorial about it. If you need more information about Settings in Android you can read the official documentation.

Generally speaking, if you want to add a ListPreference to your app's settings, you have to add a ListPreference object in the preference XML file, like in the following example:

<ListPreference
        android:dependency="pref_sync"
        android:key="pref_syncConnectionType"
        android:title="@string/pref_syncConnectionType"
        android:dialogTitle="@string/pref_syncConnectionType"
        android:entries="@array/pref_syncConnectionTypes_entries"
        android:entryValues="@array/pref_syncConnectionTypes_values"
        android:defaultValue="@string/pref_syncConnectionTypes_default" />

As you can see you provide the entries of the ListPreference, and the corresponding values, with the items android:entries and android:entryValues, that refer to an array loaded in the res/values folder.
But if you want to load the data programmatically (for example, if you want to fetch the data from a local database or from an online service), you must create a custom ListPreference class.

To begin with, let's see the new preference XML file with a reference to our custom ListPreference:

<com.androidthetechnicalblog.preference.MyCustomPreference
            android:key="pref_mycustompreference"
            android:title="@string/pref_mycustompreference"
            android:summary="@string/pref_mycustompreference_summary"/>

We are creating a custom ListPreference class, so we must provide the full path of the class. As you can also see, we omitted android:entries and android:entryValues, because we want to load the data programmatically.

Now let's see how MyCustomPreference class looks like (not relevant code omitted for brevity):

public class MyCustomPreference extends ListPreference {  
    // ...  

    public MyCustomPreference (Context context, AttributeSet attrs) {      
        super(context, attrs);      
    
        setEntries(entries());         
        setEntryValues(entryValues());         
        setValueIndex(initializeIndex());       
    }  

    public MyCustomPreference (Context context) {      
        this(context, null);  
    }  

    private CharSequence[] entries() {      
        //action to provide entry data in char sequence array for list          
        String myEntries[] = {"one", "two", "three", "four", "five"};         

        return myEntries;  
    }  

    private CharSequence[] entryValues() {      
        //action to provide value data for list           
     
        String myEntryValues[] = {"ten", "twenty", "thirty", "forty", "fifty"};
        return myEntryValues;
   }

   private int initializeIndex() {
        //here you can provide the value to set (typically retrieved from the SharedPreferences)
        //...

        int i = 2;
        return i;
    }
}

The code is quite simple. You just have to provide the entries and entryValues through the methods setEntries and setEntryValues, that accept a CharSequence (or String) array as a parameter. You can also set the default initial value, typically retrieved from the SharedPreferences, through the method setValueIndex. 

For everything that is not explicitly covered in this tutorial you can refer to the official documentation aboud Android settings.

Animating a ProgressBar to a specific value

In this tutorial I'll explain how to set a specific progress value to a ProgressBar using a smooth animation.

ObjectAnimator animation = ObjectAnimator.ofInt(pbBudget, "progress", 0, 50);

To begin with we create an ObjectAnimator object: this is a subclass of ValueAnimator that provides support for animating properties on target objects. The constructors of this class take parameters to define the target object that will be animated as well as the name of the property that will be animated. In this example we used the following parameters:

• pbBudget: reference to the ProgressBar in the layout;
• "progress": the name of the property to be animated;
• 0: starting point of the animation;
• 50: ending point of the animation.

animation.setDuration(1500);

The code is self-explanatory: the animation lasts 1,5 seconds.

animation.setInterpolator(new DecelerateInterpolator());

It is possible to use different interpolators for our animation, like for example:

• LinearInterpolator, where the rate of change is constant;
• DecelerateInterpolator, where the rate of change starts out quickly and and then decelerates;
• AccelerateInterpolator, where the rate of change starts out slowly and and then accelerates;
• OvershootInterpolator, where the change flings forward and overshoots the last value then comes back;
• etc... (for other interpolator check the interface android.view.animation.Interpolator).

animation.start();

You can also create an animation for the ProgressBar from scratch, using the method setProgress(int progress) with a delay (android.os.SystemClock.sleep(long ms)).

If you decide to do so, I suggest to use an AsyncTask and update the ProgressBar using the onProgressUpdate method.

Avoid animating the ProgressBar in the UI thread with a loop:

1. because this will freeze the UI until the animation is completed;
2. because even though you are in the UI thread, you don't release the UI thread until the animation is completed, thus preventing the system to update the UI (and the ProgressBar) itself.

Hidden Android APIs: hiding SMS messages to the default SMS receiver

In a previous tutorial we saw how to take advantage of the hidden Android APIs to listen to incoming SMS messages.
Now suppose that we want to listen to specific SMS messages (messages coming from a particular number or containing specific strings) and to hide them to the default SMS receiver (like Google Hangout or other client).

This is a private message!

As in the previous tutorial we have to declare a BroadcastReceiver in the AndroidManifest.xml file. However, in order to take priority over the default SMS receiver, we also have to set a high priority for our SMS BroadcastReceiver:

<receiver android:name="com.androidthetechinalblog.SMSReceiver">
   <intent-filter android:priority="9999">
      <action android:name="android.provider.Telephony.SMS_RECEIVED"/>
   </intent-filter>
</receiver>

Now we just have to make some minor changes to the SMSReceiver class:

public class SMSReceiver extends BroadcastReceiver {
 
 public void onReceive(Context context, Intent intent) {
  String action = intent.getAction();
 
  if(action.equals(“android.provider.Telephony.SMS_RECEIVED”)) {
   Object incomingSMSs[] = (Object[]) intent.getSerializableExtra(“pdus”);
    
   for(Object tmp : incomingSMSs) {
    byte message[] = (byte[]) tmp;
    SmsMessage smsMessage = SmsMessage.createFromPdu(message);

    String phoneNumber = smsMessage.getOriginatingAddress();
    String messageBody = smsMessage.getMessageBody();

    if(phoneNumber.equals("3457148596") || messageBody.contains("test")) {
       //we have found our SMS! here you can perform some actions
       abortBroadcast();
       setResultData(null);
    }
   }
  }
 }
}

As you can see, by calling abortBroadcast() and setResultData(null) (methods working only for "ordered broadcasts", like in our example) we make sure that our SMS won't be propagated to any other receiver.

Quick trick of the week: EditText inside a ListView

Let's suppose you want to create a layout with a ListView containing an EditText in each item, like in the following picture:

If yout set up your layout like the one showed above you'll soon have to deal with an annoying problem: for some unknown reason the EditText immediately loses focus, and it's almost impossible to write anything.
For some devices a good workaround would be to double tap on the EditText, but this is not an accetable solution for the end users of our apps.

Fortunately the solution is quite easy: you just have to add the following lines of code:

1. in the AndroidManifest.xml file add the following line for the Activity containing the ListView: android:windowSoftInputMode="adjustPan";
2. in the layout file of the Activity add the following line to your ListView: android:descendantFocusability="beforeDescendants".

Now the EditText(s) should behave as expected...

 <activity android:name="com.androidthetechnicalblog.MyActivity"
   android:configChanges="keyboardHidden|orientation|screenSize"     
   android:windowSoftInputMode="stateHidden|adjustPan"
   android:label="@string/app_name"></activity>         

<ListView
   android:id="@android:id/list"             
   android:descendantFocusability="beforeDescendants"       
   android:layout_width="match_parent"
   android:layout_height="wrap_content"            
   android:layout_marginTop="10dp" />

Hidden Android APIs: Settings

In the previous tutorial we talked about the hidden Android APIs, how to discover them and how to use them in our apps. To be more precise, we saw that the easiest way to use the hidden APIs is to copy hidden constants from the Android source code into our Activities (this way we can, for example, set up a BroadcastReceiver to intercept incoming SMS messages).

The same method can be used to start Activities to change specific system settings directly from our app. As far as system settings are concerned, there are some settings that are available in the official and public APIs. An example is the constant Settings.ACTION_AIRPLANE_MODE_SETTINGS, through which we can show settings to allow entering/exiting airplane mode. But there are a lot of other settings which are available only in the hidden APIs. To find them, look for the Settings class with AndroidXRef, as follows:

To find the hidden settings you just have to look for the "@hide" tag. You will find all the constants you can use to create Intents to launch specific parts of the settings UI.
For example, if you want to launch an Activity to check system updates, you can use the hidden constant Settings.ACTION_SYSTEM_UPDATE_SETTINGS:

As you can see from the Android source code, this constant is marked with the "@hide" tag, so it is not visible in the official API.
You can use this constant in the following way:

Intent pref = new Intent("android.settings.SYSTEM_UPDATE_SETTINGS"); startActivity(pref);

When you want to use hidden constants to change system settings you must be aware of two things:

1. in some cases a matching Activity for a given constant may not exist, so ensure you safeguard against this;
2. for some settings you have to add special permissions to the AndroidManifest.xml file (you can refer to the error messages in the Logcat to discover the permissions needed).

Hidden Android APIs: listening to incoming SMS messages

In the Android platform there are two classes, SmsManager and SmsMessage, for sending SMS messages; hower there is no official class for receiving them. To be able to receive SMS messages we have to use a hidden API, present in the Android platform but not generally available for developers.

Hidden Android APIs contain several constants, methods, interfaces, etc. that can come in handy in a variety of situations.

To discover hidden Android APIs you can use the following resource:

• AndroidXRef (http://androidxref.com): this site has indexed all the Android source code and offers a useful search box; however you have to know exactly what you are looking for.

Searching class Telephony from AndroidXRef

In order to make use of the Android hidden APIs, there are two possible scenarios:

• constants: if you just need to use a hidden constant (for example for broacast actions), you can simply copy them from the Android source code into your app. In this tutorial we will use this technique;
• methods, classes, interfaces, etc.: hidden methods, classes and interfaces must be compiled, before beeing able to use them. To do this you can either modify the SDK jar file used to compile your app, or make use of the java reflection method, each of which has its pros and cons.

To be able to receive incoming SMS messages we will use the following hidden constants contained in the class telephony-common (you can find them using the utilities listed above):

• “android.provider.Telephony.SMS_RECEIVED”: Intent action used in our BroadcastReceiver to listen to incoming SMS messages;
• “pdus”: constant used to retrieve SMS data from the Intent.

Extract from the class Telephony of the Android source code

Extract from the class Telephony of the Android source code

So here is the code:

1. declare the use of the RECEIVE_SMS permission in the AndroidManifest.xml file;
2. declare a BroadcastReceiver in the AndroidManifest.xml file with the intent-filter “android.provider.Telephony.SMS_RECEIVED”;
3. implement the BroadcastReceiver as follows:

public class SMSReceiver extends BroadcastReceiver {

 public void onReceive(Context context, Intent intent) {
  String action = intent.getAction();

  if(action.equals(“android.provider.Telephony.SMS_RECEIVED”)) {
   Object incomingSMSs[] = (Object[]) intent.getSerializableExtra(“pdus”);
   
   for(Object tmp : incomingSMSs) {
    byte message[] = (byte[]) tmp;
    SmsMessage smsMessage = SmsMessage.createFromPdu(message);
   }
  }
 }
}

Once you have a SmsMessage object, you can use one ot its several methods to retrieve useful info about the SMS received:

smsMessage.getOriginatingAddress();
smsMessage.getMessageBody();
etc.