Verwenden Sie Text-to-Speech auf Android, um eingehende Nachrichten auszulesen

Apps mit Schnittstellen, die Sprache verwenden, haben einen einzigartigen Reiz. Sie neigen dazu, dass ihre Benutzer das Gefühl haben, etwas Futuristisches zu verwenden. Android hat seit seinen Anfängen sehr robuste Text-to-Speech (TTS) -Funktionalität. In diesem Jahr hat Google seiner TTS-Engine viele hochwertige Stimmen hinzugefügt. Dies ist ein Grund mehr für Entwickler, sie in ihren Apps zu verwenden.

In diesem Lernprogramm erfahren Sie, wie Sie eine einfache App mit einer minimalistischen Benutzeroberfläche erstellen, die Textnachrichten empfangen und dem Benutzer vorlesen kann.

Voraussetzungen

Stellen Sie sicher, dass Sie das Eclipse ADT-Bundle eingerichtet haben. Sie können es auf der Android Developer-Website herunterladen. Für beste Ergebnisse benötigen Sie außerdem ein echtes Android-Gerät und einige Freunde, die Ihnen Textnachrichten senden können.

1. Erstellen Sie ein neues Projekt

Starten Sie Eclipse und erstellen Sie eine neue Android-Anwendung. Rufen Sie diese Anwendung auf SMSReader. Wenn Sie der Meinung sind, dass Sie diese App in Google Play veröffentlichen möchten, um sie mit Ihren Freunden zu teilen, müssen Sie einen eindeutigen Paketnamen verwenden. Stellen Sie das ein Minimum Erforderliches SDK zu Android 2.2 und setze das Ziel-SDK zu Android 4.4.

Diese App wird eine haben Aktivität. Wählen Aktivität erstellen und wähle Leere Aktivität.

Nennen Sie es Hauptaktivität und klicken Sie auf Fertig.

2. Bearbeiten Sie das Manifest

Diese App benötigt drei Berechtigungen:

RECEIVE_SMS um zu wissen, dass das Gerät eine SMS erhalten hat
READ_SMS um diese SMS zu lesen
READ_CONTACTS die Telefonnummer des Absenders einem Namen zuzuordnen (wenn möglich)

Fügen Sie folgende Zeilen hinzu AndroidManifest.xml.

Diese App hat nur eine Bildschirmausrichtung, das Hochformat. Bearbeiten Sie daher das Aktivität tag und füge das folgende Attribut hinzu:

android: screenOrientation = "Hochformat"

Das Manifest ist jetzt vollständig.

3. Bearbeiten Sie die Datei strings.xml

Es ist nicht zwingend erforderlich, sondern alle in der Anwendung verwendeten Zeichenfolgen zu speichern res / values / strings.xml Datei ist eine gute Praxis. Bearbeiten Sie diese Datei so, dass sie den folgenden Inhalt hat:

  SMSReader Letzte SMS Keiner SPRECHEN STARTEN HÖR AUF ZU REDEN Okay! Ich werde jetzt Ihre Nachrichten laut vorlesen. Okay! Ich werde jetzt schweigen.

Die meisten dieser Zeichenfolgen werden im nächsten Schritt verwendet.

4. Bearbeiten Sie das Layout

Bearbeiten res / layout / activity_main.xml Folgendes hinzufügen:

ein Textvorschau um den Namen der Person anzuzeigen, die die letzte SMS gesendet hat
ein Textvorschau um den Inhalt der neuesten SMS anzuzeigen
ein Umschaltknopf um die Sprachausgabe ein- und auszuschalten

Nachdem Sie Code zum Positionieren und Gestalten dieser Elemente hinzugefügt haben, sollte Ihre Datei den folgenden Inhalt haben:

Das Layout für unsere Anwendung ist jetzt abgeschlossen.

5. Erstellen Sie eine Helferklasse

Wir werden jetzt eine Hilfsklasse für die TTS-Engine erstellen. Erstellen Sie eine neue Java-Klasse und rufen Sie sie auf Sprecher.java. Diese Klasse wird verwendet, um zu vermeiden, dass die TTS-API direkt von der aufgerufen wird Aktivität.

Diese Klasse implementiert das OnInitListener Schnittstelle, damit es weiß, wann die TTS-Engine bereit ist. Wir speichern diesen Status in einer booleschen Variablen mit dem Namen bereit. Wir verwenden eine andere boolesche Variable mit dem Namen dürfen dessen Wert ist wahr Nur wenn der Benutzer der TTS-Engine das Sprechen erlaubt hat. Wir fügen auch Methoden hinzu, um den Wert dieser Variablen abzurufen und festzulegen. An diesem Punkt, Sprecher.java sollte folgenden Inhalt haben:

public class Speaker implementiert OnInitListener private TextToSpeech tts; private boolean ready = falsch; private boolean allowed = false; öffentlicher Sprecher (Kontextkontext) tts = new TextToSpeech (Kontext, this);  public boolean isAllowed () return allowed;  public void allow (boolean erlaubt) this.allowed = erlaubt;

Das OnInitListener Schnittstelle hat nur eine Methode, onInit. Diese Methode wird aufgerufen, wenn die TTS-Engine initialisiert wurde. Das Status Parameter gibt an, ob die Initialisierung erfolgreich war. Sobald wir wissen, dass die Initialisierung erfolgreich war, haben wir die Sprache der TTS-Engine eingestellt. Dies ist wichtig, um verständliche Sprache zu erzeugen. Fügen Sie den folgenden Code hinzu:

@Override public void onInit (int status) if (status == TextToSpeech.SUCCESS) // Ändern Sie dies entsprechend Ihrer // locale tts.setLanguage (Locale.US); ready = wahr;  else ready = false;

Als Nächstes fügen wir eine Methode mit dem Namen hinzu sprechen, welche die Engine verwendet, um den an sie übergebenen Text auszulesen. Zuvor prüft es, ob sowohl die dürfen und das bereit Werte sind wahr. Die von ihm erzeugte Sprache wird in den Benachrichtigungsstrom eingefügt.

public void speak (String text) // Sprich nur, wenn der TTS bereit ist // und der Benutzer das Sprechen erlaubt hat, wenn (ready && erlaubt) HashMap hash = neue HashMap(); hash.put (TextToSpeech.Engine.KEY_PARAM_STREAM, String.valueOf (AudioManager.STREAM_NOTIFICATION)); tts.speak (Text, TextToSpeech.QUEUE_ADD, Hash);

Dann fügen wir eine Methode hinzu, die für eine bestimmte Dauer Stille spielt. Mit dieser Methode können wir der Sprache Pausen hinzufügen, um sie etwas klarer zu machen. Fügen Sie der Implementierung den folgenden Code hinzu:

public void pause (int duration) tts.playSilence (duration, TextToSpeech.QUEUE_ADD, null);

Fügen Sie schließlich eine Methode hinzu, um Ressourcen freizugeben, wenn die TTS-Engine nicht mehr benötigt wird.

// Ressourcen freigeben public void destroy () tts.shutdown ();

6. Bearbeiten Sie die Aktivitätsklasse

Bearbeiten MainActivity.java und erklären Sie alle Ansichten, die wir im Layout erwähnt haben. Deklarieren Sie zwei ganze Zahlen, LANGE DAUER und KURZE DAUER. Dies sind lediglich Werte, die an den übergeben werden Redner's Pause Methode.

Erkläre auch a CODE ÜBERPRÜFEN ganze Zahl. Der Wert ist nicht wichtig. Es wird an die übergeben startActivityforResult Methode und dann verwendet, um das Ergebnis zu identifizieren.

Zum Schluss eine Redner Objekt und a Rundfunkempfänger Objekt.

Zu diesem Zeitpunkt sollte Ihre Klasse so aussehen:

public class MainActivity erweitert Aktivität private final int CHECK_CODE = 0x1; private final int LONG_DURATION = 5000; private final int SHORT_DURATION = 1200; privater Sprecher; privater ToggleButton-Schalter; private OnCheckedChangeListener toggleListener; privates TextView smsText; privates TextView SMSSender; private BroadcastReceiver smsReceiver;

Fügen Sie eine Methode hinzu, um zu prüfen, ob eine TTS-Engine auf dem Gerät installiert ist. Die Überprüfung wird durchgeführt, indem das Ergebnis eines anderen verwendet wird Aktivität.

private void checkTTS () Intent check = new Intent (); check.setAction (TextToSpeech.Engine.ACTION_CHECK_TTS_DATA); startActivityForResult (check, CHECK_CODE);

Wenn das Ergebnis von startActivityForResult kommt, die onActivityResult Methode wird aufgerufen. Deshalb müssen wir es überschreiben. Wenn das Ergebnis positiv ist, initialisieren wir das Redner Objekt. Wenn keine TTS-Engine installiert ist, leiten wir den Benutzer zur Installation um.

@Override protected void onActivityResult (int requestCode, int resultCode, Absichtsdaten) if (requestCode == CHECK_CODE) if (resultCode == TextToSpeech.Engine.CHECK_VOICE_DATA_PASS) speaker = new Speaker (this);  else Intent install = new Intent (); install.setAction (TextToSpeech.Engine.ACTION_INSTALL_TTS_DATA); startActivity (installieren);

Es ist jetzt an der Zeit, unsere zu erstellen Rundfunkempfänger um mit den Nachrichten umzugehen, die das Gerät empfängt. Wann immer es neue Nachrichten gibt, ist es onReceive Methode wird aufgerufen. Wir analysieren die Nachrichten, die als Byte-Arrays ankommen, mit dem SmsMessage Klasse. Sobald die Nachricht analysiert wurde, verwenden wir Methoden wie getDisplayMessageBody und getOriginatingAddress um aussagekräftige Informationen daraus zu extrahieren.

Mit diesen Informationen generieren wir den Text, den die TTS-Engine auslesen soll. Wir machen eine Pause LANGE DAUER Vor dem Auslesen einer neuen SMS und für KURZE DAUER zwischen den Äußerungen des Namens des SMS-Senders und dem SMS-Körper.

Fügen Sie der Implementierung den folgenden Code hinzu:

private void initializeSMSReceiver () smsReceiver = new BroadcastReceiver () @Override public void onReceive (Kontext-Kontext, Absicht), Bundle bundle = intent.getExtras (); if (bundle! = null) Object [] pdus = (Object []) bundle.get ("pdus"); für (int i = 0; iWir können nur die Telefonnummer des Absenders aus der Nachricht extrahieren. Um diese Nummer dem Namen eines Kontakts zuzuordnen, müssen wir die Kontakte des Benutzers verwenden. Die folgende Methode fragt die Kontaktdaten ab. Wenn die Telefonnummer in den Kontakten des Benutzers nicht verfügbar ist, wird die Zeichenfolge einfach zurückgegeben unbekannte Nummer:
private String getContactName (String phone) Uri Uri = Uri.withAppendedPath (PhoneLookup.CONTENT_FILTER_URI, Uri.encode (Telefon)); Zeichenfolgeprojektion [] = neue Zeichenfolge [] ContactsContract.Data.DISPLAY_NAME; Cursor Cursor = getContentResolver (). Abfrage (URI, Projektion, Null, Null, Null); if (cursor.moveToFirst ()) return Cursor.getString (0);  else return "unbekannte Nummer"; 
Vor dem Rundfunkempfänger verwendet werden kann, muss es registriert werden. In der folgenden Methode erstellen wir eine IntentFilter für eingehende SMS und dann registrieren Sie unsere smsEmpfänger dafür:
private void registerSMSReceiver () IntentFilter intentFilter = new IntentFilter ("android.provider.Telephony.SMS_RECEIVED"); registerReceiver (smsReceiver, intentFilter); 
Als nächstes erstellen wir die onCreate Methode. Hier initialisieren wir alle Objekte, die wir deklariert haben. Wir initialisieren das toggleListener um den Wert von einzustellen dürfen in dem Redner Klasse.
Nach diesen Initialisierungen rufen wir die checkTTS, initializeSMSReceiver, und registerSMSReceiver Methoden.
@Override protected void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); toggle = (ToggleButton) findViewById (R.id.speechToggle); smsText = (TextView) findViewById (R.id.sms_text); smsSender = (TextView) findViewById (R.id.sms_sender); toggleListener = new OnCheckedChangeListener () @Override public void onCheckedChanged (CompoundButton-Ansicht, boolean isChecked) if (isChecked) speaker.allow (true); speaker.speak (getString (R.string.start_speaking));  else speaker.speak (getString (R.string.stop_speaking)); speaker.allow (falsch); ; toggle.setOnCheckedChangeListener (toggleListener); checkTTS (); initializeSMSReceiver (); registerSMSReceiver ();  
Zum Schluss im onDestroy Als Methode der Aktivität heben wir die Registrierung des Empfängers auf und fahren die TTS-Engine herunter, um Ressourcen freizugeben.
@Override protected void onDestroy () super.onDestroy (); unregisterReceiver (smsReceiver); speaker.destroy (); 
 7. Ausführen und testen
Die App kann jetzt getestet werden. Kompilieren Sie es und führen Sie es auf einem physischen Android-Gerät aus. Tippen Sie auf die Umschaltfläche, um die Sprachausgabe zu aktivieren, und senden Sie sich eine SMS von einem anderen Telefon oder bitten Sie einen Ihrer Freunde, dies zu tun. Sie sollten bald hören können, wie Ihr Telefon die SMS für Sie vorliest.
Hier ist ein Beispiel der von der TTS-Engine erzeugten Sprache:
Fazit
In diesem Lernprogramm haben Sie gelernt, nicht nur die Text-to-Speech-API zu verwenden, sondern auch Broadcast-Empfänger zu verwenden und die SMS-Rohdaten sinnvoll zu verstehen. Sie können diese App jetzt weiter an Ihre Bedürfnisse anpassen.



		
			
	   
	




Code