{"id":1791,"date":"2013-09-30T19:11:15","date_gmt":"2013-09-30T07:11:15","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=1791"},"modified":"2013-09-30T19:22:28","modified_gmt":"2013-09-30T07:22:28","slug":"developing-and-debugging-an-appwidget-part-2","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/1791\/","title":{"rendered":"Developing and Debugging an AppWidget – Part 2"},"content":{"rendered":"[Estimated Reading Time: <\/span> 9<\/span> minutes]<\/span><\/span>

In the first instalment of this series<\/a>, I implemented the basic framework of a new appwidget and established a means by which I could debug the widget code. Now it’s time to add some code worth debugging.<\/p>\n

<\/p>\n

You may recall that the aim of my widget is to display the battery charge level so the first order of business is to figure out how to read the battery level.<\/p>\n

It turns out that the means by which we obtain this information involves Intents<\/strong>. On this occasion however, we shall be working with something called a “sticky intent”.<\/p>\n

Sticky Intents<\/h3>\n

The normal procedure when consuming intents – as far as my current understanding goes – is to create or declare an intent filter that will match the required intent. You then declare a receiver and wait for the expected notification to arrive at that receiver, together with the corresponding Intent<\/strong> object containing all the information necessary for the receiver to respond (or simply behave) appropriately.<\/p>\n

A sticky intent<\/strong> does not require you to register a receiver however. At least, not a real one.<\/p>\n

You simply setup the IntentFilter<\/strong> that will match the intent involved and register a null<\/strong> receiver. You then immediately<\/em> are returned a reference to the sticky intent.<\/p>\n

Information about the device battery is one such sticky intent, and the corresponding action is ACTION_BATTERY_CHANGED<\/strong>. So, let us first make sure we can get the required battery information, then we’ll worry about how to update the widget UI with that information.<\/p>\n

This code in the widget onUpdate<\/strong> method should do the trick:<\/p>\n

\r\n  method BatteryWidgetProvider.onUpdate(aContext: Context; \r\n                                        aWidgetManager: AppWidgetManager;\r\n                                        aIDs: array of Integer);\r\n  var\r\n    filter: IntentFilter;\r\n    battery: Intent;\r\n    level, scale: Integer;\r\n    pct: Float;\r\n  begin\r\n    filter  := new IntentFilter(Intent.ACTION_BATTERY_CHANGED);\r\n    battery := aContext.registerReceiver(NIL, filter);\r\n\r\n    level := battery.IntExtra[BatteryManager.EXTRA_LEVEL, -1];\r\n    scale := battery.IntExtra[BatteryManager.EXTRA_SCALE, -1];\r\n\r\n    pct := (100 * level) \/ scale;\r\n  end;\r\n<\/pre>\n
We create a new IntentFilter<\/strong> object for the standard ACTION_BATTERY_CHANGED<\/strong> action.  We then call registerReceiver<\/strong> on our context, passing a NIL<\/strong> reference for the receiver and the filter we just created and we get back the sticky intent holding the current battery state.<\/p>\n
From the battery Intent<\/strong> we can now extract the information we need which in this case is two values:  the battery level and the maximum<\/em> battery level.  Somewhat confusingly this second value is called the scale.<\/p>\n
These two pieces of information are contained within the Extras<\/strong> Bundle of the sticky intent.  Each is an integer value whose names are among several defined as constants by the BatteryManager<\/strong> class, and there are a number of ways of extracting them.<\/p>\n
Incidentally, the BatteryManager<\/strong> class resides in the android.os<\/strong> namespace, so this is added to the uses list of the unit containing BatteryWidgetProvider<\/strong>.<\/p>\n
When implementing Intent<\/strong> support in my camera app, I used methods of the Extras<\/strong> Bundle itself, but on this occasion I am taking advantage of the fact that the Intent<\/strong> object itself provides methods for reading such values and in this case I have the option of using methods which allow me to supply a default value if the value I ask for does not actually exist.<\/p>\n
The Java method is <strong>getIntExtra<\/strong>( <em>name<\/em>, <em>defaultValue<\/em> )<\/code> but as you can see, I am using the fact that Oxygene presents such methods as properties with accessor indices.<\/p>\n
So, with the battery level (BatteryManager.EXTRA_LEVEL<\/strong>) and the maximum battery level (BatteryManager.EXTRA_SCALE<\/strong>) calculating the percentage battery level is a simple matter of some basic arithmetic.<\/p>\n
Trying to run this widget throws up a problem, in the form of a runtime exception caught and presented to us by the debugger:<\/p>\n
\"Android<\/a>
Android says “No!”<\/figcaption><\/figure>\n
I should confess that from the little bit of research I did before setting about implementing this widget, I already knew this would happen but wanted to show you the consequences.<\/em><\/p>\n
Now, I could not find any reference to “IntentReceiver<\/strong>” in the Android SDK and searching for it throws up only BroadcastReceiver<\/strong>.  There are some docs on the interwebs which appear to document a very early Android SDK with an IIntentReceiver<\/strong> interface<\/em> and I wonder if this exception message is just perhaps a little out of date and should now say BroadcastReceiver<\/strong>.<\/p>\n
In any event, our AppWidgetProvider<\/strong> is a BroadcastReceiver<\/strong> and does indeed receive intents, so whatever this IntentReceiver<\/strong> actually refers to, it does seem to apply to my situation.<\/p>\n
So far our widget app contains one component – the AppWidgetProvider for our widget.<\/p>\n
For debug builds it contains a second component – my DebugActivity.<\/p>\n
But both of these declare an intent-filter<\/strong> and are thus both receivers of intents.  Any call made using the Context<\/a> of either of these components to registerReceiver<\/strong> is going to fail for the same reason.<\/p>\n
What we need is some other component that can be invoked directly without having to respond to an intent, and which has a Context<\/a> which can be used to call registerReceiver<\/strong> for the sticky intent required to get the battery information.<\/p>\n
Fortunately, there is just such a component type available:  A Service<\/a><\/strong>.<\/p>\n
Android, At Your Service<\/h3>\n
A Service<\/strong> can – and often does – support one or more intent filters, but a service does not have<\/em> to and if it does not it can still be invoked directly by name if required.  This is exactly what we shall do in this case.<\/p>\n
First of all, we add a new class to the project, extending the Service class.  I called mine UpdateService<\/strong>.<\/p>\n
\r\ninterface\r\n\r\n  uses\r\n    android.app,\r\n    android.content,\r\n    android.widget;\r\n\r\n  type\r\n    UpdateService = public class(Service)\r\n    public\r\n      method onBind(aIntent: Intent): IBinder; override;\r\n      method onStart(aIntent: Intent; aStartID: Integer); override;\r\n    end;\r\n<\/pre>\n
I am only scratching the surface of Android Services here.  Mine is a very simple service which will obtain the information required to update our widget, do the update and then … well, I’m not entirely sure.  The service may simply die at that point, or it may sit around doing nothing until the OS kills it or it is invoked again.  I’m not entirely sure, but I don’t think it really matters.<\/p>\n
This service doesn’t need to worry about binding, but we do have to override the onBind<\/strong> method since it is abstract<\/em> in the Service<\/strong> class.  For our purposes we simply return NIL<\/strong> from this method.<\/p>\n
The onStart<\/strong> override is where this service takes care of everything, and we will look at that shortly.  But first, with this Service<\/strong> looking after the actual business of performing the update, our widget onUpdate<\/strong> code then becomes a simple call to invoke this service:<\/p>\n
\r\n  method BatteryWidgetProvider.onUpdate(aContext: Context; \r\n                                        aWidgetManager: AppWidgetManager;\r\n                                        aIDs: array of Integer);\r\n  var\r\n    updateIntent: Intent;\r\n  begin\r\n    updateIntent := new Intent(aContext, typeof(UpdateService));\r\n    updateIntent.putExtra('ids', aIDs);\r\n\r\n    aContext.startService(updateIntent);\r\n  end;\r\n<\/pre>\n
To invoke a service by name we create an Intent<\/strong> using a constructor identifying the calling context and a reference to the service class to be invoked.  In Java this class reference would be obtained using what appears to be a static member of the Class<\/strong> type (Class.class<\/code>) but which is in fact a bit of Java compiler magic.  In Oxygene the equivalent magic is the typeof()<\/strong> function.<\/p>\n
With our freshly constructed Intent<\/strong>, we can then add whatever information that service may require passed to it via that Intent<\/strong>.  In this case we provide the array of Widget ID’s being updated (the user might have placed multiple instances of our widget on their device and each has a unique ID).<\/p>\n
The Intent.putExtra<\/strong> method is a massively overloaded method (24 varieties!) which supports putting a huge variety of types of information – in this case an array of Integer – as named values into the Intent Extras Bundle.<\/p>\n
Once the intent is ready, we then pass it to the startService<\/strong> method of the context.<\/p>\n
We now have a widget provider that will invoke a service to update any widget instances when required.  So now let’s complete the update service itself.<\/p>\n
Adding Updatability to the Update Service<\/h3>\n
First of all, for a service to update a widget is really quite trivial.  As mentioned in part 1<\/a>, widgets are updated by providing an updated layout representing the state of the widget at a point in time.<\/p>\n
The “snapshot” is presented to the widget in the form of a new RemoteViews object containing the complete, updated layout to be applied to the widgets being updated.  So, the UpdateService.onStart<\/strong> method is quite simple:<\/p>\n
\r\n  method UpdateService.onStart(aIntent: Intent; aStartID: Integer);\r\n  var\r\n    update: RemoteViews;\r\n    ids: array of Integer;\r\n  begin\r\n    update := buildUpdate(self);\r\n\r\n    ids := aIntent.Extras.IntArray['ids'];\r\n    AppWidgetManager.Instance[self].updateAppWidget(ids, update);\r\n  end;\r\n<\/pre>\n
We declare a RemoteViews<\/strong> object.  We will build this in a new method – to be called buildUpdate<\/strong> – accepting a reference to the current context (the service itself, i.e. self<\/strong>).  We will add this method next, but first a quick look at how the service updates the widgets with the new RemoteViews<\/strong>.<\/p>\n
First I extract the array of widget ID’s identifying the widget instances to be updated, from the Extras<\/strong> bundle of the Intent<\/strong> that started the service (remember, this array of ID’s was placed there by the widget provider when it invoked the service in the onUpdate<\/strong> provider method).<\/p>\n
I then obtain the appropriate instance of AppWidgetManager<\/strong> for the current context, conveniently provided for me in the AppWidgetManager<\/strong> class Instance<\/strong> indexed property (surprise, surprise: in Java it would be getInstance(self)<\/code>).<\/p>\n
The AppWidgetManager.updateAppWidget<\/strong> method has a number of overloads for updating widgets by different identifying criteria.  In this case I can use the method that accepts an explicit array of widget ID’s.<\/p>\n
All that is left now is to implement the buildUpdate<\/strong> method to actually construct the updated widget UI.<\/p>\n
Building the Update<\/h3>\n
We have already seen how to obtain the current battery level so we can put that code in our buildUpdate()<\/strong> method for starters:<\/p>\n
\r\n  method UpdateService.buildUpdate(const aContext: Context): RemoteViews;\r\n  var\r\n    filter: IntentFilter;\r\n    battery: Intent;\r\n    level, scale: Integer;\r\n    pct: Float;\r\n  begin\r\n    filter  := new IntentFilter(Intent.ACTION_BATTERY_CHANGED);\r\n    battery := aContext.registerReceiver(NIL, filter);\r\n\r\n    level := battery.IntExtra[BatteryManager.EXTRA_LEVEL, -1];\r\n    scale := battery.IntExtra[BatteryManager.EXTRA_SCALE, -1];\r\n\r\n    pct := (100 * level) \/ scale;\r\n  end;\r\n<\/pre>\n
Now all that’s required to is construct the RemoteViews<\/strong> object and update the layout with the battery information:<\/p>\n
\r\n  method UpdateService.buildUpdate(const aContext: Context): RemoteViews;\r\n  var\r\n    filter: IntentFilter;\r\n    battery: Intent;\r\n    level, scale, pct: Integer;\r\n  begin\r\n    filter  := new IntentFilter(Intent.ACTION_BATTERY_CHANGED);\r\n    battery := aContext.registerReceiver(NIL, filter);\r\n\r\n    level := battery.IntExtra[BatteryManager.EXTRA_LEVEL, -1];\r\n    scale := battery.IntExtra[BatteryManager.EXTRA_SCALE, -1];\r\n\r\n    pct := (100 * level) div scale;\r\n\r\n    \/\/ Build a remote view to update the widget UI\r\n\r\n    result := new RemoteViews(aContext.PackageName, R.layout.widgetlayout);\r\n    result.setTextViewText(R.id.lblInfo, pct.toString + '%');\r\n  end;\r\n<\/pre>\n
With such a simple layout for the widget UI, building the updated RemoteViews<\/strong> object is itself also very simple.<\/p>\n
First we construct a RemoteViews<\/strong> object, employing a constructor that identifies the layout resource that we wish to use.<\/p>\n
Again, we see a construct that would be familiar to an Eclipse<\/strong> or Android Studio<\/strong> Java developer.  The res<\/strong> folder in our project is represented in our application by the R<\/strong> object, the layout<\/strong> folder by the R.layout<\/strong> member, and the layout resources (files) as the members of that folder.<\/p>\n
We don’t have to use the same layout that we used for the initial layout of the widget.  In a more sophisticated widget we might use various layouts according to runtime conditions, but in this case we only need to make one small change to the layout we already declared, which is to change the Text<\/strong> attribute of the TextView<\/strong> to the battery level that we wish to display.<\/p>\n
A number of methods are provided by the RemoteViews<\/strong> object for manipulating the views within it.  In this case we are setting the Text<\/strong> property of a TextView<\/strong>.<\/p>\n
We identify the TextView<\/strong> in question by reference to the @id+<\/code> id we assigned in the layout – lblInfo<\/strong>.  Again, just as with the resources, these ID’s are created as members of the R<\/strong> object, this time as members of the R.id<\/strong> member.<\/p>\n
I should explain that I’m not interested in anything more accurate than whole percentage points, and, on my device at least, the battery level is not reported to any greater level of accuracy anyway (0-100 only), which may be the case on all devices for all I know.  So in this final version I’ve tweaked the variables and the expression for calculating the pct<\/strong> value to use integer division.  <\/p>\n
The text value we are setting it the string representation of the battery level percentage, with a ‘%’ sign appended.<\/p>\n
We return this new RemoteViews<\/strong> object to where the buildUpdate<\/strong> method was called – the onStart<\/strong> method of our service – which in turn passes it to the AppWidgetManager<\/strong> which will apply it to our widget UI.<\/p>\n
Almost done.<\/p>\n
Just one little tweak is needed in the layout to ensure that the text of our widget is visible on both light and dark backgrounds, which is to add a drop-shadow effect by adding the following attributes to the TextView<\/strong> in the widgetlayout<\/strong>:<\/p>\n
\r\n    android:textColor="@android:color\/white"\r\n    android:shadowColor="@android:color\/black"\r\n    android:shadowDx="2"\r\n    android:shadowDy="2"\r\n    android:shadowRadius="2"\r\n<\/pre>\n
\"Night-time...\"<\/a>
Night-time…<\/figcaption><\/figure>\n
\"DAYTIME!\"<\/a>
DAYTIME!<\/figcaption><\/figure>\n
There we go.<\/p>\n
Not perfect but, as with much else with these exercises, it will do for now.  \ud83d\ude42<\/p>\n
For those of a curious disposition, here’s the full source for you to play around with:<\/p>\n
\r\n
\"\"  Demo Widget for Android<\/a><\/strong> (38.5 KiB, 578 hits)<\/p>\r\n
Implements a simple battery level monitor home screen widget for Android.<\/div>\r\n<\/div>\n
In a real widget I might instead choose to provide the user with some control over the appearance of the widget so that they can adjust it to suit their particular preferences and device wallpaper etc.<\/p>\n
I should also implement much more sophisticated battery management.  Since my widget really should only update if the device is already awake, I should listen for notifications from the system telling me when the device enters and leaves sleep state, and use an alarm based update to only update when already awake.<\/p>\n
Since I intend using this widget myself, I will be turning my attention to that at some point, but for now, this short series has hopefully added a little more to your knowledge of Android development with Oxygene, as the experience of putting it together has for me.<\/p>\n","protected":false},"excerpt":{"rendered":"
[Estimated Reading Time: <\/span> 9<\/span> minutes]<\/span><\/span> In the first instalment of this series, I implemented the basic framework of a new appwidget and established a means by which I could debug the widget code. Now it’s time to add some code worth debugging.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":[]},"categories":[212,4,180],"tags":[153,224,215,181,223],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_shortlink":"https:\/\/wp.me\/p1TKYv-sT","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":1873,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1873\/","url_meta":{"origin":1791,"position":0},"title":"Developing an AppWidget – Part 5","date":"13 Oct 2013","format":false,"excerpt":"In my previous post I explained how I believed I had solved a problem with my widget, only to discover that it created a different problem in the process. I had believed that IntentService based services were long-lived, but in fact this is not the case. However, the change remains\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1774,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1774\/","url_meta":{"origin":1791,"position":1},"title":"Developing and Debugging an AppWidget – Part 1","date":"29 Sep 2013","format":false,"excerpt":"With my external HDD trials and tribulations behind me, I have finally been able to complete a project I started last weekend - implementing an Android AppWidget. Along the way I have learned some more about both Android and Oxygene and what can be involved with working with the two\u2026","rel":"","context":"In "Android"","img":{"alt_text":"Adding the xml folder","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/Screen-Shot-2013-09-29-at-15.08.09-.png?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":1855,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1855\/","url_meta":{"origin":1791,"position":2},"title":"Developing an AppWidget – Part 3","date":"08 Oct 2013","format":false,"excerpt":"Well Behaved Widgetry When we left it, my battery widget was working but wasn't particularly well behaved. There was nothing much wrong with the functionality, but plenty wrong with the implementation. Despite their impressive specifications, mobile devices have one very limiting factor. Battery Life. Indeed, the impressive specifications are part\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1869,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1869\/","url_meta":{"origin":1791,"position":3},"title":"Developing an AppWidget – Part 4","date":"10 Oct 2013","format":false,"excerpt":"Keep On Running... Some may have noticed that I updated my previous post with a footnote describing an issue with my battery widget not resuming it's updates after the phone went into (and came out of) deep sleep. I got to the bottom of that and can now happily report\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1817,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1817\/","url_meta":{"origin":1791,"position":4},"title":"Getting the Battery Level on Android With Delphi","date":"01 Oct 2013","format":false,"excerpt":"Over the past few days I posted a two part series showing how to obtain the current battery level as part of the implementation of an Android AppWidget using Oxygene. As far as I can tell AppWidgets simply aren't possible using Delphi but reading the battery is quite straightforward Android\u2026","rel":"","context":"In "Android"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":1700,"url":"https:\/\/www.deltics.co.nz\/blog\/posts\/1700\/","url_meta":{"origin":1791,"position":5},"title":"Honourable Intentions","date":"22 Sep 2013","format":false,"excerpt":"This is it. The home straight. The final part of my series on writing a camera app using Oxygene for Android. In this concluding part I shall look at making my application a well behaved Android citizen. As well as pointing out (and fixing) some mistakes I have made along\u2026","rel":"","context":"In "Android"","img":{"alt_text":"Post a photo from Google+","src":"https:\/\/i0.wp.com\/www.deltics.co.nz\/blog\/wp-content\/uploads\/Google+-Main-1024x640.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1791"}],"collection":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/comments?post=1791"}],"version-history":[{"count":12,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1791\/revisions"}],"predecessor-version":[{"id":1809,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/posts\/1791\/revisions\/1809"}],"wp:attachment":[{"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/media?parent=1791"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/categories?post=1791"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.deltics.co.nz\/blog\/wp-json\/wp\/v2\/tags?post=1791"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}