@microsoft/teams-js 2.0.0-beta.6-dev.7 → 2.0.0-beta.6-dev.8

package/dist/MicrosoftTeams.js

@@ -1122,7 +1122,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 ;// CONCATENATED MODULE: ./src/internal/constants.ts
-var version = "2.0.0-beta.6-dev.7";
+var version = "2.0.0-beta.6-dev.8";
 /**
  * @hidden
  * The client version when all SDK APIs started to check platform compatibility for the APIs was 1.6.0.
@@ -2366,7 +2366,6 @@ var runtime = {
         location: undefined,
         logs: undefined,
         mail: undefined,
-        media: undefined,
         meetingRoom: undefined,
         menus: undefined,
         monetization: undefined,
@@ -2404,7 +2403,6 @@ var teamsRuntimeConfig = {
             update: {},
         },
         logs: {},
-        media: {},
         meetingRoom: {},
         menus: {},
         monetization: {},
@@ -5006,9 +5004,9 @@ var __extends = (undefined && undefined.__extends) || (function () {
 
 
 
-
 /**
- * @alpha
+ * @deprecated
+ * As of 2.0.0-beta.6, use media only for backwards compatibility of existing code.
  */
 var media;
 (function (media) {
@@ -5029,20 +5027,35 @@ var media;
         return File;
     }());
     media.File = File;
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Launch camera, capture image or choose image from gallery and return the images as a File[] object to the callback.
+     *
+     * @params callback - Callback will be called with an @see SdkError if there are any.
+     * If error is null or undefined, the callback will be called with a collection of @see File objects
+     * @remarks
+     * Note: Currently we support getting one File through this API, i.e. the file arrays size will be one.
+     * Note: For desktop, this API is not supported. Callback will be resolved with ErrorCode.NotSupported.
+     *
+     */
     function captureImage(callback) {
+        if (!callback) {
+            throw new Error('[captureImage] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!GlobalVars.isFramelessWindow) {
-                    throw { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
-                }
-                if (!isCurrentSDKVersionAtLeast(captureImageMobileSupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                resolve(sendAndHandleSdkError('captureImage'));
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (!GlobalVars.isFramelessWindow) {
+            var notSupportedError = { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
+            callback(notSupportedError, undefined);
+            return;
+        }
+        if (!isCurrentSDKVersionAtLeast(captureImageMobileSupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, undefined);
+            return;
+        }
+        sendMessageToParent('captureImage', callback);
     }
     media.captureImage = captureImage;
     /**
@@ -5063,95 +5076,105 @@ var media;
             }
             return _this;
         }
+        /**
+         * Gets the media in chunks irrespective of size, these chunks are assembled and sent back to the webapp as file/blob
+         * @param callback - callback is called with the @see SdkError if there is an error
+         * If error is null or undefined, the callback will be called with @see Blob.
+         */
         Media.prototype.getMedia = function (callback) {
-            var _this = this;
+            if (!callback) {
+                throw new Error('[get Media] Callback cannot be null');
+            }
             ensureInitialized(FrameContexts.content, FrameContexts.task);
-            var wrappedFunction = function () {
-                return new Promise(function (resolve) {
-                    if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                        throw { errorCode: ErrorCode.OLD_PLATFORM };
-                    }
-                    if (!validateGetMediaInputs(_this.mimeType, _this.format, _this.content)) {
-                        throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                    }
-                    // Call the new get media implementation via callbacks if the client version is greater than or equal to '2.0.0'
-                    if (isCurrentSDKVersionAtLeast(getMediaCallbackSupportVersion)) {
-                        resolve(_this.getMediaViaCallback());
-                    }
-                    else {
-                        resolve(_this.getMediaViaHandler());
-                    }
-                });
-            };
-            return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+            if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+                var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+                callback(oldPlatformError, null);
+                return;
+            }
+            if (!validateGetMediaInputs(this.mimeType, this.format, this.content)) {
+                var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+                callback(invalidInput, null);
+                return;
+            }
+            // Call the new get media implementation via callbacks if the client version is greater than or equal to '2.0.0'
+            if (isCurrentSDKVersionAtLeast(getMediaCallbackSupportVersion)) {
+                this.getMediaViaCallback(callback);
+            }
+            else {
+                this.getMediaViaHandler(callback);
+            }
         };
-        Media.prototype.getMediaViaCallback = function () {
-            var _this = this;
-            return new Promise(function (resolve, reject) {
-                var helper = {
-                    mediaMimeType: _this.mimeType,
-                    assembleAttachment: [],
-                };
-                var localUriId = [_this.content];
-                sendMessageToParent('getMedia', localUriId, function (mediaResult) {
+        Media.prototype.getMediaViaCallback = function (callback) {
+            var helper = {
+                mediaMimeType: this.mimeType,
+                assembleAttachment: [],
+            };
+            var localUriId = [this.content];
+            function handleGetMediaCallbackRequest(mediaResult) {
+                if (callback) {
                     if (mediaResult && mediaResult.error) {
-                        reject(mediaResult.error);
-                    }
-                    else if (!mediaResult || !mediaResult.mediaChunk) {
-                        reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' });
-                    }
-                    else if (mediaResult.mediaChunk.chunkSequence <= 0) {
-                        var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
-                        resolve(file);
+                        callback(mediaResult.error, null);
                     }
                     else {
-                        // Keep pushing chunks into assemble attachment
-                        var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
-                        helper.assembleAttachment.push(assemble);
-                    }
-                });
-            });
-        };
-        Media.prototype.getMediaViaHandler = function () {
-            var _this = this;
-            return new Promise(function (resolve, reject) {
-                var actionName = generateGUID();
-                var helper = {
-                    mediaMimeType: _this.mimeType,
-                    assembleAttachment: [],
-                };
-                var params = [actionName, _this.content];
-                _this.content && sendMessageToParent('getMedia', params);
-                registerHandler('getMedia' + actionName, function (response) {
-                    try {
-                        var mediaResult = JSON.parse(response);
-                        if (mediaResult.error) {
-                            reject(mediaResult.error);
-                            removeHandler('getMedia' + actionName);
+                        if (mediaResult && mediaResult.mediaChunk) {
+                            // If the chunksequence number is less than equal to 0 implies EOF
+                            // create file/blob when all chunks have arrived and we get 0/-1 as chunksequence number
+                            if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                                var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
+                                callback(mediaResult.error, file);
+                            }
+                            else {
+                                // Keep pushing chunks into assemble attachment
+                                var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
+                                helper.assembleAttachment.push(assemble);
+                            }
                         }
-                        else if (!mediaResult || !mediaResult.mediaChunk) {
-                            reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' });
-                            removeHandler('getMedia' + actionName);
+                        else {
+                            callback({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' }, null);
                         }
-                        else if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                    }
+                }
+            }
+            sendMessageToParent('getMedia', localUriId, handleGetMediaCallbackRequest);
+        };
+        Media.prototype.getMediaViaHandler = function (callback) {
+            var actionName = generateGUID();
+            var helper = {
+                mediaMimeType: this.mimeType,
+                assembleAttachment: [],
+            };
+            var params = [actionName, this.content];
+            this.content && callback && sendMessageToParent('getMedia', params);
+            function handleGetMediaRequest(response) {
+                if (callback) {
+                    var mediaResult = JSON.parse(response);
+                    if (mediaResult.error) {
+                        callback(mediaResult.error, null);
+                        removeHandler('getMedia' + actionName);
+                    }
+                    else {
+                        if (mediaResult.mediaChunk) {
                             // If the chunksequence number is less than equal to 0 implies EOF
                             // create file/blob when all chunks have arrived and we get 0/-1 as chunksequence number
-                            var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
-                            resolve(file);
-                            removeHandler('getMedia' + actionName);
+                            if (mediaResult.mediaChunk.chunkSequence <= 0) {
+                                var file = createFile(helper.assembleAttachment, helper.mediaMimeType);
+                                callback(mediaResult.error, file);
+                                removeHandler('getMedia' + actionName);
+                            }
+                            else {
+                                // Keep pushing chunks into assemble attachment
+                                var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
+                                helper.assembleAttachment.push(assemble);
+                            }
                         }
                         else {
-                            // Keep pushing chunks into assemble attachment
-                            var assemble = decodeAttachment(mediaResult.mediaChunk, helper.mediaMimeType);
-                            helper.assembleAttachment.push(assemble);
+                            callback({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'data received is null' }, null);
+                            removeHandler('getMedia' + actionName);
                         }
                     }
-                    catch (err) {
-                        // catch JSON.parse() errors
-                        reject({ errorCode: ErrorCode.INTERNAL_ERROR, message: 'Error parsing the response: ' + response });
-                    }
-                });
-            });
+                }
+            }
+            registerHandler('getMedia' + actionName, handleGetMediaRequest);
         };
         return Media;
     }(File));
@@ -5166,26 +5189,38 @@ var media;
         function MediaController(controllerCallback) {
             this.controllerCallback = controllerCallback;
         }
+        /**
+         * @hidden
+         * Hide from docs
+         * --------
+         * Function to notify the host client to programatically control the experience
+         * @param mediaEvent indicates what the event that needs to be signaled to the host client
+         * Optional; @param callback is used to send app if host client has successfully handled the notification event or not
+         */
         MediaController.prototype.notifyEventToHost = function (mediaEvent, callback) {
             ensureInitialized(FrameContexts.content, FrameContexts.task);
             try {
                 throwExceptionIfMobileApiIsNotSupported(nonFullScreenVideoModeAPISupportVersion);
             }
             catch (err) {
-                var wrappedRejectedErrorFn = function () { return Promise.reject(err); };
-                return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedRejectedErrorFn, callback);
+                if (callback) {
+                    callback(err);
+                }
+                return;
             }
-            var params = {
-                mediaType: this.getMediaType(),
-                mediaControllerEvent: mediaEvent,
-            };
-            var wrappedFunction = function () {
-                return new Promise(function (resolve) { return resolve(sendAndHandleSdkError('media.controller', [params])); });
-            };
-            return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedFunction, callback);
+            var params = { mediaType: this.getMediaType(), mediaControllerEvent: mediaEvent };
+            sendMessageToParent('media.controller', [params], function (err) {
+                if (callback) {
+                    callback(err);
+                }
+            });
         };
+        /**
+         * Function to programatically stop the ongoing media event
+         * Optional; @param callback is used to send app if host client has successfully stopped the event or not
+         */
         MediaController.prototype.stop = function (callback) {
-            return Promise.resolve(this.notifyEventToHost(MediaControllerEvent.StopRecording, callback));
+            this.notifyEventToHost(MediaControllerEvent.StopRecording, callback);
         };
         return MediaController;
     }());
@@ -5201,14 +5236,16 @@ var media;
             return MediaType.Video;
         };
         VideoController.prototype.notifyEventToApp = function (mediaEvent) {
+            if (!this.controllerCallback) {
+                // Early return as app has not registered with the callback
+                return;
+            }
             switch (mediaEvent) {
                 case MediaControllerEvent.StartRecording:
-                    this.controllerCallback.onRecordingStarted();
-                    break;
-                // TODO - Should discuss whether this function should be required
-                case MediaControllerEvent.StopRecording:
-                    this.controllerCallback.onRecordingStopped && this.controllerCallback.onRecordingStopped();
-                    break;
+                    if (this.controllerCallback.onRecordingStarted) {
+                        this.controllerCallback.onRecordingStarted();
+                        break;
+                    }
             }
         };
         return VideoController;
@@ -5269,109 +5306,128 @@ var media;
         ImageOutputFormats[ImageOutputFormats["IMAGE"] = 1] = "IMAGE";
         ImageOutputFormats[ImageOutputFormats["PDF"] = 2] = "PDF";
     })(ImageOutputFormats = media.ImageOutputFormats || (media.ImageOutputFormats = {}));
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Select an attachment using camera/gallery
+     *
+     * @param mediaInputs - The input params to customize the media to be selected
+     * @param callback - The callback to invoke after fetching the media
+     */
     function selectMedia(mediaInputs, callback) {
+        if (!callback) {
+            throw new Error('[select Media] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                throwExceptionIfMediaCallIsNotSupportedOnMobile(mediaInputs);
-                if (!validateSelectMediaInputs(mediaInputs)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                var params = [mediaInputs];
-                // What comes back from native at attachments would just be objects and will be missing getMedia method on them.
-                resolve(sendMessageToParentAsync('selectMedia', params));
-            }).then(function (_a) {
-                var err = _a[0], localAttachments = _a[1], mediaEvent = _a[2];
-                // MediaControllerEvent response is used to notify the app about events and is a partial response to selectMedia
-                if (mediaEvent) {
-                    if (isVideoControllerRegistered(mediaInputs)) {
-                        mediaInputs.videoProps.videoController.notifyEventToApp(mediaEvent);
-                    }
-                    return [];
-                }
-                // Media Attachments are final response to selectMedia
-                if (!localAttachments) {
-                    throw err;
-                }
-                var mediaArray = [];
-                for (var _i = 0, localAttachments_1 = localAttachments; _i < localAttachments_1.length; _i++) {
-                    var attachment = localAttachments_1[_i];
-                    mediaArray.push(new Media(attachment));
+        if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, null);
+            return;
+        }
+        try {
+            throwExceptionIfMediaCallIsNotSupportedOnMobile(mediaInputs);
+        }
+        catch (err) {
+            callback(err, null);
+            return;
+        }
+        if (!validateSelectMediaInputs(mediaInputs)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput, null);
+            return;
+        }
+        var params = [mediaInputs];
+        // What comes back from native as attachments would just be objects and will be missing getMedia method on them
+        sendMessageToParent('selectMedia', params, function (err, localAttachments, mediaEvent) {
+            // MediaControllerEvent response is used to notify the app about events and is a partial response to selectMedia
+            if (mediaEvent) {
+                if (isVideoControllerRegistered(mediaInputs)) {
+                    mediaInputs.videoProps.videoController.notifyEventToApp(mediaEvent);
                 }
-                return mediaArray;
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+                return;
+            }
+            // Media Attachments are final response to selectMedia
+            if (!localAttachments) {
+                callback(err, null);
+                return;
+            }
+            var mediaArray = [];
+            for (var _i = 0, localAttachments_1 = localAttachments; _i < localAttachments_1.length; _i++) {
+                var attachment = localAttachments_1[_i];
+                mediaArray.push(new Media(attachment));
+            }
+            callback(err, mediaArray);
+        });
     }
     media.selectMedia = selectMedia;
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * View images using native image viewer
+     * @param uriList - list of URIs for images to be viewed - can be content URI or server URL. Supports up to 10 Images in a single call
+     * @param callback - returns back error if encountered, returns null in case of success
+     */
     function viewImages(uriList, callback) {
+        if (!callback) {
+            throw new Error('[view images] Callback cannot be null');
+        }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                if (!validateViewImagesInput(uriList)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                resolve(sendAndHandleSdkError('viewImages', uriList));
-            });
-        };
-        return callCallbackWithSdkErrorFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (!isCurrentSDKVersionAtLeast(mediaAPISupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError);
+            return;
+        }
+        if (!validateViewImagesInput(uriList)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput);
+            return;
+        }
+        var params = [uriList];
+        sendMessageToParent('viewImages', params, callback);
     }
     media.viewImages = viewImages;
-    function scanBarCode(callbackOrConfig, configMaybe) {
-        var callback;
-        var config;
-        // Because the callback isn't the second parameter in the original v1 method we need to
-        // do a bit of trickery to see which of the two ways were used to call into
-        // the flow and if the first parameter is a callback (v1) or a config object (v2)
-        if (callbackOrConfig === undefined) {
-            // no first parameter - the second one might be a config, definitely no callback
-            config = configMaybe;
-        }
-        else {
-            if (typeof callbackOrConfig === 'object') {
-                // the first parameter is an object - it's the config! No callback.
-                config = callbackOrConfig;
-            }
-            else {
-                // otherwise, it's a function, so a callback. The second parameter might be a callback
-                callback = callbackOrConfig;
-                config = configMaybe;
-            }
+    /**
+     * @deprecated
+     * As of 2.0.0-beta.6, use only for backwards compatibility of existing code.
+     *
+     * Scan Barcode/QRcode using camera
+     * @remarks
+     * Note: For desktop and web, this API is not supported. Callback will be resolved with ErrorCode.NotSupported.
+     *
+     * @param callback - callback to invoke after scanning the barcode
+     * @param config - optional input configuration to customize the barcode scanning experience
+     */
+    function scanBarCode(callback, config) {
+        if (!callback) {
+            throw new Error('[media.scanBarCode] Callback cannot be null');
         }
         ensureInitialized(FrameContexts.content, FrameContexts.task);
-        var wrappedFunction = function () {
-            return new Promise(function (resolve) {
-                if (GlobalVars.hostClientType === HostClientType.desktop ||
-                    GlobalVars.hostClientType === HostClientType.web ||
-                    GlobalVars.hostClientType === HostClientType.rigel ||
-                    GlobalVars.hostClientType === HostClientType.teamsRoomsWindows ||
-                    GlobalVars.hostClientType === HostClientType.teamsRoomsAndroid ||
-                    GlobalVars.hostClientType === HostClientType.teamsPhones ||
-                    GlobalVars.hostClientType === HostClientType.teamsDisplays) {
-                    throw { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
-                }
-                if (!isCurrentSDKVersionAtLeast(scanBarCodeAPIMobileSupportVersion)) {
-                    throw { errorCode: ErrorCode.OLD_PLATFORM };
-                }
-                if (!validateScanBarCodeInput(config)) {
-                    throw { errorCode: ErrorCode.INVALID_ARGUMENTS };
-                }
-                resolve(sendAndHandleSdkError('media.scanBarCode', config));
-            });
-        };
-        return callCallbackWithErrorOrResultFromPromiseAndReturnPromise(wrappedFunction, callback);
+        if (GlobalVars.hostClientType === HostClientType.desktop ||
+            GlobalVars.hostClientType === HostClientType.web ||
+            GlobalVars.hostClientType === HostClientType.rigel ||
+            GlobalVars.hostClientType === HostClientType.teamsRoomsWindows ||
+            GlobalVars.hostClientType === HostClientType.teamsRoomsAndroid ||
+            GlobalVars.hostClientType === HostClientType.teamsPhones ||
+            GlobalVars.hostClientType === HostClientType.teamsDisplays) {
+            var notSupportedError = { errorCode: ErrorCode.NOT_SUPPORTED_ON_PLATFORM };
+            callback(notSupportedError, null);
+            return;
+        }
+        if (!isCurrentSDKVersionAtLeast(scanBarCodeAPIMobileSupportVersion)) {
+            var oldPlatformError = { errorCode: ErrorCode.OLD_PLATFORM };
+            callback(oldPlatformError, null);
+            return;
+        }
+        if (!validateScanBarCodeInput(config)) {
+            var invalidInput = { errorCode: ErrorCode.INVALID_ARGUMENTS };
+            callback(invalidInput, null);
+            return;
+        }
+        sendMessageToParent('media.scanBarCode', [config], callback);
     }
     media.scanBarCode = scanBarCode;
-    function isSupported() {
-        return runtime.supports.media ? true : false;
-    }
-    media.isSupported = isSupported;
 })(media || (media = {}));
 
 ;// CONCATENATED MODULE: ./src/public/location.ts