ref(face-expressions) refactor face landmarks namings (#1977)

JitsiConference.js

 };
 
 /**
- * Sends a facial expression with its duration to the xmpp server.
+ * Sends a face landmarks object to the xmpp server.
  * @param {Object} payload
  */
-JitsiConference.prototype.sendFacialExpression = function(payload) {
-    this.xmpp.sendFacialExpressionEvent(this.room.roomjid, payload);
+JitsiConference.prototype.sendFaceLandmarks = function(payload) {
+    if (payload.faceExpression) {
+        this.xmpp.sendFaceExpressionEvent(this.room.roomjid, payload);
+    }
 };
 
 /**

JitsiConferenceEvents.spec.ts

         AV_MODERATION_CHANGED,
         AV_MODERATION_PARTICIPANT_APPROVED,
         AV_MODERATION_PARTICIPANT_REJECTED,
-        FACIAL_EXPRESSION_ADDED,
+        FACE_LANDMARK_ADDED,
         BREAKOUT_ROOMS_MOVE_TO_ROOM,
         BREAKOUT_ROOMS_UPDATED,
         JitsiConferenceEvents,
         expect( AV_MODERATION_CHANGED ).toBe( 'conference.av_moderation.changed' );
         expect( AV_MODERATION_PARTICIPANT_APPROVED ).toBe( 'conference.av_moderation.participant.approved' );
         expect( AV_MODERATION_PARTICIPANT_REJECTED ).toBe( 'conference.av_moderation.participant.rejected' );
-        expect( FACIAL_EXPRESSION_ADDED ).toBe( 'conference.facial_expression.added' );
+        expect( FACE_LANDMARK_ADDED ).toBe( 'conference.face_landmark.added' );
         expect( BREAKOUT_ROOMS_MOVE_TO_ROOM ).toBe( 'conference.breakout-rooms.move-to-room' );
         expect( BREAKOUT_ROOMS_UPDATED ).toBe( 'conference.breakout-rooms.updated' );
 
         expect( JitsiConferenceEvents.AV_MODERATION_CHANGED ).toBe( 'conference.av_moderation.changed' );
         expect( JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_APPROVED ).toBe( 'conference.av_moderation.participant.approved' );
         expect( JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_REJECTED ).toBe( 'conference.av_moderation.participant.rejected' );
-        expect( JitsiConferenceEvents.FACIAL_EXPRESSION_ADDED ).toBe( 'conference.facial_expression.added' );
+        expect( JitsiConferenceEvents.FACE_LANDMARK_ADDED ).toBe( 'conference.face_landmark.added' );
         expect( JitsiConferenceEvents.BREAKOUT_ROOMS_MOVE_TO_ROOM ).toBe( 'conference.breakout-rooms.move-to-room' );
         expect( JitsiConferenceEvents.BREAKOUT_ROOMS_UPDATED ).toBe( 'conference.breakout-rooms.updated' );
     } );

JitsiConferenceEvents.ts

     AV_MODERATION_PARTICIPANT_REJECTED = 'conference.av_moderation.participant.rejected',
 
     /**
-     * A new facial expression is added with its duration for a participant
+     * A new face landmark object is added for a participant
      */
-    FACIAL_EXPRESSION_ADDED = 'conference.facial_expression.added',
+    FACE_LANDMARK_ADDED = 'conference.face_landmark.added',
 
     /**
      * Event fired when a participant is requested to join a given (breakout) room.
 export const AV_MODERATION_CHANGED = JitsiConferenceEvents.AV_MODERATION_CHANGED;
 export const AV_MODERATION_PARTICIPANT_APPROVED = JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_APPROVED;
 export const AV_MODERATION_PARTICIPANT_REJECTED = JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_REJECTED;
-export const FACIAL_EXPRESSION_ADDED = JitsiConferenceEvents.FACIAL_EXPRESSION_ADDED;
+export const FACE_LANDMARK_ADDED = JitsiConferenceEvents.FACE_LANDMARK_ADDED;
 export const BREAKOUT_ROOMS_MOVE_TO_ROOM = JitsiConferenceEvents.BREAKOUT_ROOMS_MOVE_TO_ROOM;
 export const BREAKOUT_ROOMS_UPDATED = JitsiConferenceEvents.BREAKOUT_ROOMS_UPDATED;

modules/connectivity/ConnectionQuality.js

 
 /**
  * The value to use for the "type" field for messages sent
- * over the data channel that contain facial expression.
+ * over the data channel that contain a face landmark.
  */
-const FACIAL_EXPRESSION_MESSAGE_TYPE = 'facial_expression';
+const FACE_LANDMARK_MESSAGE_TYPE = 'face_landmark';
 
 const kSimulcastFormats = [
     { width: 1920,
         conference.on(
             ConferenceEvents.ENDPOINT_MESSAGE_RECEIVED,
             (participant, payload) => {
-                if (payload.type === FACIAL_EXPRESSION_MESSAGE_TYPE) {
+                if (payload.type === FACE_LANDMARK_MESSAGE_TYPE) {
                     this.eventEmitter.emit(
-                        ConferenceEvents.FACIAL_EXPRESSION_ADDED,
+                        ConferenceEvents.FACE_LANDMARK_ADDED,
                         participant.getId(),
                         payload);
                 }

modules/statistics/SpeakerStats.js

         this.totalDominantSpeakerTime = 0;
         this._dominantSpeakerStart = 0;
         this._hasLeft = false;
-        this._facialExpressions = {
+        this._faceExpressions = {
             happy: 0,
             neutral: 0,
             surprised: 0,
     }
 
     /**
-     * Gets the facial expressions of the user.
+     * Gets the face expressions of the user.
      *
      * @returns {Object}
      */
-    getFacialExpressions() {
-        return this._facialExpressions;
+    getFaceExpressions() {
+        return this._faceExpressions;
     }
 
     /**
-     * Sets the facial expressions of the user.
+     * Sets the face expressions of the user.
      *
-     * @param {Object} facialExpressions - object with facial expressions.
+     * @param {Object} faceExpressions - object with face expressions.
      * @returns {void}
      */
-    setFacialExpressions(facialExpressions) {
-        this._facialExpressions = facialExpressions;
+    setFaceExpressions(faceExpressions) {
+        this._faceExpressions = faceExpressions;
     }
 
     /**
-     * Adds a new facial expression to speaker stats.
+     * Adds a new face expression to speaker stats.
      *
-     * @param  {string} facialExpression
+     * @param  {string} faceExpression
      * @param {number} duration
      */
-    addFacialExpression(facialExpression, duration) {
-        this._facialExpressions[facialExpression] += duration;
+    addFaceExpression(faceExpression, duration) {
+        this._faceExpressions[faceExpression] += duration;
     }
 }
 

modules/statistics/SpeakerStatsCollector.js

             JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
             this._onDisplayNameChange.bind(this));
         conference.addEventListener(
-            JitsiConferenceEvents.FACIAL_EXPRESSION_ADDED,
-            this._onFacialExpressionAdd.bind(this));
+            JitsiConferenceEvents.FACE_LANDMARK_ADDED,
+            this._onFaceLandmarkAdd.bind(this));
         if (conference.xmpp) {
             conference.xmpp.addListener(
                 XMPPEvents.SPEAKER_STATS_RECEIVED,
     }
 
     /**
-     * Adds a new facial expression with its duration of a remote user.
+     * Processes a new face landmark object of a remote user.
      *
      * @param {string} userId - The user id of the user that left.
-     * @param {Object} data - The facial expression with its duration.
+     * @param {Object} data - The face landmark object.
      * @returns {void}
      * @private
      */
-    _onFacialExpressionAdd(userId, data) {
+    _onFaceLandmarkAdd(userId, data) {
         const savedUser = this.stats.users[userId];
 
-        if (savedUser) {
-            savedUser.addFacialExpression(data.facialExpression, data.duration);
+        if (savedUser && data.faceExpression) {
+            savedUser.addFaceExpression(data.faceExpression, data.duration);
         }
     }
 
             speakerStatsToUpdate.totalDominantSpeakerTime
                 = newStats[userId].totalDominantSpeakerTime;
 
-            speakerStatsToUpdate.setFacialExpressions(newStats[userId].facialExpressions);
+            speakerStatsToUpdate.setFaceExpressions(newStats[userId].faceExpressions);
         }
     }
 }

modules/xmpp/xmpp.js

     }
 
     /**
-     * Sends facial expression to speaker stats component.
+     * Sends face expressions to speaker stats component.
      * @param {String} roomJid - The room jid where the speaker event occurred.
      * @param {Object} payload - The expression to be sent to the speaker stats.
      */
-    sendFacialExpressionEvent(roomJid, payload) {
+    sendFaceExpressionEvent(roomJid, payload) {
         // no speaker stats component advertised
         if (!this.speakerStatsComponentAddress || !roomJid) {
             return;
 
         const msg = $msg({ to: this.speakerStatsComponentAddress });
 
-        msg.c('facialExpression', {
+        msg.c('faceExpression', {
             xmlns: 'http://jitsi.org/jitmeet',
             room: roomJid,
-            expression: payload.facialExpression,
+            expression: payload.faceExpression,
             duration: payload.duration
         }).up();
 

types/auto/JitsiConference.d.ts

      */
     getSpeakerStats(): object;
     /**
-     * Sends a facial expression with its duration to the xmpp server.
+     * Sends a face landmarks object to the xmpp server.
      * @param {Object} payload
      */
-    sendFacialExpression(payload: any): void;
+    sendFaceLandmarks(payload: any): void;
     /**
      * Sets the constraints for the video that is requested from the bridge.
      *

types/auto/JitsiConferenceEvents.d.ts

      */
     AV_MODERATION_PARTICIPANT_REJECTED = "conference.av_moderation.participant.rejected",
     /**
-     * A new facial expression is added with its duration for a participant
+     * A new face landmark object is added for a participant
      */
-    FACIAL_EXPRESSION_ADDED = "conference.facial_expression.added",
+    FACE_LANDMARK_ADDED = "conference.face_landmark.added",
     /**
      * Event fired when a participant is requested to join a given (breakout) room.
      */
 export declare const AV_MODERATION_CHANGED = JitsiConferenceEvents.AV_MODERATION_CHANGED;
 export declare const AV_MODERATION_PARTICIPANT_APPROVED = JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_APPROVED;
 export declare const AV_MODERATION_PARTICIPANT_REJECTED = JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_REJECTED;
-export declare const FACIAL_EXPRESSION_ADDED = JitsiConferenceEvents.FACIAL_EXPRESSION_ADDED;
+export declare const FACE_LANDMARK_ADDED = JitsiConferenceEvents.FACE_LANDMARK_ADDED;
 export declare const BREAKOUT_ROOMS_MOVE_TO_ROOM = JitsiConferenceEvents.BREAKOUT_ROOMS_MOVE_TO_ROOM;
 export declare const BREAKOUT_ROOMS_UPDATED = JitsiConferenceEvents.BREAKOUT_ROOMS_UPDATED;

types/auto/modules/statistics/SpeakerStats.d.ts

     totalDominantSpeakerTime: number;
     _dominantSpeakerStart: number;
     _hasLeft: boolean;
-    _facialExpressions: {
+    _faceExpressions: {
         happy: number;
         neutral: number;
         surprised: number;
      */
     markAsHasLeft(): void;
     /**
-     * Gets the facial expressions of the user.
+     * Gets the face expressions of the user.
      *
      * @returns {Object}
      */
-    getFacialExpressions(): any;
+    getFaceExpressions(): any;
     /**
-     * Sets the facial expressions of the user.
+     * Sets the face expressions of the user.
      *
-     * @param {Object} facialExpressions - object with facial expressions.
+     * @param {Object} faceExpressions - object with face expressions.
      * @returns {void}
      */
-    setFacialExpressions(facialExpressions: any): void;
+    setFaceExpressions(faceExpressions: any): void;
     /**
-     * Adds a new facial expression to speaker stats.
+     * Adds a new face expression to speaker stats.
      *
-     * @param  {string} facialExpression
+     * @param  {string} faceExpression
      * @param {number} duration
      */
-    addFacialExpression(facialExpression: string, duration: number): void;
+    addFaceExpression(faceExpression: string, duration: number): void;
 }

types/auto/modules/statistics/SpeakerStatsCollector.d.ts

      */
     private _onDisplayNameChange;
     /**
-     * Adds a new facial expression with its duration of a remote user.
+     * Processes a new face landmark object of a remote user.
      *
      * @param {string} userId - The user id of the user that left.
-     * @param {Object} data - The facial expression with its duration.
+     * @param {Object} data - The face landmark object.
      * @returns {void}
      * @private
      */
-    private _onFacialExpressionAdd;
+    private _onFaceLandmarkAdd;
     /**
      * Return a copy of the tracked SpeakerStats models.
      *

types/auto/modules/xmpp/xmpp.d.ts

      */
     sendDominantSpeakerEvent(roomJid: string): void;
     /**
-     * Sends facial expression to speaker stats component.
+     * Sends face expressions to speaker stats component.
      * @param {String} roomJid - The room jid where the speaker event occurred.
      * @param {Object} payload - The expression to be sent to the speaker stats.
      */
-    sendFacialExpressionEvent(roomJid: string, payload: any): void;
+    sendFaceExpressionEvent(roomJid: string, payload: any): void;
     /**
      * Check if the given argument is a valid JSON ENDPOINT_MESSAGE string by
      * parsing it and checking if it has a field called 'type'.