The queue processor should not be called for the next item
until synthesis has actually happened for the current item;
before it was being incorrectly called regardless of
whether or not the synthesizer had processed the current item.
Merge commit '014085a8727d7e10a4d39cba4a6d27826b66bc00'
* commit '014085a8727d7e10a4d39cba4a6d27826b66bc00':
Fix for a race condition that can occur if an utterance
if it was synthesing to a file, the latter can be deleted without
still being written to.
Clear the hashmap of SpeechItem to be stopped (mKillList) when the speech
queue is empty.
If files were being synthesized to while the service was being killed,
it would have left partially written files (with no header). This CL
checks if the service is rendering to a file at the time the service
is destroyed: if it is, it will stop the rendering and deletes the file.
A race condition is encountered when an application invokes shutdown()
on its TextToSpeech object while is has speak() requests still running.
Since the TTS service destructor releases the synthesizer resources and
sets the corresponding synth reference to null, an NPE was observed.
The fix consists in catching NPEs whenever the sNativeSynth object is
accessed, and return the matching error for the call.
This change is a "low risk" version of the fix for bug 2025765i (same
issue) which was reverted because it was higher risk than this CL:
it affected the logic of each call to sNativeSynth. This CL only sets
an error code when an NPE is fired because sNativeSynth is null.
Talkback produced a null pointer exception when being enabled and disabled
repeatedly due to a race condition between the onDestroy() of the service,
and the use of the service itself. The error occurs when one Talkback
thread initiates the destruction of the service (call to onDestroy()) when
it invokes shutdown() on its TextToSpeech instance (the client of the
service). At the same time, Talkback tries to say that "Accessibility" is
unchecked from another thread. During onDestroy(), the reference to the
TTS engine (sNativeSynth) is reset to null, which is used in the service
in speakInternalOnly(), and setLanguage().
The fix consists in the addition of a static variable that signals that
the service has entered onDestroy(). Once this flag is set, all method
invocations on sNativeSynth will be dismissed. Note that access to the
native resources used by sNativeSynth are synchronized at the native
layer, therefore preventing sNativeSynth.shutdown() to interfere with
a sNativeSynth.speak() call already underway.
Removed the TTS_ prefix in the TextToSpeech class to follow the standard naming convention.
Moved the TTS-related intents from the Intent class to TextToSpeech and TextToSpeech.Engine.
Renamed the TextToSpeech.Engine constants that are used as extras for the
ACTION_TTS_CHECK_TTS_DATA intent to prefix them with EXTRA_.
Cleaned up the other TextToSpeech.Engine constant to remove superfluous mentions of
"TTS" in the name.
utterances under heavy load was caused by the speech
queue being locked. Switched to using a timeout with
tryLock so that the TTS service does not give up
immediately.
so it can be recreated when the service is initialized.
In the interface with the native synthesizer library, close the lib
in the finalizer, delete the global ref to the SynthProxy java object.
for all current TextToSpeech instances by only caching the language
value so it is used with each subsequent utterance for this instance.
Synchronize calls to the engine around a global mutex since the engine
isn't thread-safe, except for the stop() call which is meant to interrupt
the synthesis loop.
the currently speaking item if that item does not belong to the
app that is trying to do the stop.
Also adds back the functionality of globally stopping speech that
was lost when utterance IDs were added (needed by screen reader).
