Przeglądaj źródła

Fixes JS error when parsing GUM error

master
hristoterezov 9 lat temu
rodzic
commit
c45f3d767d
4 zmienionych plików z 38 dodań i 28 usunięć
  1. 4
    4
      JitsiTrackErrors.js
  2. 13
    8
      lib-jitsi-meet.js
  3. 12
    12
      lib-jitsi-meet.min.js
  4. 9
    4
      modules/RTC/RTCUtils.js

+ 4
- 4
JitsiTrackErrors.js Wyświetl plik

2
     /**
2
     /**
3
      * Returns JitsiTrackErrors based on the error object passed by GUM
3
      * Returns JitsiTrackErrors based on the error object passed by GUM
4
      * @param error the error
4
      * @param error the error
5
-     * @param {Object} options the options object given to GUM.
5
+     * @param {Array} devices Array with the requested devices
6
      */
6
      */
7
-    parseError: function (error, options) {
8
-        options = options || {};
7
+    parseError: function (error, devices) {
8
+        devices = devices || [];
9
         if (typeof error == "object" && error.constraintName && error.name
9
         if (typeof error == "object" && error.constraintName && error.name
10
             && (error.name == "ConstraintNotSatisfiedError" ||
10
             && (error.name == "ConstraintNotSatisfiedError" ||
11
             error.name == "OverconstrainedError") &&
11
             error.name == "OverconstrainedError") &&
13
             error.constraintName == "maxWidth" ||
13
             error.constraintName == "maxWidth" ||
14
             error.constraintName == "minHeight" ||
14
             error.constraintName == "minHeight" ||
15
             error.constraintName == "maxHeight") &&
15
             error.constraintName == "maxHeight") &&
16
-            options.devices.indexOf("video") !== -1) {
16
+            devices.indexOf("video") !== -1) {
17
                 return this.UNSUPPORTED_RESOLUTION;
17
                 return this.UNSUPPORTED_RESOLUTION;
18
         } else {
18
         } else {
19
             return this.GENERAL;
19
             return this.GENERAL;

+ 13
- 8
lib-jitsi-meet.js Wyświetl plik

1326
     /**
1326
     /**
1327
      * Returns JitsiTrackErrors based on the error object passed by GUM
1327
      * Returns JitsiTrackErrors based on the error object passed by GUM
1328
      * @param error the error
1328
      * @param error the error
1329
-     * @param {Object} options the options object given to GUM.
1329
+     * @param {Array} devices Array with the requested devices
1330
      */
1330
      */
1331
-    parseError: function (error, options) {
1332
-        options = options || {};
1331
+    parseError: function (error, devices) {
1332
+        devices = devices || [];
1333
         if (typeof error == "object" && error.constraintName && error.name
1333
         if (typeof error == "object" && error.constraintName && error.name
1334
             && (error.name == "ConstraintNotSatisfiedError" ||
1334
             && (error.name == "ConstraintNotSatisfiedError" ||
1335
             error.name == "OverconstrainedError") &&
1335
             error.name == "OverconstrainedError") &&
1337
             error.constraintName == "maxWidth" ||
1337
             error.constraintName == "maxWidth" ||
1338
             error.constraintName == "minHeight" ||
1338
             error.constraintName == "minHeight" ||
1339
             error.constraintName == "maxHeight") &&
1339
             error.constraintName == "maxHeight") &&
1340
-            options.devices.indexOf("video") !== -1) {
1340
+            devices.indexOf("video") !== -1) {
1341
                 return this.UNSUPPORTED_RESOLUTION;
1341
                 return this.UNSUPPORTED_RESOLUTION;
1342
         } else {
1342
         } else {
1343
             return this.GENERAL;
1343
             return this.GENERAL;
2857
     }
2857
     }
2858
 
2858
 
2859
     var device = options.devices.splice(0, 1);
2859
     var device = options.devices.splice(0, 1);
2860
+    var devices = [];
2861
+    devices.push(device);
2860
     options.deviceGUM[device](function (stream) {
2862
     options.deviceGUM[device](function (stream) {
2861
             options.streams = options.streams || {};
2863
             options.streams = options.streams || {};
2862
             options.streams[device] = stream;
2864
             options.streams[device] = stream;
2865
         function (error) {
2867
         function (error) {
2866
             logger.error(
2868
             logger.error(
2867
                 "failed to obtain " + device + " stream - stop", error);
2869
                 "failed to obtain " + device + " stream - stop", error);
2868
-            options.errorCallback(JitsiTrackErrors.parseError(error));
2870
+            options.errorCallback(JitsiTrackErrors.parseError(error, devices));
2869
         });
2871
         });
2870
 }
2872
 }
2871
 
2873
 
3213
                                             desktopStream: desktopStream});
3215
                                             desktopStream: desktopStream});
3214
                                     }, function (error) {
3216
                                     }, function (error) {
3215
                                         reject(
3217
                                         reject(
3216
-                                            JitsiTrackErrors.parseError(error));
3218
+                                            JitsiTrackErrors.parseError(error,
3219
+                                                options.devices));
3217
                                     });
3220
                                     });
3218
                             } else {
3221
                             } else {
3219
                                 successCallback({audioVideo: stream});
3222
                                 successCallback({audioVideo: stream});
3220
                             }
3223
                             }
3221
                         },
3224
                         },
3222
                         function (error) {
3225
                         function (error) {
3223
-                            reject(JitsiTrackErrors.parseError(error));
3226
+                            reject(JitsiTrackErrors.parseError(error,
3227
+                                options.devices));
3224
                         },
3228
                         },
3225
                         options);
3229
                         options);
3226
                 } else if (hasDesktop) {
3230
                 } else if (hasDesktop) {
3229
                             successCallback({desktopStream: stream});
3233
                             successCallback({desktopStream: stream});
3230
                         }, function (error) {
3234
                         }, function (error) {
3231
                             reject(
3235
                             reject(
3232
-                                JitsiTrackErrors.parseError(error));
3236
+                                JitsiTrackErrors.parseError(error,
3237
+                                    ["desktop"]));
3233
                         });
3238
                         });
3234
                 }
3239
                 }
3235
             }
3240
             }

+ 12
- 12
lib-jitsi-meet.min.js
Plik diff jest za duży
Wyświetl plik


+ 9
- 4
modules/RTC/RTCUtils.js Wyświetl plik

335
     }
335
     }
336
 
336
 
337
     var device = options.devices.splice(0, 1);
337
     var device = options.devices.splice(0, 1);
338
+    var devices = [];
339
+    devices.push(device);
338
     options.deviceGUM[device](function (stream) {
340
     options.deviceGUM[device](function (stream) {
339
             options.streams = options.streams || {};
341
             options.streams = options.streams || {};
340
             options.streams[device] = stream;
342
             options.streams[device] = stream;
343
         function (error) {
345
         function (error) {
344
             logger.error(
346
             logger.error(
345
                 "failed to obtain " + device + " stream - stop", error);
347
                 "failed to obtain " + device + " stream - stop", error);
346
-            options.errorCallback(JitsiTrackErrors.parseError(error));
348
+            options.errorCallback(JitsiTrackErrors.parseError(error, devices));
347
         });
349
         });
348
 }
350
 }
349
 
351
 
691
                                             desktopStream: desktopStream});
693
                                             desktopStream: desktopStream});
692
                                     }, function (error) {
694
                                     }, function (error) {
693
                                         reject(
695
                                         reject(
694
-                                            JitsiTrackErrors.parseError(error));
696
+                                            JitsiTrackErrors.parseError(error,
697
+                                                options.devices));
695
                                     });
698
                                     });
696
                             } else {
699
                             } else {
697
                                 successCallback({audioVideo: stream});
700
                                 successCallback({audioVideo: stream});
698
                             }
701
                             }
699
                         },
702
                         },
700
                         function (error) {
703
                         function (error) {
701
-                            reject(JitsiTrackErrors.parseError(error));
704
+                            reject(JitsiTrackErrors.parseError(error,
705
+                                options.devices));
702
                         },
706
                         },
703
                         options);
707
                         options);
704
                 } else if (hasDesktop) {
708
                 } else if (hasDesktop) {
707
                             successCallback({desktopStream: stream});
711
                             successCallback({desktopStream: stream});
708
                         }, function (error) {
712
                         }, function (error) {
709
                             reject(
713
                             reject(
710
-                                JitsiTrackErrors.parseError(error));
714
+                                JitsiTrackErrors.parseError(error,
715
+                                    ["desktop"]));
711
                         });
716
                         });
712
                 }
717
                 }
713
             }
718
             }

Ładowanie…
Anuluj
Zapisz