KitKat impiega 6 secondi in più di Froyo per rispondere a TextToSpeech.speak() alla prima chiamata

Question

Su un telefono recente che esegue una versione recente di Android, il motore TextToSpeech può impiegare circa 6 secondi per reagire quando viene chiamato per la prima volta, confrontato a un vecchio telefono.

Il mio codice di prova è mostrato sotto. (MODIFICATO: Codice alternativo per Android 4.0.3 Ice Cream Sandwich, API 15 e successive, mostrato alla fine.)

Su un Motorola Moto G di 1 anno con 4.4.4 KitKat, possono essere necessari più di 7 secondi per il motore TextToSpeech per completare la prima chiamata a speak() la parola "Avviato". Ecco l'output del mio codice.

D/speak﹕ call: 1415501851978 
D/speak﹕ done: 1415501859122, delay: 7144 

Su una di 3 anni Samsung SGH-T499Y esecuzione 2.2 Froyo, ci vuole meno di un secondo a finire di parlare:

D/speak﹕ call: 1415502283050 
D/speak﹕ done: 1415502283900, delay: 850 

C'è un modo per scoprire ciò che sta accadendo in questo 6- secondo ritardo?
C'è un modo per far reagire il dispositivo più recente (e presumibilmente più veloce) più rapidamente?

package com.example.speak 

import android.app.Activity; 
import android.speech.tts.TextToSpeech; 
import android.os.Bundle; 
import android.util.Log; 

import java.util.HashMap; 
import java.util.Locale; 


public class MainActivity extends Activity implements TextToSpeech.OnInitListener, 
     TextToSpeech.OnUtteranceCompletedListener { 

    private final String TAG = "speak"; 
    private Activity activity; 
    private TextToSpeech tts; 
    private long launchTime; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     tts = new TextToSpeech(getApplicationContext(), this); 
    } 

    public void onInit(int status) { 
     if (status == TextToSpeech.SUCCESS) { 
      tts.setOnUtteranceCompletedListener(this); 
      tts.setLanguage(Locale.UK); 
      ttsSay("Started"); 
     } 
    } 

    private void ttsSay(String toSpeak) { 
     int mode = TextToSpeech.QUEUE_FLUSH; 
     HashMap hashMap = new HashMap<String, String>(); 
     hashMap.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, TAG); 

     launchTime = System.currentTimeMillis(); 
     Log.d(TAG, "call: " + launchTime); 
     tts.speak(toSpeak, mode, hashMap); 
    } 

    public void onUtteranceCompleted(String utteranceID) { 
     long millis = System.currentTimeMillis(); 
     Log.d(TAG, "done: " + millis + ", delay: " + (millis - launchTime)); 
    } 
} 

---

EDIT: A partire con Ice Cream Sandwich 4.0.3, API 15, Android fornisce UtteranceProgressListener, che può essere utilizzato per tempo, sia l'inizio e la fine della riproduzione text-to-speech. Quanto segue non è compatibile con Froyo;

package com.example.announceappprogress; 

import android.app.Activity; 
import android.speech.tts.TextToSpeech; 
import android.os.Bundle; 
import android.speech.tts.UtteranceProgressListener; 
import android.util.Log; 

import java.util.HashMap; 
import java.util.Locale; 


public class MainActivity extends Activity implements TextToSpeech.OnInitListener { 

    private final String TAG = "speak"; 
    private TextToSpeech tts; 
    private long launchTime; 
    private long startTime; 


    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     tts = new TextToSpeech(getApplicationContext(), this); 
     tts.setOnUtteranceProgressListener(mProgressListener); 
    } 

    public void onInit(int status) { 
     if (status == TextToSpeech.SUCCESS) { 
      tts.setLanguage(Locale.UK); 
      ttsSay("Started"); 
     } 
    } 

    private void ttsSay(String toSpeak) { 
     int mode = TextToSpeech.QUEUE_FLUSH; 
     HashMap hashMap = new HashMap<String, String>(); 
     hashMap.put(TextToSpeech.Engine.KEY_PARAM_UTTERANCE_ID, TAG); 

     launchTime = System.currentTimeMillis(); 
     Log.d(TAG, "called: " + launchTime); 
     tts.speak(toSpeak, mode, hashMap); 
    } 

    private final UtteranceProgressListener mProgressListener = new UtteranceProgressListener() { 
     @Override 
     public void onStart(String utteranceId) { 
      startTime = System.currentTimeMillis(); 
      Log.d(TAG, "started: " + startTime + ", delay: " + (startTime - launchTime)); 
     } 

     @Override 
     public void onError(String utteranceId) {} // Do nothing. 


     @Override 
     public void onDone(String utteranceId) { 
      long millis = System.currentTimeMillis(); 
      Log.d(TAG, "done: " + millis + ", total: " + (millis - launchTime) + ", duration: " + (millis - startTime)); 
     } 
    }; 
} 

Ecco un esempio dell'output che questo dà sul Motorola Moto G in esecuzione 4.4.4 KitKat:

D/speak﹕ called: 1415654293442 
D/speak﹕ started: 1415654299287, delay: 5845 
D/speak﹕ done: 1415654299995, total: 6553, duration: 708 

Answer 1

si sono probabilmente non si utilizza lo stesso motore TTS su entrambi i dispositivi.

Altri motori TTS concatenanti con suono umano (che potresti aver installato sul tuo nuovo dispositivo) possono utilizzare centinaia di megabyte di file di dati per generare la voce. La maggior parte di questi sistemi richiede una certa quantità di tempo di configurazione per la prima espressione. I sistemi basati su formanti semplici (e più meccanici) possono richiedere solo un paio di megabyte e quindi caricarli molto più rapidamente.

Un esperimento interessante sarebbe quello di scandire il "secondo" enunciato. Prevedo che sarà più veloce del primo sul tuo nuovo telefono. Inoltre, un sistema TTS dal suono più naturale generalmente ha un tempo di latenza più lungo tra la chiamata del TTS e l'inizio del suono dall'enunciazione. In particolare se viene fornita una frase lunga poiché il sistema controlla l'intera frase per formulare il miglior fraseggio prima di iniziare l'enunciazione.

Inoltre, sei sicuro che il tuo nuovo dispositivo non stia utilizzando un servizio TTS basato su cloud? Esistono altre variabili significative aggiuntive che influiranno sulla latenza.