Utilisez la synthèse vocale sur Android pour lire les messages entrants

Les applications avec des interfaces qui utilisent la voix ont un attrait unique. Ils ont tendance à faire sentir à leurs utilisateurs qu’ils utilisent quelque chose de futuriste. Depuis ses débuts, Android dispose d’une fonctionnalité de synthèse vocale (TTS) très robuste. Cette année, Google a ajouté de nombreuses voix de haute qualité à son moteur TTS et c’est une raison de plus pour les développeurs de l’utiliser dans leurs applications.

Dans ce didacticiel, vous apprendrez à créer une application simple, avec une interface utilisateur minimaliste, capable de recevoir des messages texte et de les lire à l’utilisateur.

Conditions préalables

Assurez-vous que le bundle Eclipse ADT est configuré. Vous pouvez le télécharger sur le Site Web des développeurs Android. Pour de meilleurs résultats, vous aurez également besoin d’un véritable appareil Android et de quelques amis qui peuvent vous envoyer des messages texte.

1. Créez un nouveau projet

Démarrez Eclipse et créez une nouvelle application Android. Appelez cette application SMSReader. Si vous pensez publier cette application sur Google Play pour la partager avec vos amis, assurez-vous d’utiliser un nom de package unique. Met le SDK minimum requis à Android 2.2 et définissez le SDK cible à Android 4.4.

Cette application en aura un Activity. Sélectionner Créer une activité et choisissez Activité vide.

Nomme le Activité principale et cliquez terminer.

2. Modifier le manifeste

Cette application nécessite trois autorisations:

• RECEIVE_SMS pour savoir que l’appareil a reçu un SMS
• READ_SMS pour lire ce SMS
• READ_CONTACTS mapper le numéro de téléphone de l’expéditeur à un nom (si possible)

Ajoutez les lignes suivantes à votre AndroidManifest.xml.

<uses-permission android:name="android.permission.READ_SMS"/>
<uses-permission android:name="android.permission.RECEIVE_SMS"/>
<uses-permission android:name="android.permission.READ_CONTACTS"/>

Cette application n’aura qu’une seule orientation d’écran, portrait. Par conséquent, modifiez le activity et ajoutez-y l’attribut suivant:

android:screenOrientation="portrait"

Le manifeste est maintenant terminé.

3. Modifier strings.xml

Ce n’est pas absolument nécessaire, mais stocker toutes les chaînes que l’application utilise dans le res / values ​​/ strings.xml fichier est une bonne pratique. Modifiez ce fichier afin qu’il ait le contenu suivant:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string name="app_name">SMSReader</string>
    <string name="sms_label">Latest SMS</string>
    <string name="none">None</string>
    <string name="speech_toggle_on">START SPEAKING</string>
	<string name="speech_toggle_off">STOP SPEAKING</string>
	
	<string name="start_speaking">Okay! I will read your messages out loud for you now.</string>
	<string name="stop_speaking">Okay! I will stay silent now.</string>
</resources>

La plupart de ces chaînes sont utilisées à l’étape suivante.

4. Modifier la mise en page

Éditer res / layout / activity_main.xml pour ajouter ce qui suit:

• une TextView pour afficher le nom de la personne qui a envoyé le dernier SMS
• une TextView pour afficher le contenu du dernier SMS
• une ToggleButton pour activer et désactiver la sortie vocale

Après avoir ajouté du code pour positionner et styliser ces éléments, votre fichier doit avoir le contenu suivant:

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="${packageName}.${activityClass}"
    android:background="#99CC00"
    >

    <TextView
        android:id="@+id/sms_sender"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="20dp"
        android:text="@string/sms_label"
        android:textColor="#ffffff"
        android:textAppearance="?android:attr/textAppearanceSmall" />

    <TextView
        android:id="@+id/sms_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_below="@+id/sms_sender"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="10dp"
        android:text="@string/none"
        android:textAppearance="?android:attr/textAppearanceLarge" 
        android:textColor="#ffffff"
        />

    <ToggleButton
        android:id="@+id/speechToggle"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:textOff="@string/speech_toggle_on"
        android:textOn="@string/speech_toggle_off"                 
        />
    
</RelativeLayout>

La mise en page de notre application est maintenant terminée.

5. Créer une classe d’assistance

Nous allons maintenant créer une classe d’assistance pour le moteur TTS. Créez une nouvelle classe Java et appelez-la Speaker.java. Cette classe est utilisée pour éviter d’appeler l’API TTS directement depuis le Activity.

Cette classe implémente le OnInitListener interface afin qu’il sache quand le moteur TTS est prêt. Nous stockons cet état prêt dans une variable booléenne nommée ready. Nous utilisons une autre variable booléenne nommée allowed dont la valeur est true uniquement si l’utilisateur a autorisé le moteur TTS à parler. Nous ajoutons également des méthodes pour obtenir et définir la valeur de cette variable. À ce point, Speaker.java devrait avoir le contenu suivant:

public class Speaker implements OnInitListener {

    private TextToSpeech tts;
	
	private boolean ready = false;
	
	private boolean allowed = false;
	
	public Speaker(Context context){
		tts = new TextToSpeech(context, this);		
	}	
	
	public boolean isAllowed(){
		return allowed;
	}
	
	public void allow(boolean allowed){
		this.allowed = allowed;
	}
}

le OnInitListener l’interface n’a qu’une seule méthode, onInit. Cette méthode est appelée lorsque le moteur TTS a été initialisé. le status Le paramètre nous permet de savoir si l’initialisation a réussi. Une fois que nous savons que l’initialisation a réussi, nous définissons la langue du moteur TTS. Ceci est important pour produire un discours compréhensible. Ajoutez le code suivant:

@Override
public void onInit(int status) {
	if(status == TextToSpeech.SUCCESS){
		// Change this to match your
		// locale
		tts.setLanguage(Locale.US);
		ready = true;
	}else{
		ready = false;
	}
}

Ensuite, nous ajoutons une méthode nommée speak, qui utilise le moteur pour lire tout texte qui lui est passé. Avant de le faire, il vérifie si les deux allowed et le ready les valeurs sont true. Le discours qu’il génère est placé dans le flux de notification.

public void speak(String text){
	
	// Speak only if the TTS is ready
	// and the user has allowed speech
	
	if(ready && allowed) {
		HashMap<String, String> hash = new HashMap<String,String>();
		hash.put(TextToSpeech.Engine.KEY_PARAM_STREAM, 
				String.valueOf(AudioManager.STREAM_NOTIFICATION));
		tts.speak(text, TextToSpeech.QUEUE_ADD, hash);
	}
}

Nous ajoutons ensuite une méthode qui joue le silence pendant une durée spécifiée. En utilisant cette méthode, nous pouvons ajouter des pauses au discours pour le rendre un peu plus clair. Ajoutez le code suivant à l’implémentation:

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

Enfin, ajoutez une méthode pour libérer des ressources lorsque le moteur TTS n’est plus nécessaire.

// Free up resources
public void destroy(){
	tts.shutdown();
}

6. Modifier la classe d’activité

Éditer MainActivity.java et déclarez toutes les vues que nous avons mentionnées dans la mise en page. Déclarez deux entiers, LONG_DURATION et SHORT_DURATION. Ce ne sont que des valeurs transmises au Speakerde pause méthode.

Déclarez également un CHECK_CODE entier. Sa valeur n’est pas importante. Il est transmis au startActivityforResult méthode puis utilisé pour identifier le résultat.

Enfin, déclarez un Speaker objet et un BroadcastReceiver objet.

À ce stade, votre classe devrait ressembler à ceci:

public class MainActivity extends Activity {    
    
	private final int CHECK_CODE = 0x1;
	private final int LONG_DURATION = 5000;
	private final int SHORT_DURATION = 1200;
	
	private Speaker speaker;	
	
	private ToggleButton toggle;
	private OnCheckedChangeListener toggleListener;
	
	private TextView smsText;
	private TextView smsSender;
	
	private BroadcastReceiver smsReceiver;
}

Ajoutez une méthode pour vérifier si un moteur TTS est installé sur l’appareil. Le contrôle est effectué en utilisant le résultat d’un autre Activity.

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

Lorsque le résultat de startActivityForResult arrive, le onActivityResult méthode est appelée. Par conséquent, nous devons le contourner. Dans cette méthode, si le résultat est positif, on initialise le Speaker objet. Si aucun moteur TTS n’est installé, nous redirigeons l’utilisateur pour l’installer.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
	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(install);
        }
	}
}

Il est maintenant temps de créer notre BroadcastReceiver pour traiter les messages que le périphérique reçoit. Chaque fois qu’il y a de nouveaux messages, son onReceive méthode est appelée. Nous analysons les messages, qui arrivent sous forme de tableaux d’octets, en utilisant le SmsMessage classe. Une fois le message analysé, nous utilisons des méthodes comme getDisplayMessageBody et getOriginatingAddress pour en extraire des informations significatives.

Avec ces informations, nous générons le texte que le moteur TTS doit lire. Nous nous arrêtons pour LONG_DURATION avant de lire un nouveau SMS et pour SHORT_DURATION entre les énoncés du nom de l’expéditeur du SMS et le corps du SMS.

Ajoutez le code suivant à l’implémentation:

private void initializeSMSReceiver(){
	smsReceiver = new BroadcastReceiver(){
		@Override
		public void onReceive(Context context, Intent intent) {
			
			Bundle bundle = intent.getExtras();
			if(bundle!=null){
				Object[] pdus = (Object[])bundle.get("pdus");
				for(int i=0;i<pdus.length;i++){
					byte[] pdu = (byte[])pdus[i];
					SmsMessage message = SmsMessage.createFromPdu(pdu);
					String text = message.getDisplayMessageBody();
					String sender = getContactName(message.getOriginatingAddress());
					speaker.pause(LONG_DURATION);
					speaker.speak("You have a new message from" + sender + "!");
					speaker.pause(SHORT_DURATION);
					speaker.speak(text);
					smsSender.setText("Message from " + sender);
					smsText.setText(text);
				}
			}
			
		}			
	};		
}

Nous ne pouvons extraire que le numéro de téléphone de l’expéditeur du message. Pour associer ce numéro au nom d’un contact, nous devons utiliser les contacts de l’utilisateur. La méthode suivante interroge les données des contacts. Si le numéro de téléphone n’est pas disponible dans les contacts de l’utilisateur, il renvoie simplement la chaîne unknown number:

private String getContactName(String phone){
	Uri uri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(phone));
	String projection[] = new String[]{ContactsContract.Data.DISPLAY_NAME};
	Cursor cursor = getContentResolver().query(uri, projection, null, null, null);				
	if(cursor.moveToFirst()){
		return cursor.getString(0);
	}else {
		return "unknown number";
	}
}

Avant le BroadcastReceiver peut être utilisé, il doit être enregistré. Dans la méthode suivante, nous créons un IntentFilter pour les messages texte entrants, puis enregistrez notre smsReceiver pour ça:

private void registerSMSReceiver() {	
	IntentFilter intentFilter = new IntentFilter("android.provider.Telephony.SMS_RECEIVED");
	registerReceiver(smsReceiver, intentFilter);
}

Ensuite, nous créons le onCreate méthode. Voici où nous initialisons tous les objets que nous avons déclarés. Nous initialisons le toggleListener pour définir la valeur de allowed dans le Speaker classe.

Après ces initialisations, nous appelons le checkTTS, initializeSMSReceiver, et registerSMSReceiver méthodes.

@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 view, boolean isChecked) {
			if(isChecked){
				speaker.allow(true);
				speaker.speak(getString(R.string.start_speaking));
			}else{
				speaker.speak(getString(R.string.stop_speaking));
				speaker.allow(false);					
			}
		}
	};		
	toggle.setOnCheckedChangeListener(toggleListener);
	
	checkTTS();
	initializeSMSReceiver();
	registerSMSReceiver();
}	

Enfin, dans le onDestroy méthode de l’activité, nous désenregistrons notre récepteur et arrêtons le moteur TTS pour libérer des ressources.

@Override
protected void onDestroy() {	
	super.onDestroy();
	unregisterReceiver(smsReceiver);
	speaker.destroy();
}

sept. Exécuter et tester

L’application est maintenant prête à être testée. Compilez et exécutez-le sur un appareil Android physique. Appuyez sur le bouton bascule pour activer la voix et vous envoyer un SMS depuis un autre téléphone ou demander à l’un de vos amis de le faire. Vous devriez bientôt pouvoir entendre votre téléphone lire le SMS à votre place.

Voici un échantillon de la parole générée par le moteur TTS:

Conclusion

Dans ce didacticiel, vous avez appris non seulement à utiliser l’API de synthèse vocale, mais également à utiliser des récepteurs de diffusion et à donner un sens à partir de données SMS brutes. Vous pouvez maintenant personnaliser davantage cette application en fonction de vos besoins.