Talk To Text App For Android
Stephanie Dejoode
Since I downloaded the new OS a few days ago I notice that my text messages and my phone calls to those with an android are not often going through. It works once in a while, but not often. I am a real estate agent, and this is totally unacceptable to me.
OK my problem was solved by Verizon. Turns out the update through the provisioning out of sink from the phone provider. All they had to do was connect me with level two support, they synchronized my provisioning, and Presto it was fixed.
I fixed the issue by resetting my phone. Settings-general-transfer/reset-reset- reset all settings. The problem is fixed and my backup was only a precaution it was not necessary to wipe my phone clean.
I did iOS 17 update on both iPhone and iPad. Iphone settings still show send as SMS and MMS Messaging, etc., options (on), however, iPad now does not have those options. Group chats sent to groups that have non iPhone users do not go thru on both iPad and iPhone. When I got new phone I had issues due to no SIM on phone and SIM on iPad so I tried those fixes (in addition to many more suggested) with no success.
Sometimes I talk instead of type. I configure speech-to-text software to capture my voice, then just talk. I often end up with a bunch of text to edit. I find talking to be an excellent alternative to typing to capture not yet fully formed ideas.
The best voice recognition tool for Google Docs, Google Voice Typing (Figure A), used to be found only on Android devices. Install the Google Docs app, open a document, and tap the microphone icon located to the left of the space bar on the on-screen keyboard. Then talk. Google Voice Typing turns your speech into text.
Google also includes speech recognition in Chrome OS as an accessibility option (Figure B). To enable it, select the three-line menu, choose Settings, scroll to the bottom of the page, and select Show advanced settings. Look for the Accessibility option to enable the on-screen keyboard. When the keyboard displays, select the microphone displayed above the on-screen keyboard to activate speech recognition.
A third-party Add-on for Google Docs on the web also enables Speech Recognition (Figure C). Unlike the on-screen keyboard, the Add-on works only within a Google Doc; the Chrome OS on-screen keyboard works with all text fields.
To install the Speech Recognition Add-on, open a Google Doc, choose Add-ons, and then select Get add-ons. Next, search for Speech, then choose the + Free button to add it. Every time you want to start voice recognition, go to the Add-ons menu, choose Speech Recognition, and click Start. A sidebar will appear to the right of your document. Choose your language and dialect, select the blue Start button, and then start talking.
I tested the control sentences above on my Toshiba Chromebook 2 with the built-in microphone and then with a Logitech G330 USB headset. I also tested the phrases with both the native Chrome OS speech recognition system and the third-party Google Docs Add-on.
When I used the headset, accuracy improved (Figure E). With the headset, the Chrome OS speech recognition system captured the phrases with 100% accuracy. Google Voice Typing in a Google Doc on a Samsung Galaxy Note 4 for the same phrases also achieved 100% accuracy without a headset.
Thanks for signing up! Keep an eye out for a confirmation email from our team. To ensure any newsletters you subscribed to hit your inbox, make sure to add newsl...@nl.technologyadvice.com to your contacts list.
If you're too busy to talk when someone calls, Bixby can answer the call for you! With the Bixby text call feature on your Galaxy phone, your calls will be answered by Bixby's automated voice. Simply start typing with the keyboard or select a quick response, and Bixby will read your messages to the caller. You can even look back on your conversations if needed.
Before we explain how to use the TTS API itself, let's first review a few aspects of the engine that will be important to your TTS-enabled application. We will then show how to make your Android application talk and how to configure the way it speaks.
The TTS engine that ships with the Android platform supports a number of languages: English, French, German, Italian and Spanish. Also, depending on which side of the Atlantic you are on, American and British accents for English are both supported.
The TTS engine needs to know which language to speak, as a word like "Paris", for example, is pronounced differently in French and English. So the voice and dictionary are language-specific resources that need to be loaded before the engine can start to speak.
Although all Android-powered devices that support the TTS functionality ship with the engine, some devices have limited storage and may lack the language-specific resource files. If a user wants to install those resources, the TTS API enables an application to query the platform for the availability of language files and can initiate their download and installation. So upon creating your activity, a good first step is to check for the presence of the TTS resources with the corresponding intent:
A successful check will be marked by a CHECK_VOICE_DATA_PASS result code, indicating this device is ready to speak, after the creation of our android.speech.tts.TextToSpeech object. If not, we need to let the user know to install the data that's required for the device to become a multi-lingual talking machine! Downloading and installing the data is accomplished by firing off the ACTION_INSTALL_TTS_DATA intent, which will take the user to Android Market, and will let her/him initiate the download. Installation of the data will happen automatically once the download completes. Here is an example of what your implementation of onActivityResult() would look like:
In the constructor of the TextToSpeech instance we pass a reference to the Context to be used (here the current Activity), and to an OnInitListener (here our Activity as well). This listener enables our application to be notified when the Text-To-Speech engine is fully loaded, so we can start configuring it and using it.
At Google I/O, we showed an example of TTS where it was used to speak the result of a translation from and to one of the 5 languages the Android TTS engine currently supports. Loading a language is as simple as calling for instance:
to load and set the language to English, as spoken in the country "US". A locale is the preferred way to specify a language because it accounts for the fact that the same language can vary from one country to another. To query whether a specific Locale is supported, you can use isLanguageAvailable(), which returns the level of support for the given Locale. For instance the calls:
will return TextToSpeech.LANG_AVAILABLE. In the first example, French is supported, but not the given country. And in the second, only the language was specified for the Locale, so that's what the match was made on.
Also note that besides the ACTION_CHECK_TTS_DATA intent to check the availability of the TTS data, you can also use isLanguageAvailable() once you have created your TextToSpeech instance, which will return TextToSpeech.LANG_MISSING_DATA if the required resources are not installed for the queried language.
Making the engine speak an Italian string while the engine is set to the French language will produce some pretty interesting results, but it will not exactly be something your user would understand So try to match the language of your application's content and the language that you loaded in your TextToSpeech instance. Also if you are using Locale.getDefault() to query the current Locale, make sure that at least the default language is supported.
Now that our TextToSpeech instance is properly initialized and configured, we can start to make your application speak. The simplest way to do so is to use the speak() method. Let's iterate on the following example to make a talking alarm clock:
The TTS engine manages a global queue of all the entries to synthesize, which are also known as "utterances". Each TextToSpeech instance can manage its own queue in order to control which utterance will interrupt the current one and which one is simply queued. Here the first speak() request would interrupt whatever was currently being synthesized: the queue is flushed and the new utterance is queued, which places it at the head of the queue. The second utterance is queued and will be played after myText1 has completed.
On Android, each audio stream that is played is associated with one stream type, as defined in android.media.AudioManager. For a talking alarm clock, we would like our text to be played on the AudioManager.STREAM_ALARM stream type so that it respects the alarm settings the user has chosen on the device. The last parameter of the speak() method allows you to pass to the TTS engine optional parameters, specified as key/value pairs in a HashMap. Let's use that mechanism to change the stream type of our utterances:
Note that speak() calls are asynchronous, so they will return well before the text is done being synthesized and played by Android, regardless of the use of QUEUE_FLUSH or QUEUE_ADD. But you might need to know when a particular utterance is done playing. For instance you might want to start playing an annoying music after myText2 has finished synthesizing (remember, we're trying to wake up the user). We will again use an optional parameter, this time to tag our utterance as one we want to identify. We also need to make sure our activity implements the TextToSpeech.OnUtteranceCompletedListener interface:
While the speak() method is used to make Android speak the text right away, there are cases where you would want the result of the synthesis to be recorded in an audio file instead. This would be the case if, for instance, there is text your application will speak often; you could avoid the synthesis CPU-overhead by rendering only once to a file, and then playing back that audio file whenever needed. Just like for speak(), you can use an optional utterance identifier to be notified on the completion of the synthesis to the file:
9d9a05e021