@microsoft/teams-js 2.11.0 → 2.12.0-beta.0

package/dist/MicrosoftTeams.d.ts

@@ -2075,7 +2075,7 @@ export namespace videoEx {
             * @internal
             * Limited to Microsoft-internal use
             */
-        interface VideoFrame extends video.VideoFrame {
+        interface VideoBufferData extends video.VideoBufferData {
                 /**
                     * @hidden
                     * The model output if you passed in an {@linkcode VideoFrameConfig.audioInferenceModel}
@@ -2094,7 +2094,24 @@ export namespace videoEx {
             * @internal
             * Limited to Microsoft-internal use
             */
-        type VideoFrameCallback = (frame: VideoFrame, notifyVideoFrameProcessed: () => void, notifyError: (errorMessage: string) => void) => void;
+        type VideoBufferHandler = (videoBufferData: VideoBufferData, notifyVideoFrameProcessed: () => void, notifyError: (errorMessage: string) => void) => void;
+        /**
+            * @hidden
+            * @beta
+            * Callbacks and configuration supplied to the host to process the video frames.
+            * @internal
+            * Limited to Microsoft-internal use
+            */
+        type RegisterForVideoFrameParameters = {
+                /**
+                    * Callback function to process the video frames shared by the host.
+                    */
+                videoBufferHandler: VideoBufferHandler;
+                /**
+                    * Video frame configuration supplied to the host to customize the generated video frame parameters, like format
+                    */
+                config: VideoFrameConfig;
+        };
         /**
             * @hidden
             * Register to process video frames
@@ -2106,7 +2123,7 @@ export namespace videoEx {
             * @internal
             * Limited to Microsoft-internal use
             */
-        function registerForVideoFrame(frameCallback: VideoFrameCallback, config: VideoFrameConfig): void;
+        function registerForVideoFrame(parameters: RegisterForVideoFrameParameters): void;
         /**
             * @hidden
             * Video extension should call this to notify host that the current selected effect parameter changed.
@@ -2121,15 +2138,6 @@ export namespace videoEx {
             * Limited to Microsoft-internal use
             */
         function notifySelectedVideoEffectChanged(effectChangeType: video.EffectChangeType, effectId: string | undefined, effectParam?: string): void;
-        /**
-            * @hidden
-            * Video effect change call back function definition
-            * @beta
-            *
-            * @internal
-            * Limited to Microsoft-internal use
-            */
-        type VideoEffectCallBack = (effectId: string | undefined, effectParam?: string) => void;
         /**
             * @hidden
             * Register the video effect callback, host uses this to notify the video extension the new video effect will by applied
@@ -2760,6 +2768,12 @@ export const errorNotSupportedOnPlatform: SdkError;
     * Minimum Adaptive Card version supported by the host.
     */
 export const minAdaptiveCardVersion: AdaptiveCardVersion;
+/**
+    * @hidden
+    *
+    * Adaptive Card version supported by the Teams v1 client.
+    */
+export const teamsMinAdaptiveCardVersion: HostVersionsInfo;
 
 /**
     * Represents information about tabs for an app
@@ -4629,38 +4643,6 @@ export namespace dialog {
                             */
                         function isSupported(): boolean;
                 }
-                /**
-                    * @hidden
-                    * Hide from docs
-                    * --------
-                    * Convert AdaptiveCardDialogInfo to DialogInfo to send the information to host in {@linkcode adaptiveCard.open} API.
-                    *
-                    * @internal
-                    */
-                function getDialogInfoFromAdaptiveCardDialogInfo(adaptiveCardDialogInfo: AdaptiveCardDialogInfo): DialogInfo;
-                /**
-                    * @hidden
-                    * Hide from docs
-                    * --------
-                    * Convert BotAdaptiveCardDialogInfo to DialogInfo to send the information to host in {@linkcode adaptiveCard.open} API.
-                    *
-                    * @internal
-                    */
-                function getDialogInfoFromBotAdaptiveCardDialogInfo(botAdaptiveCardDialogInfo: BotAdaptiveCardDialogInfo): DialogInfo;
-                /**
-                    * @hidden
-                    * Converts {@link TaskInfo} to {@link AdaptiveCardDialogInfo}
-                    * @param taskInfo - TaskInfo object to convert
-                    * @returns - converted AdaptiveCardDialogInfo
-                    */
-                function getAdaptiveCardDialogInfoFromTaskInfo(taskInfo: TaskInfo): AdaptiveCardDialogInfo;
-                /**
-                    * @hidden
-                    * Converts {@link TaskInfo} to {@link BotAdaptiveCardDialogInfo}
-                    * @param taskInfo - TaskInfo object to convert
-                    * @returns - converted BotAdaptiveCardDialogInfo
-                    */
-                function getBotAdaptiveCardDialogInfoFromTaskInfo(taskInfo: TaskInfo): BotAdaptiveCardDialogInfo;
         }
 }
 
@@ -5884,6 +5866,35 @@ export namespace media {
         export {};
 }
 
+/**
+    * Namespace to power up the in-app browser experiences in the Host App.
+    * For e.g., opening a URL in the Host App inside a browser
+    *
+    * @beta
+    */
+export namespace secondaryBrowser {
+        /**
+            * Open a URL in the secondary browser aka in-app browser
+            *
+            * @param url Url to open in the browser
+            * @returns Promise that successfully resolves if the URL  opens in the secondaryBrowser
+            * or throws an error {@link SdkError} incase of failure before starting navigation
+            *
+            * @remarks Any error that happens after navigation begins is handled by the platform browser component and not returned from this function.
+            * @beta
+            */
+        function open(url: URL): Promise<void>;
+        /**
+            * Checks if secondaryBrowser capability is supported by the host
+            * @returns boolean to represent whether secondaryBrowser is supported
+            *
+            * @throws Error if {@linkcode app.initialize} has not successfully completed
+            *
+            * @beta
+            */
+        function isSupported(): boolean;
+}
+
 /**
     * @deprecated
     * As of 2.1.0, please use geoLocation namespace.
@@ -7014,7 +7025,7 @@ export namespace video {
             * Represents a video frame
             * @beta
             */
-        export interface VideoFrame {
+        export interface VideoBufferData {
                 /**
                     * Video frame width
                     */
@@ -7026,7 +7037,7 @@ export namespace video {
                 /**
                     * Video frame buffer
                     */
-                data: Uint8ClampedArray;
+                videoFrameBuffer: Uint8ClampedArray;
                 /**
                     * NV12 luma stride, valid only when video frame format is NV12
                     */
@@ -7050,7 +7061,7 @@ export namespace video {
             */
         export enum VideoFrameFormat {
                 /** Video format used for encoding and decoding YUV color data in video streaming and storage applications. */
-                NV12 = 0
+                NV12 = "NV12"
         }
         /**
             * Video frame configuration supplied to the host to customize the generated video frame parameters, like format
@@ -7070,17 +7081,12 @@ export namespace video {
                 /**
                     * Current video effect changed
                     */
-                EffectChanged = 0,
+                EffectChanged = "EffectChanged",
                 /**
                     * Disable the video effect
                     */
-                EffectDisabled = 1
+                EffectDisabled = "EffectDisabled"
         }
-        /**
-            * Video frame call back function definition
-            * @beta
-            */
-        export type VideoFrameCallback = (frame: VideoFrame, notifyVideoFrameProcessed: notifyVideoFrameProcessedFunctionType, notifyError: notifyErrorFunctionType) => void;
         /**
             * Predefined failure reasons for preparing the selected video effect
             * @beta
@@ -7103,12 +7109,97 @@ export namespace video {
             */
         export type VideoEffectCallback = (effectId: string | undefined) => Promise<void>;
         /**
-            * Register to read the video frames in Permissions section
             * @beta
-            * @param frameCallback - The callback to invoke when registerForVideoFrame has completed
-            * @param config - VideoFrameConfig to customize generated video frame parameters
+            * Video frame call back function definition
+            * The callback will be called on every frame when running on the supported host.
+            * We require the frame rate of the video to be at least 22fps for 720p, thus the callback should process a frame timely.
+            * The video app should call `notifyVideoFrameProcessed` to notify a successfully processed video frame.
+            * The video app should call `notifyError` to notify a failure. When the failures accumulate to a certain number, the host will see the app is "frozen" and ask the user to close it or not.
             */
-        export function registerForVideoFrame(frameCallback: VideoFrameCallback, config: VideoFrameConfig): void;
+        export type VideoBufferHandler = (videoBufferData: VideoBufferData, notifyVideoFrameProcessed: notifyVideoFrameProcessedFunctionType, notifyError: notifyErrorFunctionType) => void;
+        /**
+            * @beta
+            * VideoFrame definition, align with the W3C spec: https://www.w3.org/TR/webcodecs/#videoframe-interface.
+            * The current version of typescript doesn't have the definition of VideoFrame so we have to define it here.
+            * At runtime it can be cast to VideoFrame directly: `(videoFrame as VideoFrame)`.
+            */
+        export interface VideoFrame {
+        }
+        /**
+            * @beta
+            * Video frame data extracted from the media stream. More properties may be added in the future.
+            */
+        export type VideoFrameData = {
+                /**
+                    * The video frame from the media stream.
+                    */
+                videoFrame: VideoFrame;
+        };
+        /**
+            * @beta
+            * Video frame call back function definition.
+            * The callback will be called on every frame when running on the supported host.
+            * We require the frame rate of the video to be at least 22fps for 720p, thus the callback should process a frame timely.
+            * The video app should resolve the promise to notify a successfully processed video frame.
+            * The video app should reject the promise to notify a failure. When the failures accumulate to a certain number, the host will see the app is "frozen" and ask the user to close it or not.
+            */
+        export type VideoFrameHandler = (receivedVideoFrame: VideoFrameData) => Promise<VideoFrame>;
+        /**
+            * @beta
+            * Callbacks and configuration supplied to the host to process the video frames.
+            */
+        export type RegisterForVideoFrameParameters = {
+                /**
+                    * Callback function to process the video frames extracted from a media stream.
+                    */
+                videoFrameHandler: VideoFrameHandler;
+                /**
+                    * Callback function to process the video frames shared by the host.
+                    */
+                videoBufferHandler: VideoBufferHandler;
+                /**
+                    * Video frame configuration supplied to the host to customize the generated video frame parameters, like format
+                    */
+                config: VideoFrameConfig;
+        };
+        /**
+            * Register callbacks to process the video frames if the host supports it.
+            * @beta
+            * @param parameters - Callbacks and configuration to process the video frames. A host may support either {@link VideoFrameHandler} or {@link VideoBufferHandler}, but not both.
+            * To ensure the video effect works on all supported hosts, the video app must provide both {@link VideoFrameHandler} and {@link VideoBufferHandler}.
+            * The host will choose the appropriate callback based on the host's capability.
+            *
+            * @example
+            * ```typescript
+            * video.registerForVideoFrame({
+            *   videoFrameHandler: async (videoFrameData) => {
+            *     const originalFrame = videoFrameData.videoFrame as VideoFrame;
+            *     try {
+            *       const processedFrame = await processFrame(originalFrame);
+            *       return processedFrame;
+            *     } catch (e) {
+            *       throw e;
+            *     }
+            *   },
+            *   videoBufferHandler: (
+            *     bufferData: VideoBufferData,
+            *     notifyVideoFrameProcessed: notifyVideoFrameProcessedFunctionType,
+            *     notifyError: notifyErrorFunctionType
+            *     ) => {
+            *       try {
+            *         processFrameInplace(bufferData);
+            *         notifyVideoFrameProcessed();
+            *       } catch (e) {
+            *         notifyError(e);
+            *       }
+            *     },
+            *   config: {
+            *     format: video.VideoPixelFormat.NV12,
+            *   }
+            * });
+            * ```
+            */
+        export function registerForVideoFrame(parameters: RegisterForVideoFrameParameters): void;
         /**
             * Video extension should call this to notify host that the current selected effect parameter changed.
             * If it's pre-meeting, host will call videoEffectCallback immediately then use the videoEffect.
@@ -7125,7 +7216,7 @@ export namespace video {
             */
         export function registerForVideoEffect(callback: VideoEffectCallback): void;
         /**
-            * Checks if video capability is supported by the host
+            * Checks if video capability is supported by the host.
             * @beta
             * @returns boolean to represent whether the video capability is supported
             *
@@ -8134,3 +8225,23 @@ export class LiveShareHost {
     */
 export function isSupported(): boolean;
 
+/**
+    * @hidden
+    * Create a MediaStreamTrack from the media stream with the given streamId and processed by videoFrameHandler.
+    */
+export function processMediaStream(streamId: string, videoFrameHandler: video.VideoFrameHandler, notifyError: (string: any) => void): Promise<MediaStreamTrack>;
+/**
+    * @hidden
+    * Video effect change call back function definition
+    * @beta
+    *
+    * @internal
+    * Limited to Microsoft-internal use
+    */
+type VideoEffectCallBack = (effectId: string | undefined, effectParam?: string) => Promise<void>;
+/**
+    * @hidden
+    */
+export function createEffectParameterChangeCallback(callback: VideoEffectCallBack): (effectId: string | undefined, effectParam?: string) => void;
+export { VideoEffectCallBack as DefaultVideoEffectCallBack };
+