| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.webkit; |
| |
| import android.content.Context; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.SystemClock; |
| import android.provider.Settings; |
| import android.speech.tts.TextToSpeech; |
| import android.speech.tts.TextToSpeech.Engine; |
| import android.speech.tts.TextToSpeech.OnInitListener; |
| import android.speech.tts.UtteranceProgressListener; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| import android.webkit.WebViewCore.EventHub; |
| |
| import org.apache.http.NameValuePair; |
| import org.apache.http.client.utils.URLEncodedUtils; |
| import org.json.JSONException; |
| import org.json.JSONObject; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| /** |
| * Handles injecting accessibility JavaScript and related JavaScript -> Java |
| * APIs. |
| */ |
| class AccessibilityInjector { |
| private static final String TAG = AccessibilityInjector.class.getSimpleName(); |
| |
| private static boolean DEBUG = false; |
| |
| // The WebViewClassic this injector is responsible for managing. |
| private final WebViewClassic mWebViewClassic; |
| |
| // Cached reference to mWebViewClassic.getContext(), for convenience. |
| private final Context mContext; |
| |
| // Cached reference to mWebViewClassic.getWebView(), for convenience. |
| private final WebView mWebView; |
| |
| // The Java objects that are exposed to JavaScript. |
| private TextToSpeechWrapper mTextToSpeech; |
| private CallbackHandler mCallback; |
| |
| // Lazily loaded helper objects. |
| private AccessibilityManager mAccessibilityManager; |
| private AccessibilityInjectorFallback mAccessibilityInjectorFallback; |
| private JSONObject mAccessibilityJSONObject; |
| |
| // Whether the accessibility script has been injected into the current page. |
| private boolean mAccessibilityScriptInjected; |
| |
| // Constants for determining script injection strategy. |
| private static final int ACCESSIBILITY_SCRIPT_INJECTION_UNDEFINED = -1; |
| private static final int ACCESSIBILITY_SCRIPT_INJECTION_OPTED_OUT = 0; |
| @SuppressWarnings("unused") |
| private static final int ACCESSIBILITY_SCRIPT_INJECTION_PROVIDED = 1; |
| |
| // Alias for TTS API exposed to JavaScript. |
| private static final String ALIAS_TTS_JS_INTERFACE = "accessibility"; |
| |
| // Alias for traversal callback exposed to JavaScript. |
| private static final String ALIAS_TRAVERSAL_JS_INTERFACE = "accessibilityTraversal"; |
| |
| // Template for JavaScript that injects a screen-reader. |
| private static final String ACCESSIBILITY_SCREEN_READER_JAVASCRIPT_TEMPLATE = |
| "javascript:(function() {" + |
| " var chooser = document.createElement('script');" + |
| " chooser.type = 'text/javascript';" + |
| " chooser.src = '%1s';" + |
| " document.getElementsByTagName('head')[0].appendChild(chooser);" + |
| " })();"; |
| |
| // Template for JavaScript that performs AndroidVox actions. |
| private static final String ACCESSIBILITY_ANDROIDVOX_TEMPLATE = |
| "(function() {" + |
| " if ((typeof(cvox) != 'undefined')" + |
| " && (cvox != null)" + |
| " && (typeof(cvox.ChromeVox) != 'undefined')" + |
| " && (cvox.ChromeVox != null)" + |
| " && (typeof(cvox.AndroidVox) != 'undefined')" + |
| " && (cvox.AndroidVox != null)" + |
| " && cvox.ChromeVox.isActive) {" + |
| " return cvox.AndroidVox.performAction('%1s');" + |
| " } else {" + |
| " return false;" + |
| " }" + |
| "})()"; |
| |
| // JS code used to shut down an active AndroidVox instance. |
| private static final String TOGGLE_CVOX_TEMPLATE = |
| "javascript:(function() {" + |
| " if ((typeof(cvox) != 'undefined')" + |
| " && (cvox != null)" + |
| " && (typeof(cvox.ChromeVox) != 'undefined')" + |
| " && (cvox.ChromeVox != null)" + |
| " && (typeof(cvox.ChromeVox.host) != 'undefined')" + |
| " && (cvox.ChromeVox.host != null)) {" + |
| " cvox.ChromeVox.host.activateOrDeactivateChromeVox(%b);" + |
| " }" + |
| "})();"; |
| |
| /** |
| * Creates an instance of the AccessibilityInjector based on |
| * {@code webViewClassic}. |
| * |
| * @param webViewClassic The WebViewClassic that this AccessibilityInjector |
| * manages. |
| */ |
| public AccessibilityInjector(WebViewClassic webViewClassic) { |
| mWebViewClassic = webViewClassic; |
| mWebView = webViewClassic.getWebView(); |
| mContext = webViewClassic.getContext(); |
| mAccessibilityManager = AccessibilityManager.getInstance(mContext); |
| } |
| |
| /** |
| * If JavaScript is enabled, pauses or resumes AndroidVox. |
| * |
| * @param enabled Whether feedback should be enabled. |
| */ |
| public void toggleAccessibilityFeedback(boolean enabled) { |
| if (!isAccessibilityEnabled() || !isJavaScriptEnabled()) { |
| return; |
| } |
| |
| toggleAndroidVox(enabled); |
| |
| if (!enabled && (mTextToSpeech != null)) { |
| mTextToSpeech.stop(); |
| } |
| } |
| |
| /** |
| * Attempts to load scripting interfaces for accessibility. |
| * <p> |
| * This should only be called before a page loads. |
| */ |
| public void addAccessibilityApisIfNecessary() { |
| if (!isAccessibilityEnabled() || !isJavaScriptEnabled()) { |
| return; |
| } |
| |
| addTtsApis(); |
| addCallbackApis(); |
| } |
| |
| /** |
| * Attempts to unload scripting interfaces for accessibility. |
| * <p> |
| * This should only be called before a page loads. |
| */ |
| private void removeAccessibilityApisIfNecessary() { |
| removeTtsApis(); |
| removeCallbackApis(); |
| } |
| |
| /** |
| * Destroys this accessibility injector. |
| */ |
| public void destroy() { |
| if (mTextToSpeech != null) { |
| mTextToSpeech.shutdown(); |
| mTextToSpeech = null; |
| } |
| |
| if (mCallback != null) { |
| mCallback = null; |
| } |
| } |
| |
| private void toggleAndroidVox(boolean state) { |
| if (!mAccessibilityScriptInjected) { |
| return; |
| } |
| |
| final String code = String.format(TOGGLE_CVOX_TEMPLATE, state); |
| mWebView.loadUrl(code); |
| } |
| |
| /** |
| * Initializes an {@link AccessibilityNodeInfo} with the actions and |
| * movement granularity levels supported by this |
| * {@link AccessibilityInjector}. |
| * <p> |
| * If an action identifier is added in this method, this |
| * {@link AccessibilityInjector} should also return {@code true} from |
| * {@link #supportsAccessibilityAction(int)}. |
| * </p> |
| * |
| * @param info The info to initialize. |
| * @see View#onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo) |
| */ |
| public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) { |
| info.setMovementGranularities(AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER |
| | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD |
| | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE |
| | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PARAGRAPH |
| | AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PAGE); |
| info.addAction(AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY); |
| info.addAction(AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY); |
| info.addAction(AccessibilityNodeInfo.ACTION_NEXT_HTML_ELEMENT); |
| info.addAction(AccessibilityNodeInfo.ACTION_PREVIOUS_HTML_ELEMENT); |
| info.addAction(AccessibilityNodeInfo.ACTION_CLICK); |
| info.setClickable(true); |
| } |
| |
| /** |
| * Returns {@code true} if this {@link AccessibilityInjector} should handle |
| * the specified action. |
| * |
| * @param action An accessibility action identifier. |
| * @return {@code true} if this {@link AccessibilityInjector} should handle |
| * the specified action. |
| */ |
| public boolean supportsAccessibilityAction(int action) { |
| switch (action) { |
| case AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY: |
| case AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY: |
| case AccessibilityNodeInfo.ACTION_NEXT_HTML_ELEMENT: |
| case AccessibilityNodeInfo.ACTION_PREVIOUS_HTML_ELEMENT: |
| case AccessibilityNodeInfo.ACTION_CLICK: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Performs the specified accessibility action. |
| * |
| * @param action The identifier of the action to perform. |
| * @param arguments The action arguments, or {@code null} if no arguments. |
| * @return {@code true} if the action was successful. |
| * @see View#performAccessibilityAction(int, Bundle) |
| */ |
| public boolean performAccessibilityAction(int action, Bundle arguments) { |
| if (!isAccessibilityEnabled()) { |
| mAccessibilityScriptInjected = false; |
| toggleFallbackAccessibilityInjector(false); |
| return false; |
| } |
| |
| if (mAccessibilityScriptInjected) { |
| return sendActionToAndroidVox(action, arguments); |
| } |
| |
| if (mAccessibilityInjectorFallback != null) { |
| return mAccessibilityInjectorFallback.performAccessibilityAction(action, arguments); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Attempts to handle key events when accessibility is turned on. |
| * |
| * @param event The key event to handle. |
| * @return {@code true} if the event was handled. |
| */ |
| public boolean handleKeyEventIfNecessary(KeyEvent event) { |
| if (!isAccessibilityEnabled()) { |
| mAccessibilityScriptInjected = false; |
| toggleFallbackAccessibilityInjector(false); |
| return false; |
| } |
| |
| if (mAccessibilityScriptInjected) { |
| // if an accessibility script is injected we delegate to it the key |
| // handling. this script is a screen reader which is a fully fledged |
| // solution for blind users to navigate in and interact with web |
| // pages. |
| if (event.getAction() == KeyEvent.ACTION_UP) { |
| mWebViewClassic.sendBatchableInputMessage(EventHub.KEY_UP, 0, 0, event); |
| } else if (event.getAction() == KeyEvent.ACTION_DOWN) { |
| mWebViewClassic.sendBatchableInputMessage(EventHub.KEY_DOWN, 0, 0, event); |
| } else { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| if (mAccessibilityInjectorFallback != null) { |
| // if an accessibility injector is present (no JavaScript enabled or |
| // the site opts out injecting our JavaScript screen reader) we let |
| // it decide whether to act on and consume the event. |
| return mAccessibilityInjectorFallback.onKeyEvent(event); |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Attempts to handle selection change events when accessibility is using a |
| * non-JavaScript method. |
| * <p> |
| * This must not be called from the main thread. |
| * |
| * @param selection The selection string. |
| * @param token The selection request token. |
| */ |
| public void onSelectionStringChangedWebCoreThread(String selection, int token) { |
| if (mAccessibilityInjectorFallback != null) { |
| mAccessibilityInjectorFallback.onSelectionStringChangedWebCoreThread(selection, token); |
| } |
| } |
| |
| /** |
| * Prepares for injecting accessibility scripts into a new page. |
| * |
| * @param url The URL that will be loaded. |
| */ |
| public void onPageStarted(String url) { |
| mAccessibilityScriptInjected = false; |
| if (DEBUG) { |
| Log.w(TAG, "[" + mWebView.hashCode() + "] Started loading new page"); |
| } |
| addAccessibilityApisIfNecessary(); |
| } |
| |
| /** |
| * Attempts to inject the accessibility script using a {@code <script>} tag. |
| * <p> |
| * This should be called after a page has finished loading. |
| * </p> |
| * |
| * @param url The URL that just finished loading. |
| */ |
| public void onPageFinished(String url) { |
| if (!isAccessibilityEnabled()) { |
| toggleFallbackAccessibilityInjector(false); |
| return; |
| } |
| |
| toggleFallbackAccessibilityInjector(true); |
| |
| if (shouldInjectJavaScript(url)) { |
| // If we're supposed to use the JS screen reader, request a |
| // callback to confirm that CallbackHandler is working. |
| if (DEBUG) { |
| Log.d(TAG, "[" + mWebView.hashCode() + "] Request callback "); |
| } |
| |
| mCallback.requestCallback(mWebView, mInjectScriptRunnable); |
| } |
| } |
| |
| /** |
| * Runnable used to inject the JavaScript-based screen reader if the |
| * {@link CallbackHandler} API was successfully exposed to JavaScript. |
| */ |
| private Runnable mInjectScriptRunnable = new Runnable() { |
| @Override |
| public void run() { |
| if (DEBUG) { |
| Log.d(TAG, "[" + mWebView.hashCode() + "] Received callback"); |
| } |
| |
| injectJavaScript(); |
| } |
| }; |
| |
| /** |
| * Called by {@link #mInjectScriptRunnable} to inject the JavaScript-based |
| * screen reader after confirming that the {@link CallbackHandler} API is |
| * functional. |
| */ |
| private void injectJavaScript() { |
| toggleFallbackAccessibilityInjector(false); |
| |
| if (!mAccessibilityScriptInjected) { |
| mAccessibilityScriptInjected = true; |
| final String injectionUrl = getScreenReaderInjectionUrl(); |
| mWebView.loadUrl(injectionUrl); |
| if (DEBUG) { |
| Log.d(TAG, "[" + mWebView.hashCode() + "] Loading screen reader into WebView"); |
| } |
| } else { |
| if (DEBUG) { |
| Log.w(TAG, "[" + mWebView.hashCode() + "] Attempted to inject screen reader twice"); |
| } |
| } |
| } |
| |
| /** |
| * Adjusts the accessibility injection state to reflect changes in the |
| * JavaScript enabled state. |
| * |
| * @param enabled Whether JavaScript is enabled. |
| */ |
| public void updateJavaScriptEnabled(boolean enabled) { |
| if (enabled) { |
| addAccessibilityApisIfNecessary(); |
| } else { |
| removeAccessibilityApisIfNecessary(); |
| } |
| |
| // We have to reload the page after adding or removing APIs. |
| mWebView.reload(); |
| } |
| |
| /** |
| * Toggles the non-JavaScript method for handling accessibility. |
| * |
| * @param enabled {@code true} to enable the non-JavaScript method, or |
| * {@code false} to disable it. |
| */ |
| private void toggleFallbackAccessibilityInjector(boolean enabled) { |
| if (enabled && (mAccessibilityInjectorFallback == null)) { |
| mAccessibilityInjectorFallback = new AccessibilityInjectorFallback(mWebViewClassic); |
| } else { |
| mAccessibilityInjectorFallback = null; |
| } |
| } |
| |
| /** |
| * Determines whether it's okay to inject JavaScript into a given URL. |
| * |
| * @param url The URL to check. |
| * @return {@code true} if JavaScript should be injected, {@code false} if a |
| * non-JavaScript method should be used. |
| */ |
| private boolean shouldInjectJavaScript(String url) { |
| // Respect the WebView's JavaScript setting. |
| if (!isJavaScriptEnabled()) { |
| return false; |
| } |
| |
| // Allow the page to opt out of Accessibility script injection. |
| if (getAxsUrlParameterValue(url) == ACCESSIBILITY_SCRIPT_INJECTION_OPTED_OUT) { |
| return false; |
| } |
| |
| // The user must explicitly enable Accessibility script injection. |
| if (!isScriptInjectionEnabled()) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| /** |
| * @return {@code true} if the user has explicitly enabled Accessibility |
| * script injection. |
| */ |
| private boolean isScriptInjectionEnabled() { |
| final int injectionSetting = Settings.Secure.getInt( |
| mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_SCRIPT_INJECTION, 0); |
| return (injectionSetting == 1); |
| } |
| |
| /** |
| * Attempts to initialize and add interfaces for TTS, if that hasn't already |
| * been done. |
| */ |
| private void addTtsApis() { |
| if (mTextToSpeech == null) { |
| mTextToSpeech = new TextToSpeechWrapper(mContext); |
| } |
| |
| mWebView.addJavascriptInterface(mTextToSpeech, ALIAS_TTS_JS_INTERFACE); |
| } |
| |
| /** |
| * Attempts to shutdown and remove interfaces for TTS, if that hasn't |
| * already been done. |
| */ |
| private void removeTtsApis() { |
| if (mTextToSpeech != null) { |
| mTextToSpeech.stop(); |
| mTextToSpeech.shutdown(); |
| mTextToSpeech = null; |
| } |
| |
| mWebView.removeJavascriptInterface(ALIAS_TTS_JS_INTERFACE); |
| } |
| |
| private void addCallbackApis() { |
| if (mCallback == null) { |
| mCallback = new CallbackHandler(ALIAS_TRAVERSAL_JS_INTERFACE); |
| } |
| |
| mWebView.addJavascriptInterface(mCallback, ALIAS_TRAVERSAL_JS_INTERFACE); |
| } |
| |
| private void removeCallbackApis() { |
| if (mCallback != null) { |
| mCallback = null; |
| } |
| |
| mWebView.removeJavascriptInterface(ALIAS_TRAVERSAL_JS_INTERFACE); |
| } |
| |
| /** |
| * Returns the script injection preference requested by the URL, or |
| * {@link #ACCESSIBILITY_SCRIPT_INJECTION_UNDEFINED} if the page has no |
| * preference. |
| * |
| * @param url The URL to check. |
| * @return A script injection preference. |
| */ |
| private int getAxsUrlParameterValue(String url) { |
| if (url == null) { |
| return ACCESSIBILITY_SCRIPT_INJECTION_UNDEFINED; |
| } |
| |
| try { |
| final List<NameValuePair> params = URLEncodedUtils.parse(new URI(url), null); |
| |
| for (NameValuePair param : params) { |
| if ("axs".equals(param.getName())) { |
| return verifyInjectionValue(param.getValue()); |
| } |
| } |
| } catch (URISyntaxException e) { |
| // Do nothing. |
| } catch (IllegalArgumentException e) { |
| // Catch badly-formed URLs. |
| } |
| |
| return ACCESSIBILITY_SCRIPT_INJECTION_UNDEFINED; |
| } |
| |
| private int verifyInjectionValue(String value) { |
| try { |
| final int parsed = Integer.parseInt(value); |
| |
| switch (parsed) { |
| case ACCESSIBILITY_SCRIPT_INJECTION_OPTED_OUT: |
| return ACCESSIBILITY_SCRIPT_INJECTION_OPTED_OUT; |
| case ACCESSIBILITY_SCRIPT_INJECTION_PROVIDED: |
| return ACCESSIBILITY_SCRIPT_INJECTION_PROVIDED; |
| } |
| } catch (NumberFormatException e) { |
| // Do nothing. |
| } |
| |
| return ACCESSIBILITY_SCRIPT_INJECTION_UNDEFINED; |
| } |
| |
| /** |
| * @return The URL for injecting the screen reader. |
| */ |
| private String getScreenReaderInjectionUrl() { |
| final String screenReaderUrl = Settings.Secure.getString( |
| mContext.getContentResolver(), Settings.Secure.ACCESSIBILITY_SCREEN_READER_URL); |
| return String.format(ACCESSIBILITY_SCREEN_READER_JAVASCRIPT_TEMPLATE, screenReaderUrl); |
| } |
| |
| /** |
| * @return {@code true} if JavaScript is enabled in the {@link WebView} |
| * settings. |
| */ |
| private boolean isJavaScriptEnabled() { |
| final WebSettings settings = mWebView.getSettings(); |
| if (settings == null) { |
| return false; |
| } |
| |
| return settings.getJavaScriptEnabled(); |
| } |
| |
| /** |
| * @return {@code true} if accessibility is enabled. |
| */ |
| private boolean isAccessibilityEnabled() { |
| return mAccessibilityManager.isEnabled(); |
| } |
| |
| /** |
| * Packs an accessibility action into a JSON object and sends it to AndroidVox. |
| * |
| * @param action The action identifier. |
| * @param arguments The action arguments, if applicable. |
| * @return The result of the action. |
| */ |
| private boolean sendActionToAndroidVox(int action, Bundle arguments) { |
| if (mAccessibilityJSONObject == null) { |
| mAccessibilityJSONObject = new JSONObject(); |
| } else { |
| // Remove all keys from the object. |
| final Iterator<?> keys = mAccessibilityJSONObject.keys(); |
| while (keys.hasNext()) { |
| keys.next(); |
| keys.remove(); |
| } |
| } |
| |
| try { |
| mAccessibilityJSONObject.accumulate("action", action); |
| |
| switch (action) { |
| case AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY: |
| case AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY: |
| if (arguments != null) { |
| final int granularity = arguments.getInt( |
| AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT); |
| mAccessibilityJSONObject.accumulate("granularity", granularity); |
| } |
| break; |
| case AccessibilityNodeInfo.ACTION_NEXT_HTML_ELEMENT: |
| case AccessibilityNodeInfo.ACTION_PREVIOUS_HTML_ELEMENT: |
| if (arguments != null) { |
| final String element = arguments.getString( |
| AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING); |
| mAccessibilityJSONObject.accumulate("element", element); |
| } |
| break; |
| } |
| } catch (JSONException e) { |
| return false; |
| } |
| |
| final String jsonString = mAccessibilityJSONObject.toString(); |
| final String jsCode = String.format(ACCESSIBILITY_ANDROIDVOX_TEMPLATE, jsonString); |
| return mCallback.performAction(mWebView, jsCode); |
| } |
| |
| /** |
| * Used to protect the TextToSpeech class, only exposing the methods we want to expose. |
| */ |
| private static class TextToSpeechWrapper { |
| private static final String WRAP_TAG = TextToSpeechWrapper.class.getSimpleName(); |
| |
| /** Lock used to control access to the TextToSpeech object. */ |
| private final Object mTtsLock = new Object(); |
| |
| private final HashMap<String, String> mTtsParams; |
| private final TextToSpeech mTextToSpeech; |
| |
| /** |
| * Whether this wrapper is ready to speak. If this is {@code true} then |
| * {@link #mShutdown} is guaranteed to be {@code false}. |
| */ |
| private volatile boolean mReady; |
| |
| /** |
| * Whether this wrapper was shut down. If this is {@code true} then |
| * {@link #mReady} is guaranteed to be {@code false}. |
| */ |
| private volatile boolean mShutdown; |
| |
| public TextToSpeechWrapper(Context context) { |
| if (DEBUG) { |
| Log.d(WRAP_TAG, "[" + hashCode() + "] Initializing text-to-speech on thread " |
| + Thread.currentThread().getId() + "..."); |
| } |
| |
| final String pkgName = context.getPackageName(); |
| |
| mReady = false; |
| mShutdown = false; |
| |
| mTtsParams = new HashMap<String, String>(); |
| mTtsParams.put(Engine.KEY_PARAM_UTTERANCE_ID, WRAP_TAG); |
| |
| mTextToSpeech = new TextToSpeech( |
| context, mInitListener, null, pkgName + ".**webview**", true); |
| mTextToSpeech.setOnUtteranceProgressListener(mErrorListener); |
| } |
| |
| @JavascriptInterface |
| @SuppressWarnings("unused") |
| public boolean isSpeaking() { |
| synchronized (mTtsLock) { |
| if (!mReady) { |
| return false; |
| } |
| |
| return mTextToSpeech.isSpeaking(); |
| } |
| } |
| |
| @JavascriptInterface |
| @SuppressWarnings("unused") |
| public int speak(String text, int queueMode, HashMap<String, String> params) { |
| synchronized (mTtsLock) { |
| if (!mReady) { |
| if (DEBUG) { |
| Log.w(WRAP_TAG, "[" + hashCode() + "] Attempted to speak before TTS init"); |
| } |
| return TextToSpeech.ERROR; |
| } else { |
| if (DEBUG) { |
| Log.i(WRAP_TAG, "[" + hashCode() + "] Speak called from JS binder"); |
| } |
| } |
| |
| return mTextToSpeech.speak(text, queueMode, params); |
| } |
| } |
| |
| @JavascriptInterface |
| @SuppressWarnings("unused") |
| public int stop() { |
| synchronized (mTtsLock) { |
| if (!mReady) { |
| if (DEBUG) { |
| Log.w(WRAP_TAG, "[" + hashCode() + "] Attempted to stop before initialize"); |
| } |
| return TextToSpeech.ERROR; |
| } else { |
| if (DEBUG) { |
| Log.i(WRAP_TAG, "[" + hashCode() + "] Stop called from JS binder"); |
| } |
| } |
| |
| return mTextToSpeech.stop(); |
| } |
| } |
| |
| @SuppressWarnings("unused") |
| protected void shutdown() { |
| synchronized (mTtsLock) { |
| if (!mReady) { |
| if (DEBUG) { |
| Log.w(WRAP_TAG, "[" + hashCode() + "] Called shutdown before initialize"); |
| } |
| } else { |
| if (DEBUG) { |
| Log.i(WRAP_TAG, "[" + hashCode() + "] Shutting down text-to-speech from " |
| + "thread " + Thread.currentThread().getId() + "..."); |
| } |
| } |
| mShutdown = true; |
| mReady = false; |
| mTextToSpeech.shutdown(); |
| } |
| } |
| |
| private final OnInitListener mInitListener = new OnInitListener() { |
| @Override |
| public void onInit(int status) { |
| synchronized (mTtsLock) { |
| if (!mShutdown && (status == TextToSpeech.SUCCESS)) { |
| if (DEBUG) { |
| Log.d(WRAP_TAG, "[" + TextToSpeechWrapper.this.hashCode() |
| + "] Initialized successfully"); |
| } |
| mReady = true; |
| } else { |
| if (DEBUG) { |
| Log.w(WRAP_TAG, "[" + TextToSpeechWrapper.this.hashCode() |
| + "] Failed to initialize"); |
| } |
| mReady = false; |
| } |
| } |
| } |
| }; |
| |
| private final UtteranceProgressListener mErrorListener = new UtteranceProgressListener() { |
| @Override |
| public void onStart(String utteranceId) { |
| // Do nothing. |
| } |
| |
| @Override |
| public void onError(String utteranceId) { |
| if (DEBUG) { |
| Log.w(WRAP_TAG, "[" + TextToSpeechWrapper.this.hashCode() |
| + "] Failed to speak utterance"); |
| } |
| } |
| |
| @Override |
| public void onDone(String utteranceId) { |
| // Do nothing. |
| } |
| }; |
| } |
| |
| /** |
| * Exposes result interface to JavaScript. |
| */ |
| private static class CallbackHandler { |
| private static final String JAVASCRIPT_ACTION_TEMPLATE = |
| "javascript:(function() { %s.onResult(%d, %s); })();"; |
| |
| // Time in milliseconds to wait for a result before failing. |
| private static final long RESULT_TIMEOUT = 5000; |
| |
| private final AtomicInteger mResultIdCounter = new AtomicInteger(); |
| private final Object mResultLock = new Object(); |
| private final String mInterfaceName; |
| private final Handler mMainHandler; |
| |
| private Runnable mCallbackRunnable; |
| |
| private boolean mResult = false; |
| private int mResultId = -1; |
| |
| private CallbackHandler(String interfaceName) { |
| mInterfaceName = interfaceName; |
| mMainHandler = new Handler(); |
| } |
| |
| /** |
| * Performs an action and attempts to wait for a result. |
| * |
| * @param webView The WebView to perform the action on. |
| * @param code JavaScript code that evaluates to a result. |
| * @return The result of the action, or false if it timed out. |
| */ |
| private boolean performAction(WebView webView, String code) { |
| final int resultId = mResultIdCounter.getAndIncrement(); |
| final String url = String.format( |
| JAVASCRIPT_ACTION_TEMPLATE, mInterfaceName, resultId, code); |
| webView.loadUrl(url); |
| |
| return getResultAndClear(resultId); |
| } |
| |
| /** |
| * Gets the result of a request to perform an accessibility action. |
| * |
| * @param resultId The result id to match the result with the request. |
| * @return The result of the request. |
| */ |
| private boolean getResultAndClear(int resultId) { |
| synchronized (mResultLock) { |
| final boolean success = waitForResultTimedLocked(resultId); |
| final boolean result = success ? mResult : false; |
| clearResultLocked(); |
| return result; |
| } |
| } |
| |
| /** |
| * Clears the result state. |
| */ |
| private void clearResultLocked() { |
| mResultId = -1; |
| mResult = false; |
| } |
| |
| /** |
| * Waits up to a given bound for a result of a request and returns it. |
| * |
| * @param resultId The result id to match the result with the request. |
| * @return Whether the result was received. |
| */ |
| private boolean waitForResultTimedLocked(int resultId) { |
| final long startTimeMillis = SystemClock.uptimeMillis(); |
| |
| if (DEBUG) { |
| Log.d(TAG, "Waiting for CVOX result with ID " + resultId + "..."); |
| } |
| |
| while (true) { |
| // Fail if we received a callback from the future. |
| if (mResultId > resultId) { |
| if (DEBUG) { |
| Log.w(TAG, "Aborted CVOX result"); |
| } |
| return false; |
| } |
| |
| final long elapsedTimeMillis = (SystemClock.uptimeMillis() - startTimeMillis); |
| |
| // Succeed if we received the callback we were expecting. |
| if (DEBUG) { |
| Log.w(TAG, "Check " + mResultId + " versus expected " + resultId); |
| } |
| if (mResultId == resultId) { |
| if (DEBUG) { |
| Log.w(TAG, "Received CVOX result after " + elapsedTimeMillis + " ms"); |
| } |
| return true; |
| } |
| |
| final long waitTimeMillis = (RESULT_TIMEOUT - elapsedTimeMillis); |
| |
| // Fail if we've already exceeded the timeout. |
| if (waitTimeMillis <= 0) { |
| if (DEBUG) { |
| Log.w(TAG, "Timed out while waiting for CVOX result"); |
| } |
| return false; |
| } |
| |
| try { |
| if (DEBUG) { |
| Log.w(TAG, "Start waiting..."); |
| } |
| mResultLock.wait(waitTimeMillis); |
| } catch (InterruptedException ie) { |
| if (DEBUG) { |
| Log.w(TAG, "Interrupted while waiting for CVOX result"); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Callback exposed to JavaScript. Handles returning the result of a |
| * request to a waiting (or potentially timed out) thread. |
| * |
| * @param id The result id of the request as a {@link String}. |
| * @param result The result of the request as a {@link String}. |
| */ |
| @JavascriptInterface |
| @SuppressWarnings("unused") |
| public void onResult(String id, String result) { |
| if (DEBUG) { |
| Log.w(TAG, "Saw CVOX result of '" + result + "' for ID " + id); |
| } |
| final int resultId; |
| |
| try { |
| resultId = Integer.parseInt(id); |
| } catch (NumberFormatException e) { |
| return; |
| } |
| |
| synchronized (mResultLock) { |
| if (resultId > mResultId) { |
| mResult = Boolean.parseBoolean(result); |
| mResultId = resultId; |
| } else { |
| if (DEBUG) { |
| Log.w(TAG, "Result with ID " + resultId + " was stale vesus " + mResultId); |
| } |
| } |
| mResultLock.notifyAll(); |
| } |
| } |
| |
| /** |
| * Requests a callback to ensure that the JavaScript interface for this |
| * object has been added successfully. |
| * |
| * @param webView The web view to request a callback from. |
| * @param callbackRunnable Runnable to execute if a callback is received. |
| */ |
| public void requestCallback(WebView webView, Runnable callbackRunnable) { |
| mCallbackRunnable = callbackRunnable; |
| |
| webView.loadUrl("javascript:(function() { " + mInterfaceName + ".callback(); })();"); |
| } |
| |
| @JavascriptInterface |
| @SuppressWarnings("unused") |
| public void callback() { |
| if (mCallbackRunnable != null) { |
| mMainHandler.post(mCallbackRunnable); |
| mCallbackRunnable = null; |
| } |
| } |
| } |
| } |
