{"id":1700,"date":"2013-09-22T15:15:59","date_gmt":"2013-09-22T03:15:59","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=1700"},"modified":"2013-09-22T15:15:59","modified_gmt":"2013-09-22T03:15:59","slug":"honourable-intentions","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/1700\/","title":{"rendered":"Honourable Intentions"},"content":{"rendered":"[Estimated Reading Time: <\/span> 10<\/span> minutes]<\/span><\/span>

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 the way, we will add a new capability.<\/p>\n

<\/p>\n

Models of Re-Use<\/h3>\n

A lot of the code written so far could easily be put into a library to be called much more conveniently in the future, and that might be a good idea if we intended writing lots of camera apps.<\/p>\n

But why would we want to do that ?<\/p>\n

I suppose we might have another app in the future where we also needed to be able to capture pictures from the camera. But what if the user of our camera app really, really likes using our app to capture their photos ? We wouldn’t want to duplicate the entire app every time.<\/p>\n

Android has a feature designed specifically to allow an application to provide services directly to other applications that wish to take advantage. I am sure you can think of any number of applications that include the ability to take a photo from the device camera. The Google+<\/strong> app is one.<\/p>\n

NOTE:<\/strong> The FaceBook<\/strong> Android app does not<\/strong> appear to use intents. When you post a photo from the FaceBook<\/strong> app it uses an internal camera function, ignoring any<\/strong> camera apps on your device.<\/em><\/p>\n

In the Google+<\/strong> app a user can directly share a new photo by selecting “Photo<\/strong>” from the main app screen:<\/p>\n

\"Post<\/a>
Post a photo from Google+<\/figcaption><\/figure>\n

This then presents the Google+<\/strong> image gallery, and in the top right is an action bar button to capture a new image from the camera:<\/p>\n

\"Capture<\/a>
Capture new photo with camera…<\/figcaption><\/figure>\n

Selecting this takes us to the camera app on the device:<\/p>\n

\"The<\/a>
The default camera app… pfft. We can do better than that!<\/figcaption><\/figure>\n

But I really, really<\/em> like my<\/strong> app. It’s soooo<\/em> much better than the default camera app. *cough*<\/em>. I’d like to be able to use my<\/strong> app to take the picture, even when using the Google+<\/strong> app (which of course knows nothing about my app).<\/p>\n

Fortunately Android<\/strong> supports this through a system called Intents<\/strong>.<\/p>\n

State Your Intentions<\/h3>\n

An application can invoke a service by stating that it requires a particular intent to be satisfied. Other applications can indicate the intents that they are capable of satisfying in their manifest.<\/p>\n

When an application makes an intent request, the system checks to see what applications are available. If there is only<\/strong> one then this will be called into action. If there is more<\/strong> than one, then the user is asked which they would prefer to use.<\/p>\n

If there are none<\/strong>, then the application making the request has to have some fall-back position and either tell the user they need to acquire a suitable app or provide at least a basic facility to meet the need itself.<\/p>\n

I won’t be asking for intents in my camera app, but I will be satisfying<\/strong> an intent.<\/p>\n

Intents have names, and in this case the intent is android.media.action.IMAGE_CAPTURE<\/strong>.<\/p>\n

The first step is to add an entry to the application manifest so that the system knows our application can satisfy this intent. This is called an Intent Filter<\/strong>. We add the intent-filter entry to the Activity that we intend to be invoked to satisfy the intent upon request. In our simple app, this is the MainActivity<\/strong>:<\/p>\n

\r\n  <activity android:label="@string\/app_name" android:name="nz.co.deltics.demo.camera.MainActivity">\r\n   <intent-filter>\r\n    <action android:name="android.intent.action.MAIN" \/>\r\n    <category android:name="android.intent.category.LAUNCHER" \/>\r\n   <\/intent-filter>\r\n   <intent-filter>\r\n    <action android:name="android.media.action.IMAGE_CAPTURE" \/>\r\n    <category android:name="android.intent.category.DEFAULT" \/>\r\n   <\/intent-filter>\r\n  <\/activity>\r\n<\/pre>\n
Suddenly the existing intent-filter entry that we perhaps took for granted makes a bit more sense.  android.intent.action.MAIN<\/strong> identifies MainActivity<\/strong> as the activity in our application that is our application’s MAIN<\/strong>, or Home screen, to be used when launching the app.<\/p>\n
Now we have identified that this same Activity is to be used when we respond to a request to capture an image.<\/p>\n
If our application was more complex, we might have a different Activity<\/strong> for image capture, in addition to and separate from our MainActivity<\/strong>.  The system will know that when it launches our application to take a picture it should launch directly into the image capture activity instead of our app “Home<\/em>” screen.<\/p>\n
With this declaration in our manifest (and my application installed on the device, obviously) when I select the “Take a Photo” action in Google+, my app is now presented as an option:<\/p>\n
\"Choose<\/a>
Choose your weapon<\/del> app !<\/figcaption><\/figure>\n
At this point if I select my app it will launch as normal and I can use it to take a photo, but Google+<\/strong> won’t know anything about it when I do.<\/p>\n
I need to make some changes to my app to make it co-operate with the intents system.<\/p>\n
Just What Is<\/strong> Your Intention ?<\/h3>\n
The first step is identifying the intent with which our app was launched.  If you have no specific filters other than the ability to be launched, you can probably just assume this is the intent.  But my app now has two possible reasons to be launched.  Two intents.<\/p>\n
Most of the functionality of my app is the same, regardless of the intent.  But there we will need to adapt some of the behaviour if launched with the IMAGE_CAPTURE<\/strong> intent, so we need to be able to identify that.<\/p>\n
To test for a specific intent action we can simply write:<\/p>\n
\r\n  if Intent.Action = MediaStore.ACTION_IMAGE_CAPTURE then\r\n<\/pre>\n
This is another example of Oxygene<\/strong> presenting a “getter<\/em>” method as a property, in this case “Intent<\/strong>” which actually corresponds to the getIntent()<\/strong> method that our MainActivity<\/strong> inherits from the Activity<\/strong> class.<\/p>\n
NOTE:<\/strong> The MediaStore<\/strong> class is in the android.provider namespace so this was added to the uses list of the unit.  I think I may have forgotten to mention some of the required namespaces that I have introduced along the way.  Apologies for that if you’ve been trying to follow along.<\/em><\/p>\n
The MediaStore.ACTION_IMAGE_CAPTURE<\/strong> constant took a bit of tracking down.  Many action identifiers are constants of the Intent<\/strong> class<\/a>, but since Intent<\/strong> actions can be introduced and defined as needed, these are not an exhaustive list.<\/p>\n
This does mean however that if we devised some entirely new application service that other applications might find useful that is not already defined by the Android<\/strong> system, we can filter for our own action and simply document the action name that other applications developers should use if they wish to use that intent.<\/p>\n
Satisfying An Intent<\/h3>\n
When responding to a particular intent it isn’t very useful if you are not doing what the intent, um, intends.  Sometimes this is implicit in the action itself, but in other cases an action may be accompanied by additional data that an application is expected to take into account when responding.  When provided, this additional data is supplied in an Extras<\/strong> object, as part of the Intent<\/strong>.<\/p>\n
This should be described as part of the documentation for the intent action itself.  In the case of the MediaStore.ACTION_IMAGE_CAPTURE<\/strong><\/a> action there is an optional EXTRA_OUTPUT<\/strong> item that may or may not be supplied.  This means we have to allow for two possibilities:<\/p>\n