Connect4 — 06: תור מחשב ברקע בלי מהלכים ישנים

 package com.example.connect4;
 
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.MainThread;
 import androidx.lifecycle.ViewModel;
+import com.example.connect4.ai.ComputerMoveService;
 import com.example.connect4.core.GameEngine;
+import com.example.connect4.core.GameState;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
 
-/** Retains the game across Activity recreation, without keeping a View or Activity. */
+/** Survives rotation. Only MainActivity updates the live engine on the main thread. */
 public final class GameSession extends ViewModel {
     public static final int MODE_LOCAL = 0;
     public static final int MODE_HEURISTIC = 1;
+
+    public GameEngine engine = new GameEngine();
     public int mode = MODE_LOCAL;
-    public int humanSide = com.example.connect4.core.GameState.RED;
-    public GameEngine engine = new GameEngine();
+    public int humanSide = GameState.RED;
     public boolean restored;
+    public String modelStatus = "Heuristic · win, block, then center";
+    private final ExecutorService computerWorker = Executors.newSingleThreadExecutor();
+    private final Handler mainThread = new Handler(Looper.getMainLooper());
+    private Future<?> pendingComputerMove;
+    private long computerRequestId;
+    private boolean computerThinking;
+    private boolean computerMoveFailed;
+
+    @MainThread
+    public boolean isComputerThinking() { return computerThinking; }
+
+    @MainThread
+    public boolean hasComputerMoveFailed() { return computerMoveFailed; }
+
+    /**
+     * Runs one calculation on the worker and delivers its result on the main thread.
+     * Cancelling invalidates even results that have already been posted for delivery.
+     * The callback still checks the position and applies the action through GameEngine.
+     */
+    @MainThread
+    public void requestComputerMove(
+            Supplier<ComputerMoveService.Result> calculation,
+            Consumer<ComputerMoveService.Result> onMoveReady,
+            Consumer<RuntimeException> onFailure) {
+        if (computerThinking) throw new IllegalStateException("A computer move is already pending");
+        long requestId = ++computerRequestId;
+        computerThinking = true;
+        computerMoveFailed = false;
+        pendingComputerMove = computerWorker.submit(() -> {
+            try {
+                ComputerMoveService.Result result = calculation.get();
+                mainThread.post(() -> {
+                    if (!completeComputerMove(requestId)) return;
+                    onMoveReady.accept(result);
+                });
+            } catch (RuntimeException failure) {
+                mainThread.post(() -> {
+                    if (!completeComputerMove(requestId)) return;
+                    computerMoveFailed = true;
+                    onFailure.accept(failure);
+                });
+            }
+        });
+    }
+
+    private boolean completeComputerMove(long requestId) {
+        if (requestId != computerRequestId) return false;
+        computerThinking = false;
+        pendingComputerMove = null;
+        return true;
+    }
+
+    /** Called before restart, configuration changes, leaving the screen, or disposal. */
+    @MainThread
+    public void cancelComputerMove() {
+        computerRequestId++;
+        computerThinking = false;
+        computerMoveFailed = false;
+        if (pendingComputerMove != null) pendingComputerMove.cancel(true);
+        pendingComputerMove = null;
+    }
+
+    @Override protected void onCleared() {
+        cancelComputerMove();
+        computerWorker.shutdownNow();
+    }
 }

 package com.example.connect4.core;
 
 import java.util.List;
+import java.util.concurrent.CancellationException;
 
 /** Deterministic fallback: win, block, then take the closest column to center. */
 public final class HeuristicPlayer implements ComputerPlayer {
     private static final int[] CENTER_ORDER = {3, 2, 4, 1, 5, 0, 6};

         }
         List<GameAction> legal = state.legalActions();
         if (legal.isEmpty()) {
             throw new IllegalArgumentException("Cannot choose an action without a legal move");
+        }
+        if (Thread.currentThread().isInterrupted()) {
+            throw new CancellationException("Heuristic calculation interrupted");
         }
 
         GameAction winning = immediateWinningAction(state, state.currentPlayer());
         if (winning != null) {

         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toBottomOf="@id/gameSetup" />
 
+    <TextView
+        android:id="@+id/aiStatus" android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_constraintTop_toBottomOf="@id/status"
+        app:layout_constraintStart_toStartOf="parent" />
+
     <com.example.connect4.ui.BoardView
         android:id="@+id/board"
         android:layout_width="0dp"
         android:layout_height="0dp"
         app:layout_constraintDimensionRatio="7:6"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintTop_toBottomOf="@id/status" />
+        app:layout_constraintTop_toBottomOf="@id/aiStatus" />
 
     <Button
         android:id="@+id/restart"
         android:layout_width="wrap_content"

 import androidx.lifecycle.ViewModelProvider;
 import com.example.connect4.core.GameAction;
 import com.example.connect4.core.GameEngine;
 import com.example.connect4.core.GameState;
-import com.example.connect4.core.ComputerPlayer;
-import com.example.connect4.core.HeuristicPlayer;
+import com.example.connect4.ai.ComputerMoveService;
 
 import com.example.connect4.databinding.ActivityMainBinding;
 
 import androidx.activity.EdgeToEdge;

 public class MainActivity extends AppCompatActivity {
     private ActivityMainBinding binding;
     private GameSession session;
     private GameSetupFragment setup;
+    private boolean started;
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);

         render();
     }
     /** Resets the game after changing a player or pressing New game. */
     private void newGame() {
+        session.cancelComputerMove();
         session.engine = new GameEngine();
         persist();
         render();
     }
 
     private boolean humanTurn() {
-        return !session.engine.snapshot().isTerminal()
+        return started && !session.isComputerThinking() && !session.engine.snapshot().isTerminal()
                 && (session.mode == GameSession.MODE_LOCAL
                 || session.engine.snapshot().currentPlayer() == session.humanSide);
     }

         binding.board.show(state);
         if (state.isDraw()) binding.status.setText("Draw — board full");
         else if (state.isTerminal()) binding.status.setText(state.winner() == GameState.RED ? "Red wins!" : "Yellow wins!");
         else binding.status.setText(state.currentPlayer() == GameState.RED ? "Red to play" : "Yellow to play");
-        if (session.mode == GameSession.MODE_HEURISTIC && !state.isTerminal() && !humanTurn()) {
-            ComputerPlayer player = new HeuristicPlayer();
-            GameAction action = player.chooseAction(state);
-            if (session.engine.apply(action)) { persist(); render(); }
-        }
+        if (session.isComputerThinking()) binding.status.setText("Computer is thinking…");
+        binding.aiStatus.setText(session.modelStatus);
+        requestComputerMoveIfNeeded();
     }
 
     /** Saves only accepted column history; the engine reconstructs the rest. */
     private void persist() {
         getPreferences(MODE_PRIVATE).edit().putString("moves", session.engine.snapshot().moves())
                 .putInt("mode", session.mode).putInt("side", session.humanSide).apply();
     }
 
+    @Override protected void onStart() { super.onStart(); started = true; render(); }
+
     @Override protected void onStop() {
+        started = false;
+        session.cancelComputerMove();
         persist();
         super.onStop();
     }
 
     ActivityMainBinding viewBinding() { return binding; }
     com.example.connect4.databinding.FragmentGameSetupBinding setupBinding() { return setup.viewBinding(); }
+
+    /** Captures one position; the worker never receives the live engine. */
+    private void requestComputerMoveIfNeeded() {
+        GameState requestedState = session.engine.snapshot();
+        if (!started || session.mode == GameSession.MODE_LOCAL || requestedState.isTerminal()
+                || session.isComputerThinking() || session.hasComputerMoveFailed()
+                || requestedState.currentPlayer() == session.humanSide) return;
+        binding.status.setText("Computer is thinking…");
+        session.requestComputerMove(
+                () -> ComputerMoveService.chooseHeuristicMove(requestedState),
+                result -> applyComputerMove(requestedState, result),
+                failure -> { session.modelStatus = "Computer move failed · " + failure.getMessage(); render(); });
+    }
+
+    /** Accepts only a result for the still-current position, on the main thread. */
+    private void applyComputerMove(GameState requestedState, ComputerMoveService.Result result) {
+        if (!started || !requestedState.equals(session.engine.snapshot())) return;
+        if (!session.engine.apply(result.action())) throw new IllegalStateException("Illegal computer action");
+        session.modelStatus = result.status();
+        persist();
+        render();
+    }
 }