Initial commit

This commit is contained in:
hensm
2018-06-08 04:56:02 +01:00
commit d815fb7af0
70 changed files with 8370 additions and 0 deletions

View File

@@ -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
]);
}
}