34 feature clean up session and players when leaving lobby

android/src/main/java/group07/beatbattle/android/firebase/AndroidFirebaseGateway.java

@@ -43,4 +43,41 @@ public void addHostToPlayers(
     ) {
         sessionRepository.addHostToPlayers(sessionId, hostId, hostName, callback);
     }
+
+    @Override
+    public void findSessionIdByGamePin(String gamePin, FindSessionCallback callback) {
+        sessionRepository.findSessionIdByGamePin(gamePin, callback);
+    }
+
+    @Override
+    public void addPlayerToSession(
+        String sessionId,
+        String playerId,
+        String playerName,
+        AddPlayerCallback callback
+    ) {
+        sessionRepository.addPlayerToSession(sessionId, playerId, playerName, callback);
+    }
+
+    @Override
+    public void listenToPlayers(String sessionId, PlayersListenerCallback callback) {
+        sessionRepository.listenToPlayers(sessionId, callback);
+    }
+
+    @Override
+    public void removePlayerFromSession(
+        String sessionId,
+        String playerId,
+        RemovePlayerCallback callback
+    ) {
+        sessionRepository.removePlayerFromSession(sessionId, playerId, callback);
+    }
+
+    @Override
+    public void deleteSession(
+        String sessionId,
+        DeleteSessionCallback callback
+    ) {
+        sessionRepository.deleteSession(sessionId, callback);
+    }
 }

android/src/main/java/group07/beatbattle/android/firebase/FirestoreSessionRepository.java

@@ -2,11 +2,16 @@
 
 import com.google.firebase.Timestamp;
 import com.google.firebase.firestore.FirebaseFirestore;
+import com.google.firebase.firestore.ListenerRegistration;
+import com.google.firebase.firestore.QuerySnapshot;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 import group07.beatbattle.firebase.FirebaseGateway;
+import group07.beatbattle.model.Player;
 
 public class FirestoreSessionRepository {
 
@@ -70,4 +75,158 @@ public void addHostToPlayers(
             .addOnSuccessListener(unused -> callback.onSuccess())
             .addOnFailureListener(callback::onFailure);
     }
+
+    public void findSessionIdByGamePin(
+        String gamePin,
+        FirebaseGateway.FindSessionCallback callback
+    ) {
+        firestore.collection(SESSIONS)
+            .whereEqualTo("gamePin", gamePin)
+            .limit(1)
+            .get()
+            .addOnSuccessListener(snapshot -> handleSessionLookup(snapshot, callback))
+            .addOnFailureListener(callback::onFailure);
+    }
+
+    private void handleSessionLookup(
+        QuerySnapshot snapshot,
+        FirebaseGateway.FindSessionCallback callback
+    ) {
+        if (snapshot.isEmpty()) {
+            callback.onFailure(new IllegalArgumentException("Invalid game pin"));
+            return;
+        }
+        String sessionId = snapshot.getDocuments().get(0).getId();
+        callback.onSuccess(sessionId);
+    }
+
+    public void addPlayerToSession(
+        String sessionId,
+        String playerId,
+        String playerName,
+        FirebaseGateway.AddPlayerCallback callback
+    ) {
+        Map<String, Object> player = new HashMap<>();
+        player.put("name", playerName);
+        player.put("score", 0);
+        player.put("isHost", false);
+
+        firestore.collection(SESSIONS)
+            .document(sessionId)
+            .collection(PLAYERS)
+            .document(playerId)
+            .set(player)
+            .addOnSuccessListener(unused -> callback.onSuccess())
+            .addOnFailureListener(callback::onFailure);
+    }
+
+    public ListenerRegistration listenToPlayers(
+        String sessionId,
+        FirebaseGateway.PlayersListenerCallback callback
+    ) {
+        return firestore.collection(SESSIONS)
+            .document(sessionId)
+            .collection(PLAYERS)
+            .addSnapshotListener((snapshot, error) -> {
+                if (error != null) {
+                    callback.onFailure(error);
+                    return;
+                }
+
+                if (snapshot == null) {
+                    callback.onPlayersChanged(new ArrayList<>());
+                    return;
+                }
+
+                List<Player> players = new ArrayList<>();
+
+                snapshot.getDocuments().forEach(document -> {
+                    String playerId = document.getId();
+                    String name = document.getString("name");
+                    if (name == null) {
+                        name = "Unknown";
+                    }
+
+                    boolean isHost = Boolean.TRUE.equals(document.getBoolean("isHost"));
+                    Player player = new Player(playerId, name, isHost);
+
+                    Long scoreValue = document.getLong("score");
+                    if (scoreValue != null) {
+                        player.setScore(scoreValue.intValue());
+                    }
+
+                    players.add(player);
+                });
+
+                callback.onPlayersChanged(players);
+            });
+    }
+
+    public void removePlayerFromSession(
+        String sessionId,
+        String playerId,
+        FirebaseGateway.RemovePlayerCallback callback
+    ) {
+        firestore.collection(SESSIONS)
+            .document(sessionId)
+            .collection(PLAYERS)
+            .document(playerId)
+            .delete()
+            .addOnSuccessListener(unused -> callback.onSuccess())
+            .addOnFailureListener(callback::onFailure);
+    }
+
+    public void deleteSession(
+        String sessionId,
+        FirebaseGateway.DeleteSessionCallback callback
+    ) {
+        firestore.collection(SESSIONS)
+            .document(sessionId)
+            .collection(PLAYERS)
+            .get()
+            .addOnSuccessListener(snapshot -> {
+                if (snapshot.isEmpty()) {
+                    deleteSessionDocument(sessionId, callback);
+                    return;
+                }
+
+                final int totalDocuments = snapshot.size();
+                final int[] deletedDocuments = {0};
+                final boolean[] failed = {false};
+
+                snapshot.getDocuments().forEach(document -> {
+                    document.getReference()
+                        .delete()
+                        .addOnSuccessListener(unused -> {
+                            if (failed[0]) {
+                                return;
+                            }
+
+                            deletedDocuments[0]++;
+
+                            if (deletedDocuments[0] == totalDocuments) {
+                                deleteSessionDocument(sessionId, callback);
+                            }
+                        })
+                        .addOnFailureListener(exception -> {
+                            if (!failed[0]) {
+                                failed[0] = true;
+                                callback.onFailure(exception);
+                            }
+                        });
+                });
+            })
+            .addOnFailureListener(callback::onFailure);
+    }
+
+    private void deleteSessionDocument(
+        String sessionId,
+        FirebaseGateway.DeleteSessionCallback callback
+    ) {
+        firestore.collection(SESSIONS)
+            .document(sessionId)
+            .delete()
+            .addOnSuccessListener(unused -> callback.onSuccess())
+            .addOnFailureListener(callback::onFailure);
+    }
 }