Java tutorial
/* * 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; } } } }