Merge pull request #131 from serratus/issue/128

Camera Facing Issue in Chrome >= 53

README.md

@@ -1,7 +1,7 @@
 quaggaJS
 ========
 
-- [Changelog](#changelog) (2016-08-15)
+- [Changelog](#changelog) (2016-10-03)
 - [Browser Support](#browser-support)
 - [Installing](#installing)
 - [Getting Started](#gettingstarted)
@@ -664,6 +664,10 @@ on the ``singleChannel`` flag in the configuration when using ``decodeSingle``.
 
 ## <a name="changelog">Changelog</a>
 
+### 2016-10-03
+- Fixes
+  - Fixed `facingMode` issue with Chrome >= 53 (see [#128](https://github.com/serratus/quaggaJS/issues/128))
+
 ### 2016-08-15
 - Features
   - Proper handling of EXIF orientation when using `Quagga.decodeSingle`

example/live_w_locator.js

@@ -97,9 +97,9 @@ $(function() {
                 constraints: function(value){
                     var values = value.split('x');
                     return {
-                        width: parseInt(values[0]),
-                        height: parseInt(values[1])
-                    }
+                        width: {min: parseInt(values[0])},
+                        height: {min: parseInt(values[1])}
+                    };
                 }
             },
             numOfWorkers: function(value) {
@@ -128,9 +128,10 @@ $(function() {
             inputStream: {
                 type : "LiveStream",
                 constraints: {
-                    width: 640,
-                    height: 480,
-                    facingMode: "environment"
+                    width: {min: 640},
+                    height: {min: 480},
+                    facingMode: "environment",
+                    aspectRatio: {min: 1, max: 2}
                 }
             },
             locator: {

karma-integration.conf.js

@@ -24,6 +24,7 @@ module.exports = function(config) {
             resolve: {
                 modules: [
                     path.resolve('./src/input/'),
+                    path.resolve('./src/common/'),
                     'node_modules'
                 ]
             },

karma.conf.js

@@ -29,6 +29,7 @@ module.exports = function(config) {
             resolve: {
                 modules: [
                     path.resolve('./src/input/'),
+                    path.resolve('./test/mocks/'),
                     'node_modules'
                 ]
             },

src/common/mediaDevices.js

@@ -0,0 +1,17 @@
+
+export function enumerateDevices() {
+    if (navigator.mediaDevices
+            && typeof navigator.mediaDevices.enumerateDevices === 'function') {
+        return navigator.mediaDevices.enumerateDevices();
+    }
+    return Promise.reject(new Error('enumerateDevices is not defined'));
+};
+
+export function getUserMedia(constraints) {
+    if (navigator.mediaDevices
+            && typeof navigator.mediaDevices.getUserMedia === 'function') {
+        return navigator.mediaDevices
+            .getUserMedia(constraints);
+    }
+    return Promise.reject(new Error('getUserMedia is not defined'));
+}

src/input/camera_access.js

@@ -1,4 +1,10 @@
-import {merge, pick} from 'lodash';
+import {omit, pick} from 'lodash';
+import {getUserMedia, enumerateDevices} from 'mediaDevices';
+
+const facingMatching = {
+    "user": /front/i,
+    "environment": /back/i
+};
 
 var streamRef;
 
@@ -32,10 +38,7 @@ function waitForVideo(video) {
  * @param {Object} video
  */
 function initCamera(video, constraints) {
-    if (navigator.mediaDevices
-            && typeof navigator.mediaDevices.getUserMedia === 'function') {
-        return navigator.mediaDevices
-            .getUserMedia(constraints)
+    return getUserMedia(constraints)
     .then((stream) => {
         return new Promise((resolve) => {
             streamRef = stream;
@@ -49,8 +52,6 @@ function initCamera(video, constraints) {
     })
     .then(waitForVideo.bind(null, video));
 }
-    return Promise.reject(new Error('getUserMedia is not defined'));
-}
 
 function deprecatedConstraints(videoConstraints) {
     const normalized = pick(videoConstraints, ["width", "height", "facingMode",
@@ -68,16 +69,50 @@ function deprecatedConstraints(videoConstraints) {
     return normalized;
 }
 
-function pickConstraints(videoConstraints) {
-    return {
+function pickDevice(constraints) {
+    const desiredFacing = constraints.video.facingMode,
+        facingMatch = facingMatching[desiredFacing];
+
+    if (!facingMatch) {
+        return Promise.resolve(constraints);
+    }
+    return enumerateDevices()
+    .then(devices => {
+        const selectedDeviceId = devices
+            .filter(device => device.kind === 'videoinput' && facingMatch.test(device.label))
+            .map(facingDevice => facingDevice.deviceId)[0];
+        if (selectedDeviceId) {
+            constraints = {
+                ...constraints,
+                video: {
+                    ...omit(constraints.video, ["facingMode"]),
+                    deviceId: selectedDeviceId,
+                }
+            };
+        }
+        return Promise.resolve(constraints);
+    });
+}
+
+export function pickConstraints(videoConstraints) {
+    const normalizedConstraints = {
         audio: false,
         video: deprecatedConstraints(videoConstraints)
     };
+
+    if (!normalizedConstraints.video.deviceId) {
+        if (typeof normalizedConstraints.video.facingMode === 'string'
+                && normalizedConstraints.video.facingMode.length > 0) {
+            return pickDevice(normalizedConstraints);
+        }
+    }
+    return Promise.resolve(normalizedConstraints);
 }
 
 export default {
     request: function(video, videoConstraints) {
-        return initCamera(video, pickConstraints(videoConstraints));
+        return pickConstraints(videoConstraints)
+            .then(initCamera.bind(null, video));
     },
     release: function() {
         var tracks = streamRef && streamRef.getVideoTracks();

test/mocks/mediaDevices.js

@@ -0,0 +1,36 @@
+
+let devices = [],
+    stream,
+    _constraints,
+    _supported = true;
+
+export function enumerateDevices() {
+    console.log("enumerateDevices!!!!");
+    return Promise.resolve(devices);
+};
+
+export function getUserMedia(constraints) {
+    console.log("getUserMedia!!!!");
+    _constraints = constraints;
+    if (_supported) {
+        return Promise.resolve(stream);
+    }
+    return Promise.reject(new Error("das"));
+}
+
+export function setDevices(newDevices) {
+    devices = [...newDevices];
+}
+
+export function setStream(newStream) {
+    stream = newStream;
+}
+
+export function getConstraints() {
+    return _constraints;
+}
+
+export function setSupported(supported) {
+    console.log("Supported: " + supported);
+    _supported = supported;
+}

test/spec/camera_access.spec.js

@@ -1,10 +1,13 @@
-import CameraAccess from '../../src/input/camera_access';
+import CameraAccess, {pickConstraints} from '../../src/input/camera_access';
+import {setDevices, setStream, getConstraints, setSupported} from 'mediaDevices';
 
 var originalURL,
     originalMediaStreamTrack,
     video,
-    stream;
+    stream,
+    devices = [];
 
+describe("camera_access", () => {
     beforeEach(function() {
         var tracks = [{
             stop: function() {}
@@ -24,6 +27,7 @@ beforeEach(function() {
                 return tracks;
             }
         };
+        setStream(stream);
         sinon.spy(tracks[0], "stop");
 
         video = {
@@ -47,20 +51,10 @@ afterEach(function() {
     });
 
     describe('success', function() {
-    beforeEach(function() {
-        sinon.stub(navigator.mediaDevices, "getUserMedia", function(constraints) {
-            return Promise.resolve(stream);
-        });
-    });
-
-    afterEach(function() {
-        navigator.mediaDevices.getUserMedia.restore();
-    });
         describe('request', function () {
             it('should request the camera', function (done) {
                 CameraAccess.request(video, {})
                 .then(function () {
-                expect(navigator.mediaDevices.getUserMedia.calledOnce).to.equal(true);
                     expect(video.srcObject).to.deep.equal(stream);
                     done();
                 })
@@ -75,16 +69,14 @@ describe('success', function() {
                     maxAspectRatio: 100
                 })
                 .then(function () {
-                const call = navigator.mediaDevices.getUserMedia.getCall(0),
-                    args = call.args;
-                expect(call).to.be.defined;
-                expect(args[0].video.width).to.equal(320);
-                expect(args[0].video.height).to.equal(240);
-                expect(args[0].video.facingMode).to.equal("user");
-                expect(args[0].video.aspectRatio).to.equal(2);
-                expect(args[0].video.facing).not.to.be.defined;
-                expect(args[0].video.minAspectRatio).not.to.be.defined;
-                expect(args[0].video.maxAspectRatio).not.to.be.defined;
+                    const constraints = getConstraints();
+                    expect(constraints.video.width).to.equal(320);
+                    expect(constraints.video.height).to.equal(240);
+                    expect(constraints.video.facingMode).to.equal("user");
+                    expect(constraints.video.aspectRatio).to.equal(2);
+                    expect(constraints.video.facing).not.to.be.defined;
+                    expect(constraints.video.minAspectRatio).not.to.be.defined;
+                    expect(constraints.video.maxAspectRatio).not.to.be.defined;
                     done();
                 })
             });
@@ -105,17 +97,15 @@ describe('success', function() {
     });
 
     describe('failure', function() {
-    describe("permission denied", function(){
-        beforeEach(function() {
-            sinon.stub(navigator.mediaDevices, "getUserMedia", function(constraints, success, failure) {
-                return Promise.reject(new Error());
-            });
+        beforeEach(() => {
+            setSupported(false);
         });
 
-        afterEach(function() {
-            navigator.mediaDevices.getUserMedia.restore();
+        afterEach(() => {
+            setSupported(true);
         });
 
+        describe("permission denied", function(){
             it('should throw if getUserMedia not available', function(done) {
                 CameraAccess.request(video, {})
                 .catch(function (err) {
@@ -128,20 +118,55 @@ describe('failure', function() {
         describe("not available", function(){
             var originalGetUserMedia;
 
-        beforeEach(function() {
-            originalGetUserMedia = navigator.mediaDevices.getUserMedia;
-            navigator.mediaDevices.getUserMedia = undefined;
+            it('should throw if getUserMedia not available', function(done) {
+                CameraAccess.request(video, {})
+                .catch((err) => {
+                    expect(err).to.be.defined;
+                    done();
+                });
+            });
         });
 
-        afterEach(function() {
-            navigator.mediaDevices.getUserMedia = originalGetUserMedia;
+        describe("pickConstraints", () => {
+            it("should return the given constraints if no facingMode is defined", (done) => {
+                const givenConstraints = {width: 180};
+                return pickConstraints(givenConstraints).then((actualConstraints) => {
+                    expect(actualConstraints.video).to.deep.equal(givenConstraints);
+                    done();
+                })
+                .catch((err) => {
+                    expect(err).to.equal(null);
+                    console.log(err);
+                    done();
+                });
             });
 
-        it('should throw if getUserMedia not available', function(done) {
-            CameraAccess.request(video, {})
+            it("should return the given constraints if deviceId is defined", (done) => {
+                const givenConstraints = {width: 180, deviceId: "4343"};
+                return pickConstraints(givenConstraints).then((actualConstraints) => {
+                    expect(actualConstraints.video).to.deep.equal(givenConstraints);
+                    done();
+                })
                 .catch((err) => {
-                expect(err).to.be.defined;
+                    expect(err).to.equal(null);
+                    console.log(err);
+                    done();
+                });
+            });
+
+            it("should set deviceId if facingMode is set to environment", (done) => {
+                setDevices([{deviceId: "front", kind: "videoinput", label: "front Facing"},
+                    {deviceId: "back", label: "back Facing", kind: "videoinput"}]);
+                const givenConstraints = {width: 180, facingMode: "environment"};
+                return pickConstraints(givenConstraints).then((actualConstraints) => {
+                    expect(actualConstraints.video).to.deep.equal({width: 180, deviceId: "back"});
                     done();
+                })
+                .catch((err) => {
+                    console.log(err);
+                    expect(err).to.equal(null);
+                    done();
+                });
             });
         });
     });

test/spec/result_collector.spec.js

@@ -5,6 +5,8 @@ var canvasMock,
     imageSize,
     config;
 
+
+describe("resultCollector", () => {
     beforeEach(function() {
         imageSize = {x: 320, y: 240};
         config = {
@@ -101,3 +103,4 @@ describe('addResult', function() {
             expect(collector.getResults()).to.have.length(1);
         });
     });
+})

webpack.config.js

@@ -17,6 +17,7 @@ module.exports = {
     resolve: {
         modules: [
             path.resolve('./src/input/'),
+            path.resolve('./src/common/'),
             'node_modules'
         ]
     },

webpack.node.config.js

@@ -6,6 +6,7 @@ module.exports = require('./webpack.config.js');
 module.exports.resolve = {
     modules: [
         path.resolve('./lib/'),
+        path.resolve('./src/common/'),
         'node_modules'
     ]
 };