| /* |
| * Copyright (C) 2007 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.app.Activity; |
| import android.app.AlertDialog; |
| import android.content.ActivityNotFoundException; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.graphics.Bitmap; |
| import android.net.Uri; |
| import android.net.http.SslCertificate; |
| import android.net.http.SslError; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.SystemClock; |
| import android.provider.Browser; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.widget.EditText; |
| import android.widget.TextView; |
| import com.android.internal.R; |
| |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| /** |
| * This class is a proxy class for handling WebCore -> UI thread messaging. All |
| * the callback functions are called from the WebCore thread and messages are |
| * posted to the UI thread for the actual client callback. |
| */ |
| /* |
| * This class is created in the UI thread so its handler and any private classes |
| * that extend Handler will operate in the UI thread. |
| */ |
| class CallbackProxy extends Handler { |
| // Logging tag |
| private static final String LOGTAG = "CallbackProxy"; |
| // Instance of WebViewClient that is the client callback. |
| private volatile WebViewClient mWebViewClient; |
| // Instance of WebChromeClient for handling all chrome functions. |
| private volatile WebChromeClient mWebChromeClient; |
| // Instance of WebViewClassic for handling UI requests. |
| private final WebViewClassic mWebView; |
| // Client registered callback listener for download events |
| private volatile DownloadListener mDownloadListener; |
| // Keep track of multiple progress updates. |
| private boolean mProgressUpdatePending; |
| // Keep track of the last progress amount. |
| // Start with 100 to indicate it is not in load for the empty page. |
| private volatile int mLatestProgress = 100; |
| // Back/Forward list |
| private final WebBackForwardListClassic mBackForwardList; |
| // Back/Forward list client |
| private volatile WebBackForwardListClient mWebBackForwardListClient; |
| // Used to call startActivity during url override. |
| private final Context mContext; |
| // block messages flag for destroy |
| private boolean mBlockMessages; |
| |
| // Message IDs |
| private static final int PAGE_STARTED = 100; |
| private static final int RECEIVED_ICON = 101; |
| private static final int RECEIVED_TITLE = 102; |
| private static final int OVERRIDE_URL = 103; |
| private static final int AUTH_REQUEST = 104; |
| private static final int SSL_ERROR = 105; |
| private static final int PROGRESS = 106; |
| private static final int UPDATE_VISITED = 107; |
| private static final int LOAD_RESOURCE = 108; |
| private static final int CREATE_WINDOW = 109; |
| private static final int CLOSE_WINDOW = 110; |
| private static final int SAVE_PASSWORD = 111; |
| private static final int JS_ALERT = 112; |
| private static final int JS_CONFIRM = 113; |
| private static final int JS_PROMPT = 114; |
| private static final int JS_UNLOAD = 115; |
| private static final int ASYNC_KEYEVENTS = 116; |
| private static final int DOWNLOAD_FILE = 118; |
| private static final int REPORT_ERROR = 119; |
| private static final int RESEND_POST_DATA = 120; |
| private static final int PAGE_FINISHED = 121; |
| private static final int REQUEST_FOCUS = 122; |
| private static final int SCALE_CHANGED = 123; |
| private static final int RECEIVED_CERTIFICATE = 124; |
| private static final int SWITCH_OUT_HISTORY = 125; |
| private static final int EXCEEDED_DATABASE_QUOTA = 126; |
| private static final int REACHED_APPCACHE_MAXSIZE = 127; |
| private static final int JS_TIMEOUT = 128; |
| private static final int ADD_MESSAGE_TO_CONSOLE = 129; |
| private static final int GEOLOCATION_PERMISSIONS_SHOW_PROMPT = 130; |
| private static final int GEOLOCATION_PERMISSIONS_HIDE_PROMPT = 131; |
| private static final int RECEIVED_TOUCH_ICON_URL = 132; |
| private static final int GET_VISITED_HISTORY = 133; |
| private static final int OPEN_FILE_CHOOSER = 134; |
| private static final int ADD_HISTORY_ITEM = 135; |
| private static final int HISTORY_INDEX_CHANGED = 136; |
| private static final int AUTH_CREDENTIALS = 137; |
| private static final int AUTO_LOGIN = 140; |
| private static final int CLIENT_CERT_REQUEST = 141; |
| private static final int PROCEEDED_AFTER_SSL_ERROR = 144; |
| |
| // Message triggered by the client to resume execution |
| private static final int NOTIFY = 200; |
| |
| // Result transportation object for returning results across thread |
| // boundaries. |
| private static class ResultTransport<E> { |
| // Private result object |
| private E mResult; |
| |
| public ResultTransport(E defaultResult) { |
| mResult = defaultResult; |
| } |
| |
| public synchronized void setResult(E result) { |
| mResult = result; |
| } |
| |
| public synchronized E getResult() { |
| return mResult; |
| } |
| } |
| |
| private class JsResultReceiver implements JsResult.ResultReceiver { |
| // This prevents a user from interacting with the result before WebCore is |
| // ready to handle it. |
| private boolean mReady; |
| // Tells us if the user tried to confirm or cancel the result before WebCore |
| // is ready. |
| private boolean mTriedToNotifyBeforeReady; |
| |
| public JsPromptResult mJsResult = new JsPromptResult(this); |
| |
| final void setReady() { |
| mReady = true; |
| if (mTriedToNotifyBeforeReady) { |
| notifyCallbackProxy(); |
| } |
| } |
| |
| /* Wake up the WebCore thread. */ |
| @Override |
| public void onJsResultComplete(JsResult result) { |
| if (mReady) { |
| notifyCallbackProxy(); |
| } else { |
| mTriedToNotifyBeforeReady = true; |
| } |
| } |
| |
| private void notifyCallbackProxy() { |
| synchronized (CallbackProxy.this) { |
| CallbackProxy.this.notify(); |
| } |
| } |
| } |
| |
| /** |
| * Construct a new CallbackProxy. |
| */ |
| public CallbackProxy(Context context, WebViewClassic w) { |
| // Used to start a default activity. |
| mContext = context; |
| mWebView = w; |
| mBackForwardList = new WebBackForwardListClassic(this); |
| } |
| |
| protected synchronized void blockMessages() { |
| mBlockMessages = true; |
| } |
| |
| protected synchronized boolean messagesBlocked() { |
| return mBlockMessages; |
| } |
| |
| protected void shutdown() { |
| removeCallbacksAndMessages(null); |
| setWebViewClient(null); |
| setWebChromeClient(null); |
| } |
| |
| /** |
| * Set the WebViewClient. |
| * @param client An implementation of WebViewClient. |
| */ |
| public void setWebViewClient(WebViewClient client) { |
| mWebViewClient = client; |
| } |
| |
| /** |
| * Get the WebViewClient. |
| * @return the current WebViewClient instance. |
| */ |
| public WebViewClient getWebViewClient() { |
| return mWebViewClient; |
| } |
| |
| /** |
| * Set the WebChromeClient. |
| * @param client An implementation of WebChromeClient. |
| */ |
| public void setWebChromeClient(WebChromeClient client) { |
| mWebChromeClient = client; |
| } |
| |
| /** |
| * Get the WebChromeClient. |
| * @return the current WebChromeClient instance. |
| */ |
| public WebChromeClient getWebChromeClient() { |
| return mWebChromeClient; |
| } |
| |
| /** |
| * Set the client DownloadListener. |
| * @param client An implementation of DownloadListener. |
| */ |
| public void setDownloadListener(DownloadListener client) { |
| mDownloadListener = client; |
| } |
| |
| /** |
| * Get the Back/Forward list to return to the user or to update the cached |
| * history list. |
| */ |
| public WebBackForwardListClassic getBackForwardList() { |
| return mBackForwardList; |
| } |
| |
| void setWebBackForwardListClient(WebBackForwardListClient client) { |
| mWebBackForwardListClient = client; |
| } |
| |
| WebBackForwardListClient getWebBackForwardListClient() { |
| return mWebBackForwardListClient; |
| } |
| |
| /** |
| * Called by the UI side. Calling overrideUrlLoading from the WebCore |
| * side will post a message to call this method. |
| */ |
| public boolean uiOverrideUrlLoading(String overrideUrl) { |
| if (overrideUrl == null || overrideUrl.length() == 0) { |
| return false; |
| } |
| boolean override = false; |
| if (mWebViewClient != null) { |
| override = mWebViewClient.shouldOverrideUrlLoading(mWebView.getWebView(), |
| overrideUrl); |
| } else { |
| Intent intent = new Intent(Intent.ACTION_VIEW, |
| Uri.parse(overrideUrl)); |
| intent.addCategory(Intent.CATEGORY_BROWSABLE); |
| // If another application is running a WebView and launches the |
| // Browser through this Intent, we want to reuse the same window if |
| // possible. |
| intent.putExtra(Browser.EXTRA_APPLICATION_ID, |
| mContext.getPackageName()); |
| try { |
| mContext.startActivity(intent); |
| override = true; |
| } catch (ActivityNotFoundException ex) { |
| // If no application can handle the URL, assume that the |
| // browser can handle it. |
| } |
| } |
| return override; |
| } |
| |
| /** |
| * Called by UI side. |
| */ |
| public boolean uiOverrideKeyEvent(KeyEvent event) { |
| if (mWebViewClient != null) { |
| return mWebViewClient.shouldOverrideKeyEvent(mWebView.getWebView(), event); |
| } |
| return false; |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| // We don't have to do synchronization because this function operates |
| // in the UI thread. The WebViewClient and WebChromeClient functions |
| // that check for a non-null callback are ok because java ensures atomic |
| // 32-bit reads and writes. |
| if (messagesBlocked()) return; |
| switch (msg.what) { |
| case PAGE_STARTED: |
| String startedUrl = msg.getData().getString("url"); |
| mWebView.onPageStarted(startedUrl); |
| if (mWebViewClient != null) { |
| mWebViewClient.onPageStarted(mWebView.getWebView(), startedUrl, |
| (Bitmap) msg.obj); |
| } |
| break; |
| |
| case PAGE_FINISHED: |
| String finishedUrl = (String) msg.obj; |
| mWebView.onPageFinished(finishedUrl); |
| if (mWebViewClient != null) { |
| mWebViewClient.onPageFinished(mWebView.getWebView(), finishedUrl); |
| } |
| break; |
| |
| case RECEIVED_ICON: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onReceivedIcon(mWebView.getWebView(), (Bitmap) msg.obj); |
| } |
| break; |
| |
| case RECEIVED_TOUCH_ICON_URL: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onReceivedTouchIconUrl(mWebView.getWebView(), |
| (String) msg.obj, msg.arg1 == 1); |
| } |
| break; |
| |
| case RECEIVED_TITLE: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onReceivedTitle(mWebView.getWebView(), |
| (String) msg.obj); |
| } |
| break; |
| |
| case REPORT_ERROR: |
| if (mWebViewClient != null) { |
| int reasonCode = msg.arg1; |
| final String description = msg.getData().getString("description"); |
| final String failUrl = msg.getData().getString("failingUrl"); |
| mWebViewClient.onReceivedError(mWebView.getWebView(), reasonCode, |
| description, failUrl); |
| } |
| break; |
| |
| case RESEND_POST_DATA: |
| Message resend = |
| (Message) msg.getData().getParcelable("resend"); |
| Message dontResend = |
| (Message) msg.getData().getParcelable("dontResend"); |
| if (mWebViewClient != null) { |
| mWebViewClient.onFormResubmission(mWebView.getWebView(), dontResend, |
| resend); |
| } else { |
| dontResend.sendToTarget(); |
| } |
| break; |
| |
| case OVERRIDE_URL: |
| String overrideUrl = msg.getData().getString("url"); |
| boolean override = uiOverrideUrlLoading(overrideUrl); |
| ResultTransport<Boolean> result = |
| (ResultTransport<Boolean>) msg.obj; |
| synchronized (this) { |
| result.setResult(override); |
| notify(); |
| } |
| break; |
| |
| case AUTH_REQUEST: |
| if (mWebViewClient != null) { |
| HttpAuthHandler handler = (HttpAuthHandler) msg.obj; |
| String host = msg.getData().getString("host"); |
| String realm = msg.getData().getString("realm"); |
| mWebViewClient.onReceivedHttpAuthRequest(mWebView.getWebView(), handler, |
| host, realm); |
| } |
| break; |
| |
| case SSL_ERROR: |
| if (mWebViewClient != null) { |
| HashMap<String, Object> map = |
| (HashMap<String, Object>) msg.obj; |
| mWebViewClient.onReceivedSslError(mWebView.getWebView(), |
| (SslErrorHandler) map.get("handler"), |
| (SslError) map.get("error")); |
| } |
| break; |
| |
| case PROCEEDED_AFTER_SSL_ERROR: |
| if (mWebViewClient != null && mWebViewClient instanceof WebViewClientClassicExt) { |
| ((WebViewClientClassicExt) mWebViewClient).onProceededAfterSslError( |
| mWebView.getWebView(), |
| (SslError) msg.obj); |
| } |
| break; |
| |
| case CLIENT_CERT_REQUEST: |
| if (mWebViewClient != null && mWebViewClient instanceof WebViewClientClassicExt) { |
| HashMap<String, Object> map = (HashMap<String, Object>) msg.obj; |
| ((WebViewClientClassicExt) mWebViewClient).onReceivedClientCertRequest( |
| mWebView.getWebView(), |
| (ClientCertRequestHandler) map.get("handler"), |
| (String) map.get("host_and_port")); |
| } |
| break; |
| |
| case PROGRESS: |
| // Synchronize to ensure mLatestProgress is not modified after |
| // setProgress is called and before mProgressUpdatePending is |
| // changed. |
| synchronized (this) { |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onProgressChanged(mWebView.getWebView(), |
| mLatestProgress); |
| } |
| mProgressUpdatePending = false; |
| } |
| break; |
| |
| case UPDATE_VISITED: |
| if (mWebViewClient != null) { |
| mWebViewClient.doUpdateVisitedHistory(mWebView.getWebView(), |
| (String) msg.obj, msg.arg1 != 0); |
| } |
| break; |
| |
| case LOAD_RESOURCE: |
| if (mWebViewClient != null) { |
| mWebViewClient.onLoadResource(mWebView.getWebView(), (String) msg.obj); |
| } |
| break; |
| |
| case DOWNLOAD_FILE: |
| if (mDownloadListener != null) { |
| String url = msg.getData().getString("url"); |
| String userAgent = msg.getData().getString("userAgent"); |
| String contentDisposition = |
| msg.getData().getString("contentDisposition"); |
| String mimetype = msg.getData().getString("mimetype"); |
| String referer = msg.getData().getString("referer"); |
| Long contentLength = msg.getData().getLong("contentLength"); |
| |
| if (mDownloadListener instanceof BrowserDownloadListener) { |
| ((BrowserDownloadListener) mDownloadListener).onDownloadStart(url, |
| userAgent, contentDisposition, mimetype, referer, contentLength); |
| } else { |
| mDownloadListener.onDownloadStart(url, userAgent, |
| contentDisposition, mimetype, contentLength); |
| } |
| } |
| break; |
| |
| case CREATE_WINDOW: |
| if (mWebChromeClient != null) { |
| if (!mWebChromeClient.onCreateWindow(mWebView.getWebView(), |
| msg.arg1 == 1, msg.arg2 == 1, |
| (Message) msg.obj)) { |
| synchronized (this) { |
| notify(); |
| } |
| } |
| mWebView.dismissZoomControl(); |
| } |
| break; |
| |
| case REQUEST_FOCUS: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onRequestFocus(mWebView.getWebView()); |
| } |
| break; |
| |
| case CLOSE_WINDOW: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onCloseWindow(((WebViewClassic) msg.obj).getWebView()); |
| } |
| break; |
| |
| case SAVE_PASSWORD: |
| Bundle bundle = msg.getData(); |
| String schemePlusHost = bundle.getString("host"); |
| String username = bundle.getString("username"); |
| String password = bundle.getString("password"); |
| // If the client returned false it means that the notify message |
| // will not be sent and we should notify WebCore ourselves. |
| if (!mWebView.onSavePassword(schemePlusHost, username, password, |
| (Message) msg.obj)) { |
| synchronized (this) { |
| notify(); |
| } |
| } |
| break; |
| |
| case ASYNC_KEYEVENTS: |
| if (mWebViewClient != null) { |
| mWebViewClient.onUnhandledKeyEvent(mWebView.getWebView(), |
| (KeyEvent) msg.obj); |
| } |
| break; |
| |
| case EXCEEDED_DATABASE_QUOTA: |
| if (mWebChromeClient != null) { |
| HashMap<String, Object> map = |
| (HashMap<String, Object>) msg.obj; |
| String databaseIdentifier = |
| (String) map.get("databaseIdentifier"); |
| String url = (String) map.get("url"); |
| long quota = |
| ((Long) map.get("quota")).longValue(); |
| long totalQuota = |
| ((Long) map.get("totalQuota")).longValue(); |
| long estimatedDatabaseSize = |
| ((Long) map.get("estimatedDatabaseSize")).longValue(); |
| WebStorage.QuotaUpdater quotaUpdater = |
| (WebStorage.QuotaUpdater) map.get("quotaUpdater"); |
| |
| mWebChromeClient.onExceededDatabaseQuota(url, |
| databaseIdentifier, quota, estimatedDatabaseSize, |
| totalQuota, quotaUpdater); |
| } |
| break; |
| |
| case REACHED_APPCACHE_MAXSIZE: |
| if (mWebChromeClient != null) { |
| HashMap<String, Object> map = |
| (HashMap<String, Object>) msg.obj; |
| long requiredStorage = |
| ((Long) map.get("requiredStorage")).longValue(); |
| long quota = |
| ((Long) map.get("quota")).longValue(); |
| WebStorage.QuotaUpdater quotaUpdater = |
| (WebStorage.QuotaUpdater) map.get("quotaUpdater"); |
| |
| mWebChromeClient.onReachedMaxAppCacheSize(requiredStorage, |
| quota, quotaUpdater); |
| } |
| break; |
| |
| case GEOLOCATION_PERMISSIONS_SHOW_PROMPT: |
| if (mWebChromeClient != null) { |
| HashMap<String, Object> map = |
| (HashMap<String, Object>) msg.obj; |
| String origin = (String) map.get("origin"); |
| GeolocationPermissions.Callback callback = |
| (GeolocationPermissions.Callback) |
| map.get("callback"); |
| mWebChromeClient.onGeolocationPermissionsShowPrompt(origin, |
| callback); |
| } |
| break; |
| |
| case GEOLOCATION_PERMISSIONS_HIDE_PROMPT: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.onGeolocationPermissionsHidePrompt(); |
| } |
| break; |
| |
| case JS_ALERT: |
| if (mWebChromeClient != null) { |
| final JsResultReceiver receiver = (JsResultReceiver) msg.obj; |
| final JsResult res = receiver.mJsResult; |
| String message = msg.getData().getString("message"); |
| String url = msg.getData().getString("url"); |
| if (!mWebChromeClient.onJsAlert(mWebView.getWebView(), url, message, |
| res)) { |
| if (!canShowAlertDialog()) { |
| res.cancel(); |
| receiver.setReady(); |
| break; |
| } |
| new AlertDialog.Builder(mContext) |
| .setTitle(getJsDialogTitle(url)) |
| .setMessage(message) |
| .setPositiveButton(R.string.ok, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int which) { |
| res.confirm(); |
| } |
| }) |
| .setOnCancelListener( |
| new DialogInterface.OnCancelListener() { |
| public void onCancel( |
| DialogInterface dialog) { |
| res.cancel(); |
| } |
| }) |
| .show(); |
| } |
| receiver.setReady(); |
| } |
| break; |
| |
| case JS_CONFIRM: |
| if (mWebChromeClient != null) { |
| final JsResultReceiver receiver = (JsResultReceiver) msg.obj; |
| final JsResult res = receiver.mJsResult; |
| String message = msg.getData().getString("message"); |
| String url = msg.getData().getString("url"); |
| if (!mWebChromeClient.onJsConfirm(mWebView.getWebView(), url, message, |
| res)) { |
| if (!canShowAlertDialog()) { |
| res.cancel(); |
| receiver.setReady(); |
| break; |
| } |
| new AlertDialog.Builder(mContext) |
| .setTitle(getJsDialogTitle(url)) |
| .setMessage(message) |
| .setPositiveButton(R.string.ok, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int which) { |
| res.confirm(); |
| }}) |
| .setNegativeButton(R.string.cancel, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int which) { |
| res.cancel(); |
| }}) |
| .setOnCancelListener( |
| new DialogInterface.OnCancelListener() { |
| public void onCancel( |
| DialogInterface dialog) { |
| res.cancel(); |
| } |
| }) |
| .show(); |
| } |
| // Tell the JsResult that it is ready for client |
| // interaction. |
| receiver.setReady(); |
| } |
| break; |
| |
| case JS_PROMPT: |
| if (mWebChromeClient != null) { |
| final JsResultReceiver receiver = (JsResultReceiver) msg.obj; |
| final JsPromptResult res = receiver.mJsResult; |
| String message = msg.getData().getString("message"); |
| String defaultVal = msg.getData().getString("default"); |
| String url = msg.getData().getString("url"); |
| if (!mWebChromeClient.onJsPrompt(mWebView.getWebView(), url, message, |
| defaultVal, res)) { |
| if (!canShowAlertDialog()) { |
| res.cancel(); |
| receiver.setReady(); |
| break; |
| } |
| final LayoutInflater factory = LayoutInflater |
| .from(mContext); |
| final View view = factory.inflate(R.layout.js_prompt, |
| null); |
| final EditText v = (EditText) view |
| .findViewById(R.id.value); |
| v.setText(defaultVal); |
| ((TextView) view.findViewById(R.id.message)) |
| .setText(message); |
| new AlertDialog.Builder(mContext) |
| .setTitle(getJsDialogTitle(url)) |
| .setView(view) |
| .setPositiveButton(R.string.ok, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int whichButton) { |
| res.confirm(v.getText() |
| .toString()); |
| } |
| }) |
| .setNegativeButton(R.string.cancel, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int whichButton) { |
| res.cancel(); |
| } |
| }) |
| .setOnCancelListener( |
| new DialogInterface.OnCancelListener() { |
| public void onCancel( |
| DialogInterface dialog) { |
| res.cancel(); |
| } |
| }) |
| .show(); |
| } |
| // Tell the JsResult that it is ready for client |
| // interaction. |
| receiver.setReady(); |
| } |
| break; |
| |
| case JS_UNLOAD: |
| if (mWebChromeClient != null) { |
| final JsResultReceiver receiver = (JsResultReceiver) msg.obj; |
| final JsResult res = receiver.mJsResult; |
| String message = msg.getData().getString("message"); |
| String url = msg.getData().getString("url"); |
| if (!mWebChromeClient.onJsBeforeUnload(mWebView.getWebView(), url, |
| message, res)) { |
| if (!canShowAlertDialog()) { |
| res.cancel(); |
| receiver.setReady(); |
| break; |
| } |
| final String m = mContext.getString( |
| R.string.js_dialog_before_unload, message); |
| new AlertDialog.Builder(mContext) |
| .setMessage(m) |
| .setPositiveButton(R.string.ok, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int which) { |
| res.confirm(); |
| } |
| }) |
| .setNegativeButton(R.string.cancel, |
| new DialogInterface.OnClickListener() { |
| public void onClick( |
| DialogInterface dialog, |
| int which) { |
| res.cancel(); |
| } |
| }) |
| .setOnCancelListener( |
| new DialogInterface.OnCancelListener() { |
| @Override |
| public void onCancel( |
| DialogInterface dialog) { |
| res.cancel(); |
| } |
| }) |
| .show(); |
| } |
| receiver.setReady(); |
| } |
| break; |
| |
| case JS_TIMEOUT: |
| if(mWebChromeClient != null) { |
| final JsResultReceiver receiver = (JsResultReceiver) msg.obj; |
| final JsResult res = receiver.mJsResult; |
| if(mWebChromeClient.onJsTimeout()) { |
| res.confirm(); |
| } else { |
| res.cancel(); |
| } |
| receiver.setReady(); |
| } |
| break; |
| |
| case RECEIVED_CERTIFICATE: |
| mWebView.setCertificate((SslCertificate) msg.obj); |
| break; |
| |
| case NOTIFY: |
| synchronized (this) { |
| notify(); |
| } |
| break; |
| |
| case SCALE_CHANGED: |
| if (mWebViewClient != null) { |
| mWebViewClient.onScaleChanged(mWebView.getWebView(), msg.getData() |
| .getFloat("old"), msg.getData().getFloat("new")); |
| } |
| break; |
| |
| case SWITCH_OUT_HISTORY: |
| mWebView.switchOutDrawHistory(); |
| break; |
| |
| case ADD_MESSAGE_TO_CONSOLE: |
| if (mWebChromeClient == null) { |
| break; |
| } |
| String message = msg.getData().getString("message"); |
| String sourceID = msg.getData().getString("sourceID"); |
| int lineNumber = msg.getData().getInt("lineNumber"); |
| int msgLevel = msg.getData().getInt("msgLevel"); |
| int numberOfMessageLevels = ConsoleMessage.MessageLevel.values().length; |
| // Sanity bounds check as we'll index an array with msgLevel |
| if (msgLevel < 0 || msgLevel >= numberOfMessageLevels) { |
| msgLevel = 0; |
| } |
| |
| ConsoleMessage.MessageLevel messageLevel = |
| ConsoleMessage.MessageLevel.values()[msgLevel]; |
| |
| if (!mWebChromeClient.onConsoleMessage(new ConsoleMessage(message, sourceID, |
| lineNumber, messageLevel))) { |
| // If false was returned the user did not provide their own console function so |
| // we should output some default messages to the system log. |
| String logTag = "Web Console"; |
| String logMessage = message + " at " + sourceID + ":" + lineNumber; |
| |
| switch (messageLevel) { |
| case TIP: |
| Log.v(logTag, logMessage); |
| break; |
| case LOG: |
| Log.i(logTag, logMessage); |
| break; |
| case WARNING: |
| Log.w(logTag, logMessage); |
| break; |
| case ERROR: |
| Log.e(logTag, logMessage); |
| break; |
| case DEBUG: |
| Log.d(logTag, logMessage); |
| break; |
| } |
| } |
| |
| break; |
| |
| case GET_VISITED_HISTORY: |
| if (mWebChromeClient != null) { |
| mWebChromeClient.getVisitedHistory((ValueCallback<String[]>)msg.obj); |
| } |
| break; |
| |
| case OPEN_FILE_CHOOSER: |
| if (mWebChromeClient != null) { |
| UploadFileMessageData data = (UploadFileMessageData)msg.obj; |
| mWebChromeClient.openFileChooser(data.getUploadFile(), data.getAcceptType(), |
| data.getCapture()); |
| } |
| break; |
| |
| case ADD_HISTORY_ITEM: |
| if (mWebBackForwardListClient != null) { |
| mWebBackForwardListClient.onNewHistoryItem( |
| (WebHistoryItem) msg.obj); |
| } |
| break; |
| |
| case HISTORY_INDEX_CHANGED: |
| if (mWebBackForwardListClient != null) { |
| mWebBackForwardListClient.onIndexChanged( |
| (WebHistoryItem) msg.obj, msg.arg1); |
| } |
| break; |
| case AUTH_CREDENTIALS: { |
| String host = msg.getData().getString("host"); |
| String realm = msg.getData().getString("realm"); |
| username = msg.getData().getString("username"); |
| password = msg.getData().getString("password"); |
| mWebView.setHttpAuthUsernamePassword( |
| host, realm, username, password); |
| break; |
| } |
| case AUTO_LOGIN: { |
| if (mWebViewClient != null) { |
| String realm = msg.getData().getString("realm"); |
| String account = msg.getData().getString("account"); |
| String args = msg.getData().getString("args"); |
| mWebViewClient.onReceivedLoginRequest(mWebView.getWebView(), realm, |
| account, args); |
| } |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Return the latest progress. |
| */ |
| public int getProgress() { |
| return mLatestProgress; |
| } |
| |
| /** |
| * Called by WebCore side to switch out of history Picture drawing mode |
| */ |
| void switchOutDrawHistory() { |
| sendMessage(obtainMessage(SWITCH_OUT_HISTORY)); |
| } |
| |
| private String getJsDialogTitle(String url) { |
| String title = url; |
| if (URLUtil.isDataUrl(url)) { |
| // For data: urls, we just display 'JavaScript' similar to Safari. |
| title = mContext.getString(R.string.js_dialog_title_default); |
| } else { |
| try { |
| URL aUrl = new URL(url); |
| // For example: "The page at 'http://www.mit.edu' says:" |
| title = mContext.getString(R.string.js_dialog_title, |
| aUrl.getProtocol() + "://" + aUrl.getHost()); |
| } catch (MalformedURLException ex) { |
| // do nothing. just use the url as the title |
| } |
| } |
| return title; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // WebViewClient functions. |
| // NOTE: shouldOverrideKeyEvent is never called from the WebCore thread so |
| // it is not necessary to include it here. |
| //-------------------------------------------------------------------------- |
| |
| // Performance probe |
| private static final boolean PERF_PROBE = false; |
| private long mWebCoreThreadTime; |
| private long mWebCoreIdleTime; |
| |
| /* |
| * If PERF_PROBE is true, this block needs to be added to MessageQueue.java. |
| * startWait() and finishWait() should be called before and after wait(). |
| |
| private WaitCallback mWaitCallback = null; |
| public static interface WaitCallback { |
| void startWait(); |
| void finishWait(); |
| } |
| public final void setWaitCallback(WaitCallback callback) { |
| mWaitCallback = callback; |
| } |
| */ |
| |
| // un-comment this block if PERF_PROBE is true |
| /* |
| private IdleCallback mIdleCallback = new IdleCallback(); |
| |
| private final class IdleCallback implements MessageQueue.WaitCallback { |
| private long mStartTime = 0; |
| |
| public void finishWait() { |
| mWebCoreIdleTime += SystemClock.uptimeMillis() - mStartTime; |
| } |
| |
| public void startWait() { |
| mStartTime = SystemClock.uptimeMillis(); |
| } |
| } |
| */ |
| |
| public void onPageStarted(String url, Bitmap favicon) { |
| // We need to send the message even if no WebViewClient is set, because we need to call |
| // WebView.onPageStarted(). |
| |
| // Performance probe |
| if (PERF_PROBE) { |
| mWebCoreThreadTime = SystemClock.currentThreadTimeMillis(); |
| mWebCoreIdleTime = 0; |
| // un-comment this if PERF_PROBE is true |
| // Looper.myQueue().setWaitCallback(mIdleCallback); |
| } |
| Message msg = obtainMessage(PAGE_STARTED); |
| msg.obj = favicon; |
| msg.getData().putString("url", url); |
| sendMessage(msg); |
| } |
| |
| public void onPageFinished(String url) { |
| // Performance probe |
| if (PERF_PROBE) { |
| // un-comment this if PERF_PROBE is true |
| // Looper.myQueue().setWaitCallback(null); |
| Log.d("WebCore", "WebCore thread used " + |
| (SystemClock.currentThreadTimeMillis() - mWebCoreThreadTime) |
| + " ms and idled " + mWebCoreIdleTime + " ms"); |
| } |
| Message msg = obtainMessage(PAGE_FINISHED, url); |
| sendMessage(msg); |
| } |
| |
| // Because this method is public and because CallbackProxy is mistakenly |
| // party of the public classes, we cannot remove this method. |
| public void onTooManyRedirects(Message cancelMsg, Message continueMsg) { |
| // deprecated. |
| } |
| |
| public void onReceivedError(int errorCode, String description, |
| String failingUrl) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| return; |
| } |
| |
| Message msg = obtainMessage(REPORT_ERROR); |
| msg.arg1 = errorCode; |
| msg.getData().putString("description", description); |
| msg.getData().putString("failingUrl", failingUrl); |
| sendMessage(msg); |
| } |
| |
| public void onFormResubmission(Message dontResend, |
| Message resend) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| dontResend.sendToTarget(); |
| return; |
| } |
| |
| Message msg = obtainMessage(RESEND_POST_DATA); |
| Bundle bundle = msg.getData(); |
| bundle.putParcelable("resend", resend); |
| bundle.putParcelable("dontResend", dontResend); |
| sendMessage(msg); |
| } |
| |
| /** |
| * Called by the WebCore side |
| */ |
| public boolean shouldOverrideUrlLoading(String url) { |
| // We have a default behavior if no client exists so always send the |
| // message. |
| ResultTransport<Boolean> res = new ResultTransport<Boolean>(false); |
| Message msg = obtainMessage(OVERRIDE_URL); |
| msg.getData().putString("url", url); |
| msg.obj = res; |
| sendMessageToUiThreadSync(msg); |
| return res.getResult().booleanValue(); |
| } |
| |
| public void onReceivedHttpAuthRequest(HttpAuthHandler handler, |
| String hostName, String realmName) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| handler.cancel(); |
| return; |
| } |
| Message msg = obtainMessage(AUTH_REQUEST, handler); |
| msg.getData().putString("host", hostName); |
| msg.getData().putString("realm", realmName); |
| sendMessage(msg); |
| } |
| |
| public void onReceivedSslError(SslErrorHandler handler, SslError error) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| handler.cancel(); |
| return; |
| } |
| Message msg = obtainMessage(SSL_ERROR); |
| HashMap<String, Object> map = new HashMap(); |
| map.put("handler", handler); |
| map.put("error", error); |
| msg.obj = map; |
| sendMessage(msg); |
| } |
| |
| public void onProceededAfterSslError(SslError error) { |
| if (mWebViewClient == null || !(mWebViewClient instanceof WebViewClientClassicExt)) { |
| return; |
| } |
| Message msg = obtainMessage(PROCEEDED_AFTER_SSL_ERROR); |
| msg.obj = error; |
| sendMessage(msg); |
| } |
| |
| public void onReceivedClientCertRequest(ClientCertRequestHandler handler, String host_and_port) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null || !(mWebViewClient instanceof WebViewClientClassicExt)) { |
| handler.cancel(); |
| return; |
| } |
| Message msg = obtainMessage(CLIENT_CERT_REQUEST); |
| HashMap<String, Object> map = new HashMap(); |
| map.put("handler", handler); |
| map.put("host_and_port", host_and_port); |
| msg.obj = map; |
| sendMessage(msg); |
| } |
| |
| public void onReceivedCertificate(SslCertificate certificate) { |
| // here, certificate can be null (if the site is not secure) |
| sendMessage(obtainMessage(RECEIVED_CERTIFICATE, certificate)); |
| } |
| |
| public void doUpdateVisitedHistory(String url, boolean isReload) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(UPDATE_VISITED, isReload ? 1 : 0, 0, url)); |
| } |
| |
| WebResourceResponse shouldInterceptRequest(String url) { |
| if (mWebViewClient == null) { |
| return null; |
| } |
| // Note: This method does _not_ send a message. |
| WebResourceResponse r = |
| mWebViewClient.shouldInterceptRequest(mWebView.getWebView(), url); |
| if (r == null) { |
| sendMessage(obtainMessage(LOAD_RESOURCE, url)); |
| } |
| return r; |
| } |
| |
| public void onUnhandledKeyEvent(KeyEvent event) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(ASYNC_KEYEVENTS, event)); |
| } |
| |
| public void onScaleChanged(float oldScale, float newScale) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| return; |
| } |
| Message msg = obtainMessage(SCALE_CHANGED); |
| Bundle bundle = msg.getData(); |
| bundle.putFloat("old", oldScale); |
| bundle.putFloat("new", newScale); |
| sendMessage(msg); |
| } |
| |
| void onReceivedLoginRequest(String realm, String account, String args) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebViewClient == null) { |
| return; |
| } |
| Message msg = obtainMessage(AUTO_LOGIN); |
| Bundle bundle = msg.getData(); |
| bundle.putString("realm", realm); |
| bundle.putString("account", account); |
| bundle.putString("args", args); |
| sendMessage(msg); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // DownloadListener functions. |
| //-------------------------------------------------------------------------- |
| |
| /** |
| * Starts a download if a download listener has been registered, otherwise |
| * return false. |
| */ |
| public boolean onDownloadStart(String url, String userAgent, |
| String contentDisposition, String mimetype, String referer, |
| long contentLength) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mDownloadListener == null) { |
| // Cancel the download if there is no browser client. |
| return false; |
| } |
| |
| Message msg = obtainMessage(DOWNLOAD_FILE); |
| Bundle bundle = msg.getData(); |
| bundle.putString("url", url); |
| bundle.putString("userAgent", userAgent); |
| bundle.putString("mimetype", mimetype); |
| bundle.putString("referer", referer); |
| bundle.putLong("contentLength", contentLength); |
| bundle.putString("contentDisposition", contentDisposition); |
| sendMessage(msg); |
| return true; |
| } |
| |
| |
| //-------------------------------------------------------------------------- |
| // WebView specific functions that do not interact with a client. These |
| // functions just need to operate within the UI thread. |
| //-------------------------------------------------------------------------- |
| |
| public boolean onSavePassword(String schemePlusHost, String username, |
| String password, Message resumeMsg) { |
| // resumeMsg should be null at this point because we want to create it |
| // within the CallbackProxy. |
| if (DebugFlags.CALLBACK_PROXY) { |
| junit.framework.Assert.assertNull(resumeMsg); |
| } |
| resumeMsg = obtainMessage(NOTIFY); |
| |
| Message msg = obtainMessage(SAVE_PASSWORD, resumeMsg); |
| Bundle bundle = msg.getData(); |
| bundle.putString("host", schemePlusHost); |
| bundle.putString("username", username); |
| bundle.putString("password", password); |
| sendMessageToUiThreadSync(msg); |
| // Doesn't matter here |
| return false; |
| } |
| |
| public void onReceivedHttpAuthCredentials(String host, String realm, |
| String username, String password) { |
| Message msg = obtainMessage(AUTH_CREDENTIALS); |
| msg.getData().putString("host", host); |
| msg.getData().putString("realm", realm); |
| msg.getData().putString("username", username); |
| msg.getData().putString("password", password); |
| sendMessage(msg); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // WebChromeClient methods |
| //-------------------------------------------------------------------------- |
| |
| public void onProgressChanged(int newProgress) { |
| // Synchronize so that mLatestProgress is up-to-date. |
| synchronized (this) { |
| // update mLatestProgress even mWebChromeClient is null as |
| // WebView.getProgress() needs it |
| if (mLatestProgress == newProgress) { |
| return; |
| } |
| mLatestProgress = newProgress; |
| if (mWebChromeClient == null) { |
| return; |
| } |
| if (!mProgressUpdatePending) { |
| sendEmptyMessage(PROGRESS); |
| mProgressUpdatePending = true; |
| } |
| } |
| } |
| |
| public BrowserFrame createWindow(boolean dialog, boolean userGesture) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return null; |
| } |
| |
| WebView.WebViewTransport transport = |
| mWebView.getWebView().new WebViewTransport(); |
| final Message msg = obtainMessage(NOTIFY); |
| msg.obj = transport; |
| sendMessageToUiThreadSync(obtainMessage(CREATE_WINDOW, dialog ? 1 : 0, |
| userGesture ? 1 : 0, msg)); |
| WebViewClassic w = WebViewClassic.fromWebView(transport.getWebView()); |
| if (w != null) { |
| WebViewCore core = w.getWebViewCore(); |
| // If WebView.destroy() has been called, core may be null. Skip |
| // initialization in that case and return null. |
| if (core != null) { |
| core.initializeSubwindow(); |
| return core.getBrowserFrame(); |
| } |
| } |
| return null; |
| } |
| |
| public void onRequestFocus() { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| |
| sendEmptyMessage(REQUEST_FOCUS); |
| } |
| |
| public void onCloseWindow(WebViewClassic window) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(CLOSE_WINDOW, window)); |
| } |
| |
| public void onReceivedIcon(Bitmap icon) { |
| // The current item might be null if the icon was already stored in the |
| // database and this is a new WebView. |
| WebHistoryItemClassic i = mBackForwardList.getCurrentItem(); |
| if (i != null) { |
| i.setFavicon(icon); |
| } |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(RECEIVED_ICON, icon)); |
| } |
| |
| /* package */ void onReceivedTouchIconUrl(String url, boolean precomposed) { |
| // We should have a current item but we do not want to crash so check |
| // for null. |
| WebHistoryItemClassic i = mBackForwardList.getCurrentItem(); |
| if (i != null) { |
| i.setTouchIconUrl(url, precomposed); |
| } |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(RECEIVED_TOUCH_ICON_URL, |
| precomposed ? 1 : 0, 0, url)); |
| } |
| |
| public void onReceivedTitle(String title) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| sendMessage(obtainMessage(RECEIVED_TITLE, title)); |
| } |
| |
| public void onJsAlert(String url, String message) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return; |
| } |
| JsResultReceiver result = new JsResultReceiver(); |
| Message alert = obtainMessage(JS_ALERT, result); |
| alert.getData().putString("message", message); |
| alert.getData().putString("url", url); |
| sendMessageToUiThreadSync(alert); |
| } |
| |
| public boolean onJsConfirm(String url, String message) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return false; |
| } |
| JsResultReceiver result = new JsResultReceiver(); |
| Message confirm = obtainMessage(JS_CONFIRM, result); |
| confirm.getData().putString("message", message); |
| confirm.getData().putString("url", url); |
| sendMessageToUiThreadSync(confirm); |
| return result.mJsResult.getResult(); |
| } |
| |
| public String onJsPrompt(String url, String message, String defaultValue) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return null; |
| } |
| JsResultReceiver result = new JsResultReceiver(); |
| Message prompt = obtainMessage(JS_PROMPT, result); |
| prompt.getData().putString("message", message); |
| prompt.getData().putString("default", defaultValue); |
| prompt.getData().putString("url", url); |
| sendMessageToUiThreadSync(prompt); |
| return result.mJsResult.getStringResult(); |
| } |
| |
| public boolean onJsBeforeUnload(String url, String message) { |
| // Do an unsynchronized quick check to avoid posting if no callback has |
| // been set. |
| if (mWebChromeClient == null) { |
| return true; |
| } |
| JsResultReceiver result = new JsResultReceiver(); |
| Message confirm = obtainMessage(JS_UNLOAD, result); |
| confirm.getData().putString("message", message); |
| confirm.getData().putString("url", url); |
| sendMessageToUiThreadSync(confirm); |
| return result.mJsResult.getResult(); |
| } |
| |
| /** |
| * Called by WebViewCore to inform the Java side that the current origin |
| * has overflowed it's database quota. Called in the WebCore thread so |
| * posts a message to the UI thread that will prompt the WebChromeClient |
| * for what to do. On return back to C++ side, the WebCore thread will |
| * sleep pending a new quota value. |
| * @param url The URL that caused the quota overflow. |
| * @param databaseIdentifier The identifier of the database that the |
| * transaction that caused the overflow was running on. |
| * @param quota The current quota the origin is allowed. |
| * @param estimatedDatabaseSize The estimated size of the database. |
| * @param totalQuota is the sum of all origins' quota. |
| * @param quotaUpdater An instance of a class encapsulating a callback |
| * to WebViewCore to run when the decision to allow or deny more |
| * quota has been made. |
| */ |
| public void onExceededDatabaseQuota( |
| String url, String databaseIdentifier, long quota, |
| long estimatedDatabaseSize, long totalQuota, |
| WebStorage.QuotaUpdater quotaUpdater) { |
| if (mWebChromeClient == null) { |
| // Native-side logic prevents the quota being updated to a smaller |
| // value. |
| quotaUpdater.updateQuota(quota); |
| return; |
| } |
| |
| Message exceededQuota = obtainMessage(EXCEEDED_DATABASE_QUOTA); |
| HashMap<String, Object> map = new HashMap(); |
| map.put("databaseIdentifier", databaseIdentifier); |
| map.put("url", url); |
| map.put("quota", quota); |
| map.put("estimatedDatabaseSize", estimatedDatabaseSize); |
| map.put("totalQuota", totalQuota); |
| map.put("quotaUpdater", quotaUpdater); |
| exceededQuota.obj = map; |
| sendMessage(exceededQuota); |
| } |
| |
| /** |
| * Called by WebViewCore to inform the Java side that the appcache has |
| * exceeded its max size. |
| * @param requiredStorage is the amount of storage, in bytes, that would be |
| * needed in order for the last appcache operation to succeed. |
| * @param quota is the current quota (for all origins). |
| * @param quotaUpdater An instance of a class encapsulating a callback |
| * to WebViewCore to run when the decision to allow or deny a bigger |
| * app cache size has been made. |
| */ |
| public void onReachedMaxAppCacheSize(long requiredStorage, |
| long quota, WebStorage.QuotaUpdater quotaUpdater) { |
| if (mWebChromeClient == null) { |
| // Native-side logic prevents the quota being updated to a smaller |
| // value. |
| quotaUpdater.updateQuota(quota); |
| return; |
| } |
| |
| Message msg = obtainMessage(REACHED_APPCACHE_MAXSIZE); |
| HashMap<String, Object> map = new HashMap(); |
| map.put("requiredStorage", requiredStorage); |
| map.put("quota", quota); |
| map.put("quotaUpdater", quotaUpdater); |
| msg.obj = map; |
| sendMessage(msg); |
| } |
| |
| /** |
| * Called by WebViewCore to instruct the browser to display a prompt to ask |
| * the user to set the Geolocation permission state for the given origin. |
| * @param origin The origin requesting Geolocation permsissions. |
| * @param callback The callback to call once a permission state has been |
| * obtained. |
| */ |
| public void onGeolocationPermissionsShowPrompt(String origin, |
| GeolocationPermissions.Callback callback) { |
| if (mWebChromeClient == null) { |
| return; |
| } |
| |
| Message showMessage = |
| obtainMessage(GEOLOCATION_PERMISSIONS_SHOW_PROMPT); |
| HashMap<String, Object> map = new HashMap(); |
| map.put("origin", origin); |
| map.put("callback", callback); |
| showMessage.obj = map; |
| sendMessage(showMessage); |
| } |
| |
| /** |
| * Called by WebViewCore to instruct the browser to hide the Geolocation |
| * permissions prompt. |
| */ |
| public void onGeolocationPermissionsHidePrompt() { |
| if (mWebChromeClient == null) { |
| return; |
| } |
| |
| Message hideMessage = obtainMessage(GEOLOCATION_PERMISSIONS_HIDE_PROMPT); |
| sendMessage(hideMessage); |
| } |
| |
| /** |
| * Called by WebViewCore when we have a message to be added to the JavaScript |
| * error console. Sends a message to the Java side with the details. |
| * @param message The message to add to the console. |
| * @param lineNumber The lineNumber of the source file on which the error |
| * occurred. |
| * @param sourceID The filename of the source file in which the error |
| * occurred. |
| * @param msgLevel The message level, corresponding to the MessageLevel enum in |
| * WebCore/page/Console.h |
| */ |
| public void addMessageToConsole(String message, int lineNumber, String sourceID, int msgLevel) { |
| if (mWebChromeClient == null) { |
| return; |
| } |
| |
| Message msg = obtainMessage(ADD_MESSAGE_TO_CONSOLE); |
| msg.getData().putString("message", message); |
| msg.getData().putString("sourceID", sourceID); |
| msg.getData().putInt("lineNumber", lineNumber); |
| msg.getData().putInt("msgLevel", msgLevel); |
| sendMessage(msg); |
| } |
| |
| public boolean onJsTimeout() { |
| //always interrupt timedout JS by default |
| if (mWebChromeClient == null) { |
| return true; |
| } |
| JsResultReceiver result = new JsResultReceiver(); |
| Message timeout = obtainMessage(JS_TIMEOUT, result); |
| sendMessageToUiThreadSync(timeout); |
| return result.mJsResult.getResult(); |
| } |
| |
| public void getVisitedHistory(ValueCallback<String[]> callback) { |
| if (mWebChromeClient == null) { |
| return; |
| } |
| Message msg = obtainMessage(GET_VISITED_HISTORY); |
| msg.obj = callback; |
| sendMessage(msg); |
| } |
| |
| private static class UploadFileMessageData { |
| private UploadFile mCallback; |
| private String mAcceptType; |
| private String mCapture; |
| |
| public UploadFileMessageData(UploadFile uploadFile, String acceptType, String capture) { |
| mCallback = uploadFile; |
| mAcceptType = acceptType; |
| mCapture = capture; |
| } |
| |
| public UploadFile getUploadFile() { |
| return mCallback; |
| } |
| |
| public String getAcceptType() { |
| return mAcceptType; |
| } |
| |
| public String getCapture() { |
| return mCapture; |
| } |
| } |
| |
| private class UploadFile implements ValueCallback<Uri> { |
| private Uri mValue; |
| public void onReceiveValue(Uri value) { |
| mValue = value; |
| synchronized (CallbackProxy.this) { |
| CallbackProxy.this.notify(); |
| } |
| } |
| public Uri getResult() { |
| return mValue; |
| } |
| } |
| |
| /** |
| * Called by WebViewCore to open a file chooser. |
| */ |
| /* package */ Uri openFileChooser(String acceptType, String capture) { |
| if (mWebChromeClient == null) { |
| return null; |
| } |
| Message myMessage = obtainMessage(OPEN_FILE_CHOOSER); |
| UploadFile uploadFile = new UploadFile(); |
| UploadFileMessageData data = new UploadFileMessageData(uploadFile, acceptType, capture); |
| myMessage.obj = data; |
| sendMessageToUiThreadSync(myMessage); |
| return uploadFile.getResult(); |
| } |
| |
| void onNewHistoryItem(WebHistoryItem item) { |
| if (mWebBackForwardListClient == null) { |
| return; |
| } |
| Message msg = obtainMessage(ADD_HISTORY_ITEM, item); |
| sendMessage(msg); |
| } |
| |
| void onIndexChanged(WebHistoryItem item, int index) { |
| if (mWebBackForwardListClient == null) { |
| return; |
| } |
| Message msg = obtainMessage(HISTORY_INDEX_CHANGED, index, 0, item); |
| sendMessage(msg); |
| } |
| |
| boolean canShowAlertDialog() { |
| // We can only display the alert dialog if mContext is |
| // an Activity context. |
| // FIXME: Should we display dialogs if mContext does |
| // not have the window focus (e.g. if the user is viewing |
| // another Activity when the alert should be displayed? |
| // See bug 3166409 |
| return mContext instanceof Activity; |
| } |
| |
| private synchronized void sendMessageToUiThreadSync(Message msg) { |
| sendMessage(msg); |
| WebCoreThreadWatchdog.pause(); |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| Log.e(LOGTAG, "Caught exception waiting for synchronous UI message to be processed"); |
| Log.e(LOGTAG, Log.getStackTraceString(e)); |
| } |
| WebCoreThreadWatchdog.resume(); |
| } |
| } |
