Initial commit

ext/src/shim/media/classes/EditTracksInfoRequest.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class EditTracksInfoRequest {
+    constructor (opt_activeTrackIds = null, opt_textTrackStyle = null) {
+        this.activeTrackIds = opt_activeTrackIds;
+        this.textTrackStyle = opt_textTrackStyle;
+    }
+}

ext/src/shim/media/classes/GenericMediaMetadata.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default class GenericMediaMetadata {
+    constructor () {
+        this.images = [];
+        this.metadataType = null;
+        this.releaseDate = null;
+        this.subtitle = null;
+        this.title = null;
+    }
+}

ext/src/shim/media/classes/GetStatusRequest.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class GetStatusRequest {
+    constructor () {
+        castConsole.info('GetStatusRequest');
+        this.customData = {};
+    }
+}

ext/src/shim/media/classes/LoadRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default class LoadRequest {
+  constructor (mediaInfo) {
+        this.activeTrackIds = [];
+        this.autoplay = false;
+        this.currentTime = 0;
+        this.customData = {};
+        this.media = mediaInfo;
+    }
+}

ext/src/shim/media/classes/Media.js

@@ -0,0 +1,202 @@
+"use strict";
+
+
+import Volume from "../../cast/classes/Volume";
+
+import { PlayerState
+       , RepeatMode
+       , MediaCommand } from "../enums";
+
+import _Error from "../../cast/classes/Error";
+import { ErrorCode } from "../../cast/enums";
+
+import { onMessage, sendMessage } from "../../messageBridge";
+
+import uuid from "uuid/v1";
+
+
+export default class Media {
+    constructor (sessionId, mediaSessionId, _internalSessionId) {
+        this._id = uuid();
+
+        this.activeTrackIds = [];
+        this.currentItemId = 1;
+        this.customData = {};
+        this.currentTime = 0;
+        this.idleReason = null;
+        this.items = [];
+        this.loadingItemId = null;
+        this.media = null;
+        this.mediaSessionId = mediaSessionId;
+        this.playbackRate = 1;
+        this.playerState = PlayerState.PAUSED;
+        this.preloadedItemId = null;
+        this.RepeatMode = RepeatMode.OFF;
+        this.sessionId = sessionId;
+        this.supportedMediaCommands = [
+            MediaCommand.PAUSE
+          , MediaCommand.SEEK
+          , MediaCommand.STREAM_VOLUME
+          , MediaCommand.STREAM_MUTE
+        ];
+        this.volume = new Volume();
+
+        this._sendMessage("bridge:bridgemedia/initialize", {
+            sessionId
+          , mediaSessionId
+          , _internalSessionId
+        });
+
+        onMessage(message => {
+            if (!message._id || message._id !== this._id) {
+                return;
+            }
+
+            switch (message.subject) {
+                case "shim:media/update":
+                    const status = message.data;
+                    this.currentTime = status.currentTime;
+                    this._lastCurrentTime = 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
+                    this._updateListeners.forEach(listener => listener(true));
+
+                    break;
+
+                case "shim:media/sendMediaMessageResponse":
+                    const { messageId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = this._sendMediaMessageCallbacks.get(messageId);
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else if (successCallback) {
+                        successCallback();
+                    }
+
+                    break;
+
+            }
+        });
+
+        this._updateListeners = new Set();
+        this._sendMediaMessageCallbacks = new Map();
+    }
+
+    _sendMessage (subject, data) {
+        sendMessage({
+            subject
+          , data
+          , _id: this._id
+        });
+    }
+
+    _sendMediaMessage (message, successCallback, errorCallback) {
+        message.mediaSessionId = this.mediaSessionId;
+        message.requestId = 0;
+        message.sessionId = this.sessionId;
+        message.customData = null;
+
+        const messageId = uuid();
+
+        this._sendMediaMessageCallbacks.set(messageId, [
+            successCallback
+          , errorCallback
+        ]);
+
+        this._sendMessage("bridge:bridgemedia/sendMediaMessage", {
+            message
+          , messageId
+        });
+    }
+
+    addUpdateListener (listener) {
+        this._updateListeners.add(listener);
+    }
+    editTracksInfo (editTracksInfoRequest, successCallback, errorCallback) {
+        console.log("STUB :: Media#editTracksInfo");
+    }
+    getEstimatedTime () {
+        if (!this.currentTime) return 0;
+        return this.currentTime + ((Date.now() / 1000) - this._lastCurrentTime);
+    }
+    getStatus (getStatusRequest, successCallback, errorCallback) {
+        this._sendMediaMessage({ type: "MEDIA_GET_STATUS" }
+              , successCallback, errorCallback);
+    }
+    pause (pauseRequest, successCallback, errorCallback) {
+        this._sendMediaMessage({ type: "PAUSE" }
+              , successCallback, errorCallback);
+    }
+    play (playRequest, successCallback, errorCallback) {
+        this._sendMediaMessage({ type: "PLAY" }
+              , successCallback, errorCallback);
+    }
+    queueAppendItem (item, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueAppendItem");
+    }
+    queueInsertItems (queueInsertItemsRequest, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueInsertItems");
+    }
+    queueJumpToItem (itemId, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueJumpToItem");
+    }
+    queueMoveItemToNewIndex (itemId, newIndex, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueMoveItemToNewIndex");
+    }
+    queueNext (successCallback, errorCallback) {
+        console.log("STUB :: Media#queueNext");
+    }
+    queuePrev (successCallback, errorCallback) {
+        console.log("STUB :: Media#queuePrev");
+    }
+    queueRemoveItem(itemId, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueRemoveItem");
+    }
+    queueReorderItems (queueReorderItemsRequest, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueReorderItems");
+    }
+    queueSetRepeatMode (repeatMode, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueSetRepeatMode");
+    }
+    queueUpdateItems (queueUpdateItemsRequest, successCallback, errorCallback) {
+        console.log("STUB :: Media#queueUpdateItems");
+    }
+    removeUpdateListener (listener) {
+        this._updateListeners.delete(listener);
+    }
+    seek (seekRequest, successCallback, errorCallback) {
+        console.log(seekRequest);
+        this._sendMediaMessage({
+                type: "SEEK"
+              , currentTime: seekRequest.currentTime
+          }, successCallback, errorCallback);
+    }
+    setVolume (volumeRequest, successCallback, errorCallback) {
+        this._sendMediaMessage({
+            type: "SET_VOLUME"
+          , volume: volumeRequest.volume
+        }, successCallback, errorCallback);
+    }
+    stop (stopRequest, successCallback, errorCallback) {
+        this._sendMediaMessage({ type: "STOP" }
+              , successCallback, errorCallback);
+    }
+    supportsCommand (command) {
+        console.log("STUB :: Media#supportsCommand");
+    }
+}

ext/src/shim/media/classes/MediaInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { StreamType } from "../enums";
+
+export default class MediaInfo {
+	constructor (contentId, contentType) {
+		this.contentId = contentId;
+		this.contentType = contentType;
+		this.customData = {};
+		this.duration = null;
+		this.metadata = null;
+		this.streamType = StreamType.BUFFERED;
+		this.textTrackStyle = null;
+		this.tracks = [];
+	}
+}

ext/src/shim/media/classes/MovieMediaMetadata.js

@@ -0,0 +1,12 @@
+"use strict";
+
+export default class MovieMediaMetadata {
+    constructor () {
+        this.images = [];
+        this.metadataType = null;
+        this.releaseDate = null;
+        this.studio = null;
+        this.subtitle = null;
+        this.title = null;
+    }
+}

ext/src/shim/media/classes/MusicTrackMediaMetadata.js

@@ -0,0 +1,17 @@
+"use strict";
+
+export default class MusicTrackMediaMetadata {
+  constructor () {
+        this.albumArtist = null;
+        this.albumName = null;
+        this.artist = null;
+        this.composer = null;
+        this.discNumber = null;
+        this.images = [];
+        this.metadataType = this.type = 3;
+        this.releaseDate = null;
+        this.songName = null;
+        this.title = null;
+        this.trackNumber = null;
+    }
+}

ext/src/shim/media/classes/PauseRequest.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export default class PauseRequest {
+    constructor () {
+        this.customData = {};
+    }
+}

ext/src/shim/media/classes/PhotoMediaMetadata.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export default class PhotoMediaMetadata {
+  constructor () {
+        this.artist = null;
+        this.creationDateTime = null;
+        this.height = null;
+        this.images = [];
+        this.latitude = null;
+        this.location = null;
+        this.longitude = null;
+        this.metadataType = null;
+        this.title = null;
+        this.width = null;
+    }
+}

ext/src/shim/media/classes/PlayRequest.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export default class PlayRequest {
+    constructor () {
+        this.customData = {};
+    }
+}

ext/src/shim/media/classes/QueueInsertItemsRequest.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export default class QueueInsertItemsRequest {
+  constructor (itemsToInsert) {
+        this.customData = {};
+        this.insertBefore = null;
+        this.items = itemsToInsert;
+    }
+}

ext/src/shim/media/classes/QueueItem.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export default class QueueItem {
+  constructor (mediaInfo) {
+        this.activeTrackIds = [];
+        this.autoplay = false;
+        this.customData = {};
+        this.itemId = null;
+        this.media = mediaInfo;
+        this.preloadTime = 10;
+        this.startTime = 0;
+    }
+}

ext/src/shim/media/classes/QueueLoadRequest.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import { RepeatMode } from "../enums";
+
+export default class QueueLoadRequest {
+    constructor (items) {
+        this.customData = {};
+        this.items = items;
+        this.repeatMode = RepeatMode.OFF;
+        this.startIndex = 0;
+    }
+}

ext/src/shim/media/classes/QueueRemoveItemsRequest.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class QueueRemoveItemsRequest {
+    constructor (itemIdsToRemove) {
+        this.customData = {};
+        this.itemIds = itemIdsToRemove;
+    }
+}

ext/src/shim/media/classes/QueueReorderItemsRequest.js

@@ -0,0 +1,10 @@
+"use strict";
+
+export default class QueueReorderItemsRequest {
+  constructor (itemIdsToReorder) {
+        this.customData = {};
+        this.type = "QUEUE_REORDER";
+        this.insertBefore = null;
+        this.itemIds = itemIdsToReorder;
+    }
+}

ext/src/shim/media/classes/QueueSetPropertiesRequest.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default class QueueSetPropertiesRequest {
+    constructor () {
+        this.type = "QUEUE_UPDATE";
+        this.customData = {};
+        this.repeatMode = null;
+        this.sessionId = null;
+        this.requestId = null;
+    }
+}

ext/src/shim/media/classes/QueueUpdateItemsRequest.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class QueueUpdateItemsRequest {
+    constructor () {
+        this.customData = {};
+        this.items = [];
+    }
+}

ext/src/shim/media/classes/SeekRequest.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export default class SeekRequest {
+    constructor () {
+        this.currentTime = null;
+        this.customData = {};
+        this.resumeState = null;
+    }
+}

ext/src/shim/media/classes/StopRequest.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export default class StopRequest {
+    constructor () {
+        this.customData = {};
+    }
+}

ext/src/shim/media/classes/TextTrackStyle.js

@@ -0,0 +1,18 @@
+"use strict";
+
+export default class TextTrackStyle {
+    constructor () {
+        this.backgroundColor = null;
+        this.customData = {};
+        this.edgeColor = null;
+        this.edgeType = null;
+        this.fontFamily = null;
+        this.fontGenericFamily = null;
+        this.fontScale = null;
+        this.fontStyle = null;
+        this.foregroundColor = null;
+        this.windowColor = null;
+        this.windowRoundedCornerRadius = null;
+        this.windowType = null;
+    }
+}

ext/src/shim/media/classes/Track.js

@@ -0,0 +1,14 @@
+"use strict";
+
+export default class Track {
+    constructor (trackId, trackType) {
+        this.customData = {};
+        this.language = null;
+        this.name = null;
+        this.subtype = null;
+        this.trackContentId = null;
+        this.trackContentType = null;
+        this.trackId = trackId;
+        this.type = trackType;
+    }
+}

ext/src/shim/media/classes/TvShowMediaMetadata.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export default class TvShowMediaMetadata {
+    constructor () {
+        this.episode = null;
+        this.images = [];
+        this.metadataType = null;
+        this.originalAirdate = null;
+        this.season = null;
+        this.seriesTitle = null;
+        this.title = null;
+    }
+}

ext/src/shim/media/classes/VolumeRequest.js

@@ -0,0 +1,8 @@
+"use strict";
+
+export default class VolumeRequest {
+    constructor (volume) {
+        this.volume = volume;
+        this.customData = {};
+    }
+}

ext/src/shim/media/enums/index.js

@@ -0,0 +1,92 @@
+"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: "GENERIC"
+  , MOVIE: "MOVIE"
+  , TV_SHOW: "TV_SHOW"
+  , MUSIC_TRACK: "MUSIC_TRACK"
+  , PHOTO: "PHOTO"
+};
+
+export const PlayerState = {
+    IDLE: "IDLE"
+  , PLAYING: "PLAYING"
+  , PAUSED: "PAUSED"
+  , BUFFERING:  "BUFFERING"
+};
+
+export const RepeatMode = {
+    OFF: "OFF"
+  , ALL: "ALL"
+  , SINGLE: "SINGLE"
+  , ALL_AND_SHUFFLE: "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"
+  , 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/media/index.js

@@ -0,0 +1,86 @@
+"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
+
+  , DEFAULT_MEDIA_RECEIVER_APP_ID: "CC1AD845"
+};