Connect4 — 12: ניתוק, חזרה וסנכרון עם החדר

         auth.addAuthStateListener(firebaseListener);
         return once(() -> auth.removeAuthStateListener(firebaseListener));
     }
 
+    /** Subscribes to Firebase's connection-state signal. */
+    public Subscription subscribeConnection(ConnectionListener listener) {
+        DatabaseReference connectionReference = FirebaseRefs.connection(database);
+        ValueEventListener firebaseListener = new ValueEventListener() {
+            @Override
+            public void onDataChange(DataSnapshot snapshot) {
+                listener.onConnectionChanged(Boolean.TRUE.equals(snapshot.getValue(Boolean.class)));
+            }
+
+            @Override
+            public void onCancelled(DatabaseError databaseError) {
+                listener.onError(databaseError(databaseError, null));
+            }
+        };
+        connectionReference.addValueEventListener(firebaseListener);
+        return once(() -> connectionReference.removeEventListener(firebaseListener));
+    }
 
     /** Subscribes to the lobby's validated room summaries. */
     public Subscription subscribeLobby(LobbyListener listener) {
         if (currentUid() == null) {

     public interface AuthListener {
         void onAuthChanged(String uid);
     }
 
+    public interface ConnectionListener {
+        void onConnectionChanged(boolean connected);
+
+        void onError(RepositoryError error);
+    }
+
     public interface LobbyListener {
         void onRooms(List<RoomSummary> rooms);
 
         void onError(RepositoryError error);

     public RoomSnapshot room;
     public String onlineMessage = "";
     public String onlineUid;
     public long onlineGeneration;
+    public boolean connected;
+    public boolean reconciled;
     public boolean authPending;
     public long googleRequestGeneration;
     public Runnable refreshOnline;
     private final ExecutorService computerWorker = Executors.newSingleThreadExecutor();

             <LinearLayout android:id="@+id/rooms" android:orientation="vertical"
                 android:layout_width="match_parent" android:layout_height="wrap_content" />
         </LinearLayout>
         <Button android:id="@+id/backToLobby" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Return to lobby" />
+        <Button android:id="@+id/retryOnline" android:layout_width="match_parent"
+            android:layout_height="wrap_content" android:text="Reconnect / retry" />
         <Button android:id="@+id/signOut" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="Sign out" />
     </LinearLayout>
     </LinearLayout>
 </ScrollView>

             refreshScreen();
         });
         ui.createRoom.setOnClickListener(v -> createRoom());
         ui.backToLobby.setOnClickListener(v -> lobby());
+        ui.retryOnline.setOnClickListener(v -> { stop(); start(); });
     }
 
     void start() {
         if (active || session.mode != GameSession.MODE_ONLINE) return;
         active = true;
         session.refreshOnline = refreshCallback;
+        session.connected = false;
+        session.reconciled = false;
         try {
             if (session.repository == null) session.repository = new MultiplayerRepository();
             MultiplayerRepository repo = session.repository;
             subscriptions.add(repo.subscribeAuth(uid -> {

                     session.onlineUid = uid;
                 }
                 refreshScreen();
             }));
+            subscriptions.add(repo.subscribeConnection(new MultiplayerRepository.ConnectionListener() {
+                @Override public void onConnectionChanged(boolean connected) {
+                    if (!active) return;
+                    session.connected = connected;
+                    session.reconciled = false;
+                    if (connected) refreshScreen();
+                    else host.changed();
+                }
+                @Override public void onError(RepositoryError error) { showError(error); }
+            }));
             refreshScreen();
         } catch (IllegalStateException exception) {
             session.onlineMessage = "Firebase setup unavailable. Add the registered Connect4 google-services.json and rebuild.";
             host.changed();

         screen.close();
         screen = MultiplayerRepository.Subscription.EMPTY;
         for (MultiplayerRepository.Subscription subscription : subscriptions) subscription.close();
         subscriptions.clear();
+        session.reconciled = false;
     }
 
     void modeChanged() {
         session.onlineGeneration++;

     private void refreshScreen() {
         screen.close();
         screen = MultiplayerRepository.Subscription.EMPTY;
         long token = ++screenGeneration;
+        session.reconciled = false;
         if (!active || session.repository == null || session.repository.currentUid() == null) { host.changed(); return; }
         if (session.roomId == null) {
             screen = session.repository.subscribeLobby(new MultiplayerRepository.LobbyListener() {
                 @Override public void onRooms(List<RoomSummary> rooms) {
                     if (!active || token != screenGeneration) return;
+                    session.reconciled = session.connected;
                     ui.rooms.removeAllViews();
                     for (RoomSummary room : rooms) {
                         Button button = new Button(ui.getRoot().getContext());
                         button.setText(room.getName() + " · " + (room.isValid() ? room.getStatus().toString().toLowerCase(java.util.Locale.ROOT) : "invalid room"));
-                        button.setEnabled(room.isValid() && !pending());
+                        button.setEnabled(room.isValid() && session.connected && !pending());
                         button.setOnClickListener(v -> open(room.getRoomId()));
                         ui.rooms.addView(button);
                     }
                     host.changed();

                     host.received(room);
                 }
                 @Override public void onError(RepositoryError error) { if (token == screenGeneration) showError(error); }
             });
+            if (session.connected) {
+                session.repository.getRoom(session.roomId, new MultiplayerRepository.ResultCallback<RoomSnapshot>() {
+                    @Override public void onSuccess(RoomSnapshot room) {
+                        if (!active || token != screenGeneration || !session.connected) return;
+                        session.room = room;
+                        session.reconciled = true;
+                        host.received(room);
+                    }
+                    @Override public void onError(RepositoryError error) {
+                        if (active && token == screenGeneration) showError(error);
+                    }
+                });
+            }
         }
         host.changed();
     }

         host.changed();
     }
 
     boolean canMove() {
-        return active && !pending()
+        return active && session.connected && session.reconciled && !pending()
                 && session.room != null && session.room.canMove();
     }
 
     private boolean pending() {

     }
 
     private void showError(RepositoryError error) {
         session.onlineMessage = error.getMessage();
+        session.reconciled = false;
         if (active) host.changed();
     }
 
     void render() {

         ui.signOut.setVisibility(signedIn ? View.VISIBLE : View.GONE);
         ui.signIn.setEnabled(session.repository != null && !session.authPending);
         ui.signUp.setEnabled(session.repository != null && !session.authPending);
         ui.googleSignIn.setEnabled(session.repository != null && !session.authPending);
-        ui.createRoom.setEnabled(!pending());
+        ui.createRoom.setEnabled(session.connected && !pending());
         ui.signOut.setEnabled(!pending() && !session.authPending);
         for (int i = 0; i < ui.rooms.getChildCount(); i++) {
             // Invalid rooms are never actionable; each button also guards connection in open().
-            ui.rooms.getChildAt(i).setAlpha(!pending() ? 1f : .5f);
+            ui.rooms.getChildAt(i).setAlpha(session.connected && !pending() ? 1f : .5f);
         }
         String roomLabel = session.room == null || !inRoom ? "" : session.room.getRoom().getName() + " · "
                 + session.room.getRole().toString().toLowerCase(java.util.Locale.ROOT) + " · "
                 + session.room.getStatus().toString().toLowerCase(java.util.Locale.ROOT) + "\n";
-        ui.onlineStatus.setText(roomLabel + "Room screen"
+        ui.onlineStatus.setText(roomLabel + (session.connected ? "Connected" : "Disconnected")
                 + (pending() ? " · write pending / uncertain" : "") + "\n" + session.onlineMessage);
         ui.offlineGame.setVisibility(inRoom ? View.VISIBLE : View.GONE);
         ui.restart.setText("New room");
-        ui.restart.setEnabled(session.room != null && !pending());
+        ui.restart.setEnabled(session.connected && session.reconciled && session.room != null && !pending());
         ui.aiStatus.setText("Online · " + (session.room == null ? "reconciling room" : session.room.getRole().toString().toLowerCase(java.util.Locale.ROOT)));
     }
 }