fix automatic DM avatar with functional members

spec/unit/room.spec.ts

@@ -2204,7 +2204,7 @@ describe("Room", function () {
     });
 
     describe("getAvatarFallbackMember", () => {
-        it("should should return undefined if the room isn't a 1:1", () => {
+        it("should return undefined if the room isn't a 1:1", () => {
             const room = new Room(roomId, null!, userA);
             room.currentState.setJoinedMemberCount(2);
             room.currentState.setInvitedMemberCount(1);
@@ -2231,6 +2231,84 @@ describe("Room", function () {
             });
             expect(room.getAvatarFallbackMember()?.userId).toBe(userD);
         });
+
+        it("should return undefined if the room is a 1:1 with a functional member", async function() {
+            const room = new Room(roomId, null!, userA);
+            // room.getMembers = jest.fn().mockReturnValue({
+            //     userB: new RoomMember(roomId, userB),
+            // });
+            jest.spyOn(Room.prototype as any, "getInvitedAndJoinedFunctionalMemberCount").mockReturnValue(1);
+            await room.currentState.setStateEvents([
+                utils.mkMembership({
+                    user: userA,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User A",
+                }),
+                utils.mkMembership({
+                    user: userB,
+                    mship: "join",
+                    room: roomId,
+                    event: true,
+                    name: "User B",
+                }),
+                utils.mkEvent({
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
+                    content: {
+                        service_members: [userB],
+                    },
+                }),
+            ]);
+            expect(room.getAvatarFallbackMember()).toBeUndefined();
+        });
+
+        it("should use summary heroes of nonfunctional member if 1:1 plus functional member", async function() {
+            const room = new Room(roomId, null!, userA);
+            // room.getMembers = jest.fn().mockReturnValue({
+            //     userB: new RoomMember(roomId, userB),
+            // });
+            jest.spyOn(Room.prototype as any, "getInvitedAndJoinedFunctionalMemberCount").mockReturnValue(1);
+            await room.currentState.setStateEvents([
+                utils.mkEvent({
+                    type: UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name,
+                    skey: "",
+                    room: roomId,
+                    event: true,
+                    content: {
+                        service_members: [userB],
+                    },
+                }),
+            ]);
+            room.currentState.markOutOfBandMembersStarted();
+            room.currentState.setOutOfBandMembers([
+                new MatrixEvent({
+                    type: EventType.RoomMember,
+                    state_key: userD,
+                    sender: userD,
+                    content: {
+                        membership: "join",
+                    },
+                }),
+                new MatrixEvent({
+                    type: EventType.RoomMember,
+                    state_key: userB,
+                    sender: userB,
+                    content: {
+                        membership: "join",
+                    },
+                }),
+            ]);
+            room.setSummary({
+                "m.heroes": [userA, userD, userB],
+                "m.joined_member_count": 2,
+                "m.invited_member_count": 1,
+            });
+            expect(room.getAvatarFallbackMember()?.userId).toBe(userD);
+        });
     });
 
     describe("maySendMessage", function () {

src/models/room.ts

@@ -914,12 +914,38 @@
         return this.myUserId;
     }
 
+    // gets service members (e.g. helper bots) for exclusion
+    private getFunctionalMembers(): string[] {
+        const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
+        if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {
+            return mFunctionalMembers!.getContent().service_members;
+        }
+        return [];
+    }
+
+    private getInvitedAndJoinedFunctionalMemberCount(functionalMembers: String[]): number {
+        return functionalMembers.reduce((count, m) => {
+            const membership = this.getMembers().find((member) => member.userId === m)?.membership;
+            if (membership && ["join", "invite"].includes(membership)) {
+                return count + 1;
+            }
+            return count;
+        }, 0);
+    }
+
     public getAvatarFallbackMember(): RoomMember | undefined {
-        const memberCount = this.getInvitedAndJoinedMemberCount();
+        const functionalMembers = this.getFunctionalMembers();
+        const invitedAndJoinedFunctionalMemberCount = this.getInvitedAndJoinedFunctionalMemberCount(functionalMembers);
+
+        // only get avatar if conversation is with a single specific other user
+        const memberCount = this.getInvitedAndJoinedMemberCount() - invitedAndJoinedFunctionalMemberCount;
         if (memberCount > 2) {
             return;
         }
-        const hasHeroes = Array.isArray(this.summaryHeroes) && this.summaryHeroes.length;
+
+        // prefer hero as indicated by the room summary
+        const nonFunctionalHeroes = this.summaryHeroes?.filter((h) => !functionalMembers.includes(h));
+        const hasHeroes = Array.isArray(nonFunctionalHeroes) && nonFunctionalHeroes.length;
         if (hasHeroes) {
             const availableMember = this.summaryHeroes!.map((userId) => {
                 return this.getMember(userId);
@@ -928,17 +954,21 @@
                 return availableMember;
             }
         }
+
+        // include previous members
         const members = this.currentState.getMembers();
+        const nonFunctionalMembers = members?.filter((m) => !functionalMembers.includes(m.userId));
         // could be different than memberCount
         // as this includes left members
-        if (members.length <= 2) {
-            const availableMember = members.find((m) => {
+        if (nonFunctionalMembers.length <= 2) {
+            const availableMember = nonFunctionalMembers.find((m) => {
                 return m.userId !== this.myUserId;
             });
             if (availableMember) {
                 return availableMember;
             }
         }
+
         // if all else fails, try falling back to a user,
         // and create a one-off member for it
         if (hasHeroes) {
@@ -3351,11 +3381,7 @@
         let inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;
 
         // get service members (e.g. helper bots) for exclusion
-        let excludedUserIds: string[] = [];
-        const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
-        if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {
-            excludedUserIds = mFunctionalMembers!.getContent().service_members;
-        }
+        let excludedUserIds: string[] = this.getFunctionalMembers();
 
         // get members that are NOT ourselves and are actually in the room.
         let otherNames: string[] = [];