@reactoo/watchtogether-sdk-js 2.8.47 → 2.8.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactoo/watchtogether-sdk-js",
-  "version": "2.8.47",
+  "version": "2.8.50",
   "description": "Javascript SDK for Reactoo",
   "main": "dist/watchtogether-sdk.min.js",
   "module": "dist/watchtogether-sdk.min.js",

package/src/models/iot.js

@@ -7,19 +7,12 @@ let iot = function () {
     let keepAliveIntervalId = null;
     let shouldBeConnected = false;
     let isConnecting = false;
-    let interruptCount = 0;
     let subscriptionFailureCount = 0;
 
     return {
 
         __promise: null,
 
-        __createNewWorker: () => {
-            this.__privates.iot.log('Creating new worker...');
-            this.__privates.iot.terminateWorker();
-            this.__privates.iot.initWorker();
-        },
-
         __updateCredentials: () => {
 
             if(isConnecting) {
@@ -28,7 +21,6 @@ let iot = function () {
             }
 
             this.__privates.iot.log('Updating Credentials...');
-            interruptCount = 0;
             subscriptionFailureCount = 0;
             isConnecting = true;
 
@@ -37,7 +29,8 @@ let iot = function () {
                     response.data.credentials.accessKeyId,
                     response.data.credentials.secretAccessKey,
                     response.data.credentials.sessionToken,
-                    response.data.credentials.expiration
+                    response.data.credentials.expiration,
+					__currentTopics
                 ))
                 .then((r) => {
                     isConnecting = false;
@@ -57,46 +50,39 @@ let iot = function () {
             return this.__privates.auth.__client
                 .then(client => client.apis.auth.iotSignIn({}, {requestBody: {suggestedTopics:true, domain: location.hostname}}))
         },
-
-        onConnect: (data, connectionId) => {
-            this.__privates.iot.log('MQTT client connected');
-        },
-        onClosed: (data, connectionId) => {
-            this.__privates.iot.log('MQTT client closed');
-            if(shouldBeConnected && !isConnecting) {
-                this.__privates.iot.log('Connection unexpectedly closed, reconnecting...');
-                this.iot.__createNewWorker();
-                this.iot.__updateCredentials();
-            }
+        onStopped: (data, connectionId) => {
+			this.__privates.iot.log('MQTT client disconnected');
         },
         onError: (data, connectionId) => {
-            this.__privates.iot.log('MQTT client error');
+			this.__privates.iot.log('MQTT client error');
+			if(shouldBeConnected && !isConnecting) {
+				this.__privates.iot.log('Connection unexpectedly closed, reconnecting...');
+				this.iot.__updateCredentials();
+			}
         },
         onDisconnect: (data, connectionId) => {
-            this.__privates.iot.log('MQTT client disconnect');
-        },
-        onInterrupt: (data, connectionId) => {
-            if(shouldBeConnected && !isConnecting && interruptCount > 10) {
-                this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
-                this.iot.__createNewWorker();
-                this.iot.__updateCredentials();
-            }
-            interruptCount++;
-            this.__privates.iot.log('MQTT client interrupt');
-        },
-        onResume: (data, connectionId) => {
-            this.__privates.iot.log('MQTT client resume');
+			this.__privates.iot.log('MQTT client closed');
+			if(shouldBeConnected && !isConnecting) {
+				this.__privates.iot.log('Connection unexpectedly closed, reconnecting...');
+				this.iot.__updateCredentials();
+			}
         },
+		onAttemptingConnect: (data, connectionId) => {
+			this.__privates.iot.log('MQTT client attempting_connect');
+		},
         onConnectionSuccess: (data, connectionId) => {
             this.__privates.iot.log('MQTT client connection_success');
         },
         onConnectionFailure: (data, connectionId) => {
-            if(shouldBeConnected && !isConnecting && interruptCount > 10) {
-                this.__privates.iot.log('Interrupt count exceeded, reconnecting...');
-                this.iot.__createNewWorker();
+
+			// ok this should not work as isConnecting should be true here and will be flipped after first onConnectionFailure
+			// but the aws library immediately tries new connection after failure so we get multiple onConnectionFailure calls
+			// so the second one will trigger updateCredentials again which is what we want
+
+            if(shouldBeConnected) {
+                this.__privates.iot.log('Retrying connection...');
                 this.iot.__updateCredentials();
             }
-            interruptCount++;
             this.__privates.iot.log('MQTT client connection_failure');
         },
 
@@ -107,12 +93,18 @@ let iot = function () {
                 return this.iot.__promise;
             }
 
-            interruptCount = 0;
             subscriptionFailureCount = 0;
             shouldBeConnected = true;
             isConnecting = true;
 
-            this.iot.__createNewWorker();
+			this.iot.$on('stopped', this.iot.onStopped, this);
+			this.iot.$on('error', this.iot.onError, this);
+			this.iot.$on('disconnection', this.iot.onDisconnect, this);
+			this.iot.$on('attemptingConnect', this.iot.onAttemptingConnect, this);
+			this.iot.$on('connectionSuccess', this.iot.onConnectionSuccess, this);
+			this.iot.$on('connectionFailure', this.iot.onConnectionFailure, this);
+			this.iot.$on('updateCredentials', this.iot.__updateCredentials, this);
+
             this.iot.__promise = new Promise((resolve, reject) => {
                 this.iot.getCredentials()
                     .then(response => {
@@ -141,16 +133,6 @@ let iot = function () {
 
             __currentTopics.clear();
 
-            this.iot.$on('connect', this.iot.onConnect, this);
-            this.iot.$on('closed', this.iot.onClosed, this);
-            this.iot.$on('error', this.iot.onError, this);
-            this.iot.$on('disconnect', this.iot.onDisconnect, this);
-            this.iot.$on('interrupt', this.iot.onInterrupt, this);
-            this.iot.$on('resume', this.iot.onResume, this);
-            this.iot.$on('connection_success', this.iot.onConnectionSuccess, this);
-            this.iot.$on('connection_failure', this.iot.onConnectionFailure, this);
-            this.iot.$on('updateCredentials', this.iot.__updateCredentials, this);
-
             this.iot.__promise
                 .then(([suggestedTopic, instance]) => {
                     if(!subscribeToSuggestedTopics) {
@@ -166,41 +148,39 @@ let iot = function () {
                 })
                 .catch((error) => {
                     this.__privates.iot.log('MQTT Login Error:', error);
-                    throw error;
                 });
 
-            return this.iot.__promise;
+			// we're not returning the promise because on error we will retry connection indefinitely
+            return true;
         },
 
         iotLogout: (keepCurrentTopics = false) => {
 
             if(!keepCurrentTopics) {
                 __currentTopics.clear();
-                this.__privates.iot.clearTopics();
             }
 
-            interruptCount = 0;
             subscriptionFailureCount = 0;
             shouldBeConnected = false;
 
             this.iot.disableVisibilityChangeListener();
             this.iot.disableKeepAliveInterval();
 
-            return this.__privates.iot.disconnect()
+            this.__privates.iot.disconnect()
                 .finally(() => {
-                    this.__privates.iot.terminateWorker();
-                    this.iot.$off('connect', this.iot.onConnect, this);
-                    this.iot.$off('closed', this.iot.onClosed, this);
-                    this.iot.$off('error', this.iot.onError, this);
-                    this.iot.$off('disconnect', this.iot.onDisconnect, this);
-                    this.iot.$off('interrupt', this.iot.onInterrupt, this);
-                    this.iot.$off('resume', this.iot.onResume, this);
-                    this.iot.$off('connection_success', this.iot.onConnectionSuccess, this);
-                    this.iot.$off('connection_failure', this.iot.onConnectionFailure, this);
-                    this.iot.$off('updateCredentials', this.iot.__updateCredentials, this);
+					this.iot.$off('stopped', this.iot.onStopped, this);
+					this.iot.$off('error', this.iot.onError, this);
+					this.iot.$off('disconnection', this.iot.onDisconnect, this);
+					this.iot.$off('attemptingConnect', this.iot.onAttemptingConnect, this);
+					this.iot.$off('connectionSuccess', this.iot.onConnectionSuccess, this);
+					this.iot.$off('connectionFailure', this.iot.onConnectionFailure, this);
+					this.iot.$off('updateCredentials', this.iot.__updateCredentials, this);
                     this.iot.__promise = null;
                     return true;
                 });
+
+			// we're not returning the promise because we're not returning anything useful anyway
+			return true;
         },
 
         isConnected: () => {
@@ -228,7 +208,6 @@ let iot = function () {
 
                         if(shouldBeConnected && !isConnecting && subscriptionFailureCount > 5) {
                             this.__privates.iot.log('Subscription failure exceeded, reconnecting...');
-                            this.iot.__createNewWorker();
                             this.iot.__updateCredentials();
                             return Promise.reject('subscription_failed');
                         }
@@ -278,11 +257,11 @@ let iot = function () {
         },
 
         checkConnection: () => {
-            return this.__privates.iot.checkConnection()
+            return this.__privates.iot.checkConnection(__currentTopics)
                 .catch(error => {
 
                     if(error?.cause === -1) {
-                        this.__privates.iot.log("We don't have a topic to check connection with");
+                        this.__privates.iot.log("We don't have a topic to check connection with or internet is down");
                         return;
                     }
 
@@ -297,7 +276,7 @@ let iot = function () {
                     }
 
                     this.__privates.iot.log('Connection check failed:', error);
-                    this.iot.__createNewWorker();
+
                     return this.iot.__updateCredentials();
                 });
         },
@@ -308,20 +287,7 @@ let iot = function () {
 
             clearInterval(keepAliveIntervalId);
             keepAliveIntervalId = setInterval(() => {
-                this.__privates.iot.checkConnection()
-                    .catch(error => {
-
-                        if(error?.cause === -1) {
-                            this.__privates.iot.log("We don't have a topic to check connection with or check was aborted");
-                            return;
-                        }
-
-                        if(shouldBeConnected && !isConnecting) {
-                            this.__privates.iot.log('Keepalive failed:', error);
-                            this.iot.__createNewWorker();
-                            this.iot.__updateCredentials();
-                        }
-                    });
+				this.iot.checkConnection();
             }, 15000);
         },
 

package/src/models/system.js

@@ -75,6 +75,10 @@ let system = function () {
 					}
 				}));
 		},
+		trackPlayback: ({objectId, eventType, currentTime, duration, quality, pageUrl, data} = {}) => {
+			return this.__privates.auth.__client
+				.then(client => client.apis.wt.trackPlayback({}, {requestBody: {objectId, eventType, currentTime, duration, quality, pageUrl, data}}));
+		},
 		getSchemas: () => {
 			return this.__privates.auth.__client.then(client => {
 				return client.spec?.components?.schemas

package/src/modules/wt-auth.js

@@ -115,7 +115,8 @@ class Auth {
 					isLoggedInAsInstanceAdmin: this.isLoggedInAs(this.__parsedJwt, 'instanceAdmin'),
 					isDemoAccount: this.isLoggedInAs(this.__parsedJwt, 'demo'),
 					isLoggedInAsAdmin: this.isLoggedInAs(this.__parsedJwt, 'admin'),
-					domain: this.getDomain(this.__parsedJwt)
+					domain: this.getDomain(this.__parsedJwt),
+					parentUserId: this.getParentUserId(this.__parsedJwt)
 				});
 				return client;
 			})
@@ -167,6 +168,11 @@ class Auth {
 		parsedJwt = parsedJwt || this.__parsedJwt;
 		return parsedJwt['custom:domain'];
 	}
+
+	getParentUserId(parsedJwt) {
+		parsedJwt = parsedJwt || this.__parsedJwt;
+		return parsedJwt ? parsedJwt['custom:parentUserId'] : null;
+	}
 	
 	parseJwt(jwt) {
 		if (!jwt || typeof jwt !== "string") return false;