Using the AlarmManager for updating Android Widgets

I see people asking repeatedly about how to update an Android widget more often than the restricted 30 minute interval that is enforced by the OS. Before we begin, I just want to point out and make one thing very clear: unless you have absolute reason to do so, you shouldn't be asking your widget to update more frequently than this. There probably isn't need to, to be honest. Once an hour will suffice for most people, such as if it's a weather app or checking feeds or something else that can't be made to receive broadcast or push notifications. The two main reasons behind this are as follows:

1. It will reduce the battery life of the phone.

2. Handled badly and your widget could end up making the phone completely unresponsive. Pushing updates to onscreen widgets is a somewhat costly process.

Now that you've read and understood the implications, let's move onto how to use an AlarmManager. Normally, when setting up an AppWidget, you will supply the update interval in milliseconds (as updateTimeMillis). There are two disadvantages to this. The first, as pointed out, is the minimum of 30 minutes (you'll see no warning about this if you lower it, by the way). The second, less obvious one, is that the time isn't predictable. That is to say, if you wanted to widget to always update once an hour, on the hour, it's near-impossible. Likewise, if you wanted to widget to update at 0, 15, 30 and 45 minutes past each hour, you can't do that, either.

Here's how we're going to solve this problem (note: this tutorial assumes that you already have knowledge of app widgets and services).

public class MyWidget extends AppWidgetProvider
{
    private PendingIntent service = null;

    @Override
    public void onUpdate(Context context, AppWidgetManager appWidgetManager, int[] appWidgetIds)
    {
        final AlarmManager m = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);

        final Calendar TIME = Calendar.getInstance();
        TIME.set(Calendar.MINUTE, 0);
        TIME.set(Calendar.SECOND, 0);
        TIME.set(Calendar.MILLISECOND, 0);

        final Intent i = new Intent(context, MyService.class);

        if (service == null)
        {
            service = PendingIntent.getService(context, 0, i, PendingIntent.FLAG_CANCEL_CURRENT);
        }

        m.setRepeating(AlarmManager.RTC, TIME.getTime().getTime(), 1000 * 60, service);
    }

    @Override
    public void onDisabled(Context context)
    {
        final AlarmManager m = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);

        m.cancel(service);
    }
}

and a cut down service example. The service is where we perform our logic and update the AppWidget.

public class MyService extends Service
{
    @Override
    public void onCreate()
    {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId)
    {
        buildUpdate();

        return super.onStartCommand(intent, flags, startId);
    }

    private void buildUpdate()
    {
        String lastUpdated = DateFormat.format("MMMM dd, yyyy h:mmaa", new Date()).toString();

        RemoteViews view = new RemoteViews(getPackageName(), R.layout.widget);

        view.setTextViewText(R.id.lastUpdated, lastUpdated);

        // Push update for this widget to the home screen
        ComponentName thisWidget = new ComponentName(this, MyWidget.class);
        AppWidgetManager manager = AppWidgetManager.getInstance(this);
        manager.updateAppWidget(thisWidget, view);
    }

    @Override
    public IBinder onBind(Intent intent)
    {
        return null;
    }
}

(note: you should think carefully before making your service START_STICKY, as this means the service should be explicitly stopped. Since we're running a one off procedure, we want to have this hanging around as little as possible. Don't be tempted to use a BroadcastReceiver here, as these are designed for very fast operations. Anything taking more than about 10 seconds will be seen as misbehaving by the Android OS and might be killed off)

Our Alarm is set up in the widget's onUpdate method. It shouldn't look that much different to how a standard AppWidget call to a service looks, except for that we're scheduling the alarm to do the work. Note that we're telling the widget to repeat the call once a minute. This is fine for our example, since you don't want to sit around for 15 minutes to see the results. However, in real life you will want it to do so less frequently.

We're also telling the alarm to kick off immediately. If we want it to kick off at an exact time, we'll need to create it. The simplest way is with the calendar:

Calendar TIME = Calendar.getInstance();
TIME.set(Calendar.MINUTE, 0);
TIME.set(Calendar.SECOND, 0);
TIME.set(Calendar.MILLISECOND, 0);

m.setRepeating(AlarmManager.RTC, TIME.getTime().getTime(), AlarmManager.INTERVAL_HOUR, service);

The above will kick off the service once an hour, on the hour. You'll notice that the widget is updated immediately, which is normal. It does this because it "missed" it's previous alarm of the last hour. It'll then sit quietly until the next update is due.

If you want the alarm to issue more frequently then you'll need to adjust the intervalPeriod.

Finally, we come to an important step: how to stop the alarm! You'll notice that in our class we have declared:

private PendingIntent service = null;

which is set up later in the onUpdate (if it's not null). We need to keep hold of this so that we can cancel the alarm later! We do so in the onDisable() method which will be triggered when all widgets are removed from the screen. We pass the PendingIntent to the cancel method of the AlarmManager so that it can determine which alarm it must cancel.

And there you have it. Pretty straight forward, really. If you have already created an AppWidget that calls a service, then you'll find you need only add in a handful of lines of code to have to AppWidget update more frequently, or at a more predictable interval.