anear-js-api 0.4.40 → 0.5.2

package/lib/state_machines/AnearEventMachine.js

@@ -24,15 +24,26 @@ const logger = require('../utils/Logger')
 //
 
 const { assign, createMachine, interpret } = require('xstate')
+const C = require('../utils/Constants')
+
+const getPlayingParticipantIds = (context) => {
+  return Object.keys(context.participants).filter(id => !context.participants[id].isHost);
+};
+
+const getAllParticipantIds = (context) => {
+  return Object.keys(context.participants);
+};
 
-const AnearApi = require('../api/AnearApi')
-const AnearParticipantMachine = require('../state_machines/AnearParticipantMachine')
-const AnearParticipant = require('../models/AnearParticipant')
 const RealtimeMessaging = require('../utils/RealtimeMessaging')
 const AppMachineTransition = require('../utils/AppMachineTransition')
 const DisplayEventProcessor = require('../utils/DisplayEventProcessor')
 const PugHelpers = require('../utils/PugHelpers')
-const C = require('../utils/Constants')
+
+const AnearApi = require('../api/AnearApi')
+const AnearParticipantMachine = require('../state_machines/AnearParticipantMachine')
+const AnearParticipant = require('../models/AnearParticipant')
+
+const CurrentDateTimestamp = _ => new Date().getTime()
 
 const AnearEventMachineContext = (
   anearEvent,
@@ -54,7 +65,8 @@ const AnearEventMachineContext = (
   participantsDisplayChannel: null, // display all participants
   spectatorsDisplayChannel: null,    // display all spectators
   participants: {},
-  participantMachines: {}
+  participantMachines: {},
+  participantsActionTimeout: null
 })
 
 const DeferredStates = [
@@ -126,7 +138,7 @@ const ActiveEventStatesConfig = {
                   target: '#waiting.fetching'
                 },
                 PARTICIPANT_MACHINE_READY: {
-                  actions: 'logAPMReady',
+                  actions: ['logAPMReady', 'sendEnterToAppMachine'],
                   target: '#eventCreated'
                 }
               }
@@ -164,13 +176,38 @@ const ActiveEventStatesConfig = {
       id: 'eventCreated',
       initial: 'waitingAnnounce',
       entry: [
-        'sendParticipantEnterToAppEventMachine',
         'enableSpectatorPresenceEvents'
       ],
       on: {
+        ACTION: {
+          actions: ['processParticipantAction']
+        },
         RENDER_DISPLAY: {
           target: '#createdRendering'
-        }
+        },
+        PARTICIPANT_LEAVE: [
+          {
+            cond: 'isHostLeaving',
+            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
+          },
+          {
+            cond: 'isPermanentLeave',
+            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
+          },
+          {
+            actions: ['processDisconnectEvents']
+          }
+        ],
+        PARTICIPANT_ENTER: [
+          {
+            cond: 'participantExists',
+            actions: 'processReconnectEvents'
+          },
+          {
+            // This shouldn't happen in eventCreated, but good to handle.
+            target: '#newParticipantJoining'
+          }
+        ]
       },
       states: {
         waitingAnnounce: {
@@ -207,8 +244,7 @@ const ActiveEventStatesConfig = {
         notifyingRenderComplete: {
           after: {
             timeoutRendered: {
-              target: '#waitingAnnounce',
-              actions: ['notifyAppMachineRendered']
+              target: '#waitingAnnounce'
             }
           }
         }
@@ -222,16 +258,23 @@ const ActiveEventStatesConfig = {
       // existing participant
       initial: 'transitioning',
       on: {
+        ACTION: {
+          actions: ['processParticipantAction']
+        },
         RENDER_DISPLAY: {
           target: '#announceRendering'
         },
         PARTICIPANT_LEAVE: [
+          {
+            cond: 'isHostLeaving',
+            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
+          },
           {
             cond: 'isPermanentLeave',
-            actions: ['sendParticipantExitToAppEventMachine', 'sendExitToParticipantMachine']
+            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
           },
           {
-            actions: ['sendParticipantDisconnectEvents']
+            actions: ['processDisconnectEvents']
           }
         ],
         PARTICIPANT_ENTER: [
@@ -239,7 +282,7 @@ const ActiveEventStatesConfig = {
             // a participant could re-entering the event after above PARTICIPANT_LEAVE (browser refresh).
             // so look for existing participants and send reconnect events to interested machines
             cond: 'participantExists',
-            actions: 'sendParticipantReconnectEvents'
+            actions: 'processReconnectEvents'
           },
           {
             // spectator clicked JOIN
@@ -326,7 +369,7 @@ const ActiveEventStatesConfig = {
           deferred: DeferredStatesPlus('START'),
           on: {
             PARTICIPANT_MACHINE_READY: {
-              actions: ['sendParticipantEnterToAppEventMachine'],
+              actions: ['sendEnterToAppMachine'],
               target: '#waitingToStart',
               internal: true
             }
@@ -335,28 +378,38 @@ const ActiveEventStatesConfig = {
       }
     },
     live: {
+      id: 'live',
       initial: 'transitioning',
       on: {
         RENDER_DISPLAY: {
           target: '#liveRendering'
         },
-        SPECTATOR_ENTER: {
-          actions: 'sendSpectatorEnterToAppEventMachine'
-        },
         PARTICIPANT_LEAVE: [
+          {
+            cond: 'isHostLeaving',
+            actions: ['sendHostExitToAppMachine', 'sendExitToParticipantMachine']
+          },
           {
             cond: 'isPermanentLeave',
-            actions: ['sendParticipantExitToAppEventMachine', 'sendExitToParticipantMachine']
+            actions: ['sendExitToAppMachine', 'sendExitToParticipantMachine']
           },
           {
-            actions: ['sendParticipantDisconnectEvents']
+            actions: ['processDisconnectEvents']
           }
         ],
-        PARTICIPANT_TIMEOUT: {
-          actions: ['processParticipantTimeout']
-        },
-        PAUSE: '#activeEvent.paused', // Currently no use-case for these
-        CLOSE: '#activeEvent.closeEvent' // AppM explicitly closed the event
+        PARTICIPANT_ENTER: [
+          {
+            cond: 'participantExists',
+            actions: 'processReconnectEvents'
+          },
+          {
+            // spectator clicked JOIN
+            target: '.participantEntering'
+          }
+        ],
+        PAUSE: {
+          target: 'paused'
+        }
       },
       states: {
         transitioning: {
@@ -373,28 +426,9 @@ const ActiveEventStatesConfig = {
         },
         waitingForActions: {
           id: 'waitingForActions',
+          entry: () => logger.debug('[AEM] live state...waiting for actions'),
           on: {
-            PARTICIPANT_ENTER: [
-              {
-                // a participant could re-entering the event after above PARTICIPANT_LEAVE (browser refresh).
-                // so look for existing participants and send reconnect events to interested machines
-                cond: 'participantExists',
-                actions: 'sendParticipantReconnectEvents'
-              },
-              {
-                // in the future, open house events allow spectators to join and leave freely
-                // during live.waitingForActions
-                cond: 'isOpenHouseEvent',
-                target: 'participantEntering'
-              },
-              {
-                // shouldn't receive these so log it and return to current state
-                actions: ['logInvalidParticipantEnter'],
-                target: '#activeEvent.failure'
-              }
-            ],
             ACTION: {
-              // A participant has clicked an anear-data-action
               actions: ['processParticipantAction']
             }
           }
@@ -404,10 +438,17 @@ const ActiveEventStatesConfig = {
           deferred: DeferredStates,
           invoke: {
             src: 'renderDisplay',
-            onDone: {
-              target: 'notifyingRenderComplete',
-              internal: true
-            },
+            onDone: [
+              {
+                cond: 'isParticipantsTimeoutActive',
+                target: 'notifyingRenderCompleteWithTimeout',
+                actions: 'setupParticipantsTimeout'
+              },
+              {
+                target: 'notifyingRenderComplete',
+                internal: true
+              }
+            ],
             onError: {
               target: '#activeEvent.failure'
             }
@@ -416,11 +457,57 @@ const ActiveEventStatesConfig = {
         notifyingRenderComplete: {
           after: {
             timeoutRendered: {
-              target: '#waitingForActions',
+              target: 'waitingForActions',
+              actions: ['notifyAppMachineRendered']
+            }
+          }
+        },
+        notifyingRenderCompleteWithTimeout: {
+          after: {
+            timeoutRendered: {
+              target: 'waitAllParticipantsResponse',
               actions: ['notifyAppMachineRendered']
             }
           }
         },
+        waitAllParticipantsResponse: {
+          always: {
+            cond: 'allParticipantsResponded',
+            target: 'waitingForActions',
+            actions: ['clearParticipantsTimeout']
+          },
+          after: {
+            participantsActionTimeout: {
+              target: 'handleParticipantsTimeout'
+            }
+          },
+          on: {
+            ACTION: {
+              actions: ['processAndForwardAction', 'processParticipantResponse'],
+              internal: true
+            },
+            RENDER_DISPLAY: {
+              target: '#liveRendering'
+            },
+            PARTICIPANT_LEAVE: [
+              {
+                cond: 'isHostLeaving',
+                actions: ['removeLeavingParticipantFromTimeout', 'sendHostExitToAppMachine', 'sendExitToParticipantMachine']
+              },
+              {
+                cond: 'isPermanentLeave',
+                actions: ['removeLeavingParticipantFromTimeout', 'sendExitToAppMachine', 'sendExitToParticipantMachine']
+              },
+              {
+                actions: ['processDisconnectEvents']
+              }
+            ]
+          }
+        },
+        handleParticipantsTimeout: {
+          entry: ['sendActionsTimeoutToAppM', 'clearParticipantsTimeout'],
+          always: 'waitingForActions'
+        },
         participantEntering: {
           // a PARTICIPANT_ENTER received from a new user JOIN click. Unless already exists,
           // create an AnearParticipantMachine instance.
@@ -444,8 +531,8 @@ const ActiveEventStatesConfig = {
           deferred: DeferredStates,
           on: {
             PARTICIPANT_MACHINE_READY: {
-              actions: ['sendParticipantEnterToAppEventMachine'],
-              target: '#waitingForActions',
+              actions: ['sendEnterToAppMachine'],
+              target: 'waitingForActions',
               internal: true
             }
           }
@@ -484,10 +571,10 @@ const ActiveEventStatesConfig = {
           always: 'waitForParticipantsToExit'
         },
         waitForParticipantsToExit: {
-          entry: context => logger.debug(`[AEM] Entering waitForParticipantsToExit with ${Object.keys(context.participants).length} participants`),
+          entry: context => logger.debug(`[AEM] Entering waitForParticipantsToExit with ${getAllParticipantIds(context).length} participants`),
           always: [
             {
-              cond: context => Object.keys(context.participants).length === 0,
+              cond: context => getAllParticipantIds(context).length === 0,
               target: 'finalizing'
             }
           ],
@@ -530,10 +617,10 @@ const ActiveEventStatesConfig = {
           always: 'waitForParticipantsToExit'
         },
         waitForParticipantsToExit: {
-          entry: context => logger.debug(`[AEM] Entering waitForParticipantsToExit with ${Object.keys(context.participants).length} participants`),
+          entry: context => logger.debug(`[AEM] Entering waitForParticipantsToExit with ${getAllParticipantIds(context).length} participants`),
           always: [
             {
-              cond: context => Object.keys(context.participants).length === 0,
+              cond: context => getAllParticipantIds(context).length === 0,
               target: 'finalizing'
             }
           ],
@@ -625,7 +712,7 @@ const CreateEventChannelsAndAppMachineConfig = {
       invoke: {
         src: 'attachToEventChannel',
         onDone: {
-          target: 'setupEventChannel',
+          target: '.',
           internal: true
         },
         onError: {
@@ -823,15 +910,68 @@ const AnearEventMachineFunctions = ({
         userJSON => context.appEventMachine.send('SPECTATOR_ENTER', userJSON)
       )
     },
-    sendParticipantEnterToAppEventMachine: (context, event) => {
-      const { anearParticipant } = event.data
+    sendEnterToAppMachine: (context, event) => {
+      const anearParticipant = event.data?.anearParticipant ?? event.anearParticipant;
+
+      if (!anearParticipant) {
+        logger.error('[AEM] sendEnterToAppMachine was called without an anearParticipant in the event', event);
+        return;
+      }
       const participantInfo = context.participants[anearParticipant.id]
 
-      logger.debug(`[AEM] Participant machine ${participantInfo.id} is READY`)
+      if (!participantInfo) {
+        logger.error(`[AEM] participantInfo not found for ${anearParticipant.id} in sendEnterToAppMachine`);
+        return;
+      }
+
+      const isHost = anearParticipant.isHost;
+      const eventName = isHost ? 'HOST_ENTER' : 'PARTICIPANT_ENTER';
+      const eventPayload = { participant: participantInfo };
+
+      logger.debug(`[AEM] Sending ${eventName} for ${anearParticipant.id}`);
+      context.appEventMachine.send(eventName, eventPayload);
+    },
+    processDisconnectEvents: (context, event) => {
+      const participantId = event.data.id;
+      const participant = context.participants[participantId];
+      const isHost = participant && participant.isHost;
+      const eventName = isHost ? 'HOST_DISCONNECT' : 'PARTICIPANT_DISCONNECT';
+      const participantMachine = context.participantMachines[participantId];
 
-      const startEvent = { participant: participantInfo }
+      logger.debug(`[AEM] processing disconnect for ${participantId}. Is host? ${isHost}`);
+      if (participantMachine) {
+        participantMachine.send('PARTICIPANT_DISCONNECT');
+      }
+      context.appEventMachine.send(eventName, { participantId });
+    },
+    processReconnectEvents: (context, event) => {
+      const participantId = event.data.id;
+      const participant = context.participants[participantId];
+      const isHost = participant && participant.isHost;
+      const eventName = isHost ? 'HOST_RECONNECT' : 'PARTICIPANT_RECONNECT';
+      const participantMachine = context.participantMachines[participantId];
 
-      context.appEventMachine.send('PARTICIPANT_ENTER', startEvent)
+      logger.debug(`[AEM] processing reconnect for ${participantId}. Is host? ${isHost}`);
+      if (participantMachine) {
+        participantMachine.send('PARTICIPANT_RECONNECT');
+      }
+      context.appEventMachine.send(eventName, { participantId });
+    },
+    sendExitToAppMachine: (context, event) => {
+      // coming from an action channel message, event.data.id
+      const participantId = event.data.id;
+      const participantInfo = context.participants[participantId];
+      if (participantInfo) {
+        logger.debug(`[AEM] sending PARTICIPANT_EXIT to AppM for participant ${participantId}`);
+        context.appEventMachine.send('PARTICIPANT_EXIT', { participantId });
+      } else {
+        logger.warn(`[AEM] Participant info not found for id ${participantId} during sendExitToAppMachine`);
+      }
+    },
+    sendHostExitToAppMachine: (context, event) => {
+      const participantId = event.data.id;
+      logger.debug(`[AEM] sending HOST_EXIT to AppM for host ${participantId}`);
+      context.appEventMachine.send('HOST_EXIT', { participantId });
     },
     sendExitToParticipantMachine: (context, event) => {
       // coming from an action channel message, event.data.id
@@ -843,46 +983,11 @@ const AnearEventMachineFunctions = ({
         logger.warn(`[AEM] Participant machine not found for id ${event.data.id} during sendExitToParticipantMachine`)
       }
     },
-    sendParticipantExitToAppEventMachine: (context, event) => {
-      context.appEventMachine.send('PARTICIPANT_EXIT',
-        { participantId: event.data.id }
-      )
-    },
     sendParticipantExitEvents: context => {
       Object.values(context.participantMachines).forEach(pm => pm.send('PARTICIPANT_EXIT'))
     },
 
 
-    sendParticipantDisconnectEvents: (context, event) => {
-      const participantMachine = context.participantMachines[event.data.id]
-      if (participantMachine) {
-        logger.debug("[AEM] sending PARTICIPANT_DISCONNECT to APM and AppM")
-        // triggers a timer state in APM to timeout a missing Participant
-        participantMachine.send('PARTICIPANT_DISCONNECT', event.data)
-        // gives the App the opportunity to process the potential early exit
-        // of a key player, possibly pausing or altering game behavior until
-        // the participant either times out (exits game), or comes back after
-        // the momentary outage
-        context.appEventMachine.send('PARTICIPANT_DISCONNECT',
-          { participantId: event.data.id }
-        )
-      }
-    },
-    sendParticipantReconnectEvents: (context, event) => {
-      const participantId = event.data.id
-      const participantMachine = context.participantMachines[participantId]
-      if (participantMachine) {
-        // suspends the disconnect timeout and restores participant presence state in
-        // the event
-        participantMachine.send('PARTICIPANT_RECONNECT')
-      }
-
-      const participantInfo = context.participants[participantId]
-      // send this to the app so they can receive and trigger a meta display for private participants
-      if (participantInfo) {
-        context.appEventMachine.send('PARTICIPANT_RECONNECT', { participant:  participantInfo })
-      }
-    },
     updateParticipantPresence: (context, event) => {
       // lookup the participantMachine and update its context
       const participantMachine = context.participantMachines[event.data.id]
@@ -902,6 +1007,9 @@ const AnearEventMachineFunctions = ({
       const participantId = event.data.participantId
       const eventMessagePayload = JSON.parse(event.data.payload) // { eventName: {eventObject} }
       const [appEventName, payload] = Object.entries(eventMessagePayload)[0]
+
+      logger.debug(`[AEM] got Event ${appEventName} from payload from participant ${participantId}`)
+
       const actionEventPayload = {
         participantId,
         payload
@@ -913,10 +1021,90 @@ const AnearEventMachineFunctions = ({
 
       context.appEventMachine.send(appEventName, actionEventPayload)
     },
+    processAndForwardAction: (context, event) => {
+      const participantId = event.data.participantId;
+      const { nonResponders } = context.participantsActionTimeout;
+
+      // Check if this is the last responder before the context is updated.
+      // This assumes the current participant IS a non-responder.
+      const isFinalAction = nonResponders.size === 1 && nonResponders.has(participantId);
+
+      logger.info(`[AEM] Participants FINAL ACTION is ${isFinalAction}`)
+
+      // Forward to AppM with the finalAction flag
+      const eventMessagePayload = JSON.parse(event.data.payload);
+      const [appEventName, payload] = Object.entries(eventMessagePayload)[0];
+      const appM_Payload = {
+        participantId,
+        payload,
+        finalAction: isFinalAction
+      };
+      context.appEventMachine.send(appEventName, appM_Payload);
+
+      // Forward to APM (without the flag)
+      const participantMachine = context.participantMachines[participantId];
+      if (participantMachine) {
+        const apm_Payload = { participantId, payload };
+        participantMachine.send('ACTION', apm_Payload);
+      }
+    },
     processParticipantTimeout: (context, event) => context.appEventMachine.send(
       'PARTICIPANT_TIMEOUT',
       { participantId: event.participantId }
     ),
+    setupParticipantsTimeout: assign((context, event) => {
+      const timeoutMsecs = event.data.participantsTimeout.msecs
+      const allParticipantIds = getPlayingParticipantIds(context)
+      logger.debug(`[AEM] Starting participants action timeout for ${timeoutMsecs}ms. Responders: ${allParticipantIds.join(', ')}`)
+
+      return {
+        participantsActionTimeout: {
+          msecs: timeoutMsecs,
+          nonResponders: new Set(allParticipantIds)
+        }
+      }
+    }),
+    processParticipantResponse: assign((context, event) => {
+      const participantId = event.data.participantId
+      const { nonResponders, ...rest } = context.participantsActionTimeout
+      const newNonResponders = new Set(nonResponders)
+      newNonResponders.delete(participantId)
+
+      return {
+        participantsActionTimeout: {
+          ...rest,
+          nonResponders: newNonResponders
+        }
+      }
+    }),
+    removeLeavingParticipantFromTimeout: assign((context, event) => {
+      const participantId = event.data.id
+      const { nonResponders, ...rest } = context.participantsActionTimeout
+      const newNonResponders = new Set(nonResponders)
+      newNonResponders.delete(participantId)
+
+      return {
+        participantsActionTimeout: {
+          ...rest,
+          nonResponders: newNonResponders
+        }
+      }
+    }),
+    sendActionsTimeoutToAppM: (context, _event) => {
+      const { nonResponders, msecs } = context.participantsActionTimeout
+      const nonResponderIds = [...nonResponders]
+      logger.info(`[AEM] Participants action timed out. Non-responders: ${nonResponderIds.join(', ')}`)
+
+      if (context.appEventMachine) {
+        context.appEventMachine.send('ACTIONS_TIMEOUT', {
+          timeout: msecs,
+          nonResponderIds
+        })
+      }
+    },
+    clearParticipantsTimeout: assign({
+      participantsActionTimeout: null
+    }),
     cleanupExitingParticipant: assign((context, event) => {
       const { participantId } = event
       const participant = context.participants[participantId]
@@ -951,13 +1139,11 @@ const AnearEventMachineFunctions = ({
     logInvalidParticipantEnter: (c, e) => logger.info("[AEM] Error: Unexepected PARTICIPANT_ENTER with id: ", e.data.id),
   },
   services: {
-    renderDisplay: (context, event) => {
+    renderDisplay: async (context, event) => {
       const displayEventProcessor = new DisplayEventProcessor(context)
 
-      return displayEventProcessor.processAndPublish(event.displayEvents)
+      return await displayEventProcessor.processAndPublish(event.displayEvents)
     },
-    
-
     getAttachedCreatorOrHost: async (context, event) => {
       logger.debug("[AEM] getAttachedCreatorOrHost() invoked")
 
@@ -1051,16 +1237,30 @@ const AnearEventMachineFunctions = ({
           return false
       }
     },
+    isHostLeaving: (context, event) => {
+      const participantId = event.data.id;
+      const participant = context.participants[participantId];
+      return participant && participant.isHost;
+    },
     participantExists: (context, event) => !!context.participants[event.data.id],
     eventCreatorIsHost: (context, event) => context.anearEvent.hosted,
-    isOpenHouseEvent: (context, event) => context.anearEvent.openHouse || false // TODO: need to have App open_house trait exposed in anear api
+    isOpenHouseEvent: (context, event) => context.anearEvent.openHouse || false,
+    isParticipantsTimeoutActive: (context, event) => {
+      return event.data && event.data.participantsTimeout && event.data.participantsTimeout.msecs > 0
+    },
+    allParticipantsResponded: (context, event) => {
+      return context.participantsActionTimeout && context.participantsActionTimeout.nonResponders.size === 0
+    }
   },
   delays: {
     // in the future, these delays should be goverened by the type of App and
     // if there has been activity.
     timeoutEventAnnounce: context => C.TIMEOUT_MSECS.ANNOUNCE,
     timeoutEventStart: context => C.TIMEOUT_MSECS.START,
-    timeoutRendered: context => C.TIMEOUT_MSECS.RENDERED_EVENT_DELAY
+    timeoutRendered: context => C.TIMEOUT_MSECS.RENDERED_EVENT_DELAY,
+    participantsActionTimeout: (context, event) => {
+      return context.participantsActionTimeout.msecs
+    }
   }
 })