Move media directory under cast

ext/src/shim/cast/classes/Session.ts

@@ -8,9 +8,9 @@ import Receiver from "./Receiver";
 import SenderApplication from "./SenderApplication";
 import Volume from "./Volume";
 
-import LoadRequest from "../../media/classes/LoadRequest";
-import Media from "../../media/classes/Media";
-import QueueLoadRequest from "../../media/classes/QueueLoadRequest";
+import LoadRequest from "../media/classes/LoadRequest";
+import Media from "../media/classes/Media";
+import QueueLoadRequest from "../media/classes/QueueLoadRequest";
 
 import { ErrorCode
        , SessionStatus

ext/src/shim/cast/index.ts

@@ -24,13 +24,12 @@ import { AutoJoinPolicy
        , SessionStatus
        , VolumeControlType } from "./enums";
 
+import media from "./media";
 
 import { requestSession as requestSessionTimeout } from "../timeout";
-
 import { onMessage, sendMessageResponse } from "../messageBridge";
 
 
-
 type ReceiverActionListener = (
         receiver: Receiver
       , receiverAction: typeof ReceiverAction) => void;
@@ -68,6 +67,9 @@ export default {
   , isAvailable: false
   , timeout: new Timeout()
 
+    // chrome.cast.media namespace
+  , media
+
 
   , addReceiverActionListener: (
             listener: ReceiverActionListener): void => {

ext/src/shim/cast/media/classes/EditTracksInfoRequest.ts

@@ -0,0 +1,10 @@
+"use strict";
+
+export default class EditTracksInfoRequest {
+    public requestId = 0;
+
+    constructor (
+            public activeTrackIds: number[] = null
+          , public textTrackStyle: string = null) {
+    }
+}

ext/src/shim/cast/media/classes/GenericMediaMetadata.ts

@@ -0,0 +1,16 @@
+"use strict";
+
+import Image from "../../classes/Image";
+
+import { MetadataType } from "../enums";
+
+
+export default class GenericMediaMetadata {
+    public images: Image[] = null;
+    public metadataType: number = MetadataType.GENERIC;
+    public releaseDate: string = null;
+    public releaseYear: number = null;
+    public subtitle: string = null;
+    public title: string = null;
+    public type: number = MetadataType.GENERIC;
+}

ext/src/shim/cast/media/classes/GetStatusRequest.ts

@@ -0,0 +1,5 @@
+"use strict";
+
+export default class GetStatusRequest {
+    public customData: any = null;
+}

ext/src/shim/cast/media/classes/LoadRequest.ts

@@ -0,0 +1,19 @@
+"use strict";
+
+import MediaInfo from "./MediaInfo";
+
+
+export default class LoadRequest {
+    public activeTrackIds: number[] = null;
+    public autoplay: boolean = true;
+    public currentTime: number = null;
+    public customData: any = null;
+    public media: MediaInfo;
+    public requestId: number = 0;
+    public sessionId: string = null;
+    public type: string = "LOAD";
+
+    constructor (mediaInfo: MediaInfo) {
+        this.media = mediaInfo;
+    }
+}

ext/src/shim/cast/media/classes/Media.ts

@@ -0,0 +1,320 @@
+"use strict";
+
+import uuid from "uuid/v1";
+
+import EditTracksInfoRequest from "./EditTracksInfoRequest";
+import GetStatusRequest from "./GetStatusRequest";
+import MediaInfo from "./MediaInfo";
+import PauseRequest from "./PauseRequest";
+import PlayRequest from "./PlayRequest";
+import QueueInsertItemsRequest from "./QueueInsertItemsRequest";
+import QueueItem from "./QueueItem";
+import QueueReorderItemsRequest from "./QueueReorderItemsRequest";
+import QueueUpdateItemsRequest from "./QueueUpdateItemsRequest";
+import SeekRequest from "./SeekRequest";
+import StopRequest from "./StopRequest";
+import VolumeRequest from "./VolumeRequest";
+
+import Volume from "../../classes/Volume";
+
+import { PlayerState
+       , RepeatMode } from "../enums";
+
+import _Error from "../../classes/Error";
+import { ErrorCode } from "../../enums";
+
+import { onMessage, sendMessageResponse } from "../../../messageBridge";
+
+import { Callbacks
+       , CallbacksMap
+       , ErrorCallback
+       , SuccessCallback
+       , UpdateListener } from "../../../types";
+
+
+const _id = new WeakMap<Media, string>();
+
+const _updateListeners = new WeakMap<Media, Set<UpdateListener>>();
+const _sendMediaMessageCallbacks = new WeakMap<Media, CallbacksMap>();
+
+const _lastCurrentTime = new WeakMap<Media, number>();
+
+
+export default class Media {
+    public activeTrackIds: number[] = null;
+    public currentItemId: number = null;
+    public customData: any = null;
+    public currentTime: number = 0;
+    public idleReason: string = null;
+    public items: QueueItem[] = null;
+    public loadingItemId: number = null;
+    public media: MediaInfo = null;
+    public playbackRate: number = 1;
+    public playerState: string = PlayerState.IDLE;
+    public preloadedItemId: number = null;
+    public repeatMode: string = RepeatMode.OFF;
+    public supportedMediaCommands: string[] = [];
+    public volume: Volume = new Volume();
+
+
+    constructor (
+            public sessionId: string
+          , public mediaSessionId: number
+          , _internalSessionId: string) {
+
+        _id.set(this, uuid());
+
+        _updateListeners.set(this, new Set());
+        _sendMediaMessageCallbacks.set(this, new Map());
+
+        _lastCurrentTime.set(this, undefined);
+
+
+        sendMessageResponse({
+            subject: "bridge:/media/initialize"
+          , data: {
+                sessionId
+              , mediaSessionId
+              , _internalSessionId
+            }
+          , _id: _id.get(this)
+        });
+
+        onMessage(message => {
+            if (!message._id || message._id !== _id.get(this)) {
+                return;
+            }
+
+            switch (message.subject) {
+                case "shim:/media/update": {
+                    const status = message.data;
+
+                    this.currentTime = status.currentTime;
+                    _lastCurrentTime.set(this, status._lastCurrentTime);
+                    this.customData = status.customData;
+                    this.volume = new Volume(
+                            status._volumeLevel
+                          , status._volumeMuted);
+                    this.playbackRate = status.playbackRate;
+                    this.playerState = status.playerState;
+                    this.repeatMode = status.repeatMode;
+
+                    if (status.media) {
+                        this.media = status.media;
+                    }
+                    if (status.mediaSessionId) {
+                        this.mediaSessionId = status.mediaSessionId;
+                    }
+
+                    // Call update listeners
+                    for (const listener of _updateListeners.get(this)) {
+                        listener(true);
+                    }
+
+                    break;
+                }
+
+                case "shim:/media/sendMediaMessageResponse": {
+                    const { messageId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = _sendMediaMessageCallbacks.get(this).get(messageId);
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else if (successCallback) {
+                        successCallback();
+                    }
+
+                    break;
+                }
+
+            }
+        });
+    }
+
+    public addUpdateListener (listener: UpdateListener): void {
+        _updateListeners.get(this).add(listener);
+    }
+
+    public editTracksInfo (
+            editTracksInfoRequest: EditTracksInfoRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        console.info("STUB :: Media#editTracksInfo");
+    }
+
+    public getEstimatedTime (): number {
+        if (!this.currentTime) {
+            return 0;
+        }
+
+        return this.currentTime
+                + ((Date.now() / 1000) - _lastCurrentTime.get(this));
+    }
+
+    public getStatus (
+            getStatusRequest?: GetStatusRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({ type: "MEDIA_GET_STATUS" }
+              , successCallback, errorCallback);
+    }
+
+    public pause (
+            pauseRequest: PauseRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({ type: "PAUSE" }
+              , successCallback, errorCallback);
+    }
+
+    public play (
+            playRequest?: PlayRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({ type: "PLAY" }
+              , successCallback, errorCallback);
+    }
+
+    public queueAppendItem (
+            item: QueueItem
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueAppendItem");
+    }
+
+    public queueInsertItems (
+            queueInsertItemsRequest: QueueInsertItemsRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueInsertItems");
+    }
+
+    public queueJumpToItem (
+            itemId: number
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueJumpToItem");
+    }
+
+    public queueMoveItemToNewIndex (
+            itemId: number
+          , newIndex: number
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueMoveItemToNewIndex");
+    }
+
+    public queueNext (
+            successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueNext");
+    }
+
+    public queuePrev (
+            successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queuePrev");
+    }
+
+    public queueRemoveItem (
+            itemId: number
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueRemoveItem");
+    }
+
+    public queueReorderItems (
+            queueReorderItemsRequest: QueueReorderItemsRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueReorderItems");
+    }
+
+    public queueSetRepeatMode (
+            repeatMode: string
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueSetRepeatMode");
+    }
+
+    public queueUpdateItems (
+            queueUpdateItemsRequest: QueueUpdateItemsRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+        console.info("STUB :: Media#queueUpdateItems");
+    }
+
+    public removeUpdateListener (listener: UpdateListener) {
+        _updateListeners.get(this).delete(listener);
+    }
+
+    public seek (
+            seekRequest: SeekRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({
+            type: "SEEK"
+          , currentTime: seekRequest.currentTime
+        }, successCallback, errorCallback);
+    }
+
+    public setVolume (
+            volumeRequest: VolumeRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({
+            type: "SET_VOLUME"
+          , volume: volumeRequest.volume
+        }, successCallback, errorCallback);
+    }
+
+    public stop (
+            stopRequest: StopRequest
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback): void {
+
+        this._sendMediaMessage({
+            type: "STOP"
+        }, successCallback, errorCallback);
+    }
+
+    public supportsCommand (command: string): boolean {
+        console.info("STUB :: Media#supportsCommand");
+        return true;
+    }
+
+
+    private _sendMediaMessage (
+            message: any
+          , successCallback?: SuccessCallback
+          , errorCallback?: ErrorCallback) {
+
+        message.mediaSessionId = this.mediaSessionId;
+        message.requestId = 0;
+        message.sessionId = this.sessionId;
+        message.customData = null;
+
+        const messageId = uuid();
+
+        _sendMediaMessageCallbacks.get(this).set(messageId, [
+            successCallback
+          , errorCallback
+        ]);
+
+        sendMessageResponse({
+            subject: "bridge:/media/sendMediaMessage"
+          , data: {
+                message
+              , messageId
+            }
+          , _id: _id.get(this)
+        });
+    }
+}

ext/src/shim/cast/media/classes/MediaInfo.ts

@@ -0,0 +1,33 @@
+"use strict";
+
+import GenericMediaMetadata from "./GenericMediaMetadata";
+import MovieMediaMetadata from "./MovieMediaMetadata";
+import MusicTrackMediaMetadata from "./MusicTrackMediaMetadata";
+import PhotoMediaMetadata from "./PhotoMediaMetadata";
+import TvShowMediaMetadata from "./TvShowMediaMetadata";
+
+import TextTrackStyle from "./TextTrackStyle";
+import Track from "./Track";
+
+import { StreamType } from "../enums";
+
+
+type Metadata =
+        GenericMediaMetadata
+      | MovieMediaMetadata
+      | MusicTrackMediaMetadata
+      | PhotoMediaMetadata
+      | TvShowMediaMetadata;
+
+export default class MediaInfo {
+    public customData: string = null;
+    public duration: number = null;
+    public metadata: Metadata = null;
+    public streamType: string = StreamType.BUFFERED;
+    public textTrackStyle: TextTrackStyle = null;
+    public tracks: Track[] = null;
+
+    constructor (
+            public contentId: string
+          , public contentType: string) {}
+}

ext/src/shim/cast/media/classes/MovieMediaMetadata.ts

@@ -0,0 +1,17 @@
+"use strict";
+
+import Image from "../../classes/Image";
+
+import { MetadataType } from "../enums";
+
+
+export default class MovieMediaMetadata {
+    public images: Image[] = null;
+    public metadataType: number = MetadataType.MOVIE;
+    public releaseDate: string = null;
+    public releaseYear: number = null;
+    public studio: string = null;
+    public subtitle: string = null;
+    public title: string = null;
+    public type: number = MetadataType.MOVIE;
+}

ext/src/shim/cast/media/classes/MusicTrackMediaMetadata.ts

@@ -0,0 +1,23 @@
+"use strict";
+
+import Image from "../../classes/Image";
+
+import { MetadataType } from "../enums";
+
+
+export default class MusicTrackMediaMetadata {
+    public albumArtist: string = null;
+    public albumName: string = null;
+    public artist: string = null;
+    public artistName: string = null;
+    public composer: string = null;
+    public discNumber: number = null;
+    public images: Image[] = null;
+    public metadataType: number = MetadataType.MUSIC_TRACK;
+    public releaseDate: string = null;
+    public releaseYear: number = null;
+    public songName: string = null;
+    public title: string = null;
+    public trackNumber: number = null;
+    public type: number = MetadataType.MUSIC_TRACK;
+}

ext/src/shim/cast/media/classes/PauseRequest.ts

@@ -0,0 +1,5 @@
+"use strict";
+
+export default class PauseRequest {
+    public customData: any = null;
+}

ext/src/shim/cast/media/classes/PhotoMediaMetadata.ts

@@ -0,0 +1,20 @@
+"use strict";
+
+import Image from "../../classes/Image";
+
+import { MetadataType } from "../enums";
+
+
+export default class PhotoMediaMetadata {
+    public artist: string = null;
+    public creationDateTime: string = null;
+    public height: number = null;
+    public images: Image[] = null;
+    public latitude: number = null;
+    public location: string = null;
+    public longitude: number = null;
+    public metadataType: number = MetadataType.PHOTO;
+    public title: string = null;
+    public type: number = MetadataType.PHOTO;
+    public width: number = null;
+}

ext/src/shim/cast/media/classes/PlayRequest.ts

@@ -0,0 +1,5 @@
+"use strict";
+
+export default class PlayRequest {
+    public customData: any = null;
+}

ext/src/shim/cast/media/classes/QueueInsertItemsRequest.ts

@@ -0,0 +1,15 @@
+"use strict";
+
+import QueueItem from "./QueueItem";
+
+
+export default class QueueInsertItemsRequest {
+    public customData: any = null;
+    public insertBefore: number = null;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public type: string = "QUEUE_INSERT";
+
+    constructor (
+            public items: QueueItem[]) {}
+}

ext/src/shim/cast/media/classes/QueueItem.ts

@@ -0,0 +1,19 @@
+"use strict";
+
+import MediaInfo from "./MediaInfo";
+
+
+export default class QueueItem {
+    public activeTrackIds: number[] = null;
+    public autoplay: boolean = true;
+    public customData: any = null;
+    public itemId: number = null;
+    public media: MediaInfo;
+    public playbackDuration: number = null;
+    public preloadTime: number = 0;
+    public startTime: number = 0;
+
+    constructor (mediaInfo: MediaInfo) {
+        this.media = mediaInfo;
+    }
+}

ext/src/shim/cast/media/classes/QueueLoadRequest.ts

@@ -0,0 +1,18 @@
+"use strict";
+
+import QueueItem from "./QueueItem";
+
+import { RepeatMode } from "../enums";
+
+
+export default class QueueLoadRequest {
+    public customData: any = null;
+    public repeatMode: string = RepeatMode.OFF;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public startIndex: number = 0;
+    public type: string = "QUEUE_LOAD";
+
+    constructor (
+            public items: QueueItem[]) {}
+}

ext/src/shim/cast/media/classes/QueueRemoveItemsRequest.ts

@@ -0,0 +1,11 @@
+"use strict";
+
+export default class QueueRemoveItemsRequest {
+    public customData: any = null;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public type: string = "QUEUE_REMOVE";
+
+    constructor (
+            public itemIds: number[]) {}
+}

ext/src/shim/cast/media/classes/QueueReorderItemsRequest.ts

@@ -0,0 +1,12 @@
+"use strict";
+
+export default class QueueReorderItemsRequest {
+    public customData: any = null;
+    public insertBefore: number = null;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public type: string = "QUEUE_REORDER";
+
+    constructor (
+            public itemIds: number[]) {}
+}

ext/src/shim/cast/media/classes/QueueSetPropertiesRequest.ts

@@ -0,0 +1,9 @@
+"use strict";
+
+export default class QueueSetPropertiesRequest {
+    public customData: any = null;
+    public repeatMode: string = null;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public type: string = "QUEUE_UPDATE";
+}

ext/src/shim/cast/media/classes/QueueUpdateItemsRequest.ts

@@ -0,0 +1,14 @@
+"use strict";
+
+import QueueItem from "./QueueItem";
+
+
+export default class QueueUpdateItemsRequest {
+    public customData: any = null;
+    public requestId: number = null;
+    public sessionId: string = null;
+    public type: string = "QUEUE_UPDATE";
+
+    constructor (
+            public items: QueueItem[]) {}
+}

ext/src/shim/cast/media/classes/SeekRequest.ts

@@ -0,0 +1,7 @@
+"use strict";
+
+export default class SeekRequest {
+    public currentTime: number = null;
+    public customData: any = null;
+    public resumeState: string = null;
+}

ext/src/shim/cast/media/classes/StopRequest.ts

@@ -0,0 +1,5 @@
+"use strict";
+
+export default class StopRequest {
+    public customData: any = null;
+}

ext/src/shim/cast/media/classes/TextTrackStyle.ts

@@ -0,0 +1,16 @@
+"use strict";
+
+export default class TextTrackStyle {
+    public backgroundColor: string = null;
+    public customData: any = null;
+    public edgeColor: string = null;
+    public edgeType: string = null;
+    public fontFamily: string = null;
+    public fontGenericFamily: string = null;
+    public fontScale: number = null;
+    public fontStyle: string = null;
+    public foregroundColor: string = null;
+    public windowColor: string = null;
+    public windowRoundedCornerRadius: number = null;
+    public windowType: string = null;
+}

ext/src/shim/cast/media/classes/Track.ts

@@ -0,0 +1,14 @@
+"use strict";
+
+export default class Track {
+    public customData: any = null;
+    public language: string = null;
+    public name: string = null;
+    public subtype: string = null;
+    public trackContentId: string = null;
+    public trackContentType: string = null;
+
+    constructor (
+            public trackId: number
+          , public type: string) {}
+}

ext/src/shim/cast/media/classes/TvShowMediaMetadata.ts

@@ -0,0 +1,21 @@
+"use strict";
+
+import Image from "../../classes/Image";
+
+import { MetadataType } from "../enums";
+
+
+export default class TvShowMediaMetadata {
+    public episode: number = null;
+    public episodeNumber: number = null;
+    public episodeTitle: string = null;
+    public images: Image[] = null;
+    public metadataType: number = MetadataType.TV_SHOW;
+    public originalAirdate: string = null;
+    public releaseYear: number = null;
+    public season: number = null;
+    public seasonNumber: number = null;
+    public seriesTitle: string = null;
+    public title: string = null;
+    public type: number = MetadataType.TV_SHOW;
+}

ext/src/shim/cast/media/classes/VolumeRequest.ts

@@ -0,0 +1,11 @@
+"use strict";
+
+import Volume from "../../classes/Volume";
+
+
+export default class VolumeRequest {
+    public customData: any = null;
+
+    constructor (
+            public volume: Volume) {}
+}

ext/src/shim/cast/media/enums/index.ts

@@ -0,0 +1,93 @@
+"use strict";
+
+export const IdleReason = {
+    CANCELLED: "CANCELLED"
+  , INTERRUPTED: "INTERRUPTED"
+  , FINISHED: "FINISHED"
+  , ERROR: "ERROR"
+};
+
+export const MediaCommand = {
+    PAUSE: "pause"
+  , SEEK: "seek"
+  , STREAM_VOLUME: "stream_volume"
+  , STREAM_MUTE: "stream_mute"
+};
+
+export const MetadataType = {
+    GENERIC: 0
+  , MOVIE: 1
+  , TV_SHOW: 2
+  , MUSIC_TRACK: 3
+  , PHOTO: 4
+};
+
+export const PlayerState = {
+    IDLE: "IDLE"
+  , PLAYING: "PLAYING"
+  , PAUSED: "PAUSED"
+  , BUFFERING:  "BUFFERING"
+};
+
+export const RepeatMode = {
+    OFF: "REPEAT_OFF"
+  , ALL: "REPEAT_ALL"
+  , SINGLE: "REPEAT_SINGLE"
+  , ALL_AND_SHUFFLE: "REPEAT_ALL_AND_SHUFFLE"
+};
+
+export const ResumeState = {
+    PLAYBACK_START: "PLAYBACK_START"
+  , PLAYBACK_PAUSE: "PLAYBACK_PAUSE"
+};
+
+export const StreamType = {
+    BUFFERED: "BUFFERED"
+  , LIVE: "LIVE"
+  , OTHER: "OTHER"
+};
+
+export const TextTrackEdgeType = {
+    NONE: "NONE"
+  , OUTLINE: "OUTLINE"
+  , DROP_SHADOW: "DROP_SHADOW"
+  , RAISED: "RAISED"
+  , DEPRESSED: "DEPRESSED"
+};
+
+export const TextTrackFontGenericFamily = {
+    SANS_SERIF: "SANS_SERIF"
+  , MONOSPACED_SANS_SERIF: "MONOSPACED_SANS_SERIF"
+  , SERIF: "SERIF"
+  , MONOSPACED_SERIF: "MONOSPACED_SERIF"
+  , CASUAL: "CASUAL"
+  , CURSIVE: "CURSIVE"
+  , SMALL_CAPITALS: "SMALL_CAPITALS"
+};
+
+export const TextTrackFontStyle = {
+    NORMAL: "NORMAL"
+  , BOLD: "BOLD"
+  , BOLD_ITALIC: "BOLD_ITALIC"
+  , ITALIC: "ITALIC"
+};
+
+export const TextTrackType = {
+    SUBTITLES: "SUBTITLES"
+  , CAPTIONS: "CAPTIONS"
+  , DESCRIPTIONS: "DESCRIPTIONS"
+  , CHAPTERS: "CHAPTERS"
+  , METADATA: "METADATA"
+};
+
+export const TextTrackWindowType = {
+    NONE: "NONE"
+  , NORMAL: "NORMAL"
+  , ROUNDED_CORNERS: "ROUNDED_CORNERS"
+};
+
+export const TrackType = {
+    TEXT: "TEXT"
+  , AUDIO: "AUDIO"
+  , VIDEO: "VIDEO"
+};

ext/src/shim/cast/media/index.ts

@@ -0,0 +1,98 @@
+"use strict";
+
+import EditTracksInfoRequest from "./classes/EditTracksInfoRequest";
+import GenericMediaMetadata from "./classes/GenericMediaMetadata";
+import GetStatusRequest from "./classes/GetStatusRequest";
+import LoadRequest from "./classes/LoadRequest";
+import Media from "./classes/Media";
+import MediaInfo from "./classes/MediaInfo";
+import MovieMediaMetadata from "./classes/MovieMediaMetadata";
+import MusicTrackMediaMetadata from "./classes/MusicTrackMediaMetadata";
+import PauseRequest from "./classes/PauseRequest";
+import PhotoMediaMetadata from "./classes/PhotoMediaMetadata";
+import PlayRequest from "./classes/PlayRequest";
+import QueueInsertItemsRequest from "./classes/QueueInsertItemsRequest";
+import QueueItem from "./classes/QueueItem";
+import QueueLoadRequest from "./classes/QueueLoadRequest";
+import QueueRemoveItemsRequest from "./classes/QueueRemoveItemsRequest";
+import QueueReorderItemsRequest from "./classes/QueueReorderItemsRequest";
+import QueueSetPropertiesRequest from "./classes/QueueSetPropertiesRequest";
+import QueueUpdateItemsRequest from "./classes/QueueUpdateItemsRequest";
+import SeekRequest from "./classes/SeekRequest";
+import StopRequest from "./classes/StopRequest";
+import TextTrackStyle from "./classes/TextTrackStyle";
+import Track from "./classes/Track";
+import TvShowMediaMetadata from "./classes/TvShowMediaMetadata";
+import VolumeRequest from "./classes/VolumeRequest";
+
+import { IdleReason
+       , MediaCommand
+       , MetadataType
+       , PlayerState
+       , RepeatMode
+       , ResumeState
+       , StreamType
+       , TextTrackEdgeType
+       , TextTrackFontGenericFamily
+       , TextTrackFontStyle
+       , TextTrackType
+       , TextTrackWindowType
+       , TrackType } from "./enums";
+
+
+export default {
+    // Enums
+    IdleReason
+  , MediaCommand
+  , MetadataType
+  , PlayerState
+  , RepeatMode
+  , ResumeState
+  , StreamType
+  , TextTrackEdgeType
+  , TextTrackFontGenericFamily
+  , TextTrackFontStyle
+  , TextTrackType
+  , TextTrackWindowType
+  , TrackType
+
+    // Classes
+  , EditTracksInfoRequest
+  , GenericMediaMetadata
+  , GetStatusRequest
+  , LoadRequest
+  , Media
+  , MediaInfo
+  , MovieMediaMetadata
+  , MusicTrackMediaMetadata
+  , PauseRequest
+  , PhotoMediaMetadata
+  , PlayRequest
+  , QueueInsertItemsRequest
+  , QueueItem
+  , QueueLoadRequest
+  , QueueRemoveItemsRequest
+  , QueueReorderItemsRequest
+  , QueueSetPropertiesRequest
+  , QueueUpdateItemsRequest
+  , SeekRequest
+  , StopRequest
+  , TextTrackStyle
+  , Track
+  , TvShowMediaMetadata
+  , VolumeRequest
+
+  , timeout: {
+        editTracksInfo: 0
+      , getStatus: 0
+      , load: 0
+      , pause: 0
+      , play: 0
+      , queue: 0
+      , seek: 0
+      , setVolume: 0
+      , stop: 0
+    }
+
+  , DEFAULT_MEDIA_RECEIVER_APP_ID: "CC1AD845"
+};