incubator-callback-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From macdo...@apache.org
Subject [10/15] Rename to Cordova
Date Fri, 03 Feb 2012 15:43:10 GMT
http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/664a061d/framework/src/org/apache/cordova/CameraLauncher.java
----------------------------------------------------------------------
diff --git a/framework/src/org/apache/cordova/CameraLauncher.java b/framework/src/org/apache/cordova/CameraLauncher.java
new file mode 100755
index 0000000..ec1cc36
--- /dev/null
+++ b/framework/src/org/apache/cordova/CameraLauncher.java
@@ -0,0 +1,504 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import org.apache.commons.codec.binary.Base64;
+import org.apache.cordova.api.LOG;
+import org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
+import android.app.Activity;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.Bitmap.CompressFormat;
+import android.net.Uri;
+import android.provider.MediaStore;
+
+/**
+ * This class launches the camera view, allows the user to take a picture, closes the camera view,
+ * and returns the captured image.  When the camera view is closed, the screen displayed before 
+ * the camera view was shown is redisplayed.
+ */
+public class CameraLauncher extends Plugin {
+
+    private static final int DATA_URL = 0;              // Return base64 encoded string
+    private static final int FILE_URI = 1;              // Return file uri (content://media/external/images/media/2 for Android)
+    
+    private static final int PHOTOLIBRARY = 0;          // Choose image from picture library (same as SAVEDPHOTOALBUM for Android)
+    private static final int CAMERA = 1;                // Take picture from camera
+    private static final int SAVEDPHOTOALBUM = 2;       // Choose image from picture library (same as PHOTOLIBRARY for Android)
+    
+    private static final int PICTURE = 0;               // allow selection of still pictures only. DEFAULT. Will return format specified via DestinationType
+    private static final int VIDEO = 1;                 // allow selection of video only, ONLY RETURNS URL
+    private static final int ALLMEDIA = 2;              // allow selection from all media types
+    
+    private static final int JPEG = 0;                  // Take a picture of type JPEG
+    private static final int PNG = 1;                   // Take a picture of type PNG
+    private static final String GET_PICTURE = "Get Picture";
+    private static final String GET_VIDEO = "Get Video";
+    private static final String GET_All = "Get All";
+    
+    private static final String LOG_TAG = "CameraLauncher";
+    
+    private int mQuality;                   // Compression quality hint (0-100: 0=low quality & high compression, 100=compress of max quality)
+    private int targetWidth;                // desired width of the image
+    private int targetHeight;               // desired height of the image
+    private Uri imageUri;                   // Uri of captured image       
+    private int encodingType;               // Type of encoding to use
+    private int mediaType;                  // What type of media to retrieve
+     
+    public String callbackId;
+    private int numPics;
+    
+    /**
+     * Constructor.
+     */
+    public CameraLauncher() {
+    }
+
+    /**
+     * Executes the request and returns PluginResult.
+     * 
+     * @param action        The action to execute.
+     * @param args          JSONArry of arguments for the plugin.
+     * @param callbackId    The callback id used when calling back into JavaScript.
+     * @return              A PluginResult object with a status and message.
+     */
+    public PluginResult execute(String action, JSONArray args, String callbackId) {
+        PluginResult.Status status = PluginResult.Status.OK;
+        String result = "";     
+        this.callbackId = callbackId;
+        
+        try {
+            if (action.equals("takePicture")) {
+                int srcType = CAMERA;
+                int destType = FILE_URI;
+                this.targetHeight = 0;
+                this.targetWidth = 0;
+                this.encodingType = JPEG;
+                this.mediaType = PICTURE;
+                this.mQuality = 80;
+
+                JSONObject options = args.optJSONObject(0);
+                if (options != null) {
+                    srcType = options.getInt("sourceType");
+                    destType = options.getInt("destinationType");
+                    this.targetHeight = options.getInt("targetHeight");
+                    this.targetWidth = options.getInt("targetWidth");
+                    this.encodingType = options.getInt("encodingType");
+                    this.mediaType = options.getInt("mediaType");
+                    this.mQuality = options.getInt("quality");
+                }
+                
+                if (srcType == CAMERA) {
+                    this.takePicture(destType, encodingType);
+                }
+                else if ((srcType == PHOTOLIBRARY) || (srcType == SAVEDPHOTOALBUM)) {
+                    this.getImage(srcType, destType);
+                }
+                PluginResult r = new PluginResult(PluginResult.Status.NO_RESULT);
+                r.setKeepCallback(true);
+                return r;
+            }
+            return new PluginResult(status, result);
+        } catch (JSONException e) {
+            e.printStackTrace();
+            return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
+        }
+    }
+    
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+    
+    /**
+     * Take a picture with the camera.
+     * When an image is captured or the camera view is cancelled, the result is returned
+     * in CordovaActivity.onActivityResult, which forwards the result to this.onActivityResult.
+     * 
+     * The image can either be returned as a base64 string or a URI that points to the file.
+     * To display base64 string in an img tag, set the source to:
+     *      img.src="data:image/jpeg;base64,"+result;
+     * or to display URI in an img tag
+     *      img.src=result;
+     * 
+     * @param quality           Compression quality hint (0-100: 0=low quality & high compression, 100=compress of max quality)
+     * @param returnType        Set the type of image to return. 
+     */
+    public void takePicture(int returnType, int encodingType) {
+        // Save the number of images currently on disk for later
+        this.numPics = queryImgDB().getCount();
+                
+        // Display camera
+        Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
+        
+        // Specify file so that large image is captured and returned
+        // TODO: What if there isn't any external storage?
+        File photo = createCaptureFile(encodingType);
+        intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(photo));
+        this.imageUri = Uri.fromFile(photo);
+
+        this.ctx.startActivityForResult((Plugin) this, intent, (CAMERA+1)*16 + returnType+1);
+    }
+
+    /**
+     * Create a file in the applications temporary directory based upon the supplied encoding.
+     * 
+     * @param encodingType of the image to be taken
+     * @return a File object pointing to the temporary picture
+     */
+    private File createCaptureFile(int encodingType) {
+        File photo = null;
+        if (encodingType == JPEG) {
+            photo = new File(DirectoryManager.getTempDirectoryPath(ctx),  "Pic.jpg");
+        } else if (encodingType == PNG) {
+            photo = new File(DirectoryManager.getTempDirectoryPath(ctx),  "Pic.png");            
+        } else {
+            throw new IllegalArgumentException("Invalid Encoding Type: " + encodingType);
+        }
+        return photo;
+    }
+
+    /**
+     * Get image from photo library.
+     * 
+     * @param quality           Compression quality hint (0-100: 0=low quality & high compression, 100=compress of max quality)
+     * @param srcType           The album to get image from.
+     * @param returnType        Set the type of image to return. 
+     */
+    // TODO: Images selected from SDCARD don't display correctly, but from CAMERA ALBUM do!
+    public void getImage(int srcType, int returnType) {
+        Intent intent = new Intent();
+        String title = GET_PICTURE;
+        if (this.mediaType == PICTURE) {
+            intent.setType("image/*");  
+        }
+        else if (this.mediaType == VIDEO) {
+            intent.setType("video/*");     
+            title = GET_VIDEO;
+        }
+        else if (this.mediaType == ALLMEDIA) {
+            // I wanted to make the type 'image/*, video/*' but this does not work on all versions 
+            // of android so I had to go with the wildcard search.
+            intent.setType("*/*"); 
+            title = GET_All;
+        }
+        
+        intent.setAction(Intent.ACTION_GET_CONTENT);
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        this.ctx.startActivityForResult((Plugin) this, Intent.createChooser(intent,
+                new String(title)), (srcType+1)*16 + returnType + 1);
+    }
+
+    /**
+     * Scales the bitmap according to the requested size.
+     * 
+     * @param bitmap        The bitmap to scale.
+     * @return Bitmap       A new Bitmap object of the same bitmap after scaling. 
+     */
+    public Bitmap scaleBitmap(Bitmap bitmap) {
+        int newWidth = this.targetWidth;
+        int newHeight = this.targetHeight;
+        int origWidth = bitmap.getWidth();
+        int origHeight = bitmap.getHeight();
+
+        // If no new width or height were specified return the original bitmap
+        if (newWidth <= 0 && newHeight <= 0) {
+            return bitmap;
+        }
+        // Only the width was specified
+        else if (newWidth > 0 && newHeight <= 0) {
+            newHeight = (newWidth * origHeight) / origWidth;
+        }
+        // only the height was specified
+        else if (newWidth <= 0 && newHeight > 0) {
+            newWidth = (newHeight * origWidth) / origHeight;
+        }
+        // If the user specified both a positive width and height
+        // (potentially different aspect ratio) then the width or height is
+        // scaled so that the image fits while maintaining aspect ratio.
+        // Alternatively, the specified width and height could have been
+        // kept and Bitmap.SCALE_TO_FIT specified when scaling, but this
+        // would result in whitespace in the new image.
+        else {
+            double newRatio = newWidth / (double)newHeight;
+            double origRatio = origWidth / (double)origHeight;
+
+            if (origRatio > newRatio) {
+                newHeight = (newWidth * origHeight) / origWidth;
+            } else if (origRatio < newRatio) {
+                newWidth = (newHeight * origWidth) / origHeight;
+            }
+        }
+        
+        return Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true);
+    }
+    
+    /**
+     * Called when the camera view exits. 
+     * 
+     * @param requestCode       The request code originally supplied to startActivityForResult(), 
+     *                          allowing you to identify who this result came from.
+     * @param resultCode        The integer result code returned by the child activity through its setResult().
+     * @param intent            An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+     */
+    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+        
+        // Get src and dest types from request code
+        int srcType = (requestCode/16) - 1;
+        int destType = (requestCode % 16) - 1;
+        
+        // If CAMERA
+        if (srcType == CAMERA) {
+            // If image available
+            if (resultCode == Activity.RESULT_OK) {
+                try {
+                    // Create an ExifHelper to save the exif data that is lost during compression
+                    ExifHelper exif = new ExifHelper();
+                    if (this.encodingType == JPEG) {
+                        exif.createInFile(DirectoryManager.getTempDirectoryPath(ctx) + "/Pic.jpg");
+                        exif.readExifData();
+                    }
+
+                    // Read in bitmap of captured image
+                    Bitmap bitmap;
+                    try {
+                        bitmap = android.provider.MediaStore.Images.Media.getBitmap(this.ctx.getContentResolver(), imageUri);
+                    } catch (FileNotFoundException e) {
+                        Uri uri = intent.getData();
+                        android.content.ContentResolver resolver = this.ctx.getContentResolver();
+                        bitmap = android.graphics.BitmapFactory.decodeStream(resolver.openInputStream(uri));
+                    }
+
+                    bitmap = scaleBitmap(bitmap);
+                    
+                    // If sending base64 image back
+                    if (destType == DATA_URL) {
+                        this.processPicture(bitmap);
+                        checkForDuplicateImage(DATA_URL);
+                    }
+
+                    // If sending filename back
+                    else if (destType == FILE_URI){
+                        // Create entry in media store for image
+                        // (Don't use insertImage() because it uses default compression setting of 50 - no way to change it)
+                        ContentValues values = new ContentValues();
+                        values.put(android.provider.MediaStore.Images.Media.MIME_TYPE, "image/jpeg");
+                        Uri uri = null;
+                        try {
+                            uri = this.ctx.getContentResolver().insert(android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
+                        } catch (UnsupportedOperationException e) {
+                            LOG.d(LOG_TAG, "Can't write to external media storage.");
+                            try {
+                                uri = this.ctx.getContentResolver().insert(android.provider.MediaStore.Images.Media.INTERNAL_CONTENT_URI, values);
+                            } catch (UnsupportedOperationException ex) {
+                                LOG.d(LOG_TAG, "Can't write to internal media storage.");                           
+                                this.failPicture("Error capturing image - no media storage found.");
+                                return;
+                            }
+                        }
+
+                        // Add compressed version of captured image to returned media store Uri
+                        OutputStream os = this.ctx.getContentResolver().openOutputStream(uri);
+                        bitmap.compress(Bitmap.CompressFormat.JPEG, this.mQuality, os);
+                        os.close();
+                        
+                        // Restore exif data to file
+                        if (this.encodingType == JPEG) {
+                            exif.createOutFile(FileUtils.getRealPathFromURI(uri, this.ctx));
+                            exif.writeExifData();
+                        }
+
+                        // Send Uri back to JavaScript for viewing image
+                        this.success(new PluginResult(PluginResult.Status.OK, uri.toString()), this.callbackId);
+                    }
+                    bitmap.recycle();
+                    bitmap = null;
+                    System.gc();
+                    
+                    checkForDuplicateImage(FILE_URI);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    this.failPicture("Error capturing image.");
+                }       
+            }
+
+            // If cancelled
+            else if (resultCode == Activity.RESULT_CANCELED) {
+                this.failPicture("Camera cancelled.");
+            }
+
+            // If something else
+            else {
+                this.failPicture("Did not complete!");
+            }
+        }
+        
+        // If retrieving photo from library
+        else if ((srcType == PHOTOLIBRARY) || (srcType == SAVEDPHOTOALBUM)) {
+            if (resultCode == Activity.RESULT_OK) {
+                Uri uri = intent.getData();
+                android.content.ContentResolver resolver = this.ctx.getContentResolver();
+                
+                // If you ask for video or all media type you will automatically get back a file URI 
+                // and there will be no attempt to resize any returned data
+                if (this.mediaType != PICTURE) {
+                    this.success(new PluginResult(PluginResult.Status.OK, uri.toString()), this.callbackId);                        
+                }
+                else {
+                    // If sending base64 image back
+                    if (destType == DATA_URL) {
+                        try {
+                            Bitmap bitmap = android.graphics.BitmapFactory.decodeStream(resolver.openInputStream(uri));
+                            bitmap = scaleBitmap(bitmap);
+                            this.processPicture(bitmap);
+                            bitmap.recycle();
+                            bitmap = null;
+                            System.gc();
+                        } catch (FileNotFoundException e) {
+                            e.printStackTrace();
+                            this.failPicture("Error retrieving image.");
+                        }
+                    }
+                    
+                    // If sending filename back
+                    else if (destType == FILE_URI) {
+                        // Do we need to scale the returned file
+                        if (this.targetHeight > 0 && this.targetWidth > 0) {
+                            try {
+                                Bitmap bitmap = android.graphics.BitmapFactory.decodeStream(resolver.openInputStream(uri));
+                                bitmap = scaleBitmap(bitmap);
+    
+                                String fileName = DirectoryManager.getTempDirectoryPath(ctx) + "/resize.jpg";
+                                OutputStream os = new FileOutputStream(fileName);                         
+                                bitmap.compress(Bitmap.CompressFormat.JPEG, this.mQuality, os);
+                                os.close();
+    
+                                bitmap.recycle();
+                                bitmap = null;
+                                
+                                // The resized image is cached by the app in order to get around this and not have to delete you 
+                                // application cache I'm adding the current system time to the end of the file url.
+                                this.success(new PluginResult(PluginResult.Status.OK, ("file://" + fileName + "?" + System.currentTimeMillis())), this.callbackId);
+                                System.gc();
+                            } catch (Exception e) {
+                                e.printStackTrace();
+                                this.failPicture("Error retrieving image.");
+                            }
+                        }
+                        else {
+                            this.success(new PluginResult(PluginResult.Status.OK, uri.toString()), this.callbackId);                        
+                        }
+                    }
+                }
+            }
+            else if (resultCode == Activity.RESULT_CANCELED) {
+                this.failPicture("Selection cancelled.");               
+            }
+            else {
+                this.failPicture("Selection did not complete!");                
+            }
+        }
+    }
+
+    /**
+     * Creates a cursor that can be used to determine how many images we have.
+     * 
+     * @return a cursor
+     */
+    private Cursor queryImgDB() {
+        return this.ctx.getContentResolver().query(
+                android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
+                new String[] { MediaStore.Images.Media._ID },
+                null,
+                null,
+                null);
+    }
+    
+    /**
+     * Used to find out if we are in a situation where the Camera Intent adds to images
+     * to the content store. If we are using a FILE_URI and the number of images in the DB 
+     * increases by 2 we have a duplicate, when using a DATA_URL the number is 1.
+     * 
+     * @param type FILE_URI or DATA_URL
+     */
+    private void checkForDuplicateImage(int type) {
+        int diff = 1;
+        Cursor cursor = queryImgDB();
+        int currentNumOfImages = cursor.getCount();
+        
+        if (type == FILE_URI) {
+            diff = 2;
+        }
+        
+        // delete the duplicate file if the difference is 2 for file URI or 1 for Data URL
+        if ((currentNumOfImages - numPics) == diff) {
+            cursor.moveToLast();
+            int id = Integer.valueOf(cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media._ID))) - 1;                    
+            Uri uri = Uri.parse(MediaStore.Images.Media.EXTERNAL_CONTENT_URI + "/" + id);
+            this.ctx.getContentResolver().delete(uri, null, null);
+        }
+    }
+
+    /**
+     * Compress bitmap using jpeg, convert to Base64 encoded string, and return to JavaScript.
+     *
+     * @param bitmap
+     */
+    public void processPicture(Bitmap bitmap) {     
+        ByteArrayOutputStream jpeg_data = new ByteArrayOutputStream();
+        try {
+            if (bitmap.compress(CompressFormat.JPEG, mQuality, jpeg_data)) {
+                byte[] code  = jpeg_data.toByteArray();
+                byte[] output = Base64.encodeBase64(code);
+                String js_out = new String(output);
+                this.success(new PluginResult(PluginResult.Status.OK, js_out), this.callbackId);
+                js_out = null;
+                output = null;
+                code = null;
+            }   
+        }
+        catch(Exception e) {
+            this.failPicture("Error compressing image.");
+        }       
+        jpeg_data = null;
+    }
+    
+    /**
+     * Send error message to JavaScript.
+     * 
+     * @param err
+     */
+    public void failPicture(String err) {
+        this.error(new PluginResult(PluginResult.Status.ERROR, err), this.callbackId);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/664a061d/framework/src/org/apache/cordova/Capture.java
----------------------------------------------------------------------
diff --git a/framework/src/org/apache/cordova/Capture.java b/framework/src/org/apache/cordova/Capture.java
new file mode 100644
index 0000000..d2d5b7d
--- /dev/null
+++ b/framework/src/org/apache/cordova/Capture.java
@@ -0,0 +1,399 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+
+import org.apache.cordova.api.LOG;
+import org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import android.app.Activity;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.util.Log;
+
+
+public class Capture extends Plugin {
+
+    private static final String VIDEO_3GPP = "video/3gpp";
+    private static final String AUDIO_3GPP = "audio/3gpp";
+    private static final String IMAGE_JPEG = "image/jpeg";
+    
+    private static final int CAPTURE_AUDIO = 0;     // Constant for capture audio
+    private static final int CAPTURE_IMAGE = 1;     // Constant for capture image
+    private static final int CAPTURE_VIDEO = 2;     // Constant for capture video
+    private static final String LOG_TAG = "Capture";
+    
+    private static final int CAPTURE_INTERNAL_ERR = 0;
+    private static final int CAPTURE_APPLICATION_BUSY = 1;
+    private static final int CAPTURE_INVALID_ARGUMENT = 2;
+    private static final int CAPTURE_NO_MEDIA_FILES = 3;
+    private static final int CAPTURE_NOT_SUPPORTED = 20;
+    
+    private String callbackId;                      // The ID of the callback to be invoked with our result
+    private long limit;                             // the number of pics/vids/clips to take
+    private double duration;                        // optional duration parameter for video recording
+    private JSONArray results;                      // The array of results to be returned to the user
+    private Uri imageUri;                           // Uri of captured image 
+
+    @Override
+    public PluginResult execute(String action, JSONArray args, String callbackId) {
+        this.callbackId = callbackId;
+        this.limit = 1;
+        this.duration = 0.0f;
+        this.results = new JSONArray();
+        
+        JSONObject options = args.optJSONObject(0);
+        if (options != null) {
+            limit = options.optLong("limit", 1);
+            duration = options.optDouble("duration", 0.0f);
+        }
+
+        if (action.equals("getFormatData")) {
+            try {
+                JSONObject obj = getFormatData(args.getString(0), args.getString(1));
+                return new PluginResult(PluginResult.Status.OK, obj);
+            } catch (JSONException e) {
+                return new PluginResult(PluginResult.Status.ERROR);
+            }
+        }
+        else if (action.equals("captureAudio")) {
+            this.captureAudio();
+        }
+        else if (action.equals("captureImage")) {
+            this.captureImage();
+        }
+        else if (action.equals("captureVideo")) {
+            this.captureVideo(duration);    
+        }
+        
+        PluginResult r = new PluginResult(PluginResult.Status.NO_RESULT);
+        r.setKeepCallback(true);
+        return r;
+    }
+
+    /**
+     * Provides the media data file data depending on it's mime type
+     * 
+     * @param filePath path to the file
+     * @param mimeType of the file
+     * @return a MediaFileData object
+     */
+    private JSONObject getFormatData(String filePath, String mimeType) {
+        JSONObject obj = new JSONObject();
+        try {
+            // setup defaults
+            obj.put("height", 0);
+            obj.put("width", 0);
+            obj.put("bitrate", 0);
+            obj.put("duration", 0);
+            obj.put("codecs", "");
+
+            // If the mimeType isn't set the rest will fail
+            // so let's see if we can determine it.
+            if (mimeType == null || mimeType.equals("")) {
+                mimeType = FileUtils.getMimeType(filePath);
+            }
+            Log.d(LOG_TAG, "Mime type = " + mimeType);
+            
+            if (mimeType.equals(IMAGE_JPEG) || filePath.endsWith(".jpg")) {
+                obj = getImageData(filePath, obj);
+            }
+            else if (mimeType.endsWith(AUDIO_3GPP)) {
+                obj = getAudioVideoData(filePath, obj, false);
+            }
+            else if (mimeType.equals(VIDEO_3GPP)) {
+                obj = getAudioVideoData(filePath, obj, true);
+            }
+        }
+        catch (JSONException e) {
+            Log.d(LOG_TAG, "Error: setting media file data object");
+        }
+        return obj;
+    }
+
+    /**
+     * Get the Image specific attributes
+     * 
+     * @param filePath path to the file
+     * @param obj represents the Media File Data
+     * @return a JSONObject that represents the Media File Data
+     * @throws JSONException
+     */
+    private JSONObject getImageData(String filePath, JSONObject obj) throws JSONException {
+        Bitmap bitmap = BitmapFactory.decodeFile(filePath);
+        obj.put("height", bitmap.getHeight());
+        obj.put("width", bitmap.getWidth());
+        return obj;
+    }
+
+    /**
+     * Get the Image specific attributes
+     * 
+     * @param filePath path to the file
+     * @param obj represents the Media File Data
+     * @param video if true get video attributes as well
+     * @return a JSONObject that represents the Media File Data
+     * @throws JSONException
+     */
+    private JSONObject getAudioVideoData(String filePath, JSONObject obj, boolean video) throws JSONException {
+        MediaPlayer player = new MediaPlayer();
+        try {
+            player.setDataSource(filePath);
+            player.prepare();
+            obj.put("duration", player.getDuration());
+            if (video) {
+                obj.put("height", player.getVideoHeight());
+                obj.put("width", player.getVideoWidth());
+            }
+        }
+        catch (IOException e) {
+            Log.d(LOG_TAG, "Error: loading video file");
+        } 
+        return obj;
+    }
+
+    /**
+     * Sets up an intent to capture audio.  Result handled by onActivityResult()
+     */
+    private void captureAudio() {
+        Intent intent = new Intent(android.provider.MediaStore.Audio.Media.RECORD_SOUND_ACTION);
+
+        this.ctx.startActivityForResult((Plugin) this, intent, CAPTURE_AUDIO);
+    }
+
+    /**
+     * Sets up an intent to capture images.  Result handled by onActivityResult()
+     */
+    private void captureImage() {
+        Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
+
+        // Specify file so that large image is captured and returned
+        File photo = new File(DirectoryManager.getTempDirectoryPath(ctx),  "Capture.jpg");
+        intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(photo));
+        this.imageUri = Uri.fromFile(photo);
+
+        this.ctx.startActivityForResult((Plugin) this, intent, CAPTURE_IMAGE);
+    }
+
+    /**
+     * Sets up an intent to capture video.  Result handled by onActivityResult()
+     */
+    private void captureVideo(double duration) {
+        Intent intent = new Intent(android.provider.MediaStore.ACTION_VIDEO_CAPTURE);
+        // Introduced in API 8
+        //intent.putExtra(android.provider.MediaStore.EXTRA_DURATION_LIMIT, duration);
+        
+        this.ctx.startActivityForResult((Plugin) this, intent, CAPTURE_VIDEO);
+    }
+    
+    /**
+     * Called when the video view exits. 
+     * 
+     * @param requestCode       The request code originally supplied to startActivityForResult(), 
+     *                          allowing you to identify who this result came from.
+     * @param resultCode        The integer result code returned by the child activity through its setResult().
+     * @param intent            An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+     * @throws JSONException 
+     */
+    public void onActivityResult(int requestCode, int resultCode, Intent intent) {
+
+        // Result received okay
+        if (resultCode == Activity.RESULT_OK) {
+            // An audio clip was requested
+            if (requestCode == CAPTURE_AUDIO) {
+                // Get the uri of the audio clip
+                Uri data = intent.getData();
+                // create a file object from the uri
+                results.put(createMediaFile(data));
+
+                if (results.length() >= limit) {
+                    // Send Uri back to JavaScript for listening to audio
+                    this.success(new PluginResult(PluginResult.Status.OK, results, "navigator.device.capture._castMediaFile"), this.callbackId);
+                } else {
+                    // still need to capture more audio clips
+                    captureAudio();
+                }
+            } else if (requestCode == CAPTURE_IMAGE) {
+                // For some reason if I try to do:
+                // Uri data = intent.getData();
+                // It crashes in the emulator and on my phone with a null pointer exception
+                // To work around it I had to grab the code from CameraLauncher.java
+                try {
+                    // Create an ExifHelper to save the exif data that is lost during compression
+                    ExifHelper exif = new ExifHelper();
+                    exif.createInFile(DirectoryManager.getTempDirectoryPath(ctx) + "/Capture.jpg");
+                    exif.readExifData();
+                    
+                    // Read in bitmap of captured image
+                    Bitmap bitmap = android.provider.MediaStore.Images.Media.getBitmap(this.ctx.getContentResolver(), imageUri);
+
+                    // Create entry in media store for image
+                    // (Don't use insertImage() because it uses default compression setting of 50 - no way to change it)
+                    ContentValues values = new ContentValues();
+                    values.put(android.provider.MediaStore.Images.Media.MIME_TYPE, IMAGE_JPEG);
+                    Uri uri = null;
+                    try {
+                        uri = this.ctx.getContentResolver().insert(android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
+                    } catch (UnsupportedOperationException e) {
+                        LOG.d(LOG_TAG, "Can't write to external media storage.");
+                        try {
+                            uri = this.ctx.getContentResolver().insert(android.provider.MediaStore.Images.Media.INTERNAL_CONTENT_URI, values);
+                        } catch (UnsupportedOperationException ex) {
+                            LOG.d(LOG_TAG, "Can't write to internal media storage.");                           
+                            this.fail(createErrorObject(CAPTURE_INTERNAL_ERR, "Error capturing image - no media storage found."));
+                            return;
+                        }
+                    }
+
+                    // Add compressed version of captured image to returned media store Uri
+                    OutputStream os  = this.ctx.getContentResolver().openOutputStream(uri);
+                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
+                    os.close();
+
+                    bitmap.recycle();
+                    bitmap = null;
+                    System.gc();
+                    
+                    // Restore exif data to file
+                    exif.createOutFile(FileUtils.getRealPathFromURI(uri, this.ctx));
+                    exif.writeExifData();
+                    
+                    // Add image to results
+                    results.put(createMediaFile(uri));
+                    
+                    if (results.length() >= limit) {
+                        // Send Uri back to JavaScript for viewing image
+                        this.success(new PluginResult(PluginResult.Status.OK, results, "navigator.device.capture._castMediaFile"), this.callbackId);
+                    } else {
+                        // still need to capture more images
+                        captureImage();
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    this.fail(createErrorObject(CAPTURE_INTERNAL_ERR, "Error capturing image."));
+                }
+            } else if (requestCode == CAPTURE_VIDEO) {
+                // Get the uri of the video clip
+                Uri data = intent.getData();
+                // create a file object from the uri
+                results.put(createMediaFile(data));
+
+                if (results.length() >= limit) {
+                    // Send Uri back to JavaScript for viewing video
+                    this.success(new PluginResult(PluginResult.Status.OK, results, "navigator.device.capture._castMediaFile"), this.callbackId);
+                } else {
+                    // still need to capture more video clips
+                    captureVideo(duration);
+                }
+            }
+        }
+        // If canceled
+        else if (resultCode == Activity.RESULT_CANCELED) {
+            // If we have partial results send them back to the user
+            if (results.length() > 0) {
+                this.success(new PluginResult(PluginResult.Status.OK, results, "navigator.device.capture._castMediaFile"), this.callbackId);                
+            }
+            // user canceled the action
+            else {
+                this.fail(createErrorObject(CAPTURE_NO_MEDIA_FILES, "Canceled."));
+            }
+        }
+        // If something else
+        else {
+            // If we have partial results send them back to the user
+            if (results.length() > 0) {
+                this.success(new PluginResult(PluginResult.Status.OK, results, "navigator.device.capture._castMediaFile"), this.callbackId);                
+            }
+            // something bad happened
+            else {
+                this.fail(createErrorObject(CAPTURE_NO_MEDIA_FILES, "Did not complete!"));
+            }
+        }
+    }
+
+    /**
+     * Creates a JSONObject that represents a File from the Uri
+     *  
+     * @param data the Uri of the audio/image/video
+     * @return a JSONObject that represents a File
+     * @throws IOException 
+     */
+    private JSONObject createMediaFile(Uri data){
+        File fp = new File(FileUtils.getRealPathFromURI(data, this.ctx));
+        JSONObject obj = new JSONObject();
+
+        try {       
+            // File properties
+            obj.put("name", fp.getName());
+            obj.put("fullPath", fp.getAbsolutePath());
+            
+            // Because of an issue with MimeTypeMap.getMimeTypeFromExtension() all .3gpp files 
+            // are reported as video/3gpp. I'm doing this hacky check of the URI to see if it 
+            // is stored in the audio or video content store.
+            if (fp.getAbsoluteFile().toString().endsWith(".3gp") || fp.getAbsoluteFile().toString().endsWith(".3gpp")) {
+                if (data.toString().contains("/audio/")) {
+                    obj.put("type", AUDIO_3GPP);                
+                } else {
+                    obj.put("type", VIDEO_3GPP);                
+                }               
+            } else {
+                obj.put("type", FileUtils.getMimeType(fp.getAbsolutePath()));                
+            }
+            
+            obj.put("lastModifiedDate", fp.lastModified());
+            obj.put("size", fp.length());
+        } catch (JSONException e) {
+            // this will never happen
+            e.printStackTrace();
+        }
+        
+        return obj;
+    }
+    
+    private JSONObject createErrorObject(int code, String message) {
+        JSONObject obj = new JSONObject();
+        try {
+            obj.put("code", code);
+            obj.put("message", message);
+        } catch (JSONException e) {
+            // This will never happen
+        }
+        return obj;
+    }
+
+    /**
+     * Send error message to JavaScript.
+     * 
+     * @param err
+     */
+    public void fail(JSONObject err) {
+        this.error(new PluginResult(PluginResult.Status.ERROR, err), this.callbackId);
+    }
+}

http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/664a061d/framework/src/org/apache/cordova/CompassListener.java
----------------------------------------------------------------------
diff --git a/framework/src/org/apache/cordova/CompassListener.java b/framework/src/org/apache/cordova/CompassListener.java
new file mode 100755
index 0000000..f5fa2b6
--- /dev/null
+++ b/framework/src/org/apache/cordova/CompassListener.java
@@ -0,0 +1,305 @@
+/*
+       Licensed to the Apache Software Foundation (ASF) under one
+       or more contributor license agreements.  See the NOTICE file
+       distributed with this work for additional information
+       regarding copyright ownership.  The ASF licenses this file
+       to you under the Apache License, Version 2.0 (the
+       "License"); you may not use this file except in compliance
+       with the License.  You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+       Unless required by applicable law or agreed to in writing,
+       software distributed under the License is distributed on an
+       "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+       KIND, either express or implied.  See the License for the
+       specific language governing permissions and limitations
+       under the License.
+*/
+package org.apache.cordova;
+
+import java.util.List;
+
+import org.apache.cordova.api.CordovaActivity;
+import org.apache.cordova.api.Plugin;
+import org.apache.cordova.api.PluginResult;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.content.Context;
+
+/**
+ * This class listens to the compass sensor and stores the latest heading value.
+ */
+public class CompassListener extends Plugin implements SensorEventListener {
+
+    public static int STOPPED = 0;
+    public static int STARTING = 1;
+    public static int RUNNING = 2;
+    public static int ERROR_FAILED_TO_START = 3;
+    
+    public long TIMEOUT = 30000;        // Timeout in msec to shut off listener
+    
+    int status;                         // status of listener
+    float heading;                      // most recent heading value
+    long timeStamp;                     // time of most recent value
+    long lastAccessTime;                // time the value was last retrieved
+    int accuracy;                       // accuracy of the sensor
+    
+    private SensorManager sensorManager;// Sensor manager
+    Sensor mSensor;                     // Compass sensor returned by sensor manager
+    
+    /**
+     * Constructor.
+     */
+    public CompassListener() {
+        this.timeStamp = 0;
+        this.setStatus(CompassListener.STOPPED);
+    }
+
+    /**
+     * Sets the context of the Command. This can then be used to do things like
+     * get file paths associated with the Activity.
+     * 
+     * @param ctx The context of the main Activity.
+     */
+    public void setContext(CordovaActivity ctx) {
+        super.setContext(ctx);
+        this.sensorManager = (SensorManager) ctx.getSystemService(Context.SENSOR_SERVICE);
+    }
+
+    /**
+     * Executes the request and returns PluginResult.
+     * 
+     * @param action        The action to execute.
+     * @param args          JSONArry of arguments for the plugin.
+     * @param callbackId    The callback id used when calling back into JavaScript.
+     * @return              A PluginResult object with a status and message.
+     */
+    public PluginResult execute(String action, JSONArray args, String callbackId) {
+        PluginResult.Status status = PluginResult.Status.OK;
+        String result = "";     
+        
+        try {
+            if (action.equals("start")) {
+                this.start();
+            }
+            else if (action.equals("stop")) {
+                this.stop();
+            }
+            else if (action.equals("getStatus")) {
+                int i = this.getStatus();
+                return new PluginResult(status, i);
+            }
+            else if (action.equals("getHeading")) {
+                // If not running, then this is an async call, so don't worry about waiting
+                if (this.status != RUNNING) {
+                    int r = this.start();
+                    if (r == ERROR_FAILED_TO_START) {
+                        return new PluginResult(PluginResult.Status.IO_EXCEPTION, ERROR_FAILED_TO_START);
+                    }
+                    // Wait until running
+                    long timeout = 2000;
+                    while ((this.status == STARTING) && (timeout > 0)) {
+                        timeout = timeout - 100;
+                        try {
+                            Thread.sleep(100);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    }
+                    if (timeout == 0) {
+                        return new PluginResult(PluginResult.Status.IO_EXCEPTION, AccelListener.ERROR_FAILED_TO_START);                     
+                    }
+                }
+                //float f = this.getHeading();
+                return new PluginResult(status, getCompassHeading(), "navigator.compass._castDate");
+            }
+            else if (action.equals("setTimeout")) {
+                this.setTimeout(args.getLong(0));
+            }
+            else if (action.equals("getTimeout")) {
+                long l = this.getTimeout();
+                return new PluginResult(status, l);
+            }
+            return new PluginResult(status, result);
+        } catch (JSONException e) {
+            e.printStackTrace();
+            return new PluginResult(PluginResult.Status.JSON_EXCEPTION);
+        }
+    }
+
+    /**
+     * Identifies if action to be executed returns a value and should be run synchronously.
+     * 
+     * @param action    The action to execute
+     * @return          T=returns value
+     */
+    public boolean isSynch(String action) {
+        if (action.equals("getStatus")) {
+            return true;
+        }
+        else if (action.equals("getHeading")) {
+            // Can only return value if RUNNING
+            if (this.status == RUNNING) {
+                return true;
+            }
+        }
+        else if (action.equals("getTimeout")) {
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Called when listener is to be shut down and object is being destroyed.
+     */
+    public void onDestroy() {
+        this.stop();
+    }
+
+    //--------------------------------------------------------------------------
+    // LOCAL METHODS
+    //--------------------------------------------------------------------------
+
+    /**
+     * Start listening for compass sensor.
+     * 
+     * @return          status of listener
+     */
+    public int start() {
+        
+        // If already starting or running, then just return
+        if ((this.status == CompassListener.RUNNING) || (this.status == CompassListener.STARTING)) {
+            return this.status;
+        }
+
+        // Get accelerometer from sensor manager
+        List<Sensor> list = this.sensorManager.getSensorList(Sensor.TYPE_ORIENTATION);
+
+        // If found, then register as listener
+        if (list.size() > 0) {
+            this.mSensor = list.get(0);
+            this.sensorManager.registerListener(this, this.mSensor, SensorManager.SENSOR_DELAY_NORMAL);
+            this.lastAccessTime = System.currentTimeMillis();
+            this.setStatus(CompassListener.STARTING);
+        }
+
+        // If error, then set status to error
+        else {
+            this.setStatus(CompassListener.ERROR_FAILED_TO_START);
+        }
+        
+        return this.status;
+    }
+    
+    /**
+     * Stop listening to compass sensor.
+     */
+    public void stop() {
+        if (this.status != CompassListener.STOPPED) {
+            this.sensorManager.unregisterListener(this);
+        }
+        this.setStatus(CompassListener.STOPPED);
+    }
+    
+    
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        // TODO Auto-generated method stub  
+    }
+
+    /**
+     * Sensor listener event.
+     * 
+     * @param SensorEvent event
+     */
+    public void onSensorChanged(SensorEvent event) {
+
+        // We only care about the orientation as far as it refers to Magnetic North
+        float heading = event.values[0];
+
+        // Save heading
+        this.timeStamp = System.currentTimeMillis();
+        this.heading = heading;
+        this.setStatus(CompassListener.RUNNING);
+
+        // If heading hasn't been read for TIMEOUT time, then turn off compass sensor to save power
+        if ((this.timeStamp - this.lastAccessTime) > this.TIMEOUT) {
+            this.stop();
+        }
+    }
+    
+    /**
+     * Get status of compass sensor.
+     * 
+     * @return          status
+     */
+    public int getStatus() {
+        return this.status;
+    }
+    
+    /**
+     * Get the most recent compass heading.
+     * 
+     * @return          heading
+     */
+    public float getHeading() {
+        this.lastAccessTime = System.currentTimeMillis();
+        return this.heading;
+    }
+    
+    /**
+     * Set the timeout to turn off compass sensor if getHeading() hasn't been called.
+     * 
+     * @param timeout       Timeout in msec.
+     */
+    public void setTimeout(long timeout) {
+        this.TIMEOUT = timeout;
+    }
+    
+    /**
+     * Get the timeout to turn off compass sensor if getHeading() hasn't been called.
+     * 
+     * @return timeout in msec
+     */
+    public long getTimeout() {
+        return this.TIMEOUT;
+    }
+
+    /**
+     * Set the status and send it to JavaScript.
+     * @param status
+     */
+    private void setStatus(int status) {
+        this.status = status;
+    }
+
+    /**
+     * Create the CompassHeading JSON object to be returned to JavaScript
+     * 
+     * @return a compass heading
+     */
+    private JSONObject getCompassHeading() {
+        JSONObject obj = new JSONObject();
+        
+        try {
+            obj.put("magneticHeading", this.getHeading());
+            obj.put("trueHeading", this.getHeading());
+            // Since the magnetic and true heading are always the same our and accuracy 
+            // is defined as the difference between true and magnetic always return zero
+            obj.put("headingAccuracy", 0);
+            obj.put("timestamp", this.timeStamp);
+        } catch (JSONException e) {
+            // Should never happen
+        }
+        
+        return obj;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-cordova-android/blob/664a061d/framework/src/org/apache/cordova/ContactAccessor.java
----------------------------------------------------------------------
diff --git a/framework/src/org/apache/cordova/ContactAccessor.java b/framework/src/org/apache/cordova/ContactAccessor.java
new file mode 100644
index 0000000..38d4b0b
--- /dev/null
+++ b/framework/src/org/apache/cordova/ContactAccessor.java
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cordova;
+
+import java.util.HashMap;
+
+import android.app.Activity;
+import android.util.Log;
+import android.webkit.WebView;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * This abstract class defines SDK-independent API for communication with
+ * Contacts Provider. The actual implementation used by the application depends
+ * on the level of API available on the device. If the API level is Cupcake or
+ * Donut, we want to use the {@link ContactAccessorSdk3_4} class. If it is
+ * Eclair or higher, we want to use {@link ContactAccessorSdk5}.
+ */
+public abstract class ContactAccessor {
+  
+    protected final String LOG_TAG = "ContactsAccessor";
+    protected Activity mApp;
+    protected WebView mView;
+  
+    /**
+     * Check to see if the data associated with the key is required to 
+     * be populated in the Contact object.
+     * @param key 
+     * @param map created by running buildPopulationSet.
+     * @return true if the key data is required
+     */
+    protected boolean isRequired(String key, HashMap<String,Boolean> map) {
+    Boolean retVal = map.get(key);
+    return (retVal == null) ? false : retVal.booleanValue();
+  }
+    
+    /**
+     * Create a hash map of what data needs to be populated in the Contact object
+     * @param fields the list of fields to populate
+     * @return the hash map of required data
+     */
+  protected HashMap<String,Boolean> buildPopulationSet(JSONArray fields) {
+    HashMap<String,Boolean> map = new HashMap<String,Boolean>();
+    
+    String key;
+    try {
+        if (fields.length() == 1 && fields.getString(0).equals("*")) {
+                map.put("displayName", true);
+                map.put("name", true);
+                map.put("nickname", true);
+                map.put("phoneNumbers", true);
+                map.put("emails", true);
+                map.put("addresses", true);
+                map.put("ims", true);
+                map.put("organizations", true);
+                map.put("birthday", true);
+                map.put("note", true);
+                map.put("urls", true);
+                map.put("photos", true);
+                map.put("categories", true);
+        } 
+        else {
+          for (int i=0; i<fields.length(); i++) {
+            key = fields.getString(i);
+            if (key.startsWith("displayName")) {
+              map.put("displayName", true);
+            }
+            else if (key.startsWith("name")) {
+              map.put("name", true);
+            }
+            else if (key.startsWith("nickname")) {
+              map.put("nickname", true);
+            }
+            else if (key.startsWith("phoneNumbers")) {
+              map.put("phoneNumbers", true);
+            }
+            else if (key.startsWith("emails")) {
+              map.put("emails", true);
+            }
+            else if (key.startsWith("addresses")) {
+              map.put("addresses", true);
+            }
+            else if (key.startsWith("ims")) {
+              map.put("ims", true);
+            }
+            else if (key.startsWith("organizations")) {
+              map.put("organizations", true);
+            }
+            else if (key.startsWith("birthday")) {
+              map.put("birthday", true);
+            }
+            else if (key.startsWith("note")) {
+              map.put("note", true);
+            }
+            else if (key.startsWith("urls")) {
+              map.put("urls", true);
+            }
+                    else if (key.startsWith("photos")) {
+                        map.put("photos", true);
+                    }
+                    else if (key.startsWith("categories")) {
+                        map.put("categories", true);
+                    }
+          }
+        }
+    }
+    catch (JSONException e) {
+      Log.e(LOG_TAG, e.getMessage(), e);
+    }
+    return map;
+  }
+  
+  /**
+   * Convenience method to get a string from a JSON object.  Saves a 
+   * lot of try/catch writing.
+   * If the property is not found in the object null will be returned.
+   * 
+   * @param obj contact object to search
+   * @param property to be looked up
+   * @return The value of the property
+   */
+  protected String getJsonString(JSONObject obj, String property) {
+    String value = null;
+    try {
+        if (obj != null) {
+      value = obj.getString(property);
+          if (value.equals("null")) {
+            Log.d(LOG_TAG, property + " is string called 'null'");
+            value = null;
+          }
+        }
+    }
+    catch (JSONException e) {
+      Log.d(LOG_TAG, "Could not get = " + e.getMessage());
+    }   
+    return value;
+  }
+
+    /**
+     * Handles adding a JSON Contact object into the database.
+     * @return TODO
+     */
+  public abstract String save(JSONObject contact);
+
+    /**
+     * Handles searching through SDK-specific contacts API.
+     */
+    public abstract JSONArray search(JSONArray filter, JSONObject options);
+
+    /**
+     * Handles searching through SDK-specific contacts API.
+     * @throws JSONException 
+     */
+    public abstract JSONObject getContactById(String id) throws JSONException;
+
+    /**
+     * Handles removing a contact from the database.
+     */
+  public abstract boolean remove(String id);
+  
+  /**
+   * A class that represents the where clause to be used in the database query 
+   */
+  class WhereOptions {
+    private String where;
+    private String[] whereArgs;
+    public void setWhere(String where) {
+      this.where = where;
+    }
+    public String getWhere() {
+      return where;
+    }
+    public void setWhereArgs(String[] whereArgs) {
+      this.whereArgs = whereArgs;
+    }
+    public String[] getWhereArgs() {
+      return whereArgs;
+    }
+  }
+}


Mime
View raw message