diff --git a/apps/camera/js/app.js b/apps/camera/js/app.js
index 85800739c9e1..4150ae643947 100644
--- a/apps/camera/js/app.js
+++ b/apps/camera/js/app.js
@@ -5,27 +5,22 @@ define(function(require, exports, module) {
  * Dependencies
  */
 
-var performanceTesting = require('performanceTesting');
 var NotificationView = require('views/notification');
 var ViewfinderView = require('views/viewfinder');
 var orientation = require('lib/orientation');
 var ControlsView = require('views/controls');
 var FocusRing = require('views/focus-ring');
 var ZoomBarView = require('views/zoom-bar');
-var lockscreen = require('lib/lock-screen');
-var constants = require('config/camera');
 var bindAll = require('lib/bind-all');
 var model = require('vendor/model');
 var debug = require('debug')('app');
 var HudView = require('views/hud');
 var bind = require('lib/bind');
-var dcf = require('lib/dcf');
 
 /**
  * Locals
  */
 
-var LOCATION_PROMPT_DELAY = constants.PROMPT_DELAY;
 var unbind = bind.unbind;
 
 // Mixin model methods
@@ -57,7 +52,6 @@ function App(options) {
   this.controllers = options.controllers;
   this.geolocation = options.geolocation;
   this.activity = options.activity;
-  this.config = options.config;
   this.settings = options.settings;
   this.storage = options.storage;
   this.camera = options.camera;
@@ -72,20 +66,15 @@ function App(options) {
  * @public
  */
 App.prototype.boot = function() {
-  if (this.didBoot) {
-    return;
-  }
-
+  if (this.didBoot) { return; }
   this.initializeViews();
   this.runControllers();
   this.injectViews();
   this.bindEvents();
-  this.miscStuff();
   this.configureL10n();
   this.emit('boot');
-  debug('booted');
-
   this.didBoot = true;
+  debug('booted');
 };
 
 App.prototype.teardown = function() {
@@ -118,6 +107,11 @@ App.prototype.runControllers = function() {
   debug('controllers run');
 };
 
+/**
+ * Initialize views.
+ *
+ * @private
+ */
 App.prototype.initializeViews = function() {
   debug('initializing views');
   this.views.viewfinder = new ViewfinderView();
@@ -129,6 +123,11 @@ App.prototype.initializeViews = function() {
   debug('views initialized');
 };
 
+/**
+ * Put views in the DOM.
+ *
+ * @private
+ */
 App.prototype.injectViews = function() {
   debug('injecting views');
   this.views.viewfinder.appendTo(this.el);
@@ -143,6 +142,7 @@ App.prototype.injectViews = function() {
 /**
  * Attaches event handlers.
  *
+ * @private
  */
 App.prototype.bindEvents = function() {
   this.storage.once('checked:healthy', this.geolocationWatch);
@@ -151,8 +151,6 @@ App.prototype.bindEvents = function() {
   bind(this.el, 'click', this.onClick);
   this.on('focus', this.onFocus);
   this.on('blur', this.onBlur);
-  this.on('previewgallery:opened', lockscreen.enableTimeout);
-  this.on('previewgallery:closed', lockscreen.disableTimeout);
   debug('events bound');
 };
 
@@ -176,8 +174,7 @@ App.prototype.unbindEvents = function() {
  * app was minimised
  */
 App.prototype.onFocus = function() {
-  var ms = LOCATION_PROMPT_DELAY;
-  setTimeout(this.geolocationWatch, ms);
+  this.geolocationWatch();
   this.storage.check();
   orientation.start();
   debug('focus');
@@ -200,18 +197,19 @@ App.prototype.onClick = function() {
 };
 
 /**
- * Begins watching location
- * if not within a pending
- * activity and the app
- * isn't currently hidden.
+ * Begins watching location if not within
+ * a pending activity and the app isn't
+ * currently hidden.
+ *
+ * Watching is delayed by the `promptDelay`
+ * defined in settings.
  *
+ * @private
  */
 App.prototype.geolocationWatch = function() {
+  var delay = this.settings.geolocation.get('promptDelay');
   var shouldWatch = !this.activity.active && !this.doc.hidden;
-  if (shouldWatch) {
-    this.geolocation.watch();
-    debug('geolocation watched');
-  }
+  if (shouldWatch) { setTimeout(this.geolocation.watch, delay); }
 };
 
 /**
@@ -234,7 +232,7 @@ App.prototype.onVisibilityChange = function() {
  * @private
  */
 App.prototype.onBeforeUnload = function() {
-  this.views.viewfinder.setPreviewStream(null);
+  this.views.viewfinder.stopStream();
   this.emit('beforeunload');
   debug('beforeunload');
 };
@@ -256,43 +254,4 @@ App.prototype.configureL10n = function() {
   if (complete) { this.emit('localized'); }
 };
 
-/**
- * Miscalaneous tasks to be
- * run when the app first
- * starts.
- *
- * TODO: Eventually this function
- * will be removed, and all this
- * logic will sit in specific places.
- *
- */
-App.prototype.miscStuff = function() {
-  var camera = this.camera;
-  var focusTimeout;
-  var self = this;
-
-  // TODO: Should probably be
-  // moved to a focusRing controller
-  camera.on('change:focus', function(value) {
-    self.views.focusRing.setState(value);
-    clearTimeout(focusTimeout);
-
-    if (value === 'fail') {
-      focusTimeout = setTimeout(function() {
-        self.views.focusRing.setState(null);
-      }, 1000);
-    }
-  });
-
-
-  dcf.init();
-  performanceTesting.dispatch('initialising-camera-preview');
-
-  // Prevent the phone
-  // from going to sleep.
-  lockscreen.disableTimeout();
-
-  debug('misc stuff done');
-};
-
 });
diff --git a/apps/camera/js/config/camera.js b/apps/camera/js/config/camera.js
index 328583407742..d539685afb1d 100644
--- a/apps/camera/js/config/camera.js
+++ b/apps/camera/js/config/camera.js
@@ -1,31 +1,16 @@
 define(function(require, exports, module) {
 'use strict';
 
+/**
+ * This file is @deprecated!
+ * Please use config/settings.js instead.
+ */
+
 /**
  * Exports
  */
 
 module.exports = {
-  CAMERA_MODE_TYPE: {
-    PICTURE: 'picture',
-    VIDEO: 'video'
-  },
-
-  STORAGE_STATE_TYPE: {
-    INIT: 0,
-    AVAILABLE: 1,
-    NOCARD: 2,
-    UNMOUNTED: 3,
-    CAPACITY: 4
-  },
-
-  FOCUS_MODE_TYPE: {
-    MANUALLY_TRIGGERED: 'auto',
-    CONTINUOUS_CAMERA: 'continuous-picture',
-    CONTINUOUS_VIDEO: 'continuous-video'
-  },
-
-  PROMPT_DELAY: 2000,
 
   // The minimum available disk space to start recording a video.
   RECORD_SPACE_MIN: 1024 * 1024 * 2,
diff --git a/apps/camera/js/config/settings.js b/apps/camera/js/config/settings.js
index a7954b8ce49a..3bf921b34372 100644
--- a/apps/camera/js/config/settings.js
+++ b/apps/camera/js/config/settings.js
@@ -17,6 +17,9 @@ module.exports = {
       healthy: 100
     }
   },
+  geolocation: {
+    promptDelay: 2000
+  },
   mode: {
     options: [
       {
diff --git a/apps/camera/js/controllers/camera.js b/apps/camera/js/controllers/camera.js
index 7bac07368d2c..4dc0ade300a0 100644
--- a/apps/camera/js/controllers/camera.js
+++ b/apps/camera/js/controllers/camera.js
@@ -15,7 +15,6 @@ var bindAll = require('lib/bind-all');
 exports = module.exports = function(app) { return new CameraController(app); };
 exports.CameraController = CameraController;
 
-
 /**
  * Initialize a new `CameraController`
  *
@@ -46,15 +45,14 @@ CameraController.prototype.bindEvents = function() {
   // don't have to depend directly on camera
   camera.on('change:videoElapsed', app.firer('camera:recorderTimeUpdate'));
   camera.on('change:capabilities', this.app.setter('capabilities'));
+  camera.on('change:focus', this.app.firer('camera:focuschanged'));
+  camera.on('filesizelimitreached', this.onFileSizeLimitReached);
   camera.on('configured', app.firer('camera:configured'));
   camera.on('change:recording', app.setter('recording'));
   camera.on('shutter', app.firer('camera:shutter'));
   camera.on('loaded', app.firer('camera:loaded'));
   camera.on('ready', app.firer('camera:ready'));
   camera.on('busy', app.firer('camera:busy'));
-
-  // Camera
-  camera.on('filesizelimitreached', this.onFileSizeLimitReached);
   camera.on('newimage', this.onNewImage);
   camera.on('newvideo', this.onNewVideo);
 
@@ -67,6 +65,7 @@ CameraController.prototype.bindEvents = function() {
   app.on('settings:configured', this.onSettingsConfigured);
   app.on('change:batteryStatus', this.onBatteryStatusChange);
 
+  // Settings
   settings.recorderProfiles.on('change:selected', this.onRecorderProfileChange);
   settings.pictureSizes.on('change:selected', this.onPictureSizeChange);
   settings.flashModes.on('change:selected', this.onFlashModeChange);
@@ -281,20 +280,10 @@ CameraController.prototype.setFlashMode = function() {
 };
 
 CameraController.prototype.onBlur = function() {
-  var recording = this.camera.get('recording');
-  var camera = this.camera;
-
-  if (recording) {
-    camera.stopRecording();
-  }
-
-  this.viewfinder.stopPreview();
-  camera.set('previewActive', false);
-  camera.set('focus', 'none');
-  camera.release();
-
-  this.viewfinder.setPreviewStream(null);
-
+  this.camera.stopRecording();
+  this.camera.set('previewActive', false);
+  this.camera.set('focus', 'none');
+  this.camera.release();
   debug('torn down');
 };
 
diff --git a/apps/camera/js/controllers/preview-gallery.js b/apps/camera/js/controllers/preview-gallery.js
index 114fc1fe6c45..4dc5ced094d4 100644
--- a/apps/camera/js/controllers/preview-gallery.js
+++ b/apps/camera/js/controllers/preview-gallery.js
@@ -24,9 +24,7 @@ var THUMBNAIL_HEIGHT = 54 * window.devicePixelRatio;
  * Exports
  */
 
-exports = module.exports = function(app) {
-  return new PreviewGalleryController(app);
-};
+module.exports = function(app) { return new PreviewGalleryController(app); };
 module.exports.PreviewGalleryController = PreviewGalleryController;
 
 function PreviewGalleryController(app) {
@@ -40,12 +38,10 @@ function PreviewGalleryController(app) {
 }
 
 PreviewGalleryController.prototype.bindEvents = function() {
+  this.storage.on('itemdeleted', this.onItemDeleted);
   this.app.on('preview', this.openPreview);
   this.app.on('newmedia', this.onNewMedia);
   this.app.on('blur', this.onBlur);
-
-  this.storage.on('itemdeleted', this.onItemDeleted);
-
   debug('events bound');
 };
 
@@ -77,6 +73,7 @@ PreviewGalleryController.prototype.openPreview = function() {
   this.view.set('secure-mode', secureMode);
   this.view.open();
 
+  this.app.set('previewGalleryOpen', true);
   this.previewItem();
 };
 
@@ -94,6 +91,8 @@ PreviewGalleryController.prototype.closePreview = function() {
     this.view.destroy();
     this.view = null;
   }
+
+  this.app.set('previewGalleryOpen', false);
   this.app.emit('previewgallery:closed');
 };
 
@@ -108,7 +107,7 @@ PreviewGalleryController.prototype.onGalleryButtonClick = function() {
   // The button shouldn't even be visible in this case, but
   // let's be really sure here.
   if (this.app.inSecureMode) { return; }
-  
+
   var MozActivity = window.MozActivity;
 
   // Launch the gallery with an activity
@@ -142,7 +141,7 @@ PreviewGalleryController.prototype.shareCurrentItem = function() {
 };
 
 /**
- * Delete the current item 
+ * Delete the current item
  * when the delete button is pressed.
  * @private
  */
diff --git a/apps/camera/js/controllers/viewfinder.js b/apps/camera/js/controllers/viewfinder.js
index ba41525019f3..a2306ae48f04 100644
--- a/apps/camera/js/controllers/viewfinder.js
+++ b/apps/camera/js/controllers/viewfinder.js
@@ -7,6 +7,7 @@ define(function(require, exports, module) {
 
 var debug = require('debug')('controller:viewfinder');
 var bindAll = require('lib/bind-all');
+
 /**
  * Exports
  */
@@ -27,71 +28,170 @@ function ViewfinderController(app) {
   this.activity = app.activity;
   this.settings = app.settings;
   this.viewfinder = app.views.viewfinder;
+  this.focusRing = app.views.focusRing;
   this.bindEvents();
   this.configure();
   debug('initialized');
 }
 
+/**
+ * Initial configuration.
+ *
+ * @private
+ */
 ViewfinderController.prototype.configure = function() {
   this.configureScaleType();
   this.configureGrid();
 };
 
+/**
+ * Configure the viewfinder scale type,
+ * aspect fill/fit, depending on setting.
+ *
+ * @private
+ */
 ViewfinderController.prototype.configureScaleType = function() {
   var scaleType = this.app.settings.viewfinder.get('scaleType');
   this.viewfinder.scaleType = scaleType;
   debug('set scale type: %s', scaleType);
 };
 
+/**
+ * Show/hide grid depending on currently
+ * selected option.
+ *
+ * @private
+ */
 ViewfinderController.prototype.configureGrid = function() {
   var grid = this.app.settings.grid.selected('key');
   this.viewfinder.set('grid', grid);
 };
 
+/**
+ * Hides the viewfinder frame-grid.
+ *
+ * @private
+ */
 ViewfinderController.prototype.hideGrid = function() {
   this.viewfinder.set('grid', 'off');
 };
 
+/**
+ * Bind to relavant events.
+ *
+ * @private
+ */
 ViewfinderController.prototype.bindEvents = function() {
   this.app.settings.grid.on('change:selected', this.viewfinder.setter('grid'));
   this.viewfinder.on('click', this.app.firer('viewfinder:click'));
   this.viewfinder.on('pinchChange', this.onPinchChange);
-  this.app.on('camera:configured', this.loadStream);
-  this.app.on('camera:configured', this.updatePreview);
+  this.camera.on('zoomchanged', this.onZoomChanged);
+  this.app.on('camera:focuschanged', this.focusRing.setState);
+  this.app.on('camera:configured', this.onCameraConfigured);
   this.app.on('camera:shutter', this.viewfinder.shutter);
-  this.app.on('settings:opened', this.hideGrid);
+  this.app.on('previewgallery:closed', this.startStream);
+  this.app.on('previewgallery:opened', this.stopStream);
   this.app.on('settings:closed', this.configureGrid);
-  this.camera.on('zoomChange', this.onZoomChange);
+  this.app.on('settings:opened', this.hideGrid);
+  this.app.on('blur', this.stopStream);
 };
 
-ViewfinderController.prototype.loadStream = function() {
+/**
+ * Perform required viewfinder configuration
+ * once the camera has configured.
+ *
+ * @private
+ */
+ViewfinderController.prototype.onCameraConfigured = function() {
+  this.startStream();
+  this.configurePreview();
+  this.configureZoom();
+
+  // BUG: We have to use a 300ms timeout here
+  // to conceal a Gecko rendering bug whereby the
+  // video element appears not to have painted the
+  // newly set dimensions before fading in.
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=982230
+  setTimeout(this.viewfinder.fadeIn, 300);
+};
+
+/**
+ * Start the viewfinder stream flowing
+ * with the current camera configuration.
+ *
+ * This indirectly enforces a screen wakelock,
+ * meaning the device is unable to go to sleep.
+ *
+ * We don't want the stream to start flowing if
+ * the preview-gallery is open, as this prevents
+ * the device falling asleep.
+ *
+ * @private
+ */
+ViewfinderController.prototype.startStream = function() {
+  if (this.app.get('previewGalleryOpen')) { return; }
   this.camera.loadStreamInto(this.viewfinder.els.video);
+  debug('stream started');
 };
 
-ViewfinderController.prototype.updatePreview = function() {
+/**
+ * Stop the preview stream flowing.
+ *
+ * This indirectly removes the wakelock
+ * that is magically enforced by the
+ * flowing camera stream. Meaning the
+ * device is able to go to sleep.
+ *
+ * @private
+ */
+ViewfinderController.prototype.stopStream = function() {
+  this.viewfinder.stopStream();
+  debug('stream stopped');
+};
+
+/**
+ * Configure the size and postion
+ * of the preview video stream.
+ *
+ * @private
+ */
+ViewfinderController.prototype.configurePreview = function() {
   var camera = this.app.settings.cameras.selected('key');
   var isFrontCamera = camera === 'front';
   var sensorAngle = this.camera.getSensorAngle();
-  this.viewfinder.updatePreview(this.camera.previewSize(), sensorAngle,
-                                isFrontCamera);
-
-  var enableZoom = this.camera.isZoomSupported() &&
-                   this.app.settings.zoom.enabled();
-  if (enableZoom) {
-    this.viewfinder.enableZoom(this.camera.getMinimumZoom(),
-                               this.camera.getMaximumZoom());
-  } else {
+  var previewSize = this.camera.previewSize();
+
+  this.viewfinder.updatePreview(previewSize, sensorAngle, isFrontCamera);
+};
+
+/**
+ * Configures the viewfinder
+ * to the current camera.
+ *
+ * @private
+ */
+ViewfinderController.prototype.configureZoom = function() {
+  var zoomSupported = this.camera.isZoomSupported();
+  var zoomEnabled = this.app.settings.zoom.enabled();
+  var enableZoom = zoomSupported && zoomEnabled;
+
+  if (!enableZoom) {
     this.viewfinder.disableZoom();
+    return;
   }
 
-  // BUG: We have to use a 300ms timeout here
-  // to conceal a Gecko rendering bug whereby the
-  // video element appears not to have painted the
-  // newly set dimensions before fading in.
-  // https://bugzilla.mozilla.org/show_bug.cgi?id=982230
-  setTimeout(this.viewfinder.fadeIn, 300);
+  var minimumZoom = this.camera.getMinimumZoom();
+  var maximumZoom = this.camera.getMaximumZoom();
+
+  this.viewfinder.enableZoom(minimumZoom, maximumZoom);
 };
 
+/**
+ * Updates the zoom level on the camera
+ * when the pinch changes.
+ *
+ * @private
+ */
 ViewfinderController.prototype.onPinchChange = function(zoom) {
   this.camera.setZoom(zoom);
 };
@@ -105,7 +205,7 @@ ViewfinderController.prototype.onPinchChange = function(zoom) {
  *
  * @param {Number} zoom
  */
-ViewfinderController.prototype.onZoomChange = function(zoom) {
+ViewfinderController.prototype.onZoomChanged = function(zoom) {
   var zoomPreviewAdjustment = this.camera.getZoomPreviewAdjustment();
   this.viewfinder.setZoomPreviewAdjustment(zoomPreviewAdjustment);
   this.viewfinder.setZoom(zoom);
diff --git a/apps/camera/js/controllers/zoom-bar.js b/apps/camera/js/controllers/zoom-bar.js
index 182ba63d2a6f..b4e9f18dfcee 100644
--- a/apps/camera/js/controllers/zoom-bar.js
+++ b/apps/camera/js/controllers/zoom-bar.js
@@ -32,7 +32,7 @@ function ZoomBarController(app) {
 
 ZoomBarController.prototype.bindEvents = function() {
   this.zoomBar.on('change', this.onChange);
-  this.camera.on('zoomChange', this.onZoomChange);
+  this.camera.on('zoomchanged', this.onZoomChanged);
   this.viewfinder.on('pinchStart', this.onPinchStart);
   this.viewfinder.on('pinchEnd', this.onPinchEnd);
 };
@@ -45,7 +45,7 @@ ZoomBarController.prototype.onChange = function(value) {
   this.camera.setZoom(zoom);
 };
 
-ZoomBarController.prototype.onZoomChange = function(zoom) {
+ZoomBarController.prototype.onZoomChanged = function(zoom) {
   var minimumZoom = this.camera.getMinimumZoom();
   var maximumZoom = this.camera.getMaximumZoom();
   var range = maximumZoom - minimumZoom;
diff --git a/apps/camera/js/lib/camera.js b/apps/camera/js/lib/camera.js
index e6e02e644d47..79cd82e839ec 100644
--- a/apps/camera/js/lib/camera.js
+++ b/apps/camera/js/lib/camera.js
@@ -64,6 +64,7 @@ function Camera(options) {
  * Plugs Video Stream into Video Element.
  *
  * @param  {Elmement} videoElement
+ * @public
  */
 Camera.prototype.loadStreamInto = function(videoElement) {
   debug('loading stream into element');
@@ -86,38 +87,96 @@ Camera.prototype.loadStreamInto = function(videoElement) {
   debug('stream loaded into video');
 };
 
-Camera.prototype.load = function() {
+/**
+ * Loads the currently selected camera.
+ *
+ * There are cases whereby the camera
+ * may still be 'releasing' its hardware.
+ * If this is the case we wait for the
+ * release process to finish, then attempt
+ * to load again.
+ *
+ * @public
+ */
+Camera.prototype.load = function(done) {
   debug('load camera');
 
-  // If hardware is still pending for release
-  // we're not allowed to request a new caemera
-  if (this.cameraReleasePending) {
-    debug('camera not loaded: hardware unavailable');
-    return;
-  }
   var selectedCamera = this.get('selectedCamera');
   var loadingNewCamera = selectedCamera !== this.lastLoadedCamera;
-  this.lastLoadedCamera = selectedCamera;
+  var self = this;
+
   this.emit('busy');
 
+  // If hardware is still being released
+  // we're not allowed to request the camera.
+  if (this.releasing) {
+    debug('wait for camera release');
+    this.once('released', function() { self.load(done); });
+    return;
+  }
+
+  // Don't re-load hardware if selected camera is the same
   if (this.mozCamera && !loadingNewCamera) {
-    this.gotCamera(this.mozCamera);
+    this.configureCamera(this.mozCamera);
+    debug('camera not changed');
+    done();
     return;
   }
 
-  // If a camera is already loaded,
-  // it must be 'released' first.
-  if (this.mozCamera) { this.release(this.requestCamera); }
-  else { this.requestCamera(); }
+  // If a camera is already loaded, it must be 'released' first.
+  if (this.mozCamera) {
+    this.release(ready);
+  } else {
+    ready();
+  }
+
+  function ready() {
+    self.requestCamera(selectedCamera, done);
+    self.lastLoadedCamera = selectedCamera;
+  }
 };
 
-Camera.prototype.requestCamera = function() {
-  var selectedCamera = this.get('selectedCamera');
-  navigator.mozCameras.getCamera(selectedCamera, {}, this.gotCamera);
+/**
+ * Requests the mozCamera object,
+ * then configures it.
+ *
+ * @param  {String}   camera  'front'|'back'
+ * @private
+ */
+Camera.prototype.requestCamera = function(camera, done) {
+  done = done || function() {};
+
+  var self = this;
+  navigator.mozCameras.getCamera(camera, {}, onSuccess, onError);
+
+  function onSuccess(mozCamera) {
+    debug('successfully got mozCamera');
+    self.configureCamera(mozCamera);
+    done();
+  }
+
+  function onError(err) {
+    debug('error requesting camera');
+    done(err);
+  }
+
+  debug('camera requested');
 };
 
-Camera.prototype.gotCamera = function(mozCamera) {
-  debug('got camera');
+/**
+ * Configures the newly recieved
+ * mozCamera object.
+ *
+ * Setting the 'cababilities' key
+ * triggers 'change' callback inside
+ * the CameraController that sets the
+ * app up for the new camera.
+ *
+ * @param  {MozCamera} mozCamera
+ * @private
+ */
+Camera.prototype.configureCamera = function(mozCamera) {
+  debug('configuring camera');
   var capabilities = mozCamera.capabilities;
   this.mozCamera = mozCamera;
   this.mozCamera.onShutter = this.onShutter;
@@ -125,6 +184,7 @@ Camera.prototype.gotCamera = function(mozCamera) {
   this.mozCamera.onRecorderStateChange = this.onRecorderStateChange;
   this.configureFocus(capabilities.focusModes);
   this.set('capabilities', this.formatCapabilities(capabilities));
+  debug('configured camera');
 };
 
 Camera.prototype.formatCapabilities = function(capabilities) {
@@ -229,37 +289,31 @@ Camera.prototype.setFlashMode = function(key) {
  */
 Camera.prototype.release = function(done) {
   done = done || function() {};
+  var self = this;
 
+  // Ignore if there is no loaded camera
   if (!this.mozCamera) {
     done();
     return;
   }
 
-  var self = this;
   // The hardware is not available during
   // the release process
-  this.cameraReleasePending = true;
   this.mozCamera.release(onSuccess, onError);
+  this.releasing = true;
   this.mozCamera = null;
 
   function onSuccess() {
-    self.cameraReleasePending = false;
-    // If the app is in foreground it reloads the camera
-    // This is needed in case the user exits and enters
-    // the application quickly. We have to wait until
-    // the previous camera has been released to request
-    // a new one.
-    if(!document.hidden) {
-      self.load();
-    }
+    self.releasing = false;
+    self.emit('released');
     debug('successfully released');
     done();
   }
 
-  function onError() {
-    self.cameraReleasePending = false;
+  function onError(err) {
     debug('failed to release hardware');
-    done();
+    self.releasing = false;
+    done(err);
   }
 };
 
@@ -836,7 +890,7 @@ Camera.prototype.getZoom = function() {
 
 Camera.prototype.setZoom = function(zoom) {
   this.mozCamera.zoom = zoom;
-  this.emit('zoomChange', zoom);
+  this.emit('zoomchanged', zoom);
 };
 
 Camera.prototype.getZoomPreviewAdjustment = function() {
diff --git a/apps/camera/js/lib/dcf.js b/apps/camera/js/lib/dcf.js
index c3ad9bffdb67..c5e07f8389e2 100644
--- a/apps/camera/js/lib/dcf.js
+++ b/apps/camera/js/lib/dcf.js
@@ -10,6 +10,7 @@ define(function(require, exports, module) {
  */
 
 var asyncStorage = require('asyncStorage');
+var debug = require('debug')('dcf');
 var format = require('format');
 
 /**
@@ -28,6 +29,7 @@ var dcfConfig = {
 };
 
 exports.init = function() {
+  debug('initializing');
   asyncStorage.getItem(dcfConfig.key, function(value) {
     dcfConfigLoaded = true;
     dcfConfig.seq = value ? value : defaultSeq;
@@ -39,6 +41,8 @@ exports.init = function() {
       exports.createDCFFilename(args.storage, args.type, args.callback);
       deferredArgs = null;
     }
+
+    debug('initialized');
   });
 };
 
diff --git a/apps/camera/js/lib/geo-location.js b/apps/camera/js/lib/geo-location.js
index c79a2f7d02e3..c36afce584e1 100644
--- a/apps/camera/js/lib/geo-location.js
+++ b/apps/camera/js/lib/geo-location.js
@@ -1,6 +1,12 @@
 define(function(require, exports, module) {
 'use strict';
 
+/**
+ * Dependencies
+ */
+
+var debug = require('debug')('geolocation');
+
 /**
  * Locals
  */
@@ -29,10 +35,12 @@ function GeoLocation() {
 /**
  * Watches device location.
  *
+ * @public
  */
 GeoLocation.prototype.watch = function() {
   if (!this.watcher) {
     this.watcher = geolocation.watchPosition(this.setPosition);
+    debug('started watching');
   }
 };
 
@@ -40,16 +48,19 @@ GeoLocation.prototype.watch = function() {
  * Stops watching
  * device location.
  *
+ * @public
  */
 GeoLocation.prototype.stopWatching = function() {
   geolocation.clearWatch(this.watcher);
   this.watcher = null;
+  debug('stopped watching');
 };
 
 /**
  * Updates the stored
  * position object.
  *
+ * @private
  */
 GeoLocation.prototype.setPosition = function(position) {
   this.position = {
diff --git a/apps/camera/js/lib/lock-screen.js b/apps/camera/js/lib/lock-screen.js
deleted file mode 100644
index 0d0148b5016f..000000000000
--- a/apps/camera/js/lib/lock-screen.js
+++ /dev/null
@@ -1,35 +0,0 @@
-define(function(require, exports, module) {
-'use strict';
-
-/**
- * Locals
- */
-
-var screenLock;
-
-/**
- * Stops the device
- * from going to sleep.
- *
- */
-exports.disableTimeout = function() {
-  if (!screenLock) {
-    screenLock = navigator.requestWakeLock('screen');
-  }
-};
-
-/**
- * Removes the wake lock
- * meaning the device will
- * once again sleep after
- * usual timeout.
- *
- */
-exports.enableTimeout = function() {
-  if (screenLock) {
-    screenLock.unlock();
-    screenLock = null;
-  }
-};
-
-});
diff --git a/apps/camera/js/lib/storage.js b/apps/camera/js/lib/storage.js
index 6638e8a57a00..e04b2e4d926f 100644
--- a/apps/camera/js/lib/storage.js
+++ b/apps/camera/js/lib/storage.js
@@ -5,9 +5,15 @@ define(function(require, exports, module) {
  * Dependencies
  */
 
-var createFilename = require('lib/dcf').createDCFFilename;
 var debug = require('debug')('storage');
 var events = require('vendor/evt');
+var dcf = require('lib/dcf');
+
+/**
+ * Locals
+ */
+
+var createFilename = dcf.createDCFFilename;
 
 /**
  * Expose `Storage`
@@ -26,6 +32,7 @@ function Storage() {
   this.image = navigator.getDeviceStorage('pictures');
   this.image.addEventListener('change', this.onStorageChange);
   this.createVideoFilepath = this.createVideoFilepath.bind(this);
+  dcf.init();
   debug('initialized');
 }
 
diff --git a/apps/camera/js/views/viewfinder.js b/apps/camera/js/views/viewfinder.js
index 31985313323e..dd0dea360ba4 100644
--- a/apps/camera/js/views/viewfinder.js
+++ b/apps/camera/js/views/viewfinder.js
@@ -169,7 +169,7 @@ module.exports = View.extend({
    * pinch-to-zoom gestures can correctly adjust the current zoom
    * level in the event that the zoom level is changed outside of
    * the pinch-to-zoom gesture (e.g.: ZoomBar). This gets called
-   * when the `Camera` emits a `zoomChange` event.
+   * when the `Camera` emits a `zoomchanged` event.
    */
   setZoom: function(zoom) {
     if (!isZoomEnabled) {
@@ -182,28 +182,15 @@ module.exports = View.extend({
   /**
    * Adjust the scale of the <video/> tag to compensate for the inability
    * of the Camera API to zoom the preview stream beyond a certain point.
-   * This gets called when the `Camera` emits a `zoomChange` event and is
+   * This gets called when the `Camera` emits a `zoomchanged` event and is
    * calculated by `Camera.prototype.getZoomPreviewAdjustment()`.
    */
   setZoomPreviewAdjustment: function(zoomPreviewAdjustment) {
     this.els.video.style.transform = 'scale(' + zoomPreviewAdjustment + ')';
   },
 
-  setPreviewStream: function(previewStream) {
-    this.els.video.mozSrcObject = previewStream;
-  },
-
-  setStream: function(stream, done) {
-    this.setPreviewStream(stream);
-    this.startPreview();
-  },
-
-  startPreview: function() {
-    this.els.video.play();
-  },
-
-  stopPreview: function() {
-    this.els.video.pause();
+  stopStream: function() {
+    this.els.video.mozSrcObject = null;
   },
 
   fadeOut: function(done) {
diff --git a/apps/camera/test/unit/app_test.js b/apps/camera/test/unit/app_test.js
index 52c651f5b659..cf7b689b3928 100644
--- a/apps/camera/test/unit/app_test.js
+++ b/apps/camera/test/unit/app_test.js
@@ -2,21 +2,25 @@
 'use strict';
 
 suite('app', function() {
-  var modules = {};
-
   suiteSetup(function(done) {
+    var self = this;
+
     req([
       'app',
       'lib/camera',
       'vendor/view',
       'lib/geo-location',
-      'lib/activity'
-    ], function(App, Camera, View, GeoLocation, Activity) {
-      modules.app = App;
-      modules.view = View;
-      modules.camera = Camera;
-      modules.geolocation = GeoLocation;
-      modules.activity = Activity;
+      'lib/activity',
+      'lib/storage',
+      'lib/setting',
+    ], function(App, Camera, View, GeoLocation, Activity, Storage, Setting) {
+      self.App = App;
+      self.View = View;
+      self.Camera = Camera;
+      self.Geolocation = GeoLocation;
+      self.Activity = Activity;
+      self.Storage = Storage;
+      self.Setting = Setting;
       done();
     });
   });
@@ -39,12 +43,6 @@ suite('app', function() {
   };
 
   setup(function() {
-    var GeoLocation = modules.geolocation;
-    var Activity = modules.activity;
-    var Camera = modules.camera;
-    var View = modules.view;
-    var App = modules.app;
-
     if (!navigator.mozCameras) {
       navigator.mozCameras = {
         getListOfCameras: function() { return []; },
@@ -59,18 +57,19 @@ suite('app', function() {
       doc: mocks.doc(),
       win: mocks.win(),
       el: document.createElement('div'),
-      geolocation: new GeoLocation(),
-      activity: new Activity(),
-      camera: new Camera(),
+      geolocation: sinon.createStubInstance(this.Geolocation),
+      activity: new this.Activity(),
+      camera: sinon.createStubInstance(this.Camera),
       sounds: {},
-      storage: {
-        once: sinon.spy()
+      storage: sinon.createStubInstance(this.Storage),
+      settings: {
+        geolocation: sinon.createStubInstance(this.Setting)
       },
       views: {
-        viewfinder: new View({ name: 'viewfinder' }),
-        focusRing: new View({ name: 'focus-ring' }),
-        controls: new View({ name: 'controls' }),
-        hud: new View({ name: 'hud' })
+        viewfinder: new this.View({ name: 'viewfinder' }),
+        focusRing: new this.View({ name: 'focus-ring' }),
+        controls: new this.View({ name: 'controls' }),
+        hud: new this.View({ name: 'hud' })
       },
       controllers: {
         hud: sinon.spy(),
@@ -94,21 +93,23 @@ suite('app', function() {
     // Sandbox to put all our stubs in
     this.sandbox = sinon.sandbox.create();
 
+    // Sinon take over setTimeout
+    this.clock = sinon.useFakeTimers();
+
     // Stub out all methods
-    this.sandbox.stub(options.camera);
     this.sandbox.stub(options.activity);
-    this.sandbox.stub(options.geolocation);
     this.sandbox.stub(options.viewfinder);
     this.sandbox.stub(options.focusRing);
     this.sandbox.stub(options.hud);
 
     // More complex stubs
     options.activity.check.callsArg(0);
-    this.sandbox.stub(App.prototype, 'miscStuff');
-    this.sandbox.spy(App.prototype, 'boot');
+    this.sandbox.spy(this.App.prototype, 'boot');
 
     // Create the app
-    this.app = new App(options);
+    this.app = new this.App(options);
+
+    this.sandbox.spy(this.app, 'on');
     this.sandbox.spy(this.app, 'set');
     this.sandbox.spy(this.app, 'emit');
     this.sandbox.spy(this.app, 'firer');
@@ -116,6 +117,7 @@ suite('app', function() {
 
   teardown(function() {
     this.sandbox.restore();
+    this.clock.restore();
     delete navigator.mozCameras;
   });
 
@@ -141,21 +143,22 @@ suite('app', function() {
 
       // need to `new App()` again here (and disregard `this.app`)
       // because we have changed the option mock.
-      var App = modules.app;
-      var app = new App(options);
+      var app = new this.App(options);
 
       assert.ok(app.inSecureMode === true);
     });
   });
 
   suite('App#boot()', function() {
+    setup(function() {
+      this.app.boot();
+    });
+
     test('Should run each of the controllers,' +
          'passing itself as first argument', function() {
       var controllers = this.app.controllers;
       var app = this.app;
 
-      this.app.boot();
-
       assert.ok(controllers.hud.calledWith(app));
       assert.ok(controllers.controls.calledWith(app));
       assert.ok(controllers.viewfinder.calledWith(app));
@@ -169,8 +172,6 @@ suite('app', function() {
     test('Should put each of the views into the root element', function() {
       var el = this.app.el;
 
-      this.app.boot();
-
       assert.ok(el.querySelector('.viewfinder'));
       assert.ok(el.querySelector('.focus-ring'));
       assert.ok(el.querySelector('.controls'));
@@ -178,7 +179,6 @@ suite('app', function() {
     });
 
     test('Should bind to `visibilitychange` event', function() {
-      this.app.boot();
       var call = this.app.doc.addEventListener.getCall(0);
       assert.ok(call.args[0] === 'visibilitychange');
       assert.ok(typeof call.args[1] === 'function');
@@ -186,7 +186,6 @@ suite('app', function() {
 
     test('Should bind to `beforeunload` event', function() {
       var addEventListener = this.app.win.addEventListener;
-      this.app.boot();
       assert.ok(addEventListener.calledWith('beforeunload', this.app.onBeforeUnload));
     });
 
@@ -195,54 +194,80 @@ suite('app', function() {
       var controls = this.app.controllers.controls;
       var camera = this.app.controllers.camera;
 
-      this.app.boot();
-
       assert.isTrue(activity.calledBefore(controls));
       assert.isTrue(activity.calledBefore(camera));
     });
 
-    suite('app.geolocation', function() {
-      test('Should watch location only once storage confirmed healthy',
-      function() {
-        var geolocationWatch = this.app.geolocationWatch;
-        var storage = this.app.storage;
-        this.app.boot();
-        assert.ok(storage.once.calledWith('checked:healthy', geolocationWatch));
+    test('Should watch location only once storage confirmed healthy', function() {
+      var geolocationWatch = this.app.geolocationWatch;
+      var storage = this.app.storage;
+      assert.ok(storage.once.calledWith('checked:healthy', geolocationWatch));
+    });
+
+    suite('App#geolocationWatch()', function() {
+      setup(function() {
+        this.options.settings.geolocation.get
+          .withArgs('promptDelay')
+          .returns(2000);
       });
 
-      test('Should *not* watch location if not in activity', function() {
-        var geolocation = this.app.geolocation;
+      test('Should watch geolocation after given delay', function() {
+        this.app.geolocationWatch();
 
+        assert.isFalse(this.app.geolocation.watch.called);
+        this.clock.tick(2000);
+
+        assert.isTrue(this.app.geolocation.watch.called);
+      });
+
+      test('Should *not* watch location if not in activity', function() {
         this.app.doc.hidden = false;
         this.app.activity.active = true;
+
         this.app.geolocationWatch();
+        this.clock.tick(2000);
 
-        assert.ok(geolocation.watch.notCalled);
+        assert.isFalse(this.app.geolocation.watch.called);
       });
 
       test('Should *not* watch location if app hidden', function() {
-        var geolocation = this.app.geolocation;
-
         this.app.doc.hidden = true;
         this.app.activity.active = false;
+
         this.app.geolocationWatch();
+        this.clock.tick(2000);
 
-        assert.ok(geolocation.watch.notCalled);
+        assert.isFalse(this.app.geolocation.watch.called);
       });
     });
   });
 
   suite('App#onBlur', function() {
-    test('Should stop watching location', function() {
-      var geolocation = this.app.geolocation;
+    setup(function() {
       this.app.onBlur();
-      assert.ok(geolocation.stopWatching.called);
+    });
+
+    test('Should stop watching location', function() {
+      assert.ok(this.app.geolocation.stopWatching.called);
     });
 
     test('Should stop cancel any pending activity', function() {
-      var activity = this.app.activity;
-      this.app.onBlur();
-      assert.ok(activity.cancel.called);
+      assert.ok(this.app.activity.cancel.called);
+    });
+  });
+
+  suite('App#onFocus()', function() {
+    setup(function() {
+      sinon.spy(this.app, 'geolocationWatch');
+      this.app.onFocus();
+    });
+
+    test('Should run a storage check', function() {
+      assert.ok(this.app.storage.check.called);
+    });
+
+    test('Should begin watching location again', function() {
+      assert.ok(this.app.geolocationWatch.called);
     });
   });
 
diff --git a/apps/camera/test/unit/controllers/camera_test.js b/apps/camera/test/unit/controllers/camera_test.js
index 713fccc1de7d..3a331e544bcc 100644
--- a/apps/camera/test/unit/controllers/camera_test.js
+++ b/apps/camera/test/unit/controllers/camera_test.js
@@ -82,25 +82,29 @@ suite('controllers/camera', function() {
     test('Should set the capture mode to \'picture\' by default', function() {
       this.app.settings.mode.selected.withArgs('key').returns('picture');
       this.controller = new this.CameraController(this.app);
-
       assert.isTrue(this.app.camera.setMode.called);
     });
 
     test('Should load camera on app `boot`', function() {
-      this.app.on.calledWith('boot', this.app.camera.load);
+      assert.isTrue(this.app.on.calledWith('boot', this.camera.load));
     });
 
     test('Should load camera on app `focus`', function() {
-      this.app.on.calledWith('focus', this.app.camera.load);
+      assert.isTrue(this.app.on.calledWith('focus', this.camera.load));
     });
 
     test('Should teardown camera on app `blur`', function() {
-      this.app.on.calledWith('blur', this.controller.onBlur);
+      assert.isTrue(this.app.on.calledWith('blur', this.controller.onBlur));
     });
 
     test('Should set the camera createVideoFilepath method', function() {
       assert.equal(this.camera.createVideoFilepath, this.app.storage.createVideoFilepath);
     });
+
+    test('Should relay focus change events', function() {
+      assert.isTrue(this.camera.on.calledWith('change:focus'));
+      assert.isTrue(this.app.firer.calledWith('camera:focuschanged'));
+    });
   });
 
   suite('CameraController#onSettingsConfigured()', function() {
@@ -310,23 +314,15 @@ suite('controllers/camera', function() {
   });
 
   suite('CameraController#onBlur()', function() {
-    test('Should stop recording if recording', function() {
-      this.app.get.withArgs('recording').returns(false);
-      this.controller.onBlur();
-      assert.isFalse(this.camera.stopRecording.called);
-
-      this.app.get.withArgs('recording').returns(true);
+    setup(function() {
       this.controller.onBlur();
-      assert.isFalse(this.camera.stopRecording.called);
     });
 
-    test('Should stop viewfinder preview', function() {
-      this.controller.onBlur();
-      assert.isTrue(this.viewfinder.stopPreview.called);
+    test('Should stop recording if recording', function() {
+      assert.isTrue(this.camera.stopRecording.called);
     });
 
     test('Should release the camera hardware', function() {
-      this.controller.onBlur();
       assert.isTrue(this.camera.release.called);
     });
   });
diff --git a/apps/camera/test/unit/controllers/preview-gallery_test.js b/apps/camera/test/unit/controllers/preview-gallery_test.js
index a40bc08a18eb..af82d1ffb602 100644
--- a/apps/camera/test/unit/controllers/preview-gallery_test.js
+++ b/apps/camera/test/unit/controllers/preview-gallery_test.js
@@ -43,12 +43,15 @@ suite('controllers/preview-gallery', function() {
     this.app.storage.video.delete.withArgs('root/fileName').returns({});
     this.app.settings = sinon.createStubInstance(this.Settings);
 
+    this.app.activity = {};
+
     // Our test instance
     this.previewGalleryController = new this.PreviewGalleryController(this.app);
 
     // For convenience
     this.camera = this.app.camera;
     this.previewGallery = this.previewGalleryController.view;
+    this.controller = this.previewGalleryController;
     this.storage = this.app.storage;
   });
 
@@ -237,4 +240,25 @@ suite('controllers/preview-gallery', function() {
       assert.ok(this.previewGalleryController.configure.called);
     });
   });
+
+  suite('PreviewGalleryController#openPreview()', function() {
+    setup(function() {
+      sinon.stub(this.controller, 'previewItem');
+      this.controller.openPreview();
+    });
+
+    test('Should set `previewGalleryOpen` to `true` on app', function() {
+      assert.isTrue(this.app.set.calledWith('previewGalleryOpen', true));
+    });
+  });
+
+  suite('PreviewGalleryController#closePreview()', function() {
+    setup(function() {
+      this.controller.closePreview();
+    });
+
+    test('Should set `previewGalleryOpen` to `false` on app', function() {
+      assert.isTrue(this.app.set.calledWith('previewGalleryOpen', false));
+    });
+  });
 });
diff --git a/apps/camera/test/unit/controllers/viewfinder_test.js b/apps/camera/test/unit/controllers/viewfinder_test.js
index 65bdef064091..6a037e86d041 100644
--- a/apps/camera/test/unit/controllers/viewfinder_test.js
+++ b/apps/camera/test/unit/controllers/viewfinder_test.js
@@ -10,14 +10,16 @@ suite('controllers/viewfinder', function() {
       'lib/camera',
       'controllers/viewfinder',
       'views/viewfinder',
+      'views/focus-ring',
       'lib/activity',
       'lib/settings',
       'lib/setting'
     ], function(
-      App, Camera, ViewfinderController,
-      ViewfinderView, Activity, Settings, Setting) {
+      App, Camera, ViewfinderController, ViewfinderView,
+      FocusRingView, Activity, Settings, Setting) {
       self.ViewfinderController = ViewfinderController.ViewfinderController;
       self.ViewfinderView = ViewfinderView;
+      self.FocusRingView = FocusRingView;
       self.Settings = Settings;
       self.Setting = Setting;
       self.Activity = Activity;
@@ -34,16 +36,158 @@ suite('controllers/viewfinder', function() {
     this.app.settings = sinon.createStubInstance(this.Settings);
     this.app.settings.grid = sinon.createStubInstance(this.Setting);
     this.app.views = {
-      viewfinder: sinon.createStubInstance(this.ViewfinderView)
+      viewfinder: sinon.createStubInstance(this.ViewfinderView),
+      focusRing: sinon.createStubInstance(this.FocusRingView),
     };
 
+    // Fake elements
+    this.app.views.viewfinder.els = { video: {} };
+
     // Settings
     this.app.settings = sinon.createStubInstance(this.Settings);
     this.app.settings.grid = sinon.createStubInstance(this.Setting);
     this.app.settings.viewfinder = sinon.createStubInstance(this.Setting);
+    this.app.settings.cameras = sinon.createStubInstance(this.Setting);
+    this.app.settings.zoom = sinon.createStubInstance(this.Setting);
+
+    // Default return values
+    this.app.settings.viewfinder.get.withArgs('scaleType').returns('fill');
+    this.app.settings.grid.selected.withArgs('key').returns('off');
 
     // Shortcuts
     this.viewfinder = this.app.views.viewfinder;
+    this.focusRing = this.app.views.focusRing;
+    this.settings = this.app.settings;
+    this.camera = this.app.camera;
+
+    // Test instance
+    this.controller = new this.ViewfinderController(this.app);
+  });
+
+  suite('ViewfinderController()', function() {
+    test('Should stop the stream when the PreviewGallery is opened', function() {
+      assert.isTrue(this.app.on.calledWith('previewgallery:opened', this.controller.stopStream));
+    });
+
+    test('Should start the stream when the PreviewGallery is closed', function() {
+      assert.isTrue(this.app.on.calledWith('previewgallery:closed', this.controller.startStream));
+    });
+
+    test('Should stop the stream when on app blur', function() {
+      assert.isTrue(this.app.on.calledWith('blur', this.controller.stopStream));
+    });
+
+    test('Should hide the grid when the settings menu opened', function() {
+      assert.isTrue(this.app.on.calledWith('settings:opened', this.controller.hideGrid));
+    });
+
+    test('Should show the grid again when the settings menu is closed', function() {
+      assert.isTrue(this.app.on.calledWith('settings:closed', this.controller.configureGrid));
+    });
+
+    test('Should flash viewfinder shutter when camera shutter fires', function() {
+      assert.isTrue(this.app.on.calledWith('camera:shutter', this.viewfinder.shutter));
+    });
+
+    test('Should respond to `zoomchanged` event', function() {
+      assert.isTrue(this.camera.on.calledWith('zoomchanged'));
+    });
+
+    test('Should should set the foucsRing state when focus changes', function() {
+      assert.isTrue(this.app.on.calledWith('camera:focuschanged', this.focusRing.setState));
+    });
+
+    test('Should set the scaleType on the view', function() {
+      assert.equal(this.viewfinder.scaleType, 'fill');
+    });
+
+    test('Should set grid on/off', function() {
+      assert.isTrue(this.viewfinder.set.calledWith('grid', 'off'));
+      this.app.settings.grid.selected.withArgs('key').returns('on');
+      this.viewfinder.set.reset();
+
+      this.controller = new this.ViewfinderController(this.app);
+      assert.isTrue(this.viewfinder.set.calledWith('grid', 'on'));
+    });
+  });
+
+  suite('ViewfinderController#startStream()', function() {
+    test('Should load preview stream into viewfinder video element', function() {
+      var video = this.viewfinder.els.video;
+      this.controller.startStream();
+      assert.isTrue(this.camera.loadStreamInto.calledWith(video));
+    });
+
+    test('Should not `loadStreamInto` if preview-gallery is open', function() {
+      this.app.get.withArgs('previewGalleryOpen').returns(true);
+      this.controller.startStream();
+      assert.isFalse(this.camera.loadStreamInto.called);
+    });
+  });
+
+  suite('ViewfinderController#configurePreview()', function() {
+    setup(function() {
+      this.settings.cameras.selected.withArgs('key').returns('back');
+      this.camera.getSensorAngle.returns(90);
+      this.camera.previewSize.returns({ width: 400, height: 300 });
+    });
+
+    test('Should pass current previewSize', function() {
+      this.controller.configurePreview();
+      var previewSize = this.viewfinder.updatePreview.args[0][0];
+      assert.deepEqual(previewSize, { width: 400, height: 300 });
+    });
+
+    test('Should pass the sensor angle', function() {
+      this.controller.configurePreview();
+      var arg = this.viewfinder.updatePreview.args[0][1];
+      assert.equal(arg, 90);
+    });
+
+    test('Should indicate if selected camera is front', function() {
+      var arg;
+
+      // Back
+      this.controller.configurePreview();
+      arg = this.viewfinder.updatePreview.args[0][2];
+      assert.equal(arg, false);
+      this.viewfinder.updatePreview.reset();
+
+      // Front
+      this.settings.cameras.selected.withArgs('key').returns('front');
+      this.controller.configurePreview();
+      arg = this.viewfinder.updatePreview.args[0][2];
+      assert.equal(arg, true);
+    });
+  });
+
+  suite('ViewfinderController#configureZoom()', function() {
+    setup(function() {
+      this.camera.isZoomSupported.returns(true);
+      this.settings.zoom.enabled.returns(true);
+
+      this.camera.getMinimumZoom.returns(0);
+      this.camera.getMaximumZoom.returns(3);
+    });
+
+    test('Should call enableZoom on the viewfinder', function() {
+      this.controller.configureZoom();
+      assert.isTrue(this.viewfinder.enableZoom.calledWith(0, 3));
+    });
+
+    test('Should disable zoom if camera doesn\'t support zoom', function() {
+      this.camera.isZoomSupported.returns(false);
+
+      this.controller.configureZoom();
+      assert.isTrue(this.viewfinder.disableZoom.called);
+    });
+
+    test('Should disable zoom if zoom disabled in settings', function() {
+      this.settings.zoom.enabled.returns(false);
+
+      this.controller.configureZoom();
+      assert.isTrue(this.viewfinder.disableZoom.called);
+    });
   });
 
   suite('click:viewfinder', function() {
diff --git a/apps/camera/test/unit/lib/camera_test.js b/apps/camera/test/unit/lib/camera_test.js
index 1fa8a89527e6..b6038eb986c3 100644
--- a/apps/camera/test/unit/lib/camera_test.js
+++ b/apps/camera/test/unit/lib/camera_test.js
@@ -1,4 +1,4 @@
-suite('camera', function() {
+suite('lib/camera', function() {
   'use strict';
   var require = window.req;
 
@@ -11,18 +11,32 @@ suite('camera', function() {
   });
 
   setup(function() {
-    var mozCameras = { getListOfCameras: function() {} };
+    var mozCameras = {
+      getListOfCameras: function() {},
+      getCamera: function() {}
+    };
+
     if (!navigator.mozCameras) { navigator.mozCameras = mozCameras; }
-    if (!navigator.getDeviceStorage) {
-      navigator.getDeviceStorage = function() {};
-    }
-    sinon.stub(navigator, 'getDeviceStorage').returns({});
-    sinon.stub(navigator.mozCameras, 'getListOfCameras').returns([]);
+    if (!navigator.getDeviceStorage) { navigator.getDeviceStorage = function() {}; }
+
+    this.sandbox = sinon.sandbox.create();
+    this.sandbox.stub(navigator, 'getDeviceStorage').returns({});
+    this.sandbox.stub(navigator.mozCameras);
+
+    navigator.mozCameras.getListOfCameras.returns([]);
+
+    // Fake mozCamera
+    this.mozCamera = {
+      autoFocus: sinon.stub(),
+      release: sinon.stub()
+    };
+
+    this.camera = new this.Camera();
+    this.sandbox.stub(this.camera, 'emit');
   });
 
   teardown(function() {
-    navigator.mozCameras.getListOfCameras.restore();
-    navigator.getDeviceStorage.restore();
+    this.sandbox.restore();
   });
 
   suite('Camera#focus()', function() {
@@ -30,7 +44,7 @@ suite('camera', function() {
       this.camera = {
         autoFocus: {},
         set: sinon.spy(),
-        mozCamera: { autoFocus: sinon.stub() },
+        mozCamera: this.mozCamera,
         focus: this.Camera.prototype.focus,
         orientation: sinon.stub()
       };
@@ -326,7 +340,7 @@ suite('camera', function() {
         setHDR: this.Camera.prototype.setHDR,
         get: function() {}
       };
-      this.sandbox = sinon.sandbox.create();
+
       this.sandbox.stub(this.camera, 'get', function() {
         return {sceneModes: ['auto', 'hdr']};
       });
@@ -356,7 +370,7 @@ suite('camera', function() {
         setHDR: this.Camera.prototype.setHDR,
         get: function() {}
       };
-      this.sandbox = sinon.sandbox.create();
+
       this.sandbox.stub(this.camera, 'get', function() {
         return {sceneModes: ['auto', 'hdr']};
       });
@@ -480,4 +494,154 @@ suite('camera', function() {
       assert.ok(this.camera.emit.calledWith('ready'));
     });
   });
+
+  suite('Camera#load()', function() {
+    setup(function() {
+      var self = this;
+
+      this.camera = new this.Camera();
+
+      sinon.stub(this.camera, 'emit');
+      sinon.stub(this.camera, 'release').callsArg(0);
+      sinon.stub(this.camera, 'configureCamera');
+
+      sinon.stub(this.camera, 'requestCamera', function(camera, done) {
+        self.camera.mozCamera = self.mozCamera;
+        if (done) { done(); }
+      });
+
+      this.camera.set('selectedCamera', 'back');
+    });
+
+    test('Should emit a \'busy\' event', function() {
+      this.camera.load();
+      assert.isTrue(this.camera.emit.calledWith('busy'));
+    });
+
+    test('Should not request camera until camera has finished releasing', function() {
+      this.camera.releasing = true;
+      this.camera.load();
+
+      assert.isFalse(this.camera.requestCamera.called);
+
+      this.camera.releasing = false;
+      this.camera.fire('released');
+
+      assert.isTrue(this.camera.requestCamera.called);
+    });
+
+    test('Should `requestCamera` first time called', function() {
+      var callback = sinon.spy();
+      this.camera.load(callback);
+
+      assert.isTrue(this.camera.requestCamera.calledWith('back'));
+      assert.isFalse(this.camera.release.called);
+      assert.isTrue(callback.calledOnce);
+    });
+
+    test('Should `release` camera then `request` if selectedCamera changed', function() {
+      var requestCamera = this.camera.requestCamera;
+      var release = this.camera.release;
+      var callback = sinon.spy();
+
+      this.camera.load();
+      this.camera.set('selectedCamera', 'front');
+      this.camera.requestCamera.reset();
+
+      this.camera.load(callback);
+      assert.isTrue(release.calledBefore(requestCamera));
+      assert.isTrue(requestCamera.calledWith('front'));
+      assert.isTrue(callback.calledOnce);
+    });
+
+    test('Should just `configureCamera` if selected camera has\'t changed', function() {
+      var callback = sinon.spy();
+
+      this.camera.load();
+      this.camera.requestCamera.reset();
+
+      this.camera.load(callback);
+      assert.isTrue(this.camera.configureCamera.called);
+      assert.isFalse(this.camera.requestCamera.called);
+      assert.equal(callback.callCount, 1);
+    });
+  });
+
+  suite('Camera#requestCamera()', function() {
+    setup(function() {
+      this.camera = new this.Camera();
+      this.sandbox.stub(this.camera, 'configureCamera');
+      navigator.mozCameras.getCamera.callsArgWith(2, this.mozCamera);
+    });
+
+    test('Should call `navigator.mozCameras.getCamera()`', function() {
+      this.camera.requestCamera('back');
+      assert.isTrue(navigator.mozCameras.getCamera.called);
+    });
+
+    test('Should call .configureCamera', function() {
+      var callback = sinon.spy();
+      this.camera.requestCamera('back', callback);
+      assert.isTrue(this.camera.configureCamera.calledWith(this.mozCamera));
+    });
+
+    test('Should call the callback', function() {
+      var callback = sinon.spy();
+      this.camera.requestCamera('back', callback);
+      assert.isTrue(callback.called);
+    });
+
+    test('Should pass a single argument on error', function() {
+      var callback = sinon.spy();
+
+      // Simulate error callback
+      navigator.mozCameras.getCamera.restore();
+      this.sandbox.stub(navigator.mozCameras, 'getCamera').callsArgWith(3, 'error');
+
+      this.camera.requestCamera('back', callback);
+      assert.isTrue(callback.calledWith('error'));
+    });
+  });
+
+  suite('Camera#release()', function() {
+    setup(function() {
+      this.mozCamera.release.callsArgAsync(0);
+      this.camera.mozCamera = this.mozCamera;
+    });
+
+    test('Should flag as `releasing` until released', function(done) {
+      var self = this;
+
+      this.camera.release(function() {
+        assert.isFalse(self.camera.releasing);
+        done();
+      });
+
+      assert.isTrue(this.camera.releasing);
+    });
+
+    test('Should call the callback', function(done) {
+      this.camera.release(done);
+    });
+
+    test('Should emit \'released\' event', function(done) {
+      var self = this;
+      this.camera.release(function() {
+        assert.isTrue(self.camera.emit.called);
+        done();
+      });
+    });
+
+    test('Should call the callback with an error argument', function(done) {
+      var self = this;
+
+      this.mozCamera.release = sinon.stub();
+      this.mozCamera.release.callsArgWithAsync(1, 'error');
+
+      this.camera.release(function(err) {
+        assert.equal(err, 'error');
+        done();
+      });
+    });
+  });
 });
diff --git a/apps/camera/test/unit/lib/sounds_test.js b/apps/camera/test/unit/lib/sounds_test.js
index a9134d84427a..335a24436209 100644
--- a/apps/camera/test/unit/lib/sounds_test.js
+++ b/apps/camera/test/unit/lib/sounds_test.js
@@ -35,6 +35,7 @@ suite('Sounds', function() {
 
   setup(function() {
     this.sandbox = sinon.sandbox.create();
+    this.clock = sinon.useFakeTimers();
     this.sounds = new Sounds();
 
     // A sound to pass to APIs
@@ -54,6 +55,7 @@ suite('Sounds', function() {
   teardown(function() {
     navigator.mozSettings = this.backup.mozSettings;
     this.sandbox.restore();
+    this.clock.restore();
   });
 
   suite('Sounds()', function() {
@@ -100,6 +102,7 @@ suite('Sounds', function() {
 
   suite('Sounds#isEnabled()', function() {
     setup(function() {
+      var self = this;
 
       // Mock object that mimicks
       // mozSettings get API. Inside
@@ -117,7 +120,7 @@ suite('Sounds', function() {
                 result: result
               }
             });
-          }, 1);
+          });
           return this;
         }
       };
@@ -128,11 +131,14 @@ suite('Sounds', function() {
       this.sounds.isEnabled(this.mockSound);
     });
 
-    test('Should return the result from mozSettings API', function(done) {
+    test('Should return the result from mozSettings API', function() {
       this.sounds.isEnabled(this.mockSound, function(result) {
         assert.ok(result === 'the-result');
-        done();
       });
+
+      // Move time forwards
+      // so the callback fires
+      this.clock.tick(1);
     });
   });
 
diff --git a/apps/camera/test/unit/media_frame_test.js b/apps/camera/test/unit/media_frame_test.js
index 02ff40d2634b..e80c8ed8f427 100644
--- a/apps/camera/test/unit/media_frame_test.js
+++ b/apps/camera/test/unit/media_frame_test.js
@@ -10,6 +10,8 @@ suite('Media Frame Unit Tests', function() {
   var mockDeviceStorage = false;
 
   suiteSetup(function() {
+    this.clock = sinon.useFakeTimers();
+
     if (!navigator['getDeviceStorage']) {
       // create dummy getDeviceStorage for sinon overriding.
       navigator.getDeviceStorage = function() {};
@@ -18,6 +20,8 @@ suite('Media Frame Unit Tests', function() {
   });
 
   suiteTeardown(function() {
+    this.clock.restore();
+
     if (mockDeviceStorage) {
       delete navigator.getDeviceStorage;
     }
@@ -75,7 +79,7 @@ suite('Media Frame Unit Tests', function() {
       assert.isTrue(frame.displayingImage);
     });
 
-    test('=> displayImage preview file, get success', function(done) {
+    test('=> displayImage preview file, get success', function() {
       var preview = {
         'filename': 'dummyFilename',
         'width': 1000,
@@ -89,13 +93,12 @@ suite('Media Frame Unit Tests', function() {
           assert.equal(filename, 'dummyFilename');
           var retObj = {};
 
-          window.setTimeout(function() {
+          setTimeout(function() {
             retObj.result = new Blob(['empty-image'], {'type': 'image/jpeg'});
             retObj.onsuccess();
             assert.isTrue(frame.displayingPreview);
             assert.isTrue(frame.displayingImage);
             frame.reset();
-            done();
           });
 
           return retObj;
@@ -107,9 +110,13 @@ suite('Media Frame Unit Tests', function() {
       });
 
       frame.displayImage(dummyBlob, 1600, 1200, preview, 0, false);
+
+      // Move time forwards so
+      // stub callback fires
+      this.clock.tick(1);
     });
 
-    test('=> displayImage preview file, get error', function(done) {
+    test('=> displayImage preview file, get error', function() {
       var preview = {
         'filename': 'dummyFilename',
         'width': 1000,
@@ -123,13 +130,12 @@ suite('Media Frame Unit Tests', function() {
           assert.equal(filename, 'dummyFilename');
           var retObj = {};
 
-          window.setTimeout(function() {
+          setTimeout(function() {
             retObj.onerror();
             assert.isFalse(frame.displayingPreview);
             assert.isNull(frame.preview);
             assert.isTrue(frame.displayingImage);
             frame.reset();
-            done();
           });
 
           return retObj;
@@ -141,6 +147,10 @@ suite('Media Frame Unit Tests', function() {
       });
 
       frame.displayImage(dummyBlob, 1600, 1200, preview, 0, false);
+
+      // Move time forwards so
+      // stub callback fires
+      this.clock.tick(1);
     });
   });
 });