Question

var camera = {
  settings : {
    quality : 50,
    targetWidth : 1024,
    targetHeight : 1024,
    correctOrientation : true
  }
};
var error = function(message) {
  alert("Error happened while trying to get a picture", message);
};
document.addEventListener("deviceready", function() {
  camera.toFile = function() {
    this.settings.destinationType = navigator.camera.DestinationType.FILE_URI;
    return this;
  },
  camera.toBase64 = function() {
    this.settings.destinationType = navigator.camera.DestinationType.DATA_URL;
    return this;
  },
  camera.fromCamera = function() {
    this.settings.sourceType = navigator.camera.PictureSourceType.CAMERA;
    return this;
  };
  camera.fromLibrary = function() {
    this.settings.sourceType = navigator.camera.PictureSourceType.PHOTOLIBRARY;
    return this;
  };
  camera.fromPhotoAlbum = function() {
    this.settings.sourceType = navigator.camera.PictureSourceType.SAVEDPHOTOALBUM;
    return this;
  }
  camera.get = function(callback) {
    navigator.camera.getPicture(function(data) {
      alert("taking a picture successful");
      callback(data);
    }, error, camera.settings);
  };
}, false);

This is my small wrapper for the camera. And I call it like this:

camera.fromPhotoAlbum().toBase64().get(function(base64){});

About 20% of the time, the “alert(“taking a picture successful”);” is not called, while no error is shown. If I cancel taking a picture, an alert with the message “Error happened while trying to get a picture” is shown, so the error callback works.

Basically nothing happens. I’ve tested it on a Samsung Galaxy S2 on CM9 and a brand new HTC One X.

Answer 1

There was another question recently about this same problem that I answered. We ran into this at my company and solved it. It has more to do with the Android system than Phonegap.

What’s happening is when you start the camera, your app goes into onStop(). While there, the Android system has the right to kill your app if it needs memory. It just so happens that memory usually gets low when the camera takes a picture and dumps it into memory, so there’s a good chance your app will get killed while your user takes a picture.

Now that your app is dead, when the camera finishes, it restarts your app. That’s why it’s acting so weird; the camera comes back into your app, but not the same instance that it had before, so your callback never gets called, since it doesn’t exist anymore.

You can reduce the frequency at which this occurs by reducing the quality of the picture and passing it by URI instead of data to your app, but the problem won’t go away completely.

To work around the callback never happening, we made a Java callback that starts the camera and saves the picture to the same location every time it takes one. Then, when the app starts back up from getting killed, it looks in that location for the picture.

It’s a weird solution to a stupid problem, but if your app gets killed, that camera callback simply won’t happen. If you need more information on how to make the Java callback to do this, let me know and I’ll put our code up here. Otherwise, take a look at this SO answer for more info.

EDIT: Here’s the code we use in our main DroidGap activity:

private static final String folderPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/appName";
private static final String filePath = "phonegapImage.jpg";

@Override
public void onCreate(Bundle savedState) {
    //...The rest of onCreate, this makes the Java available in JavaScript
    appView.addJavascriptInterface(this, "Camera");
}

public void takePhoto(final String callback) {
    Log.v("Camera Plugin", "Starting takePhoto callback");

    Intent intent = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(folderPath, filePath)));
    startActivityForResult(intent, TAKE_PICTURE);
}

public String getPhotoUri() {
    return Uri.fromFile(new File(folderPath, filePath)).toString();
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);

    switch (requestCode) {
        case TAKE_PICTURE:
            if (resultCode == Activity.RESULT_OK) {
                //Do whatever you need to do when the camera returns
                //This is after the picture is already saved, we return to the page
            }
            break;
        default:
            Log.v("Camera", "Something strange happened...");
            break;
    }
}

Then, in your JavaScript, you can invoke the camera with:

Camera.takePhoto("onPhotoURISuccess");
//Then, to get the location of the photo after you take it and load the page again
var imgPath = Camera.getPhotoUri();

So, that’s about it. Just make sure to change all of the path/file/page/etc names to what you want to use in your app. This will overwrite that image every time a picture is taken, but you can probably figure something out to dynamically name them if you don’t want that. You can use that URI just as you would any other path in your JavaScript.