Techblog

Sprachsteuerung für Unity mit Android

Von Ihno Lübbers
16. Oktober 2017

Unity ist derzeit eine der am meisten genutzten Game-Engines am Markt. Vermutlich ist das auch auf die hervorragende Verfügbarkeit von Plugins, sogenannte Unity-Packages, für diverse Technologien und Einsatzzwecke zurückzuführen. Insbesondere für die Entwicklung von VR- und AR-Anwendungen für den Konsumentenmarkt wird neben der Unreal-Engine fast ausschließlich Unity genutzt. Da es aber in VR (Virtual Reality) und AR (Augmented Reality) schwer fällt, konventionelle Eingabemedien wie Maus und Tastatur zu nutzen, müssen andere Möglichkeiten herhalten.

Alternative Interaktionsmöglichkeiten sind typischerweise Controller- und Gestensteuerung beispielsweise in Kombination mit einer Spracherkennung. Unity verfügt über eine eingebaute Spracherkennung, die auf die Windows Spracherkennung zugreift. Wie zu erwarten ist, kann diese auf anderen Plattformen, beispielsweise Android, nicht eingesetzt werden. Für Android kann stattdessen ein natives Plugin implementiert werden, das die vorhandene Spracherkennung der Plattform aufruft.

How-to: Android Plugin für Unity zur Spracherkennung

In diesem Tutorial beschreibe ich, wie ein Android-Plugin für Unity erstellt wird, das native Android-Funktionen aufruft. Der erste Teil beschreibt die grundsätzliche Android-Plugin-Erstellung für Unity. Der zweite Teil zeigt, wie Unity-Funktionen aus Android aufgerufen und aus Unity heraus native Android-Schnittstellen angesprochen werden. Im Unterschied zu vielen der existierenden Android-Plugins für Unity wird in diesem Tutorial nicht von der UnityPlayerActivity abgeleitet. Statt dessen wird mit einem Fragment gearbeitet. Dadurch verhindert man, dass unterschiedliche Android Plugins sich in Unity gegenseitig überschreiben – Stichwort: Manifest.

Das Tutorial kann als Merge von diesem Tutorial und dem Git-Repository betrachtet werden: 

Das Git Repository mit gesamten Projekten, dem fertigen Plugin sowie Source-Code gibt es hier

 


Teil 1

HelloFromAndroid Plugin

Im ersten Teil wird ein minimales Android-Plugin für Unity erstellt, das nichts weiter tut, als eine Begrüßung auszugeben. Wer das kennt, kann direkt zum zweiten Teil springen.

Schritt 1- Android Studio Project Setup:

  • Neues Android-Studio-Projekt ohne Activity anlegen
    File -> New -> New Project -> „Dein Projekt“
  • Projekt- statt Android-Ansicht aktivieren, um alle Dateien zu sehen
  • Neues Android-Library-Modul anlegen
    File -> New -> New Module -> “Dein Modul”
  • Das zu Beginn automatisch generierte „app“ Modul kann gelöscht werden
    Rechtsklick „app“ Modul -> Open Module Settings -> Minus>
    Der „app“ Ordner kann jetzt gelöscht werden

Schritt 2 – Erstellen eines Hello-Plugins

  • Zum src Ordner deines Moduls navigieren und die Klasse „HelloFromAndroid.java“ mit folgendem Inhalt anlegen:

  1. package de.maibornwolff.speechrec;
  2.  
  3. public class HelloFromAndroid {
  4.     public static String sayHi(String caller){
  5.         return "Hi "+caller+", I'm Android!";
  6.     }
  7. }
  • Das Hello-Plugin ist fertig und kann in Android Studio über Gradle gebaut werden
    Gradle Tab -> „dein Modul“ -> Tasks -> build -> assemble
  • Die generierten .aar Dateien befinden sich build -> outputs Ordner des Moduls

 

Schritt 3 – Verwendung im Unity Projekt

  • Ein neues Unity Projekt anlegen und den Ordner Plugins/“dein Plugin“ darin anlegen
  • Eine der .aar Dateien aus Schritt 2 (debug/release) per Drag&Drop in den Ordner kopieren

  • Eine „GetGreeting.cs“ Klasse mit folgendem Inhalt in den Assets anlegen:
  1. using UnityEngine;
  2. using UnityEngine.UI;
  3.  
  4. public class GetGreeting : MonoBehaviour
  5. {
  6.     public Text uiText;
  7.  
  8.     void Start()
  9.     {      
  10.         AndroidJavaClass pluginClass = new AndroidJavaClass(
  11.             "de.maibornwolff.speechrec.HelloFromAndroid");
  12.         uiText.text = pluginClass.CallStatic<string>("sayHi", "Unity");
  13.     }
  14. }
  • Nicht vergessen, die Variable uiText im Unity-Editor zu verbinden und das Skript einem aktiven Objekt (z.B. der Main Camera) hinzuzufügen!
  • Die HelloFromAndroid-App ist fertig und kann für Android gebaut werden!
  • Zum Testen ein Device anschließen oder Android Emulator starten.
  • Über Assets -> Export Package, kann auch ein Unity Package erstellt werden.


Teil 2

Natives Plugin für die Spracherkennung

Im zweiten Teil erstellen wir ein Plugin, das aus Unity heraus die integrierte Spracherkennung von Android aufruft und das Ergebnis an Unity zurückliefert. Es empfiehlt sich,  entweder ein neues Android-Projekt zu erstellen (wie in Schritt 1 beschrieben), oder die Datei „HelloFromAndroid.java“ aus Teil 1 zu löschen, da sie nicht länger benötigt wird. Das .aar-Plugin und das Script im Unity-Projekt sollten ebenfalls gelöscht werden.

Schritt 4 – Nutzen von Unity-Funktionen in Android Studio

  • Um in Android Studio auf Unity zugreifen zu können, wird die classes.jar der Unity Installation in den libs-Ordner des Moduls in Android Studio kopiert
    Fundort bei Windows: C:\Program Files\Unity\Editor\Data\PlaybackEngines\AndroidPlayer\Variations\mono\Release\Classes\classes.jar
    Optional: Beim Kopieren umbenennen in „UnityPlayer.jar“

  • Um mögliche „unable to convert classes into dex format“-Fehler beim Unity-Build zu vermeiden, sollten alle Android- und Unity-Dependencies des Moduls auf „Provided“ gesetzt werden, da diese von Unity ohnehin bereitgestellt werden. 

  • Im „src“ Ordner wird eine Android-Fragment-Klasse mit folgendem Inhalt angelegt:

  1. package de.maibornwolff.speechrecognition.plugin;
  2.  
  3. import android.app.Fragment;
  4. import android.content.Intent;
  5. import android.os.Bundle;
  6. import android.speech.RecognizerIntent;
  7. import android.util.Log;
  8. import com.unity3d.player.UnityPlayer;
  9. import java.util.Locale;
  10.  
  11. import static android.app.Activity.RESULT_OK;
  12.  
  13. public class SpeechRecFragment extends Fragment {
  14.  
  15.     static final String TAG = "SpeechRecFragment";
  16.     static final int REQ_CODE_SPEECH_INPUT = 1;
  17.     static SpeechRecFragment instance;
  18.     static String gameObjectName;
  19.  
  20.     public static void start(String gameObjectName) {
  21.         instance = new SpeechRecFragment();
  22.         instance.gameObjectName = gameObjectName;
  23.         UnityPlayer.currentActivity.getFragmentManager().
  24.                 beginTransaction().add(instance, SpeechRecFragment.TAG).commit();
  25.     }
  26.  
  27.     @Override
  28.     public void onCreate(Bundle savedInstanceState) {
  29.         super.onCreate(savedInstanceState);
  30.         // Retain between configuration changes (like device rotation)
  31.         setRetainInstance(true);
  32.     }
  33.  
  34.     public static void promptSpeechInput() {
  35.         Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
  36.         intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
  37.                 RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
  38.         intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, Locale.getDefault());
  39.         instance.startActivityForResult(intent, REQ_CODE_SPEECH_INPUT);
  40.     }
  41.  
  42.     @Override
  43.     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  44.         switch (requestCode) {
  45.             case REQ_CODE_SPEECH_INPUT: {
  46.                 if (resultCode == RESULT_OK && null != data) {
  47.                     UnityPlayer.UnitySendMessage(gameObjectName, "OnSpeechRecognitionResult",
  48.                             data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS).get(0));
  49.                     String match = data.getStringArrayListExtra(
  50.                             RecognizerIntent.EXTRA_RESULTS).get(0);
  51.                     Log.i("UnityTag", match);
  52.                 }
  53.             }
  54.         }
  55.     }
  56. }
  • Das Plugin kann jetzt über Gradle gebaut und die .aar in das Unity-Projekt eingefügt werden.

 

Schritt 5 – Aufruf der nativen Android Funktion aus Unity

  • Im Unity wird ein Script „AndroidSpeechRecognizer.cs“ mit folgendem Inhalt angelegt:
  1. using UnityEngine;
  2. using UnityEngine.UI;
  3.  
  4. public class AndroidSpeechReconizer : MonoBehaviour {
  5.  
  6.     AndroidJavaClass pluginClass;  
  7.     public Text uiText;
  8.  
  9.     void Start()
  10.     {      
  11.         AndroidJavaClass pluginClass = new AndroidJavaClass(
  12.             "de.maibornwolff.speechrecognition.plugin.SpeechRecFragment");      
  13.         pluginClass.CallStatic("start", gameObject.name);    
  14.         pluginClass.CallStatic("promptSpeechInput");        
  15.     }
  16.  
  17.     public void OnSpeechRecognitionResult(string result)
  18.     {
  19.         uiText.text = result;
  20.     }
  21. }
  • dann das Script einem aktiven Objekt in der Szene hinzufügen und den UI-Text verlinken

  • Das Unity Test-Projekt ist fertig und kann für Android gebaut werden.
  • Über Assets → Export Package kann zudem ein Unitypackage erstellt werden:

 

Das mit diesem Tutorial erstellte Plugin ruft, wie in der Abbildung zu sehen ist, die in Android eingebaute Spracherkennung von Google auf. Die Resultate werden an die im Quellcode definierte Funktion in Unity zurückgeliefert. Nach dem beschriebenen Prinzip können auch andere native Android-Funktionen, beispielsweise Kamera, aufgerufen und als Unity Plugin exportiert werden. Da im Kern des Plugins ein Android-Fragment - statt der UnityPlayerActivity - genutzt wird, können die so erstellten Plugins auch problemlos im selben Unity-Projekt genutzt werden, denn jedes Fragment besitzt eine eigene „onActivityResult()“ Funktion.

Neuen Kommentar schreiben

Public Comment form

  • Zulässige HTML-Tags: <a> <em> <strong> <cite> <blockquote> <code> <ul> <ol> <li> <dl> <dt> <dd><p><h1><h2><h3>

Plain text

  • Keine HTML-Tags erlaubt.
  • Internet- und E-Mail-Adressen werden automatisch umgewandelt.
  • HTML - Zeilenumbrüche und Absätze werden automatisch erzeugt.

ME Landing Page Question

Erhalten Sie regelmäßig Praxis-Tipps per E-Mail

Praxis-Tipps per E-Mail erhalten