Initial commit

ext/src/shim/cast/classes/ApiConfig.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export default class ApiConfig {
+    constructor (
+            sessionRequest
+          , sessionListener
+          , receiverListener
+          , opt_autoJoinPolicy
+          , opt_defaultActionPolicy) {
+
+        this.autoJoinPolicy
+        this.receiverListener = receiverListener;
+        this.sessionListener = sessionListener;
+        this.sessionRequest = sessionRequest;
+    }
+};

ext/src/shim/cast/classes/DialRequest.js

@@ -0,0 +1,12 @@
+"use strict";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.DialRequest
+export default class DialRequest {
+    constructor (
+            appName
+          , opt_launchParameter = null) {
+
+        this.appName = appName;
+        this.launchParameter = opt_launchParameter;
+    }
+};

ext/src/shim/cast/classes/Error.js

@@ -0,0 +1,14 @@
+"use strict";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.Error
+export default class Error {
+    constructor (
+            code
+          , opt_description = null
+          , opt_details = null) {
+
+        this.code = code;
+        this.description = opt_description;
+        this.details = opt_details;
+    }
+};

ext/src/shim/cast/classes/Image.js

@@ -0,0 +1,11 @@
+"use strict";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.Image
+export default class Image {
+    width = null;
+    height = null;
+
+    constructor (url) {
+        this.url = url;
+    }
+};

ext/src/shim/cast/classes/Receiver.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { Capability
+       , ReceiverType } from "../enums";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.Receiver
+export default class Receiver {
+    constructor (
+            label
+          , friendlyName
+          , opt_capabilities = [
+                Capability.VIDEO_OUT
+              , Capability.AUDIO_OUT ]
+          , opt_volume = null) {
+
+        this.capabilities = opt_capabilities;
+        this.displayStatus = null;
+        this.friendlyName = friendlyName;
+        this.isActiveInput = null;
+        this.label = label;
+        this.receiverType = ReceiverType.CAST;
+        this.volume = opt_volume;
+    }
+};

ext/src/shim/cast/classes/ReceiverDisplayStatus.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.ReceiverDisplayStatus
+export default class ReceiverDisplayStatus {
+    constructor (statusText, appImages) {
+        this.appImages = appImages;
+        this.showStop = null;
+        this.statusText = statusText;
+    }
+};

ext/src/shim/cast/classes/SenderApplication.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.SenderApplication
+export default class SenderApplication {
+    constructor (platform) {
+        this.packageId = null;
+        this.platform = platform;
+        this.url = null;
+    }
+};

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

@@ -0,0 +1,319 @@
+"use strict";
+
+import _Error   from "./Error";
+import Volume   from "./Volume";
+import Media    from "../../media/classes/Media";
+
+import { SessionStatus
+       , ErrorCode
+       , VolumeControlType } from "../enums";
+
+import { onMessage, sendMessage } from "../../messageBridge";
+
+import uuid from "uuid/v1";
+
+
+export default class Session {
+    constructor (
+            sessionId
+          , appId
+          , displayName
+          , appImages
+          , receiver
+          , successCallback) {
+
+        this._id = uuid();
+        this._messageListeners = new Map();
+        this._updateListeners = new Set();
+
+        this._sendMessageCallbacks = new Map();
+        this._setReceiverMutedCallbacks = new Map();
+        this._setReceiverVolumeLevelCallbacks = new Map();
+        this._stopCallbacks = new Map();
+
+        this.sessionId = sessionId;
+        this.appId = appId;
+        this.appImages = appImages;
+        this.displayName = displayName;
+        this.receiver = receiver;
+
+        this.media = [];
+        this.namespaces = [];
+        this.senderApps = [];
+        this.status = SessionStatus.DISCONNECTED;
+        this.statusText = null;
+
+        this._sendMessage("bridge:bridgesession/initialize", {
+            address: receiver._address
+          , port: receiver._port
+          , appId
+          , sessionId
+        });
+
+
+        onMessage(message => {
+            // Filter other session messages
+            if (message._id && message._id !== this._id) {
+                return;
+            }
+
+            switch (message.subject) {
+                case "shim:session/stopped":
+                    this.status = SessionStatus.STOPPED;
+                    this._updateListeners.forEach(listener => listener());
+                    break;
+
+                case "shim:session/connected":
+                    this.status = SessionStatus.CONNECTED;
+                    this.sessionId = message.data.sessionId;
+                    this.namespaces = message.data.namespaces;
+                    this.displayName = message.data.displayName;
+                    this.statusText = message.data.statusText;
+
+                    if (successCallback) {
+                        successCallback(this);
+                    }
+
+                    break;
+
+                case "shim:session/updateStatus":
+                    if (message.data.volume) {
+                        if (!this.receiver.volume) {
+                            const receiverVolume = new Volume(
+                                    message.data.volume.level
+                                  , message.data.volume.muted);
+
+                            receiverVolume.controlType = message.data.volume.controlType;
+                            receiverVolume.stepInterval = message.data.volume.stepInterval;
+
+                            this.receiver.volume = receiverVolume;
+                        } else {
+                            this.receiver.volume.level = message.data.volume.level;
+                            this.receiver.volume.muted = message.data.volume.muted;
+                        }
+                    }
+                    break;
+
+
+                case "shim:session/impl_addMessageListener": {
+                    const { namespace, data } = message.data;
+                    this._messageListeners.get(namespace).forEach(
+                            listener => listener(namespace, data));
+                    break;
+                }
+
+                case "shim:session/impl_sendMessage": {
+                    const { messageId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = this._sendMessageCallbacks.get(messageId)
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else if (successCallback) {
+                        successCallback();
+                    }
+                    this._sendMessageCallbacks.delete(messageId);
+                    break;
+                }
+
+                case "shim:session/impl_setReceiverMuted": {
+                    const { volumeId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = this._setReceiverMutedCallbacks.get(volumeId);
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else if (successCallback) {
+                        successCallback();
+                    }
+                    break;
+                    this._setReceiverMutedCallbacks.delete(volumeId);
+                }
+
+                case "shim:session/impl_setReceiverVolumeLevel": {
+                    const { volumeId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = this._setReceiverVolumeLevelCallbacks.get(volumeId);
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else if (successCallback) {
+                        successCallback();
+                    }
+                    this._setReceiverVolumeLevelCallbacks.delete(volumeId);
+                    break;
+                }
+
+                case "shim:session/impl_stop": {
+                    const { stopId, error } = message.data;
+                    const [ successCallback, errorCallback ]
+                            = this._stopCallbacks.get(stopId);
+
+                    if (error && errorCallback) {
+                        errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+                    } else {
+                        this.status = SessionStatus.STOPPED;
+                        this._updateListeners.forEach(listener => listener());
+
+                        if (successCallback) {
+                            successCallback();
+                        }
+                    }
+                    this._stopCallbacks.delete(stopId);
+                    break;
+                }
+
+            }
+        });
+    }
+
+    _sendMessage (subject, data = {}) {
+        sendMessage({
+            subject
+          , data
+          , _id: this._id
+        });
+    }
+
+
+    addMediaListener (listener) {
+        console.info("STUB :: Session#addMediaListener")
+    }
+
+    addMessageListener (namespace, listener) {
+        if (!this._messageListeners.has(namespace)) {
+            this._messageListeners.set(namespace, new Set());
+        }
+        this._messageListeners.get(namespace).add(listener);
+        this._sendMessage("bridge:bridgesession/impl_addMessageListener", {
+            namespace
+        });
+    }
+
+    addUpdateListener (listener) {
+        this._updateListeners.add(listener);
+    }
+
+    leave (successCallback, errorCallback) {
+        const id = uuid();
+
+        this._sendMessage("bridge:bridgesession/impl_leave", { id });
+
+        this._leaveCallbacks.set(id, [
+            successCallback
+          , errorCallback
+        ]);
+    }
+
+    loadMedia (loadRequest, successCallback, errorCallback) {
+        this.sendMediaMessage({
+            type: "LOAD"
+          , requestId: 0
+          , media: loadRequest.media
+          , activeTrackIds: loadRequest.activeTrackIds || []
+          , autoplay: loadRequest.autoplay || false
+          , currentTime: loadRequest.currentTime || 0
+          , customData: loadRequest.customData || {}
+          , repeatMode: "REPEAT_OFF"
+        });
+
+        let hasResponded = false;
+
+        this.addMessageListener("urn:x-cast:com.google.cast.media"
+              , (namespace, data) => {
+            if (hasResponded) return;
+
+            const mediaObject = JSON.parse(data);
+
+            if (mediaObject.status && mediaObject.status.length > 0) {
+                hasResponded = true;
+
+                const media = new Media(
+                        this.sessionId
+                      , mediaObject.status[0].mediaSessionId
+                      , this._id);
+
+                media.media = loadRequest.media;
+                this.media = [ media ];
+
+                media.play();
+                successCallback(media);
+            } else {
+                errorCallback(new _Error(ErrorCode.SESSION_ERROR));
+            }
+        })
+    }
+
+    queueLoad () {
+        console.info("STUB :: Session#queueLoad");
+    }
+    removeMediaListener (listener) {
+        console.info("STUB :: Session#removeMediaListener");
+    }
+    removeMessageListener (namespace, listener) {
+        this._messageListeners.get(namespace).delete(listener);
+    }
+    removeUpdateListener (namespace, listener) {
+        this._updateListeners.delete(listener);
+    }
+
+    sendMediaMessage (message) {
+        this.sendMessage(
+                "urn:x-cast:com.google.cast.media"
+              , message
+              , () => {}
+              , () => {});
+    }
+
+    sendMessage (namespace, message, successCallback, errorCallback) {
+        const messageId = uuid();
+
+        this._sendMessage("bridge:bridgesession/impl_sendMessage", {
+            namespace
+          , message
+          , messageId
+        });
+
+        this._sendMessageCallbacks.set(messageId, [
+            successCallback
+          , errorCallback
+        ]);
+    }
+
+    setReceiverMuted (muted, successCallback, errorCallback) {
+        const volumeId = uuid();
+
+        this._sendMessage("bridge:bridgesession/impl_setReceiverMuted", {
+            muted
+          , volumeId
+        });
+
+        this._setReceiverMutedCallbacks.set(volumeId, [
+            successCallback
+          , errorCallback
+        ]);
+    }
+
+    setReceiverVolumeLevel (newLevel, successCallback, errorCallback) {
+        const volumeId = uuid();
+        this._sendMessage("bridge:bridgesession/impl_setReceiverVolumeLevel", {
+            newLevel
+          , volumeId
+        });
+
+        this._setReceiverVolumeLevelCallbacks.set(volumeId, [
+            successCallback
+          , errorCallback
+        ]);
+    }
+
+    stop (successCallback, errorCallback) {
+        const stopId = uuid();
+        this._sendMessage("bridge:bridgesession/impl_stop", { stopId });
+
+        this._stopCallbacks.set(stopId, [
+            successCallback
+          , errorCallback
+        ]);
+    }
+}

ext/src/shim/cast/classes/SessionRequest.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { Capability } from "../enums";
+import { requestSession as requestSessionTimeout } from "../../timeout.js";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.SessionRequest
+export default class SessionRequest {
+    constructor (
+            appId
+          , opt_capabilities = [
+                Capability.VIDEO_OUT
+              , Capability.AUDIO_OUT ]
+          , opt_timeout = null) {
+
+        this.appId = appId;
+        this.capabilities = opt_capabilities;
+        this.language = null;
+        this.requestSessionTimeout = requestSessionTimeout;
+    }
+};

ext/src/shim/cast/classes/Timeout.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import * as timeouts from "../../timeout.js";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.Timeout
+export default class Timeout {
+    constructor () {
+        Object.assign(this, timeouts);
+    }
+};

ext/src/shim/cast/classes/Volume.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { VolumeControlType } from "../enums";
+
+// https://developers.google.com/cast/docs/reference/chrome/chrome.cast.Volume
+export default class Volume {
+    constructor (
+            opt_level = null
+          , opt_muted = null) {
+        this.level = opt_level;
+        this.muted = opt_muted;
+    }
+};

ext/src/shim/cast/classes/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import ApiConfig             from "./ApiConfig";
+import DialRequest           from "./DialRequest";
+import Error_                from "./Error";
+import Image_                from "./Image";
+import Receiver              from "./Receiver";
+import ReceiverDisplayStatus from "./ReceiverDisplayStatus";
+import SenderApplication     from "./SenderApplication";
+import Session               from "./Session";
+import SessionRequest        from "./SessionRequest";
+import Timeout               from "./Timeout";
+import Volume                from "./Volume";
+
+
+export default {
+    AutoJoinPolicy
+  , Capability
+  , DefaultActionPolicy
+  , DialAppState
+  , ErrorCode
+  , ReceiverAction
+  , ReceiverAvailability
+  , ReceiverType
+  , SenderPlatform
+  , SessionStatus
+  , VolumeControlType
+};

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

@@ -0,0 +1,74 @@
+"use strict";
+
+export const AutoJoinPolicy = {
+    TAB_AND_ORIGIN_SCOPED: "tab_and_origin_scoped"
+  , ORIGIN_SCOPED: "origin_scoped"
+  , PAGE_SCOPED: "page_scoped"
+};
+
+export const Capability = {
+    VIDEO_OUT: "video_out"
+  , AUDIO_OUT: "audio_out"
+  , VIDEO_IN: "video_in"
+  , AUDIO_IN: "audio_in"
+  , MULTIZONE_GROUP: "multizone_group"
+};
+
+export const DefaultActionPolicy = {
+    CREATE_SESSION: "create_session"
+  , CAST_THIS_TAB: "cast_this_tab"
+};
+
+export const DialAppState = {
+    RUNNING: "running"
+  , STOPPED: "stopped"
+  , ERROR: "error"
+};
+
+export const ErrorCode = {
+    CANCEL: "cancel"
+  , TIMEOUT: "timeout"
+  , API_NOT_INITIALIZED: "api_not_initialized"
+  , INVALID_PARAMETER: "invalid_parameter"
+  , EXTENSION_NOT_COMPATIBLE: "extension_not_compatible"
+  , EXTENSION_MISSING: "extension_missing"
+  , RECEIVER_UNAVAILABLE: "receiver_unavailable"
+  , SESSION_ERROR: "session_error"
+  , CHANNEL_ERROR: "channel_error"
+  , LOAD_MEDIA_FAILED: "load_media_failed"
+};
+
+export const ReceiverAction = {
+    CAST: "cast"
+  , STOP: "stop"
+};
+
+export const ReceiverAvailability = {
+    AVAILABLE: "available"
+  , UNAVAILABLE: "unavailable"
+};
+
+export const ReceiverType = {
+    CAST: "cast"
+  , DIAL: "dial"
+  , HANGOUT: "hangout"
+  , CUSTOM: "custom"
+};
+
+export const SenderPlatform = {
+    CHROME: "chrome"
+  , IOS: "ios"
+  , ANDROID: "android"
+};
+
+export const SessionStatus = {
+    CONNECTED: "connected"
+  , DISCONNECTED: "disconnected"
+  , STOPPED: "stopped"
+};
+
+export const VolumeControlType = {
+    ATTENUATION: "attenuation"
+  , FIXED: "fixed"
+  , MASTER: "master"
+};

ext/src/shim/cast/index.js

@@ -0,0 +1,261 @@
+"use strict";
+
+import ApiConfig             from "./classes/ApiConfig";
+import DialRequest           from "./classes/DialRequest";
+import Error_                from "./classes/Error";
+import Image_                from "./classes/Image";
+import Receiver              from "./classes/Receiver";
+import ReceiverDisplayStatus from "./classes/ReceiverDisplayStatus";
+import SenderApplication     from "./classes/SenderApplication";
+import Session               from "./classes/Session";
+import SessionRequest        from "./classes/SessionRequest";
+import Timeout               from "./classes/Timeout";
+import Volume                from "./classes/Volume";
+
+import { AutoJoinPolicy
+       , Capability
+       , DefaultActionPolicy
+       , DialAppState
+       , ErrorCode
+       , ReceiverAction
+       , ReceiverAvailability
+       , ReceiverType
+       , SenderPlatform
+       , SessionStatus
+       , VolumeControlType } from "./enums";
+
+import { requestSession as requestSessionTimeout } from "../timeout";
+
+import state from "../state";
+
+import { onMessage, sendMessage } from "../messageBridge";
+
+
+const cast = {
+    // Enums
+    AutoJoinPolicy
+  , Capability
+  , DefaultActionPolicy
+  , DialAppState
+  , ErrorCode
+  , ReceiverAction
+  , ReceiverAvailability
+  , ReceiverType
+  , SenderPlatform
+  , SessionStatus
+  , VolumeControlType
+
+    // Classes
+  , ApiConfig
+  , DialRequest
+  , Error: Error_
+  , Image: Image_
+  , Receiver
+  , ReceiverDisplayStatus
+  , SenderApplication
+  , Session
+  , SessionRequest
+  , Timeout
+  , Volume
+
+  , timeout: new Timeout()
+  , isAvailable: true
+  , VERSION: [ 1, 2 ]
+};
+
+
+const receiverListeners = new Set();
+
+let sessionSuccessCallback;
+let sessionErrorCallback;
+
+
+cast.addReceiverActionListener = (listener) => {
+    console.info("Caster (Debug): cast.addReceiverActionListener");
+    receiverListeners.add(listener);
+};
+
+cast.initialize = (
+        apiConfig
+      , successCallback
+      , errorCallback) => {
+
+    console.info("Caster (Debug): cast.initialize");
+
+    // Already initialized
+    if (state.apiConfig) {
+        errorCallback(new Error_(ErrorCode.RECEIVER_UNAVAILABLE));
+        return;
+    }
+
+    state.apiConfig = apiConfig;
+
+    sendMessage({
+        subject: "bridge:discover"
+    });
+
+    apiConfig.receiverListener(state.receiverList.length
+        ? ReceiverAvailability.AVAILABLE
+        : ReceiverAvailability.UNAVAILABLE);
+
+    successCallback();
+};
+
+cast.logMessage = (message) => {
+    console.log("CAST MSG:", message);
+};
+
+cast.precache = (data) => {
+    console.info("STUB :: cast.precache");
+};
+
+cast.removeReceiverActionListener = (listener) => {
+    receiverListeners.delete(listener);
+}
+
+cast.requestSession = (
+        successCallback
+      , errorCallback
+      , opt_sessionRequest = state.apiConfig.sessionRequest) => {
+
+    console.info("Caster (Debug): cast.requestSession");
+
+    // Called before initialization
+    if (!state.apiConfig) {
+        errorCallback(new Error_(ErrorCode.API_NOT_INITIALIZED));
+        return;
+    }
+
+    // No available receivers
+    if (!state.receiverList.length) {
+        errorCallback(new Error_(ErrorCode.RECEIVER_UNAVAILABLE));
+        return;
+    }
+
+    sessionSuccessCallback = successCallback;
+    sessionErrorCallback = errorCallback;
+
+    // Open destination chooser
+    sendMessage({
+        subject: "main:openPopup"
+    });
+};
+
+cast.requestSessionById = (sessionId) => {
+    console.info("STUB :: cast.requestSessionById");
+};
+
+cast.setCustomReceivers = (receivers, successCallback, errorCallback) => {
+    console.info("STUB :: cast.setCustomReceivers");
+};
+
+cast.setPageContext = (win) => {
+    console.info("STUB :: cast.setPageContext");
+};
+
+cast.setReceiverDisplayStatus = (sessionId) => {
+    console.info("STUB :: cast.setReceiverDisplayStatus");
+};
+
+cast.unescape = (escaped) => unescape(escaped);
+
+
+onMessage(message => {
+    switch (message.subject) {
+        /**
+         * Cast destination found (serviceUp). Set the API availability
+         * property and call the page event function (__onGCastApiAvailable).
+         */
+        case "shim:serviceUp":
+            const receiver = new Receiver(
+                    message.data.id
+                  , message.data.friendlyName);
+
+            receiver._address = message.data.address;
+            receiver._port = message.data.port;
+
+            if (state.receiverList.find(r => r.label === receiver.label)) {
+                break;
+            }
+
+            state.receiverList.push(receiver);
+
+            // Notify listeners of new cast destination
+            state.apiConfig.receiverListener(ReceiverAvailability.AVAILABLE);
+            receiverListeners.forEach(
+                    listener => listener(ReceiverAvailability.AVAILABLE));
+
+            break;
+
+        /**
+         * Cast destination lost (serviceDown). Remove from the receiver list
+         * and update availability state.
+         */
+        case "shim:serviceDown":
+            state.receiverList = state.receiverList.filter(
+                    receiver => receiver.label !== message.data.id);
+
+            if (state.receiverList.length === 0) {
+                state.apiConfig.receiverListener(
+                        ReceiverAvailability.UNAVAILABLE);
+            }
+
+            break;
+
+        case "shim:selectReceiver":
+            console.info("Caster (Debug): Selected receiver");
+            const selectedReceiver = message.data;
+
+            const sessionConstructorArgs = [
+                state.sessionList.length             // sessionId
+              , state.apiConfig.sessionRequest.appId // appId
+              , selectedReceiver.friendlyName        // displayName
+              , []                                   // appImages
+              , selectedReceiver                     // receiver
+              , (session) => {
+                    sendMessage({
+                        subject: "popup:close"
+                    });
+
+                    state.apiConfig.sessionListener(session);
+                    sessionSuccessCallback(session);
+                }
+            ];
+
+            // If existing session active, stop it and start new one
+            if (state.sessionList.length) {
+                const lastSession
+                        = state.sessionList[state.sessionList.length - 1];
+
+                if (lastSession.status !== SessionStatus.STOPPED) {
+                    lastSession.stop(() => {
+                        state.sessionList.push(new Session(
+                                ...sessionConstructorArgs));
+                    });
+                    break;
+                }
+            }
+
+            state.sessionList.push(new Session(...sessionConstructorArgs));
+
+            break;
+
+        /**
+         * Popup is ready to receive data to populate the cast destination
+         * chooser.
+         */
+        case "shim:popupReady":
+            sendMessage({
+                subject: "popup:populate"
+              , data: state.receiverList
+            });
+            break;
+    }
+});
+
+// Trigger bridge mDNS discovery
+sendMessage({
+    subject: "main:initialize"
+});
+
+export default cast;

ext/src/shim/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import cast  from "./cast";
+import media from "./media";
+
+if (!window.chrome) {
+	window.chrome = {};
+}
+
+window.chrome.cast = cast;
+window.chrome.cast.media = media;
+
+// Call page's API loaded function if defined
+const readyFunction = window.__onGCastApiAvailable;
+console.log(readyFunction);
+if (readyFunction && typeof readyFunction === "function") {
+    readyFunction(true);
+}

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"
+};

ext/src/shim/messageBridge.js

@@ -0,0 +1,15 @@
+"use strict";
+
+export function onMessage (listener) {
+	document.addEventListener("__castMessage", ev => {
+		listener(JSON.parse(ev.detail));
+	});
+}
+
+export function sendMessage (message) {
+	const event = new CustomEvent("__castMessageResponse", {
+		detail: message
+	});
+
+	document.dispatchEvent(event);
+}

ext/src/shim/state.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// Global API state
+const state = {
+    apiConfig: null
+  , receiverList: []
+  , sessionList: []
+};
+
+export default state;

ext/src/shim/timeout.js

@@ -0,0 +1,7 @@
+"use strict";
+
+export const leaveSession = 3000;
+export const requestSession = 60000;
+export const sendCustomMessage = 3000;
+export const setReceiverVolume = 3000;
+export const stopSession = 3000;