{"id":1658,"date":"2013-09-19T23:06:17","date_gmt":"2013-09-19T11:06:17","guid":{"rendered":"https:\/\/www.deltics.co.nz\/blog\/?p=1658"},"modified":"2013-09-19T23:06:17","modified_gmt":"2013-09-19T11:06:17","slug":"crash-bang-wallop-what-a-picture","status":"publish","type":"post","link":"https:\/\/www.deltics.co.nz\/blog\/posts\/1658\/","title":{"rendered":"Crash Bang Wallop, What a Picture!"},"content":{"rendered":"[Estimated Reading Time: <\/span> 6<\/span> minutes]<\/span><\/span>

The fourth and final<\/del> part in the not-as-short-as-I-thought-it-would be series on building a camera app for Android<\/strong> using Oxygene<\/strong>. In this penultimate instalment we will add the capability to actually take a picture. But that won’t take very long, so then we will spend a bit of time tidying up the application UI.<\/p>\n

<\/p>\n

Taking A Picture<\/h3>\n

Taking a picture on Android<\/strong> is actually very straightforward. Once you have a reference to the Camera<\/strong> object (which we already have) it is a simple matter of calling the takePicture()<\/strong> method. This method requires a reference to an implementation of the Camera.PictureCallback<\/strong> interface.<\/p>\n

This is a simple interface which I chose to implement on the MainActivity<\/strong> itself, resulting in this new version of the MainActivity<\/strong> class:<\/p>\n

\r\n    MainActivity = public class(Activity, Camera.PictureCallback)\r\n    private\r\n      mCamera: Camera;\r\n      mViewFinder: ViewFinder;\r\n    public\r\n      method onCreate(savedInstanceState: Bundle); override;\r\n      method onDestroy; override;\r\n      method CaptureClick(v: View);\r\n\r\n    private \/\/ Camera.PictureCallback\r\n      method onPictureTaken(aPicture: array of SByte; aCamera: Camera);\r\n    end;\r\n<\/pre>\n
The code we need to add to the CaptureClick<\/strong> method is trivial:<\/p>\n
\r\n  method MainActivity.CaptureClick(v: View);\r\n  begin\r\n    \/\/ Stop the preview while we take the picture\r\n\r\n    mViewFinder.stop;\r\n\r\n    mCamera.takePicture(NIL, NIL, self);\r\n  end;\r\n<\/pre>\n
This call triggers an asynchronous image capture from the camera.  The three parameters to the method in this call are references to callbacks called at different points in the image capture process.<\/p>\n
The first is a Camera.ShutterCallback<\/strong> – this is a simple notification that the shutter has fired and a picture taken.  I could use this to play a sound for the user’s benefit, for example.<\/p>\n
The second is a Camera.PictureCallback<\/strong> – this is called when the RAW image data is ready.  I could use this if I wished to capture the RAW image data.<\/p>\n
The third is also a Camera.PictureCallback<\/strong> and is called then the JPEG image data is ready.  This is the only notification I am interested in for this app, which is why the first two callbacks are specified as NIL.<\/p>\n
Of course, I also need to implement that JPEG callback – my onPictureTaken<\/strong> implementation:<\/p>\n
\r\n  method MainActivity.onPictureTaken(aPicture: array of SByte; aCamera: Camera);\r\n  var\r\n    timestamp: String;\r\n    dir: File;\r\n    jpegFile: File;\r\n    stream: FileOutputStream;\r\n  begin\r\n    \/\/ Get a string containing formatted datetime as the basis for a unique filename\r\n\r\n    timestamp := new SimpleDateFormat('yyyyMMdd_HHmmss').format(new Date());\r\n\r\n    \/\/ Obtain the location of the pictures storage directory and compose a file\r\n\r\n    dir      := Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);\r\n    jpegFile := new File(dir.Path + File.separator + 'IMG_' + timestamp + '.jpg');\r\n\r\n    \/\/ If we have a valid File, open an output stream and write the aPicture data to it\r\n\r\n    if assigned(jpegFile) then\r\n    begin\r\n      stream := new FileOutputStream(jpegFile);\r\n      stream.write(aPicture);\r\n      stream.close;\r\n    end;\r\n\r\n    \/\/ Restart the viewfinder preview\r\n\r\n    mViewFinder.start;\r\n  end;\r\n<\/pre>\n
You may have noticed the calls to start()<\/strong> and stop()<\/strong> the viewfinder.  These were the result of a simple (manual) refactoring of the existing ViewFinder<\/strong> code previously contained in the onSurfaceCreated<\/strong> and onSurfaceDestroyed<\/strong> methods.<\/p>\n
One more finesse and we’re almost done.<\/p>\n
Maintaining (or rather Ob<\/strong>taining) Focus<\/h3>\n
I thought it would be cute to add a “touch to autofocus” feature.  Nothing fancy, just tap the preview to trigger the camera to autofocus.<\/p>\n
This will be handled by the ViewFinder<\/strong> class, so we add the View.OnTouchListener<\/strong> interface to the list of implemented interfaces and the corresponding onTouch<\/strong> method to the declaration of that class:<\/p>\n
\r\n    ViewFinder = public class(SurfaceView, SurfaceHolder.Callback,\r\n                                           View.OnTouchListener)\r\n      \/\/ ...\r\n\r\n    private \/\/ View.OnTouchListener\r\n      method onTouch(aView: View; aEvent: MotionEvent): Boolean;\r\n\r\n      \/\/ ...\r\n    end;\r\n<\/pre>\n
In the existing constructor we add the simple assignment of the ViewFinder<\/strong> as it’s own listener for touch events:<\/p>\n
\r\n    OnTouchListener := self;\r\n<\/pre>\n
And finally of course, implement the onTouch<\/strong> method itself:<\/p>\n
\r\n  method ViewFinder.onTouch(aView: View; aEvent: MotionEvent): Boolean;\r\n  begin\r\n    mCamera.autoFocus(NIL);\r\n  end;\r\n<\/pre>\n
autoFocus<\/strong> is another example of an asynchronous method that will notify a callback when the operation is complete, in this case indicating whether focus was successful or not via parameters passed to the call back.  Again, we could use this to provide some audio feedback or perform other processing with a focussed preview image.  But I’m not going to bother so can simply pass NIL.<\/p>\n
That’s it!<\/p>\n
The app is (almost) complete with the following features.<\/p>\n