Android topics — 22: טקסט שנאמר וקול שמוכתב

 package com.example.topics;
 
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.media.AudioAttributes;
+import android.media.AudioFocusRequest;
+import android.media.AudioManager;
 import android.os.Bundle;
-
+import android.speech.RecognizerIntent;
+import android.speech.tts.TextToSpeech;
+import android.speech.tts.UtteranceProgressListener;
 import androidx.activity.EdgeToEdge;
+import androidx.activity.result.ActivityResultLauncher;
+import androidx.activity.result.contract.ActivityResultContracts;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.core.graphics.Insets;
 import androidx.core.view.ViewCompat;
 import androidx.core.view.WindowInsetsCompat;
-
 import com.example.topics.databinding.ActivityMainBinding;
+import java.util.ArrayList;
+import java.util.Locale;
 
 public class MainActivity extends AppCompatActivity {
-
     private ActivityMainBinding binding;
-
+    private TextToSpeech speaker;
+    private boolean speakerReady;
+    private AudioManager audio;
+    private AudioFocusRequest focus;
+    private boolean hasFocus;
+    private String activeUtterance;
+    private int utteranceGeneration;
+    private final ActivityResultLauncher<Intent> recognize = registerForActivityResult(
+            new ActivityResultContracts.StartActivityForResult(), result -> {
+                if (result.getResultCode() != Activity.RESULT_OK || result.getData() == null) {
+                    binding.status.setText(R.string.speech_cancelled);
+                    return;
+                }
+                ArrayList<String> words = result.getData().getStringArrayListExtra(
+                        RecognizerIntent.EXTRA_RESULTS);
+                if (words == null || words.isEmpty()) {
+                    binding.status.setText(R.string.speech_empty);
+                    return;
+                }
+                binding.words.setText(words.get(0));
+                binding.status.setText(R.string.speech_received);
+            });
+
+    /**
+     * Creates the current Activity View tree and connects the screen's actions.
+     *
+     * @param savedInstanceState prior small UI snapshot, or null for a fresh launch
+     */
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 ⁞
         setContentView(binding.getRoot());
         ViewCompat.setOnApplyWindowInsetsListener(binding.main, (v, insets) -> {
             Insets bars = insets.getInsets(WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout());
-            v.setPadding(bars.left, bars.top, bars.right, bars.bottom);            return insets;
+            v.setPadding(bars.left, bars.top, bars.right, bars.bottom);
+            return insets;
         });
+        audio = getSystemService(AudioManager.class);
+        AudioAttributes attributes = new AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_MEDIA)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH).build();
+        focus = new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+                .setAudioAttributes(attributes)
+                .setWillPauseWhenDucked(true)
+                .setOnAudioFocusChangeListener(change -> {
+                    if (change < 0) runOnUiThread(() -> {
+                        if (!hasFocus || isDestroyed()) return;
+                        activeUtterance = null;
+                        if (speaker != null) speaker.stop();
+                        releaseFocus();
+                        binding.status.setText(R.string.focus_lost);
+                    });
+                }).build();
+        speaker = new TextToSpeech(this, state -> runOnUiThread(() -> {
+            // Both readiness and Views belong to main; a destroyed screen owns neither.
+            if (isDestroyed()) return;
+            speakerReady = state == TextToSpeech.SUCCESS && speaker != null
+                    && speaker.setLanguage(Locale.getDefault()) >= TextToSpeech.LANG_AVAILABLE;
+            binding.status.setText(speakerReady ? R.string.speech_ready : R.string.speech_unavailable);
+        }));
+        speaker.setOnUtteranceProgressListener(new UtteranceProgressListener() {
+            /**
+             * Receives engine start notification; the launch already set the speaking state.
+             *
+             * @param utteranceId identity assigned by speak
+             */
+            @Override
+            public void onStart(String utteranceId) { }
+            /**
+             * Posts completion to main and accepts it only for the current utterance.
+             *
+             * @param utteranceId identity of the completed utterance
+             */
+            @Override
+            public void onDone(String utteranceId) { runOnUiThread(() -> {
+                if (!isDestroyed() && utteranceId.equals(activeUtterance)) finishSpeaking();
+            }); }
+            /**
+             * Posts failure to main and accepts it only for the current utterance.
+             *
+             * @param utteranceId identity of the failed utterance
+             */
+            @Override
+            public void onError(String utteranceId) { runOnUiThread(() -> {
+                if (!isDestroyed() && utteranceId.equals(activeUtterance)) finishSpeaking();
+            }); }
+        });
+        binding.speak.setOnClickListener(v -> speak());
+        binding.listen.setOnClickListener(v -> listen());
+        binding.stop.setOnClickListener(v -> stopSpeaking());
+    }
+
+    /**
+     * Starts the current nonblank text only after the engine and audio focus are ready.
+     */
+    private void speak() {
+        String words = binding.words.getText().toString().trim();
+        if (!speakerReady || words.isEmpty()) {
+            binding.status.setText(R.string.speech_unavailable);
+            return;
+        }
+        if (audio.requestAudioFocus(focus) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+            binding.status.setText(R.string.focus_denied);
+            return;
+        }
+        hasFocus = true;
+        // QUEUE_FLUSH can finish an older utterance after this one has started.
+        activeUtterance = "lesson-" + (++utteranceGeneration);
+        int result = speaker.speak(words, TextToSpeech.QUEUE_FLUSH, null, activeUtterance);
+        if (result != TextToSpeech.SUCCESS) finishSpeaking();
+        else binding.status.setText(R.string.speaking);
+    }
+
+    /**
+     * Stops our output and delegates recognition to an external app; cancellation preserves text.
+     */
+    private void listen() {
+        stopSpeaking();
+        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH)
+                .putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+                        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
+                .putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault().toLanguageTag());
+        try {
+            recognize.launch(intent);
+        } catch (ActivityNotFoundException noRecognizer) {
+            binding.status.setText(R.string.recognizer_unavailable);
+        }
+    }
+
+    /**
+     * Finishes the accepted current utterance and releases its audio focus once.
+     */
+    private void finishSpeaking() {
+        activeUtterance = null;
+        if (!hasFocus) return;
+        releaseFocus();
+        binding.status.setText(R.string.speech_stopped);
+    }
+
+    /**
+     * Abandons the same request object only if this screen currently owns focus.
+     */
+    private void releaseFocus() {
+        if (!hasFocus) return;
+        hasFocus = false;
+        audio.abandonAudioFocusRequest(focus);
+    }
+
+    /**
+     * Invalidates the utterance before stopping the engine and releasing focus.
+     */
+    private void stopSpeaking() {
+        activeUtterance = null; // Later callbacks from this utterance are now obsolete.
+        if (speaker != null) speaker.stop();
+        releaseFocus();
+        binding.status.setText(R.string.speech_stopped);
+    }
+
+    /**
+     * Stops Activity-owned playback when the screen is no longer visible.
+     */
+    @Override
+    protected void onStop() {
+        stopSpeaking();
+        super.onStop();
+    }
+
+    /**
+     * Releases the TTS engine and prevents late initialization from reviving readiness.
+     */
+    @Override
+    protected void onDestroy() {
+        speakerReady = false;
+        activeUtterance = null;
+        if (speaker != null) speaker.shutdown();
+        super.onDestroy();
     }
 }

     android:layout_width="match_parent"
     android:layout_height="match_parent"
     tools:context=".MainActivity">
-
-    <TextView
-        android:layout_width="wrap_content"
+    <LinearLayout
+        android:layout_width="0dp"
         android:layout_height="wrap_content"
-        android:text="Hello World!"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintEnd_toEndOf="parent"
+        android:orientation="vertical"
+        android:padding="24dp"
+        app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-
+        app:layout_constraintEnd_toEndOf="parent">
+        <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/speech_intro"
+            android:textSize="20sp" />
+        <EditText
+            android:id="@+id/words"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="@string/speech_hint"
+            android:inputType="textCapSentences|textMultiLine"
+            android:minLines="2"
+            android:text="@string/speech_sample" />
+        <Button android:id="@+id/speak" android:layout_width="match_parent"
+            android:layout_height="wrap_content" android:text="@string/speak" />
+        <Button android:id="@+id/stop" android:layout_width="match_parent"
+            android:layout_height="wrap_content" android:text="@string/stop" />
+        <Button android:id="@+id/listen" android:layout_width="match_parent"
+            android:layout_height="wrap_content" android:text="@string/listen" />
+        <TextView android:id="@+id/status" android:layout_width="match_parent"
+            android:layout_height="wrap_content" android:layout_marginTop="16dp"
+            android:accessibilityLiveRegion="polite" android:text="@string/speech_loading" />
+    </LinearLayout>
 </androidx.constraintlayout.widget.ConstraintLayout>

 <resources>
     <string name="app_name">topics</string>
+    <string name="speech_intro">Edit a sentence and hear it, or ask a speech app to transcribe your voice.</string>
+    <string name="speech_hint">Words to speak</string>
+    <string name="speech_sample">Hello from Android.</string>
+    <string name="speak">Speak text</string>
+    <string name="stop">Stop speaking</string>
+    <string name="listen">Dictate with speech app</string>
+    <string name="speech_loading">Preparing speech engine…</string>
+    <string name="speech_ready">Speech engine ready.</string>
+    <string name="speech_unavailable">Speech engine or language unavailable.</string>
+    <string name="speaking">Speaking…</string>
+    <string name="speech_stopped">Playback stopped; audio focus released.</string>
+    <string name="focus_lost">Another app took audio focus.</string>
+    <string name="focus_denied">Audio focus unavailable; playback did not start.</string>
+    <string name="speech_cancelled">Dictation cancelled; text unchanged.</string>
+    <string name="speech_empty">No words were recognized.</string>
+    <string name="speech_received">Recognized words inserted. Review them before using them.</string>
+    <string name="recognizer_unavailable">No speech recognition app is installed.</string>
 </resources>