@vouchfor/embeds 0.0.0-experiment.a2cd27b → 0.0.0-experiment.a499b59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vouchfor/embeds",
-  "version": "0.0.0-experiment.a2cd27b",
+  "version": "0.0.0-experiment.a499b59",
   "license": "MIT",
   "author": "Aaron Williams",
   "main": "dist/es/embeds.js",
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@lit/task": "^1.0.0",
-    "@vouchfor/media-player": "0.0.0-experiment.a2cd27b",
+    "@vouchfor/media-player": "0.0.0-experiment.a499b59",
     "uuid": "^9.0.1"
   },
   "peerDependencies": {

package/src/components/Embed/controllers/fetcher.ts

@@ -45,7 +45,7 @@ class FetcherController {
     });
 
     const vouch = await res.json();
-    this.host.dispatchEvent(new CustomEvent('vouch:loaded', { detail: vouchId }));
+    this.host.dispatchEvent(new CustomEvent('vouch:loaded', { detail: vouch?.id }));
 
     // HACK: we're currently using API Gateway caching on the embed API without any invalidation logic,
     // so to ensure that the cache stays up to date, whenever we detect a cache hit we trigger another

package/src/components/Embed/controllers/tracking.ts

@@ -4,15 +4,16 @@ import type { Embed } from '..';
 import type { VideoEventDetail } from '@vouchfor/media-player';
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
 
+import packageJson from '../../../../package.json';
 import { getEnvUrls } from '~/utils/env';
 
-// In seconds due to checking against node.currentTime
-const STREAMED_THROTTLE = 10;
+const MINIMUM_SEND_THRESHOLD = 1;
 
 type EmbedHost = ReactiveControllerHost & Embed;
 
 type TrackingEvent = 'VOUCH_LOADED' | 'VOUCH_RESPONSE_VIEWED' | 'VIDEO_PLAYED' | 'VIDEO_STREAMED';
 type TrackingPayload = {
+  vouchId?: string;
   answerId?: string;
   streamStart?: number;
   streamEnd?: number;
@@ -45,13 +46,14 @@ class TrackingController implements ReactiveController {
     host.addController(this);
   }
 
-  private _findVouchId() {
+  private _findVouchId(payload?: TrackingPayload) {
+    if (payload && 'vouchId' in payload) {
+      return payload.vouchId;
+    }
     if (this.host.vouch) {
-      if ('uuid' in this.host.vouch) {
-        return this.host.vouch.uuid;
-      }
       return this.host.vouch.id;
     }
+    return null;
   }
 
   private _createVisitor = (visitorId: string) => {
@@ -130,7 +132,7 @@ class TrackingController implements ReactiveController {
   };
 
   private _sendTrackingEvent = (event: TrackingEvent, payload?: TrackingPayload) => {
-    const vouchId = this._findVouchId();
+    const vouchId = this._findVouchId(payload);
 
     if (!vouchId || this.host.disableTracking) {
       return;
@@ -140,21 +142,45 @@ class TrackingController implements ReactiveController {
     const { client, tab, request, visitor } = this._getUids();
 
     navigator.sendBeacon(
-      `${publicApiUrl}/api/events`,
+      `${publicApiUrl}/api/v2/events`,
       JSON.stringify({
         event,
-        payload,
+        payload: {
+          ...payload,
+          vouchId
+        },
         context: {
           'x-uid-client': client,
           'x-uid-tab': tab,
           'x-uid-request': request,
           'x-uid-visitor': visitor,
-          'x-reporting-metadata': this._getReportingMetadata()
+          'x-reporting-metadata': this._getReportingMetadata(),
+          'x-embeds-version': packageJson.version
         }
       })
     );
   };
 
+  private _streamEnded = () => {
+    if (this._currentlyPlayingVideo) {
+      const { id, key } = this._currentlyPlayingVideo;
+      // Don't send a tracking event when seeking backwards
+      if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
+        // Send a video streamed event any time the stream ends to capture the time between starting
+        // the video and the video stopping for any reason (pausing, deleting the embed node or closing the browser)
+        this._sendTrackingEvent('VIDEO_STREAMED', {
+          answerId: id,
+          streamStart: this._streamStartTime[key],
+          streamEnd: this._streamLatestTime[key]
+        });
+      }
+
+      // Make sure these events are only sent once by deleting the start and latest times
+      delete this._streamStartTime[key];
+      delete this._streamLatestTime[key];
+    }
+  };
+
   private _handleVouchLoaded = ({ detail: vouchId }: CustomEvent<string>) => {
     if (!vouchId) {
       return;
@@ -162,7 +188,7 @@ class TrackingController implements ReactiveController {
 
     // Only send loaded event once per session
     if (!this._hasLoaded[vouchId]) {
-      this._sendTrackingEvent('VOUCH_LOADED');
+      this._sendTrackingEvent('VOUCH_LOADED', { vouchId });
       this._hasLoaded[vouchId] = true;
     }
   };
@@ -186,54 +212,60 @@ class TrackingController implements ReactiveController {
       this._answersViewed[key] = true;
     }
 
-    this._streamStartTime[key] = node.currentTime;
-    this._streamLatestTime[key] = node.currentTime;
-  };
-
-  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
-    // We only want to count any time that the video is actually playing
-    if (!this.host.paused) {
-      this._currentlyPlayingVideo = { id, key, node };
+    if (!this._streamStartTime[key]) {
+      this._streamStartTime[key] = node.currentTime;
       this._streamLatestTime[key] = node.currentTime;
     }
+  };
 
+  private _handleVideoTimeUpdate = ({ detail: { id, key, node } }: CustomEvent<VideoEventDetail>) => {
     if (
-      !node.paused &&
+      // We only want to count any time that the video is actually playing
       !this.host.paused &&
-      // Only fire the video seeked event when this video is the active one
-      id === this.host.scene?.video?.id &&
-      // Throttle the frequency that we send streamed events while playing
-      this._streamLatestTime[key] - this._streamStartTime[key] > STREAMED_THROTTLE
+      // Only update the latest time if this event fires for the currently active video
+      id === this.host.scene?.video?.id
     ) {
-      this._sendTrackingEvent('VIDEO_STREAMED', {
-        answerId: id,
-        streamStart: this._streamStartTime[key],
-        streamEnd: this._streamLatestTime[key]
-      });
-
-      this._streamStartTime[key] = node.currentTime;
+      this._currentlyPlayingVideo = { id, key, node };
+      this._streamLatestTime[key] = node.currentTime;
     }
   };
 
   private _handleVideoPause = ({ detail: { id, key } }: CustomEvent<VideoEventDetail>) => {
-    // Don't send a tracking event when seeking backwards
-    if (this._streamLatestTime[key] > this._streamStartTime[key]) {
-      // Send a video streamed event any time the video pauses then reset the streamed state
-      // We do this to capture the last bit of time that the video was played between the previous
-      // stream event and the video being paused manually or stopping because it ended
+    if (this._streamLatestTime[key] > this._streamStartTime[key] + MINIMUM_SEND_THRESHOLD) {
       this._sendTrackingEvent('VIDEO_STREAMED', {
         answerId: id,
         streamStart: this._streamStartTime[key],
         streamEnd: this._streamLatestTime[key]
       });
     }
-    this._currentlyPlayingVideo = null;
     delete this._streamStartTime[key];
     delete this._streamLatestTime[key];
   };
 
+  private _pageUnloading = () => {
+    this._streamEnded();
+    // This will try to send the same stream event again so we delete the start and latest
+    // time in stream ended so that there is no times to send and the pause event does nothing
+    this.host.pause();
+  };
+
+  private _handleVisibilityChange = () => {
+    if (document.visibilityState === 'hidden') {
+      this._pageUnloading();
+    }
+  };
+
+  private _handlePageHide = () => {
+    this._pageUnloading();
+  };
+
   hostConnected() {
     requestAnimationFrame(() => {
+      if ('onvisibilitychange' in document) {
+        document.addEventListener('visibilitychange', this._handleVisibilityChange);
+      } else {
+        window.addEventListener('pagehide', this._handlePageHide);
+      }
       this.host.addEventListener('vouch:loaded', this._handleVouchLoaded);
       this.host.mediaPlayer?.addEventListener('play', this._handlePlay);
       this.host.mediaPlayer?.addEventListener('video:play', this._handleVideoPlay);
@@ -243,20 +275,12 @@ class TrackingController implements ReactiveController {
   }
 
   hostDisconnected() {
-    if (this._currentlyPlayingVideo) {
-      const { id, key } = this._currentlyPlayingVideo;
-      if (this._streamLatestTime[key] > this._streamStartTime[key]) {
-        // Send a video streamed event any time the video pauses then reset the streamed state
-        // We do this to capture the last bit of time that the video was played between the previous
-        // stream event and the video being paused manually or stopping because it ended
-        this._sendTrackingEvent('VIDEO_STREAMED', {
-          answerId: id,
-          streamStart: this._streamStartTime[key],
-          streamEnd: this._streamLatestTime[key]
-        });
-      }
+    this._streamEnded();
+    if ('onvisibilitychange' in document) {
+      document.removeEventListener('visibilitychange', this._handleVisibilityChange);
+    } else {
+      window.removeEventListener('pagehide', this._handlePageHide);
     }
-
     this.host.removeEventListener('vouch:loaded', this._handleVouchLoaded);
     this.host.mediaPlayer?.removeEventListener('play', this._handlePlay);
     this.host.mediaPlayer?.removeEventListener('video:play', this._handleVideoPlay);