sam_oneal/fx_cast
1
0
Fork 0
mirror of https://github.com/hensm/fx_cast.git synced 2026-06-12 10:39:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Set transportId on Session

Browse Source
This commit is contained in:
hensm
2019-01-11 01:48:54 +00:00
parent c3e61dd95d
commit ab82229228
1 changed files with 320 additions and 319 deletions
Download Patch File Download Diff File Expand all files Collapse all files

639
ext/src/shim/cast/classes/Session.js
View File

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