Hex — 07: שחקני RL מסופקים

 package com.example.hex;
 
 import android.os.Bundle;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+
 import androidx.activity.EdgeToEdge;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.graphics.Insets;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.WindowInsetsCompat;
+
 import com.example.hex.databinding.ActivityMainBinding;
+
+import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
 
-/** Coordinates human moves and an offline computer reply. */
+/** Hosts the game screen and coordinates board input, model loading, and background AI turns. */
 public final class MainActivity extends AppCompatActivity {
     private ActivityMainBinding binding;
     private HexGame game;
     private TfliteValueModel valueModel;
     private ExecutorService aiExecutor;
     private Future<?> aiTask;
+    private List<ModelCatalog.Level> computerLevels = Collections.emptyList();
+    private ModelCatalog.Level selectedLevel;
     private boolean vsAi = true;
     private boolean aiThinking;
     private boolean modelLoading;
     private int gameGeneration;
+    private final AtomicInteger modelSelectionGeneration = new AtomicInteger();
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         EdgeToEdge.enable(this);
+
         binding = ActivityMainBinding.inflate(getLayoutInflater());
         setContentView(binding.getRoot());
+
         ViewCompat.setOnApplyWindowInsetsListener(binding.main, (v, insets) -> {
             Insets systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
             v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom);
             return insets;
         });
+
         aiExecutor = Executors.newSingleThreadExecutor();
         game = new HexGame();
+
+        binding.modeAi.setChecked(vsAi);
+        binding.modeHuman.setChecked(!vsAi);
+        binding.boardView.setGame(game);
         binding.boardView.setOnCellClickListener(this::onCellClicked);
         binding.restartButton.setOnClickListener(view -> restartGame());
-        binding.modeAi.setChecked(true);
         binding.modeGroup.setOnCheckedChangeListener((group, checkedId) -> {
             boolean requestedAi = checkedId == R.id.modeAi;
             if (requestedAi != vsAi) {
                 vsAi = requestedAi;
+                binding.computerLevelContainer.setVisibility(vsAi ? View.VISIBLE : View.GONE);
                 restartGame();
             }
         });
-        loadModel();
+        setupComputerLevels();
+
         render();
+        if (vsAi && game.getCurrentPlayer() == HexGame.BLUE && !game.isOver()) {
+            startAiMove();
+        }
+    }
+
+
+
+    private void setupComputerLevels() {
+        try {
+            computerLevels = ModelCatalog.load(getApplicationContext());
+        } catch (Exception exception) {
+            computerLevels = Collections.emptyList();
+            binding.computerLevelSpinner.setEnabled(false);
+            return;
+        }
+
+        ArrayAdapter<ModelCatalog.Level> adapter = new ArrayAdapter<>(this,
+                android.R.layout.simple_spinner_item, computerLevels);
+        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+        binding.computerLevelSpinner.setAdapter(adapter);
+        binding.computerLevelSpinner.setSelection(0, false);
+        binding.computerLevelSpinner.setOnItemSelectedListener(
+                new AdapterView.OnItemSelectedListener() {
+                    @Override
+                    public void onItemSelected(AdapterView<?> parent, View view,
+                                               int position, long id) {
+                        switchComputerLevel(computerLevels.get(position));
+                    }
+
+                    @Override
+                    public void onNothingSelected(AdapterView<?> parent) {
+                        // The current selection remains active.
+                    }
+                });
+        switchComputerLevel(computerLevels.get(0));
     }
 
-    private void loadModel() {
+    private void switchComputerLevel(ModelCatalog.Level level) {
+        if (level == selectedLevel && (modelLoading || valueModel != null)) {
+            return;
+        }
+
+        selectedLevel = level;
+        int selectionGeneration = modelSelectionGeneration.incrementAndGet();
+        TfliteValueModel previousModel = valueModel;
+        valueModel = null;
         modelLoading = true;
+        restartGame();
+
         aiExecutor.submit(() -> {
-            TfliteValueModel loaded = null;
+            if (previousModel != null) {
+                previousModel.close();
+            }
+            if (selectionGeneration != modelSelectionGeneration.get()) {
+                return;
+            }
+
+            TfliteValueModel loadedModel = null;
+            Exception loadFailure = null;
             try {
-                loaded = new TfliteValueModel(getApplicationContext());
-            } catch (Exception ignored) {
-                // The screen will say that the computer is unavailable.
+                loadedModel = new TfliteValueModel(getApplicationContext(),
+                        level.modelAsset, level.metadataAsset);
+            } catch (Exception exception) {
+                loadFailure = exception;
             }
-            TfliteValueModel result = loaded;
-            runOnUiThread(() -> {
-                if (isFinishing() || isDestroyed()) {
-                    if (result != null) result.close();
-                    return;
-                }
-                valueModel = result;
-                modelLoading = false;
-                render();
-            });
+
+            TfliteValueModel result = loadedModel;
+            Exception failure = loadFailure;
+            runOnUiThread(() -> finishModelSwitch(
+                    selectionGeneration, level, result, failure));
         });
     }
 
+    private void finishModelSwitch(int selectionGeneration, ModelCatalog.Level level,
+                                   TfliteValueModel loadedModel, Exception failure) {
+        if (isFinishing() || isDestroyed()
+                || selectionGeneration != modelSelectionGeneration.get()
+                || selectedLevel != level) {
+            if (loadedModel != null) {
+                loadedModel.close();
+            }
+            return;
+        }
+
+        modelLoading = false;
+        valueModel = failure == null ? loadedModel : null;
+        render();
+    }
+
     private void onCellClicked(int row, int column) {
-        if (aiThinking || game.isOver()
-                || (vsAi && (modelLoading || valueModel == null
-                || game.getCurrentPlayer() != HexGame.RED))) return;
-        if (!game.play(row, column)) return;
+        if (aiThinking || (vsAi && modelLoading) || game.isOver()
+                || (vsAi && valueModel == null)
+                || (vsAi && game.getCurrentPlayer() == HexGame.BLUE)) {
+            return;
+        }
+        if (!game.play(row, column)) {
+            return;
+        }
         render();
-        if (vsAi && !game.isOver()) startAiMove();
+        if (vsAi && !game.isOver()) {
+            startAiMove();
+        }
     }
 
     private void startAiMove() {
         TfliteValueModel model = valueModel;
         if (!vsAi || model == null || game.isOver()
-                || game.getCurrentPlayer() != HexGame.BLUE || aiThinking) return;
+                || game.getCurrentPlayer() != HexGame.BLUE || aiThinking) {
+            render();
+            return;
+        }
+
         aiThinking = true;
         render();
         int generation = gameGeneration;
         aiTask = aiExecutor.submit(() -> {
             try {
                 HexGame.Move move = new HexAi(model).chooseMove(position);
-                runOnUiThread(() -> {
-                    if (isFinishing() || isDestroyed()
-                            || generation != gameGeneration || !aiThinking) return;
-                    aiThinking = false;
-                    if (move != null && game.getCurrentPlayer() == HexGame.BLUE) {
-                        game.play(move.row, move.column);
-                    }
-                    render();
-                });
+                runOnUiThread(() -> applyAiMove(generation, move));
             } catch (RuntimeException exception) {
-                runOnUiThread(() -> {
-                    if (isFinishing() || isDestroyed()
-                            || generation != gameGeneration) return;
-                    aiThinking = false;
-                    valueModel = null;
-                    aiExecutor.submit(model::close);
-                    render();
-                });
+                runOnUiThread(() -> handleAiFailure(generation, model));
             }
         });
     }
 
+    private void applyAiMove(int generation, HexGame.Move move) {
+        if (isFinishing() || isDestroyed() || generation != gameGeneration || !aiThinking) {
+            return;
+        }
+        aiThinking = false;
+        if (move != null && game.getCurrentPlayer() == HexGame.BLUE) {
+            game.play(move.row, move.column);
+        }
+        render();
+    }
+
+    private void handleAiFailure(int generation, TfliteValueModel failedModel) {
+        if (isFinishing() || isDestroyed() || generation != gameGeneration) {
+            return;
+        }
+        aiThinking = false;
+        if (valueModel == failedModel) {
+            valueModel = null;
+            aiExecutor.submit(failedModel::close);
+        }
+        render();
+    }
+
     private void restartGame() {
         gameGeneration++;
         aiThinking = false;
             aiTask = null;
         }
         game = new HexGame();
+        binding.boardView.setGame(game);
         render();
     }
 
     private void render() {
         binding.boardView.setGame(game);
-        binding.boardView.setEnabled(!aiThinking && !game.isOver()
+        boolean canTap = !aiThinking && !game.isOver()
                 && (!vsAi || (!modelLoading && valueModel != null
-                && game.getCurrentPlayer() == HexGame.RED)));
+                && game.getCurrentPlayer() == HexGame.RED));
+        binding.boardView.setEnabled(canTap);
+
         if (game.getWinner() == HexGame.RED) {
             binding.statusText.setText(R.string.status_red_wins);
         } else if (game.getWinner() == HexGame.BLUE) {
             binding.statusText.setText(game.getCurrentPlayer() == HexGame.RED
                     ? R.string.status_red_turn : R.string.status_blue_turn);
         }
-        binding.modelText.setText(vsAi
-                ? (valueModel == null ? R.string.model_unavailable_help
-                : R.string.model_untrained)
-                : R.string.model_local);
+
+        if (!vsAi) {
+            binding.modelText.setText(R.string.model_local);
+        } else if (selectedLevel == null) {
+            binding.modelText.setText(R.string.model_unavailable_help);
+        } else if (modelLoading) {
+            binding.modelText.setText(getString(R.string.model_loading, selectedLevel.label));
+        } else if (valueModel == null) {
+            binding.modelText.setText(R.string.model_unavailable_help);
+        } else if (valueModel.isUntrainedMock()) {
+            binding.modelText.setText(R.string.model_untrained);
+        } else {
+            binding.modelText.setText(selectedLevel.description);
+        }
     }
 
     @Override
     protected void onDestroy() {
         gameGeneration++;
-        if (aiTask != null) aiTask.cancel(true);
-        TfliteValueModel model = valueModel;
+        modelSelectionGeneration.incrementAndGet();
+        if (aiTask != null) {
+            aiTask.cancel(true);
+        }
+        TfliteValueModel modelToClose = valueModel;
         valueModel = null;
-        if (model != null) aiExecutor.submit(model::close);
+        if (modelToClose != null) {
+            aiExecutor.submit(modelToClose::close);
+        }
         aiExecutor.shutdown();
         binding = null;
         super.onDestroy();