diff options
Diffstat (limited to 'core/java')
314 files changed, 29308 insertions, 10940 deletions
diff --git a/core/java/android/accounts/AbstractAccountAuthenticator.java b/core/java/android/accounts/AbstractAccountAuthenticator.java new file mode 100644 index 0000000..38ae962 --- /dev/null +++ b/core/java/android/accounts/AbstractAccountAuthenticator.java @@ -0,0 +1,266 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.os.Bundle; +import android.os.RemoteException; +import android.os.Binder; +import android.util.Log; +import android.content.pm.PackageManager; +import android.content.Context; +import android.Manifest; + +/** + * Base class for creating AccountAuthenticators. This implements the IAccountAuthenticator + * binder interface and also provides helper libraries to simplify the creation of + * AccountAuthenticators. + */ +public abstract class AbstractAccountAuthenticator { + private final Context mContext; + + public AbstractAccountAuthenticator(Context context) { + mContext = context; + } + + class Transport extends IAccountAuthenticator.Stub { + public void addAccount(IAccountAuthenticatorResponse response, String accountType, + String authTokenType, String[] requiredFeatures, Bundle options) + throws RemoteException { + checkBinderPermission(); + final Bundle result; + try { + result = AbstractAccountAuthenticator.this.addAccount( + new AccountAuthenticatorResponse(response), + accountType, authTokenType, requiredFeatures, options); + } catch (NetworkErrorException e) { + response.onError(Constants.ERROR_CODE_NETWORK_ERROR, e.getMessage()); + return; + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "addAccount not supported"); + return; + } + if (result != null) { + response.onResult(result); + } + } + + public void confirmPassword(IAccountAuthenticatorResponse response, + Account account, String password) throws RemoteException { + checkBinderPermission(); + boolean result; + try { + result = AbstractAccountAuthenticator.this.confirmPassword( + new AccountAuthenticatorResponse(response), + account, password); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "confirmPassword not supported"); + return; + } catch (NetworkErrorException e) { + response.onError(Constants.ERROR_CODE_NETWORK_ERROR, e.getMessage()); + return; + } + Bundle bundle = new Bundle(); + bundle.putBoolean(Constants.BOOLEAN_RESULT_KEY, result); + response.onResult(bundle); + } + + public void confirmCredentials(IAccountAuthenticatorResponse response, + Account account) throws RemoteException { + checkBinderPermission(); + final Bundle result; + try { + result = AbstractAccountAuthenticator.this.confirmCredentials( + new AccountAuthenticatorResponse(response), account); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "confirmCredentials not supported"); + return; + } + if (result != null) { + response.onResult(result); + } + } + + public void getAuthTokenLabel(IAccountAuthenticatorResponse response, + String authTokenType) + throws RemoteException { + checkBinderPermission(); + try { + Bundle result = new Bundle(); + result.putString(Constants.AUTH_TOKEN_LABEL_KEY, + AbstractAccountAuthenticator.this.getAuthTokenLabel(authTokenType)); + response.onResult(result); + } catch (IllegalArgumentException e) { + response.onError(Constants.ERROR_CODE_BAD_ARGUMENTS, + "unknown authTokenType"); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "getAuthTokenTypeLabel not supported"); + } + } + + public void getAuthToken(IAccountAuthenticatorResponse response, + Account account, String authTokenType, Bundle loginOptions) + throws RemoteException { + checkBinderPermission(); + try { + final Bundle result = AbstractAccountAuthenticator.this.getAuthToken( + new AccountAuthenticatorResponse(response), account, + authTokenType, loginOptions); + if (result != null) { + response.onResult(result); + } + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "getAuthToken not supported"); + } catch (NetworkErrorException e) { + response.onError(Constants.ERROR_CODE_NETWORK_ERROR, e.getMessage()); + } + } + + public void updateCredentials(IAccountAuthenticatorResponse response, Account account, + String authTokenType, Bundle loginOptions) throws RemoteException { + checkBinderPermission(); + final Bundle result; + try { + result = AbstractAccountAuthenticator.this.updateCredentials( + new AccountAuthenticatorResponse(response), account, + authTokenType, loginOptions); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "updateCredentials not supported"); + return; + } + if (result != null) { + response.onResult(result); + } + } + + public void editProperties(IAccountAuthenticatorResponse response, + String accountType) throws RemoteException { + checkBinderPermission(); + final Bundle result; + try { + result = AbstractAccountAuthenticator.this.editProperties( + new AccountAuthenticatorResponse(response), accountType); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "editProperties not supported"); + return; + } + if (result != null) { + response.onResult(result); + } + } + + public void hasFeatures(IAccountAuthenticatorResponse response, + Account account, String[] features) throws RemoteException { + checkBinderPermission(); + final Bundle result; + try { + result = AbstractAccountAuthenticator.this.hasFeatures( + new AccountAuthenticatorResponse(response), account, features); + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "hasFeatures not supported"); + return; + } catch (NetworkErrorException e) { + response.onError(Constants.ERROR_CODE_NETWORK_ERROR, e.getMessage()); + return; + } + if (result != null) { + response.onResult(result); + } + } + + public void getAccountRemovalAllowed(IAccountAuthenticatorResponse response, + Account account) throws RemoteException { + checkBinderPermission(); + try { + final Bundle result = AbstractAccountAuthenticator.this.getAccountRemovalAllowed( + new AccountAuthenticatorResponse(response), account); + if (result != null) { + response.onResult(result); + } + } catch (UnsupportedOperationException e) { + response.onError(Constants.ERROR_CODE_UNSUPPORTED_OPERATION, + "getAccountRemovalAllowed not supported"); + return; + } catch (NetworkErrorException e) { + response.onError(Constants.ERROR_CODE_NETWORK_ERROR, e.getMessage()); + return; + } + } + } + + private void checkBinderPermission() { + final int uid = Binder.getCallingUid(); + final String perm = Manifest.permission.ACCOUNT_MANAGER_SERVICE; + if (mContext.checkCallingOrSelfPermission(perm) != PackageManager.PERMISSION_GRANTED) { + throw new SecurityException("caller uid " + uid + " lacks " + perm); + } + } + + Transport mTransport = new Transport(); + + /** + * @return the IAccountAuthenticator binder transport object + */ + public final IAccountAuthenticator getIAccountAuthenticator() + { + return mTransport; + } + + /** + * Returns a Bundle that contains the Intent of the activity that can be used to edit the + * properties. In order to indicate success the activity should call response.setResult() + * with a non-null Bundle. + * @param response used to set the result for the request. If the Constants.INTENT_KEY + * is set in the bundle then this response field is to be used for sending future + * results if and when the Intent is started. + * @param accountType the AccountType whose properties are to be edited. + * @return a Bundle containing the result or the Intent to start to continue the request. + * If this is null then the request is considered to still be active and the result should + * sent later using response. + */ + public abstract Bundle editProperties(AccountAuthenticatorResponse response, + String accountType); + public abstract Bundle addAccount(AccountAuthenticatorResponse response, String accountType, + String authTokenType, String[] requiredFeatures, Bundle options) + throws NetworkErrorException; + /* @deprecated */ + public abstract boolean confirmPassword(AccountAuthenticatorResponse response, + Account account, String password) throws NetworkErrorException; + public abstract Bundle confirmCredentials(AccountAuthenticatorResponse response, + Account account); + public abstract Bundle getAuthToken(AccountAuthenticatorResponse response, + Account account, String authTokenType, Bundle loginOptions) + throws NetworkErrorException; + public abstract String getAuthTokenLabel(String authTokenType); + public abstract Bundle updateCredentials(AccountAuthenticatorResponse response, + Account account, String authTokenType, Bundle loginOptions); + public abstract Bundle hasFeatures(AccountAuthenticatorResponse response, + Account account, String[] features) throws NetworkErrorException; + public Bundle getAccountRemovalAllowed(AccountAuthenticatorResponse response, + Account account) throws NetworkErrorException { + final Bundle result = new Bundle(); + result.putBoolean(Constants.BOOLEAN_RESULT_KEY, true); + return result; + } +} diff --git a/core/java/android/speech/RecognitionResult.aidl b/core/java/android/accounts/Account.aidl index 59e53ab..8752d99 100644 --- a/core/java/android/speech/RecognitionResult.aidl +++ b/core/java/android/accounts/Account.aidl @@ -14,6 +14,6 @@ * limitations under the License. */ -package android.speech; +package android.accounts; -parcelable RecognitionResult; +parcelable Account; diff --git a/core/java/android/accounts/Account.java b/core/java/android/accounts/Account.java new file mode 100644 index 0000000..7b83a30 --- /dev/null +++ b/core/java/android/accounts/Account.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.os.Parcelable; +import android.os.Parcel; +import android.text.TextUtils; + +/** + * Value type that represents an Account in the {@link AccountManager}. This object is + * {@link Parcelable} and also overrides {@link #equals} and {@link #hashCode}, making it + * suitable for use as the key of a {@link java.util.Map} + */ +public class Account implements Parcelable { + public final String name; + public final String type; + + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof Account)) return false; + final Account other = (Account)o; + return name.equals(other.name) && type.equals(other.type); + } + + public int hashCode() { + int result = 17; + result = 31 * result + name.hashCode(); + result = 31 * result + type.hashCode(); + return result; + } + + public Account(String name, String type) { + if (TextUtils.isEmpty(name)) { + throw new IllegalArgumentException("the name must not be empty: " + name); + } + if (TextUtils.isEmpty(type)) { + throw new IllegalArgumentException("the type must not be empty: " + type); + } + this.name = name; + this.type = type; + } + + public Account(Parcel in) { + this.name = in.readString(); + this.type = in.readString(); + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(name); + dest.writeString(type); + } + + public static final Creator<Account> CREATOR = new Creator<Account>() { + public Account createFromParcel(Parcel source) { + return new Account(source); + } + + public Account[] newArray(int size) { + return new Account[size]; + } + }; + + public String toString() { + return "Account {name=" + name + ", type=" + type + "}"; + } +} diff --git a/core/java/android/accounts/AccountAuthenticatorActivity.java b/core/java/android/accounts/AccountAuthenticatorActivity.java new file mode 100644 index 0000000..0319ab9 --- /dev/null +++ b/core/java/android/accounts/AccountAuthenticatorActivity.java @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.app.Activity; +import android.content.Intent; +import android.os.Bundle; + +/** + * Base class for implementing an Activity that is used to help implement an + * AbstractAccountAuthenticator. If the AbstractAccountAuthenticator needs to return an Intent + * that is to be used to launch an Activity that needs to return results to satisfy an + * AbstractAccountAuthenticator request, it should store the AccountAuthenticatorResponse + * inside of the Intent as follows: + * <p> + * intent.putExtra(Constants.ACCOUNT_AUTHENTICATOR_RESPONSE_KEY, response); + * <p> + * The activity that it launches should extend the AccountAuthenticatorActivity. If this + * activity has a result that satisfies the original request it sets it via: + * <p> + * setAccountAuthenticatorResult(result) + * <p> + * This result will be sent as the result of the request when the activity finishes. If this + * is never set or if it is set to null then the request will be canceled when the activity + * finishes. + */ +public class AccountAuthenticatorActivity extends Activity { + private AccountAuthenticatorResponse mAccountAuthenticatorResponse = null; + private Bundle mResultBundle = null; + + /** + * Set the result that is to be sent as the result of the request that caused this + * Activity to be launched. If result is null or this method is never called then + * the request will be canceled. + * @param result this is returned as the result of the AbstractAccountAuthenticator request + */ + public final void setAccountAuthenticatorResult(Bundle result) { + mResultBundle = result; + } + + /** + * Retreives the AccountAuthenticatorResponse from either the intent of the icicle, if the + * icicle is non-zero. + * @param icicle the save instance data of this Activity, may be null + */ + protected void onCreate(Bundle icicle) { + super.onCreate(icicle); + + if (icicle == null) { + Intent intent = getIntent(); + mAccountAuthenticatorResponse = + intent.getParcelableExtra(Constants.ACCOUNT_AUTHENTICATOR_RESPONSE_KEY); + } else { + mAccountAuthenticatorResponse = + icicle.getParcelable(Constants.ACCOUNT_AUTHENTICATOR_RESPONSE_KEY); + } + + if (mAccountAuthenticatorResponse != null) { + mAccountAuthenticatorResponse.onRequestContinued(); + } + } + + /** + * Saves the AccountAuthenticatorResponse in the instance state. + * @param outState where to store any instance data + */ + protected void onSaveInstanceState(Bundle outState) { + outState.putParcelable(Constants.ACCOUNT_AUTHENTICATOR_RESPONSE_KEY, + mAccountAuthenticatorResponse); + super.onSaveInstanceState(outState); + } + + /** + * Sends the result or a Constants.ERROR_CODE_CANCELED error if a result isn't present. + */ + public void finish() { + if (mAccountAuthenticatorResponse != null) { + // send the result bundle back if set, otherwise send an error. + if (mResultBundle != null) { + mAccountAuthenticatorResponse.onResult(mResultBundle); + } else { + mAccountAuthenticatorResponse.onError(Constants.ERROR_CODE_CANCELED, "canceled"); + } + mAccountAuthenticatorResponse = null; + } + super.finish(); + } +} diff --git a/core/java/android/accounts/AccountAuthenticatorCache.java b/core/java/android/accounts/AccountAuthenticatorCache.java new file mode 100644 index 0000000..2f52f40 --- /dev/null +++ b/core/java/android/accounts/AccountAuthenticatorCache.java @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.content.pm.PackageManager; +import android.content.pm.RegisteredServicesCache; +import android.content.res.TypedArray; +import android.content.Context; +import android.util.AttributeSet; + +/** + * A cache of services that export the {@link IAccountAuthenticator} interface. This cache + * is built by interrogating the {@link PackageManager} and is updated as packages are added, + * removed and changed. The authenticators are referred to by their account type and + * are made available via the {@link RegisteredServicesCache#getServiceInfo} method. + * @hide + */ +/* package private */ class AccountAuthenticatorCache + extends RegisteredServicesCache<AuthenticatorDescription> { + private static final String TAG = "Account"; + + public AccountAuthenticatorCache(Context context) { + super(context, Constants.AUTHENTICATOR_INTENT_ACTION, + Constants.AUTHENTICATOR_META_DATA_NAME, Constants.AUTHENTICATOR_ATTRIBUTES_NAME); + } + + public AuthenticatorDescription parseServiceAttributes(String packageName, AttributeSet attrs) { + TypedArray sa = mContext.getResources().obtainAttributes(attrs, + com.android.internal.R.styleable.AccountAuthenticator); + try { + final String accountType = + sa.getString(com.android.internal.R.styleable.AccountAuthenticator_accountType); + final int labelId = sa.getResourceId( + com.android.internal.R.styleable.AccountAuthenticator_label, 0); + final int iconId = sa.getResourceId( + com.android.internal.R.styleable.AccountAuthenticator_icon, 0); + return new AuthenticatorDescription(accountType, packageName, labelId, iconId); + } finally { + sa.recycle(); + } + } +} diff --git a/core/java/android/accounts/AccountAuthenticatorResponse.java b/core/java/android/accounts/AccountAuthenticatorResponse.java new file mode 100644 index 0000000..7198046 --- /dev/null +++ b/core/java/android/accounts/AccountAuthenticatorResponse.java @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.os.Bundle; +import android.os.Parcelable; +import android.os.Parcel; +import android.os.RemoteException; + +/** + * Object that wraps calls to an {@link IAccountAuthenticatorResponse} object. + * TODO: this interface is still in flux + */ +public class AccountAuthenticatorResponse implements Parcelable { + private IAccountAuthenticatorResponse mAccountAuthenticatorResponse; + + public AccountAuthenticatorResponse(IAccountAuthenticatorResponse response) { + mAccountAuthenticatorResponse = response; + } + + public AccountAuthenticatorResponse(Parcel parcel) { + mAccountAuthenticatorResponse = + IAccountAuthenticatorResponse.Stub.asInterface(parcel.readStrongBinder()); + } + + public void onResult(Bundle result) { + try { + mAccountAuthenticatorResponse.onResult(result); + } catch (RemoteException e) { + // this should never happen + } + } + + public void onRequestContinued() { + try { + mAccountAuthenticatorResponse.onRequestContinued(); + } catch (RemoteException e) { + // this should never happen + } + } + + public void onError(int errorCode, String errorMessage) { + try { + mAccountAuthenticatorResponse.onError(errorCode, errorMessage); + } catch (RemoteException e) { + // this should never happen + } + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeStrongBinder(mAccountAuthenticatorResponse.asBinder()); + } + + public static final Creator<AccountAuthenticatorResponse> CREATOR = + new Creator<AccountAuthenticatorResponse>() { + public AccountAuthenticatorResponse createFromParcel(Parcel source) { + return new AccountAuthenticatorResponse(source); + } + + public AccountAuthenticatorResponse[] newArray(int size) { + return new AccountAuthenticatorResponse[size]; + } + }; +} diff --git a/core/java/android/accounts/AccountManager.java b/core/java/android/accounts/AccountManager.java new file mode 100644 index 0000000..9f70534 --- /dev/null +++ b/core/java/android/accounts/AccountManager.java @@ -0,0 +1,855 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.app.Activity; +import android.content.Intent; +import android.content.Context; +import android.content.IntentFilter; +import android.content.BroadcastReceiver; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.RemoteException; +import android.os.Parcelable; + +import java.io.IOException; +import java.util.concurrent.Callable; +import java.util.concurrent.CancellationException; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.FutureTask; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.TimeUnit; +import java.util.HashMap; +import java.util.Map; + +import com.google.android.collect.Maps; + +/** + * A class that helps with interactions with the AccountManagerService. It provides + * methods to allow for account, password, and authtoken management for all accounts on the + * device. Some of these calls are implemented with the help of the corresponding + * {@link IAccountAuthenticator} services. One accesses the {@link AccountManager} by calling: + * AccountManager accountManager = AccountManager.get(context); + * + * <p> + * TODO(fredq) this interface is still in flux + */ +public class AccountManager { + private static final String TAG = "AccountManager"; + + private final Context mContext; + private final IAccountManager mService; + private final Handler mMainHandler; + + /** + * @hide + */ + public AccountManager(Context context, IAccountManager service) { + mContext = context; + mService = service; + mMainHandler = new Handler(mContext.getMainLooper()); + } + + /** + * @hide used for testing only + */ + public AccountManager(Context context, IAccountManager service, Handler handler) { + mContext = context; + mService = service; + mMainHandler = handler; + } + + public static AccountManager get(Context context) { + return (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE); + } + + public String getPassword(final Account account) { + try { + return mService.getPassword(account); + } catch (RemoteException e) { + // will never happen + throw new RuntimeException(e); + } + } + + public String getUserData(final Account account, final String key) { + try { + return mService.getUserData(account, key); + } catch (RemoteException e) { + // will never happen + throw new RuntimeException(e); + } + } + + public AuthenticatorDescription[] getAuthenticatorTypes() { + try { + return mService.getAuthenticatorTypes(); + } catch (RemoteException e) { + // will never happen + throw new RuntimeException(e); + } + } + + public Account[] getAccounts() { + try { + return mService.getAccounts(null); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public Account[] getAccountsByType(String type) { + try { + return mService.getAccounts(type); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public boolean addAccountExplicitly(Account account, String password, Bundle extras) { + try { + return mService.addAccount(account, password, extras); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public AccountManagerFuture<Boolean> removeAccount(final Account account, + AccountManagerCallback<Boolean> callback, Handler handler) { + return new Future2Task<Boolean>(handler, callback) { + public void doWork() throws RemoteException { + mService.removeAccount(mResponse, account); + } + public Boolean bundleToResult(Bundle bundle) throws AuthenticatorException { + if (!bundle.containsKey(Constants.BOOLEAN_RESULT_KEY)) { + throw new AuthenticatorException("no result in response"); + } + return bundle.getBoolean(Constants.BOOLEAN_RESULT_KEY); + } + }.start(); + } + + public void invalidateAuthToken(final String accountType, final String authToken) { + try { + mService.invalidateAuthToken(accountType, authToken); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public String peekAuthToken(final Account account, final String authTokenType) { + try { + return mService.peekAuthToken(account, authTokenType); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public void setPassword(final Account account, final String password) { + try { + mService.setPassword(account, password); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public void clearPassword(final Account account) { + try { + mService.clearPassword(account); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public void setUserData(final Account account, final String key, final String value) { + try { + mService.setUserData(account, key, value); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public void setAuthToken(Account account, final String authTokenType, final String authToken) { + try { + mService.setAuthToken(account, authTokenType, authToken); + } catch (RemoteException e) { + // won't ever happen + throw new RuntimeException(e); + } + } + + public String blockingGetAuthToken(Account account, String authTokenType, + boolean notifyAuthFailure) + throws OperationCanceledException, IOException, AuthenticatorException { + Bundle bundle = getAuthToken(account, authTokenType, notifyAuthFailure, null /* callback */, + null /* handler */).getResult(); + return bundle.getString(Constants.AUTHTOKEN_KEY); + } + + /** + * Request the auth token for this account/authTokenType. If this succeeds then the + * auth token will then be passed to the activity. If this results in an authentication + * failure then a login intent will be returned that can be invoked to prompt the user to + * update their credentials. This login activity will return the auth token to the calling + * activity. If activity is null then the login intent will not be invoked. + * + * @param account the account whose auth token should be retrieved + * @param authTokenType the auth token type that should be retrieved + * @param loginOptions + * @param activity the activity to launch the login intent, if necessary, and to which + */ + public AccountManagerFuture<Bundle> getAuthToken( + final Account account, final String authTokenType, final Bundle loginOptions, + final Activity activity, AccountManagerCallback<Bundle> callback, Handler handler) { + if (activity == null) throw new IllegalArgumentException("activity is null"); + if (authTokenType == null) throw new IllegalArgumentException("authTokenType is null"); + return new AmsTask(activity, handler, callback) { + public void doWork() throws RemoteException { + mService.getAuthToken(mResponse, account, authTokenType, + false /* notifyOnAuthFailure */, true /* expectActivityLaunch */, + loginOptions); + } + }.start(); + } + + public AccountManagerFuture<Bundle> getAuthToken( + final Account account, final String authTokenType, final boolean notifyAuthFailure, + AccountManagerCallback<Bundle> callback, Handler handler) { + if (account == null) throw new IllegalArgumentException("account is null"); + if (authTokenType == null) throw new IllegalArgumentException("authTokenType is null"); + return new AmsTask(null, handler, callback) { + public void doWork() throws RemoteException { + mService.getAuthToken(mResponse, account, authTokenType, + notifyAuthFailure, false /* expectActivityLaunch */, null /* options */); + } + }.start(); + } + + public AccountManagerFuture<Bundle> addAccount(final String accountType, + final String authTokenType, final String[] requiredFeatures, + final Bundle addAccountOptions, + final Activity activity, AccountManagerCallback<Bundle> callback, Handler handler) { + return new AmsTask(activity, handler, callback) { + public void doWork() throws RemoteException { + mService.addAcount(mResponse, accountType, authTokenType, + requiredFeatures, activity != null, addAccountOptions); + } + }.start(); + } + + /** @deprecated use {@link #confirmCredentials} instead */ + public AccountManagerFuture<Boolean> confirmPassword(final Account account, final String password, + AccountManagerCallback<Boolean> callback, Handler handler) { + return new Future2Task<Boolean>(handler, callback) { + public void doWork() throws RemoteException { + mService.confirmPassword(mResponse, account, password); + } + public Boolean bundleToResult(Bundle bundle) throws AuthenticatorException { + if (!bundle.containsKey(Constants.BOOLEAN_RESULT_KEY)) { + throw new AuthenticatorException("no result in response"); + } + return bundle.getBoolean(Constants.BOOLEAN_RESULT_KEY); + } + }.start(); + } + + public AccountManagerFuture<Account[]> getAccountsByTypeAndFeatures( + final String type, final String[] features, + AccountManagerCallback<Account[]> callback, Handler handler) { + if (type == null) throw new IllegalArgumentException("type is null"); + return new Future2Task<Account[]>(handler, callback) { + public void doWork() throws RemoteException { + mService.getAccountsByFeatures(mResponse, type, features); + } + public Account[] bundleToResult(Bundle bundle) throws AuthenticatorException { + if (!bundle.containsKey(Constants.ACCOUNTS_KEY)) { + throw new AuthenticatorException("no result in response"); + } + final Parcelable[] parcelables = bundle.getParcelableArray(Constants.ACCOUNTS_KEY); + Account[] descs = new Account[parcelables.length]; + for (int i = 0; i < parcelables.length; i++) { + descs[i] = (Account) parcelables[i]; + } + return descs; + } + }.start(); + } + + public AccountManagerFuture<Bundle> confirmCredentials(final Account account, final Activity activity, + final AccountManagerCallback<Bundle> callback, + final Handler handler) { + return new AmsTask(activity, handler, callback) { + public void doWork() throws RemoteException { + mService.confirmCredentials(mResponse, account, activity != null); + } + }.start(); + } + + public AccountManagerFuture<Bundle> updateCredentials(final Account account, final String authTokenType, + final Bundle loginOptions, final Activity activity, + final AccountManagerCallback<Bundle> callback, + final Handler handler) { + return new AmsTask(activity, handler, callback) { + public void doWork() throws RemoteException { + mService.updateCredentials(mResponse, account, authTokenType, activity != null, + loginOptions); + } + }.start(); + } + + public AccountManagerFuture<Bundle> editProperties(final String accountType, final Activity activity, + final AccountManagerCallback<Bundle> callback, + final Handler handler) { + return new AmsTask(activity, handler, callback) { + public void doWork() throws RemoteException { + mService.editProperties(mResponse, accountType, activity != null); + } + }.start(); + } + + private void ensureNotOnMainThread() { + final Looper looper = Looper.myLooper(); + if (looper != null && looper == mContext.getMainLooper()) { + // We really want to throw an exception here, but GTalkService exercises this + // path quite a bit and needs some serious rewrite in order to work properly. + //noinspection ThrowableInstanceNeverThrow +// Log.e(TAG, "calling this from your main thread can lead to deadlock and/or ANRs", +// new Exception()); + // TODO(fredq) remove the log and throw this exception when the callers are fixed +// throw new IllegalStateException( +// "calling this from your main thread can lead to deadlock"); + } + } + + private void postToHandler(Handler handler, final AccountManagerCallback<Bundle> callback, + final AccountManagerFuture<Bundle> future) { + handler = handler == null ? mMainHandler : handler; + handler.post(new Runnable() { + public void run() { + callback.run(future); + } + }); + } + + private void postToHandler(Handler handler, final OnAccountsUpdatedListener listener, + final Account[] accounts) { + final Account[] accountsCopy = new Account[accounts.length]; + // send a copy to make sure that one doesn't + // change what another sees + System.arraycopy(accounts, 0, accountsCopy, 0, accountsCopy.length); + handler = (handler == null) ? mMainHandler : handler; + handler.post(new Runnable() { + public void run() { + listener.onAccountsUpdated(accountsCopy); + } + }); + } + + private abstract class AmsTask extends FutureTask<Bundle> implements AccountManagerFuture<Bundle> { + final IAccountManagerResponse mResponse; + final Handler mHandler; + final AccountManagerCallback<Bundle> mCallback; + final Activity mActivity; + public AmsTask(Activity activity, Handler handler, AccountManagerCallback<Bundle> callback) { + super(new Callable<Bundle>() { + public Bundle call() throws Exception { + throw new IllegalStateException("this should never be called"); + } + }); + + mHandler = handler; + mCallback = callback; + mActivity = activity; + mResponse = new Response(); + } + + public final AccountManagerFuture<Bundle> start() { + try { + doWork(); + } catch (RemoteException e) { + setException(e); + } + return this; + } + + public abstract void doWork() throws RemoteException; + + private Bundle internalGetResult(Long timeout, TimeUnit unit) + throws OperationCanceledException, IOException, AuthenticatorException { + ensureNotOnMainThread(); + try { + if (timeout == null) { + return get(); + } else { + return get(timeout, unit); + } + } catch (CancellationException e) { + throw new OperationCanceledException(); + } catch (TimeoutException e) { + // fall through and cancel + } catch (InterruptedException e) { + // fall through and cancel + } catch (ExecutionException e) { + final Throwable cause = e.getCause(); + if (cause instanceof IOException) { + throw (IOException) cause; + } else if (cause instanceof UnsupportedOperationException) { + throw new AuthenticatorException(cause); + } else if (cause instanceof AuthenticatorException) { + throw (AuthenticatorException) cause; + } else if (cause instanceof RuntimeException) { + throw (RuntimeException) cause; + } else if (cause instanceof Error) { + throw (Error) cause; + } else { + throw new IllegalStateException(cause); + } + } finally { + cancel(true /* interrupt if running */); + } + throw new OperationCanceledException(); + } + + public Bundle getResult() + throws OperationCanceledException, IOException, AuthenticatorException { + return internalGetResult(null, null); + } + + public Bundle getResult(long timeout, TimeUnit unit) + throws OperationCanceledException, IOException, AuthenticatorException { + return internalGetResult(timeout, unit); + } + + protected void done() { + if (mCallback != null) { + postToHandler(mHandler, mCallback, this); + } + } + + /** Handles the responses from the AccountManager */ + private class Response extends IAccountManagerResponse.Stub { + public void onResult(Bundle bundle) { + Intent intent = bundle.getParcelable("intent"); + if (intent != null && mActivity != null) { + // since the user provided an Activity we will silently start intents + // that we see + mActivity.startActivity(intent); + // leave the Future running to wait for the real response to this request + } else if (bundle.getBoolean("retry")) { + try { + doWork(); + } catch (RemoteException e) { + // this will only happen if the system process is dead, which means + // we will be dying ourselves + } + } else { + set(bundle); + } + } + + public void onError(int code, String message) { + if (code == Constants.ERROR_CODE_CANCELED) { + // the authenticator indicated that this request was canceled, do so now + cancel(true /* mayInterruptIfRunning */); + return; + } + setException(convertErrorToException(code, message)); + } + } + + } + + private abstract class BaseFutureTask<T> extends FutureTask<T> { + final public IAccountManagerResponse mResponse; + final Handler mHandler; + + public BaseFutureTask(Handler handler) { + super(new Callable<T>() { + public T call() throws Exception { + throw new IllegalStateException("this should never be called"); + } + }); + mHandler = handler; + mResponse = new Response(); + } + + public abstract void doWork() throws RemoteException; + + public abstract T bundleToResult(Bundle bundle) throws AuthenticatorException; + + protected void postRunnableToHandler(Runnable runnable) { + Handler handler = (mHandler == null) ? mMainHandler : mHandler; + handler.post(runnable); + } + + protected void startTask() { + try { + doWork(); + } catch (RemoteException e) { + setException(e); + } + } + + protected class Response extends IAccountManagerResponse.Stub { + public void onResult(Bundle bundle) { + try { + T result = bundleToResult(bundle); + if (result == null) { + return; + } + set(result); + return; + } catch (ClassCastException e) { + // we will set the exception below + } catch (AuthenticatorException e) { + // we will set the exception below + } + onError(Constants.ERROR_CODE_INVALID_RESPONSE, "no result in response"); + } + + public void onError(int code, String message) { + if (code == Constants.ERROR_CODE_CANCELED) { + cancel(true /* mayInterruptIfRunning */); + return; + } + setException(convertErrorToException(code, message)); + } + } + } + + private abstract class Future2Task<T> + extends BaseFutureTask<T> implements AccountManagerFuture<T> { + final AccountManagerCallback<T> mCallback; + public Future2Task(Handler handler, AccountManagerCallback<T> callback) { + super(handler); + mCallback = callback; + } + + protected void done() { + if (mCallback != null) { + postRunnableToHandler(new Runnable() { + public void run() { + mCallback.run(Future2Task.this); + } + }); + } + } + + public Future2Task<T> start() { + startTask(); + return this; + } + + private T internalGetResult(Long timeout, TimeUnit unit) + throws OperationCanceledException, IOException, AuthenticatorException { + ensureNotOnMainThread(); + try { + if (timeout == null) { + return get(); + } else { + return get(timeout, unit); + } + } catch (InterruptedException e) { + // fall through and cancel + } catch (TimeoutException e) { + // fall through and cancel + } catch (CancellationException e) { + // fall through and cancel + } catch (ExecutionException e) { + final Throwable cause = e.getCause(); + if (cause instanceof IOException) { + throw (IOException) cause; + } else if (cause instanceof UnsupportedOperationException) { + throw new AuthenticatorException(cause); + } else if (cause instanceof AuthenticatorException) { + throw (AuthenticatorException) cause; + } else if (cause instanceof RuntimeException) { + throw (RuntimeException) cause; + } else if (cause instanceof Error) { + throw (Error) cause; + } else { + throw new IllegalStateException(cause); + } + } finally { + cancel(true /* interrupt if running */); + } + throw new OperationCanceledException(); + } + + public T getResult() + throws OperationCanceledException, IOException, AuthenticatorException { + return internalGetResult(null, null); + } + + public T getResult(long timeout, TimeUnit unit) + throws OperationCanceledException, IOException, AuthenticatorException { + return internalGetResult(timeout, unit); + } + + } + + private Exception convertErrorToException(int code, String message) { + if (code == Constants.ERROR_CODE_NETWORK_ERROR) { + return new IOException(message); + } + + if (code == Constants.ERROR_CODE_UNSUPPORTED_OPERATION) { + return new UnsupportedOperationException(message); + } + + if (code == Constants.ERROR_CODE_INVALID_RESPONSE) { + return new AuthenticatorException(message); + } + + if (code == Constants.ERROR_CODE_BAD_ARGUMENTS) { + return new IllegalArgumentException(message); + } + + return new AuthenticatorException(message); + } + + private class GetAuthTokenByTypeAndFeaturesTask + extends AmsTask implements AccountManagerCallback<Bundle> { + GetAuthTokenByTypeAndFeaturesTask(final String accountType, final String authTokenType, + final String[] features, Activity activityForPrompting, + final Bundle addAccountOptions, final Bundle loginOptions, + AccountManagerCallback<Bundle> callback, Handler handler) { + super(activityForPrompting, handler, callback); + if (accountType == null) throw new IllegalArgumentException("account type is null"); + mAccountType = accountType; + mAuthTokenType = authTokenType; + mFeatures = features; + mAddAccountOptions = addAccountOptions; + mLoginOptions = loginOptions; + mMyCallback = this; + } + volatile AccountManagerFuture<Bundle> mFuture = null; + final String mAccountType; + final String mAuthTokenType; + final String[] mFeatures; + final Bundle mAddAccountOptions; + final Bundle mLoginOptions; + final AccountManagerCallback<Bundle> mMyCallback; + + public void doWork() throws RemoteException { + getAccountsByTypeAndFeatures(mAccountType, mFeatures, + new AccountManagerCallback<Account[]>() { + public void run(AccountManagerFuture<Account[]> future) { + Account[] accounts; + try { + accounts = future.getResult(); + } catch (OperationCanceledException e) { + setException(e); + return; + } catch (IOException e) { + setException(e); + return; + } catch (AuthenticatorException e) { + setException(e); + return; + } + + if (accounts.length == 0) { + if (mActivity != null) { + // no accounts, add one now. pretend that the user directly + // made this request + mFuture = addAccount(mAccountType, mAuthTokenType, mFeatures, + mAddAccountOptions, mActivity, mMyCallback, mHandler); + } else { + // send result since we can't prompt to add an account + Bundle result = new Bundle(); + result.putString(Constants.ACCOUNT_NAME_KEY, null); + result.putString(Constants.ACCOUNT_TYPE_KEY, null); + result.putString(Constants.AUTHTOKEN_KEY, null); + try { + mResponse.onResult(result); + } catch (RemoteException e) { + // this will never happen + } + // we are done + } + } else if (accounts.length == 1) { + // have a single account, return an authtoken for it + if (mActivity == null) { + mFuture = getAuthToken(accounts[0], mAuthTokenType, + false /* notifyAuthFailure */, mMyCallback, mHandler); + } else { + mFuture = getAuthToken(accounts[0], + mAuthTokenType, mLoginOptions, + mActivity, mMyCallback, mHandler); + } + } else { + if (mActivity != null) { + IAccountManagerResponse chooseResponse = + new IAccountManagerResponse.Stub() { + public void onResult(Bundle value) throws RemoteException { + Account account = new Account( + value.getString(Constants.ACCOUNT_NAME_KEY), + value.getString(Constants.ACCOUNT_TYPE_KEY)); + mFuture = getAuthToken(account, mAuthTokenType, mLoginOptions, + mActivity, mMyCallback, mHandler); + } + + public void onError(int errorCode, String errorMessage) + throws RemoteException { + mResponse.onError(errorCode, errorMessage); + } + }; + // have many accounts, launch the chooser + Intent intent = new Intent(); + intent.setClassName("android", + "android.accounts.ChooseAccountActivity"); + intent.putExtra(Constants.ACCOUNTS_KEY, accounts); + intent.putExtra(Constants.ACCOUNT_MANAGER_RESPONSE_KEY, + new AccountManagerResponse(chooseResponse)); + mActivity.startActivity(intent); + // the result will arrive via the IAccountManagerResponse + } else { + // send result since we can't prompt to select an account + Bundle result = new Bundle(); + result.putString(Constants.ACCOUNTS_KEY, null); + try { + mResponse.onResult(result); + } catch (RemoteException e) { + // this will never happen + } + // we are done + } + } + }}, mHandler); + } + + + + // TODO(fredq) pass through the calls to our implemention of Future2 to the underlying + // future that we create. We need to do things like have cancel cancel the mFuture, if set + // or to cause this to be canceled if mFuture isn't set. + // Once this is done then getAuthTokenByFeatures can be changed to return a Future2. + + public void run(AccountManagerFuture<Bundle> future) { + try { + set(future.get()); + } catch (InterruptedException e) { + cancel(true); + } catch (CancellationException e) { + cancel(true); + } catch (ExecutionException e) { + setException(e.getCause()); + } + } + } + + public void getAuthTokenByFeatures( + final String accountType, final String authTokenType, final String[] features, + final Activity activityForPrompting, final Bundle addAccountOptions, + final Bundle loginOptions, + final AccountManagerCallback<Bundle> callback, final Handler handler) { + if (accountType == null) throw new IllegalArgumentException("account type is null"); + if (authTokenType == null) throw new IllegalArgumentException("authTokenType is null"); + new GetAuthTokenByTypeAndFeaturesTask(accountType, authTokenType, features, + activityForPrompting, addAccountOptions, loginOptions, callback, handler).start(); + } + + private final HashMap<OnAccountsUpdatedListener, Handler> mAccountsUpdatedListeners = + Maps.newHashMap(); + + /** + * BroadcastReceiver that listens for the LOGIN_ACCOUNTS_CHANGED_ACTION intent + * so that it can read the updated list of accounts and send them to the listener + * in mAccountsUpdatedListeners. + */ + private final BroadcastReceiver mAccountsChangedBroadcastReceiver = new BroadcastReceiver() { + public void onReceive(final Context context, final Intent intent) { + final Account[] accounts = getAccounts(); + // send the result to the listeners + synchronized (mAccountsUpdatedListeners) { + for (Map.Entry<OnAccountsUpdatedListener, Handler> entry : + mAccountsUpdatedListeners.entrySet()) { + postToHandler(entry.getValue(), entry.getKey(), accounts); + } + } + } + }; + + /** + * Add a {@link OnAccountsUpdatedListener} to this instance of the {@link AccountManager}. + * The listener is guaranteed to be invoked on the thread of the Handler that is passed + * in or the main thread's Handler if handler is null. + * @param listener the listener to add + * @param handler the Handler whose thread will be used to invoke the listener. If null + * the AccountManager context's main thread will be used. + * @param updateImmediately if true then the listener will be invoked as a result of this + * call. + * @throws IllegalArgumentException if listener is null + * @throws IllegalStateException if listener was already added + */ + public void addOnAccountsUpdatedListener(final OnAccountsUpdatedListener listener, + Handler handler, boolean updateImmediately) { + if (listener == null) { + throw new IllegalArgumentException("the listener is null"); + } + synchronized (mAccountsUpdatedListeners) { + if (mAccountsUpdatedListeners.containsKey(listener)) { + throw new IllegalStateException("this listener is already added"); + } + final boolean wasEmpty = mAccountsUpdatedListeners.isEmpty(); + + mAccountsUpdatedListeners.put(listener, handler); + + if (wasEmpty) { + // Register a broadcast receiver to monitor account changes + IntentFilter intentFilter = new IntentFilter(); + intentFilter.addAction(Constants.LOGIN_ACCOUNTS_CHANGED_ACTION); + mContext.registerReceiver(mAccountsChangedBroadcastReceiver, intentFilter); + } + } + + if (updateImmediately) { + postToHandler(handler, listener, getAccounts()); + } + } + + /** + * Remove an {@link OnAccountsUpdatedListener} that was previously registered with + * {@link #addOnAccountsUpdatedListener}. + * @param listener the listener to remove + * @throws IllegalArgumentException if listener is null + * @throws IllegalStateException if listener was not already added + */ + public void removeOnAccountsUpdatedListener(OnAccountsUpdatedListener listener) { + if (listener == null) { + throw new IllegalArgumentException("the listener is null"); + } + synchronized (mAccountsUpdatedListeners) { + if (mAccountsUpdatedListeners.remove(listener) == null) { + throw new IllegalStateException("this listener was not previously added"); + } + if (mAccountsUpdatedListeners.isEmpty()) { + mContext.unregisterReceiver(mAccountsChangedBroadcastReceiver); + } + } + } +} diff --git a/core/java/android/accounts/AccountManagerCallback.java b/core/java/android/accounts/AccountManagerCallback.java new file mode 100644 index 0000000..4aa7169 --- /dev/null +++ b/core/java/android/accounts/AccountManagerCallback.java @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2009 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.accounts; + +public interface AccountManagerCallback<V> { + void run(AccountManagerFuture<V> future); +}
\ No newline at end of file diff --git a/core/java/android/accounts/AccountManagerFuture.java b/core/java/android/accounts/AccountManagerFuture.java new file mode 100644 index 0000000..9939398 --- /dev/null +++ b/core/java/android/accounts/AccountManagerFuture.java @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2009 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.accounts; + +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeoutException; +import java.io.IOException; + +/** + * An extension of {@link java.util.concurrent.Future} that provides wrappers for {@link #get()} + * that handle the various + * exceptions that {@link #get()} may return and rethrows them as exceptions specific to + * {@link android.accounts.AccountManager}. + */ +public interface AccountManagerFuture<V> extends Future<V> { + /** + * Wrapper for {@link java.util.concurrent.Future#get()}. If the get() throws + * {@link InterruptedException} then the + * {@link AccountManagerFuture} is canceled and + * {@link android.accounts.OperationCanceledException} is thrown. + * @return the {@link android.os.Bundle} that is returned by get() + * @throws android.accounts.OperationCanceledException if get() throws the unchecked + * CancellationException + * or if the Future was interrupted. + */ + V getResult() throws OperationCanceledException, IOException, AuthenticatorException; + + /** + * Wrapper for {@link java.util.concurrent.Future#get()}. If the get() throws + * {@link InterruptedException} then the + * {@link AccountManagerFuture} is canceled and + * {@link android.accounts.OperationCanceledException} is thrown. + * @param timeout the maximum time to wait + * @param unit the time unit of the timeout argument + * @return the {@link android.os.Bundle} that is returned by + * {@link java.util.concurrent.Future#get()} + * @throws android.accounts.OperationCanceledException if get() throws the unchecked + * {@link java.util.concurrent.CancellationException} or if the {@link AccountManagerFuture} + * was interrupted. + */ + V getResult(long timeout, TimeUnit unit) + throws OperationCanceledException, IOException, AuthenticatorException; + + @Deprecated + V get() throws InterruptedException, ExecutionException; + + @Deprecated + V get(long timeout, TimeUnit unit) + throws InterruptedException, ExecutionException, TimeoutException; +}
\ No newline at end of file diff --git a/core/java/android/accounts/AccountManagerResponse.java b/core/java/android/accounts/AccountManagerResponse.java new file mode 100644 index 0000000..25371fd --- /dev/null +++ b/core/java/android/accounts/AccountManagerResponse.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.os.Bundle; +import android.os.Parcel; +import android.os.Parcelable; +import android.os.RemoteException; + +/** + * Object that wraps calls to an {@link android.accounts.IAccountManagerResponse} object. + * @hide + */ +public class AccountManagerResponse implements Parcelable { + private IAccountManagerResponse mResponse; + + public AccountManagerResponse(IAccountManagerResponse response) { + mResponse = response; + } + + public AccountManagerResponse(Parcel parcel) { + mResponse = + IAccountManagerResponse.Stub.asInterface(parcel.readStrongBinder()); + } + + public void onResult(Bundle result) { + try { + mResponse.onResult(result); + } catch (RemoteException e) { + // this should never happen + } + } + + public void onError(int errorCode, String errorMessage) { + try { + mResponse.onError(errorCode, errorMessage); + } catch (RemoteException e) { + // this should never happen + } + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeStrongBinder(mResponse.asBinder()); + } + + public static final Creator<AccountManagerResponse> CREATOR = + new Creator<AccountManagerResponse>() { + public AccountManagerResponse createFromParcel(Parcel source) { + return new AccountManagerResponse(source); + } + + public AccountManagerResponse[] newArray(int size) { + return new AccountManagerResponse[size]; + } + }; +}
\ No newline at end of file diff --git a/core/java/android/accounts/AccountManagerService.java b/core/java/android/accounts/AccountManagerService.java new file mode 100644 index 0000000..140c814 --- /dev/null +++ b/core/java/android/accounts/AccountManagerService.java @@ -0,0 +1,1598 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.content.BroadcastReceiver; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.PackageManager; +import android.content.pm.RegisteredServicesCache; +import android.database.Cursor; +import android.database.DatabaseUtils; +import android.database.sqlite.SQLiteDatabase; +import android.database.sqlite.SQLiteOpenHelper; +import android.os.Bundle; +import android.os.Handler; +import android.os.HandlerThread; +import android.os.IBinder; +import android.os.Looper; +import android.os.Message; +import android.os.RemoteException; +import android.os.SystemClock; +import android.os.Binder; +import android.os.SystemProperties; +import android.telephony.TelephonyManager; +import android.text.TextUtils; +import android.util.Log; +import android.util.Pair; +import android.app.PendingIntent; +import android.app.NotificationManager; +import android.app.Notification; +import android.Manifest; + +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +import java.util.HashMap; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicReference; + +import com.android.internal.telephony.TelephonyIntents; +import com.android.internal.R; + +/** + * A system service that provides account, password, and authtoken management for all + * accounts on the device. Some of these calls are implemented with the help of the corresponding + * {@link IAccountAuthenticator} services. This service is not accessed by users directly, + * instead one uses an instance of {@link AccountManager}, which can be accessed as follows: + * AccountManager accountManager = + * (AccountManager)context.getSystemService(Context.ACCOUNT_SERVICE) + * @hide + */ +public class AccountManagerService extends IAccountManager.Stub { + private static final String TAG = "AccountManagerService"; + + private static final int TIMEOUT_DELAY_MS = 1000 * 60; + private static final String DATABASE_NAME = "accounts.db"; + private static final int DATABASE_VERSION = 3; + + private final Context mContext; + + private HandlerThread mMessageThread; + private final MessageHandler mMessageHandler; + + // Messages that can be sent on mHandler + private static final int MESSAGE_TIMED_OUT = 3; + private static final int MESSAGE_CONNECTED = 7; + private static final int MESSAGE_DISCONNECTED = 8; + + private final AccountAuthenticatorCache mAuthenticatorCache; + private final AuthenticatorBindHelper mBindHelper; + private final DatabaseHelper mOpenHelper; + private final SimWatcher mSimWatcher; + + private static final String TABLE_ACCOUNTS = "accounts"; + private static final String ACCOUNTS_ID = "_id"; + private static final String ACCOUNTS_NAME = "name"; + private static final String ACCOUNTS_TYPE = "type"; + private static final String ACCOUNTS_PASSWORD = "password"; + + private static final String TABLE_AUTHTOKENS = "authtokens"; + private static final String AUTHTOKENS_ID = "_id"; + private static final String AUTHTOKENS_ACCOUNTS_ID = "accounts_id"; + private static final String AUTHTOKENS_TYPE = "type"; + private static final String AUTHTOKENS_AUTHTOKEN = "authtoken"; + + private static final String TABLE_GRANTS = "grants"; + private static final String GRANTS_ACCOUNTS_ID = "accounts_id"; + private static final String GRANTS_AUTH_TOKEN_TYPE = "auth_token_type"; + private static final String GRANTS_GRANTEE_UID = "uid"; + + private static final String TABLE_EXTRAS = "extras"; + private static final String EXTRAS_ID = "_id"; + private static final String EXTRAS_ACCOUNTS_ID = "accounts_id"; + private static final String EXTRAS_KEY = "key"; + private static final String EXTRAS_VALUE = "value"; + + private static final String TABLE_META = "meta"; + private static final String META_KEY = "key"; + private static final String META_VALUE = "value"; + + private static final String[] ACCOUNT_NAME_TYPE_PROJECTION = + new String[]{ACCOUNTS_ID, ACCOUNTS_NAME, ACCOUNTS_TYPE}; + private static final Intent ACCOUNTS_CHANGED_INTENT = + new Intent(Constants.LOGIN_ACCOUNTS_CHANGED_ACTION); + + private static final String COUNT_OF_MATCHING_GRANTS = "" + + "SELECT COUNT(*) FROM " + TABLE_GRANTS + ", " + TABLE_ACCOUNTS + + " WHERE " + GRANTS_ACCOUNTS_ID + "=" + ACCOUNTS_ID + + " AND " + GRANTS_GRANTEE_UID + "=?" + + " AND " + GRANTS_AUTH_TOKEN_TYPE + "=?" + + " AND " + ACCOUNTS_NAME + "=?" + + " AND " + ACCOUNTS_TYPE + "=?"; + + private final LinkedHashMap<String, Session> mSessions = new LinkedHashMap<String, Session>(); + private final AtomicInteger mNotificationIds = new AtomicInteger(1); + + private final HashMap<Pair<Pair<Account, String>, Integer>, Integer> + mCredentialsPermissionNotificationIds = + new HashMap<Pair<Pair<Account, String>, Integer>, Integer>(); + private final HashMap<Account, Integer> mSigninRequiredNotificationIds = + new HashMap<Account, Integer>(); + private static AtomicReference<AccountManagerService> sThis = + new AtomicReference<AccountManagerService>(); + + private static final boolean isDebuggableMonkeyBuild = + SystemProperties.getBoolean("ro.monkey", false) + && SystemProperties.getBoolean("ro.debuggable", false); + /** + * This should only be called by system code. One should only call this after the service + * has started. + * @return a reference to the AccountManagerService instance + * @hide + */ + public static AccountManagerService getSingleton() { + return sThis.get(); + } + + public class AuthTokenKey { + public final Account mAccount; + public final String mAuthTokenType; + private final int mHashCode; + + public AuthTokenKey(Account account, String authTokenType) { + mAccount = account; + mAuthTokenType = authTokenType; + mHashCode = computeHashCode(); + } + + public boolean equals(Object o) { + if (o == this) { + return true; + } + if (!(o instanceof AuthTokenKey)) { + return false; + } + AuthTokenKey other = (AuthTokenKey)o; + if (!mAccount.equals(other.mAccount)) { + return false; + } + return (mAuthTokenType == null) + ? other.mAuthTokenType == null + : mAuthTokenType.equals(other.mAuthTokenType); + } + + private int computeHashCode() { + int result = 17; + result = 31 * result + mAccount.hashCode(); + result = 31 * result + ((mAuthTokenType == null) ? 0 : mAuthTokenType.hashCode()); + return result; + } + + public int hashCode() { + return mHashCode; + } + } + + public AccountManagerService(Context context) { + mContext = context; + + mOpenHelper = new DatabaseHelper(mContext); + + mMessageThread = new HandlerThread("AccountManagerService"); + mMessageThread.start(); + mMessageHandler = new MessageHandler(mMessageThread.getLooper()); + + mAuthenticatorCache = new AccountAuthenticatorCache(mContext); + mBindHelper = new AuthenticatorBindHelper(mContext, mAuthenticatorCache, mMessageHandler, + MESSAGE_CONNECTED, MESSAGE_DISCONNECTED); + + mSimWatcher = new SimWatcher(mContext); + sThis.set(this); + } + + public String getPassword(Account account) { + checkAuthenticateAccountsPermission(account); + + long identityToken = clearCallingIdentity(); + try { + return readPasswordFromDatabase(account); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private String readPasswordFromDatabase(Account account) { + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + Cursor cursor = db.query(TABLE_ACCOUNTS, new String[]{ACCOUNTS_PASSWORD}, + ACCOUNTS_NAME + "=? AND " + ACCOUNTS_TYPE+ "=?", + new String[]{account.name, account.type}, null, null, null); + try { + if (cursor.moveToNext()) { + return cursor.getString(0); + } + return null; + } finally { + cursor.close(); + } + } + + public String getUserData(Account account, String key) { + checkAuthenticateAccountsPermission(account); + long identityToken = clearCallingIdentity(); + try { + return readUserDataFromDatabase(account, key); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private String readUserDataFromDatabase(Account account, String key) { + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId < 0) { + return null; + } + Cursor cursor = db.query(TABLE_EXTRAS, new String[]{EXTRAS_VALUE}, + EXTRAS_ACCOUNTS_ID + "=" + accountId + " AND " + EXTRAS_KEY + "=?", + new String[]{key}, null, null, null); + try { + if (cursor.moveToNext()) { + return cursor.getString(0); + } + return null; + } finally { + cursor.close(); + } + } finally { + db.endTransaction(); + } + } + + public AuthenticatorDescription[] getAuthenticatorTypes() { + long identityToken = clearCallingIdentity(); + try { + Collection<AccountAuthenticatorCache.ServiceInfo<AuthenticatorDescription>> + authenticatorCollection = mAuthenticatorCache.getAllServices(); + AuthenticatorDescription[] types = + new AuthenticatorDescription[authenticatorCollection.size()]; + int i = 0; + for (AccountAuthenticatorCache.ServiceInfo<AuthenticatorDescription> authenticator + : authenticatorCollection) { + types[i] = authenticator.type; + i++; + } + return types; + } finally { + restoreCallingIdentity(identityToken); + } + } + + public Account[] getAccountsByType(String accountType) { + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + + final String selection = accountType == null ? null : (ACCOUNTS_TYPE + "=?"); + final String[] selectionArgs = accountType == null ? null : new String[]{accountType}; + Cursor cursor = db.query(TABLE_ACCOUNTS, ACCOUNT_NAME_TYPE_PROJECTION, + selection, selectionArgs, null, null, null); + try { + int i = 0; + Account[] accounts = new Account[cursor.getCount()]; + while (cursor.moveToNext()) { + accounts[i] = new Account(cursor.getString(1), cursor.getString(2)); + i++; + } + return accounts; + } finally { + cursor.close(); + } + } + + public boolean addAccount(Account account, String password, Bundle extras) { + checkAuthenticateAccountsPermission(account); + + // fails if the account already exists + long identityToken = clearCallingIdentity(); + try { + return insertAccountIntoDatabase(account, password, extras); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private boolean insertAccountIntoDatabase(Account account, String password, Bundle extras) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + long numMatches = DatabaseUtils.longForQuery(db, + "select count(*) from " + TABLE_ACCOUNTS + + " WHERE " + ACCOUNTS_NAME + "=? AND " + ACCOUNTS_TYPE+ "=?", + new String[]{account.name, account.type}); + if (numMatches > 0) { + return false; + } + ContentValues values = new ContentValues(); + values.put(ACCOUNTS_NAME, account.name); + values.put(ACCOUNTS_TYPE, account.type); + values.put(ACCOUNTS_PASSWORD, password); + long accountId = db.insert(TABLE_ACCOUNTS, ACCOUNTS_NAME, values); + if (accountId < 0) { + return false; + } + if (extras != null) { + for (String key : extras.keySet()) { + final String value = extras.getString(key); + if (insertExtra(db, accountId, key, value) < 0) { + return false; + } + } + } + db.setTransactionSuccessful(); + sendAccountsChangedBroadcast(); + return true; + } finally { + db.endTransaction(); + } + } + + private long insertExtra(SQLiteDatabase db, long accountId, String key, String value) { + ContentValues values = new ContentValues(); + values.put(EXTRAS_KEY, key); + values.put(EXTRAS_ACCOUNTS_ID, accountId); + values.put(EXTRAS_VALUE, value); + return db.insert(TABLE_EXTRAS, EXTRAS_KEY, values); + } + + public void removeAccount(IAccountManagerResponse response, Account account) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new RemoveAccountSession(response, account).bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private class RemoveAccountSession extends Session { + final Account mAccount; + public RemoveAccountSession(IAccountManagerResponse response, Account account) { + super(response, account.type, false /* expectActivityLaunch */); + mAccount = account; + } + + protected String toDebugString(long now) { + return super.toDebugString(now) + ", removeAccount" + + ", account " + mAccount; + } + + public void run() throws RemoteException { + mAuthenticator.getAccountRemovalAllowed(this, mAccount); + } + + public void onResult(Bundle result) { + if (result != null && result.containsKey(Constants.BOOLEAN_RESULT_KEY) + && !result.containsKey(Constants.INTENT_KEY)) { + final boolean removalAllowed = result.getBoolean(Constants.BOOLEAN_RESULT_KEY); + if (removalAllowed) { + removeAccount(mAccount); + } + IAccountManagerResponse response = getResponseAndClose(); + if (response != null) { + Bundle result2 = new Bundle(); + result2.putBoolean(Constants.BOOLEAN_RESULT_KEY, removalAllowed); + try { + response.onResult(result2); + } catch (RemoteException e) { + // ignore + } + } + } + super.onResult(result); + } + } + + private void removeAccount(Account account) { + final SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.delete(TABLE_ACCOUNTS, ACCOUNTS_NAME + "=? AND " + ACCOUNTS_TYPE+ "=?", + new String[]{account.name, account.type}); + sendAccountsChangedBroadcast(); + } + + public void invalidateAuthToken(String accountType, String authToken) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + invalidateAuthToken(db, accountType, authToken); + db.setTransactionSuccessful(); + } finally { + db.endTransaction(); + } + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void invalidateAuthToken(SQLiteDatabase db, String accountType, String authToken) { + if (authToken == null || accountType == null) { + return; + } + Cursor cursor = db.rawQuery( + "SELECT " + TABLE_AUTHTOKENS + "." + AUTHTOKENS_ID + + ", " + TABLE_ACCOUNTS + "." + ACCOUNTS_NAME + + ", " + TABLE_AUTHTOKENS + "." + AUTHTOKENS_TYPE + + " FROM " + TABLE_ACCOUNTS + + " JOIN " + TABLE_AUTHTOKENS + + " ON " + TABLE_ACCOUNTS + "." + ACCOUNTS_ID + + " = " + AUTHTOKENS_ACCOUNTS_ID + + " WHERE " + AUTHTOKENS_AUTHTOKEN + " = ? AND " + + TABLE_ACCOUNTS + "." + ACCOUNTS_TYPE + " = ?", + new String[]{authToken, accountType}); + try { + while (cursor.moveToNext()) { + long authTokenId = cursor.getLong(0); + String accountName = cursor.getString(1); + String authTokenType = cursor.getString(2); + db.delete(TABLE_AUTHTOKENS, AUTHTOKENS_ID + "=" + authTokenId, null); + } + } finally { + cursor.close(); + } + } + + private boolean saveAuthTokenToDatabase(Account account, String type, String authToken) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId < 0) { + return false; + } + db.delete(TABLE_AUTHTOKENS, + AUTHTOKENS_ACCOUNTS_ID + "=" + accountId + " AND " + AUTHTOKENS_TYPE + "=?", + new String[]{type}); + ContentValues values = new ContentValues(); + values.put(AUTHTOKENS_ACCOUNTS_ID, accountId); + values.put(AUTHTOKENS_TYPE, type); + values.put(AUTHTOKENS_AUTHTOKEN, authToken); + if (db.insert(TABLE_AUTHTOKENS, AUTHTOKENS_AUTHTOKEN, values) >= 0) { + db.setTransactionSuccessful(); + return true; + } + return false; + } finally { + db.endTransaction(); + } + } + + public String readAuthTokenFromDatabase(Account account, String authTokenType) { + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId < 0) { + return null; + } + return getAuthToken(db, accountId, authTokenType); + } finally { + db.endTransaction(); + } + } + + public String peekAuthToken(Account account, String authTokenType) { + checkAuthenticateAccountsPermission(account); + long identityToken = clearCallingIdentity(); + try { + return readAuthTokenFromDatabase(account, authTokenType); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void setAuthToken(Account account, String authTokenType, String authToken) { + checkAuthenticateAccountsPermission(account); + long identityToken = clearCallingIdentity(); + try { + cacheAuthToken(account, authTokenType, authToken); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void setPassword(Account account, String password) { + checkAuthenticateAccountsPermission(account); + long identityToken = clearCallingIdentity(); + try { + ContentValues values = new ContentValues(); + values.put(ACCOUNTS_PASSWORD, password); + mOpenHelper.getWritableDatabase().update(TABLE_ACCOUNTS, values, + ACCOUNTS_NAME + "=? AND " + ACCOUNTS_TYPE+ "=?", + new String[]{account.name, account.type}); + sendAccountsChangedBroadcast(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void sendAccountsChangedBroadcast() { + mContext.sendBroadcast(ACCOUNTS_CHANGED_INTENT); + } + + public void clearPassword(Account account) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + setPassword(account, null); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void sendResult(IAccountManagerResponse response, Bundle bundle) { + if (response != null) { + try { + response.onResult(bundle); + } catch (RemoteException e) { + // if the caller is dead then there is no one to care about remote + // exceptions + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "failure while notifying response", e); + } + } + } + } + + public void setUserData(Account account, String key, String value) { + checkAuthenticateAccountsPermission(account); + long identityToken = clearCallingIdentity(); + try { + writeUserdataIntoDatabase(account, key, value); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void writeUserdataIntoDatabase(Account account, String key, String value) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId < 0) { + return; + } + long extrasId = getExtrasId(db, accountId, key); + if (extrasId < 0 ) { + extrasId = insertExtra(db, accountId, key, value); + if (extrasId < 0) { + return; + } + } else { + ContentValues values = new ContentValues(); + values.put(EXTRAS_VALUE, value); + if (1 != db.update(TABLE_EXTRAS, values, EXTRAS_ID + "=" + extrasId, null)) { + return; + } + + } + db.setTransactionSuccessful(); + } finally { + db.endTransaction(); + } + } + + private void onResult(IAccountManagerResponse response, Bundle result) { + try { + response.onResult(result); + } catch (RemoteException e) { + // if the caller is dead then there is no one to care about remote + // exceptions + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "failure while notifying response", e); + } + } + } + + public void getAuthToken(IAccountManagerResponse response, final Account account, + final String authTokenType, final boolean notifyOnAuthFailure, + final boolean expectActivityLaunch, final Bundle loginOptions) { + checkBinderPermission(Manifest.permission.USE_CREDENTIALS); + final int callerUid = Binder.getCallingUid(); + final boolean permissionGranted = permissionIsGranted(account, authTokenType, callerUid); + + long identityToken = clearCallingIdentity(); + try { + // if the caller has permission, do the peek. otherwise go the more expensive + // route of starting a Session + if (permissionGranted) { + String authToken = readAuthTokenFromDatabase(account, authTokenType); + if (authToken != null) { + Bundle result = new Bundle(); + result.putString(Constants.AUTHTOKEN_KEY, authToken); + result.putString(Constants.ACCOUNT_NAME_KEY, account.name); + result.putString(Constants.ACCOUNT_TYPE_KEY, account.type); + onResult(response, result); + return; + } + } + + new Session(response, account.type, expectActivityLaunch) { + protected String toDebugString(long now) { + if (loginOptions != null) loginOptions.keySet(); + return super.toDebugString(now) + ", getAuthToken" + + ", " + account + + ", authTokenType " + authTokenType + + ", loginOptions " + loginOptions + + ", notifyOnAuthFailure " + notifyOnAuthFailure; + } + + public void run() throws RemoteException { + // If the caller doesn't have permission then create and return the + // "grant permission" intent instead of the "getAuthToken" intent. + if (!permissionGranted) { + mAuthenticator.getAuthTokenLabel(this, authTokenType); + } else { + mAuthenticator.getAuthToken(this, account, authTokenType, loginOptions); + } + } + + public void onResult(Bundle result) { + if (result != null) { + if (result.containsKey(Constants.AUTH_TOKEN_LABEL_KEY)) { + Intent intent = newGrantCredentialsPermissionIntent(account, callerUid, + new AccountAuthenticatorResponse(this), + authTokenType, + result.getString(Constants.AUTH_TOKEN_LABEL_KEY)); + Bundle bundle = new Bundle(); + bundle.putParcelable(Constants.INTENT_KEY, intent); + onResult(bundle); + return; + } + String authToken = result.getString(Constants.AUTHTOKEN_KEY); + if (authToken != null) { + String name = result.getString(Constants.ACCOUNT_NAME_KEY); + String type = result.getString(Constants.ACCOUNT_TYPE_KEY); + if (TextUtils.isEmpty(type) || TextUtils.isEmpty(name)) { + onError(Constants.ERROR_CODE_INVALID_RESPONSE, + "the type and name should not be empty"); + return; + } + cacheAuthToken(new Account(name, type), authTokenType, authToken); + } + + Intent intent = result.getParcelable(Constants.INTENT_KEY); + if (intent != null && notifyOnAuthFailure) { + doNotification( + account, result.getString(Constants.AUTH_FAILED_MESSAGE_KEY), + intent); + } + } + super.onResult(result); + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void createNoCredentialsPermissionNotification(Account account, Intent intent) { + int uid = intent.getIntExtra( + GrantCredentialsPermissionActivity.EXTRAS_REQUESTING_UID, -1); + String authTokenType = intent.getStringExtra( + GrantCredentialsPermissionActivity.EXTRAS_AUTH_TOKEN_TYPE); + String authTokenLabel = intent.getStringExtra( + GrantCredentialsPermissionActivity.EXTRAS_AUTH_TOKEN_LABEL); + + Notification n = new Notification(android.R.drawable.stat_sys_warning, null, + 0 /* when */); + final CharSequence subtitleFormatString = + mContext.getText(R.string.permission_request_notification_subtitle); + n.setLatestEventInfo(mContext, + mContext.getText(R.string.permission_request_notification_title), + String.format(subtitleFormatString.toString(), account.name), + PendingIntent.getActivity(mContext, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT)); + ((NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE)) + .notify(getCredentialPermissionNotificationId(account, authTokenType, uid), n); + } + + private Intent newGrantCredentialsPermissionIntent(Account account, int uid, + AccountAuthenticatorResponse response, String authTokenType, String authTokenLabel) { + RegisteredServicesCache.ServiceInfo<AuthenticatorDescription> serviceInfo = + mAuthenticatorCache.getServiceInfo( + AuthenticatorDescription.newKey(account.type)); + if (serviceInfo == null) { + throw new IllegalArgumentException("unknown account type: " + account.type); + } + + final Context authContext; + try { + authContext = mContext.createPackageContext( + serviceInfo.type.packageName, 0); + } catch (PackageManager.NameNotFoundException e) { + throw new IllegalArgumentException("unknown account type: " + account.type); + } + + Intent intent = new Intent(mContext, GrantCredentialsPermissionActivity.class); + intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + intent.addCategory( + String.valueOf(getCredentialPermissionNotificationId(account, authTokenType, uid))); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_ACCOUNT, account); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_AUTH_TOKEN_LABEL, authTokenLabel); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_AUTH_TOKEN_TYPE, authTokenType); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_RESPONSE, response); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_ACCOUNT_TYPE_LABEL, + authContext.getString(serviceInfo.type.labelId)); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_PACKAGES, + mContext.getPackageManager().getPackagesForUid(uid)); + intent.putExtra(GrantCredentialsPermissionActivity.EXTRAS_REQUESTING_UID, uid); + return intent; + } + + private Integer getCredentialPermissionNotificationId(Account account, String authTokenType, + int uid) { + Integer id; + synchronized(mCredentialsPermissionNotificationIds) { + final Pair<Pair<Account, String>, Integer> key = + new Pair<Pair<Account, String>, Integer>( + new Pair<Account, String>(account, authTokenType), uid); + id = mCredentialsPermissionNotificationIds.get(key); + if (id == null) { + id = mNotificationIds.incrementAndGet(); + mCredentialsPermissionNotificationIds.put(key, id); + } + } + return id; + } + + private Integer getSigninRequiredNotificationId(Account account) { + Integer id; + synchronized(mSigninRequiredNotificationIds) { + id = mSigninRequiredNotificationIds.get(account); + if (id == null) { + id = mNotificationIds.incrementAndGet(); + mSigninRequiredNotificationIds.put(account, id); + } + } + return id; + } + + + public void addAcount(final IAccountManagerResponse response, final String accountType, + final String authTokenType, final String[] requiredFeatures, + final boolean expectActivityLaunch, final Bundle options) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new Session(response, accountType, expectActivityLaunch) { + public void run() throws RemoteException { + mAuthenticator.addAccount(this, mAccountType, authTokenType, requiredFeatures, + options); + } + + protected String toDebugString(long now) { + return super.toDebugString(now) + ", addAccount" + + ", accountType " + accountType + + ", requiredFeatures " + + (requiredFeatures != null + ? TextUtils.join(",", requiredFeatures) + : null); + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void confirmCredentials(IAccountManagerResponse response, + final Account account, final boolean expectActivityLaunch) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new Session(response, account.type, expectActivityLaunch) { + public void run() throws RemoteException { + mAuthenticator.confirmCredentials(this, account); + } + protected String toDebugString(long now) { + return super.toDebugString(now) + ", confirmCredentials" + + ", " + account; + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void confirmPassword(IAccountManagerResponse response, final Account account, + final String password) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new Session(response, account.type, false /* expectActivityLaunch */) { + public void run() throws RemoteException { + mAuthenticator.confirmPassword(this, account, password); + } + protected String toDebugString(long now) { + return super.toDebugString(now) + ", confirmPassword" + + ", " + account; + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void updateCredentials(IAccountManagerResponse response, final Account account, + final String authTokenType, final boolean expectActivityLaunch, + final Bundle loginOptions) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new Session(response, account.type, expectActivityLaunch) { + public void run() throws RemoteException { + mAuthenticator.updateCredentials(this, account, authTokenType, loginOptions); + } + protected String toDebugString(long now) { + if (loginOptions != null) loginOptions.keySet(); + return super.toDebugString(now) + ", updateCredentials" + + ", " + account + + ", authTokenType " + authTokenType + + ", loginOptions " + loginOptions; + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void editProperties(IAccountManagerResponse response, final String accountType, + final boolean expectActivityLaunch) { + checkManageAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + new Session(response, accountType, expectActivityLaunch) { + public void run() throws RemoteException { + mAuthenticator.editProperties(this, mAccountType); + } + protected String toDebugString(long now) { + return super.toDebugString(now) + ", editProperties" + + ", accountType " + accountType; + } + }.bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private class GetAccountsByTypeAndFeatureSession extends Session { + private final String[] mFeatures; + private volatile Account[] mAccountsOfType = null; + private volatile ArrayList<Account> mAccountsWithFeatures = null; + private volatile int mCurrentAccount = 0; + + public GetAccountsByTypeAndFeatureSession(IAccountManagerResponse response, + String type, String[] features) { + super(response, type, false /* expectActivityLaunch */); + mFeatures = features; + } + + public void run() throws RemoteException { + mAccountsOfType = getAccountsByType(mAccountType); + // check whether each account matches the requested features + mAccountsWithFeatures = new ArrayList<Account>(mAccountsOfType.length); + mCurrentAccount = 0; + + checkAccount(); + } + + public void checkAccount() { + if (mCurrentAccount >= mAccountsOfType.length) { + sendResult(); + return; + } + + try { + mAuthenticator.hasFeatures(this, mAccountsOfType[mCurrentAccount], mFeatures); + } catch (RemoteException e) { + onError(Constants.ERROR_CODE_REMOTE_EXCEPTION, "remote exception"); + } + } + + public void onResult(Bundle result) { + mNumResults++; + if (result == null) { + onError(Constants.ERROR_CODE_INVALID_RESPONSE, "null bundle"); + return; + } + if (result.getBoolean(Constants.BOOLEAN_RESULT_KEY, false)) { + mAccountsWithFeatures.add(mAccountsOfType[mCurrentAccount]); + } + mCurrentAccount++; + checkAccount(); + } + + public void sendResult() { + IAccountManagerResponse response = getResponseAndClose(); + if (response != null) { + try { + Account[] accounts = new Account[mAccountsWithFeatures.size()]; + for (int i = 0; i < accounts.length; i++) { + accounts[i] = mAccountsWithFeatures.get(i); + } + Bundle result = new Bundle(); + result.putParcelableArray(Constants.ACCOUNTS_KEY, accounts); + response.onResult(result); + } catch (RemoteException e) { + // if the caller is dead then there is no one to care about remote exceptions + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "failure while notifying response", e); + } + } + } + } + + + protected String toDebugString(long now) { + return super.toDebugString(now) + ", getAccountsByTypeAndFeatures" + + ", " + (mFeatures != null ? TextUtils.join(",", mFeatures) : null); + } + } + + public Account[] getAccounts(String type) { + checkReadAccountsPermission(); + long identityToken = clearCallingIdentity(); + try { + return getAccountsByType(type); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public void getAccountsByFeatures(IAccountManagerResponse response, + String type, String[] features) { + checkReadAccountsPermission(); + if (features != null && type == null) { + if (response != null) { + try { + response.onError(Constants.ERROR_CODE_BAD_ARGUMENTS, "type is null"); + } catch (RemoteException e) { + // ignore this + } + } + return; + } + long identityToken = clearCallingIdentity(); + try { + if (features == null || features.length == 0) { + getAccountsByType(type); + return; + } + new GetAccountsByTypeAndFeatureSession(response, type, features).bind(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private boolean cacheAuthToken(Account account, String authTokenType, String authToken) { + return saveAuthTokenToDatabase(account, authTokenType, authToken); + } + + private long getAccountId(SQLiteDatabase db, Account account) { + Cursor cursor = db.query(TABLE_ACCOUNTS, new String[]{ACCOUNTS_ID}, + "name=? AND type=?", new String[]{account.name, account.type}, null, null, null); + try { + if (cursor.moveToNext()) { + return cursor.getLong(0); + } + return -1; + } finally { + cursor.close(); + } + } + + private long getExtrasId(SQLiteDatabase db, long accountId, String key) { + Cursor cursor = db.query(TABLE_EXTRAS, new String[]{EXTRAS_ID}, + EXTRAS_ACCOUNTS_ID + "=" + accountId + " AND " + EXTRAS_KEY + "=?", + new String[]{key}, null, null, null); + try { + if (cursor.moveToNext()) { + return cursor.getLong(0); + } + return -1; + } finally { + cursor.close(); + } + } + + private String getAuthToken(SQLiteDatabase db, long accountId, String authTokenType) { + Cursor cursor = db.query(TABLE_AUTHTOKENS, new String[]{AUTHTOKENS_AUTHTOKEN}, + AUTHTOKENS_ACCOUNTS_ID + "=" + accountId + " AND " + AUTHTOKENS_TYPE + "=?", + new String[]{authTokenType}, + null, null, null); + try { + if (cursor.moveToNext()) { + return cursor.getString(0); + } + return null; + } finally { + cursor.close(); + } + } + + private abstract class Session extends IAccountAuthenticatorResponse.Stub + implements AuthenticatorBindHelper.Callback, IBinder.DeathRecipient { + IAccountManagerResponse mResponse; + final String mAccountType; + final boolean mExpectActivityLaunch; + final long mCreationTime; + + public int mNumResults = 0; + private int mNumRequestContinued = 0; + private int mNumErrors = 0; + + + IAccountAuthenticator mAuthenticator = null; + + public Session(IAccountManagerResponse response, String accountType, + boolean expectActivityLaunch) { + super(); + if (response == null) throw new IllegalArgumentException("response is null"); + if (accountType == null) throw new IllegalArgumentException("accountType is null"); + mResponse = response; + mAccountType = accountType; + mExpectActivityLaunch = expectActivityLaunch; + mCreationTime = SystemClock.elapsedRealtime(); + synchronized (mSessions) { + mSessions.put(toString(), this); + } + try { + response.asBinder().linkToDeath(this, 0 /* flags */); + } catch (RemoteException e) { + mResponse = null; + binderDied(); + } + } + + IAccountManagerResponse getResponseAndClose() { + if (mResponse == null) { + // this session has already been closed + return null; + } + IAccountManagerResponse response = mResponse; + close(); // this clears mResponse so we need to save the response before this call + return response; + } + + private void close() { + synchronized (mSessions) { + if (mSessions.remove(toString()) == null) { + // the session was already closed, so bail out now + return; + } + } + if (mResponse != null) { + // stop listening for response deaths + mResponse.asBinder().unlinkToDeath(this, 0 /* flags */); + + // clear this so that we don't accidentally send any further results + mResponse = null; + } + cancelTimeout(); + unbind(); + } + + public void binderDied() { + mResponse = null; + close(); + } + + protected String toDebugString() { + return toDebugString(SystemClock.elapsedRealtime()); + } + + protected String toDebugString(long now) { + return "Session: expectLaunch " + mExpectActivityLaunch + + ", connected " + (mAuthenticator != null) + + ", stats (" + mNumResults + "/" + mNumRequestContinued + + "/" + mNumErrors + ")" + + ", lifetime " + ((now - mCreationTime) / 1000.0); + } + + void bind() { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "initiating bind to authenticator type " + mAccountType); + } + if (!mBindHelper.bind(mAccountType, this)) { + Log.d(TAG, "bind attempt failed for " + toDebugString()); + onError(Constants.ERROR_CODE_REMOTE_EXCEPTION, "bind failure"); + } + } + + private void unbind() { + if (mAuthenticator != null) { + mAuthenticator = null; + mBindHelper.unbind(this); + } + } + + public void scheduleTimeout() { + mMessageHandler.sendMessageDelayed( + mMessageHandler.obtainMessage(MESSAGE_TIMED_OUT, this), TIMEOUT_DELAY_MS); + } + + public void cancelTimeout() { + mMessageHandler.removeMessages(MESSAGE_TIMED_OUT, this); + } + + public void onConnected(IBinder service) { + mAuthenticator = IAccountAuthenticator.Stub.asInterface(service); + try { + run(); + } catch (RemoteException e) { + onError(Constants.ERROR_CODE_REMOTE_EXCEPTION, + "remote exception"); + } + } + + public abstract void run() throws RemoteException; + + public void onDisconnected() { + mAuthenticator = null; + IAccountManagerResponse response = getResponseAndClose(); + if (response != null) { + onError(Constants.ERROR_CODE_REMOTE_EXCEPTION, + "disconnected"); + } + } + + public void onTimedOut() { + IAccountManagerResponse response = getResponseAndClose(); + if (response != null) { + onError(Constants.ERROR_CODE_REMOTE_EXCEPTION, + "timeout"); + } + } + + public void onResult(Bundle result) { + mNumResults++; + if (result != null && !TextUtils.isEmpty(result.getString(Constants.AUTHTOKEN_KEY))) { + String accountName = result.getString(Constants.ACCOUNT_NAME_KEY); + String accountType = result.getString(Constants.ACCOUNT_TYPE_KEY); + if (!TextUtils.isEmpty(accountName) && !TextUtils.isEmpty(accountType)) { + Account account = new Account(accountName, accountType); + cancelNotification(getSigninRequiredNotificationId(account)); + } + } + IAccountManagerResponse response; + if (mExpectActivityLaunch && result != null + && result.containsKey(Constants.INTENT_KEY)) { + response = mResponse; + } else { + response = getResponseAndClose(); + } + if (response != null) { + try { + if (result == null) { + response.onError(Constants.ERROR_CODE_INVALID_RESPONSE, + "null bundle returned"); + } else { + response.onResult(result); + } + } catch (RemoteException e) { + // if the caller is dead then there is no one to care about remote exceptions + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "failure while notifying response", e); + } + } + } + } + + public void onRequestContinued() { + mNumRequestContinued++; + } + + public void onError(int errorCode, String errorMessage) { + mNumErrors++; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "Session.onError: " + errorCode + ", " + errorMessage); + } + IAccountManagerResponse response = getResponseAndClose(); + if (response != null) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "Session.onError: responding"); + } + try { + response.onError(errorCode, errorMessage); + } catch (RemoteException e) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "Session.onError: caught RemoteException while responding", e); + } + } + } else { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "Session.onError: already closed"); + } + } + } + } + + private class MessageHandler extends Handler { + MessageHandler(Looper looper) { + super(looper); + } + + public void handleMessage(Message msg) { + if (mBindHelper.handleMessage(msg)) { + return; + } + switch (msg.what) { + case MESSAGE_TIMED_OUT: + Session session = (Session)msg.obj; + session.onTimedOut(); + break; + + default: + throw new IllegalStateException("unhandled message: " + msg.what); + } + } + } + + private class DatabaseHelper extends SQLiteOpenHelper { + public DatabaseHelper(Context context) { + super(context, DATABASE_NAME, null, DATABASE_VERSION); + } + + @Override + public void onCreate(SQLiteDatabase db) { + db.execSQL("CREATE TABLE " + TABLE_ACCOUNTS + " ( " + + ACCOUNTS_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + + ACCOUNTS_NAME + " TEXT NOT NULL, " + + ACCOUNTS_TYPE + " TEXT NOT NULL, " + + ACCOUNTS_PASSWORD + " TEXT, " + + "UNIQUE(" + ACCOUNTS_NAME + "," + ACCOUNTS_TYPE + "))"); + + db.execSQL("CREATE TABLE " + TABLE_AUTHTOKENS + " ( " + + AUTHTOKENS_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + + AUTHTOKENS_ACCOUNTS_ID + " INTEGER NOT NULL, " + + AUTHTOKENS_TYPE + " TEXT NOT NULL, " + + AUTHTOKENS_AUTHTOKEN + " TEXT, " + + "UNIQUE (" + AUTHTOKENS_ACCOUNTS_ID + "," + AUTHTOKENS_TYPE + "))"); + + createGrantsTable(db); + + db.execSQL("CREATE TABLE " + TABLE_EXTRAS + " ( " + + EXTRAS_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " + + EXTRAS_ACCOUNTS_ID + " INTEGER, " + + EXTRAS_KEY + " TEXT NOT NULL, " + + EXTRAS_VALUE + " TEXT, " + + "UNIQUE(" + EXTRAS_ACCOUNTS_ID + "," + EXTRAS_KEY + "))"); + + db.execSQL("CREATE TABLE " + TABLE_META + " ( " + + META_KEY + " TEXT PRIMARY KEY NOT NULL, " + + META_VALUE + " TEXT)"); + + createAccountsDeletionTrigger(db); + } + + private void createAccountsDeletionTrigger(SQLiteDatabase db) { + db.execSQL("" + + " CREATE TRIGGER " + TABLE_ACCOUNTS + "Delete DELETE ON " + TABLE_ACCOUNTS + + " BEGIN" + + " DELETE FROM " + TABLE_AUTHTOKENS + + " WHERE " + AUTHTOKENS_ACCOUNTS_ID + "=OLD." + ACCOUNTS_ID + " ;" + + " DELETE FROM " + TABLE_EXTRAS + + " WHERE " + EXTRAS_ACCOUNTS_ID + "=OLD." + ACCOUNTS_ID + " ;" + + " DELETE FROM " + TABLE_GRANTS + + " WHERE " + GRANTS_ACCOUNTS_ID + "=OLD." + ACCOUNTS_ID + " ;" + + " END"); + } + + private void createGrantsTable(SQLiteDatabase db) { + db.execSQL("CREATE TABLE " + TABLE_GRANTS + " ( " + + GRANTS_ACCOUNTS_ID + " INTEGER NOT NULL, " + + GRANTS_AUTH_TOKEN_TYPE + " STRING NOT NULL, " + + GRANTS_GRANTEE_UID + " INTEGER NOT NULL, " + + "UNIQUE (" + GRANTS_ACCOUNTS_ID + "," + GRANTS_AUTH_TOKEN_TYPE + + "," + GRANTS_GRANTEE_UID + "))"); + } + + @Override + public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { + Log.e(TAG, "upgrade from version " + oldVersion + " to version " + newVersion); + + if (oldVersion == 1) { + // no longer need to do anything since the work is done + // when upgrading from version 2 + oldVersion++; + } + + if (oldVersion == 2) { + createGrantsTable(db); + db.execSQL("DROP TRIGGER " + TABLE_ACCOUNTS + "Delete"); + createAccountsDeletionTrigger(db); + oldVersion++; + } + } + + @Override + public void onOpen(SQLiteDatabase db) { + if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "opened database " + DATABASE_NAME); + } + } + + private void setMetaValue(String key, String value) { + ContentValues values = new ContentValues(); + values.put(META_KEY, key); + values.put(META_VALUE, value); + mOpenHelper.getWritableDatabase().replace(TABLE_META, META_KEY, values); + } + + private String getMetaValue(String key) { + Cursor c = mOpenHelper.getReadableDatabase().query(TABLE_META, + new String[]{META_VALUE}, META_KEY + "=?", new String[]{key}, null, null, null); + try { + if (c.moveToNext()) { + return c.getString(0); + } + return null; + } finally { + c.close(); + } + } + + private class SimWatcher extends BroadcastReceiver { + public SimWatcher(Context context) { + // Re-scan the SIM card when the SIM state changes, and also if + // the disk recovers from a full state (we may have failed to handle + // things properly while the disk was full). + final IntentFilter filter = new IntentFilter(); + filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); + filter.addAction(Intent.ACTION_DEVICE_STORAGE_OK); + context.registerReceiver(this, filter); + } + + /** + * Compare the IMSI to the one stored in the login service's + * database. If they differ, erase all passwords and + * authtokens (and store the new IMSI). + */ + @Override + public void onReceive(Context context, Intent intent) { + // Check IMSI on every update; nothing happens if the IMSI is missing or unchanged. + String imsi = ((TelephonyManager) context.getSystemService( + Context.TELEPHONY_SERVICE)).getSubscriberId(); + if (TextUtils.isEmpty(imsi)) return; + + String storedImsi = getMetaValue("imsi"); + + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "current IMSI=" + imsi + "; stored IMSI=" + storedImsi); + } + + if (!imsi.equals(storedImsi) && !"initial".equals(storedImsi)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "wiping all passwords and authtokens"); + } + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + db.execSQL("DELETE from " + TABLE_AUTHTOKENS); + db.execSQL("UPDATE " + TABLE_ACCOUNTS + " SET " + ACCOUNTS_PASSWORD + " = ''"); + sendAccountsChangedBroadcast(); + db.setTransactionSuccessful(); + } finally { + db.endTransaction(); + } + } + setMetaValue("imsi", imsi); + } + } + + public IBinder onBind(Intent intent) { + return asBinder(); + } + + protected void dump(FileDescriptor fd, PrintWriter fout, String[] args) { + synchronized (mSessions) { + final long now = SystemClock.elapsedRealtime(); + fout.println("AccountManagerService: " + mSessions.size() + " sessions"); + for (Session session : mSessions.values()) { + fout.println(" " + session.toDebugString(now)); + } + } + + fout.println(); + + mAuthenticatorCache.dump(fd, fout, args); + } + + private void doNotification(Account account, CharSequence message, Intent intent) { + long identityToken = clearCallingIdentity(); + try { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "doNotification: " + message + " intent:" + intent); + } + + if (intent.getComponent() != null && + GrantCredentialsPermissionActivity.class.getName().equals( + intent.getComponent().getClassName())) { + createNoCredentialsPermissionNotification(account, intent); + } else { + Notification n = new Notification(android.R.drawable.stat_sys_warning, null, + 0 /* when */); + n.setLatestEventInfo(mContext, mContext.getText(R.string.notification_title), + message, PendingIntent.getActivity( + mContext, 0, intent, PendingIntent.FLAG_CANCEL_CURRENT)); + ((NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE)) + .notify(getSigninRequiredNotificationId(account), n); + } + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void cancelNotification(int id) { + long identityToken = clearCallingIdentity(); + try { + ((NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE)) + .cancel(id); + } finally { + restoreCallingIdentity(identityToken); + } + } + + private void checkBinderPermission(String permission) { + final int uid = Binder.getCallingUid(); + if (mContext.checkCallingOrSelfPermission(permission) != + PackageManager.PERMISSION_GRANTED) { + String msg = "caller uid " + uid + " lacks " + permission; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "caller uid " + uid + " has " + permission); + } + } + + private boolean permissionIsGranted(Account account, String authTokenType, int callerUid) { + final boolean fromAuthenticator = hasAuthenticatorUid(account.type, callerUid); + final boolean hasExplicitGrants = hasExplicitlyGrantedPermission(account, authTokenType); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "checkGrantsOrCallingUidAgainstAuthenticator: caller uid " + + callerUid + ", account " + account + + ": is authenticator? " + fromAuthenticator + + ", has explicit permission? " + hasExplicitGrants); + } + return fromAuthenticator || hasExplicitGrants; + } + + private boolean hasAuthenticatorUid(String accountType, int callingUid) { + for (RegisteredServicesCache.ServiceInfo<AuthenticatorDescription> serviceInfo : + mAuthenticatorCache.getAllServices()) { + if (serviceInfo.type.type.equals(accountType)) { + return (serviceInfo.uid == callingUid) || + (mContext.getPackageManager().checkSignatures(serviceInfo.uid, callingUid) + == PackageManager.SIGNATURE_MATCH); + } + } + return false; + } + + private boolean hasExplicitlyGrantedPermission(Account account, String authTokenType) { + if (Binder.getCallingUid() == android.os.Process.SYSTEM_UID) { + return true; + } + SQLiteDatabase db = mOpenHelper.getReadableDatabase(); + String[] args = {String.valueOf(Binder.getCallingUid()), authTokenType, + account.name, account.type}; + final boolean permissionGranted = + DatabaseUtils.longForQuery(db, COUNT_OF_MATCHING_GRANTS, args) != 0; + if (!permissionGranted && isDebuggableMonkeyBuild) { + // TODO: Skip this check when running automated tests. Replace this + // with a more general solution. + Log.w(TAG, "no credentials permission for usage of " + account + ", " + + authTokenType + " by uid " + Binder.getCallingUid() + + " but ignoring since this is a monkey build"); + return true; + } + return permissionGranted; + } + + private void checkCallingUidAgainstAuthenticator(Account account) { + final int uid = Binder.getCallingUid(); + if (!hasAuthenticatorUid(account.type, uid)) { + String msg = "caller uid " + uid + " is different than the authenticator's uid"; + Log.w(TAG, msg); + throw new SecurityException(msg); + } + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "caller uid " + uid + " is the same as the authenticator's uid"); + } + } + + private void checkAuthenticateAccountsPermission(Account account) { + checkBinderPermission(Manifest.permission.AUTHENTICATE_ACCOUNTS); + checkCallingUidAgainstAuthenticator(account); + } + + private void checkReadAccountsPermission() { + checkBinderPermission(Manifest.permission.GET_ACCOUNTS); + } + + private void checkManageAccountsPermission() { + checkBinderPermission(Manifest.permission.MANAGE_ACCOUNTS); + } + + /** + * Allow callers with the given uid permission to get credentials for account/authTokenType. + * <p> + * Although this is public it can only be accessed via the AccountManagerService object + * which is in the system. This means we don't need to protect it with permissions. + * @hide + */ + public void grantAppPermission(Account account, String authTokenType, int uid) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId >= 0) { + ContentValues values = new ContentValues(); + values.put(GRANTS_ACCOUNTS_ID, accountId); + values.put(GRANTS_AUTH_TOKEN_TYPE, authTokenType); + values.put(GRANTS_GRANTEE_UID, uid); + db.insert(TABLE_GRANTS, GRANTS_ACCOUNTS_ID, values); + db.setTransactionSuccessful(); + } + } finally { + db.endTransaction(); + } + cancelNotification(getCredentialPermissionNotificationId(account, authTokenType, uid)); + } + + /** + * Don't allow callers with the given uid permission to get credentials for + * account/authTokenType. + * <p> + * Although this is public it can only be accessed via the AccountManagerService object + * which is in the system. This means we don't need to protect it with permissions. + * @hide + */ + public void revokeAppPermission(Account account, String authTokenType, int uid) { + SQLiteDatabase db = mOpenHelper.getWritableDatabase(); + db.beginTransaction(); + try { + long accountId = getAccountId(db, account); + if (accountId >= 0) { + db.delete(TABLE_GRANTS, + GRANTS_ACCOUNTS_ID + "=? AND " + GRANTS_AUTH_TOKEN_TYPE + "=? AND " + + GRANTS_GRANTEE_UID + "=?", + new String[]{String.valueOf(accountId), authTokenType, + String.valueOf(uid)}); + db.setTransactionSuccessful(); + } + } finally { + db.endTransaction(); + } + cancelNotification(getCredentialPermissionNotificationId(account, authTokenType, uid)); + } +} diff --git a/core/java/android/accounts/AccountMonitor.java b/core/java/android/accounts/AccountMonitor.java deleted file mode 100644 index f21385e..0000000 --- a/core/java/android/accounts/AccountMonitor.java +++ /dev/null @@ -1,174 +0,0 @@ -/* - * 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.accounts; - -import android.content.BroadcastReceiver; -import android.content.ComponentName; -import android.content.Context; -import android.content.Intent; -import android.content.IntentFilter; -import android.content.ServiceConnection; -import android.database.SQLException; -import android.os.IBinder; -import android.os.Process; -import android.os.RemoteException; -import android.util.Log; - -/** - * A helper class that calls back on the provided - * AccountMonitorListener with the set of current accounts both when - * it gets created and whenever the set changes. It does this by - * binding to the AccountsService and registering to receive the - * intent broadcast when the set of accounts is changed. The - * connection to the accounts service is only made when it needs to - * fetch the current list of accounts (that is, when the - * AccountMonitor is first created, and when the intent is received). - */ -public class AccountMonitor extends BroadcastReceiver implements ServiceConnection { - private final Context mContext; - private final AccountMonitorListener mListener; - private boolean mClosed = false; - private int pending = 0; - - // This thread runs in the background and runs the code to update accounts - // in the listener. - private class AccountUpdater extends Thread { - private IBinder mService; - - public AccountUpdater(IBinder service) { - mService = service; - } - - @Override - public void run() { - Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); - IAccountsService accountsService = IAccountsService.Stub.asInterface(mService); - String[] accounts = null; - do { - try { - accounts = accountsService.getAccounts(); - } catch (RemoteException e) { - // if the service was killed then the system will restart it and when it does we - // will get another onServiceConnected, at which point we will do a notify. - Log.w("AccountMonitor", "Remote exception when getting accounts", e); - return; - } - - synchronized (AccountMonitor.this) { - --pending; - if (pending == 0) { - break; - } - } - } while (true); - - mContext.unbindService(AccountMonitor.this); - - try { - mListener.onAccountsUpdated(accounts); - } catch (SQLException e) { - // Better luck next time. If the problem was disk-full, - // the STORAGE_OK intent will re-trigger the update. - Log.e("AccountMonitor", "Can't update accounts", e); - } - } - } - - /** - * Initializes the AccountMonitor and initiates a bind to the - * AccountsService to get the initial account list. For 1.0, - * the "list" is always a single account. - * - * @param context the context we are running in - * @param listener the user to notify when the account set changes - */ - public AccountMonitor(Context context, AccountMonitorListener listener) { - if (listener == null) { - throw new IllegalArgumentException("listener is null"); - } - - mContext = context; - mListener = listener; - - // Register a broadcast receiver to monitor account changes - IntentFilter intentFilter = new IntentFilter(); - intentFilter.addAction(AccountsServiceConstants.LOGIN_ACCOUNTS_CHANGED_ACTION); - intentFilter.addAction(Intent.ACTION_DEVICE_STORAGE_OK); // To recover from disk-full. - mContext.registerReceiver(this, intentFilter); - - // Send the listener the initial state now. - notifyListener(); - } - - @Override - public void onReceive(Context context, Intent intent) { - notifyListener(); - } - - public void onServiceConnected(ComponentName className, IBinder service) { - // Create a background thread to update the accounts. - new AccountUpdater(service).start(); - } - - public void onServiceDisconnected(ComponentName className) { - } - - private synchronized void notifyListener() { - if (pending == 0) { - // initiate the bind - if (!mContext.bindService(AccountsServiceConstants.SERVICE_INTENT, - this, Context.BIND_AUTO_CREATE)) { - // This is normal if GLS isn't part of this build. - Log.w("AccountMonitor", - "Couldn't connect to " + - AccountsServiceConstants.SERVICE_INTENT + - " (Missing service?)"); - } - } else { - // already bound. bindService will not trigger another - // call to onServiceConnected, so instead we make sure - // that the existing background thread will call - // getAccounts() after this function returns, by - // incrementing pending. - // - // Yes, this else clause contains only a comment. - } - ++pending; - } - - /** - * calls close() - * @throws Throwable - */ - @Override - protected void finalize() throws Throwable { - close(); - super.finalize(); - } - - /** - * Unregisters the account receiver. Consecutive calls to this - * method are harmless, but also do nothing. Once this call is - * made no more notifications will occur. - */ - public synchronized void close() { - if (!mClosed) { - mContext.unregisterReceiver(this); - mClosed = true; - } - } -} diff --git a/core/java/android/accounts/AccountsServiceConstants.java b/core/java/android/accounts/AccountsServiceConstants.java deleted file mode 100644 index b882e7b..0000000 --- a/core/java/android/accounts/AccountsServiceConstants.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * Copyright (C) 2008 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.accounts; - -import android.content.Intent; - -/** - * Miscellaneous constants used by the AccountsService and its - * clients. - */ -// TODO: These constants *could* come directly from the -// IAccountsService interface, but that's not possible since the -// aidl compiler doesn't let you define constants (yet.) -public class AccountsServiceConstants { - /** This class is never instantiated. */ - private AccountsServiceConstants() { - } - - /** - * Action sent as a broadcast Intent by the AccountsService - * when accounts are added to and/or removed from the device's - * database, or when the primary account is changed. - */ - public static final String LOGIN_ACCOUNTS_CHANGED_ACTION = - "android.accounts.LOGIN_ACCOUNTS_CHANGED"; - - /** - * Action sent as a broadcast Intent by the AccountsService - * when it starts up and no accounts are available (so some should be added). - */ - public static final String LOGIN_ACCOUNTS_MISSING_ACTION = - "android.accounts.LOGIN_ACCOUNTS_MISSING"; - - /** - * Action on the intent used to bind to the IAccountsService interface. This - * is used for services that have multiple interfaces (allowing - * them to differentiate the interface intended, and return the proper - * Binder.) - */ - private static final String ACCOUNTS_SERVICE_ACTION = "android.accounts.IAccountsService"; - - /* - * The intent uses a component in addition to the action to ensure the actual - * accounts service is bound to (a malicious third-party app could - * theoretically have a service with the same action). - */ - /** The intent used to bind to the accounts service. */ - public static final Intent SERVICE_INTENT = - new Intent() - .setClassName("com.google.android.googleapps", - "com.google.android.googleapps.GoogleLoginService") - .setAction(ACCOUNTS_SERVICE_ACTION); - - /** - * Checks whether the intent is to bind to the accounts service. - * - * @param bindIntent The Intent used to bind to the service. - * @return Whether the intent is to bind to the accounts service. - */ - public static final boolean isForAccountsService(Intent bindIntent) { - String otherAction = bindIntent.getAction(); - return otherAction != null && otherAction.equals(ACCOUNTS_SERVICE_ACTION); - } -} diff --git a/core/java/android/accounts/AuthenticatorBindHelper.java b/core/java/android/accounts/AuthenticatorBindHelper.java new file mode 100644 index 0000000..91e23ab --- /dev/null +++ b/core/java/android/accounts/AuthenticatorBindHelper.java @@ -0,0 +1,252 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.Handler; +import android.os.IBinder; +import android.os.Message; +import android.util.Log; + +import java.util.ArrayList; +import java.util.Map; + +import com.google.android.collect.Lists; +import com.google.android.collect.Maps; + +/** + * A helper object that simplifies binding to Account Authenticators. It uses the + * {@link AccountAuthenticatorCache} to find the component name of the authenticators, + * allowing the user to bind by account name. It also allows multiple, simultaneous binds + * to the same authenticator, with each bind call guaranteed to return either + * {@link Callback#onConnected} or {@link Callback#onDisconnected} if the bind() call + * itself succeeds, even if the authenticator is already bound internally. + * @hide + */ +public class AuthenticatorBindHelper { + private static final String TAG = "Accounts"; + private final Handler mHandler; + private final Context mContext; + private final int mMessageWhatConnected; + private final int mMessageWhatDisconnected; + private final Map<String, MyServiceConnection> mServiceConnections = Maps.newHashMap(); + private final Map<String, ArrayList<Callback>> mServiceUsers = Maps.newHashMap(); + private final AccountAuthenticatorCache mAuthenticatorCache; + + public AuthenticatorBindHelper(Context context, + AccountAuthenticatorCache authenticatorCache, Handler handler, + int messageWhatConnected, int messageWhatDisconnected) { + mContext = context; + mHandler = handler; + mAuthenticatorCache = authenticatorCache; + mMessageWhatConnected = messageWhatConnected; + mMessageWhatDisconnected = messageWhatDisconnected; + } + + public interface Callback { + void onConnected(IBinder service); + void onDisconnected(); + } + + public boolean bind(String authenticatorType, Callback callback) { + // if the authenticator is connecting or connected then return true + synchronized (mServiceConnections) { + if (mServiceConnections.containsKey(authenticatorType)) { + MyServiceConnection connection = mServiceConnections.get(authenticatorType); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "service connection already exists for " + authenticatorType); + } + mServiceUsers.get(authenticatorType).add(callback); + if (connection.mService != null) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "the service is connected, scheduling a connected message for " + + authenticatorType); + } + connection.scheduleCallbackConnectedMessage(callback); + } else { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "the service is *not* connected, waiting for for " + + authenticatorType); + } + } + return true; + } + + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "there is no service connection for " + authenticatorType); + } + + // otherwise find the component name for the authenticator and initiate a bind + // if no authenticator or the bind fails then return false, otherwise return true + AccountAuthenticatorCache.ServiceInfo<AuthenticatorDescription> authenticatorInfo = + mAuthenticatorCache.getServiceInfo( + AuthenticatorDescription.newKey(authenticatorType)); + if (authenticatorInfo == null) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "there is no authenticator for " + authenticatorType + + ", bailing out"); + } + return false; + } + + MyServiceConnection connection = new MyServiceConnection(authenticatorType); + + Intent intent = new Intent(); + intent.setAction("android.accounts.AccountAuthenticator"); + intent.setComponent(authenticatorInfo.componentName); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "performing bindService to " + authenticatorInfo.componentName); + } + if (!mContext.bindService(intent, connection, Context.BIND_AUTO_CREATE)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "bindService to " + authenticatorInfo.componentName + " failed"); + } + return false; + } + + mServiceConnections.put(authenticatorType, connection); + mServiceUsers.put(authenticatorType, Lists.newArrayList(callback)); + return true; + } + } + + public void unbind(Callback callbackToUnbind) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "unbinding callback " + callbackToUnbind); + } + synchronized (mServiceConnections) { + for (Map.Entry<String, ArrayList<Callback>> entry : mServiceUsers.entrySet()) { + final String authenticatorType = entry.getKey(); + final ArrayList<Callback> serviceUsers = entry.getValue(); + for (Callback callback : serviceUsers) { + if (callback == callbackToUnbind) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "found callback in service" + authenticatorType); + } + serviceUsers.remove(callbackToUnbind); + if (serviceUsers.isEmpty()) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "there are no more callbacks for service " + + authenticatorType + ", unbinding service"); + } + unbindFromService(authenticatorType); + } else { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "leaving service " + authenticatorType + + " around since there are still callbacks using it"); + } + } + return; + } + } + } + Log.e(TAG, "did not find callback " + callbackToUnbind + " in any of the services"); + } + } + + private void unbindFromService(String authenticatorType) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "unbindService from " + authenticatorType); + } + mContext.unbindService(mServiceConnections.get(authenticatorType)); + mServiceUsers.remove(authenticatorType); + mServiceConnections.remove(authenticatorType); + } + + private class ConnectedMessagePayload { + public final IBinder mService; + public final Callback mCallback; + public ConnectedMessagePayload(IBinder service, Callback callback) { + mService = service; + mCallback = callback; + } + } + + private class MyServiceConnection implements ServiceConnection { + private final String mAuthenticatorType; + private IBinder mService = null; + + public MyServiceConnection(String authenticatorType) { + mAuthenticatorType = authenticatorType; + } + + public void onServiceConnected(ComponentName name, IBinder service) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "onServiceConnected for account type " + mAuthenticatorType); + } + // post a message for each service user to tell them that the service is connected + synchronized (mServiceConnections) { + mService = service; + for (Callback callback : mServiceUsers.get(mAuthenticatorType)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "the service became connected, scheduling a connected " + + "message for " + mAuthenticatorType); + } + scheduleCallbackConnectedMessage(callback); + } + } + } + + private void scheduleCallbackConnectedMessage(Callback callback) { + final ConnectedMessagePayload payload = + new ConnectedMessagePayload(mService, callback); + mHandler.obtainMessage(mMessageWhatConnected, payload).sendToTarget(); + } + + public void onServiceDisconnected(ComponentName name) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "onServiceDisconnected for account type " + mAuthenticatorType); + } + // post a message for each service user to tell them that the service is disconnected, + // and unbind from the service. + synchronized (mServiceConnections) { + for (Callback callback : mServiceUsers.get(mAuthenticatorType)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "the service became disconnected, scheduling a " + + "disconnected message for " + + mAuthenticatorType); + } + mHandler.obtainMessage(mMessageWhatDisconnected, callback).sendToTarget(); + } + unbindFromService(mAuthenticatorType); + } + } + } + + boolean handleMessage(Message message) { + if (message.what == mMessageWhatConnected) { + ConnectedMessagePayload payload = (ConnectedMessagePayload)message.obj; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "notifying callback " + payload.mCallback + " that it is connected"); + } + payload.mCallback.onConnected(payload.mService); + return true; + } else if (message.what == mMessageWhatDisconnected) { + Callback callback = (Callback)message.obj; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "notifying callback " + callback + " that it is disconnected"); + } + callback.onDisconnected(); + return true; + } else { + return false; + } + } +} diff --git a/core/java/android/accounts/AuthenticatorDescription.aidl b/core/java/android/accounts/AuthenticatorDescription.aidl new file mode 100644 index 0000000..136361c --- /dev/null +++ b/core/java/android/accounts/AuthenticatorDescription.aidl @@ -0,0 +1,19 @@ +/* + * Copyright (C) 2009 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.accounts; + +parcelable AuthenticatorDescription; diff --git a/core/java/android/accounts/AuthenticatorDescription.java b/core/java/android/accounts/AuthenticatorDescription.java new file mode 100644 index 0000000..f896bf8 --- /dev/null +++ b/core/java/android/accounts/AuthenticatorDescription.java @@ -0,0 +1,69 @@ +package android.accounts; + +import android.os.Parcelable; +import android.os.Parcel; + +public class AuthenticatorDescription implements Parcelable { + final public String type; + final public int labelId; + final public int iconId; + final public String packageName; + + public AuthenticatorDescription(String type, String packageName, int labelId, int iconId) { + this.type = type; + this.packageName = packageName; + this.labelId = labelId; + this.iconId = iconId; + } + + public static AuthenticatorDescription newKey(String type) { + return new AuthenticatorDescription(type); + } + + private AuthenticatorDescription(String type) { + this.type = type; + this.packageName = null; + this.labelId = 0; + this.iconId = 0; + } + + private AuthenticatorDescription(Parcel source) { + this.type = source.readString(); + this.packageName = source.readString(); + this.labelId = source.readInt(); + this.iconId = source.readInt(); + } + + public int describeContents() { + return 0; + } + + public int hashCode() { + return type.hashCode(); + } + + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof AuthenticatorDescription)) return false; + final AuthenticatorDescription other = (AuthenticatorDescription) o; + return type.equals(other.type); + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeString(type); + dest.writeString(packageName); + dest.writeInt(labelId); + dest.writeInt(iconId); + } + + public static final Creator<AuthenticatorDescription> CREATOR = + new Creator<AuthenticatorDescription>() { + public AuthenticatorDescription createFromParcel(Parcel source) { + return new AuthenticatorDescription(source); + } + + public AuthenticatorDescription[] newArray(int size) { + return new AuthenticatorDescription[size]; + } + }; +} diff --git a/core/java/android/accounts/AuthenticatorException.java b/core/java/android/accounts/AuthenticatorException.java new file mode 100644 index 0000000..4023494 --- /dev/null +++ b/core/java/android/accounts/AuthenticatorException.java @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2009 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.accounts; + +public class AuthenticatorException extends Exception { + public AuthenticatorException() { + super(); + } + public AuthenticatorException(String message) { + super(message); + } + public AuthenticatorException(String message, Throwable cause) { + super(message, cause); + } + public AuthenticatorException(Throwable cause) { + super(cause); + } +} diff --git a/core/java/android/accounts/ChooseAccountActivity.java b/core/java/android/accounts/ChooseAccountActivity.java new file mode 100644 index 0000000..bd6f205 --- /dev/null +++ b/core/java/android/accounts/ChooseAccountActivity.java @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.app.ListActivity; +import android.os.Bundle; +import android.os.Parcelable; +import android.widget.ArrayAdapter; +import android.widget.ListView; +import android.view.View; +import android.util.Log; + +public class ChooseAccountActivity extends ListActivity { + private static final String TAG = "AccountManager"; + private Parcelable[] mAccounts = null; + private AccountManagerResponse mAccountManagerResponse = null; + private Bundle mResult; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + if (savedInstanceState == null) { + mAccounts = getIntent().getParcelableArrayExtra(Constants.ACCOUNTS_KEY); + mAccountManagerResponse = + getIntent().getParcelableExtra(Constants.ACCOUNT_MANAGER_RESPONSE_KEY); + } else { + mAccounts = savedInstanceState.getParcelableArray(Constants.ACCOUNTS_KEY); + mAccountManagerResponse = + savedInstanceState.getParcelable(Constants.ACCOUNT_MANAGER_RESPONSE_KEY); + } + + String[] mAccountNames = new String[mAccounts.length]; + for (int i = 0; i < mAccounts.length; i++) { + mAccountNames[i] = ((Account) mAccounts[i]).name; + } + + // Use an existing ListAdapter that will map an array + // of strings to TextViews + setListAdapter(new ArrayAdapter<String>(this, + android.R.layout.simple_list_item_1, mAccountNames)); + getListView().setTextFilterEnabled(true); + } + + protected void onListItemClick(ListView l, View v, int position, long id) { + Account account = (Account) mAccounts[position]; + Log.d(TAG, "selected account " + account); + Bundle bundle = new Bundle(); + bundle.putString(Constants.ACCOUNT_NAME_KEY, account.name); + bundle.putString(Constants.ACCOUNT_TYPE_KEY, account.type); + mResult = bundle; + finish(); + } + + public void finish() { + if (mAccountManagerResponse != null) { + if (mResult != null) { + mAccountManagerResponse.onResult(mResult); + } else { + mAccountManagerResponse.onError(Constants.ERROR_CODE_CANCELED, "canceled"); + } + } + super.finish(); + } +} diff --git a/core/java/android/accounts/Constants.java b/core/java/android/accounts/Constants.java new file mode 100644 index 0000000..8736f41 --- /dev/null +++ b/core/java/android/accounts/Constants.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2009 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.accounts; + +public class Constants { + // this should never be instantiated + private Constants() {} + + public static final int ERROR_CODE_REMOTE_EXCEPTION = 1; + public static final int ERROR_CODE_NETWORK_ERROR = 3; + public static final int ERROR_CODE_CANCELED = 4; + public static final int ERROR_CODE_INVALID_RESPONSE = 5; + public static final int ERROR_CODE_UNSUPPORTED_OPERATION = 6; + public static final int ERROR_CODE_BAD_ARGUMENTS = 7; + public static final int ERROR_CODE_BAD_REQUEST = 8; + + public static final String ACCOUNTS_KEY = "accounts"; + public static final String AUTHENTICATOR_TYPES_KEY = "authenticator_types"; + public static final String USERDATA_KEY = "userdata"; + public static final String AUTHTOKEN_KEY = "authtoken"; + public static final String PASSWORD_KEY = "password"; + public static final String ACCOUNT_NAME_KEY = "authAccount"; + public static final String ACCOUNT_TYPE_KEY = "accountType"; + public static final String ERROR_CODE_KEY = "errorCode"; + public static final String ERROR_MESSAGE_KEY = "errorMessage"; + public static final String INTENT_KEY = "intent"; + public static final String BOOLEAN_RESULT_KEY = "booleanResult"; + public static final String ACCOUNT_AUTHENTICATOR_RESPONSE_KEY = "accountAuthenticatorResponse"; + public static final String ACCOUNT_MANAGER_RESPONSE_KEY = "accountManagerResponse"; + public static final String AUTH_FAILED_MESSAGE_KEY = "authFailedMessage"; + public static final String AUTH_TOKEN_LABEL_KEY = "authTokenLabelKey"; + + public static final String AUTHENTICATOR_INTENT_ACTION = + "android.accounts.AccountAuthenticator"; + public static final String AUTHENTICATOR_META_DATA_NAME = + "android.accounts.AccountAuthenticator"; + public static final String AUTHENTICATOR_ATTRIBUTES_NAME = "account-authenticator"; + + /** + * Action sent as a broadcast Intent by the AccountsService + * when accounts are added to and/or removed from the device's + * database, or when the primary account is changed. + */ + public static final String LOGIN_ACCOUNTS_CHANGED_ACTION = + "android.accounts.LOGIN_ACCOUNTS_CHANGED"; +} diff --git a/core/java/android/accounts/GrantCredentialsPermissionActivity.java b/core/java/android/accounts/GrantCredentialsPermissionActivity.java new file mode 100644 index 0000000..e06afb4 --- /dev/null +++ b/core/java/android/accounts/GrantCredentialsPermissionActivity.java @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.app.Activity; +import android.os.Bundle; +import android.widget.TextView; +import android.widget.ArrayAdapter; +import android.widget.ListView; +import android.view.View; +import android.view.LayoutInflater; +import android.view.ViewGroup; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import com.android.internal.R; + +/** + * @hide + */ +public class GrantCredentialsPermissionActivity extends Activity implements View.OnClickListener { + public static final String EXTRAS_ACCOUNT = "account"; + public static final String EXTRAS_AUTH_TOKEN_LABEL = "authTokenLabel"; + public static final String EXTRAS_AUTH_TOKEN_TYPE = "authTokenType"; + public static final String EXTRAS_RESPONSE = "response"; + public static final String EXTRAS_ACCOUNT_TYPE_LABEL = "accountTypeLabel"; + public static final String EXTRAS_PACKAGES = "application"; + public static final String EXTRAS_REQUESTING_UID = "uid"; + private Account mAccount; + private String mAuthTokenType; + private int mUid; + private Bundle mResultBundle = null; + + protected void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + getWindow().setContentView(R.layout.grant_credentials_permission); + mAccount = getIntent().getExtras().getParcelable(EXTRAS_ACCOUNT); + mAuthTokenType = getIntent().getExtras().getString(EXTRAS_AUTH_TOKEN_TYPE); + mUid = getIntent().getExtras().getInt(EXTRAS_REQUESTING_UID); + final String accountTypeLabel = + getIntent().getExtras().getString(EXTRAS_ACCOUNT_TYPE_LABEL); + final String[] packages = getIntent().getExtras().getStringArray(EXTRAS_PACKAGES); + + findViewById(R.id.allow).setOnClickListener(this); + findViewById(R.id.deny).setOnClickListener(this); + + TextView messageView = (TextView) getWindow().findViewById(R.id.message); + String authTokenLabel = getIntent().getExtras().getString(EXTRAS_AUTH_TOKEN_LABEL); + if (authTokenLabel.length() == 0) { + CharSequence grantCredentialsPermissionFormat = getResources().getText( + R.string.grant_credentials_permission_message_desc); + messageView.setText(String.format(grantCredentialsPermissionFormat.toString(), + mAccount.name, accountTypeLabel)); + } else { + CharSequence grantCredentialsPermissionFormat = getResources().getText( + R.string.grant_credentials_permission_message_with_authtokenlabel_desc); + messageView.setText(String.format(grantCredentialsPermissionFormat.toString(), + authTokenLabel, mAccount.name, accountTypeLabel)); + } + + String[] packageLabels = new String[packages.length]; + final PackageManager pm = getPackageManager(); + for (int i = 0; i < packages.length; i++) { + try { + packageLabels[i] = + pm.getApplicationLabel(pm.getApplicationInfo(packages[i], 0)).toString(); + } catch (PackageManager.NameNotFoundException e) { + packageLabels[i] = packages[i]; + } + } + ((ListView) findViewById(R.id.packages_list)).setAdapter( + new PackagesArrayAdapter(this, packageLabels)); + } + + public void onClick(View v) { + switch (v.getId()) { + case R.id.allow: + AccountManagerService.getSingleton().grantAppPermission(mAccount, mAuthTokenType, + mUid); + Intent result = new Intent(); + result.putExtra("retry", true); + setResult(RESULT_OK, result); + setAccountAuthenticatorResult(result.getExtras()); + break; + + case R.id.deny: + AccountManagerService.getSingleton().revokeAppPermission(mAccount, mAuthTokenType, + mUid); + setResult(RESULT_CANCELED); + break; + } + finish(); + } + + public final void setAccountAuthenticatorResult(Bundle result) { + mResultBundle = result; + } + + /** + * Sends the result or a Constants.ERROR_CODE_CANCELED error if a result isn't present. + */ + public void finish() { + Intent intent = getIntent(); + AccountAuthenticatorResponse accountAuthenticatorResponse = + intent.getParcelableExtra(EXTRAS_RESPONSE); + if (accountAuthenticatorResponse != null) { + // send the result bundle back if set, otherwise send an error. + if (mResultBundle != null) { + accountAuthenticatorResponse.onResult(mResultBundle); + } else { + accountAuthenticatorResponse.onError(Constants.ERROR_CODE_CANCELED, "canceled"); + } + } + super.finish(); + } + + private static class PackagesArrayAdapter extends ArrayAdapter<String> { + protected LayoutInflater mInflater; + private static final int mResource = R.layout.simple_list_item_1; + + public PackagesArrayAdapter(Context context, String[] items) { + super(context, mResource, items); + mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); + } + + static class ViewHolder { + TextView label; + } + + @Override + public View getView(int position, View convertView, ViewGroup parent) { + // A ViewHolder keeps references to children views to avoid unneccessary calls + // to findViewById() on each row. + ViewHolder holder; + + // When convertView is not null, we can reuse it directly, there is no need + // to reinflate it. We only inflate a new View when the convertView supplied + // by ListView is null. + if (convertView == null) { + convertView = mInflater.inflate(mResource, null); + + // Creates a ViewHolder and store references to the two children views + // we want to bind data to. + holder = new ViewHolder(); + holder.label = (TextView) convertView.findViewById(R.id.text1); + + convertView.setTag(holder); + } else { + // Get the ViewHolder back to get fast access to the TextView + // and the ImageView. + holder = (ViewHolder) convertView.getTag(); + } + + holder.label.setText(getItem(position)); + + return convertView; + } + } +} diff --git a/core/java/android/accounts/IAccountAuthenticator.aidl b/core/java/android/accounts/IAccountAuthenticator.aidl new file mode 100644 index 0000000..48f053c --- /dev/null +++ b/core/java/android/accounts/IAccountAuthenticator.aidl @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.accounts.IAccountAuthenticatorResponse; +import android.accounts.Account; +import android.os.Bundle; + +/** + * Service that allows the interaction with an authentication server. + */ +oneway interface IAccountAuthenticator { + /** + * prompts the user for account information and adds the result to the IAccountManager + */ + void addAccount(in IAccountAuthenticatorResponse response, String accountType, + String authTokenType, in String[] requiredFeatures, in Bundle options); + + /** + * Checks that the account/password combination is valid. + * @deprecated + */ + void confirmPassword(in IAccountAuthenticatorResponse response, + in Account account, String password); + + /** + * prompts the user for the credentials of the account + */ + void confirmCredentials(in IAccountAuthenticatorResponse response, in Account account); + + /** + * gets the password by either prompting the user or querying the IAccountManager + */ + void getAuthToken(in IAccountAuthenticatorResponse response, in Account account, + String authTokenType, in Bundle options); + + /** + * Gets the user-visible label of the given authtoken type. + */ + void getAuthTokenLabel(in IAccountAuthenticatorResponse response, String authTokenType); + + /** + * prompts the user for a new password and writes it to the IAccountManager + */ + void updateCredentials(in IAccountAuthenticatorResponse response, in Account account, + String authTokenType, in Bundle options); + + /** + * launches an activity that lets the user edit and set the properties for an authenticator + */ + void editProperties(in IAccountAuthenticatorResponse response, String accountType); + + /** + * returns a Bundle where the boolean value BOOLEAN_RESULT_KEY is set if the account has the + * specified features + */ + void hasFeatures(in IAccountAuthenticatorResponse response, in Account account, + in String[] features); + + /** + * Gets whether or not the account is allowed to be removed. + */ + void getAccountRemovalAllowed(in IAccountAuthenticatorResponse response, in Account account); +} diff --git a/core/java/android/accounts/IAccountAuthenticatorResponse.aidl b/core/java/android/accounts/IAccountAuthenticatorResponse.aidl new file mode 100644 index 0000000..a9ac2f1 --- /dev/null +++ b/core/java/android/accounts/IAccountAuthenticatorResponse.aidl @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2009 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.accounts; +import android.os.Bundle; + +/** + * The interface used to return responses from an {@link IAccountAuthenticator} + */ +oneway interface IAccountAuthenticatorResponse { + void onResult(in Bundle value); + void onRequestContinued(); + void onError(int errorCode, String errorMessage); +} diff --git a/core/java/android/accounts/IAccountManager.aidl b/core/java/android/accounts/IAccountManager.aidl new file mode 100644 index 0000000..411952b --- /dev/null +++ b/core/java/android/accounts/IAccountManager.aidl @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 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.accounts; + +import android.accounts.IAccountManagerResponse; +import android.accounts.Account; +import android.accounts.AuthenticatorDescription; +import android.os.Bundle; + + +/** + * Central application service that provides account management. + * @hide + */ +interface IAccountManager { + String getPassword(in Account account); + String getUserData(in Account account, String key); + AuthenticatorDescription[] getAuthenticatorTypes(); + Account[] getAccounts(String accountType); + void getAccountsByFeatures(in IAccountManagerResponse response, String accountType, in String[] features); + boolean addAccount(in Account account, String password, in Bundle extras); + void removeAccount(in IAccountManagerResponse response, in Account account); + void invalidateAuthToken(String accountType, String authToken); + String peekAuthToken(in Account account, String authTokenType); + void setAuthToken(in Account account, String authTokenType, String authToken); + void setPassword(in Account account, String password); + void clearPassword(in Account account); + void setUserData(in Account account, String key, String value); + + void getAuthToken(in IAccountManagerResponse response, in Account account, + String authTokenType, boolean notifyOnAuthFailure, boolean expectActivityLaunch, + in Bundle options); + void addAcount(in IAccountManagerResponse response, String accountType, + String authTokenType, in String[] requiredFeatures, boolean expectActivityLaunch, + in Bundle options); + void updateCredentials(in IAccountManagerResponse response, in Account account, + String authTokenType, boolean expectActivityLaunch, in Bundle options); + void editProperties(in IAccountManagerResponse response, String accountType, + boolean expectActivityLaunch); + void confirmCredentials(in IAccountManagerResponse response, in Account account, + boolean expectActivityLaunch); + + /* + * @deprecated + */ + void confirmPassword(in IAccountManagerResponse response, in Account account, + String password); +} diff --git a/core/java/android/accounts/IAccountManagerResponse.aidl b/core/java/android/accounts/IAccountManagerResponse.aidl new file mode 100644 index 0000000..ca1203d --- /dev/null +++ b/core/java/android/accounts/IAccountManagerResponse.aidl @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2009 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.accounts; +import android.os.Bundle; + +/** + * The interface used to return responses for asynchronous calls to the {@link IAccountManager} + * @hide + */ +oneway interface IAccountManagerResponse { + void onResult(in Bundle value); + void onError(int errorCode, String errorMessage); +} diff --git a/core/java/android/accounts/IAccountsService.aidl b/core/java/android/accounts/IAccountsService.aidl deleted file mode 100644 index dda513c..0000000 --- a/core/java/android/accounts/IAccountsService.aidl +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (C) 2008 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.accounts; - -/** - * Central application service that allows querying the list of accounts. - */ -interface IAccountsService { - /** - * Gets the list of Accounts the user has previously logged - * in to. Accounts are of the form "username@domain". - * <p> - * This method will return an empty array if the device doesn't - * know about any accounts (yet). - * - * @return The accounts. The array will be zero-length if the - * AccountsService doesn't know about any accounts yet. - */ - String[] getAccounts(); - - /** - * This is an interim solution for bypassing a forgotten gesture on the - * unlock screen (it is hidden, please make sure it stays this way!). This - * will be *removed* when the unlock screen design supports additional - * authenticators. - * <p> - * The user will be presented with username and password fields that are - * called as parameters to this method. If true is returned, the user is - * able to define a new gesture and get back into the system. If false, the - * user can try again. - * - * @param username The username entered. - * @param password The password entered. - * @return Whether to allow the user to bypass the lock screen and define a - * new gesture. - * @hide (The package is already hidden, but just in case someone - * unhides that, this should not be revealed.) - */ - boolean shouldUnlock(String username, String password); -} diff --git a/core/java/android/accounts/NetworkErrorException.java b/core/java/android/accounts/NetworkErrorException.java new file mode 100644 index 0000000..f855cc8 --- /dev/null +++ b/core/java/android/accounts/NetworkErrorException.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2009 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.accounts; + +public class NetworkErrorException extends Exception { + public NetworkErrorException() { + super(); + } + public NetworkErrorException(String message) { + super(message); + } + public NetworkErrorException(String message, Throwable cause) { + super(message, cause); + } + public NetworkErrorException(Throwable cause) { + super(cause); + } +}
\ No newline at end of file diff --git a/core/java/android/accounts/AccountMonitorListener.java b/core/java/android/accounts/OnAccountsUpdatedListener.java index d0bd9a9..bd249d0 100644 --- a/core/java/android/accounts/AccountMonitorListener.java +++ b/core/java/android/accounts/OnAccountsUpdatedListener.java @@ -19,11 +19,11 @@ package android.accounts; /** * An interface that contains the callback used by the AccountMonitor */ -public interface AccountMonitorListener { +public interface OnAccountsUpdatedListener { /** * This invoked when the AccountMonitor starts up and whenever the account * set changes. - * @param currentAccounts the current accounts + * @param accounts the current accounts */ - void onAccountsUpdated(String[] currentAccounts); + void onAccountsUpdated(Account[] accounts); } diff --git a/core/java/android/accounts/OperationCanceledException.java b/core/java/android/accounts/OperationCanceledException.java new file mode 100644 index 0000000..2f2c164 --- /dev/null +++ b/core/java/android/accounts/OperationCanceledException.java @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2009 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.accounts; + +public class OperationCanceledException extends Exception { + public OperationCanceledException() { + super(); + } + public OperationCanceledException(String message) { + super(message); + } + public OperationCanceledException(String message, Throwable cause) { + super(message, cause); + } + public OperationCanceledException(Throwable cause) { + super(cause); + } +} diff --git a/core/java/android/accounts/package.html b/core/java/android/accounts/package.html deleted file mode 100755 index c9f96a6..0000000 --- a/core/java/android/accounts/package.html +++ /dev/null @@ -1,5 +0,0 @@ -<body> - -{@hide} - -</body> diff --git a/core/java/android/app/Activity.java b/core/java/android/app/Activity.java index f2905a7..80d7285 100644 --- a/core/java/android/app/Activity.java +++ b/core/java/android/app/Activity.java @@ -1930,11 +1930,32 @@ public class Activity extends ContextThemeWrapper * * @see #hasWindowFocus() * @see #onResume + * @see View#onWindowFocusChanged(boolean) */ public void onWindowFocusChanged(boolean hasFocus) { } /** + * Called when the main window associated with the activity has been + * attached to the window manager. + * See {@link View#onAttachedToWindow() View.onAttachedToWindow()} + * for more information. + * @see View#onAttachedToWindow + */ + public void onAttachedToWindow() { + } + + /** + * Called when the main window associated with the activity has been + * detached from the window manager. + * See {@link View#onDetachedFromWindow() View.onDetachedFromWindow()} + * for more information. + * @see View#onDetachedFromWindow + */ + public void onDetachedFromWindow() { + } + + /** * Returns true if this activity's <em>main</em> window currently has window focus. * Note that this is not the same as the view itself having focus. * @@ -2394,6 +2415,7 @@ public class Activity extends ContextThemeWrapper * * @param id The id of the managed dialog. * + * @see Dialog * @see #onCreateDialog(int) * @see #onPrepareDialog(int, Dialog) * @see #dismissDialog(int) @@ -2535,6 +2557,25 @@ public class Activity extends ContextThemeWrapper } /** + * Similar to {@link #startSearch}, but actually fires off the search query after invoking + * the search dialog. Made available for testing purposes. + * + * @param query The query to trigger. If empty, the request will be ignored. + * @param appSearchData An application can insert application-specific + * context here, in order to improve quality or specificity of its own + * searches. This data will be returned with SEARCH intent(s). Null if + * no extra data is required. + * @param globalSearch If false, this will only launch the search that has been specifically + * defined by the application (which is usually defined as a local search). If no default + * search is defined in the current application or activity, no search will be launched. + * If true, this will always launch a platform-global (e.g. web-based) search instead. + */ + public void triggerSearch(String query, Bundle appSearchData, boolean globalSearch) { + ensureSearchManager(); + mSearchManager.triggerSearch(query, getComponentName(), appSearchData, globalSearch); + } + + /** * Request that key events come to this activity. Use this if your * activity has no views with focus, but the activity still wants * a chance to process key events. @@ -3255,7 +3296,7 @@ public class Activity extends ContextThemeWrapper throw new IllegalArgumentException("no ident"); } } - mSearchManager.setIdent(ident); + mSearchManager.setIdent(ident, getComponentName()); } @Override diff --git a/core/java/android/app/ActivityManagerNative.java b/core/java/android/app/ActivityManagerNative.java index 447512a..4dc23c0 100644 --- a/core/java/android/app/ActivityManagerNative.java +++ b/core/java/android/app/ActivityManagerNative.java @@ -39,9 +39,6 @@ import android.text.TextUtils; import android.util.Config; import android.util.Log; -import java.io.FileNotFoundException; -import java.io.FileDescriptor; -import java.io.IOException; import java.util.ArrayList; import java.util.List; @@ -551,8 +548,13 @@ public abstract class ActivityManagerNative extends Binder implements IActivityM data.enforceInterface(IActivityManager.descriptor); ComponentName className = ComponentName.readFromParcel(data); IBinder token = data.readStrongBinder(); - boolean isForeground = data.readInt() != 0; - setServiceForeground(className, token, isForeground); + int id = data.readInt(); + Notification notification = null; + if (data.readInt() != 0) { + notification = Notification.CREATOR.createFromParcel(data); + } + boolean removeNotification = data.readInt() != 0; + setServiceForeground(className, token, id, notification, removeNotification); reply.writeNoException(); return true; } @@ -1664,13 +1666,20 @@ class ActivityManagerProxy implements IActivityManager return res; } public void setServiceForeground(ComponentName className, IBinder token, - boolean isForeground) throws RemoteException { + int id, Notification notification, boolean removeNotification) throws RemoteException { Parcel data = Parcel.obtain(); Parcel reply = Parcel.obtain(); data.writeInterfaceToken(IActivityManager.descriptor); ComponentName.writeToParcel(className, data); data.writeStrongBinder(token); - data.writeInt(isForeground ? 1 : 0); + data.writeInt(id); + if (notification != null) { + data.writeInt(1); + notification.writeToParcel(data, 0); + } else { + data.writeInt(0); + } + data.writeInt(removeNotification ? 1 : 0); mRemote.transact(SET_SERVICE_FOREGROUND_TRANSACTION, data, reply, 0); reply.readException(); data.recycle(); diff --git a/core/java/android/app/ApplicationContext.java b/core/java/android/app/ApplicationContext.java index 92929ea..7c0d1d3 100644 --- a/core/java/android/app/ApplicationContext.java +++ b/core/java/android/app/ApplicationContext.java @@ -22,8 +22,8 @@ import com.google.android.collect.Maps; import org.xmlpull.v1.XmlPullParserException; -import android.bluetooth.BluetoothDevice; -import android.bluetooth.IBluetoothDevice; +import android.bluetooth.BluetoothAdapter; +import android.bluetooth.IBluetooth; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.ContentResolver; @@ -59,8 +59,6 @@ import android.content.res.XmlResourceParser; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteDatabase.CursorFactory; import android.graphics.Bitmap; -import android.graphics.BitmapFactory; -import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; import android.hardware.SensorManager; import android.location.ILocationManager; @@ -78,7 +76,6 @@ import android.os.Handler; import android.os.IBinder; import android.os.IPowerManager; import android.os.Looper; -import android.os.ParcelFileDescriptor; import android.os.PowerManager; import android.os.Process; import android.os.RemoteException; @@ -88,14 +85,14 @@ import android.os.FileUtils.FileStatus; import android.telephony.TelephonyManager; import android.text.ClipboardManager; import android.util.AndroidRuntimeException; -import android.util.DisplayMetrics; import android.util.Log; import android.view.ContextThemeWrapper; -import android.view.Display; import android.view.LayoutInflater; import android.view.WindowManagerImpl; import android.view.accessibility.AccessibilityManager; import android.view.inputmethod.InputMethodManager; +import android.accounts.AccountManager; +import android.accounts.IAccountManager; import java.io.File; import java.io.FileInputStream; @@ -155,14 +152,12 @@ class ApplicationContext extends Context { private final static boolean DEBUG_ICONS = false; private static final Object sSync = new Object(); + private static AccountManager sAccountManager; private static AlarmManager sAlarmManager; private static PowerManager sPowerManager; private static ConnectivityManager sConnectivityManager; private static WifiManager sWifiManager; private static LocationManager sLocationManager; - private static boolean sIsBluetoothDeviceCached = false; - private static BluetoothDevice sBluetoothDevice; - private static IWallpaperService sWallpaperService; private static final HashMap<File, SharedPreferencesImpl> sSharedPrefs = new HashMap<File, SharedPreferencesImpl>(); @@ -177,8 +172,8 @@ class ApplicationContext extends Context { private Resources.Theme mTheme = null; private PackageManager mPackageManager; private NotificationManager mNotificationManager = null; - private AccessibilityManager mAccessibilityManager = null; private ActivityManager mActivityManager = null; + private WallpaperManager mWallpaperManager = null; private Context mReceiverRestrictedContext = null; private SearchManager mSearchManager = null; private SensorManager mSensorManager = null; @@ -187,6 +182,8 @@ class ApplicationContext extends Context { private StatusBarManager mStatusBarManager = null; private TelephonyManager mTelephonyManager = null; private ClipboardManager mClipboardManager = null; + private boolean mIsBluetoothAdapterCached = false; + private BluetoothAdapter mBluetoothAdapter; private boolean mRestricted; private final Object mSync = new Object(); @@ -198,9 +195,6 @@ class ApplicationContext extends Context { private File mCacheDir; - private Drawable mWallpaper; - private IWallpaperServiceCallback mWallpaperCallback = null; - private static long sInstanceCount = 0; private static final String[] EMPTY_FILE_LIST = {}; @@ -520,127 +514,37 @@ class ApplicationContext extends Context { @Override public Drawable getWallpaper() { - Drawable dr = peekWallpaper(); - return dr != null ? dr : getResources().getDrawable( - com.android.internal.R.drawable.default_wallpaper); + return getWallpaperManager().getDrawable(); } @Override - public synchronized Drawable peekWallpaper() { - if (mWallpaper != null) { - return mWallpaper; - } - mWallpaperCallback = new WallpaperCallback(this); - mWallpaper = getCurrentWallpaperLocked(); - return mWallpaper; - } - - private Drawable getCurrentWallpaperLocked() { - try { - ParcelFileDescriptor fd = getWallpaperService().getWallpaper(mWallpaperCallback); - if (fd != null) { - Bitmap bm = BitmapFactory.decodeFileDescriptor(fd.getFileDescriptor()); - if (bm != null) { - // For now clear the density until we figure out how - // to deal with it for wallpapers. - bm.setDensity(0); - return new BitmapDrawable(getResources(), bm); - } - } - } catch (RemoteException e) { - } - return null; + public Drawable peekWallpaper() { + return getWallpaperManager().peekDrawable(); } @Override public int getWallpaperDesiredMinimumWidth() { - try { - return getWallpaperService().getWidthHint(); - } catch (RemoteException e) { - // Shouldn't happen! - return 0; - } + return getWallpaperManager().getDesiredMinimumWidth(); } @Override public int getWallpaperDesiredMinimumHeight() { - try { - return getWallpaperService().getHeightHint(); - } catch (RemoteException e) { - // Shouldn't happen! - return 0; - } + return getWallpaperManager().getDesiredMinimumHeight(); } @Override public void setWallpaper(Bitmap bitmap) throws IOException { - try { - ParcelFileDescriptor fd = getWallpaperService().setWallpaper(); - if (fd == null) { - return; - } - FileOutputStream fos = null; - try { - fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); - bitmap.compress(Bitmap.CompressFormat.PNG, 90, fos); - } finally { - if (fos != null) { - fos.close(); - } - } - } catch (RemoteException e) { - } + getWallpaperManager().setBitmap(bitmap); } @Override public void setWallpaper(InputStream data) throws IOException { - try { - ParcelFileDescriptor fd = getWallpaperService().setWallpaper(); - if (fd == null) { - return; - } - FileOutputStream fos = null; - try { - fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); - setWallpaper(data, fos); - } finally { - if (fos != null) { - fos.close(); - } - } - } catch (RemoteException e) { - } - } - - private void setWallpaper(InputStream data, FileOutputStream fos) - throws IOException { - byte[] buffer = new byte[32768]; - int amt; - while ((amt=data.read(buffer)) > 0) { - fos.write(buffer, 0, amt); - } + getWallpaperManager().setStream(data); } @Override public void clearWallpaper() throws IOException { - try { - /* Set the wallpaper to the default values */ - ParcelFileDescriptor fd = getWallpaperService().setWallpaper(); - if (fd != null) { - FileOutputStream fos = null; - try { - fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); - setWallpaper(getResources().openRawResource( - com.android.internal.R.drawable.default_wallpaper), - fos); - } finally { - if (fos != null) { - fos.close(); - } - } - } - } catch (RemoteException e) { - } + getWallpaperManager().clear(); } @Override @@ -901,8 +805,12 @@ class ApplicationContext extends Context { } } else if (ACTIVITY_SERVICE.equals(name)) { return getActivityManager(); + } else if (INPUT_METHOD_SERVICE.equals(name)) { + return InputMethodManager.getInstance(this); } else if (ALARM_SERVICE.equals(name)) { return getAlarmManager(); + } else if (ACCOUNT_SERVICE.equals(name)) { + return getAccountManager(); } else if (POWER_SERVICE.equals(name)) { return getPowerManager(); } else if (CONNECTIVITY_SERVICE.equals(name)) { @@ -919,10 +827,10 @@ class ApplicationContext extends Context { return getLocationManager(); } else if (SEARCH_SERVICE.equals(name)) { return getSearchManager(); - } else if ( SENSOR_SERVICE.equals(name)) { + } else if (SENSOR_SERVICE.equals(name)) { return getSensorManager(); } else if (BLUETOOTH_SERVICE.equals(name)) { - return getBluetoothDevice(); + return getBluetoothAdapter(); } else if (VIBRATOR_SERVICE.equals(name)) { return getVibrator(); } else if (STATUS_BAR_SERVICE.equals(name)) { @@ -938,13 +846,24 @@ class ApplicationContext extends Context { return getTelephonyManager(); } else if (CLIPBOARD_SERVICE.equals(name)) { return getClipboardManager(); - } else if (INPUT_METHOD_SERVICE.equals(name)) { - return InputMethodManager.getInstance(this); + } else if (WALLPAPER_SERVICE.equals(name)) { + return getWallpaperManager(); } return null; } + private AccountManager getAccountManager() { + synchronized (sSync) { + if (sAccountManager == null) { + IBinder b = ServiceManager.getService(ACCOUNT_SERVICE); + IAccountManager service = IAccountManager.Stub.asInterface(b); + sAccountManager = new AccountManager(this, service); + } + } + return sAccountManager; + } + private ActivityManager getActivityManager() { synchronized (mSync) { if (mActivityManager == null) { @@ -1001,8 +920,7 @@ class ApplicationContext extends Context { return sWifiManager; } - private NotificationManager getNotificationManager() - { + private NotificationManager getNotificationManager() { synchronized (mSync) { if (mNotificationManager == null) { mNotificationManager = new NotificationManager( @@ -1013,6 +931,16 @@ class ApplicationContext extends Context { return mNotificationManager; } + private WallpaperManager getWallpaperManager() { + synchronized (mSync) { + if (mWallpaperManager == null) { + mWallpaperManager = new WallpaperManager(getOuterContext(), + mMainThread.getHandler()); + } + } + return mWallpaperManager; + } + private TelephonyManager getTelephonyManager() { synchronized (mSync) { if (mTelephonyManager == null) { @@ -1052,21 +980,16 @@ class ApplicationContext extends Context { return mSearchManager; } - private BluetoothDevice getBluetoothDevice() { - if (sIsBluetoothDeviceCached) { - return sBluetoothDevice; - } - synchronized (sSync) { + private synchronized BluetoothAdapter getBluetoothAdapter() { + if (!mIsBluetoothAdapterCached) { + mIsBluetoothAdapterCached = true; IBinder b = ServiceManager.getService(BLUETOOTH_SERVICE); - if (b == null) { - sBluetoothDevice = null; - } else { - IBluetoothDevice service = IBluetoothDevice.Stub.asInterface(b); - sBluetoothDevice = new BluetoothDevice(service); + if (b != null) { + IBluetooth service = IBluetooth.Stub.asInterface(b); + mBluetoothAdapter = new BluetoothAdapter(service); } - sIsBluetoothDeviceCached = true; } - return sBluetoothDevice; + return mBluetoothAdapter; } private SensorManager getSensorManager() { @@ -1087,16 +1010,6 @@ class ApplicationContext extends Context { return mVibrator; } - private IWallpaperService getWallpaperService() { - synchronized (sSync) { - if (sWallpaperService == null) { - IBinder b = ServiceManager.getService(WALLPAPER_SERVICE); - sWallpaperService = IWallpaperService.Stub.asInterface(b); - } - } - return sWallpaperService; - } - private AudioManager getAudioManager() { if (mAudioManager == null) { @@ -1746,6 +1659,15 @@ class ApplicationContext extends Context { } @Override + public int checkSignatures(int uid1, int uid2) { + try { + return mPM.checkUidSignatures(uid1, uid2); + } catch (RemoteException e) { + throw new RuntimeException("Package manager has died", e); + } + } + + @Override public String[] getPackagesForUid(int uid) { try { return mPM.getPackagesForUid(uid); @@ -2801,25 +2723,4 @@ class ApplicationContext extends Context { return false; } } - - private static class WallpaperCallback extends IWallpaperServiceCallback.Stub { - private WeakReference<ApplicationContext> mContext; - - public WallpaperCallback(ApplicationContext context) { - mContext = new WeakReference<ApplicationContext>(context); - } - - public synchronized void onWallpaperChanged() { - - /* The wallpaper has changed but we shouldn't eagerly load the - * wallpaper as that would be inefficient. Reset the cached wallpaper - * to null so if the user requests the wallpaper again then we'll - * fetch it. - */ - final ApplicationContext applicationContext = mContext.get(); - if (applicationContext != null) { - applicationContext.mWallpaper = null; - } - } - } } diff --git a/core/java/android/app/ApplicationErrorReport.java b/core/java/android/app/ApplicationErrorReport.java index 6b17236..aeae5f9 100644 --- a/core/java/android/app/ApplicationErrorReport.java +++ b/core/java/android/app/ApplicationErrorReport.java @@ -171,6 +171,11 @@ public class ApplicationErrorReport implements Parcelable { public String throwMethodName; /** + * Line number the exception was thrown from. + */ + public int throwLineNumber; + + /** * Stack trace. */ public String stackTrace; @@ -190,6 +195,7 @@ public class ApplicationErrorReport implements Parcelable { throwFileName = in.readString(); throwClassName = in.readString(); throwMethodName = in.readString(); + throwLineNumber = in.readInt(); stackTrace = in.readString(); } @@ -202,6 +208,7 @@ public class ApplicationErrorReport implements Parcelable { dest.writeString(throwFileName); dest.writeString(throwClassName); dest.writeString(throwMethodName); + dest.writeInt(throwLineNumber); dest.writeString(stackTrace); } @@ -214,6 +221,7 @@ public class ApplicationErrorReport implements Parcelable { pw.println(prefix + "throwFileName: " + throwFileName); pw.println(prefix + "throwClassName: " + throwClassName); pw.println(prefix + "throwMethodName: " + throwMethodName); + pw.println(prefix + "throwLineNumber: " + throwLineNumber); pw.println(prefix + "stackTrace: " + stackTrace); } } diff --git a/core/java/android/app/ApplicationThreadNative.java b/core/java/android/app/ApplicationThreadNative.java index a3c6325..5335239 100644 --- a/core/java/android/app/ApplicationThreadNative.java +++ b/core/java/android/app/ApplicationThreadNative.java @@ -524,7 +524,8 @@ class ApplicationThreadProxy implements IApplicationThread { data.writeInterfaceToken(IApplicationThread.descriptor); app.writeToParcel(data, 0); data.writeInt(backupMode); - mRemote.transact(SCHEDULE_CREATE_BACKUP_AGENT_TRANSACTION, data, null, 0); + mRemote.transact(SCHEDULE_CREATE_BACKUP_AGENT_TRANSACTION, data, null, + IBinder.FLAG_ONEWAY); data.recycle(); } @@ -532,7 +533,8 @@ class ApplicationThreadProxy implements IApplicationThread { Parcel data = Parcel.obtain(); data.writeInterfaceToken(IApplicationThread.descriptor); app.writeToParcel(data, 0); - mRemote.transact(SCHEDULE_DESTROY_BACKUP_AGENT_TRANSACTION, data, null, 0); + mRemote.transact(SCHEDULE_DESTROY_BACKUP_AGENT_TRANSACTION, data, null, + IBinder.FLAG_ONEWAY); data.recycle(); } diff --git a/core/java/android/app/Dialog.java b/core/java/android/app/Dialog.java index 9432755..35d1004 100644 --- a/core/java/android/app/Dialog.java +++ b/core/java/android/app/Dialog.java @@ -576,6 +576,12 @@ public class Dialog implements DialogInterface, Window.Callback, public void onWindowFocusChanged(boolean hasFocus) { } + public void onAttachedToWindow() { + } + + public void onDetachedFromWindow() { + } + /** * Called to process key events. You can override this to intercept all * key events before they are dispatched to the window. Be sure to call diff --git a/core/java/android/app/IActivityManager.java b/core/java/android/app/IActivityManager.java index f6ef549..45c202d 100644 --- a/core/java/android/app/IActivityManager.java +++ b/core/java/android/app/IActivityManager.java @@ -139,7 +139,7 @@ public interface IActivityManager extends IInterface { public boolean stopServiceToken(ComponentName className, IBinder token, int startId) throws RemoteException; public void setServiceForeground(ComponentName className, IBinder token, - boolean isForeground) throws RemoteException; + int id, Notification notification, boolean keepNotification) throws RemoteException; public int bindService(IApplicationThread caller, IBinder token, Intent service, String resolvedType, IServiceConnection connection, int flags) throws RemoteException; diff --git a/core/java/android/app/ISearchManager.aidl b/core/java/android/app/ISearchManager.aidl index bd72544..ed5dd3d 100644 --- a/core/java/android/app/ISearchManager.aidl +++ b/core/java/android/app/ISearchManager.aidl @@ -36,6 +36,17 @@ interface ISearchManager { boolean globalSearch, ISearchManagerCallback searchManagerCallback, int ident); + + void triggerSearch(in String query, + in ComponentName launchActivity, + in Bundle appSearchData, + ISearchManagerCallback searchManagerCallback, + boolean globalSearch, + int ident); + void stopSearch(); + + boolean isVisible(); + } diff --git a/core/java/android/app/IWallpaperService.aidl b/core/java/android/app/IWallpaperManager.aidl index a332b1a..7741668 100644 --- a/core/java/android/app/IWallpaperService.aidl +++ b/core/java/android/app/IWallpaperManager.aidl @@ -17,20 +17,26 @@ package android.app; import android.os.ParcelFileDescriptor; -import android.app.IWallpaperServiceCallback; +import android.app.IWallpaperManagerCallback; +import android.content.ComponentName; /** @hide */ -interface IWallpaperService { +interface IWallpaperManager { /** * Set the wallpaper. */ - ParcelFileDescriptor setWallpaper(); + ParcelFileDescriptor setWallpaper(String name); + + /** + * Set the live wallpaper. + */ + void setWallpaperComponent(in ComponentName name); /** * Get the wallpaper. */ - ParcelFileDescriptor getWallpaper(IWallpaperServiceCallback cb); + ParcelFileDescriptor getWallpaper(IWallpaperManagerCallback cb); /** * Clear the wallpaper. diff --git a/core/java/android/app/IWallpaperServiceCallback.aidl b/core/java/android/app/IWallpaperManagerCallback.aidl index 6086f40..991b2bc 100644 --- a/core/java/android/app/IWallpaperServiceCallback.aidl +++ b/core/java/android/app/IWallpaperManagerCallback.aidl @@ -17,13 +17,13 @@ package android.app; /** - * Callback interface used by IWallpaperService to send asynchronous + * Callback interface used by IWallpaperManager to send asynchronous * notifications back to its clients. Note that this is a * one-way interface so the server does not block waiting for the client. * * @hide */ -oneway interface IWallpaperServiceCallback { +oneway interface IWallpaperManagerCallback { /** * Called when the wallpaper has changed */ diff --git a/core/java/android/app/LauncherActivity.java b/core/java/android/app/LauncherActivity.java index d788c43..a83f4e8 100644 --- a/core/java/android/app/LauncherActivity.java +++ b/core/java/android/app/LauncherActivity.java @@ -18,6 +18,7 @@ package android.app; import android.content.Context; import android.content.Intent; +import android.content.pm.ComponentInfo; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.content.res.Resources; @@ -70,13 +71,15 @@ public abstract class LauncherActivity extends ListActivity { ListItem(PackageManager pm, ResolveInfo resolveInfo, IconResizer resizer) { this.resolveInfo = resolveInfo; label = resolveInfo.loadLabel(pm); - if (label == null && resolveInfo.activityInfo != null) { + ComponentInfo ci = resolveInfo.activityInfo; + if (ci == null) ci = resolveInfo.serviceInfo; + if (label == null && ci != null) { label = resolveInfo.activityInfo.name; } icon = resizer.createIconThumbnail(resolveInfo.loadIcon(pm)); - packageName = resolveInfo.activityInfo.applicationInfo.packageName; - className = resolveInfo.activityInfo.name; + packageName = ci.applicationInfo.packageName; + className = ci.name; } public ListItem() { @@ -325,8 +328,7 @@ public abstract class LauncherActivity extends ListActivity { requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS); setProgressBarIndeterminateVisibility(true); - setContentView(com.android.internal.R.layout.activity_list); - + onSetContentView(); mIntent = new Intent(getTargetIntent()); mIntent.setComponent(null); @@ -338,10 +340,17 @@ public abstract class LauncherActivity extends ListActivity { setProgressBarIndeterminateVisibility(false); } + /** + * Override to call setContentView() with your own content view to + * customize the list layout. + */ + protected void onSetContentView() { + setContentView(com.android.internal.R.layout.activity_list); + } + @Override protected void onListItemClick(ListView l, View v, int position, long id) { - Intent intent = ((ActivityAdapter)mAdapter).intentForPosition(position); - + Intent intent = intentForPosition(position); startActivity(intent); } @@ -374,12 +383,19 @@ public abstract class LauncherActivity extends ListActivity { } /** + * Perform query on package manager for list items. The default + * implementation queries for activities. + */ + protected List<ResolveInfo> onQueryPackageManager(Intent queryIntent) { + return mPackageManager.queryIntentActivities(queryIntent, /* no flags */ 0); + } + + /** * Perform the query to determine which results to show and return a list of them. */ public List<ListItem> makeListItems() { // Load all matching activities and sort correctly - List<ResolveInfo> list = mPackageManager.queryIntentActivities(mIntent, - /* no flags */ 0); + List<ResolveInfo> list = onQueryPackageManager(mIntent); Collections.sort(list, new ResolveInfo.DisplayNameComparator(mPackageManager)); IconResizer resizer = new IconResizer(); diff --git a/core/java/android/app/Notification.java b/core/java/android/app/Notification.java index 9834c75..be5a7d3 100644 --- a/core/java/android/app/Notification.java +++ b/core/java/android/app/Notification.java @@ -257,6 +257,13 @@ public class Notification implements Parcelable */ public static final int FLAG_NO_CLEAR = 0x00000020; + /** + * Bit to be bitwise-ored into the {@link #flags} field that should be + * set if this notification represents a currently running service. This + * will normally be set for you by {@link Service#startForeground}. + */ + public static final int FLAG_FOREGROUND_SERVICE = 0x00000040; + public int flags; /** @@ -458,7 +465,9 @@ public class Notification implements Parcelable sb.append(this.vibrate[i]); sb.append(','); } - sb.append(this.vibrate[N]); + if (N != -1) { + sb.append(this.vibrate[N]); + } sb.append("]"); } else if ((this.defaults & DEFAULT_VIBRATE) != 0) { sb.append("default"); diff --git a/core/java/android/app/NotificationManager.java b/core/java/android/app/NotificationManager.java index 39edab7..7b51fdf 100644 --- a/core/java/android/app/NotificationManager.java +++ b/core/java/android/app/NotificationManager.java @@ -61,7 +61,8 @@ public class NotificationManager private static INotificationManager sService; - static private INotificationManager getService() + /** @hide */ + static public INotificationManager getService() { if (sService != null) { return sService; diff --git a/core/java/android/app/SearchDialog.java b/core/java/android/app/SearchDialog.java index b75bec2..8a9cca7 100644 --- a/core/java/android/app/SearchDialog.java +++ b/core/java/android/app/SearchDialog.java @@ -1120,7 +1120,7 @@ public class SearchDialog extends Dialog implements OnItemClickListener, OnItemS /** * Launch a search for the text in the query text field. */ - protected void launchQuerySearch() { + public void launchQuerySearch() { launchQuerySearch(KeyEvent.KEYCODE_UNKNOWN, null); } diff --git a/core/java/android/app/SearchManager.java b/core/java/android/app/SearchManager.java index 62faadc..4854952 100644 --- a/core/java/android/app/SearchManager.java +++ b/core/java/android/app/SearchManager.java @@ -29,6 +29,7 @@ import android.os.ServiceManager; import android.server.search.SearchableInfo; import android.util.Log; import android.view.KeyEvent; +import android.text.TextUtils; import java.util.List; @@ -1511,7 +1512,17 @@ public class SearchManager private final Context mContext; + /** + * compact representation of the activity associated with this search manager so + * we can say who we are when starting search. the search managerservice, in turn, + * uses this to properly handle the back stack. + */ private int mIdent; + + /** + * The package associated with this seach manager. + */ + private String mAssociatedPackage; // package private since they are used by the inner class SearchManagerCallback /* package */ final Handler mHandler; @@ -1531,11 +1542,15 @@ public class SearchManager return mIdent != 0; } - /*package*/ void setIdent(int ident) { + /*package*/ void setIdent(int ident, ComponentName component) { if (mIdent != 0) { throw new IllegalStateException("mIdent already set"); } + if (component == null) { + throw new IllegalArgumentException("component must be non-null"); + } mIdent = ident; + mAssociatedPackage = component.getPackageName(); } /** @@ -1585,12 +1600,55 @@ public class SearchManager boolean globalSearch) { if (mIdent == 0) throw new IllegalArgumentException( "Called from outside of an Activity context"); + if (!globalSearch && !mAssociatedPackage.equals(launchActivity.getPackageName())) { + Log.w(TAG, "invoking app search on a different package " + + "not associated with this search manager"); + } try { // activate the search manager and start it up! mService.startSearch(initialQuery, selectInitialQuery, launchActivity, appSearchData, globalSearch, mSearchManagerCallback, mIdent); } catch (RemoteException ex) { - Log.e(TAG, "startSearch() failed: " + ex); + Log.e(TAG, "startSearch() failed.", ex); + } + } + + /** + * Similar to {@link #startSearch} but actually fires off the search query after invoking + * the search dialog. Made available for testing purposes. + * + * @param query The query to trigger. If empty, request will be ignored. + * @param launchActivity The ComponentName of the activity that has launched this search. + * @param appSearchData An application can insert application-specific + * context here, in order to improve quality or specificity of its own + * searches. This data will be returned with SEARCH intent(s). Null if + * no extra data is required. + * @param globalSearch If false, this will only launch the search that has been specifically + * defined by the application (which is usually defined as a local search). If no default + * search is defined in the current application or activity, no search will be launched. + * If true, this will always launch a platform-global (e.g. web-based) search instead. + * + * @see #startSearch + */ + public void triggerSearch(String query, + ComponentName launchActivity, + Bundle appSearchData, + boolean globalSearch) { + if (mIdent == 0) throw new IllegalArgumentException( + "Called from outside of an Activity context"); + if (!mAssociatedPackage.equals(launchActivity.getPackageName())) { + throw new IllegalArgumentException("invoking app search on a different package " + + "not associated with this search manager"); + } + if (query == null || TextUtils.getTrimmedLength(query) == 0) { + Log.w(TAG, "triggerSearch called with empty query, ignoring."); + return; + } + try { + mService.triggerSearch(query, launchActivity, appSearchData, mSearchManagerCallback, + globalSearch, mIdent); + } catch (RemoteException ex) { + Log.e(TAG, "triggerSearch() failed.", ex); } } diff --git a/core/java/android/app/Service.java b/core/java/android/app/Service.java index d2fb605..2dedaa7 100644 --- a/core/java/android/app/Service.java +++ b/core/java/android/app/Service.java @@ -24,6 +24,7 @@ import android.content.Context; import android.content.res.Configuration; import android.os.RemoteException; import android.os.IBinder; +import android.util.Log; import java.io.FileDescriptor; import java.io.PrintWriter; @@ -304,24 +305,53 @@ public abstract class Service extends ContextWrapper implements ComponentCallbac } /** - * Control whether this service is considered to be a foreground service. + * @deprecated This is a now a no-op, use + * {@link #startForeground(int, Notification)} instead. + */ + @Deprecated + public final void setForeground(boolean isForeground) { + Log.w(TAG, "setForeground: ignoring old API call on " + getClass().getName()); + } + + /** + * Make this service run in the foreground, supplying the ongoing + * notification to be shown to the user while in this state. * By default services are background, meaning that if the system needs to * kill them to reclaim more memory (such as to display a large page in a * web browser), they can be killed without too much harm. You can set this - * flag if killing your service would be disruptive to the user: such as + * flag if killing your service would be disruptive to the user, such as * if your service is performing background music playback, so the user * would notice if their music stopped playing. * - * @param isForeground Determines whether this service is considered to - * be foreground (true) or background (false). + * @param id The identifier for this notification as per + * {@link NotificationManager#notify(int, Notification) + * NotificationManager.notify(int, Notification)}. + * @param notification The Notification to be displayed. + * + * @see #stopForeground(boolean) */ - public final void setForeground(boolean isForeground) { - if (mActivityManager == null) { - return; + public final void startForeground(int id, Notification notification) { + try { + mActivityManager.setServiceForeground( + new ComponentName(this, mClassName), mToken, id, + notification, true); + } catch (RemoteException ex) { } + } + + /** + * Remove this service from foreground state, allowing it to be killed if + * more memory is needed. + * @param removeNotification If true, the notification previously provided + * to {@link #startForeground} will be removed. Otherwise it will remain + * until a later call removes it (or the service is destroyed). + * @see #startForeground(int, Notification) + */ + public final void stopForeground(boolean removeNotification) { try { mActivityManager.setServiceForeground( - new ComponentName(this, mClassName), mToken, isForeground); + new ComponentName(this, mClassName), mToken, 0, null, + removeNotification); } catch (RemoteException ex) { } } diff --git a/core/java/android/app/WallpaperManager.java b/core/java/android/app/WallpaperManager.java new file mode 100644 index 0000000..c5ca0a3 --- /dev/null +++ b/core/java/android/app/WallpaperManager.java @@ -0,0 +1,369 @@ +/* + * Copyright (C) 2009 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.app; + +import android.content.Context; +import android.content.Intent; +import android.content.res.Resources; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.drawable.BitmapDrawable; +import android.graphics.drawable.Drawable; +import android.os.Handler; +import android.os.IBinder; +import android.os.ParcelFileDescriptor; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.util.Log; +import android.view.ViewRoot; + +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; + +public class WallpaperManager { + private static String TAG = "WallpaperManager"; + private static boolean DEBUG = false; + + /** + * Launch an activity for the user to pick the current global live + * wallpaper. + * @hide + */ + public static final String ACTION_LIVE_WALLPAPER_CHOOSER + = "android.service.wallpaper.LIVE_WALLPAPER_CHOOSER"; + + private final Context mContext; + + static class Globals extends IWallpaperManagerCallback.Stub { + private IWallpaperManager mService; + private Drawable mWallpaper; + + Globals() { + IBinder b = ServiceManager.getService(Context.WALLPAPER_SERVICE); + mService = IWallpaperManager.Stub.asInterface(b); + } + + public void onWallpaperChanged() { + /* The wallpaper has changed but we shouldn't eagerly load the + * wallpaper as that would be inefficient. Reset the cached wallpaper + * to null so if the user requests the wallpaper again then we'll + * fetch it. + */ + synchronized (this) { + mWallpaper = null; + } + } + + public Drawable peekWallpaper(Context context) { + synchronized (this) { + if (mWallpaper != null) { + return mWallpaper; + } + mWallpaper = getCurrentWallpaperLocked(context); + return mWallpaper; + } + } + + private Drawable getCurrentWallpaperLocked(Context context) { + try { + ParcelFileDescriptor fd = mService.getWallpaper(this); + if (fd != null) { + Bitmap bm = BitmapFactory.decodeFileDescriptor( + fd.getFileDescriptor(), null, null); + if (bm != null) { + // For now clear the density until we figure out how + // to deal with it for wallpapers. + bm.setDensity(0); + return new BitmapDrawable(context.getResources(), bm); + } + } + } catch (RemoteException e) { + } + return null; + } + } + + private static Object mSync = new Object(); + private static Globals sGlobals; + + static Globals getGlobals() { + synchronized (mSync) { + if (sGlobals == null) { + sGlobals = new Globals(); + } + return sGlobals; + } + } + + /*package*/ WallpaperManager(Context context, Handler handler) { + mContext = context; + } + + /** + * Retrieve a WallpaperManager associated with the given Context. + */ + public static WallpaperManager getInstance(Context context) { + return (WallpaperManager)context.getSystemService( + Context.WALLPAPER_SERVICE); + } + + /** @hide */ + public IWallpaperManager getIWallpaperManager() { + return getGlobals().mService; + } + + /** + * Like {@link #peekDrawable}, but always returns a valid Drawable. If + * no wallpaper is set, the system default wallpaper is returned. + * + * @return Returns a Drawable object that will draw the wallpaper. + */ + public Drawable getDrawable() { + Drawable dr = peekDrawable(); + return dr != null ? dr : Resources.getSystem().getDrawable( + com.android.internal.R.drawable.default_wallpaper); + } + + /** + * Retrieve the current system wallpaper. This is returned as an + * abstract Drawable that you can install in a View to display whatever + * wallpaper the user has currently set. If there is no wallpaper set, + * a null pointer is returned. + * + * @return Returns a Drawable object that will draw the wallpaper or a + * null pointer if these is none. + */ + public Drawable peekDrawable() { + return getGlobals().peekWallpaper(mContext); + } + + /** + * Change the current system wallpaper to the bitmap in the given resource. + * The resource is opened as a raw data stream and copied into the + * wallpaper; it must be a valid PNG or JPEG image. On success, the intent + * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. + * + * @param resid The bitmap to save. + * + * @throws IOException If an error occurs reverting to the default + * wallpaper. + */ + public void setResource(int resid) throws IOException { + try { + Resources resources = mContext.getResources(); + /* Set the wallpaper to the default values */ + ParcelFileDescriptor fd = getGlobals().mService.setWallpaper( + "res:" + resources.getResourceName(resid)); + if (fd != null) { + FileOutputStream fos = null; + try { + fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); + setWallpaper(resources.openRawResource(resid), fos); + } finally { + if (fos != null) { + fos.close(); + } + } + } + } catch (RemoteException e) { + } + } + + /** + * Change the current system wallpaper to a bitmap. The given bitmap is + * converted to a PNG and stored as the wallpaper. On success, the intent + * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. + * + * @param bitmap The bitmap to save. + * + * @throws IOException If an error occurs reverting to the default + * wallpaper. + */ + public void setBitmap(Bitmap bitmap) throws IOException { + try { + ParcelFileDescriptor fd = getGlobals().mService.setWallpaper(null); + if (fd == null) { + return; + } + FileOutputStream fos = null; + try { + fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); + bitmap.compress(Bitmap.CompressFormat.PNG, 90, fos); + } finally { + if (fos != null) { + fos.close(); + } + } + } catch (RemoteException e) { + } + } + + /** + * Change the current system wallpaper to a specific byte stream. The + * give InputStream is copied into persistent storage and will now be + * used as the wallpaper. Currently it must be either a JPEG or PNG + * image. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} + * is broadcast. + * + * @param data A stream containing the raw data to install as a wallpaper. + * + * @throws IOException If an error occurs reverting to the default + * wallpaper. + */ + public void setStream(InputStream data) throws IOException { + try { + ParcelFileDescriptor fd = getGlobals().mService.setWallpaper(null); + if (fd == null) { + return; + } + FileOutputStream fos = null; + try { + fos = new ParcelFileDescriptor.AutoCloseOutputStream(fd); + setWallpaper(data, fos); + } finally { + if (fos != null) { + fos.close(); + } + } + } catch (RemoteException e) { + } + } + + private void setWallpaper(InputStream data, FileOutputStream fos) + throws IOException { + byte[] buffer = new byte[32768]; + int amt; + while ((amt=data.read(buffer)) > 0) { + fos.write(buffer, 0, amt); + } + } + + /** + * Returns the desired minimum width for the wallpaper. Callers of + * {@link #setBitmap(android.graphics.Bitmap)} or + * {@link #setStream(java.io.InputStream)} should check this value + * beforehand to make sure the supplied wallpaper respects the desired + * minimum width. + * + * If the returned value is <= 0, the caller should use the width of + * the default display instead. + * + * @return The desired minimum width for the wallpaper. This value should + * be honored by applications that set the wallpaper but it is not + * mandatory. + */ + public int getDesiredMinimumWidth() { + try { + return getGlobals().mService.getWidthHint(); + } catch (RemoteException e) { + // Shouldn't happen! + return 0; + } + } + + /** + * Returns the desired minimum height for the wallpaper. Callers of + * {@link #setBitmap(android.graphics.Bitmap)} or + * {@link #setStream(java.io.InputStream)} should check this value + * beforehand to make sure the supplied wallpaper respects the desired + * minimum height. + * + * If the returned value is <= 0, the caller should use the height of + * the default display instead. + * + * @return The desired minimum height for the wallpaper. This value should + * be honored by applications that set the wallpaper but it is not + * mandatory. + */ + public int getDesiredMinimumHeight() { + try { + return getGlobals().mService.getHeightHint(); + } catch (RemoteException e) { + // Shouldn't happen! + return 0; + } + } + + /** + * For use only by the current home application, to specify the size of + * wallpaper it would like to use. This allows such applications to have + * a virtual wallpaper that is larger than the physical screen, matching + * the size of their workspace. + * @param minimumWidth Desired minimum width + * @param minimumHeight Desired minimum height + */ + public void suggestDesiredDimensions(int minimumWidth, int minimumHeight) { + try { + getGlobals().mService.setDimensionHints(minimumWidth, minimumHeight); + } catch (RemoteException e) { + } + } + + /** + * Set the position of the current wallpaper within any larger space, when + * that wallpaper is visible behind the given window. The X and Y offsets + * are floating point numbers ranging from 0 to 1, representing where the + * wallpaper should be positioned within the screen space. These only + * make sense when the wallpaper is larger than the screen. + * + * @param windowToken The window who these offsets should be associated + * with, as returned by {@link android.view.View#getWindowVisibility() + * View.getWindowToken()}. + * @param xOffset The offset olong the X dimension, from 0 to 1. + * @param yOffset The offset along the Y dimension, from 0 to 1. + */ + public void setWallpaperOffsets(IBinder windowToken, float xOffset, float yOffset) { + try { + ViewRoot.getWindowSession(mContext.getMainLooper()).setWallpaperPosition( + windowToken, xOffset, yOffset); + } catch (RemoteException e) { + // Ignore. + } + } + + /** + * Clear the offsets previously associated with this window through + * {@link #setWallpaperOffsets(IBinder, float, float)}. This reverts + * the window to its default state, where it does not cause the wallpaper + * to scroll from whatever its last offsets were. + * + * @param windowToken The window who these offsets should be associated + * with, as returned by {@link android.view.View#getWindowVisibility() + * View.getWindowToken()}. + */ + public void clearWallpaperOffsets(IBinder windowToken) { + try { + ViewRoot.getWindowSession(mContext.getMainLooper()).setWallpaperPosition( + windowToken, -1, -1); + } catch (RemoteException e) { + // Ignore. + } + } + + /** + * Remove any currently set wallpaper, reverting to the system's default + * wallpaper. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} + * is broadcast. + * + * @throws IOException If an error occurs reverting to the default + * wallpaper. + */ + public void clear() throws IOException { + setResource(com.android.internal.R.drawable.default_wallpaper); + } +} diff --git a/core/java/android/appwidget/AppWidgetHostView.java b/core/java/android/appwidget/AppWidgetHostView.java index 9799ac4..a4c141e 100644 --- a/core/java/android/appwidget/AppWidgetHostView.java +++ b/core/java/android/appwidget/AppWidgetHostView.java @@ -24,16 +24,17 @@ import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Paint; import android.os.SystemClock; +import android.os.Parcelable; +import android.os.Parcel; import android.util.AttributeSet; import android.util.Log; +import android.util.SparseArray; import android.view.Gravity; import android.view.LayoutInflater; import android.view.View; -import android.view.ViewGroup; import android.widget.FrameLayout; import android.widget.RemoteViews; import android.widget.TextView; -import android.widget.FrameLayout.LayoutParams; /** * Provides the glue to show AppWidget views. This class offers automatic animation @@ -108,6 +109,24 @@ public class AppWidgetHostView extends FrameLayout { return mInfo; } + @Override + protected void dispatchSaveInstanceState(SparseArray<Parcelable> container) { + final ParcelableSparseArray jail = new ParcelableSparseArray(); + super.dispatchSaveInstanceState(jail); + container.put(generateId(), jail); + } + + private int generateId() { + final int id = getId(); + return id == View.NO_ID ? mAppWidgetId : id; + } + + @Override + protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container) { + final ParcelableSparseArray jail = (ParcelableSparseArray) container.get(generateId()); + super.dispatchRestoreInstanceState(jail); + } + /** {@inheritDoc} */ @Override public LayoutParams generateLayoutParams(AttributeSet attrs) { @@ -303,6 +322,7 @@ public class AppWidgetHostView extends FrameLayout { if (mInfo != null) { Context theirContext = mContext.createPackageContext( mInfo.provider.getPackageName(), Context.CONTEXT_RESTRICTED); + mRemoteContext = theirContext; LayoutInflater inflater = (LayoutInflater) theirContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE); inflater = inflater.cloneInContext(theirContext); @@ -317,8 +337,8 @@ public class AppWidgetHostView extends FrameLayout { exception = e; } - if (exception != null && LOGD) { - Log.w(TAG, "Error inflating AppWidget " + mInfo, exception); + if (exception != null) { + Log.w(TAG, "Error inflating AppWidget " + mInfo + ": " + exception.toString()); } if (defaultView == null) { @@ -339,4 +359,36 @@ public class AppWidgetHostView extends FrameLayout { tv.setBackgroundColor(Color.argb(127, 0, 0, 0)); return tv; } + + private static class ParcelableSparseArray extends SparseArray<Parcelable> implements Parcelable { + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + final int count = size(); + dest.writeInt(count); + for (int i = 0; i < count; i++) { + dest.writeInt(keyAt(i)); + dest.writeParcelable(valueAt(i), 0); + } + } + + public static final Parcelable.Creator<ParcelableSparseArray> CREATOR = + new Parcelable.Creator<ParcelableSparseArray>() { + public ParcelableSparseArray createFromParcel(Parcel source) { + final ParcelableSparseArray array = new ParcelableSparseArray(); + final ClassLoader loader = array.getClass().getClassLoader(); + final int count = source.readInt(); + for (int i = 0; i < count; i++) { + array.put(source.readInt(), source.readParcelable(loader)); + } + return array; + } + + public ParcelableSparseArray[] newArray(int size) { + return new ParcelableSparseArray[size]; + } + }; + } } diff --git a/core/java/android/backup/BackupDataInput.java b/core/java/android/backup/BackupDataInput.java index 69c206c..e67b0be 100644 --- a/core/java/android/backup/BackupDataInput.java +++ b/core/java/android/backup/BackupDataInput.java @@ -97,12 +97,7 @@ public class BackupDataInput { public void skipEntityData() throws IOException { if (mHeaderReady) { - int result = skipEntityData_native(mBackupReader); - if (result >= 0) { - return; - } else { - throw new IOException("result=0x" + Integer.toHexString(result)); - } + skipEntityData_native(mBackupReader); } else { throw new IllegalStateException("mHeaderReady=false"); } diff --git a/core/java/android/backup/BackupManager.java b/core/java/android/backup/BackupManager.java index c52fcd2..da1647a 100644 --- a/core/java/android/backup/BackupManager.java +++ b/core/java/android/backup/BackupManager.java @@ -43,7 +43,7 @@ public class BackupManager { private static final String TAG = "BackupManager"; /** @hide TODO: REMOVE THIS */ - public static final boolean EVEN_THINK_ABOUT_DOING_RESTORE = false; + public static final boolean EVEN_THINK_ABOUT_DOING_RESTORE = true; private Context mContext; private static IBackupManager sService; diff --git a/core/java/android/backup/IRestoreSession.aidl b/core/java/android/backup/IRestoreSession.aidl index 2a1fbc1..fd40d98 100644 --- a/core/java/android/backup/IRestoreSession.aidl +++ b/core/java/android/backup/IRestoreSession.aidl @@ -40,6 +40,8 @@ interface IRestoreSession { * Restore the given set onto the device, replacing the current data of any app * contained in the restore set with the data previously backed up. * + * @return Zero on success; nonzero on error. The observer will only receive + * progress callbacks if this method returned zero. * @param token The token from {@link getAvailableRestoreSets()} corresponding to * the restore set that should be used. * @param observer If non-null, this binder points to an object that will receive @@ -50,6 +52,9 @@ interface IRestoreSession { /** * End this restore session. After this method is called, the IRestoreSession binder * is no longer valid. + * + * <p><b>Note:</b> The caller <i>must</i> invoke this method to end the restore session, + * even if {@link getAvailableRestoreSets} or {@link performRestore} failed. */ void endRestoreSession(); } diff --git a/core/java/android/bluetooth/BluetoothA2dp.java b/core/java/android/bluetooth/BluetoothA2dp.java index 2ea45d5..b531a50 100644 --- a/core/java/android/bluetooth/BluetoothA2dp.java +++ b/core/java/android/bluetooth/BluetoothA2dp.java @@ -25,7 +25,10 @@ import android.os.RemoteException; import android.os.IBinder; import android.util.Log; -import java.util.List; +import java.util.Arrays; +import java.util.Collections; +import java.util.Set; +import java.util.HashSet; /** * Public API for controlling the Bluetooth A2DP Profile Service. @@ -47,7 +50,7 @@ import java.util.List; * * @hide */ -public class BluetoothA2dp { +public final class BluetoothA2dp { private static final String TAG = "BluetoothA2dp"; private static final boolean DBG = false; @@ -79,6 +82,7 @@ public class BluetoothA2dp { /** Default priority for a2dp devices that should not allow incoming * connections */ public static final int PRIORITY_OFF = 0; + private final IBluetoothA2dp mService; private final Context mContext; @@ -89,6 +93,7 @@ public class BluetoothA2dp { */ public BluetoothA2dp(Context c) { mContext = c; + IBinder b = ServiceManager.getService(BluetoothA2dpService.BLUETOOTH_A2DP_SERVICE); if (b == null) { throw new RuntimeException("Bluetooth A2DP service not available!"); @@ -99,14 +104,14 @@ public class BluetoothA2dp { /** Initiate a connection to an A2DP sink. * Listen for SINK_STATE_CHANGED_ACTION to find out when the * connection is completed. - * @param address Remote BT address. + * @param device Remote BT device. * @return Result code, negative indicates an immediate error. * @hide */ - public int connectSink(String address) { - if (DBG) log("connectSink(" + address + ")"); + public int connectSink(BluetoothDevice device) { + if (DBG) log("connectSink(" + device + ")"); try { - return mService.connectSink(address); + return mService.connectSink(device); } catch (RemoteException e) { Log.w(TAG, "", e); return BluetoothError.ERROR_IPC; @@ -116,14 +121,14 @@ public class BluetoothA2dp { /** Initiate disconnect from an A2DP sink. * Listen for SINK_STATE_CHANGED_ACTION to find out when * disconnect is completed. - * @param address Remote BT address. + * @param device Remote BT device. * @return Result code, negative indicates an immediate error. * @hide */ - public int disconnectSink(String address) { - if (DBG) log("disconnectSink(" + address + ")"); + public int disconnectSink(BluetoothDevice device) { + if (DBG) log("disconnectSink(" + device + ")"); try { - return mService.disconnectSink(address); + return mService.disconnectSink(device); } catch (RemoteException e) { Log.w(TAG, "", e); return BluetoothError.ERROR_IPC; @@ -131,24 +136,25 @@ public class BluetoothA2dp { } /** Check if a specified A2DP sink is connected. - * @param address Remote BT address. + * @param device Remote BT device. * @return True if connected (or playing), false otherwise and on error. * @hide */ - public boolean isSinkConnected(String address) { - if (DBG) log("isSinkConnected(" + address + ")"); - int state = getSinkState(address); + public boolean isSinkConnected(BluetoothDevice device) { + if (DBG) log("isSinkConnected(" + device + ")"); + int state = getSinkState(device); return state == STATE_CONNECTED || state == STATE_PLAYING; } /** Check if any A2DP sink is connected. - * @return a List of connected A2DP sinks, or null on error. + * @return a unmodifiable set of connected A2DP sinks, or null on error. * @hide */ - public List<String> listConnectedSinks() { - if (DBG) log("listConnectedSinks()"); + public Set<BluetoothDevice> getConnectedSinks() { + if (DBG) log("getConnectedSinks()"); try { - return mService.listConnectedSinks(); + return Collections.unmodifiableSet( + new HashSet<BluetoothDevice>(Arrays.asList(mService.getConnectedSinks()))); } catch (RemoteException e) { Log.w(TAG, "", e); return null; @@ -156,14 +162,14 @@ public class BluetoothA2dp { } /** Get the state of an A2DP sink - * @param address Remote BT address. + * @param device Remote BT device. * @return State code, or negative on error * @hide */ - public int getSinkState(String address) { - if (DBG) log("getSinkState(" + address + ")"); + public int getSinkState(BluetoothDevice device) { + if (DBG) log("getSinkState(" + device + ")"); try { - return mService.getSinkState(address); + return mService.getSinkState(device); } catch (RemoteException e) { Log.w(TAG, "", e); return BluetoothError.ERROR_IPC; @@ -177,15 +183,15 @@ public class BluetoothA2dp { * Sinks with priority greater than zero will accept incoming connections * (if no sink is currently connected). * Priority for unpaired sink must be PRIORITY_NONE. - * @param address Paired sink + * @param device Paired sink * @param priority Integer priority, for example PRIORITY_AUTO or * PRIORITY_NONE * @return Result code, negative indicates an error */ - public int setSinkPriority(String address, int priority) { - if (DBG) log("setSinkPriority(" + address + ", " + priority + ")"); + public int setSinkPriority(BluetoothDevice device, int priority) { + if (DBG) log("setSinkPriority(" + device + ", " + priority + ")"); try { - return mService.setSinkPriority(address, priority); + return mService.setSinkPriority(device, priority); } catch (RemoteException e) { Log.w(TAG, "", e); return BluetoothError.ERROR_IPC; @@ -194,44 +200,19 @@ public class BluetoothA2dp { /** * Get priority of a2dp sink. - * @param address Sink + * @param device Sink * @return non-negative priority, or negative error code on error. */ - public int getSinkPriority(String address) { - if (DBG) log("getSinkPriority(" + address + ")"); + public int getSinkPriority(BluetoothDevice device) { + if (DBG) log("getSinkPriority(" + device + ")"); try { - return mService.getSinkPriority(address); + return mService.getSinkPriority(device); } catch (RemoteException e) { Log.w(TAG, "", e); return BluetoothError.ERROR_IPC; } } - /** - * Check class bits for possible A2DP Sink support. - * This is a simple heuristic that tries to guess if a device with the - * given class bits might be a A2DP Sink. It is not accurate for all - * devices. It tries to err on the side of false positives. - * @return True if this device might be a A2DP sink - */ - public static boolean doesClassMatchSink(int btClass) { - if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) { - return true; - } - // By the A2DP spec, sinks must indicate the RENDER service. - // However we found some that do not (Chordette). So lets also - // match on some other class bits. - switch (BluetoothClass.Device.getDevice(btClass)) { - case BluetoothClass.Device.AUDIO_VIDEO_HIFI_AUDIO: - case BluetoothClass.Device.AUDIO_VIDEO_HEADPHONES: - case BluetoothClass.Device.AUDIO_VIDEO_LOUDSPEAKER: - case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO: - return true; - default: - return false; - } - } - /** Helper for converting a state to a string. * For debug use only - strings are not internationalized. * @hide diff --git a/core/java/android/bluetooth/BluetoothAdapter.java b/core/java/android/bluetooth/BluetoothAdapter.java new file mode 100644 index 0000000..6bd2a5a --- /dev/null +++ b/core/java/android/bluetooth/BluetoothAdapter.java @@ -0,0 +1,376 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import android.os.RemoteException; +import android.util.Log; + +import java.io.IOException; +import java.util.Collections; +import java.util.Set; +import java.util.HashSet; + +/** + * Represents the local Bluetooth adapter. + * + * <p>Use {@link android.content.Context#getSystemService} with {@link + * android.content.Context#BLUETOOTH_SERVICE} to get the default local + * Bluetooth adapter. On most Android devices there is only one local + * Bluetotoh adapter. + * + * <p>Use the {@link BluetoothDevice} class for operations on remote Bluetooth + * devices. + * + * <p>TODO: unhide more of this class + */ +public final class BluetoothAdapter { + private static final String TAG = "BluetoothAdapter"; + + /** @hide */ + public static final int BLUETOOTH_STATE_OFF = 0; + /** @hide */ + public static final int BLUETOOTH_STATE_TURNING_ON = 1; + /** @hide */ + public static final int BLUETOOTH_STATE_ON = 2; + /** @hide */ + public static final int BLUETOOTH_STATE_TURNING_OFF = 3; + + /** Inquiry scan and page scan are both off. + * Device is neither discoverable nor connectable + * @hide */ + public static final int SCAN_MODE_NONE = 0; + /** Page scan is on, inquiry scan is off. + * Device is connectable, but not discoverable + * @hide*/ + public static final int SCAN_MODE_CONNECTABLE = 1; + /** Page scan and inquiry scan are on. + * Device is connectable and discoverable + * @hide*/ + public static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE = 3; + + /** @hide */ + public static final int RESULT_FAILURE = -1; + /** @hide */ + public static final int RESULT_SUCCESS = 0; + + /** The user will be prompted to enter a pin + * @hide */ + public static final int PAIRING_VARIANT_PIN = 0; + /** The user will be prompted to enter a passkey + * @hide */ + public static final int PAIRING_VARIANT_PASSKEY = 1; + /** The user will be prompted to confirm the passkey displayed on the screen + * @hide */ + public static final int PAIRING_VARIANT_CONFIRMATION = 2; + + private final IBluetooth mService; + + /** + * Do not use this constructor. Use Context.getSystemService() instead. + * @hide + */ + public BluetoothAdapter(IBluetooth service) { + if (service == null) { + throw new IllegalArgumentException("service is null"); + } + mService = service; + } + + /** + * Get a {@link BluetoothDevice} object for the given Bluetooth hardware + * address. + * <p>Valid Bluetooth hardware addresses must be upper case, in a format + * such as "00:11:22:33:AA:BB". + * <p>A {@link BluetoothDevice} will always be returned for a valid + * hardware address, even if this adapter has never seen that device. + * @param address valid Bluetooth MAC address + * @throws IllegalArgumentException if address is invalid + */ + public BluetoothDevice getRemoteDevice(String address) { + return new BluetoothDevice(address); + } + + /** + * Is Bluetooth currently turned on. + * + * @return true if Bluetooth enabled, false otherwise. + * @hide + */ + public boolean isEnabled() { + try { + return mService.isEnabled(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Get the current state of Bluetooth. + * + * @return One of BLUETOOTH_STATE_ or BluetoothError.ERROR. + * @hide + */ + public int getBluetoothState() { + try { + return mService.getBluetoothState(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return BluetoothError.ERROR; + } + + /** + * Enable the Bluetooth device. + * Turn on the underlying hardware. + * This is an asynchronous call, + * BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION can be used to check if + * and when the device is sucessfully enabled. + * @return false if we cannot enable the Bluetooth device. True does not + * imply the device was enabled, it only implies that so far there were no + * problems. + * @hide + */ + public boolean enable() { + try { + return mService.enable(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Disable the Bluetooth device. + * This turns off the underlying hardware. + * + * @return true if successful, false otherwise. + * @hide + */ + public boolean disable() { + try { + return mService.disable(true); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** @hide */ + public String getAddress() { + try { + return mService.getAddress(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Get the friendly Bluetooth name of this device. + * + * This name is visible to remote Bluetooth devices. Currently it is only + * possible to retrieve the Bluetooth name when Bluetooth is enabled. + * + * @return the Bluetooth name, or null if there was a problem. + * @hide + */ + public String getName() { + try { + return mService.getName(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Set the friendly Bluetooth name of this device. + * + * This name is visible to remote Bluetooth devices. The Bluetooth Service + * is responsible for persisting this name. + * + * @param name the name to set + * @return true, if the name was successfully set. False otherwise. + * @hide + */ + public boolean setName(String name) { + try { + return mService.setName(name); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * Get the current scan mode. + * Used to determine if the local device is connectable and/or discoverable + * @return Scan mode, one of SCAN_MODE_* or an error code + * @hide + */ + public int getScanMode() { + try { + return mService.getScanMode(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return BluetoothError.ERROR_IPC; + } + + /** + * Set the current scan mode. + * Used to make the local device connectable and/or discoverable + * @param scanMode One of SCAN_MODE_* + * @hide + */ + public void setScanMode(int scanMode) { + try { + mService.setScanMode(scanMode); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + /** @hide */ + public int getDiscoverableTimeout() { + try { + return mService.getDiscoverableTimeout(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return -1; + } + + /** @hide */ + public void setDiscoverableTimeout(int timeout) { + try { + mService.setDiscoverableTimeout(timeout); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + /** @hide */ + public boolean startDiscovery() { + try { + return mService.startDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** @hide */ + public void cancelDiscovery() { + try { + mService.cancelDiscovery(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + } + + /** @hide */ + public boolean isDiscovering() { + try { + return mService.isDiscovering(); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return false; + } + + /** + * List remote devices that are bonded (paired) to the local adapter. + * + * Bonding (pairing) is the process by which the user enters a pin code for + * the device, which generates a shared link key, allowing for + * authentication and encryption of future connections. In Android we + * require bonding before RFCOMM or SCO connections can be made to a remote + * device. + * + * This function lists which remote devices we have a link key for. It does + * not cause any RF transmission, and does not check if the remote device + * still has it's link key with us. If the other side no longer has its + * link key then the RFCOMM or SCO connection attempt will result in an + * error. + * + * This function does not check if the remote device is in range. + * + * Remote devices that have an in-progress bonding attempt are not + * returned. + * + * @return unmodifiable set of bonded devices, or null on error + * @hide + */ + public Set<BluetoothDevice> getBondedDevices() { + try { + return toDeviceSet(mService.listBonds()); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return null; + } + + /** + * Create a listening, secure RFCOMM Bluetooth socket. + * <p>A remote device connecting to this socket will be authenticated and + * communication on this socket will be encrypted. + * <p>Use {@link BluetoothServerSocket#accept} to retrieve incoming + * connections to listening {@link BluetoothServerSocket}. + * <p>Valid RFCOMM channels are in range 1 to 30. + * @param channel RFCOMM channel to listen on + * @return a listening RFCOMM BluetoothServerSocket + * @throws IOException on error, for example Bluetooth not available, or + * insufficient permissions, or channel in use. + */ + public BluetoothServerSocket listenUsingRfcommOn(int channel) throws IOException { + BluetoothServerSocket socket = new BluetoothServerSocket( + BluetoothSocket.TYPE_RFCOMM, true, true, channel); + try { + socket.mSocket.bindListenNative(); + } catch (IOException e) { + try { + socket.close(); + } catch (IOException e2) { } + throw e; + } + return socket; + } + + /** + * Construct an unencrypted, unauthenticated, RFCOMM server socket. + * Call #accept to retrieve connections to this socket. + * @return An RFCOMM BluetoothServerSocket + * @throws IOException On error, for example Bluetooth not available, or + * insufficient permissions. + * @hide + */ + public BluetoothServerSocket listenUsingInsecureRfcommOn(int port) throws IOException { + BluetoothServerSocket socket = new BluetoothServerSocket( + BluetoothSocket.TYPE_RFCOMM, false, false, port); + try { + socket.mSocket.bindListenNative(); + } catch (IOException e) { + try { + socket.close(); + } catch (IOException e2) { } + throw e; + } + return socket; + } + + /** + * Construct a SCO server socket. + * Call #accept to retrieve connections to this socket. + * @return A SCO BluetoothServerSocket + * @throws IOException On error, for example Bluetooth not available, or + * insufficient permissions. + * @hide + */ + public static BluetoothServerSocket listenUsingScoOn() throws IOException { + BluetoothServerSocket socket = new BluetoothServerSocket( + BluetoothSocket.TYPE_SCO, false, false, -1); + try { + socket.mSocket.bindListenNative(); + } catch (IOException e) { + try { + socket.close(); + } catch (IOException e2) { } + throw e; + } + return socket; + } + + private Set<BluetoothDevice> toDeviceSet(String[] addresses) { + Set<BluetoothDevice> devices = new HashSet<BluetoothDevice>(addresses.length); + for (int i = 0; i < addresses.length; i++) { + devices.add(getRemoteDevice(addresses[i])); + } + return Collections.unmodifiableSet(devices); + } +} diff --git a/core/java/android/bluetooth/BluetoothAudioGateway.java b/core/java/android/bluetooth/BluetoothAudioGateway.java index f3afd2a..abd7723 100644 --- a/core/java/android/bluetooth/BluetoothAudioGateway.java +++ b/core/java/android/bluetooth/BluetoothAudioGateway.java @@ -9,24 +9,22 @@ import android.util.Log; /** * Listen's for incoming RFCOMM connection for the headset / handsfree service. * - * This class is planned for deletion, in favor of a generic Rfcomm class. + * TODO: Use the new generic BluetoothSocket class instead of this legacy code * * @hide */ -public class BluetoothAudioGateway { +public final class BluetoothAudioGateway { private static final String TAG = "BT Audio Gateway"; private static final boolean DBG = false; private int mNativeData; static { classInitNative(); } - private BluetoothDevice mBluetooth; - /* in */ private int mHandsfreeAgRfcommChannel = -1; private int mHeadsetAgRfcommChannel = -1; - /* out */ + /* out - written by native code */ private String mConnectingHeadsetAddress; private int mConnectingHeadsetRfcommChannel; /* -1 when not connected */ private int mConnectingHeadsetSocketFd; @@ -35,17 +33,18 @@ public class BluetoothAudioGateway { private int mConnectingHandsfreeSocketFd; private int mTimeoutRemainingMs; /* in/out */ + private final BluetoothAdapter mAdapter; + public static final int DEFAULT_HF_AG_CHANNEL = 10; public static final int DEFAULT_HS_AG_CHANNEL = 11; - public BluetoothAudioGateway(BluetoothDevice bluetooth) { - this(bluetooth, DEFAULT_HF_AG_CHANNEL, DEFAULT_HS_AG_CHANNEL); + public BluetoothAudioGateway(BluetoothAdapter adapter) { + this(adapter, DEFAULT_HF_AG_CHANNEL, DEFAULT_HS_AG_CHANNEL); } - public BluetoothAudioGateway(BluetoothDevice bluetooth, - int handsfreeAgRfcommChannel, - int headsetAgRfcommChannel) { - mBluetooth = bluetooth; + public BluetoothAudioGateway(BluetoothAdapter adapter, int handsfreeAgRfcommChannel, + int headsetAgRfcommChannel) { + mAdapter = adapter; mHandsfreeAgRfcommChannel = handsfreeAgRfcommChannel; mHeadsetAgRfcommChannel = headsetAgRfcommChannel; initializeNativeDataNative(); @@ -58,18 +57,17 @@ public class BluetoothAudioGateway { private Handler mCallback; public class IncomingConnectionInfo { - IncomingConnectionInfo(BluetoothDevice bluetooth, String address, int socketFd, - int rfcommChan) { - mBluetooth = bluetooth; - mAddress = address; + public BluetoothAdapter mAdapter; + public BluetoothDevice mRemoteDevice; + public int mSocketFd; + public int mRfcommChan; + IncomingConnectionInfo(BluetoothAdapter adapter, BluetoothDevice remoteDevice, + int socketFd, int rfcommChan) { + mAdapter = adapter; + mRemoteDevice = remoteDevice; mSocketFd = socketFd; mRfcommChan = rfcommChan; } - - public BluetoothDevice mBluetooth; - public String mAddress; - public int mSocketFd; - public int mRfcommChan; } public static final int MSG_INCOMING_HEADSET_CONNECTION = 100; @@ -111,12 +109,11 @@ public class BluetoothAudioGateway { mConnectingHeadsetRfcommChannel); Message msg = Message.obtain(mCallback); msg.what = MSG_INCOMING_HEADSET_CONNECTION; - msg.obj = - new IncomingConnectionInfo( - mBluetooth, - mConnectingHeadsetAddress, - mConnectingHeadsetSocketFd, - mConnectingHeadsetRfcommChannel); + msg.obj = new IncomingConnectionInfo( + mAdapter, + mAdapter.getRemoteDevice(mConnectingHeadsetAddress), + mConnectingHeadsetSocketFd, + mConnectingHeadsetRfcommChannel); msg.sendToTarget(); } if (mConnectingHandsfreeRfcommChannel >= 0) { @@ -126,12 +123,11 @@ public class BluetoothAudioGateway { Message msg = Message.obtain(); msg.setTarget(mCallback); msg.what = MSG_INCOMING_HANDSFREE_CONNECTION; - msg.obj = - new IncomingConnectionInfo( - mBluetooth, - mConnectingHandsfreeAddress, - mConnectingHandsfreeSocketFd, - mConnectingHandsfreeRfcommChannel); + msg.obj = new IncomingConnectionInfo( + mAdapter, + mAdapter.getRemoteDevice(mConnectingHandsfreeAddress), + mConnectingHandsfreeSocketFd, + mConnectingHandsfreeRfcommChannel); msg.sendToTarget(); } } diff --git a/core/java/android/bluetooth/BluetoothClass.java b/core/java/android/bluetooth/BluetoothClass.java index 88ce18b..0061f10 100644 --- a/core/java/android/bluetooth/BluetoothClass.java +++ b/core/java/android/bluetooth/BluetoothClass.java @@ -46,6 +46,10 @@ public class BluetoothClass { /** Indicates the Bluetooth API could not retrieve the class */ public static final int ERROR = 0xFF000000; + public static final int PROFILE_HEADSET = 0; + public static final int PROFILE_A2DP = 1; + public static final int PROFILE_OPP = 2; + /** Every Bluetooth device has zero or more service classes */ public static class Service { public static final int BITMASK = 0xFFE000; @@ -187,5 +191,74 @@ public class BluetoothClass { return (btClass & Device.BITMASK); } } + + /** + * Check class bits for possible bluetooth profile support. + * This is a simple heuristic that tries to guess if a device with the + * given class bits might support specified profile. It is not accurate for all + * devices. It tries to err on the side of false positives. + * @param btClass The class + * @param profile The profile to be checked + * @return True if this device might support specified profile. + */ + public static boolean doesClassMatch(int btClass, int profile) { + if (profile == PROFILE_A2DP) { + if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) { + return true; + } + // By the A2DP spec, sinks must indicate the RENDER service. + // However we found some that do not (Chordette). So lets also + // match on some other class bits. + switch (BluetoothClass.Device.getDevice(btClass)) { + case BluetoothClass.Device.AUDIO_VIDEO_HIFI_AUDIO: + case BluetoothClass.Device.AUDIO_VIDEO_HEADPHONES: + case BluetoothClass.Device.AUDIO_VIDEO_LOUDSPEAKER: + case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO: + return true; + default: + return false; + } + } else if (profile == PROFILE_HEADSET) { + // The render service class is required by the spec for HFP, so is a + // pretty good signal + if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) { + return true; + } + // Just in case they forgot the render service class + switch (BluetoothClass.Device.getDevice(btClass)) { + case BluetoothClass.Device.AUDIO_VIDEO_HANDSFREE: + case BluetoothClass.Device.AUDIO_VIDEO_WEARABLE_HEADSET: + case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO: + return true; + default: + return false; + } + } else if (profile == PROFILE_OPP) { + if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.OBJECT_TRANSFER)) { + return true; + } + + switch (BluetoothClass.Device.getDevice(btClass)) { + case BluetoothClass.Device.COMPUTER_UNCATEGORIZED: + case BluetoothClass.Device.COMPUTER_DESKTOP: + case BluetoothClass.Device.COMPUTER_SERVER: + case BluetoothClass.Device.COMPUTER_LAPTOP: + case BluetoothClass.Device.COMPUTER_HANDHELD_PC_PDA: + case BluetoothClass.Device.COMPUTER_PALM_SIZE_PC_PDA: + case BluetoothClass.Device.COMPUTER_WEARABLE: + case BluetoothClass.Device.PHONE_UNCATEGORIZED: + case BluetoothClass.Device.PHONE_CELLULAR: + case BluetoothClass.Device.PHONE_CORDLESS: + case BluetoothClass.Device.PHONE_SMART: + case BluetoothClass.Device.PHONE_MODEM_OR_GATEWAY: + case BluetoothClass.Device.PHONE_ISDN: + return true; + default: + return false; + } + } else { + return false; + } + } } diff --git a/core/java/android/bluetooth/IBluetoothDeviceCallback.aidl b/core/java/android/bluetooth/BluetoothDevice.aidl index d057093..daae74d 100644 --- a/core/java/android/bluetooth/IBluetoothDeviceCallback.aidl +++ b/core/java/android/bluetooth/BluetoothDevice.aidl @@ -1,11 +1,11 @@ /* - * Copyright (C) 2008, The Android Open Source Project + * Copyright (C) 2009 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 + * 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, @@ -16,10 +16,4 @@ package android.bluetooth; -/** - * {@hide} - */ -oneway interface IBluetoothDeviceCallback -{ - void onGetRemoteServiceChannelResult(in String address, int channel); -} +parcelable BluetoothDevice; diff --git a/core/java/android/bluetooth/BluetoothDevice.java b/core/java/android/bluetooth/BluetoothDevice.java index 951b4b0..0a71961 100644 --- a/core/java/android/bluetooth/BluetoothDevice.java +++ b/core/java/android/bluetooth/BluetoothDevice.java @@ -1,5 +1,5 @@ /* - * Copyright (C) 2008 The Android Open Source Project + * Copyright (C) 2009 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. @@ -16,337 +16,192 @@ package android.bluetooth; +import android.content.Context; +import android.os.IBinder; +import android.os.Parcel; +import android.os.Parcelable; import android.os.RemoteException; +import android.os.ServiceManager; import android.util.Log; +import java.io.IOException; import java.io.UnsupportedEncodingException; /** - * The Android Bluetooth API is not finalized, and *will* change. Use at your - * own risk. + * Represents a remote Bluetooth device. * - * Manages the local Bluetooth device. Scan for devices, create bondings, - * power up and down the adapter. + * <p>Use {@link BluetoothAdapter#getRemoteDevice} to create a {@link + * BluetoothDevice}. * - * @hide + * <p>This class is really just a thin wrapper for a Bluetooth hardware + * address. Objects of this class are immutable. Operations on this class + * are performed on the remote Bluetooth hardware address, using the + * {@link BluetoothAdapter} that was used to create this {@link + * BluetoothDevice}. + * + * TODO: unhide more of this class */ -public class BluetoothDevice { - - public static final int BLUETOOTH_STATE_OFF = 0; - public static final int BLUETOOTH_STATE_TURNING_ON = 1; - public static final int BLUETOOTH_STATE_ON = 2; - public static final int BLUETOOTH_STATE_TURNING_OFF = 3; - - /** Inquiry scan and page scan are both off. - * Device is neither discoverable nor connectable */ - public static final int SCAN_MODE_NONE = 0; - /** Page scan is on, inquiry scan is off. - * Device is connectable, but not discoverable */ - public static final int SCAN_MODE_CONNECTABLE = 1; - /** Page scan and inquiry scan are on. - * Device is connectable and discoverable */ - public static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE = 3; - - public static final int RESULT_FAILURE = -1; - public static final int RESULT_SUCCESS = 0; +public final class BluetoothDevice implements Parcelable { + private static final String TAG = "BluetoothDevice"; /** We do not have a link key for the remote device, and are therefore not - * bonded */ + * bonded + * @hide*/ public static final int BOND_NOT_BONDED = 0; - /** We have a link key for the remote device, and are probably bonded. */ + /** We have a link key for the remote device, and are probably bonded. + * @hide */ public static final int BOND_BONDED = 1; - /** We are currently attempting bonding */ + /** We are currently attempting bonding + * @hide */ public static final int BOND_BONDING = 2; + /** Ask device picker to show all kinds of BT devices. + * @hide */ + public static final int DEVICE_PICKER_FILTER_TYPE_ALL = 0; + /** Ask device picker to show BT devices that support AUDIO profiles. + * @hide */ + public static final int DEVICE_PICKER_FILTER_TYPE_AUDIO = 1; + /** Ask device picker to show BT devices that support Object Transfer. + * @hide */ + public static final int DEVICE_PICKER_FILTER_TYPE_TRANSFER = 2; + //TODO: Unify these result codes in BluetoothResult or BluetoothError /** A bond attempt failed because pins did not match, or remote device did - * not respond to pin request in time */ + * not respond to pin request in time + * @hide */ public static final int UNBOND_REASON_AUTH_FAILED = 1; /** A bond attempt failed because the other side explicilty rejected - * bonding */ + * bonding + * @hide */ public static final int UNBOND_REASON_AUTH_REJECTED = 2; - /** A bond attempt failed because we canceled the bonding process */ + /** A bond attempt failed because we canceled the bonding process + * @hide */ public static final int UNBOND_REASON_AUTH_CANCELED = 3; - /** A bond attempt failed because we could not contact the remote device */ + /** A bond attempt failed because we could not contact the remote device + * @hide */ public static final int UNBOND_REASON_REMOTE_DEVICE_DOWN = 4; - /** A bond attempt failed because a discovery is in progress */ + /** A bond attempt failed because a discovery is in progress + * @hide */ public static final int UNBOND_REASON_DISCOVERY_IN_PROGRESS = 5; - /** An existing bond was explicitly revoked */ + /** An existing bond was explicitly revoked + * @hide */ public static final int UNBOND_REASON_REMOVED = 6; - private static final String TAG = "BluetoothDevice"; - - private final IBluetoothDevice mService; - /** - * @hide - hide this because it takes a parameter of type - * IBluetoothDevice, which is a System private class. - * Also note that Context.getSystemService is a factory that - * returns a BlueToothDevice. That is the right way to get - * a BluetoothDevice. - */ - public BluetoothDevice(IBluetoothDevice service) { - mService = service; - } + //TODO: Remove duplicates between here and BluetoothAdapter + /** The user will be prompted to enter a pin + * @hide */ + public static final int PAIRING_VARIANT_PIN = 0; + /** The user will be prompted to enter a passkey + * @hide */ + public static final int PAIRING_VARIANT_PASSKEY = 1; + /** The user will be prompted to confirm the passkey displayed on the screen + * @hide */ + public static final int PAIRING_VARIANT_CONFIRMATION = 2; - /** - * Is Bluetooth currently turned on. - * - * @return true if Bluetooth enabled, false otherwise. - */ - public boolean isEnabled() { - try { - return mService.isEnabled(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } + private static final int ADDRESS_LENGTH = 17; - /** - * Get the current state of Bluetooth. - * - * @return One of BLUETOOTH_STATE_ or BluetoothError.ERROR. - */ - public int getBluetoothState() { - try { - return mService.getBluetoothState(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return BluetoothError.ERROR; - } + private static IBluetooth sService; /* Guarenteed constant after first object constructed */ - /** - * Enable the Bluetooth device. - * Turn on the underlying hardware. - * This is an asynchronous call, - * BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION can be used to check if - * and when the device is sucessfully enabled. - * @return false if we cannot enable the Bluetooth device. True does not - * imply the device was enabled, it only implies that so far there were no - * problems. - */ - public boolean enable() { - try { - return mService.enable(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } + private final String mAddress; /** - * Disable the Bluetooth device. - * This turns off the underlying hardware. - * - * @return true if successful, false otherwise. + * Create a new BluetoothDevice + * Bluetooth MAC address must be upper case, such as "00:11:22:33:AA:BB", + * and is validated in this constructor. + * @param address valid Bluetooth MAC address + * @throws RuntimeException Bluetooth is not available on this platform + * @throws IllegalArgumentException address is invalid + * @hide */ - public boolean disable() { - try { - return mService.disable(true); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } + /*package*/ BluetoothDevice(String address) { + synchronized (BluetoothDevice.class) { + if (sService == null) { + IBinder b = ServiceManager.getService(Context.BLUETOOTH_SERVICE); + if (b == null) { + throw new RuntimeException("Bluetooth service not available"); + } + sService = IBluetooth.Stub.asInterface(b); + } + } - public String getAddress() { - try { - return mService.getAddress(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } + if (!checkBluetoothAddress(address)) { + throw new IllegalArgumentException(address + " is not a valid Bluetooth address"); + } - /** - * Get the friendly Bluetooth name of this device. - * - * This name is visible to remote Bluetooth devices. Currently it is only - * possible to retrieve the Bluetooth name when Bluetooth is enabled. - * - * @return the Bluetooth name, or null if there was a problem. - */ - public String getName() { - try { - return mService.getName(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + mAddress = address; } - /** - * Set the friendly Bluetooth name of this device. - * - * This name is visible to remote Bluetooth devices. The Bluetooth Service - * is responsible for persisting this name. - * - * @param name the name to set - * @return true, if the name was successfully set. False otherwise. - */ - public boolean setName(String name) { - try { - return mService.setName(name); - } catch (RemoteException e) {Log.e(TAG, "", e);} + @Override + public boolean equals(Object o) { + if (o instanceof BluetoothDevice) { + return mAddress.equals(((BluetoothDevice)o).getAddress()); + } return false; } - public String getVersion() { - try { - return mService.getVersion(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } - public String getRevision() { - try { - return mService.getRevision(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } - public String getManufacturer() { - try { - return mService.getManufacturer(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } - public String getCompany() { - try { - return mService.getCompany(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + @Override + public int hashCode() { + return mAddress.hashCode(); } /** - * Get the current scan mode. - * Used to determine if the local device is connectable and/or discoverable - * @return Scan mode, one of SCAN_MODE_* or an error code + * Returns a string representation of this BluetoothDevice. + * <p>Currently this is the Bluetooth hardware address, for example + * "00:11:22:AA:BB:CC". However, you should always use {@link #getAddress} + * if you explicitly require the Bluetooth hardware address in case the + * {@link #toString} representation changes in the future. + * @return string representation of this BluetoothDevice */ - public int getScanMode() { - try { - return mService.getScanMode(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return BluetoothError.ERROR_IPC; - } - - /** - * Set the current scan mode. - * Used to make the local device connectable and/or discoverable - * @param scanMode One of SCAN_MODE_* - */ - public void setScanMode(int scanMode) { - try { - mService.setScanMode(scanMode); - } catch (RemoteException e) {Log.e(TAG, "", e);} - } - - public int getDiscoverableTimeout() { - try { - return mService.getDiscoverableTimeout(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return -1; - } - public void setDiscoverableTimeout(int timeout) { - try { - mService.setDiscoverableTimeout(timeout); - } catch (RemoteException e) {Log.e(TAG, "", e);} - } - - public boolean startDiscovery() { - return startDiscovery(true); - } - public boolean startDiscovery(boolean resolveNames) { - try { - return mService.startDiscovery(resolveNames); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } - - public void cancelDiscovery() { - try { - mService.cancelDiscovery(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - } - - public boolean isDiscovering() { - try { - return mService.isDiscovering(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; + @Override + public String toString() { + return mAddress; } - public boolean startPeriodicDiscovery() { - try { - return mService.startPeriodicDiscovery(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } - public boolean stopPeriodicDiscovery() { - try { - return mService.stopPeriodicDiscovery(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } - public boolean isPeriodicDiscovery() { - try { - return mService.isPeriodicDiscovery(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; + /** @hide */ + public int describeContents() { + return 0; } - public String[] listRemoteDevices() { - try { - return mService.listRemoteDevices(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } + /** @hide */ + public static final Parcelable.Creator<BluetoothDevice> CREATOR = + new Parcelable.Creator<BluetoothDevice>() { + public BluetoothDevice createFromParcel(Parcel in) { + return new BluetoothDevice(in.readString()); + } + public BluetoothDevice[] newArray(int size) { + return new BluetoothDevice[size]; + } + }; - /** - * List remote devices that have a low level (ACL) connection. - * - * RFCOMM, SDP and L2CAP are all built on ACL connections. Devices can have - * an ACL connection even when not paired - this is common for SDP queries - * or for in-progress pairing requests. - * - * In most cases you probably want to test if a higher level protocol is - * connected, rather than testing ACL connections. - * - * @return bluetooth hardware addresses of remote devices with a current - * ACL connection. Array size is 0 if no devices have a - * connection. Null on error. - */ - public String[] listAclConnections() { - try { - return mService.listAclConnections(); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + /** @hide */ + public void writeToParcel(Parcel out, int flags) { + out.writeString(mAddress); } /** - * Check if a specified remote device has a low level (ACL) connection. - * - * RFCOMM, SDP and L2CAP are all built on ACL connections. Devices can have - * an ACL connection even when not paired - this is common for SDP queries - * or for in-progress pairing requests. - * - * In most cases you probably want to test if a higher level protocol is - * connected, rather than testing ACL connections. - * - * @param address the Bluetooth hardware address you want to check. - * @return true if there is an ACL connection, false otherwise and on - * error. + * Returns the hardware address of this BluetoothDevice. + * <p> For example, "00:11:22:AA:BB:CC". + * @return Bluetooth hardware address as string */ - public boolean isAclConnected(String address) { - try { - return mService.isAclConnected(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; + public String getAddress() { + return mAddress; } /** - * Perform a low level (ACL) disconnection of a remote device. + * Get the friendly Bluetooth name of the remote device. * - * This forcably disconnects the ACL layer connection to a remote device, - * which will cause all RFCOMM, SDP and L2CAP connections to this remote - * device to close. + * <p>The local adapter will automatically retrieve remote names when + * performing a device scan, and will cache them. This method just returns + * the name for this device from the cache. * - * @param address the Bluetooth hardware address you want to disconnect. - * @return true if the device was disconnected, false otherwise and on - * error. + * @return the Bluetooth name, or null if there was a problem. + * @hide */ - public boolean disconnectRemoteDeviceAcl(String address) { + public String getName() { try { - return mService.disconnectRemoteDeviceAcl(address); + return sService.getRemoteName(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; + return null; } /** @@ -358,62 +213,39 @@ public class BluetoothDevice { * @param address the remote device Bluetooth address. * @return false If there was an immediate problem creating the bonding, * true otherwise. + * @hide */ - public boolean createBond(String address) { + public boolean createBond() { try { - return mService.createBond(address); + return sService.createBond(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} return false; } /** * Cancel an in-progress bonding request started with createBond. + * @hide */ - public boolean cancelBondProcess(String address) { - try { - return mService.cancelBondProcess(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } - - /** - * Remove an already exisiting bonding (delete the link key). - */ - public boolean removeBond(String address) { + public boolean cancelBondProcess() { try { - return mService.removeBond(address); + return sService.cancelBondProcess(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} return false; } /** - * List remote devices that are bonded (paired) to the local device. + * Removes the remote device and the pairing information associated + * with it. * - * Bonding (pairing) is the process by which the user enters a pin code for - * the device, which generates a shared link key, allowing for - * authentication and encryption of future connections. In Android we - * require bonding before RFCOMM or SCO connections can be made to a remote - * device. - * - * This function lists which remote devices we have a link key for. It does - * not cause any RF transmission, and does not check if the remote device - * still has it's link key with us. If the other side no longer has its - * link key then the RFCOMM or SCO connection attempt will result in an - * error. - * - * This function does not check if the remote device is in range. - * - * Remote devices that have an in-progress bonding attempt are not - * returned. - * - * @return bluetooth hardware addresses of remote devices that are - * bonded. Array size is 0 if no devices are bonded. Null on error. + * @return true if the device was disconnected, false otherwise and on + * error. + * @hide */ - public String[] listBonds() { + public boolean removeBond() { try { - return mService.listBonds(); + return sService.removeBond(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + return false; } /** @@ -425,106 +257,114 @@ public class BluetoothDevice { * * @param address Bluetooth hardware address of the remote device to check. * @return Result code + * @hide */ - public int getBondState(String address) { + public int getBondState() { try { - return mService.getBondState(address); + return sService.getBondState(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} return BluetoothError.ERROR_IPC; } - public String getRemoteName(String address) { + /** @hide */ + public int getBluetoothClass() { try { - return mService.getRemoteName(address); + return sService.getRemoteClass(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + return BluetoothError.ERROR_IPC; } - public String getRemoteVersion(String address) { + /** @hide */ + public String[] getUuids() { try { - return mService.getRemoteVersion(address); + return sService.getRemoteUuids(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} return null; } - public String getRemoteRevision(String address) { + + /** @hide */ + public int getServiceChannel(String uuid) { + try { + return sService.getRemoteServiceChannel(mAddress, uuid); + } catch (RemoteException e) {Log.e(TAG, "", e);} + return BluetoothError.ERROR_IPC; + } + + /** @hide */ + public boolean setPin(byte[] pin) { try { - return mService.getRemoteRevision(address); + return sService.setPin(mAddress, pin); } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + return false; } - public String getRemoteManufacturer(String address) { + + /** @hide */ + public boolean setPasskey(int passkey) { try { - return mService.getRemoteManufacturer(address); + return sService.setPasskey(mAddress, passkey); } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + return false; } - public String getRemoteCompany(String address) { + + /** @hide */ + public boolean setPairingConfirmation(boolean confirm) { try { - return mService.getRemoteCompany(address); + return sService.setPairingConfirmation(mAddress, confirm); } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + return false; } - /** - * Returns the RFCOMM channel associated with the 16-byte UUID on - * the remote Bluetooth address. - * - * Performs a SDP ServiceSearchAttributeRequest transaction. The provided - * uuid is verified in the returned record. If there was a problem, or the - * specified uuid does not exist, -1 is returned. - */ - public boolean getRemoteServiceChannel(String address, short uuid16, - IBluetoothDeviceCallback callback) { + /** @hide */ + public boolean cancelPairingUserInput() { try { - return mService.getRemoteServiceChannel(address, uuid16, callback); + return sService.cancelPairingUserInput(mAddress); } catch (RemoteException e) {Log.e(TAG, "", e);} return false; } /** - * Get the major, minor and servics classes of a remote device. - * These classes are encoded as a 32-bit integer. See BluetoothClass. - * @param address remote device - * @return 32-bit class suitable for use with BluetoothClass, or - * BluetoothClass.ERROR on error + * Create an RFCOMM {@link BluetoothSocket} ready to start a secure + * outgoing connection to this remote device. + * <p>The remote device will be authenticated and communication on this + * socket will be encrypted. + * <p>Use {@link BluetoothSocket#connect} to intiate the outgoing + * connection. + * <p>Valid RFCOMM channels are in range 1 to 30. + * @param channel RFCOMM channel to connect to + * @return a RFCOMM BluetoothServerSocket ready for an outgoing connection + * @throws IOException on error, for example Bluetooth not available, or + * insufficient permissions */ - public int getRemoteClass(String address) { - try { - return mService.getRemoteClass(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return BluetoothClass.ERROR; + public BluetoothSocket createRfcommSocket(int channel) throws IOException { + return new BluetoothSocket(BluetoothSocket.TYPE_RFCOMM, -1, true, true, this, channel); } - public byte[] getRemoteFeatures(String address) { - try { - return mService.getRemoteFeatures(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } - public String lastSeen(String address) { - try { - return mService.lastSeen(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; - } - public String lastUsed(String address) { - try { - return mService.lastUsed(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return null; + /** + * Construct an insecure RFCOMM socket ready to start an outgoing + * connection. + * Call #connect on the returned #BluetoothSocket to begin the connection. + * The remote device will not be authenticated and communication on this + * socket will not be encrypted. + * @param port remote port + * @return An RFCOMM BluetoothSocket + * @throws IOException On error, for example Bluetooth not available, or + * insufficient permissions. + * @hide + */ + public BluetoothSocket createInsecureRfcommSocket(int port) throws IOException { + return new BluetoothSocket(BluetoothSocket.TYPE_RFCOMM, -1, false, false, this, port); } - public boolean setPin(String address, byte[] pin) { - try { - return mService.setPin(address, pin); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; - } - public boolean cancelPin(String address) { - try { - return mService.cancelPin(address); - } catch (RemoteException e) {Log.e(TAG, "", e);} - return false; + /** + * Construct a SCO socket ready to start an outgoing connection. + * Call #connect on the returned #BluetoothSocket to begin the connection. + * @return a SCO BluetoothSocket + * @throws IOException on error, for example Bluetooth not available, or + * insufficient permissions. + * @hide + */ + public BluetoothSocket createScoSocket() throws IOException { + return new BluetoothSocket(BluetoothSocket.TYPE_SCO, -1, true, true, this, -1); } /** @@ -534,6 +374,7 @@ public class BluetoothDevice { * @param pin pin as java String * @return the pin code as a UTF8 byte array, or null if it is an invalid * Bluetooth pin. + * @hide */ public static byte[] convertPinToBytes(String pin) { if (pin == null) { @@ -552,8 +393,8 @@ public class BluetoothDevice { return pinBytes; } - private static final int ADDRESS_LENGTH = 17; - /** Sanity check a bluetooth address, such as "00:43:A8:23:10:F0" */ + /** Sanity check a bluetooth address, such as "00:43:A8:23:10:F0" + * @hide */ public static boolean checkBluetoothAddress(String address) { if (address == null || address.length() != ADDRESS_LENGTH) { return false; diff --git a/core/java/android/bluetooth/BluetoothHeadset.java b/core/java/android/bluetooth/BluetoothHeadset.java index fe1e09a..d31b6ae 100644 --- a/core/java/android/bluetooth/BluetoothHeadset.java +++ b/core/java/android/bluetooth/BluetoothHeadset.java @@ -49,7 +49,7 @@ import android.util.Log; * * @hide */ -public class BluetoothHeadset { +public final class BluetoothHeadset { private static final String TAG = "BluetoothHeadset"; private static final boolean DBG = false; @@ -163,16 +163,16 @@ public class BluetoothHeadset { } /** - * Get the Bluetooth address of the current headset. - * @return The Bluetooth address, or null if not in connected or connecting + * Get the BluetoothDevice for the current headset. + * @return current headset, or null if not in connected or connecting * state, or if this proxy object is not connected to the Headset * service. */ - public String getHeadsetAddress() { - if (DBG) log("getHeadsetAddress()"); + public BluetoothDevice getCurrentHeadset() { + if (DBG) log("getCurrentHeadset()"); if (mService != null) { try { - return mService.getHeadsetAddress(); + return mService.getCurrentHeadset(); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); @@ -185,19 +185,19 @@ public class BluetoothHeadset { * Request to initiate a connection to a headset. * This call does not block. Fails if a headset is already connecting * or connected. - * Initiates auto-connection if address is null. Tries to connect to all + * Initiates auto-connection if device is null. Tries to connect to all * devices with priority greater than PRIORITY_AUTO in descending order. - * @param address The Bluetooth Address to connect to, or null to - * auto-connect to the last connected headset. - * @return False if there was a problem initiating the connection - * procedure, and no further HEADSET_STATE_CHANGED intents - * will be expected. + * @param device device to connect to, or null to auto-connect last connected + * headset + * @return false if there was a problem initiating the connection + * procedure, and no further HEADSET_STATE_CHANGED intents + * will be expected. */ - public boolean connectHeadset(String address) { - if (DBG) log("connectHeadset(" + address + ")"); + public boolean connectHeadset(BluetoothDevice device) { + if (DBG) log("connectHeadset(" + device + ")"); if (mService != null) { try { - if (mService.connectHeadset(address)) { + if (mService.connectHeadset(device)) { return true; } } catch (RemoteException e) {Log.e(TAG, e.toString());} @@ -213,11 +213,11 @@ public class BluetoothHeadset { * connecting). Returns false if not connected, or if this proxy object * if not currently connected to the headset service. */ - public boolean isConnected(String address) { - if (DBG) log("isConnected(" + address + ")"); + public boolean isConnected(BluetoothDevice device) { + if (DBG) log("isConnected(" + device + ")"); if (mService != null) { try { - return mService.isConnected(address); + return mService.isConnected(device); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); @@ -295,16 +295,16 @@ public class BluetoothHeadset { * auto-connected. * Incoming connections are ignored regardless of priority if there is * already a headset connected. - * @param address Paired headset + * @param device paired headset * @param priority Integer priority, for example PRIORITY_AUTO or * PRIORITY_NONE - * @return True if successful, false if there was some error. + * @return true if successful, false if there was some error */ - public boolean setPriority(String address, int priority) { - if (DBG) log("setPriority(" + address + ", " + priority + ")"); + public boolean setPriority(BluetoothDevice device, int priority) { + if (DBG) log("setPriority(" + device + ", " + priority + ")"); if (mService != null) { try { - return mService.setPriority(address, priority); + return mService.setPriority(device, priority); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); @@ -315,14 +315,14 @@ public class BluetoothHeadset { /** * Get priority of headset. - * @param address Headset - * @return non-negative priority, or negative error code on error. + * @param device headset + * @return non-negative priority, or negative error code on error */ - public int getPriority(String address) { - if (DBG) log("getPriority(" + address + ")"); + public int getPriority(BluetoothDevice device) { + if (DBG) log("getPriority(" + device + ")"); if (mService != null) { try { - return mService.getPriority(address); + return mService.getPriority(device); } catch (RemoteException e) {Log.e(TAG, e.toString());} } else { Log.w(TAG, "Proxy not attached to service"); @@ -356,30 +356,6 @@ public class BluetoothHeadset { return -1; } - /** - * Check class bits for possible HSP or HFP support. - * This is a simple heuristic that tries to guess if a device with the - * given class bits might support HSP or HFP. It is not accurate for all - * devices. It tries to err on the side of false positives. - * @return True if this device might support HSP or HFP. - */ - public static boolean doesClassMatch(int btClass) { - // The render service class is required by the spec for HFP, so is a - // pretty good signal - if (BluetoothClass.Service.hasService(btClass, BluetoothClass.Service.RENDER)) { - return true; - } - // Just in case they forgot the render service class - switch (BluetoothClass.Device.getDevice(btClass)) { - case BluetoothClass.Device.AUDIO_VIDEO_HANDSFREE: - case BluetoothClass.Device.AUDIO_VIDEO_WEARABLE_HEADSET: - case BluetoothClass.Device.AUDIO_VIDEO_CAR_AUDIO: - return true; - default: - return false; - } - } - private ServiceConnection mConnection = new ServiceConnection() { public void onServiceConnected(ComponentName className, IBinder service) { if (DBG) Log.d(TAG, "Proxy object connected"); diff --git a/core/java/android/bluetooth/BluetoothInputStream.java b/core/java/android/bluetooth/BluetoothInputStream.java new file mode 100644 index 0000000..c060f32 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothInputStream.java @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import java.io.IOException; +import java.io.InputStream; + +/** + * BluetoothInputStream. + * + * Used to write to a Bluetooth socket. + * + * @hide + */ +/*package*/ final class BluetoothInputStream extends InputStream { + private BluetoothSocket mSocket; + + /*package*/ BluetoothInputStream(BluetoothSocket s) { + mSocket = s; + } + + /** + * Return number of bytes available before this stream will block. + */ + public int available() throws IOException { + return mSocket.availableNative(); + } + + public void close() throws IOException { + mSocket.close(); + } + + /** + * Reads a single byte from this stream and returns it as an integer in the + * range from 0 to 255. Returns -1 if the end of the stream has been + * reached. Blocks until one byte has been read, the end of the source + * stream is detected or an exception is thrown. + * + * @return the byte read or -1 if the end of stream has been reached. + * @throws IOException + * if the stream is closed or another IOException occurs. + * @since Android 1.5 + */ + public int read() throws IOException { + byte b[] = new byte[1]; + int ret = mSocket.readNative(b, 0, 1); + if (ret == 1) { + return (int)b[0] & 0xff; + } else { + return -1; + } + } + + /** + * Reads at most {@code length} bytes from this stream and stores them in + * the byte array {@code b} starting at {@code offset}. + * + * @param b + * the byte array in which to store the bytes read. + * @param offset + * the initial position in {@code buffer} to store the bytes + * read from this stream. + * @param length + * the maximum number of bytes to store in {@code b}. + * @return the number of bytes actually read or -1 if the end of the stream + * has been reached. + * @throws IndexOutOfBoundsException + * if {@code offset < 0} or {@code length < 0}, or if + * {@code offset + length} is greater than the length of + * {@code b}. + * @throws IOException + * if the stream is closed or another IOException occurs. + * @since Android 1.5 + */ + public int read(byte[] b, int offset, int length) throws IOException { + if (b == null) { + throw new NullPointerException("byte array is null"); + } + if ((offset | length) < 0 || length > b.length - offset) { + throw new ArrayIndexOutOfBoundsException("invalid offset or length"); + } + return mSocket.readNative(b, offset, length); + } +} diff --git a/core/java/android/bluetooth/BluetoothIntent.java b/core/java/android/bluetooth/BluetoothIntent.java index 344601b..c39bc3d 100644 --- a/core/java/android/bluetooth/BluetoothIntent.java +++ b/core/java/android/bluetooth/BluetoothIntent.java @@ -31,8 +31,8 @@ import android.annotation.SdkConstant.SdkConstantType; public interface BluetoothIntent { public static final String SCAN_MODE = "android.bluetooth.intent.SCAN_MODE"; - public static final String ADDRESS = - "android.bluetooth.intent.ADDRESS"; + public static final String DEVICE = + "android.bluetooth.intent.DEVICE"; public static final String NAME = "android.bluetooth.intent.NAME"; public static final String ALIAS = @@ -57,6 +57,39 @@ public interface BluetoothIntent { "android.bluetooth.intent.BOND_PREVIOUS_STATE"; public static final String REASON = "android.bluetooth.intent.REASON"; + public static final String PAIRING_VARIANT = + "android.bluetooth.intent.PAIRING_VARIANT"; + public static final String PASSKEY = + "android.bluetooth.intent.PASSKEY"; + + public static final String DEVICE_PICKER_NEED_AUTH = + "android.bluetooth.intent.DEVICE_PICKER_NEED_AUTH"; + public static final String DEVICE_PICKER_FILTER_TYPE = + "android.bluetooth.intent.DEVICE_PICKER_FILTER_TYPE"; + public static final String DEVICE_PICKER_LAUNCH_PACKAGE = + "android.bluetooth.intent.DEVICE_PICKER_LAUNCH_PACKAGE"; + public static final String DEVICE_PICKER_LAUNCH_CLASS = + "android.bluetooth.intent.DEVICE_PICKER_LAUNCH_CLASS"; + + /** + * Broadcast when one BT device is selected from BT device picker screen. + * Selected BT device address is contained in extra string "BluetoothIntent.ADDRESS". + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String DEVICE_PICKER_DEVICE_SELECTED = + "android.bluetooth.intent.action.DEVICE_SELECTED"; + + /** + * Broadcast when someone want to select one BT device from devices list. + * This intent contains below extra data: + * - BluetoothIntent.DEVICE_PICKER_NEED_AUTH (boolean): if need authentication + * - BluetoothIntent.DEVICE_PICKER_FILTER_TYPE (int): what kinds of device should be listed + * - BluetoothIntent.DEVICE_PICKER_LAUNCH_PACKAGE (string): where(which package) this intent come from + * - BluetoothIntent.DEVICE_PICKER_LAUNCH_CLASS (string): where(which class) this intent come from + */ + @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) + public static final String DEVICE_PICKER_DEVICE_PICKER = + "android.bluetooth.intent.action.DEVICE_PICKER"; /** Broadcast when the local Bluetooth device state changes, for example * when Bluetooth is enabled. Will contain int extra's BLUETOOTH_STATE and diff --git a/core/java/android/bluetooth/BluetoothOutputStream.java b/core/java/android/bluetooth/BluetoothOutputStream.java new file mode 100644 index 0000000..7e2ead4 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothOutputStream.java @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import java.io.IOException; +import java.io.OutputStream; + +/** + * BluetoothOutputStream. + * + * Used to read from a Bluetooth socket. + * + * @hide + */ +/*package*/ final class BluetoothOutputStream extends OutputStream { + private BluetoothSocket mSocket; + + /*package*/ BluetoothOutputStream(BluetoothSocket s) { + mSocket = s; + } + + /** + * Close this output stream and the socket associated with it. + */ + public void close() throws IOException { + mSocket.close(); + } + + /** + * Writes a single byte to this stream. Only the least significant byte of + * the integer {@code oneByte} is written to the stream. + * + * @param oneByte + * the byte to be written. + * @throws IOException + * if an error occurs while writing to this stream. + * @since Android 1.0 + */ + public void write(int oneByte) throws IOException { + byte b[] = new byte[1]; + b[0] = (byte)oneByte; + mSocket.writeNative(b, 0, 1); + } + + /** + * Writes {@code count} bytes from the byte array {@code buffer} starting + * at position {@code offset} to this stream. + * + * @param b + * the buffer to be written. + * @param offset + * the start position in {@code buffer} from where to get bytes. + * @param count + * the number of bytes from {@code buffer} to write to this + * stream. + * @throws IOException + * if an error occurs while writing to this stream. + * @throws IndexOutOfBoundsException + * if {@code offset < 0} or {@code count < 0}, or if + * {@code offset + count} is bigger than the length of + * {@code buffer}. + * @since Android 1.0 + */ + public void write(byte[] b, int offset, int count) throws IOException { + if (b == null) { + throw new NullPointerException("buffer is null"); + } + if ((offset | count) < 0 || count > b.length - offset) { + throw new IndexOutOfBoundsException("invalid offset or length"); + } + mSocket.writeNative(b, offset, count); + } +} diff --git a/core/java/android/bluetooth/BluetoothPbap.java b/core/java/android/bluetooth/BluetoothPbap.java new file mode 100644 index 0000000..645e241 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothPbap.java @@ -0,0 +1,257 @@ +/* + * Copyright (C) 2008 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.bluetooth; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.ServiceConnection; +import android.os.RemoteException; +import android.os.IBinder; +import android.os.ServiceManager; +import android.util.Log; + +/** + * The Android Bluetooth API is not finalized, and *will* change. Use at your + * own risk. + * + * Public API for controlling the Bluetooth Pbap Service. This includes + * Bluetooth Phone book Access profile. + * BluetoothPbap is a proxy object for controlling the Bluetooth Pbap + * Service via IPC. + * + * Creating a BluetoothPbap object will create a binding with the + * BluetoothPbap service. Users of this object should call close() when they + * are finished with the BluetoothPbap, so that this proxy object can unbind + * from the service. + * + * This BluetoothPbap object is not immediately bound to the + * BluetoothPbap service. Use the ServiceListener interface to obtain a + * notification when it is bound, this is especially important if you wish to + * immediately call methods on BluetoothPbap after construction. + * + * Android only supports one connected Bluetooth Pce at a time. + * + * @hide + */ +public class BluetoothPbap { + + private static final String TAG = "BluetoothPbap"; + private static final boolean DBG = false; + + /** int extra for PBAP_STATE_CHANGED_ACTION */ + public static final String PBAP_STATE = + "android.bluetooth.pbap.intent.PBAP_STATE"; + /** int extra for PBAP_STATE_CHANGED_ACTION */ + public static final String PBAP_PREVIOUS_STATE = + "android.bluetooth.pbap.intent.PBAP_PREVIOUS_STATE"; + + /** Indicates the state of an pbap connection state has changed. + * This intent will always contain PBAP_STATE, PBAP_PREVIOUS_STATE and + * BluetoothIntent.ADDRESS extras. + */ + public static final String PBAP_STATE_CHANGED_ACTION = + "android.bluetooth.pbap.intent.action.PBAP_STATE_CHANGED"; + + private IBluetoothPbap mService; + private final Context mContext; + private final ServiceListener mServiceListener; + + /** There was an error trying to obtain the state */ + public static final int STATE_ERROR = -1; + /** No client currently connected */ + public static final int STATE_DISCONNECTED = 0; + /** Connection attempt in progress */ + public static final int STATE_CONNECTING = 1; + /** Client is currently connected */ + public static final int STATE_CONNECTED = 2; + + public static final int RESULT_FAILURE = 0; + public static final int RESULT_SUCCESS = 1; + /** Connection canceled before completion. */ + public static final int RESULT_CANCELED = 2; + + /** + * An interface for notifying Bluetooth PCE IPC clients when they have + * been connected to the BluetoothPbap service. + */ + public interface ServiceListener { + /** + * Called to notify the client when this proxy object has been + * connected to the BluetoothPbap service. Clients must wait for + * this callback before making IPC calls on the BluetoothPbap + * service. + */ + public void onServiceConnected(); + + /** + * Called to notify the client that this proxy object has been + * disconnected from the BluetoothPbap service. Clients must not + * make IPC calls on the BluetoothPbap service after this callback. + * This callback will currently only occur if the application hosting + * the BluetoothPbap service, but may be called more often in future. + */ + public void onServiceDisconnected(); + } + + /** + * Create a BluetoothPbap proxy object. + */ + public BluetoothPbap(Context context, ServiceListener l) { + mContext = context; + mServiceListener = l; + if (!context.bindService(new Intent(IBluetoothPbap.class.getName()), mConnection, 0)) { + Log.e(TAG, "Could not bind to Bluetooth Pbap Service"); + } + } + + protected void finalize() throws Throwable { + try { + close(); + } finally { + super.finalize(); + } + } + + /** + * Close the connection to the backing service. + * Other public functions of BluetoothPbap will return default error + * results once close() has been called. Multiple invocations of close() + * are ok. + */ + public synchronized void close() { + if (mConnection != null) { + mContext.unbindService(mConnection); + mConnection = null; + } + } + + /** + * Get the current state of the BluetoothPbap service. + * @return One of the STATE_ return codes, or STATE_ERROR if this proxy + * object is currently not connected to the Pbap service. + */ + public int getState() { + if (DBG) log("getState()"); + if (mService != null) { + try { + return mService.getState(); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } else { + Log.w(TAG, "Proxy not attached to service"); + if (DBG) log(Log.getStackTraceString(new Throwable())); + } + return BluetoothPbap.STATE_ERROR; + } + + /** + * Get the currently connected remote Bluetooth device (PCE). + * @return The remote Bluetooth device, or null if not in connected or + * connecting state, or if this proxy object is not connected to + * the Pbap service. + */ + public BluetoothDevice getClient() { + if (DBG) log("getClient()"); + if (mService != null) { + try { + return mService.getClient(); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } else { + Log.w(TAG, "Proxy not attached to service"); + if (DBG) log(Log.getStackTraceString(new Throwable())); + } + return null; + } + + /** + * Returns true if the specified Bluetooth device is connected (does not + * include connecting). Returns false if not connected, or if this proxy + * object is not currently connected to the Pbap service. + */ + public boolean isConnected(BluetoothDevice device) { + if (DBG) log("isConnected(" + device + ")"); + if (mService != null) { + try { + return mService.isConnected(device); + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } else { + Log.w(TAG, "Proxy not attached to service"); + if (DBG) log(Log.getStackTraceString(new Throwable())); + } + return false; + } + + /** + * Disconnects the current Pbap client (PCE). Currently this call blocks, + * it may soon be made asynchornous. Returns false if this proxy object is + * not currently connected to the Pbap service. + */ + public boolean disconnect() { + if (DBG) log("disconnect()"); + if (mService != null) { + try { + mService.disconnect(); + return true; + } catch (RemoteException e) {Log.e(TAG, e.toString());} + } else { + Log.w(TAG, "Proxy not attached to service"); + if (DBG) log(Log.getStackTraceString(new Throwable())); + } + return false; + } + + /** + * Check class bits for possible PBAP support. + * This is a simple heuristic that tries to guess if a device with the + * given class bits might support PBAP. It is not accurate for all + * devices. It tries to err on the side of false positives. + * @return True if this device might support PBAP. + */ + public static boolean doesClassMatchSink(int btClass) { + // TODO optimize the rule + switch (BluetoothClass.Device.getDevice(btClass)) { + case BluetoothClass.Device.COMPUTER_DESKTOP: + case BluetoothClass.Device.COMPUTER_LAPTOP: + case BluetoothClass.Device.COMPUTER_SERVER: + case BluetoothClass.Device.COMPUTER_UNCATEGORIZED: + return true; + default: + return false; + } + } + + private ServiceConnection mConnection = new ServiceConnection() { + public void onServiceConnected(ComponentName className, IBinder service) { + if (DBG) log("Proxy object connected"); + mService = IBluetoothPbap.Stub.asInterface(service); + if (mServiceListener != null) { + mServiceListener.onServiceConnected(); + } + } + public void onServiceDisconnected(ComponentName className) { + if (DBG) log("Proxy object disconnected"); + mService = null; + if (mServiceListener != null) { + mServiceListener.onServiceDisconnected(); + } + } + }; + + private static void log(String msg) { + Log.d(TAG, msg); + } +} diff --git a/core/java/android/bluetooth/BluetoothServerSocket.java b/core/java/android/bluetooth/BluetoothServerSocket.java new file mode 100644 index 0000000..e653c23 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothServerSocket.java @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import java.io.Closeable; +import java.io.IOException; + +/** + * A listening Bluetooth socket. + * + * <p>The interface for Bluetooth Sockets is similar to that of TCP sockets: + * {@link java.net.Socket} and {@link java.net.ServerSocket}. On the server + * side, use a {@link BluetoothServerSocket} to create a listening server + * socket. It will return a new, connected {@link BluetoothSocket} on an + * accepted connection. On the client side, use the same + * {@link BluetoothSocket} object to both intiate the outgoing connection, + * and to manage the connected socket. + * + * <p>The most common type of Bluetooth Socket is RFCOMM. RFCOMM is a + * connection orientated, streaming transport over Bluetooth. It is also known + * as the Serial Port Profile (SPP). + * + * <p>Use {@link BluetoothDevice#createRfcommSocket} to create a new {@link + * BluetoothSocket} ready for an outgoing connection to a remote + * {@link BluetoothDevice}. + * + * <p>Use {@link BluetoothAdapter#listenUsingRfcommOn} to create a listening + * {@link BluetoothServerSocket} ready for incoming connections to the local + * {@link BluetoothAdapter}. + * + * <p>{@link BluetoothSocket} and {@link BluetoothServerSocket} are thread + * safe. In particular, {@link #close} will always immediately abort ongoing + * operations and close the socket. + */ +public final class BluetoothServerSocket implements Closeable { + /*package*/ final BluetoothSocket mSocket; + + /** + * Construct a socket for incoming connections. + * @param type type of socket + * @param auth require the remote device to be authenticated + * @param encrypt require the connection to be encrypted + * @param port remote port + * @throws IOException On error, for example Bluetooth not available, or + * insufficient priveleges + */ + /*package*/ BluetoothServerSocket(int type, boolean auth, boolean encrypt, int port) + throws IOException { + mSocket = new BluetoothSocket(type, -1, auth, encrypt, null, port); + } + + /** + * Block until a connection is established. + * <p>Returns a connected {@link BluetoothSocket} on successful connection. + * <p>Once this call returns, it can be called again to accept subsequent + * incoming connections. + * <p>{@link #close} can be used to abort this call from another thread. + * @return a connected {@link BluetoothSocket} + * @throws IOException on error, for example this call was aborted, or + * timeout + */ + public BluetoothSocket accept() throws IOException { + return accept(-1); + } + + /** + * Block until a connection is established, with timeout. + * <p>Returns a connected {@link BluetoothSocket} on successful connection. + * <p>Once this call returns, it can be called again to accept subsequent + * incoming connections. + * <p>{@link #close} can be used to abort this call from another thread. + * @return a connected {@link BluetoothSocket} + * @throws IOException on error, for example this call was aborted, or + * timeout + */ + public BluetoothSocket accept(int timeout) throws IOException { + return mSocket.acceptNative(timeout); + } + + /** + * Immediately close this socket, and release all associated resources. + * <p>Causes blocked calls on this socket in other threads to immediately + * throw an IOException. + */ + public void close() throws IOException { + mSocket.closeNative(); + } +} diff --git a/core/java/android/bluetooth/BluetoothSocket.java b/core/java/android/bluetooth/BluetoothSocket.java new file mode 100644 index 0000000..eae0f37 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothSocket.java @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import java.io.Closeable; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +/** + * A connected or connecting Bluetooth socket. + * + * <p>The interface for Bluetooth Sockets is similar to that of TCP sockets: + * {@link java.net.Socket} and {@link java.net.ServerSocket}. On the server + * side, use a {@link BluetoothServerSocket} to create a listening server + * socket. It will return a new, connected {@link BluetoothSocket} on an + * accepted connection. On the client side, use the same + * {@link BluetoothSocket} object to both intiate the outgoing connection, + * and to manage the connected socket. + * + * <p>The most common type of Bluetooth Socket is RFCOMM. RFCOMM is a + * connection orientated, streaming transport over Bluetooth. It is also known + * as the Serial Port Profile (SPP). + * + * <p>Use {@link BluetoothDevice#createRfcommSocket} to create a new {@link + * BluetoothSocket} ready for an outgoing connection to a remote + * {@link BluetoothDevice}. + * + * <p>Use {@link BluetoothAdapter#listenUsingRfcommOn} to create a listening + * {@link BluetoothServerSocket} ready for incoming connections to the local + * {@link BluetoothAdapter}. + * + * <p>{@link BluetoothSocket} and {@link BluetoothServerSocket} are thread + * safe. In particular, {@link #close} will always immediately abort ongoing + * operations and close the socket. + */ +public final class BluetoothSocket implements Closeable { + /** Keep TYPE_ fields in sync with BluetoothSocket.cpp */ + /*package*/ static final int TYPE_RFCOMM = 1; + /*package*/ static final int TYPE_SCO = 2; + /*package*/ static final int TYPE_L2CAP = 3; + + private final int mType; /* one of TYPE_RFCOMM etc */ + private final int mPort; /* RFCOMM channel or L2CAP psm */ + private final BluetoothDevice mDevice; /* remote device */ + private final String mAddress; /* remote address */ + private final boolean mAuth; + private final boolean mEncrypt; + private final BluetoothInputStream mInputStream; + private final BluetoothOutputStream mOutputStream; + + private int mSocketData; /* used by native code only */ + + /** + * Construct a BluetoothSocket. + * @param type type of socket + * @param fd fd to use for connected socket, or -1 for a new socket + * @param auth require the remote device to be authenticated + * @param encrypt require the connection to be encrypted + * @param device remote device that this socket can connect to + * @param port remote port + * @throws IOException On error, for example Bluetooth not available, or + * insufficient priveleges + */ + /*package*/ BluetoothSocket(int type, int fd, boolean auth, boolean encrypt, + BluetoothDevice device, int port) throws IOException { + mType = type; + mAuth = auth; + mEncrypt = encrypt; + mDevice = device; + if (device == null) { + mAddress = null; + } else { + mAddress = device.getAddress(); + } + mPort = port; + if (fd == -1) { + initSocketNative(); + } else { + initSocketFromFdNative(fd); + } + mInputStream = new BluetoothInputStream(this); + mOutputStream = new BluetoothOutputStream(this); + } + + /** + * Construct a BluetoothSocket from address. + * @param type type of socket + * @param fd fd to use for connected socket, or -1 for a new socket + * @param auth require the remote device to be authenticated + * @param encrypt require the connection to be encrypted + * @param address remote device that this socket can connect to + * @param port remote port + * @throws IOException On error, for example Bluetooth not available, or + * insufficient priveleges + */ + private BluetoothSocket(int type, int fd, boolean auth, boolean encrypt, String address, + int port) throws IOException { + this(type, fd, auth, encrypt, new BluetoothDevice(address), port); + } + + /** @hide */ + @Override + protected void finalize() throws Throwable { + try { + close(); + } finally { + super.finalize(); + } + } + + /** + * Attempt to connect to a remote device. + * <p>This method will block until a connection is made or the connection + * fails. If this method returns without an exception then this socket + * is now connected. + * <p>{@link #close} can be used to abort this call from another thread. + * @throws IOException on error, for example connection failure + */ + public void connect() throws IOException { + connectNative(); + } + + /** + * Immediately close this socket, and release all associated resources. + * <p>Causes blocked calls on this socket in other threads to immediately + * throw an IOException. + */ + public void close() throws IOException { + closeNative(); + } + + /** + * Get the remote device this socket is connecting, or connected, to. + * @return remote device + */ + public BluetoothDevice getRemoteDevice() { + return mDevice; + } + + /** + * Get the input stream associated with this socket. + * <p>The input stream will be returned even if the socket is not yet + * connected, but operations on that stream will throw IOException until + * the associated socket is connected. + * @return InputStream + */ + public InputStream getInputStream() throws IOException { + return mInputStream; + } + + /** + * Get the output stream associated with this socket. + * <p>The output stream will be returned even if the socket is not yet + * connected, but operations on that stream will throw IOException until + * the associated socket is connected. + * @return OutputStream + */ + public OutputStream getOutputStream() throws IOException { + return mOutputStream; + } + + private native void initSocketNative() throws IOException; + private native void initSocketFromFdNative(int fd) throws IOException; + private native void connectNative() throws IOException; + /*package*/ native void bindListenNative() throws IOException; + /*package*/ native BluetoothSocket acceptNative(int timeout) throws IOException; + /*package*/ native int availableNative() throws IOException; + /*package*/ native int readNative(byte[] b, int offset, int length) throws IOException; + /*package*/ native int writeNative(byte[] b, int offset, int length) throws IOException; + /*package*/ native void closeNative() throws IOException; + private native void destroyNative() throws IOException; +} diff --git a/core/java/android/bluetooth/BluetoothUuid.java b/core/java/android/bluetooth/BluetoothUuid.java new file mode 100644 index 0000000..1ec7fb3 --- /dev/null +++ b/core/java/android/bluetooth/BluetoothUuid.java @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2009 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.bluetooth; + +import java.util.UUID; + +/** +* Static helper methods and constants to decode the UUID of remote devices. +* @hide +*/ +public final class BluetoothUuid { + + /* See Bluetooth Assigned Numbers document - SDP section, to get the values of UUIDs + * for the various services. + * + * The following 128 bit values are calculated as: + * uuid * 2^96 + BASE_UUID + */ + public static final UUID AudioSink = UUID.fromString("0000110B-0000-1000-8000-00805F9B34FB"); + public static final UUID AudioSource = UUID.fromString("0000110A-0000-1000-8000-00805F9B34FB"); + public static final UUID AdvAudioDist = UUID.fromString("0000110D-0000-1000-8000-00805F9B34FB"); + public static final UUID HSP = UUID.fromString("00001108-0000-1000-8000-00805F9B34FB"); + public static final UUID Handsfree = UUID.fromString("0000111E-0000-1000-8000-00805F9B34FB"); + public static final UUID AvrcpController = + UUID.fromString("0000110E-0000-1000-8000-00805F9B34FB"); + + public static boolean isAudioSource(UUID uuid) { + return uuid.equals(AudioSource); + } + + public static boolean isAudioSink(UUID uuid) { + return uuid.equals(AudioSink); + } + + public static boolean isAdvAudioDist(UUID uuid) { + return uuid.equals(AdvAudioDist); + } + + public static boolean isHandsfree(UUID uuid) { + return uuid.equals(Handsfree); + } + + public static boolean isHeadset(UUID uuid) { + return uuid.equals(HSP); + } + + public static boolean isAvrcpController(UUID uuid) { + return uuid.equals(AvrcpController); + } +} diff --git a/core/java/android/bluetooth/Database.java b/core/java/android/bluetooth/Database.java deleted file mode 100644 index fef641a..0000000 --- a/core/java/android/bluetooth/Database.java +++ /dev/null @@ -1,200 +0,0 @@ -/* - * 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.bluetooth; - -import android.bluetooth.RfcommSocket; - -import android.util.Log; - -import java.io.*; -import java.util.*; - -/** - * The Android Bluetooth API is not finalized, and *will* change. Use at your - * own risk. - * - * A low-level API to the Service Discovery Protocol (SDP) Database. - * - * Allows service records to be added to the local SDP database. Once added, - * these services will be advertised to remote devices when they make SDP - * queries on this device. - * - * Currently this API is a thin wrapper to the bluez SDP Database API. See: - * http://wiki.bluez.org/wiki/Database - * http://wiki.bluez.org/wiki/HOWTO/ManagingServiceRecords - * @hide - */ -public final class Database { - private static Database mInstance; - - private static final String sLogName = "android.bluetooth.Database"; - - /** - * Class load time initialization - */ - static { - classInitNative(); - } - private native static void classInitNative(); - - /** - * Private to enforce singleton property - */ - private Database() { - initializeNativeDataNative(); - } - private native void initializeNativeDataNative(); - - protected void finalize() throws Throwable { - try { - cleanupNativeDataNative(); - } finally { - super.finalize(); - } - } - private native void cleanupNativeDataNative(); - - /** - * Singelton accessor - * @return The singleton instance of Database - */ - public static synchronized Database getInstance() { - if (mInstance == null) { - mInstance = new Database(); - } - return mInstance; - } - - /** - * Advertise a service with an RfcommSocket. - * - * This adds the service the SDP Database with the following attributes - * set: Service Name, Protocol Descriptor List, Service Class ID List - * TODO: Construct a byte[] record directly, rather than via XML. - * @param socket The rfcomm socket to advertise (by channel). - * @param serviceName A short name for this service - * @param uuid - * Unique identifier for this service, by which clients - * can search for your service - * @return Handle to the new service record - */ - public int advertiseRfcommService(RfcommSocket socket, - String serviceName, - UUID uuid) throws IOException { - String xmlRecord = - "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" + - "<record>\n" + - " <attribute id=\"0x0001\">\n" + // ServiceClassIDList - " <sequence>\n" + - " <uuid value=\"" - + uuid.toString() + // UUID for this service - "\"/>\n" + - " </sequence>\n" + - " </attribute>\n" + - " <attribute id=\"0x0004\">\n" + // ProtocolDescriptorList - " <sequence>\n" + - " <sequence>\n" + - " <uuid value=\"0x0100\"/>\n" + // L2CAP - " </sequence>\n" + - " <sequence>\n" + - " <uuid value=\"0x0003\"/>\n" + // RFCOMM - " <uint8 value=\"" + - socket.getPort() + // RFCOMM port - "\" name=\"channel\"/>\n" + - " </sequence>\n" + - " </sequence>\n" + - " </attribute>\n" + - " <attribute id=\"0x0100\">\n" + // ServiceName - " <text value=\"" + serviceName + "\"/>\n" + - " </attribute>\n" + - "</record>\n"; - Log.i(sLogName, xmlRecord); - return addServiceRecordFromXml(xmlRecord); - } - - - /** - * Add a new service record. - * @param record The byte[] record - * @return A handle to the new record - */ - public synchronized int addServiceRecord(byte[] record) throws IOException { - int handle = addServiceRecordNative(record); - Log.i(sLogName, "Added SDP record: " + Integer.toHexString(handle)); - return handle; - } - private native int addServiceRecordNative(byte[] record) - throws IOException; - - /** - * Add a new service record, using XML. - * @param record The record as an XML string - * @return A handle to the new record - */ - public synchronized int addServiceRecordFromXml(String record) throws IOException { - int handle = addServiceRecordFromXmlNative(record); - Log.i(sLogName, "Added SDP record: " + Integer.toHexString(handle)); - return handle; - } - private native int addServiceRecordFromXmlNative(String record) - throws IOException; - - /** - * Update an exisiting service record. - * @param handle Handle to exisiting record - * @param record The updated byte[] record - */ - public synchronized void updateServiceRecord(int handle, byte[] record) { - try { - updateServiceRecordNative(handle, record); - } catch (IOException e) { - Log.e(getClass().toString(), e.getMessage()); - } - } - private native void updateServiceRecordNative(int handle, byte[] record) - throws IOException; - - /** - * Update an exisiting record, using XML. - * @param handle Handle to exisiting record - * @param record The record as an XML string. - */ - public synchronized void updateServiceRecordFromXml(int handle, String record) { - try { - updateServiceRecordFromXmlNative(handle, record); - } catch (IOException e) { - Log.e(getClass().toString(), e.getMessage()); - } - } - private native void updateServiceRecordFromXmlNative(int handle, String record) - throws IOException; - - /** - * Remove a service record. - * It is only possible to remove service records that were added by the - * current connection. - * @param handle Handle to exisiting record to be removed - */ - public synchronized void removeServiceRecord(int handle) { - try { - removeServiceRecordNative(handle); - } catch (IOException e) { - Log.e(getClass().toString(), e.getMessage()); - } - } - private native void removeServiceRecordNative(int handle) throws IOException; -} diff --git a/core/java/android/bluetooth/HeadsetBase.java b/core/java/android/bluetooth/HeadsetBase.java index f987ffd..29cf41d 100644 --- a/core/java/android/bluetooth/HeadsetBase.java +++ b/core/java/android/bluetooth/HeadsetBase.java @@ -31,7 +31,7 @@ import android.util.Log; * * @hide */ -public class HeadsetBase { +public final class HeadsetBase { private static final String TAG = "Bluetooth HeadsetBase"; private static final boolean DBG = false; @@ -42,8 +42,9 @@ public class HeadsetBase { private static int sAtInputCount = 0; /* TODO: Consider not using a static variable */ - private final BluetoothDevice mBluetooth; - private final String mAddress; + private final BluetoothAdapter mAdapter; + private final BluetoothDevice mRemoteDevice; + private final String mAddress; // for native code private final int mRfcommChannel; private int mNativeData; private Thread mEventThread; @@ -73,12 +74,13 @@ public class HeadsetBase { private native void cleanupNativeDataNative(); - public HeadsetBase(PowerManager pm, BluetoothDevice bluetooth, String address, - int rfcommChannel) { + public HeadsetBase(PowerManager pm, BluetoothAdapter adapter, BluetoothDevice device, + int rfcommChannel) { mDirection = DIRECTION_OUTGOING; mConnectTimestamp = System.currentTimeMillis(); - mBluetooth = bluetooth; - mAddress = address; + mAdapter = adapter; + mRemoteDevice = device; + mAddress = device.getAddress(); mRfcommChannel = rfcommChannel; mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "HeadsetBase"); mWakeLock.setReferenceCounted(false); @@ -88,12 +90,13 @@ public class HeadsetBase { } /* Create from an already exisiting rfcomm connection */ - public HeadsetBase(PowerManager pm, BluetoothDevice bluetooth, String address, int socketFd, - int rfcommChannel, Handler handler) { + public HeadsetBase(PowerManager pm, BluetoothAdapter adapter, BluetoothDevice device, + int socketFd, int rfcommChannel, Handler handler) { mDirection = DIRECTION_INCOMING; mConnectTimestamp = System.currentTimeMillis(); - mBluetooth = bluetooth; - mAddress = address; + mAdapter = adapter; + mRemoteDevice = device; + mAddress = device.getAddress(); mRfcommChannel = rfcommChannel; mEventThreadHandler = handler; mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "HeadsetBase"); @@ -252,12 +255,8 @@ public class HeadsetBase { return mEventThread != null; } - public String getAddress() { - return mAddress; - } - - public String getName() { - return mBluetooth.getRemoteName(mAddress); + public BluetoothDevice getRemoteDevice() { + return mRemoteDevice; } public int getDirection() { diff --git a/core/java/android/bluetooth/IBluetoothDevice.aidl b/core/java/android/bluetooth/IBluetooth.aidl index 6cd792e..9e05a87 100644 --- a/core/java/android/bluetooth/IBluetoothDevice.aidl +++ b/core/java/android/bluetooth/IBluetooth.aidl @@ -16,14 +16,12 @@ package android.bluetooth; -import android.bluetooth.IBluetoothDeviceCallback; - /** * System private API for talking with the Bluetooth service. * * {@hide} */ -interface IBluetoothDevice +interface IBluetooth { boolean isEnabled(); int getBluetoothState(); @@ -33,10 +31,6 @@ interface IBluetoothDevice String getAddress(); String getName(); boolean setName(in String name); - String getVersion(); - String getRevision(); - String getManufacturer(); - String getCompany(); int getScanMode(); boolean setScanMode(int mode); @@ -44,17 +38,9 @@ interface IBluetoothDevice int getDiscoverableTimeout(); boolean setDiscoverableTimeout(int timeout); - boolean startDiscovery(boolean resolveNames); + boolean startDiscovery(); boolean cancelDiscovery(); boolean isDiscovering(); - boolean startPeriodicDiscovery(); - boolean stopPeriodicDiscovery(); - boolean isPeriodicDiscovery(); - String[] listRemoteDevices(); - - String[] listAclConnections(); - boolean isAclConnected(in String address); - boolean disconnectRemoteDeviceAcl(in String address); boolean createBond(in String address); boolean cancelBondProcess(in String address); @@ -63,16 +49,13 @@ interface IBluetoothDevice int getBondState(in String address); String getRemoteName(in String address); - String getRemoteVersion(in String address); - String getRemoteRevision(in String address); int getRemoteClass(in String address); - String getRemoteManufacturer(in String address); - String getRemoteCompany(in String address); - boolean getRemoteServiceChannel(in String address, int uuid16, in IBluetoothDeviceCallback callback); - byte[] getRemoteFeatures(in String adddress); - String lastSeen(in String address); - String lastUsed(in String address); + String[] getRemoteUuids(in String address); + int getRemoteServiceChannel(in String address, String uuid); boolean setPin(in String address, in byte[] pin); - boolean cancelPin(in String address); + boolean setPasskey(in String address, int passkey); + boolean setPairingConfirmation(in String address, boolean confirm); + boolean cancelPairingUserInput(in String address); + } diff --git a/core/java/android/bluetooth/IBluetoothA2dp.aidl b/core/java/android/bluetooth/IBluetoothA2dp.aidl index 55ff27f..e6c6be2 100644 --- a/core/java/android/bluetooth/IBluetoothA2dp.aidl +++ b/core/java/android/bluetooth/IBluetoothA2dp.aidl @@ -16,16 +16,18 @@ package android.bluetooth; +import android.bluetooth.BluetoothDevice; + /** * System private API for Bluetooth A2DP service * * {@hide} */ interface IBluetoothA2dp { - int connectSink(in String address); - int disconnectSink(in String address); - List<String> listConnectedSinks(); - int getSinkState(in String address); - int setSinkPriority(in String address, int priority); - int getSinkPriority(in String address); + int connectSink(in BluetoothDevice device); + int disconnectSink(in BluetoothDevice device); + BluetoothDevice[] getConnectedSinks(); // change to Set<> once AIDL supports + int getSinkState(in BluetoothDevice device); + int setSinkPriority(in BluetoothDevice device, int priority); + int getSinkPriority(in BluetoothDevice device); } diff --git a/core/java/android/bluetooth/IBluetoothHeadset.aidl b/core/java/android/bluetooth/IBluetoothHeadset.aidl index 5f42fd6..6cccd50 100644 --- a/core/java/android/bluetooth/IBluetoothHeadset.aidl +++ b/core/java/android/bluetooth/IBluetoothHeadset.aidl @@ -16,6 +16,8 @@ package android.bluetooth; +import android.bluetooth.BluetoothDevice; + /** * System private API for Bluetooth Headset service * @@ -23,13 +25,13 @@ package android.bluetooth; */ interface IBluetoothHeadset { int getState(); - String getHeadsetAddress(); - boolean connectHeadset(in String address); + BluetoothDevice getCurrentHeadset(); + boolean connectHeadset(in BluetoothDevice device); void disconnectHeadset(); - boolean isConnected(in String address); + boolean isConnected(in BluetoothDevice device); boolean startVoiceRecognition(); boolean stopVoiceRecognition(); - boolean setPriority(in String address, int priority); - int getPriority(in String address); + boolean setPriority(in BluetoothDevice device, int priority); + int getPriority(in BluetoothDevice device); int getBatteryUsageHint(); } diff --git a/core/java/android/bluetooth/IBluetoothPbap.aidl b/core/java/android/bluetooth/IBluetoothPbap.aidl new file mode 100644 index 0000000..7cc77d1 --- /dev/null +++ b/core/java/android/bluetooth/IBluetoothPbap.aidl @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2008 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.bluetooth; + +import android.bluetooth.BluetoothDevice; + +/** + * System private API for Bluetooth pbap service + * + * {@hide} + */ +interface IBluetoothPbap { + int getState(); + BluetoothDevice getClient(); + boolean connect(in BluetoothDevice device); + void disconnect(); + boolean isConnected(in BluetoothDevice device); +} diff --git a/core/java/android/bluetooth/RfcommSocket.java b/core/java/android/bluetooth/RfcommSocket.java deleted file mode 100644 index a33263f..0000000 --- a/core/java/android/bluetooth/RfcommSocket.java +++ /dev/null @@ -1,674 +0,0 @@ -/* - * 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.bluetooth; - -import java.io.IOException; -import java.io.FileOutputStream; -import java.io.FileInputStream; -import java.io.OutputStream; -import java.io.InputStream; -import java.io.FileDescriptor; - -/** - * The Android Bluetooth API is not finalized, and *will* change. Use at your - * own risk. - * - * This class implements an API to the Bluetooth RFCOMM layer. An RFCOMM socket - * is similar to a normal socket in that it takes an address and a port number. - * The difference is of course that the address is a Bluetooth-device address, - * and the port number is an RFCOMM channel. The API allows for the - * establishment of listening sockets via methods - * {@link #bind(String, int) bind}, {@link #listen(int) listen}, and - * {@link #accept(RfcommSocket, int) accept}, as well as for the making of - * outgoing connections with {@link #connect(String, int) connect}, - * {@link #connectAsync(String, int) connectAsync}, and - * {@link #waitForAsyncConnect(int) waitForAsyncConnect}. - * - * After constructing a socket, you need to {@link #create() create} it and then - * {@link #destroy() destroy} it when you are done using it. Both - * {@link #create() create} and {@link #accept(RfcommSocket, int) accept} return - * a {@link java.io.FileDescriptor FileDescriptor} for the actual data. - * Alternatively, you may call {@link #getInputStream() getInputStream} and - * {@link #getOutputStream() getOutputStream} to retrieve the respective streams - * without going through the FileDescriptor. - * - * @hide - */ -public class RfcommSocket { - - /** - * Used by the native implementation of the class. - */ - private int mNativeData; - - /** - * Used by the native implementation of the class. - */ - private int mPort; - - /** - * Used by the native implementation of the class. - */ - private String mAddress; - - /** - * We save the return value of {@link #create() create} and - * {@link #accept(RfcommSocket,int) accept} in this variable, and use it to - * retrieve the I/O streams. - */ - private FileDescriptor mFd; - - /** - * After a call to {@link #waitForAsyncConnect(int) waitForAsyncConnect}, - * if the return value is zero, then, the the remaining time left to wait is - * written into this variable (by the native implementation). It is possible - * that {@link #waitForAsyncConnect(int) waitForAsyncConnect} returns before - * the user-specified timeout expires, which is why we save the remaining - * time in this member variable for the user to retrieve by calling method - * {@link #getRemainingAsyncConnectWaitingTimeMs() getRemainingAsyncConnectWaitingTimeMs}. - */ - private int mTimeoutRemainingMs; - - /** - * Set to true when an asynchronous (nonblocking) connect is in progress. - * {@see #connectAsync(String,int)}. - */ - private boolean mIsConnecting; - - /** - * Set to true after a successful call to {@link #bind(String,int) bind} and - * used for error checking in {@link #listen(int) listen}. Reset to false - * on {@link #destroy() destroy}. - */ - private boolean mIsBound = false; - - /** - * Set to true after a successful call to {@link #listen(int) listen} and - * used for error checking in {@link #accept(RfcommSocket,int) accept}. - * Reset to false on {@link #destroy() destroy}. - */ - private boolean mIsListening = false; - - /** - * Used to store the remaining time after an accept with a non-negative - * timeout returns unsuccessfully. It is possible that a blocking - * {@link #accept(int) accept} may wait for less than the time specified by - * the user, which is why we store the remainder in this member variable for - * it to be retrieved with method - * {@link #getRemainingAcceptWaitingTimeMs() getRemainingAcceptWaitingTimeMs}. - */ - private int mAcceptTimeoutRemainingMs; - - /** - * Maintained by {@link #getInputStream() getInputStream}. - */ - protected FileInputStream mInputStream; - - /** - * Maintained by {@link #getOutputStream() getOutputStream}. - */ - protected FileOutputStream mOutputStream; - - private native void initializeNativeDataNative(); - - /** - * Constructor. - */ - public RfcommSocket() { - initializeNativeDataNative(); - } - - private native void cleanupNativeDataNative(); - - /** - * Called by the GC to clean up the native data that we set up when we - * construct the object. - */ - protected void finalize() throws Throwable { - try { - cleanupNativeDataNative(); - } finally { - super.finalize(); - } - } - - private native static void classInitNative(); - - static { - classInitNative(); - } - - /** - * Creates a socket. You need to call this method before performing any - * other operation on a socket. - * - * @return FileDescriptor for the data stream. - * @throws IOException - * @see #destroy() - */ - public FileDescriptor create() throws IOException { - if (mFd == null) { - mFd = createNative(); - } - if (mFd == null) { - throw new IOException("socket not created"); - } - return mFd; - } - - private native FileDescriptor createNative(); - - /** - * Destroys a socket created by {@link #create() create}. Call this - * function when you no longer use the socket in order to release the - * underlying OS resources. - * - * @see #create() - */ - public void destroy() { - synchronized (this) { - destroyNative(); - mFd = null; - mIsBound = false; - mIsListening = false; - } - } - - private native void destroyNative(); - - /** - * Returns the {@link java.io.FileDescriptor FileDescriptor} of the socket. - * - * @return the FileDescriptor - * @throws IOException - * when the socket has not been {@link #create() created}. - */ - public FileDescriptor getFileDescriptor() throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - return mFd; - } - - /** - * Retrieves the input stream from the socket. Alternatively, you can do - * that from the FileDescriptor returned by {@link #create() create} or - * {@link #accept(RfcommSocket, int) accept}. - * - * @return InputStream - * @throws IOException - * if you have not called {@link #create() create} on the - * socket. - */ - public InputStream getInputStream() throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - - synchronized (this) { - if (mInputStream == null) { - mInputStream = new FileInputStream(mFd); - } - - return mInputStream; - } - } - - /** - * Retrieves the output stream from the socket. Alternatively, you can do - * that from the FileDescriptor returned by {@link #create() create} or - * {@link #accept(RfcommSocket, int) accept}. - * - * @return OutputStream - * @throws IOException - * if you have not called {@link #create() create} on the - * socket. - */ - public OutputStream getOutputStream() throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - - synchronized (this) { - if (mOutputStream == null) { - mOutputStream = new FileOutputStream(mFd); - } - - return mOutputStream; - } - } - - /** - * Starts a blocking connect to a remote RFCOMM socket. It takes the address - * of a device and the RFCOMM channel (port) to which to connect. - * - * @param address - * is the Bluetooth address of the remote device. - * @param port - * is the RFCOMM channel - * @return true on success, false on failure - * @throws IOException - * if {@link #create() create} has not been called. - * @see #connectAsync(String, int) - */ - public boolean connect(String address, int port) throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - return connectNative(address, port); - } - } - - private native boolean connectNative(String address, int port); - - /** - * Starts an asynchronous (nonblocking) connect to a remote RFCOMM socket. - * It takes the address of the device to connect to, as well as the RFCOMM - * channel (port). On successful return (return value is true), you need to - * call method {@link #waitForAsyncConnect(int) waitForAsyncConnect} to - * block for up to a specified number of milliseconds while waiting for the - * asyncronous connect to complete. - * - * @param address - * of remote device - * @param port - * the RFCOMM channel - * @return true when the asynchronous connect has successfully started, - * false if there was an error. - * @throws IOException - * is you have not called {@link #create() create} - * @see #waitForAsyncConnect(int) - * @see #getRemainingAsyncConnectWaitingTimeMs() - * @see #connect(String, int) - */ - public boolean connectAsync(String address, int port) throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - mIsConnecting = connectAsyncNative(address, port); - return mIsConnecting; - } - } - - private native boolean connectAsyncNative(String address, int port); - - /** - * Interrupts an asynchronous connect in progress. This method does nothing - * when there is no asynchronous connect in progress. - * - * @throws IOException - * if you have not called {@link #create() create}. - * @see #connectAsync(String, int) - */ - public void interruptAsyncConnect() throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - if (mIsConnecting) { - mIsConnecting = !interruptAsyncConnectNative(); - } - } - } - - private native boolean interruptAsyncConnectNative(); - - /** - * Tells you whether there is an asynchronous connect in progress. This - * method returns an undefined value when there is a synchronous connect in - * progress. - * - * @return true if there is an asyc connect in progress, false otherwise - * @see #connectAsync(String, int) - */ - public boolean isConnecting() { - return mIsConnecting; - } - - /** - * Blocks for a specified amount of milliseconds while waiting for an - * asynchronous connect to complete. Returns an integer value to indicate - * one of the following: the connect succeeded, the connect is still in - * progress, or the connect failed. It is possible for this method to block - * for less than the time specified by the user, and still return zero - * (i.e., async connect is still in progress.) For this reason, if the - * return value is zero, you need to call method - * {@link #getRemainingAsyncConnectWaitingTimeMs() getRemainingAsyncConnectWaitingTimeMs} - * to retrieve the remaining time. - * - * @param timeoutMs - * the time to block while waiting for the async connect to - * complete. - * @return a positive value if the connect succeeds; zero, if the connect is - * still in progress, and a negative value if the connect failed. - * - * @throws IOException - * @see #getRemainingAsyncConnectWaitingTimeMs() - * @see #connectAsync(String, int) - */ - public int waitForAsyncConnect(int timeoutMs) throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - int ret = waitForAsyncConnectNative(timeoutMs); - if (ret != 0) { - mIsConnecting = false; - } - return ret; - } - } - - private native int waitForAsyncConnectNative(int timeoutMs); - - /** - * Returns the number of milliseconds left to wait after the last call to - * {@link #waitForAsyncConnect(int) waitForAsyncConnect}. - * - * It is possible that waitForAsyncConnect() waits for less than the time - * specified by the user, and still returns zero (i.e., async connect is - * still in progress.) For this reason, if the return value is zero, you - * need to call this method to retrieve the remaining time before you call - * waitForAsyncConnect again. - * - * @return the remaining timeout in milliseconds. - * @see #waitForAsyncConnect(int) - * @see #connectAsync(String, int) - */ - public int getRemainingAsyncConnectWaitingTimeMs() { - return mTimeoutRemainingMs; - } - - /** - * Shuts down both directions on a socket. - * - * @return true on success, false on failure; if the return value is false, - * the socket might be left in a patially shut-down state (i.e. one - * direction is shut down, but the other is still open.) In this - * case, you should {@link #destroy() destroy} and then - * {@link #create() create} the socket again. - * @throws IOException - * is you have not caled {@link #create() create}. - * @see #shutdownInput() - * @see #shutdownOutput() - */ - public boolean shutdown() throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - if (shutdownNative(true)) { - return shutdownNative(false); - } - - return false; - } - } - - /** - * Shuts down the input stream of the socket, but leaves the output stream - * in its current state. - * - * @return true on success, false on failure - * @throws IOException - * is you have not called {@link #create() create} - * @see #shutdown() - * @see #shutdownOutput() - */ - public boolean shutdownInput() throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - return shutdownNative(true); - } - } - - /** - * Shut down the output stream of the socket, but leaves the input stream in - * its current state. - * - * @return true on success, false on failure - * @throws IOException - * is you have not called {@link #create() create} - * @see #shutdown() - * @see #shutdownInput() - */ - public boolean shutdownOutput() throws IOException { - synchronized (this) { - if (mFd == null) { - throw new IOException("socket not created"); - } - return shutdownNative(false); - } - } - - private native boolean shutdownNative(boolean shutdownInput); - - /** - * Tells you whether a socket is connected to another socket. This could be - * for input or output or both. - * - * @return true if connected, false otherwise. - * @see #isInputConnected() - * @see #isOutputConnected() - */ - public boolean isConnected() { - return isConnectedNative() > 0; - } - - /** - * Determines whether input is connected (i.e., whether you can receive data - * on this socket.) - * - * @return true if input is connected, false otherwise. - * @see #isConnected() - * @see #isOutputConnected() - */ - public boolean isInputConnected() { - return (isConnectedNative() & 1) != 0; - } - - /** - * Determines whether output is connected (i.e., whether you can send data - * on this socket.) - * - * @return true if output is connected, false otherwise. - * @see #isConnected() - * @see #isInputConnected() - */ - public boolean isOutputConnected() { - return (isConnectedNative() & 2) != 0; - } - - private native int isConnectedNative(); - - /** - * Binds a listening socket to the local device, or a non-listening socket - * to a remote device. The port is automatically selected as the first - * available port in the range 12 to 30. - * - * NOTE: Currently we ignore the device parameter and always bind the socket - * to the local device, assuming that it is a listening socket. - * - * TODO: Use bind(0) in native code to have the kernel select an unused - * port. - * - * @param device - * Bluetooth address of device to bind to (currently ignored). - * @return true on success, false on failure - * @throws IOException - * if you have not called {@link #create() create} - * @see #listen(int) - * @see #accept(RfcommSocket,int) - */ - public boolean bind(String device) throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - for (int port = 12; port <= 30; port++) { - if (bindNative(device, port)) { - mIsBound = true; - return true; - } - } - mIsBound = false; - return false; - } - - /** - * Binds a listening socket to the local device, or a non-listening socket - * to a remote device. - * - * NOTE: Currently we ignore the device parameter and always bind the socket - * to the local device, assuming that it is a listening socket. - * - * @param device - * Bluetooth address of device to bind to (currently ignored). - * @param port - * RFCOMM channel to bind socket to. - * @return true on success, false on failure - * @throws IOException - * if you have not called {@link #create() create} - * @see #listen(int) - * @see #accept(RfcommSocket,int) - */ - public boolean bind(String device, int port) throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - mIsBound = bindNative(device, port); - return mIsBound; - } - - private native boolean bindNative(String device, int port); - - /** - * Starts listening for incoming connections on this socket, after it has - * been bound to an address and RFCOMM channel with - * {@link #bind(String,int) bind}. - * - * @param backlog - * the number of pending incoming connections to queue for - * {@link #accept(RfcommSocket, int) accept}. - * @return true on success, false on failure - * @throws IOException - * if you have not called {@link #create() create} or if the - * socket has not been bound to a device and RFCOMM channel. - */ - public boolean listen(int backlog) throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - if (!mIsBound) { - throw new IOException("socket not bound"); - } - mIsListening = listenNative(backlog); - return mIsListening; - } - - private native boolean listenNative(int backlog); - - /** - * Accepts incoming-connection requests for a listening socket bound to an - * RFCOMM channel. The user may provide a time to wait for an incoming - * connection. - * - * Note that this method may return null (i.e., no incoming connection) - * before the user-specified timeout expires. For this reason, on a null - * return value, you need to call - * {@link #getRemainingAcceptWaitingTimeMs() getRemainingAcceptWaitingTimeMs} - * in order to see how much time is left to wait, before you call this - * method again. - * - * @param newSock - * is set to the new socket that is created as a result of a - * successful accept. - * @param timeoutMs - * time (in milliseconds) to block while waiting to an - * incoming-connection request. A negative value is an infinite - * wait. - * @return FileDescriptor of newSock on success, null on failure. Failure - * occurs if the timeout expires without a successful connect. - * @throws IOException - * if the socket has not been {@link #create() create}ed, is - * not bound, or is not a listening socket. - * @see #bind(String, int) - * @see #listen(int) - * @see #getRemainingAcceptWaitingTimeMs() - */ - public FileDescriptor accept(RfcommSocket newSock, int timeoutMs) - throws IOException { - synchronized (newSock) { - if (mFd == null) { - throw new IOException("socket not created"); - } - if (mIsListening == false) { - throw new IOException("not listening on socket"); - } - newSock.mFd = acceptNative(newSock, timeoutMs); - return newSock.mFd; - } - } - - /** - * Returns the number of milliseconds left to wait after the last call to - * {@link #accept(RfcommSocket, int) accept}. - * - * Since accept() may return null (i.e., no incoming connection) before the - * user-specified timeout expires, you need to call this method in order to - * see how much time is left to wait, and wait for that amount of time - * before you call accept again. - * - * @return the remaining time, in milliseconds. - */ - public int getRemainingAcceptWaitingTimeMs() { - return mAcceptTimeoutRemainingMs; - } - - private native FileDescriptor acceptNative(RfcommSocket newSock, - int timeoutMs); - - /** - * Get the port (rfcomm channel) associated with this socket. - * - * This is only valid if the port has been set via a successful call to - * {@link #bind(String, int)}, {@link #connect(String, int)} - * or {@link #connectAsync(String, int)}. This can be checked - * with {@link #isListening()} and {@link #isConnected()}. - * @return Port (rfcomm channel) - */ - public int getPort() throws IOException { - if (mFd == null) { - throw new IOException("socket not created"); - } - if (!mIsListening && !isConnected()) { - throw new IOException("not listening or connected on socket"); - } - return mPort; - } - - /** - * Return true if this socket is listening ({@link #listen(int)} - * has been called successfully). - */ - public boolean isListening() { - return mIsListening; - } -} diff --git a/core/java/android/content/AbstractCursorEntityIterator.java b/core/java/android/content/AbstractCursorEntityIterator.java new file mode 100644 index 0000000..c2b13a4 --- /dev/null +++ b/core/java/android/content/AbstractCursorEntityIterator.java @@ -0,0 +1,120 @@ +package android.content; + +import android.database.Cursor; +import android.database.sqlite.SQLiteDatabase; +import android.os.RemoteException; + +/** + * An abstract class that makes it easy to implement an EntityIterator over a cursor. + * The user must implement {@link #newEntityFromCursorLocked}, which runs inside of a + * database transaction. + */ +public abstract class AbstractCursorEntityIterator implements EntityIterator { + private final Cursor mEntityCursor; + private final SQLiteDatabase mDb; + private volatile Entity mNextEntity; + private volatile boolean mIsClosed; + + public AbstractCursorEntityIterator(SQLiteDatabase db, Cursor entityCursor) { + mEntityCursor = entityCursor; + mDb = db; + mNextEntity = null; + mIsClosed = false; + } + + /** + * If there are entries left in the cursor then advance the cursor and use the new row to + * populate mNextEntity. If the cursor is at the end or if advancing it causes the cursor + * to become at the end then set mEntityCursor to null. If newEntityFromCursor returns null + * then continue advancing until it either returns a non-null Entity or the cursor reaches + * the end. + */ + private void fillEntityIfAvailable() { + while (mNextEntity == null) { + if (!mEntityCursor.moveToNext()) { + // the cursor is at then end, bail out + return; + } + // This may return null if newEntityFromCursor is not able to create an entity + // from the current cursor position. In that case this method will loop and try + // the next cursor position + mNextEntity = newEntityFromCursorLocked(mEntityCursor); + } + mDb.beginTransaction(); + try { + int position = mEntityCursor.getPosition(); + mNextEntity = newEntityFromCursorLocked(mEntityCursor); + int newPosition = mEntityCursor.getPosition(); + if (newPosition != position) { + throw new IllegalStateException("the cursor position changed during the call to" + + "newEntityFromCursorLocked, from " + position + " to " + newPosition); + } + } finally { + mDb.endTransaction(); + } + } + + /** + * Checks if there are more Entities accessible via this iterator. This may not be called + * if the iterator is already closed. + * @return true if the call to next() will return an Entity. + */ + public boolean hasNext() { + if (mIsClosed) { + throw new IllegalStateException("calling hasNext() when the iterator is closed"); + } + fillEntityIfAvailable(); + return mNextEntity != null; + } + + /** + * Returns the next Entity that is accessible via this iterator. This may not be called + * if the iterator is already closed. + * @return the next Entity that is accessible via this iterator + */ + public Entity next() { + if (mIsClosed) { + throw new IllegalStateException("calling next() when the iterator is closed"); + } + if (!hasNext()) { + throw new IllegalStateException("you may only call next() if hasNext() is true"); + } + + try { + return mNextEntity; + } finally { + mNextEntity = null; + } + } + + public void reset() throws RemoteException { + if (mIsClosed) { + throw new IllegalStateException("calling reset() when the iterator is closed"); + } + mEntityCursor.moveToPosition(-1); + mNextEntity = null; + } + + /** + * Closes this iterator making it invalid. If is invalid for the user to call any public + * method on the iterator once it has been closed. + */ + public void close() { + if (mIsClosed) { + throw new IllegalStateException("closing when already closed"); + } + mIsClosed = true; + mEntityCursor.close(); + } + + /** + * Returns a new Entity from the current cursor position. This is called from within a + * database transaction. If a new entity cannot be created from this cursor position (e.g. + * if the row that is referred to no longer exists) then this may return null. The cursor + * is guaranteed to be pointing to a valid row when this call is made. The implementation + * of newEntityFromCursorLocked is not allowed to change the position of the cursor. + * @param cursor from where to read the data for the Entity + * @return an Entity that corresponds to the current cursor position or null + */ + public abstract Entity newEntityFromCursorLocked(Cursor cursor); +} diff --git a/core/java/android/content/AbstractSyncableContentProvider.java b/core/java/android/content/AbstractSyncableContentProvider.java index 249d9ba..808f30c 100644 --- a/core/java/android/content/AbstractSyncableContentProvider.java +++ b/core/java/android/content/AbstractSyncableContentProvider.java @@ -4,8 +4,9 @@ import android.database.sqlite.SQLiteOpenHelper; import android.database.sqlite.SQLiteDatabase; import android.database.Cursor; import android.net.Uri; -import android.accounts.AccountMonitor; -import android.accounts.AccountMonitorListener; +import android.accounts.OnAccountsUpdatedListener; +import android.accounts.Account; +import android.accounts.AccountManager; import android.provider.SyncConstValue; import android.util.Config; import android.util.Log; @@ -14,9 +15,12 @@ import android.text.TextUtils; import java.util.Collections; import java.util.Map; -import java.util.HashMap; import java.util.Vector; import java.util.ArrayList; +import java.util.Set; +import java.util.HashSet; + +import com.google.android.collect.Maps; /** * A specialization of the ContentProvider that centralizes functionality @@ -32,26 +36,30 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro private final String mDatabaseName; private final int mDatabaseVersion; private final Uri mContentUri; - private AccountMonitor mAccountMonitor; /** the account set in the last call to onSyncStart() */ - private String mSyncingAccount; + private Account mSyncingAccount; private SyncStateContentProviderHelper mSyncState = null; - private static final String[] sAccountProjection = new String[] {SyncConstValue._SYNC_ACCOUNT}; + private static final String[] sAccountProjection = + new String[] {SyncConstValue._SYNC_ACCOUNT, SyncConstValue._SYNC_ACCOUNT_TYPE}; private boolean mIsTemporary; private AbstractTableMerger mCurrentMerger = null; private boolean mIsMergeCancelled = false; - private static final String SYNC_ACCOUNT_WHERE_CLAUSE = SyncConstValue._SYNC_ACCOUNT + "=?"; + private static final String SYNC_ACCOUNT_WHERE_CLAUSE = + SyncConstValue._SYNC_ACCOUNT + "=? AND " + SyncConstValue._SYNC_ACCOUNT_TYPE + "=?"; protected boolean isTemporary() { return mIsTemporary; } + private final ThreadLocal<Boolean> mApplyingBatch = new ThreadLocal<Boolean>(); + private final ThreadLocal<Set<Uri>> mPendingBatchNotifications = new ThreadLocal<Set<Uri>>(); + /** * Indicates whether or not this ContentProvider contains a full * set of data or just diffs. This knowledge comes in handy when @@ -133,7 +141,8 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { if (!upgradeDatabase(db, oldVersion, newVersion)) { mSyncState.discardSyncData(db, null /* all accounts */); - getContext().getContentResolver().startSync(mContentUri, new Bundle()); + ContentResolver.requestSync(null /* all accounts */, + mContentUri.getAuthority(), new Bundle()); } } @@ -150,23 +159,36 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro mOpenHelper = new AbstractSyncableContentProvider.DatabaseHelper(getContext(), mDatabaseName); mSyncState = new SyncStateContentProviderHelper(mOpenHelper); - - AccountMonitorListener listener = new AccountMonitorListener() { - public void onAccountsUpdated(String[] accounts) { - // Some providers override onAccountsChanged(); give them a database to work with. - mDb = mOpenHelper.getWritableDatabase(); - onAccountsChanged(accounts); - TempProviderSyncAdapter syncAdapter = (TempProviderSyncAdapter)getSyncAdapter(); - if (syncAdapter != null) { - syncAdapter.onAccountsChanged(accounts); - } - } - }; - mAccountMonitor = new AccountMonitor(getContext(), listener); + AccountManager.get(getContext()).addOnAccountsUpdatedListener( + new OnAccountsUpdatedListener() { + public void onAccountsUpdated(Account[] accounts) { + // Some providers override onAccountsChanged(); give them a database to + // work with. + mDb = mOpenHelper.getWritableDatabase(); + // Only call onAccountsChanged on GAIA accounts; otherwise, the contacts and + // calendar providers will choke as they try to sync unknown accounts with + // AbstractGDataSyncAdapter, which will put acore into a crash loop + ArrayList<Account> gaiaAccounts = new ArrayList<Account>(); + for (Account acct: accounts) { + if (acct.type.equals("com.google.GAIA")) { + gaiaAccounts.add(acct); + } + } + accounts = new Account[gaiaAccounts.size()]; + int i = 0; + for (Account acct: gaiaAccounts) { + accounts[i++] = acct; + } + onAccountsChanged(accounts); + TempProviderSyncAdapter syncAdapter = getTempProviderSyncAdapter(); + if (syncAdapter != null) { + syncAdapter.onAccountsChanged(accounts); + } + } + }, null /* handler */, true /* updateImmediately */); return true; } - /** * Get a non-persistent instance of this content provider. * You must call {@link #close} on the returned @@ -236,147 +258,117 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro return Collections.emptyList(); } - /** - * <p> - * Call mOpenHelper.getWritableDatabase() and mDb.beginTransaction(). - * {@link #endTransaction} MUST be called after calling this method. - * Those methods should be used like this: - * </p> - * - * <pre class="prettyprint"> - * boolean successful = false; - * beginTransaction(); - * try { - * // Do something related to mDb - * successful = true; - * return ret; - * } finally { - * endTransaction(successful); - * } - * </pre> - * - * @hide This method is dangerous from the view of database manipulation, though using - * this makes batch insertion/update/delete much faster. - */ - public final void beginTransaction() { + @Override + public final int update(final Uri url, final ContentValues values, + final String selection, final String[] selectionArgs) { mDb = mOpenHelper.getWritableDatabase(); - mDb.beginTransaction(); - } - - /** - * <p> - * Call mDb.endTransaction(). If successful is true, try to call - * mDb.setTransactionSuccessful() before calling mDb.endTransaction(). - * This method MUST be used with {@link #beginTransaction()}. - * </p> - * - * @hide This method is dangerous from the view of database manipulation, though using - * this makes batch insertion/update/delete much faster. - */ - public final void endTransaction(boolean successful) { + final boolean notApplyingBatch = !applyingBatch(); + if (notApplyingBatch) { + mDb.beginTransaction(); + } try { - if (successful) { - // setTransactionSuccessful() must be called just once during opening the - // transaction. - mDb.setTransactionSuccessful(); + if (isTemporary() && mSyncState.matches(url)) { + int numRows = mSyncState.asContentProvider().update( + url, values, selection, selectionArgs); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + return numRows; } - } finally { - mDb.endTransaction(); - } - } - @Override - public final int update(final Uri uri, final ContentValues values, - final String selection, final String[] selectionArgs) { - boolean successful = false; - beginTransaction(); - try { - int ret = nonTransactionalUpdate(uri, values, selection, selectionArgs); - successful = true; - return ret; + int result = updateInternal(url, values, selection, selectionArgs); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + if (!isTemporary() && result > 0) { + if (notApplyingBatch) { + getContext().getContentResolver().notifyChange(url, null /* observer */, + changeRequiresLocalSync(url)); + } else { + mPendingBatchNotifications.get().add(url); + } + } + return result; } finally { - endTransaction(successful); - } - } - - /** - * @hide - */ - public final int nonTransactionalUpdate(final Uri uri, final ContentValues values, - final String selection, final String[] selectionArgs) { - if (isTemporary() && mSyncState.matches(uri)) { - int numRows = mSyncState.asContentProvider().update( - uri, values, selection, selectionArgs); - return numRows; - } - - int result = updateInternal(uri, values, selection, selectionArgs); - if (!isTemporary() && result > 0) { - getContext().getContentResolver().notifyChange(uri, null /* observer */, - changeRequiresLocalSync(uri)); + if (notApplyingBatch) { + mDb.endTransaction(); + } } - - return result; } @Override - public final int delete(final Uri uri, final String selection, + public final int delete(final Uri url, final String selection, final String[] selectionArgs) { - boolean successful = false; - beginTransaction(); + mDb = mOpenHelper.getWritableDatabase(); + final boolean notApplyingBatch = !applyingBatch(); + if (notApplyingBatch) { + mDb.beginTransaction(); + } try { - int ret = nonTransactionalDelete(uri, selection, selectionArgs); - successful = true; - return ret; + if (isTemporary() && mSyncState.matches(url)) { + int numRows = mSyncState.asContentProvider().delete(url, selection, selectionArgs); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + return numRows; + } + int result = deleteInternal(url, selection, selectionArgs); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + if (!isTemporary() && result > 0) { + if (notApplyingBatch) { + getContext().getContentResolver().notifyChange(url, null /* observer */, + changeRequiresLocalSync(url)); + } else { + mPendingBatchNotifications.get().add(url); + } + } + return result; } finally { - endTransaction(successful); + if (notApplyingBatch) { + mDb.endTransaction(); + } } } - /** - * @hide - */ - public final int nonTransactionalDelete(final Uri uri, final String selection, - final String[] selectionArgs) { - if (isTemporary() && mSyncState.matches(uri)) { - int numRows = mSyncState.asContentProvider().delete(uri, selection, selectionArgs); - return numRows; - } - int result = deleteInternal(uri, selection, selectionArgs); - if (!isTemporary() && result > 0) { - getContext().getContentResolver().notifyChange(uri, null /* observer */, - changeRequiresLocalSync(uri)); - } - return result; + private boolean applyingBatch() { + return mApplyingBatch.get() != null && mApplyingBatch.get(); } @Override - public final Uri insert(final Uri uri, final ContentValues values) { - boolean successful = false; - beginTransaction(); - try { - Uri ret = nonTransactionalInsert(uri, values); - successful = true; - return ret; - } finally { - endTransaction(successful); + public final Uri insert(final Uri url, final ContentValues values) { + mDb = mOpenHelper.getWritableDatabase(); + final boolean notApplyingBatch = !applyingBatch(); + if (notApplyingBatch) { + mDb.beginTransaction(); } - } - - /** - * @hide - */ - public final Uri nonTransactionalInsert(final Uri uri, final ContentValues values) { - if (isTemporary() && mSyncState.matches(uri)) { - Uri result = mSyncState.asContentProvider().insert(uri, values); + try { + if (isTemporary() && mSyncState.matches(url)) { + Uri result = mSyncState.asContentProvider().insert(url, values); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + return result; + } + Uri result = insertInternal(url, values); + if (notApplyingBatch) { + mDb.setTransactionSuccessful(); + } + if (!isTemporary() && result != null) { + if (notApplyingBatch) { + getContext().getContentResolver().notifyChange(url, null /* observer */, + changeRequiresLocalSync(url)); + } else { + mPendingBatchNotifications.get().add(url); + } + } return result; + } finally { + if (notApplyingBatch) { + mDb.endTransaction(); + } } - Uri result = insertInternal(uri, values); - if (!isTemporary() && result != null) { - getContext().getContentResolver().notifyChange(uri, null /* observer */, - changeRequiresLocalSync(uri)); - } - return result; } @Override @@ -411,6 +403,92 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro } /** + * <p> + * Start batch transaction. {@link #endTransaction} MUST be called after + * calling this method. Those methods should be used like this: + * </p> + * + * <pre class="prettyprint"> + * boolean successful = false; + * beginBatch() + * try { + * // Do something related to mDb + * successful = true; + * return ret; + * } finally { + * endBatch(successful); + * } + * </pre> + * + * @hide This method should be used only when {@link ContentProvider#applyBatch} is not enough and must be + * used with {@link #endBatch}. + * e.g. If returned value has to be used during one transaction, this method might be useful. + */ + public final void beginBatch() { + // initialize if this is the first time this thread has applied a batch + if (mApplyingBatch.get() == null) { + mApplyingBatch.set(false); + mPendingBatchNotifications.set(new HashSet<Uri>()); + } + + if (applyingBatch()) { + throw new IllegalStateException( + "applyBatch is not reentrant but mApplyingBatch is already set"); + } + SQLiteDatabase db = getDatabase(); + db.beginTransaction(); + boolean successful = false; + try { + mApplyingBatch.set(true); + successful = true; + } finally { + if (!successful) { + // Something unexpected happened. We must call endTransaction() at least. + db.endTransaction(); + } + } + } + + /** + * <p> + * Finish batch transaction. If "successful" is true, try to call + * mDb.setTransactionSuccessful() before calling mDb.endTransaction(). + * This method MUST be used with {@link #beginBatch()}. + * </p> + * + * @hide This method must be used with {@link #beginTransaction} + */ + public final void endBatch(boolean successful) { + try { + if (successful) { + // setTransactionSuccessful() must be called just once during opening the + // transaction. + mDb.setTransactionSuccessful(); + } + } finally { + mApplyingBatch.set(false); + getDatabase().endTransaction(); + for (Uri url : mPendingBatchNotifications.get()) { + getContext().getContentResolver().notifyChange(url, null /* observer */, + changeRequiresLocalSync(url)); + } + } + } + + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws OperationApplicationException { + boolean successful = false; + beginBatch(); + try { + ContentProviderResult[] results = super.applyBatch(operations); + successful = true; + return results; + } finally { + endBatch(successful); + } + } + + /** * Check if changes to this URI can be syncable changes. * @param uri the URI of the resource that was changed * @return true if changes to this URI can be syncable changes, false otherwise @@ -437,8 +515,8 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro * @param context the sync context for the operation * @param account */ - public void onSyncStart(SyncContext context, String account) { - if (TextUtils.isEmpty(account)) { + public void onSyncStart(SyncContext context, Account account) { + if (account == null) { throw new IllegalArgumentException("you passed in an empty account"); } mSyncingAccount = account; @@ -457,7 +535,7 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro * The account of the most recent call to onSyncStart() * @return the account */ - public String getSyncingAccount() { + public Account getSyncingAccount() { return mSyncingAccount; } @@ -568,12 +646,11 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro * Make sure that there are no entries for accounts that no longer exist * @param accountsArray the array of currently-existing accounts */ - protected void onAccountsChanged(String[] accountsArray) { - Map<String, Boolean> accounts = new HashMap<String, Boolean>(); - for (String account : accountsArray) { + protected void onAccountsChanged(Account[] accountsArray) { + Map<Account, Boolean> accounts = Maps.newHashMap(); + for (Account account : accountsArray) { accounts.put(account, false); } - accounts.put(SyncConstValue.NON_SYNCABLE_ACCOUNT, false); SQLiteDatabase db = mOpenHelper.getWritableDatabase(); Map<String, String> tableMap = db.getSyncedTables(); @@ -585,8 +662,7 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro try { mSyncState.onAccountsChanged(accountsArray); for (String table : tables) { - deleteRowsForRemovedAccounts(accounts, table, - SyncConstValue._SYNC_ACCOUNT); + deleteRowsForRemovedAccounts(accounts, table); } db.setTransactionSuccessful(); } finally { @@ -601,23 +677,23 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro * * @param accounts a map of existing accounts * @param table the table to delete from - * @param accountColumnName the name of the column that is expected - * to hold the account. */ - protected void deleteRowsForRemovedAccounts(Map<String, Boolean> accounts, - String table, String accountColumnName) { + protected void deleteRowsForRemovedAccounts(Map<Account, Boolean> accounts, String table) { SQLiteDatabase db = mOpenHelper.getWritableDatabase(); Cursor c = db.query(table, sAccountProjection, null, null, - accountColumnName, null, null); + "_sync_account, _sync_account_type", null, null); try { while (c.moveToNext()) { - String account = c.getString(0); - if (TextUtils.isEmpty(account)) { + String accountName = c.getString(0); + String accountType = c.getString(1); + if (TextUtils.isEmpty(accountName)) { continue; } + Account account = new Account(accountName, accountType); if (!accounts.containsKey(account)) { int numDeleted; - numDeleted = db.delete(table, accountColumnName + "=?", new String[]{account}); + numDeleted = db.delete(table, "_sync_account=? AND _sync_account_type=?", + new String[]{account.name, account.type}); if (Config.LOGV) { Log.v(TAG, "deleted " + numDeleted + " records from table " + table @@ -634,7 +710,7 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro * Called when the sync system determines that this provider should no longer * contain records for the specified account. */ - public void wipeAccount(String account) { + public void wipeAccount(Account account) { SQLiteDatabase db = mOpenHelper.getWritableDatabase(); Map<String, String> tableMap = db.getSyncedTables(); ArrayList<String> tables = new ArrayList<String>(); @@ -649,7 +725,8 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro // remove the data in the synced tables for (String table : tables) { - db.delete(table, SYNC_ACCOUNT_WHERE_CLAUSE, new String[]{account}); + db.delete(table, SYNC_ACCOUNT_WHERE_CLAUSE, + new String[]{account.name, account.type}); } db.setTransactionSuccessful(); } finally { @@ -660,14 +737,14 @@ public abstract class AbstractSyncableContentProvider extends SyncableContentPro /** * Retrieves the SyncData bytes for the given account. The byte array returned may be null. */ - public byte[] readSyncDataBytes(String account) { + public byte[] readSyncDataBytes(Account account) { return mSyncState.readSyncDataBytes(mOpenHelper.getReadableDatabase(), account); } /** * Sets the SyncData bytes for the given account. The byte array may be null. */ - public void writeSyncDataBytes(String account, byte[] data) { + public void writeSyncDataBytes(Account account, byte[] data) { mSyncState.writeSyncDataBytes(mOpenHelper.getWritableDatabase(), account, data); } } diff --git a/core/java/android/content/AbstractTableMerger.java b/core/java/android/content/AbstractTableMerger.java index 9f609a3..9545fd7 100644 --- a/core/java/android/content/AbstractTableMerger.java +++ b/core/java/android/content/AbstractTableMerger.java @@ -25,6 +25,7 @@ import android.provider.BaseColumns; import static android.provider.SyncConstValue.*; import android.text.TextUtils; import android.util.Log; +import android.accounts.Account; /** * @hide @@ -55,15 +56,17 @@ public abstract class AbstractTableMerger private volatile boolean mIsMergeCancelled; - private static final String SELECT_MARKED = _SYNC_MARK + "> 0 and " + _SYNC_ACCOUNT + "=?"; + private static final String SELECT_MARKED = _SYNC_MARK + "> 0 and " + + _SYNC_ACCOUNT + "=? and " + _SYNC_ACCOUNT_TYPE + "=?"; private static final String SELECT_BY_SYNC_ID_AND_ACCOUNT = - _SYNC_ID +"=? and " + _SYNC_ACCOUNT + "=?"; + _SYNC_ID +"=? and " + _SYNC_ACCOUNT + "=? and " + _SYNC_ACCOUNT_TYPE + "=?"; private static final String SELECT_BY_ID = BaseColumns._ID +"=?"; private static final String SELECT_UNSYNCED = - "(" + _SYNC_ACCOUNT + " IS NULL OR " + _SYNC_ACCOUNT + "=?) AND " - + "(" + _SYNC_ID + " IS NULL OR (" + _SYNC_DIRTY + " > 0 AND " + "(" + _SYNC_ACCOUNT + " IS NULL OR (" + + _SYNC_ACCOUNT + "=? and " + _SYNC_ACCOUNT_TYPE + "=?)) and " + + "(" + _SYNC_ID + " IS NULL OR (" + _SYNC_DIRTY + " > 0 and " + _SYNC_VERSION + " IS NOT NULL))"; public AbstractTableMerger(SQLiteDatabase database, @@ -134,7 +137,7 @@ public abstract class AbstractTableMerger * construct a temporary instance to hold them. */ public void merge(final SyncContext context, - final String account, + final Account account, final SyncableContentProvider serverDiffs, TempProviderSyncResult result, SyncResult syncResult, SyncableContentProvider temporaryInstanceFactory) { @@ -157,7 +160,7 @@ public abstract class AbstractTableMerger * @hide this is public for testing purposes only */ public void mergeServerDiffs(SyncContext context, - String account, SyncableContentProvider serverDiffs, SyncResult syncResult) { + Account account, SyncableContentProvider serverDiffs, SyncResult syncResult) { boolean diffsArePartial = serverDiffs.getContainsDiffs(); // mark the current rows so that we can distinguish these from new // inserts that occur during the merge @@ -166,342 +169,340 @@ public abstract class AbstractTableMerger mDb.update(mDeletedTable, mSyncMarkValues, null, null); } - // load the local database entries, so we can merge them with the server - final String[] accountSelectionArgs = new String[]{account}; - Cursor localCursor = mDb.query(mTable, syncDirtyProjection, - SELECT_MARKED, accountSelectionArgs, null, null, - mTable + "." + _SYNC_ID); - Cursor deletedCursor; - if (mDeletedTable != null) { - deletedCursor = mDb.query(mDeletedTable, syncIdAndVersionProjection, + Cursor localCursor = null; + Cursor deletedCursor = null; + Cursor diffsCursor = null; + try { + // load the local database entries, so we can merge them with the server + final String[] accountSelectionArgs = new String[]{account.name, account.type}; + localCursor = mDb.query(mTable, syncDirtyProjection, SELECT_MARKED, accountSelectionArgs, null, null, - mDeletedTable + "." + _SYNC_ID); - } else { - deletedCursor = - mDb.rawQuery("select 'a' as _sync_id, 'b' as _sync_version limit 0", null); - } - - // Apply updates and insertions from the server - Cursor diffsCursor = serverDiffs.query(mTableURL, - null, null, null, mTable + "." + _SYNC_ID); - int deletedSyncIDColumn = deletedCursor.getColumnIndexOrThrow(_SYNC_ID); - int deletedSyncVersionColumn = deletedCursor.getColumnIndexOrThrow(_SYNC_VERSION); - int serverSyncIDColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_ID); - int serverSyncVersionColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_VERSION); - int serverSyncLocalIdColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_LOCAL_ID); - - String lastSyncId = null; - int diffsCount = 0; - int localCount = 0; - localCursor.moveToFirst(); - deletedCursor.moveToFirst(); - while (diffsCursor.moveToNext()) { - if (mIsMergeCancelled) { - localCursor.close(); - deletedCursor.close(); - diffsCursor.close(); - return; - } - mDb.yieldIfContended(); - String serverSyncId = diffsCursor.getString(serverSyncIDColumn); - String serverSyncVersion = diffsCursor.getString(serverSyncVersionColumn); - long localRowId = 0; - String localSyncVersion = null; - - diffsCount++; - context.setStatusText("Processing " + diffsCount + "/" - + diffsCursor.getCount()); - if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "processing server entry " + - diffsCount + ", " + serverSyncId); - - if (TRACE) { - if (diffsCount == 10) { - Debug.startMethodTracing("atmtrace"); - } - if (diffsCount == 20) { - Debug.stopMethodTracing(); - } + mTable + "." + _SYNC_ID); + if (mDeletedTable != null) { + deletedCursor = mDb.query(mDeletedTable, syncIdAndVersionProjection, + SELECT_MARKED, accountSelectionArgs, null, null, + mDeletedTable + "." + _SYNC_ID); + } else { + deletedCursor = + mDb.rawQuery("select 'a' as _sync_id, 'b' as _sync_version limit 0", null); } - boolean conflict = false; - boolean update = false; - boolean insert = false; + // Apply updates and insertions from the server + diffsCursor = serverDiffs.query(mTableURL, + null, null, null, mTable + "." + _SYNC_ID); + int deletedSyncIDColumn = deletedCursor.getColumnIndexOrThrow(_SYNC_ID); + int deletedSyncVersionColumn = deletedCursor.getColumnIndexOrThrow(_SYNC_VERSION); + int serverSyncIDColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_ID); + int serverSyncVersionColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_VERSION); + int serverSyncLocalIdColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_LOCAL_ID); - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "found event with serverSyncID " + serverSyncId); - } - if (TextUtils.isEmpty(serverSyncId)) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.e(TAG, "server entry doesn't have a serverSyncID"); + String lastSyncId = null; + int diffsCount = 0; + int localCount = 0; + localCursor.moveToFirst(); + deletedCursor.moveToFirst(); + while (diffsCursor.moveToNext()) { + if (mIsMergeCancelled) { + return; } - continue; - } - - // It is possible that the sync adapter wrote the same record multiple times, - // e.g. if the same record came via multiple feeds. If this happens just ignore - // the duplicate records. - if (serverSyncId.equals(lastSyncId)) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "skipping record with duplicate remote server id " + lastSyncId); + mDb.yieldIfContended(); + String serverSyncId = diffsCursor.getString(serverSyncIDColumn); + String serverSyncVersion = diffsCursor.getString(serverSyncVersionColumn); + long localRowId = 0; + String localSyncVersion = null; + + diffsCount++; + context.setStatusText("Processing " + diffsCount + "/" + + diffsCursor.getCount()); + if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "processing server entry " + + diffsCount + ", " + serverSyncId); + + if (TRACE) { + if (diffsCount == 10) { + Debug.startMethodTracing("atmtrace"); + } + if (diffsCount == 20) { + Debug.stopMethodTracing(); + } } - continue; - } - lastSyncId = serverSyncId; - String localSyncID = null; - boolean localSyncDirty = false; + boolean conflict = false; + boolean update = false; + boolean insert = false; - while (!localCursor.isAfterLast()) { - if (mIsMergeCancelled) { - localCursor.deactivate(); - deletedCursor.deactivate(); - diffsCursor.deactivate(); - return; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "found event with serverSyncID " + serverSyncId); + } + if (TextUtils.isEmpty(serverSyncId)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.e(TAG, "server entry doesn't have a serverSyncID"); + } + continue; } - localCount++; - localSyncID = localCursor.getString(2); - // If the local record doesn't have a _sync_id then - // it is new. Ignore it for now, we will send an insert - // the the server later. - if (TextUtils.isEmpty(localSyncID)) { + // It is possible that the sync adapter wrote the same record multiple times, + // e.g. if the same record came via multiple feeds. If this happens just ignore + // the duplicate records. + if (serverSyncId.equals(lastSyncId)) { if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "local record " + - localCursor.getLong(1) + - " has no _sync_id, ignoring"); + Log.v(TAG, "skipping record with duplicate remote server id " + lastSyncId); } - localCursor.moveToNext(); - localSyncID = null; continue; } + lastSyncId = serverSyncId; - int comp = serverSyncId.compareTo(localSyncID); + String localSyncID = null; + boolean localSyncDirty = false; - // the local DB has a record that the server doesn't have - if (comp > 0) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "local record " + - localCursor.getLong(1) + - " has _sync_id " + localSyncID + - " that is < server _sync_id " + serverSyncId); + while (!localCursor.isAfterLast()) { + if (mIsMergeCancelled) { + return; } - if (diffsArePartial) { - localCursor.moveToNext(); - } else { - deleteRow(localCursor); - if (mDeletedTable != null) { - mDb.delete(mDeletedTable, _SYNC_ID +"=?", new String[] {localSyncID}); + localCount++; + localSyncID = localCursor.getString(2); + + // If the local record doesn't have a _sync_id then + // it is new. Ignore it for now, we will send an insert + // the the server later. + if (TextUtils.isEmpty(localSyncID)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "local record " + + localCursor.getLong(1) + + " has no _sync_id, ignoring"); } - syncResult.stats.numDeletes++; - mDb.yieldIfContended(); + localCursor.moveToNext(); + localSyncID = null; + continue; } - localSyncID = null; - continue; - } - // the server has a record that the local DB doesn't have - if (comp < 0) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "local record " + - localCursor.getLong(1) + - " has _sync_id " + localSyncID + - " that is > server _sync_id " + serverSyncId); + int comp = serverSyncId.compareTo(localSyncID); + + // the local DB has a record that the server doesn't have + if (comp > 0) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "local record " + + localCursor.getLong(1) + + " has _sync_id " + localSyncID + + " that is < server _sync_id " + serverSyncId); + } + if (diffsArePartial) { + localCursor.moveToNext(); + } else { + deleteRow(localCursor); + if (mDeletedTable != null) { + mDb.delete(mDeletedTable, _SYNC_ID +"=?", new String[] {localSyncID}); + } + syncResult.stats.numDeletes++; + mDb.yieldIfContended(); + } + localSyncID = null; + continue; } - localSyncID = null; - } - // the server and the local DB both have this record - if (comp == 0) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "local record " + - localCursor.getLong(1) + - " has _sync_id " + localSyncID + - " that matches the server _sync_id"); + // the server has a record that the local DB doesn't have + if (comp < 0) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "local record " + + localCursor.getLong(1) + + " has _sync_id " + localSyncID + + " that is > server _sync_id " + serverSyncId); + } + localSyncID = null; } - localSyncDirty = localCursor.getInt(0) != 0; - localRowId = localCursor.getLong(1); - localSyncVersion = localCursor.getString(3); - localCursor.moveToNext(); - } - break; - } + // the server and the local DB both have this record + if (comp == 0) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "local record " + + localCursor.getLong(1) + + " has _sync_id " + localSyncID + + " that matches the server _sync_id"); + } + localSyncDirty = localCursor.getInt(0) != 0; + localRowId = localCursor.getLong(1); + localSyncVersion = localCursor.getString(3); + localCursor.moveToNext(); + } - // If this record is in the deleted table then update the server version - // in the deleted table, if necessary, and then ignore it here. - // We will send a deletion indication to the server down a - // little further. - if (findInCursor(deletedCursor, deletedSyncIDColumn, serverSyncId)) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "remote record " + serverSyncId + " is in the deleted table"); + break; } - final String deletedSyncVersion = deletedCursor.getString(deletedSyncVersionColumn); - if (!TextUtils.equals(deletedSyncVersion, serverSyncVersion)) { + + // If this record is in the deleted table then update the server version + // in the deleted table, if necessary, and then ignore it here. + // We will send a deletion indication to the server down a + // little further. + if (findInCursor(deletedCursor, deletedSyncIDColumn, serverSyncId)) { if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "setting version of deleted record " + serverSyncId + " to " - + serverSyncVersion); + Log.v(TAG, "remote record " + serverSyncId + " is in the deleted table"); + } + final String deletedSyncVersion = deletedCursor.getString(deletedSyncVersionColumn); + if (!TextUtils.equals(deletedSyncVersion, serverSyncVersion)) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "setting version of deleted record " + serverSyncId + " to " + + serverSyncVersion); + } + ContentValues values = new ContentValues(); + values.put(_SYNC_VERSION, serverSyncVersion); + mDb.update(mDeletedTable, values, "_sync_id=?", new String[]{serverSyncId}); } - ContentValues values = new ContentValues(); - values.put(_SYNC_VERSION, serverSyncVersion); - mDb.update(mDeletedTable, values, "_sync_id=?", new String[]{serverSyncId}); + continue; } - continue; - } - // If the _sync_local_id is present in the diffsCursor - // then this record corresponds to a local record that was just - // inserted into the server and the _sync_local_id is the row id - // of the local record. Set these fields so that the next check - // treats this record as an update, which will allow the - // merger to update the record with the server's sync id - if (!diffsCursor.isNull(serverSyncLocalIdColumn)) { - localRowId = diffsCursor.getLong(serverSyncLocalIdColumn); - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "the remote record with sync id " + serverSyncId - + " has a local sync id, " + localRowId); + // If the _sync_local_id is present in the diffsCursor + // then this record corresponds to a local record that was just + // inserted into the server and the _sync_local_id is the row id + // of the local record. Set these fields so that the next check + // treats this record as an update, which will allow the + // merger to update the record with the server's sync id + if (!diffsCursor.isNull(serverSyncLocalIdColumn)) { + localRowId = diffsCursor.getLong(serverSyncLocalIdColumn); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "the remote record with sync id " + serverSyncId + + " has a local sync id, " + localRowId); + } + localSyncID = serverSyncId; + localSyncDirty = false; + localSyncVersion = null; } - localSyncID = serverSyncId; - localSyncDirty = false; - localSyncVersion = null; - } - if (!TextUtils.isEmpty(localSyncID)) { - // An existing server item has changed - // If serverSyncVersion is null, there is no edit URL; - // server won't let this change be written. - boolean recordChanged = (localSyncVersion == null) || - (serverSyncVersion == null) || - !serverSyncVersion.equals(localSyncVersion); - if (recordChanged) { - if (localSyncDirty) { - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "remote record " + serverSyncId - + " conflicts with local _sync_id " + localSyncID - + ", local _id " + localRowId); + if (!TextUtils.isEmpty(localSyncID)) { + // An existing server item has changed + // If serverSyncVersion is null, there is no edit URL; + // server won't let this change be written. + boolean recordChanged = (localSyncVersion == null) || + (serverSyncVersion == null) || + !serverSyncVersion.equals(localSyncVersion); + if (recordChanged) { + if (localSyncDirty) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "remote record " + serverSyncId + + " conflicts with local _sync_id " + localSyncID + + ", local _id " + localRowId); + } + conflict = true; + } else { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, + "remote record " + + serverSyncId + + " updates local _sync_id " + + localSyncID + ", local _id " + + localRowId); + } + update = true; } - conflict = true; } else { if (Log.isLoggable(TAG, Log.VERBOSE)) { Log.v(TAG, - "remote record " + - serverSyncId + - " updates local _sync_id " + - localSyncID + ", local _id " + - localRowId); + "Skipping update: localSyncVersion: " + localSyncVersion + + ", serverSyncVersion: " + serverSyncVersion); } - update = true; } } else { + // the local db doesn't know about this record so add it if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, - "Skipping update: localSyncVersion: " + localSyncVersion + - ", serverSyncVersion: " + serverSyncVersion); + Log.v(TAG, "remote record " + serverSyncId + " is new, inserting"); } + insert = true; } - } else { - // the local db doesn't know about this record so add it - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "remote record " + serverSyncId + " is new, inserting"); + + if (update) { + updateRow(localRowId, serverDiffs, diffsCursor); + syncResult.stats.numUpdates++; + } else if (conflict) { + resolveRow(localRowId, serverSyncId, serverDiffs, diffsCursor); + syncResult.stats.numUpdates++; + } else if (insert) { + insertRow(serverDiffs, diffsCursor); + syncResult.stats.numInserts++; } - insert = true; } - if (update) { - updateRow(localRowId, serverDiffs, diffsCursor); - syncResult.stats.numUpdates++; - } else if (conflict) { - resolveRow(localRowId, serverSyncId, serverDiffs, diffsCursor); - syncResult.stats.numUpdates++; - } else if (insert) { - insertRow(serverDiffs, diffsCursor); - syncResult.stats.numInserts++; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "processed " + diffsCount + " server entries"); } - } - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, "processed " + diffsCount + " server entries"); - } - - // If tombstones aren't in use delete any remaining local rows that - // don't have corresponding server rows. Keep the rows that don't - // have a sync id since those were created locally and haven't been - // synced to the server yet. - if (!diffsArePartial) { - while (!localCursor.isAfterLast() && !TextUtils.isEmpty(localCursor.getString(2))) { - if (mIsMergeCancelled) { - localCursor.deactivate(); - deletedCursor.deactivate(); - diffsCursor.deactivate(); - return; - } - localCount++; - final String localSyncId = localCursor.getString(2); - if (Log.isLoggable(TAG, Log.VERBOSE)) { - Log.v(TAG, - "deleting local record " + - localCursor.getLong(1) + - " _sync_id " + localSyncId); - } - deleteRow(localCursor); - if (mDeletedTable != null) { - mDb.delete(mDeletedTable, _SYNC_ID + "=?", new String[] {localSyncId}); + // If tombstones aren't in use delete any remaining local rows that + // don't have corresponding server rows. Keep the rows that don't + // have a sync id since those were created locally and haven't been + // synced to the server yet. + if (!diffsArePartial) { + while (!localCursor.isAfterLast() && !TextUtils.isEmpty(localCursor.getString(2))) { + if (mIsMergeCancelled) { + return; + } + localCount++; + final String localSyncId = localCursor.getString(2); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, + "deleting local record " + + localCursor.getLong(1) + + " _sync_id " + localSyncId); + } + deleteRow(localCursor); + if (mDeletedTable != null) { + mDb.delete(mDeletedTable, _SYNC_ID + "=?", new String[] {localSyncId}); + } + syncResult.stats.numDeletes++; + mDb.yieldIfContended(); } - syncResult.stats.numDeletes++; - mDb.yieldIfContended(); } + if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "checked " + localCount + + " local entries"); + } finally { + if (diffsCursor != null) diffsCursor.close(); + if (localCursor != null) localCursor.close(); + if (deletedCursor != null) deletedCursor.close(); } - if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "checked " + localCount + - " local entries"); - diffsCursor.deactivate(); - localCursor.deactivate(); - deletedCursor.deactivate(); if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "applying deletions from the server"); // Apply deletions from the server if (mDeletedTableURL != null) { diffsCursor = serverDiffs.query(mDeletedTableURL, null, null, null, null); - - while (diffsCursor.moveToNext()) { - if (mIsMergeCancelled) { - diffsCursor.deactivate(); - return; + try { + while (diffsCursor.moveToNext()) { + if (mIsMergeCancelled) { + return; + } + // delete all rows that match each element in the diffsCursor + fullyDeleteMatchingRows(diffsCursor, account, syncResult); + mDb.yieldIfContended(); } - // delete all rows that match each element in the diffsCursor - fullyDeleteMatchingRows(diffsCursor, account, syncResult); - mDb.yieldIfContended(); + } finally { + diffsCursor.close(); } - diffsCursor.deactivate(); } } - private void fullyDeleteMatchingRows(Cursor diffsCursor, String account, + private void fullyDeleteMatchingRows(Cursor diffsCursor, Account account, SyncResult syncResult) { int serverSyncIdColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_ID); final boolean deleteBySyncId = !diffsCursor.isNull(serverSyncIdColumn); // delete the rows explicitly so that the delete operation can be overridden - final Cursor c; final String[] selectionArgs; - if (deleteBySyncId) { - selectionArgs = new String[]{diffsCursor.getString(serverSyncIdColumn), account}; - c = mDb.query(mTable, new String[]{BaseColumns._ID}, SELECT_BY_SYNC_ID_AND_ACCOUNT, - selectionArgs, null, null, null); - } else { - int serverSyncLocalIdColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_LOCAL_ID); - selectionArgs = new String[]{diffsCursor.getString(serverSyncLocalIdColumn)}; - c = mDb.query(mTable, new String[]{BaseColumns._ID}, SELECT_BY_ID, selectionArgs, - null, null, null); - } + Cursor c = null; try { + if (deleteBySyncId) { + selectionArgs = new String[]{diffsCursor.getString(serverSyncIdColumn), + account.name, account.type}; + c = mDb.query(mTable, new String[]{BaseColumns._ID}, SELECT_BY_SYNC_ID_AND_ACCOUNT, + selectionArgs, null, null, null); + } else { + int serverSyncLocalIdColumn = diffsCursor.getColumnIndexOrThrow(_SYNC_LOCAL_ID); + selectionArgs = new String[]{diffsCursor.getString(serverSyncLocalIdColumn)}; + c = mDb.query(mTable, new String[]{BaseColumns._ID}, SELECT_BY_ID, selectionArgs, + null, null, null); + } c.moveToFirst(); while (!c.isAfterLast()) { deleteRow(c); // advances the cursor syncResult.stats.numDeletes++; } } finally { - c.deactivate(); + if (c != null) c.close(); } if (deleteBySyncId && mDeletedTable != null) { mDb.delete(mDeletedTable, SELECT_BY_SYNC_ID_AND_ACCOUNT, selectionArgs); @@ -519,43 +520,46 @@ public abstract class AbstractTableMerger * Finds local changes, placing the results in the given result object. * @param temporaryInstanceFactory As an optimization for the case * where there are no client-side diffs, mergeResult may initially - * have no {@link android.content.TempProviderSyncResult#tempContentProvider}. If this is + * have no {@link TempProviderSyncResult#tempContentProvider}. If this is * the first in the sequence of AbstractTableMergers to find * client-side diffs, it will use the given ContentProvider to * create a temporary instance and store its {@link - * ContentProvider} in the mergeResult. + * android.content.ContentProvider} in the mergeResult. * @param account * @param syncResult */ private void findLocalChanges(TempProviderSyncResult mergeResult, - SyncableContentProvider temporaryInstanceFactory, String account, + SyncableContentProvider temporaryInstanceFactory, Account account, SyncResult syncResult) { SyncableContentProvider clientDiffs = mergeResult.tempContentProvider; if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "generating client updates"); - final String[] accountSelectionArgs = new String[]{account}; + final String[] accountSelectionArgs = new String[]{account.name, account.type}; // Generate the client updates and insertions // Create a cursor for dirty records + long numInsertsOrUpdates = 0; Cursor localChangesCursor = mDb.query(mTable, null, SELECT_UNSYNCED, accountSelectionArgs, null, null, null); - long numInsertsOrUpdates = localChangesCursor.getCount(); - while (localChangesCursor.moveToNext()) { - if (mIsMergeCancelled) { - localChangesCursor.close(); - return; - } - if (clientDiffs == null) { - clientDiffs = temporaryInstanceFactory.getTemporaryInstance(); + try { + numInsertsOrUpdates = localChangesCursor.getCount(); + while (localChangesCursor.moveToNext()) { + if (mIsMergeCancelled) { + return; + } + if (clientDiffs == null) { + clientDiffs = temporaryInstanceFactory.getTemporaryInstance(); + } + mValues.clear(); + cursorRowToContentValues(localChangesCursor, mValues); + mValues.remove("_id"); + DatabaseUtils.cursorLongToContentValues(localChangesCursor, "_id", mValues, + _SYNC_LOCAL_ID); + clientDiffs.insert(mTableURL, mValues); } - mValues.clear(); - cursorRowToContentValues(localChangesCursor, mValues); - mValues.remove("_id"); - DatabaseUtils.cursorLongToContentValues(localChangesCursor, "_id", mValues, - _SYNC_LOCAL_ID); - clientDiffs.insert(mTableURL, mValues); + } finally { + localChangesCursor.close(); } - localChangesCursor.close(); // Generate the client deletions if (Log.isLoggable(TAG, Log.VERBOSE)) Log.v(TAG, "generating client deletions"); @@ -564,23 +568,25 @@ public abstract class AbstractTableMerger if (mDeletedTable != null) { Cursor deletedCursor = mDb.query(mDeletedTable, syncIdAndVersionProjection, - _SYNC_ACCOUNT + "=? AND " + _SYNC_ID + " IS NOT NULL", accountSelectionArgs, + _SYNC_ACCOUNT + "=? AND " + _SYNC_ACCOUNT_TYPE + "=? AND " + + _SYNC_ID + " IS NOT NULL", accountSelectionArgs, null, null, mDeletedTable + "." + _SYNC_ID); - - numDeletedEntries = deletedCursor.getCount(); - while (deletedCursor.moveToNext()) { - if (mIsMergeCancelled) { - deletedCursor.close(); - return; - } - if (clientDiffs == null) { - clientDiffs = temporaryInstanceFactory.getTemporaryInstance(); + try { + numDeletedEntries = deletedCursor.getCount(); + while (deletedCursor.moveToNext()) { + if (mIsMergeCancelled) { + return; + } + if (clientDiffs == null) { + clientDiffs = temporaryInstanceFactory.getTemporaryInstance(); + } + mValues.clear(); + DatabaseUtils.cursorRowToContentValues(deletedCursor, mValues); + clientDiffs.insert(mDeletedTableURL, mValues); } - mValues.clear(); - DatabaseUtils.cursorRowToContentValues(deletedCursor, mValues); - clientDiffs.insert(mDeletedTableURL, mValues); + } finally { + deletedCursor.close(); } - deletedCursor.close(); } if (clientDiffs != null) { diff --git a/core/java/android/content/AbstractThreadedSyncAdapter.java b/core/java/android/content/AbstractThreadedSyncAdapter.java new file mode 100644 index 0000000..538225a --- /dev/null +++ b/core/java/android/content/AbstractThreadedSyncAdapter.java @@ -0,0 +1,192 @@ +/* + * Copyright (C) 2009 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.content; + +import android.accounts.Account; +import android.os.Bundle; +import android.os.Process; + +import java.util.concurrent.atomic.AtomicInteger; + +/** + * An abstract implementation of a SyncAdapter that spawns a thread to invoke a sync operation. + * If a sync operation is already in progress when a startSync() request is received then an error + * will be returned to the new request and the existing request will be allowed to continue. + * When a startSync() is received and there is no sync operation in progress then a thread + * will be started to run the operation and {@link #performSync} will be invoked on that thread. + * If a cancelSync() is received that matches an existing sync operation then the thread + * that is running that sync operation will be interrupted, which will indicate to the thread + * that the sync has been canceled. + * + * @hide + */ +public abstract class AbstractThreadedSyncAdapter { + private final Context mContext; + private final AtomicInteger mNumSyncStarts; + private final ISyncAdapterImpl mISyncAdapterImpl; + + // all accesses to this member variable must be synchronized on "this" + private SyncThread mSyncThread; + + /** Kernel event log tag. Also listed in data/etc/event-log-tags. */ + public static final int LOG_SYNC_DETAILS = 2743; + private final boolean mAutoInitialize; + + /** + * Creates an {@link AbstractThreadedSyncAdapter}. + * @param context the {@link android.content.Context} that this is running within. + * @param autoInitialize if true then sync requests that have + * {@link ContentResolver#SYNC_EXTRAS_INITIALIZE} set will be internally handled by + * {@link AbstractThreadedSyncAdapter} by calling + * {@link ContentResolver#setIsSyncable(android.accounts.Account, String, int)} with 1 if it + * is currently set to <0. + */ + public AbstractThreadedSyncAdapter(Context context, boolean autoInitialize) { + mContext = context; + mISyncAdapterImpl = new ISyncAdapterImpl(); + mNumSyncStarts = new AtomicInteger(0); + mSyncThread = null; + mAutoInitialize = autoInitialize; + } + + class ISyncAdapterImpl extends ISyncAdapter.Stub { + public void startSync(ISyncContext syncContext, String authority, Account account, + Bundle extras) { + final SyncContext syncContextClient = new SyncContext(syncContext); + + boolean alreadyInProgress; + // synchronize to make sure that mSyncThread doesn't change between when we + // check it and when we use it + synchronized (this) { + if (mSyncThread == null) { + if (mAutoInitialize + && extras != null + && extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false)) { + if (ContentResolver.getIsSyncable(account, authority) < 0) { + ContentResolver.setIsSyncable(account, authority, 1); + } + syncContextClient.onFinished(new SyncResult()); + return; + } + mSyncThread = new SyncThread( + "SyncAdapterThread-" + mNumSyncStarts.incrementAndGet(), + syncContextClient, authority, account, extras); + Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); + mSyncThread.start(); + alreadyInProgress = false; + } else { + alreadyInProgress = true; + } + } + + // do this outside since we don't want to call back into the syncContext while + // holding the synchronization lock + if (alreadyInProgress) { + syncContextClient.onFinished(SyncResult.ALREADY_IN_PROGRESS); + } + } + + public void cancelSync(ISyncContext syncContext) { + // synchronize to make sure that mSyncThread doesn't change between when we + // check it and when we use it + synchronized (this) { + if (mSyncThread != null + && mSyncThread.mSyncContext.getISyncContext() == syncContext) { + mSyncThread.interrupt(); + } + } + } + } + + /** + * The thread that invokes performSync(). It also acquires the provider for this sync + * before calling performSync and releases it afterwards. Cancel this thread in order to + * cancel the sync. + */ + private class SyncThread extends Thread { + private final SyncContext mSyncContext; + private final String mAuthority; + private final Account mAccount; + private final Bundle mExtras; + + private SyncThread(String name, SyncContext syncContext, String authority, + Account account, Bundle extras) { + super(name); + mSyncContext = syncContext; + mAuthority = authority; + mAccount = account; + mExtras = extras; + } + + public void run() { + if (isCanceled()) { + return; + } + + SyncResult syncResult = new SyncResult(); + ContentProviderClient provider = null; + try { + provider = mContext.getContentResolver().acquireContentProviderClient(mAuthority); + if (provider != null) { + AbstractThreadedSyncAdapter.this.performSync(mAccount, mExtras, + mAuthority, provider, syncResult); + } else { + // TODO(fredq) update the syncResults to indicate that we were unable to + // find the provider. maybe with a ProviderError? + } + } finally { + if (provider != null) { + provider.release(); + } + if (!isCanceled()) { + mSyncContext.onFinished(syncResult); + } + // synchronize so that the assignment will be seen by other threads + // that also synchronize accesses to mSyncThread + synchronized (this) { + mSyncThread = null; + } + } + } + + private boolean isCanceled() { + return Thread.currentThread().isInterrupted(); + } + } + + /** + * @return a reference to the ISyncAdapter interface into this SyncAdapter implementation. + */ + public final ISyncAdapter getISyncAdapter() { + return mISyncAdapterImpl; + } + + /** + * Perform a sync for this account. SyncAdapter-specific parameters may + * be specified in extras, which is guaranteed to not be null. Invocations + * of this method are guaranteed to be serialized. + * + * @param account the account that should be synced + * @param extras SyncAdapter-specific parameters + * @param authority the authority of this sync request + * @param provider a ContentProviderClient that points to the ContentProvider for this + * authority + * @param syncResult SyncAdapter-specific parameters + */ + public abstract void performSync(Account account, Bundle extras, + String authority, ContentProviderClient provider, SyncResult syncResult); +}
\ No newline at end of file diff --git a/core/java/android/content/ActiveSyncInfo.java b/core/java/android/content/ActiveSyncInfo.java index 63be8d1..209dffa 100644 --- a/core/java/android/content/ActiveSyncInfo.java +++ b/core/java/android/content/ActiveSyncInfo.java @@ -16,17 +16,18 @@ package android.content; +import android.accounts.Account; import android.os.Parcel; import android.os.Parcelable.Creator; /** @hide */ public class ActiveSyncInfo { public final int authorityId; - public final String account; + public final Account account; public final String authority; public final long startTime; - ActiveSyncInfo(int authorityId, String account, String authority, + ActiveSyncInfo(int authorityId, Account account, String authority, long startTime) { this.authorityId = authorityId; this.account = account; @@ -40,14 +41,14 @@ public class ActiveSyncInfo { public void writeToParcel(Parcel parcel, int flags) { parcel.writeInt(authorityId); - parcel.writeString(account); + account.writeToParcel(parcel, 0); parcel.writeString(authority); parcel.writeLong(startTime); } ActiveSyncInfo(Parcel parcel) { authorityId = parcel.readInt(); - account = parcel.readString(); + account = new Account(parcel); authority = parcel.readString(); startTime = parcel.readLong(); } diff --git a/core/java/android/content/AsyncQueryHandler.java b/core/java/android/content/AsyncQueryHandler.java index ac851cc..5e88de0 100644 --- a/core/java/android/content/AsyncQueryHandler.java +++ b/core/java/android/content/AsyncQueryHandler.java @@ -38,7 +38,8 @@ public abstract class AsyncQueryHandler extends Handler { private static final int EVENT_ARG_INSERT = 2; private static final int EVENT_ARG_UPDATE = 3; private static final int EVENT_ARG_DELETE = 4; - + private static final int EVENT_ARG_QUERY_ENTITIES = 5; + /* package */ final WeakReference<ContentResolver> mResolver; private static Looper sLooper = null; @@ -85,12 +86,25 @@ public abstract class AsyncQueryHandler extends Handler { cursor.getCount(); } } catch (Exception e) { + Log.w(TAG, e.toString()); cursor = null; } args.result = cursor; break; + case EVENT_ARG_QUERY_ENTITIES: + EntityIterator iterator = null; + try { + iterator = resolver.queryEntities(args.uri, args.selection, + args.selectionArgs, args.orderBy); + } catch (Exception e) { + Log.w(TAG, e.toString()); + } + + args.result = iterator; + break; + case EVENT_ARG_INSERT: args.result = resolver.insert(args.uri, args.values); break; @@ -103,7 +117,6 @@ public abstract class AsyncQueryHandler extends Handler { case EVENT_ARG_DELETE: args.result = resolver.delete(args.uri, args.selection, args.selectionArgs); break; - } // passing the original token value back to the caller @@ -128,7 +141,7 @@ public abstract class AsyncQueryHandler extends Handler { if (sLooper == null) { HandlerThread thread = new HandlerThread("AsyncQueryWorker"); thread.start(); - + sLooper = thread.getLooper(); } } @@ -182,6 +195,44 @@ public abstract class AsyncQueryHandler extends Handler { } /** + * This method begins an asynchronous query for an {@link EntityIterator}. + * When the query is done {@link #onQueryEntitiesComplete} is called. + * + * @param token A token passed into {@link #onQueryComplete} to identify the + * query. + * @param cookie An object that gets passed into {@link #onQueryComplete} + * @param uri The URI, using the content:// scheme, for the content to + * retrieve. + * @param selection A filter declaring which rows to return, formatted as an + * SQL WHERE clause (excluding the WHERE itself). Passing null + * will return all rows for the given URI. + * @param selectionArgs You may include ?s in selection, which will be + * replaced by the values from selectionArgs, in the order that + * they appear in the selection. The values will be bound as + * Strings. + * @param orderBy How to order the rows, formatted as an SQL ORDER BY clause + * (excluding the ORDER BY itself). Passing null will use the + * default sort order, which may be unordered. + */ + public void startQueryEntities(int token, Object cookie, Uri uri, String selection, + String[] selectionArgs, String orderBy) { + // Use the token as what so cancelOperations works properly + Message msg = mWorkerThreadHandler.obtainMessage(token); + msg.arg1 = EVENT_ARG_QUERY_ENTITIES; + + WorkerArgs args = new WorkerArgs(); + args.handler = this; + args.uri = uri; + args.selection = selection; + args.selectionArgs = selectionArgs; + args.orderBy = orderBy; + args.cookie = cookie; + msg.obj = args; + + mWorkerThreadHandler.sendMessage(msg); + } + + /** * Attempts to cancel operation that has not already started. Note that * there is no guarantee that the operation will be canceled. They still may * result in a call to on[Query/Insert/Update/Delete]Complete after this @@ -279,8 +330,8 @@ public abstract class AsyncQueryHandler extends Handler { * Called when an asynchronous query is completed. * * @param token the token to identify the query, passed in from - * {@link #startQuery}. - * @param cookie the cookie object that's passed in from {@link #startQuery}. + * {@link #startQuery}. + * @param cookie the cookie object passed in from {@link #startQuery}. * @param cursor The cursor holding the results from the query. */ protected void onQueryComplete(int token, Object cookie, Cursor cursor) { @@ -288,6 +339,17 @@ public abstract class AsyncQueryHandler extends Handler { } /** + * Called when an asynchronous query is completed. + * + * @param token The token to identify the query. + * @param cookie The cookie object. + * @param iterator The iterator holding the query results. + */ + protected void onQueryEntitiesComplete(int token, Object cookie, EntityIterator iterator) { + // Empty + } + + /** * Called when an asynchronous insert is completed. * * @param token the token to identify the query, passed in from @@ -337,13 +399,17 @@ public abstract class AsyncQueryHandler extends Handler { int token = msg.what; int event = msg.arg1; - + // pass token back to caller on each callback. switch (event) { case EVENT_ARG_QUERY: onQueryComplete(token, args.cookie, (Cursor) args.result); break; + case EVENT_ARG_QUERY_ENTITIES: + onQueryEntitiesComplete(token, args.cookie, (EntityIterator)args.result); + break; + case EVENT_ARG_INSERT: onInsertComplete(token, args.cookie, (Uri) args.result); break; diff --git a/core/java/android/content/ContentProvider.java b/core/java/android/content/ContentProvider.java index 6b50405..5b29b97 100644 --- a/core/java/android/content/ContentProvider.java +++ b/core/java/android/content/ContentProvider.java @@ -34,6 +34,7 @@ import android.os.Process; import java.io.File; import java.io.FileNotFoundException; +import java.util.ArrayList; /** * Content providers are one of the primary building blocks of Android applications, providing @@ -130,6 +131,12 @@ public abstract class ContentProvider implements ComponentCallbacks { selectionArgs, sortOrder); } + public EntityIterator queryEntities(Uri uri, String selection, String[] selectionArgs, + String sortOrder) { + enforceReadPermission(uri); + return ContentProvider.this.queryEntities(uri, selection, selectionArgs, sortOrder); + } + public String getType(Uri uri) { return ContentProvider.this.getType(uri); } @@ -145,6 +152,25 @@ public abstract class ContentProvider implements ComponentCallbacks { return ContentProvider.this.bulkInsert(uri, initialValues); } + public Uri insertEntity(Uri uri, Entity entities) { + enforceWritePermission(uri); + return ContentProvider.this.insertEntity(uri, entities); + } + + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws OperationApplicationException { + for (ContentProviderOperation operation : operations) { + if (operation.isReadOperation()) { + enforceReadPermission(operation.getUri()); + } + + if (operation.isWriteOperation()) { + enforceWritePermission(operation.getUri()); + } + } + return ContentProvider.this.applyBatch(operations); + } + public int delete(Uri uri, String selection, String[] selectionArgs) { enforceWritePermission(uri); return ContentProvider.this.delete(uri, selection, selectionArgs); @@ -156,6 +182,11 @@ public abstract class ContentProvider implements ComponentCallbacks { return ContentProvider.this.update(uri, values, selection, selectionArgs); } + public int updateEntity(Uri uri, Entity entity) { + enforceWritePermission(uri); + return ContentProvider.this.updateEntity(uri, entity); + } + public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException { if (mode != null && mode.startsWith("rw")) enforceWritePermission(uri); @@ -170,12 +201,6 @@ public abstract class ContentProvider implements ComponentCallbacks { return ContentProvider.this.openAssetFile(uri, mode); } - public ISyncAdapter getSyncAdapter() { - enforceWritePermission(null); - SyncAdapter sa = ContentProvider.this.getSyncAdapter(); - return sa != null ? sa.getISyncAdapter() : null; - } - private void enforceReadPermission(Uri uri) { final int uid = Binder.getCallingUid(); if (uid == mMyUid) { @@ -377,9 +402,10 @@ public abstract class ContentProvider implements ComponentCallbacks { * Example client call:<p> * <pre>// Request a specific record. * Cursor managedCursor = managedQuery( - Contacts.People.CONTENT_URI.addId(2), + ContentUris.withAppendedId(Contacts.People.CONTENT_URI, 2), projection, // Which columns to return. null, // WHERE clause. + null, // WHERE clause value substitution People.NAME + " ASC"); // Sort order.</pre> * Example implementation:<p> * <pre>// SQLiteQueryBuilder is a helper class that creates the @@ -408,20 +434,28 @@ public abstract class ContentProvider implements ComponentCallbacks { return c;</pre> * * @param uri The URI to query. This will be the full URI sent by the client; - * if the client is requesting a specific record, the URI will end in a record number - * that the implementation should parse and add to a WHERE or HAVING clause, specifying - * that _id value. + * if the client is requesting a specific record, the URI will end in a record number + * that the implementation should parse and add to a WHERE or HAVING clause, specifying + * that _id value. * @param projection The list of columns to put into the cursor. If * null all columns are included. * @param selection A selection criteria to apply when filtering rows. * If null then all rows are included. + * @param selectionArgs You may include ?s in selection, which will be replaced by + * the values from selectionArgs, in order that they appear in the selection. + * The values will be bound as Strings. * @param sortOrder How the rows in the cursor should be sorted. - * If null then the provider is free to define the sort order. + * If null then the provider is free to define the sort order. * @return a Cursor or null. */ public abstract Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder); + public EntityIterator queryEntities(Uri uri, String selection, String[] selectionArgs, + String sortOrder) { + throw new UnsupportedOperationException(); + } + /** * Return the MIME type of the data at the given URI. This should start with * <code>vnd.android.cursor.item</code> for a single record, @@ -472,6 +506,10 @@ public abstract class ContentProvider implements ComponentCallbacks { return numValues; } + public Uri insertEntity(Uri uri, Entity entity) { + throw new UnsupportedOperationException(); + } + /** * A request to delete one or more rows. The selection clause is applied when performing * the deletion, allowing the operation to affect multiple rows in a @@ -516,6 +554,10 @@ public abstract class ContentProvider implements ComponentCallbacks { public abstract int update(Uri uri, ContentValues values, String selection, String[] selectionArgs); + public int updateEntity(Uri uri, Entity entity) { + throw new UnsupportedOperationException(); + } + /** * Open a file blob associated with a content URI. * This method can be called from multiple @@ -639,23 +681,6 @@ public abstract class ContentProvider implements ComponentCallbacks { } /** - * Get the sync adapter that is to be used by this content provider. - * This is intended for use by the sync system. If null then this - * content provider is considered not syncable. - * This method can be called from multiple - * threads, as described in - * <a href="{@docRoot}guide/topics/fundamentals.html#procthread">Application Fundamentals: - * Processes and Threads</a>. - * - * @return the SyncAdapter that is to be used by this ContentProvider, or null - * if this ContentProvider is not syncable - * @hide - */ - public SyncAdapter getSyncAdapter() { - return null; - } - - /** * Returns true if this instance is a temporary content provider. * @return true if this instance is a temporary content provider */ @@ -697,4 +722,27 @@ public abstract class ContentProvider implements ComponentCallbacks { ContentProvider.this.onCreate(); } } -} + + /** + * Applies each of the {@link ContentProviderOperation} objects and returns an array + * of their results. Passes through OperationApplicationException, which may be thrown + * by the call to {@link ContentProviderOperation#apply}. + * If all the applications succeed then a {@link ContentProviderResult} array with the + * same number of elements as the operations will be returned. It is implementation-specific + * how many, if any, operations will have been successfully applied if a call to + * apply results in a {@link OperationApplicationException}. + * @param operations the operations to apply + * @return the results of the applications + * @throws OperationApplicationException thrown if an application fails. + * See {@link ContentProviderOperation#apply} for more information. + */ + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws OperationApplicationException { + final int numOperations = operations.size(); + final ContentProviderResult[] results = new ContentProviderResult[numOperations]; + for (int i = 0; i < numOperations; i++) { + results[i] = operations.get(i).apply(this, results, i); + } + return results; + } +}
\ No newline at end of file diff --git a/core/java/android/content/ContentProviderClient.java b/core/java/android/content/ContentProviderClient.java new file mode 100644 index 0000000..452653e --- /dev/null +++ b/core/java/android/content/ContentProviderClient.java @@ -0,0 +1,135 @@ +/* + * Copyright (C) 2009 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.content; + +import android.database.Cursor; +import android.net.Uri; +import android.os.RemoteException; +import android.os.ParcelFileDescriptor; +import android.content.res.AssetFileDescriptor; + +import java.io.FileNotFoundException; +import java.util.ArrayList; + +/** + * The public interface object used to interact with a {@link ContentProvider}. This is obtained by + * calling {@link ContentResolver#acquireContentProviderClient}. This object must be released + * using {@link #release} in order to indicate to the system that the {@link ContentProvider} is + * no longer needed and can be killed to free up resources. + */ +public class ContentProviderClient { + private final IContentProvider mContentProvider; + private final ContentResolver mContentResolver; + + /** + * @hide + */ + ContentProviderClient(ContentResolver contentResolver, IContentProvider contentProvider) { + mContentProvider = contentProvider; + mContentResolver = contentResolver; + } + + /** see {@link ContentProvider#query} */ + public Cursor query(Uri url, String[] projection, String selection, + String[] selectionArgs, String sortOrder) throws RemoteException { + return mContentProvider.query(url, projection, selection, selectionArgs, sortOrder); + } + + /** see {@link ContentProvider#getType} */ + public String getType(Uri url) throws RemoteException { + return mContentProvider.getType(url); + } + + /** see {@link ContentProvider#insert} */ + public Uri insert(Uri url, ContentValues initialValues) + throws RemoteException { + return mContentProvider.insert(url, initialValues); + } + + /** see {@link ContentProvider#bulkInsert} */ + public int bulkInsert(Uri url, ContentValues[] initialValues) throws RemoteException { + return mContentProvider.bulkInsert(url, initialValues); + } + + /** see {@link ContentProvider#delete} */ + public int delete(Uri url, String selection, String[] selectionArgs) + throws RemoteException { + return mContentProvider.delete(url, selection, selectionArgs); + } + + /** see {@link ContentProvider#update} */ + public int update(Uri url, ContentValues values, String selection, + String[] selectionArgs) throws RemoteException { + return mContentProvider.update(url, values, selection, selectionArgs); + } + + /** see {@link ContentProvider#openFile} */ + public ParcelFileDescriptor openFile(Uri url, String mode) + throws RemoteException, FileNotFoundException { + return mContentProvider.openFile(url, mode); + } + + /** see {@link ContentProvider#openAssetFile} */ + public AssetFileDescriptor openAssetFile(Uri url, String mode) + throws RemoteException, FileNotFoundException { + return mContentProvider.openAssetFile(url, mode); + } + + /** see {@link ContentProvider#queryEntities} */ + public EntityIterator queryEntities(Uri uri, String selection, String[] selectionArgs, + String sortOrder) throws RemoteException { + return mContentProvider.queryEntities(uri, selection, selectionArgs, sortOrder); + } + + /** see {@link ContentProvider#insertEntity} */ + public Uri insertEntity(Uri uri, Entity entity) throws RemoteException { + return mContentProvider.insertEntity(uri, entity); + } + + /** see {@link ContentProvider#updateEntity} */ + public int updateEntity(Uri uri, Entity entity) throws RemoteException { + return mContentProvider.updateEntity(uri, entity); + } + + /** see {@link ContentProvider#applyBatch} */ + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws RemoteException, OperationApplicationException { + return mContentProvider.applyBatch(operations); + } + + /** + * Call this to indicate to the system that the associated {@link ContentProvider} is no + * longer needed by this {@link ContentProviderClient}. + * @return true if this was release, false if it was already released + */ + public boolean release() { + return mContentResolver.releaseProvider(mContentProvider); + } + + /** + * Get a reference to the {@link ContentProvider} that is associated with this + * client. If the {@link ContentProvider} is running in a different process then + * null will be returned. This can be used if you know you are running in the same + * process as a provider, and want to get direct access to its implementation details. + * + * @return If the associated {@link ContentProvider} is local, returns it. + * Otherwise returns null. + */ + public ContentProvider getLocalContentProvider() { + return ContentProvider.coerceToLocalContentProvider(mContentProvider); + } +} diff --git a/core/java/android/content/ContentProviderNative.java b/core/java/android/content/ContentProviderNative.java index e5e3f74..e367ceb 100644 --- a/core/java/android/content/ContentProviderNative.java +++ b/core/java/android/content/ContentProviderNative.java @@ -33,6 +33,7 @@ import android.os.ParcelFileDescriptor; import android.os.Parcelable; import java.io.FileNotFoundException; +import java.util.ArrayList; /** * {@hide} @@ -105,6 +106,20 @@ abstract public class ContentProviderNative extends Binder implements IContentPr return true; } + case QUERY_ENTITIES_TRANSACTION: + { + data.enforceInterface(IContentProvider.descriptor); + Uri url = Uri.CREATOR.createFromParcel(data); + String selection = data.readString(); + String[] selectionArgs = data.readStringArray(); + String sortOrder = data.readString(); + EntityIterator entityIterator = queryEntities(url, selection, selectionArgs, + sortOrder); + reply.writeNoException(); + reply.writeStrongBinder(new IEntityIteratorImpl(entityIterator).asBinder()); + return true; + } + case GET_TYPE_TRANSACTION: { data.enforceInterface(IContentProvider.descriptor); @@ -140,6 +155,43 @@ abstract public class ContentProviderNative extends Binder implements IContentPr return true; } + case INSERT_ENTITIES_TRANSACTION: + { + data.enforceInterface(IContentProvider.descriptor); + Uri uri = Uri.CREATOR.createFromParcel(data); + Entity entity = (Entity) data.readParcelable(null); + Uri newUri = insertEntity(uri, entity); + reply.writeNoException(); + Uri.writeToParcel(reply, newUri); + return true; + } + + case UPDATE_ENTITIES_TRANSACTION: + { + data.enforceInterface(IContentProvider.descriptor); + Uri uri = Uri.CREATOR.createFromParcel(data); + Entity entity = (Entity) data.readParcelable(null); + int count = updateEntity(uri, entity); + reply.writeNoException(); + reply.writeInt(count); + return true; + } + + case APPLY_BATCH_TRANSACTION: + { + data.enforceInterface(IContentProvider.descriptor); + final int numOperations = data.readInt(); + final ArrayList<ContentProviderOperation> operations = + new ArrayList<ContentProviderOperation>(numOperations); + for (int i = 0; i < numOperations; i++) { + operations.add(i, ContentProviderOperation.CREATOR.createFromParcel(data)); + } + final ContentProviderResult[] results = applyBatch(operations); + reply.writeNoException(); + reply.writeTypedArray(results, 0); + return true; + } + case DELETE_TRANSACTION: { data.enforceInterface(IContentProvider.descriptor); @@ -206,15 +258,6 @@ abstract public class ContentProviderNative extends Binder implements IContentPr } return true; } - - case GET_SYNC_ADAPTER_TRANSACTION: - { - data.enforceInterface(IContentProvider.descriptor); - ISyncAdapter sa = getSyncAdapter(); - reply.writeNoException(); - reply.writeStrongBinder(sa != null ? sa.asBinder() : null); - return true; - } } } catch (Exception e) { DatabaseUtils.writeExceptionToParcel(reply, e); @@ -224,6 +267,29 @@ abstract public class ContentProviderNative extends Binder implements IContentPr return super.onTransact(code, data, reply, flags); } + private class IEntityIteratorImpl extends IEntityIterator.Stub { + private final EntityIterator mEntityIterator; + + IEntityIteratorImpl(EntityIterator iterator) { + mEntityIterator = iterator; + } + public boolean hasNext() throws RemoteException { + return mEntityIterator.hasNext(); + } + + public Entity next() throws RemoteException { + return mEntityIterator.next(); + } + + public void reset() throws RemoteException { + mEntityIterator.reset(); + } + + public void close() throws RemoteException { + mEntityIterator.close(); + } + } + public IBinder asBinder() { return this; @@ -297,7 +363,7 @@ final class ContentProviderProxy implements IContentProvider BulkCursorToCursorAdaptor adaptor = new BulkCursorToCursorAdaptor(); IBulkCursor bulkCursor = bulkQuery(url, projection, selection, selectionArgs, sortOrder, adaptor.getObserver(), window); - + if (bulkCursor == null) { return null; } @@ -305,6 +371,58 @@ final class ContentProviderProxy implements IContentProvider return adaptor; } + public EntityIterator queryEntities(Uri url, String selection, String[] selectionArgs, + String sortOrder) + throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + + data.writeInterfaceToken(IContentProvider.descriptor); + + url.writeToParcel(data, 0); + data.writeString(selection); + data.writeStringArray(selectionArgs); + data.writeString(sortOrder); + + mRemote.transact(IContentProvider.QUERY_ENTITIES_TRANSACTION, data, reply, 0); + + DatabaseUtils.readExceptionFromParcel(reply); + + IBinder entityIteratorBinder = reply.readStrongBinder(); + + data.recycle(); + reply.recycle(); + + return new RemoteEntityIterator(IEntityIterator.Stub.asInterface(entityIteratorBinder)); + } + + static class RemoteEntityIterator implements EntityIterator { + private final IEntityIterator mEntityIterator; + RemoteEntityIterator(IEntityIterator entityIterator) { + mEntityIterator = entityIterator; + } + + public boolean hasNext() throws RemoteException { + return mEntityIterator.hasNext(); + } + + public Entity next() throws RemoteException { + return mEntityIterator.next(); + } + + public void reset() throws RemoteException { + mEntityIterator.reset(); + } + + public void close() { + try { + mEntityIterator.close(); + } catch (RemoteException e) { + // doesn't matter + } + } + } + public String getType(Uri url) throws RemoteException { Parcel data = Parcel.obtain(); @@ -366,6 +484,66 @@ final class ContentProviderProxy implements IContentProvider return count; } + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws RemoteException, OperationApplicationException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + + data.writeInterfaceToken(IContentProvider.descriptor); + data.writeInt(operations.size()); + for (ContentProviderOperation operation : operations) { + operation.writeToParcel(data, 0); + } + mRemote.transact(IContentProvider.APPLY_BATCH_TRANSACTION, data, reply, 0); + + DatabaseUtils.readExceptionWithOperationApplicationExceptionFromParcel(reply); + final ContentProviderResult[] results = + reply.createTypedArray(ContentProviderResult.CREATOR); + + data.recycle(); + reply.recycle(); + + return results; + } + + public Uri insertEntity(Uri uri, Entity entity) throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + + try { + data.writeInterfaceToken(IContentProvider.descriptor); + uri.writeToParcel(data, 0); + data.writeParcelable(entity, 0); + + mRemote.transact(IContentProvider.INSERT_ENTITIES_TRANSACTION, data, reply, 0); + + DatabaseUtils.readExceptionFromParcel(reply); + return Uri.CREATOR.createFromParcel(reply); + } finally { + data.recycle(); + reply.recycle(); + } + } + + public int updateEntity(Uri uri, Entity entity) throws RemoteException { + Parcel data = Parcel.obtain(); + Parcel reply = Parcel.obtain(); + + try { + data.writeInterfaceToken(IContentProvider.descriptor); + uri.writeToParcel(data, 0); + data.writeParcelable(entity, 0); + + mRemote.transact(IContentProvider.UPDATE_ENTITIES_TRANSACTION, data, reply, 0); + + DatabaseUtils.readExceptionFromParcel(reply); + return reply.readInt(); + } finally { + data.recycle(); + reply.recycle(); + } + } + public int delete(Uri url, String selection, String[] selectionArgs) throws RemoteException { Parcel data = Parcel.obtain(); @@ -456,23 +634,6 @@ final class ContentProviderProxy implements IContentProvider return fd; } - public ISyncAdapter getSyncAdapter() throws RemoteException { - Parcel data = Parcel.obtain(); - Parcel reply = Parcel.obtain(); - - data.writeInterfaceToken(IContentProvider.descriptor); - - mRemote.transact(IContentProvider.GET_SYNC_ADAPTER_TRANSACTION, data, reply, 0); - - DatabaseUtils.readExceptionFromParcel(reply); - ISyncAdapter syncAdapter = ISyncAdapter.Stub.asInterface(reply.readStrongBinder()); - - data.recycle(); - reply.recycle(); - - return syncAdapter; - } - private IBinder mRemote; } diff --git a/core/java/android/content/ContentProviderOperation.java b/core/java/android/content/ContentProviderOperation.java new file mode 100644 index 0000000..f5a4b75 --- /dev/null +++ b/core/java/android/content/ContentProviderOperation.java @@ -0,0 +1,548 @@ +/* + * Copyright (C) 2009 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.content; + +import android.database.Cursor; +import android.net.Uri; +import android.os.Parcel; +import android.os.Parcelable; +import android.text.TextUtils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +public class ContentProviderOperation implements Parcelable { + /** @hide exposed for unit tests */ + public final static int TYPE_INSERT = 1; + /** @hide exposed for unit tests */ + public final static int TYPE_UPDATE = 2; + /** @hide exposed for unit tests */ + public final static int TYPE_DELETE = 3; + /** @hide exposed for unit tests */ + public final static int TYPE_ASSERT = 4; + + private final int mType; + private final Uri mUri; + private final String mSelection; + private final String[] mSelectionArgs; + private final ContentValues mValues; + private final Integer mExpectedCount; + private final ContentValues mValuesBackReferences; + private final Map<Integer, Integer> mSelectionArgsBackReferences; + + /** + * Creates a {@link ContentProviderOperation} by copying the contents of a + * {@link Builder}. + */ + private ContentProviderOperation(Builder builder) { + mType = builder.mType; + mUri = builder.mUri; + mValues = builder.mValues; + mSelection = builder.mSelection; + mSelectionArgs = builder.mSelectionArgs; + mExpectedCount = builder.mExpectedCount; + mSelectionArgsBackReferences = builder.mSelectionArgsBackReferences; + mValuesBackReferences = builder.mValuesBackReferences; + } + + private ContentProviderOperation(Parcel source) { + mType = source.readInt(); + mUri = Uri.CREATOR.createFromParcel(source); + mValues = source.readInt() != 0 ? ContentValues.CREATOR.createFromParcel(source) : null; + mSelection = source.readInt() != 0 ? source.readString() : null; + mSelectionArgs = source.readInt() != 0 ? source.readStringArray() : null; + mExpectedCount = source.readInt() != 0 ? source.readInt() : null; + mValuesBackReferences = source.readInt() != 0 + + ? ContentValues.CREATOR.createFromParcel(source) + : null; + mSelectionArgsBackReferences = source.readInt() != 0 + ? new HashMap<Integer, Integer>() + : null; + if (mSelectionArgsBackReferences != null) { + final int count = source.readInt(); + for (int i = 0; i < count; i++) { + mSelectionArgsBackReferences.put(source.readInt(), source.readInt()); + } + } + } + + public void writeToParcel(Parcel dest, int flags) { + dest.writeInt(mType); + Uri.writeToParcel(dest, mUri); + if (mValues != null) { + dest.writeInt(1); + mValues.writeToParcel(dest, 0); + } else { + dest.writeInt(0); + } + if (mSelection != null) { + dest.writeInt(1); + dest.writeString(mSelection); + } else { + dest.writeInt(0); + } + if (mSelectionArgs != null) { + dest.writeInt(1); + dest.writeStringArray(mSelectionArgs); + } else { + dest.writeInt(0); + } + if (mExpectedCount != null) { + dest.writeInt(1); + dest.writeInt(mExpectedCount); + } else { + dest.writeInt(0); + } + if (mValuesBackReferences != null) { + dest.writeInt(1); + mValuesBackReferences.writeToParcel(dest, 0); + } else { + dest.writeInt(0); + } + if (mSelectionArgsBackReferences != null) { + dest.writeInt(1); + dest.writeInt(mSelectionArgsBackReferences.size()); + for (Map.Entry<Integer, Integer> entry : mSelectionArgsBackReferences.entrySet()) { + dest.writeInt(entry.getKey()); + dest.writeInt(entry.getValue()); + } + } else { + dest.writeInt(0); + } + } + + /** + * Create a {@link Builder} suitable for building an insert {@link ContentProviderOperation}. + * @param uri The {@link Uri} that is the target of the insert. + * @return a {@link Builder} + */ + public static Builder newInsert(Uri uri) { + return new Builder(TYPE_INSERT, uri); + } + + /** + * Create a {@link Builder} suitable for building an update {@link ContentProviderOperation}. + * @param uri The {@link Uri} that is the target of the update. + * @return a {@link Builder} + */ + public static Builder newUpdate(Uri uri) { + return new Builder(TYPE_UPDATE, uri); + } + + /** + * Create a {@link Builder} suitable for building a delete {@link ContentProviderOperation}. + * @param uri The {@link Uri} that is the target of the delete. + * @return a {@link Builder} + */ + public static Builder newDelete(Uri uri) { + return new Builder(TYPE_DELETE, uri); + } + + /** + * Create a {@link Builder} suitable for building a + * {@link ContentProviderOperation} to assert a set of values as provided + * through {@link Builder#withValues(ContentValues)}. + */ + public static Builder newAssertQuery(Uri uri) { + return new Builder(TYPE_ASSERT, uri); + } + + public Uri getUri() { + return mUri; + } + + /** @hide exposed for unit tests */ + public int getType() { + return mType; + } + + public boolean isWriteOperation() { + return mType == TYPE_DELETE || mType == TYPE_INSERT || mType == TYPE_UPDATE; + } + + public boolean isReadOperation() { + return mType == TYPE_ASSERT; + } + + /** + * Applies this operation using the given provider. The backRefs array is used to resolve any + * back references that were requested using + * {@link Builder#withValueBackReferences(ContentValues)} and + * {@link Builder#withSelectionBackReference}. + * @param provider the {@link ContentProvider} on which this batch is applied + * @param backRefs a {@link ContentProviderResult} array that will be consulted + * to resolve any requested back references. + * @param numBackRefs the number of valid results on the backRefs array. + * @return a {@link ContentProviderResult} that contains either the {@link Uri} of the inserted + * row if this was an insert otherwise the number of rows affected. + * @throws OperationApplicationException thrown if either the insert fails or + * if the number of rows affected didn't match the expected count + */ + public ContentProviderResult apply(ContentProvider provider, ContentProviderResult[] backRefs, + int numBackRefs) throws OperationApplicationException { + ContentValues values = resolveValueBackReferences(backRefs, numBackRefs); + String[] selectionArgs = + resolveSelectionArgsBackReferences(backRefs, numBackRefs); + + if (mType == TYPE_INSERT) { + Uri newUri = provider.insert(mUri, values); + if (newUri == null) { + throw new OperationApplicationException("insert failed"); + } + return new ContentProviderResult(newUri); + } + + int numRows; + if (mType == TYPE_DELETE) { + numRows = provider.delete(mUri, mSelection, selectionArgs); + } else if (mType == TYPE_UPDATE) { + numRows = provider.update(mUri, values, mSelection, selectionArgs); + } else if (mType == TYPE_ASSERT) { + // Build projection map from expected values + final ArrayList<String> projectionList = new ArrayList<String>(); + for (Map.Entry<String, Object> entry : values.valueSet()) { + projectionList.add(entry.getKey()); + } + + // Assert that all rows match expected values + final String[] projection = projectionList.toArray(new String[projectionList.size()]); + final Cursor cursor = provider.query(mUri, projection, mSelection, selectionArgs, null); + numRows = cursor.getCount(); + try { + while (cursor.moveToNext()) { + for (int i = 0; i < projection.length; i++) { + final String cursorValue = cursor.getString(i); + final String expectedValue = values.getAsString(projection[i]); + if (!TextUtils.equals(cursorValue, expectedValue)) { + // Throw exception when expected values don't match + throw new OperationApplicationException("Found value " + cursorValue + + " when expected " + expectedValue + " for column " + + projection[i]); + } + } + } + } finally { + cursor.close(); + } + } else { + throw new IllegalStateException("bad type, " + mType); + } + + if (mExpectedCount != null && mExpectedCount != numRows) { + throw new OperationApplicationException("wrong number of rows: " + numRows); + } + + return new ContentProviderResult(numRows); + } + + /** + * The ContentValues back references are represented as a ContentValues object where the + * key refers to a column and the value is an index of the back reference whose + * valued should be associated with the column. + * @param backRefs an array of previous results + * @param numBackRefs the number of valid previous results in backRefs + * @return the ContentValues that should be used in this operation application after + * expansion of back references. This can be called if either mValues or mValuesBackReferences + * is null + * @VisibleForTesting this is intended to be a private method but it is exposed for + * unit testing purposes + */ + public ContentValues resolveValueBackReferences( + ContentProviderResult[] backRefs, int numBackRefs) { + if (mValuesBackReferences == null) { + return mValues; + } + final ContentValues values; + if (mValues == null) { + values = new ContentValues(); + } else { + values = new ContentValues(mValues); + } + for (Map.Entry<String, Object> entry : mValuesBackReferences.valueSet()) { + String key = entry.getKey(); + Integer backRefIndex = mValuesBackReferences.getAsInteger(key); + if (backRefIndex == null) { + throw new IllegalArgumentException("values backref " + key + " is not an integer"); + } + values.put(key, backRefToValue(backRefs, numBackRefs, backRefIndex)); + } + return values; + } + + /** + * The Selection Arguments back references are represented as a Map of Integer->Integer where + * the key is an index into the selection argument array (see {@link Builder#withSelection}) + * and the value is the index of the previous result that should be used for that selection + * argument array slot. + * @param backRefs an array of previous results + * @param numBackRefs the number of valid previous results in backRefs + * @return the ContentValues that should be used in this operation application after + * expansion of back references. This can be called if either mValues or mValuesBackReferences + * is null + * @VisibleForTesting this is intended to be a private method but it is exposed for + * unit testing purposes + */ + public String[] resolveSelectionArgsBackReferences( + ContentProviderResult[] backRefs, int numBackRefs) { + if (mSelectionArgsBackReferences == null) { + return mSelectionArgs; + } + String[] newArgs = new String[mSelectionArgs.length]; + System.arraycopy(mSelectionArgs, 0, newArgs, 0, mSelectionArgs.length); + for (Map.Entry<Integer, Integer> selectionArgBackRef + : mSelectionArgsBackReferences.entrySet()) { + final Integer selectionArgIndex = selectionArgBackRef.getKey(); + final int backRefIndex = selectionArgBackRef.getValue(); + newArgs[selectionArgIndex] = + String.valueOf(backRefToValue(backRefs, numBackRefs, backRefIndex)); + } + return newArgs; + } + + /** + * Return the string representation of the requested back reference. + * @param backRefs an array of results + * @param numBackRefs the number of items in the backRefs array that are valid + * @param backRefIndex which backRef to be used + * @throws ArrayIndexOutOfBoundsException thrown if the backRefIndex is larger than + * the numBackRefs + * @return the string representation of the requested back reference. + */ + private static long backRefToValue(ContentProviderResult[] backRefs, int numBackRefs, + Integer backRefIndex) { + if (backRefIndex >= numBackRefs) { + throw new ArrayIndexOutOfBoundsException("asked for back ref " + backRefIndex + + " but there are only " + numBackRefs + " back refs"); + } + ContentProviderResult backRef = backRefs[backRefIndex]; + long backRefValue; + if (backRef.uri != null) { + backRefValue = ContentUris.parseId(backRef.uri); + } else { + backRefValue = backRef.count; + } + return backRefValue; + } + + public int describeContents() { + return 0; + } + + public static final Creator<ContentProviderOperation> CREATOR = + new Creator<ContentProviderOperation>() { + public ContentProviderOperation createFromParcel(Parcel source) { + return new ContentProviderOperation(source); + } + + public ContentProviderOperation[] newArray(int size) { + return new ContentProviderOperation[size]; + } + }; + + + /** + * Used to add parameters to a {@link ContentProviderOperation}. The {@link Builder} is + * first created by calling {@link ContentProviderOperation#newInsert(android.net.Uri)}, + * {@link ContentProviderOperation#newUpdate(android.net.Uri)}, + * {@link ContentProviderOperation#newDelete(android.net.Uri)} or + * {@link ContentProviderOperation#newAssertQuery(Uri)}. The withXXX methods + * can then be used to add parameters to the builder. See the specific methods to find for + * which {@link Builder} type each is allowed. Call {@link #build} to create the + * {@link ContentProviderOperation} once all the parameters have been supplied. + */ + public static class Builder { + private final int mType; + private final Uri mUri; + private String mSelection; + private String[] mSelectionArgs; + private ContentValues mValues; + private Integer mExpectedCount; + private ContentValues mValuesBackReferences; + private Map<Integer, Integer> mSelectionArgsBackReferences; + + /** Create a {@link Builder} of a given type. The uri must not be null. */ + private Builder(int type, Uri uri) { + if (uri == null) { + throw new IllegalArgumentException("uri must not be null"); + } + mType = type; + mUri = uri; + } + + /** Create a ContentProviderOperation from this {@link Builder}. */ + public ContentProviderOperation build() { + if (mType == TYPE_UPDATE || mType == TYPE_ASSERT) { + if ((mValues == null || mValues.size() == 0) + && (mValuesBackReferences == null || mValuesBackReferences.size() == 0)) { + throw new IllegalArgumentException("Empty values"); + } + } + return new ContentProviderOperation(this); + } + + /** + * Add a {@link ContentValues} of back references. The key is the name of the column + * and the value is an integer that is the index of the previous result whose + * value should be used for the column. The value is added as a {@link String}. + * A column value from the back references takes precedence over a value specified in + * {@link #withValues}. + * This can only be used with builders of type insert, update, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withValueBackReferences(ContentValues backReferences) { + if (mType != TYPE_INSERT && mType != TYPE_UPDATE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException( + "only inserts, updates, and asserts can have value back-references"); + } + mValuesBackReferences = backReferences; + return this; + } + + /** + * Add a ContentValues back reference. + * A column value from the back references takes precedence over a value specified in + * {@link #withValues}. + * This can only be used with builders of type insert, update, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withValueBackReference(String key, int previousResult) { + if (mType != TYPE_INSERT && mType != TYPE_UPDATE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException( + "only inserts, updates, and asserts can have value back-references"); + } + if (mValuesBackReferences == null) { + mValuesBackReferences = new ContentValues(); + } + mValuesBackReferences.put(key, previousResult); + return this; + } + + /** + * Add a back references as a selection arg. Any value at that index of the selection arg + * that was specified by {@link #withSelection} will be overwritten. + * This can only be used with builders of type update, delete, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withSelectionBackReference(int selectionArgIndex, int previousResult) { + if (mType != TYPE_UPDATE && mType != TYPE_DELETE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException("only updates, deletes, and asserts " + + "can have selection back-references"); + } + if (mSelectionArgsBackReferences == null) { + mSelectionArgsBackReferences = new HashMap<Integer, Integer>(); + } + mSelectionArgsBackReferences.put(selectionArgIndex, previousResult); + return this; + } + + /** + * The ContentValues to use. This may be null. These values may be overwritten by + * the corresponding value specified by {@link #withValueBackReference} or by + * future calls to {@link #withValues} or {@link #withValue}. + * This can only be used with builders of type insert, update, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withValues(ContentValues values) { + if (mType != TYPE_INSERT && mType != TYPE_UPDATE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException( + "only inserts, updates, and asserts can have values"); + } + if (mValues == null) { + mValues = new ContentValues(); + } + mValues.putAll(values); + return this; + } + + /** + * A value to insert or update. This value may be overwritten by + * the corresponding value specified by {@link #withValueBackReference}. + * This can only be used with builders of type insert, update, or assert. + * @param key the name of this value + * @param value the value itself. the type must be acceptable for insertion by + * {@link ContentValues#put} + * @return this builder, to allow for chaining. + */ + public Builder withValue(String key, Object value) { + if (mType != TYPE_INSERT && mType != TYPE_UPDATE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException("only inserts and updates can have values"); + } + if (mValues == null) { + mValues = new ContentValues(); + } + if (value == null) { + mValues.putNull(key); + } else if (value instanceof String) { + mValues.put(key, (String) value); + } else if (value instanceof Byte) { + mValues.put(key, (Byte) value); + } else if (value instanceof Short) { + mValues.put(key, (Short) value); + } else if (value instanceof Integer) { + mValues.put(key, (Integer) value); + } else if (value instanceof Long) { + mValues.put(key, (Long) value); + } else if (value instanceof Float) { + mValues.put(key, (Float) value); + } else if (value instanceof Double) { + mValues.put(key, (Double) value); + } else if (value instanceof Boolean) { + mValues.put(key, (Boolean) value); + } else if (value instanceof byte[]) { + mValues.put(key, (byte[]) value); + } else { + throw new IllegalArgumentException("bad value type: " + value.getClass().getName()); + } + return this; + } + + /** + * The selection and arguments to use. An occurrence of '?' in the selection will be + * replaced with the corresponding occurence of the selection argument. Any of the + * selection arguments may be overwritten by a selection argument back reference as + * specified by {@link #withSelectionBackReference}. + * This can only be used with builders of type update, delete, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withSelection(String selection, String[] selectionArgs) { + if (mType != TYPE_UPDATE && mType != TYPE_DELETE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException( + "only updates, deletes, and asserts can have selections"); + } + mSelection = selection; + mSelectionArgs = selectionArgs; + return this; + } + + /** + * If set then if the number of rows affected by this operation do not match + * this count {@link OperationApplicationException} will be throw. + * This can only be used with builders of type update, delete, or assert. + * @return this builder, to allow for chaining. + */ + public Builder withExpectedCount(int count) { + if (mType != TYPE_UPDATE && mType != TYPE_DELETE && mType != TYPE_ASSERT) { + throw new IllegalArgumentException( + "only updates, deletes, and asserts can have expected counts"); + } + mExpectedCount = count; + return this; + } + } +} diff --git a/core/java/android/content/ContentProviderResult.java b/core/java/android/content/ContentProviderResult.java new file mode 100644 index 0000000..5d188ef --- /dev/null +++ b/core/java/android/content/ContentProviderResult.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2009 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.content; + +import android.net.Uri; +import android.os.Parcelable; +import android.os.Parcel; + +/** + * Contains the result of the application of a {@link ContentProviderOperation}. It is guaranteed + * to have exactly one of {@link #uri} or {@link #count} set. + */ +public class ContentProviderResult implements Parcelable { + public final Uri uri; + public final Integer count; + + public ContentProviderResult(Uri uri) { + if (uri == null) throw new IllegalArgumentException("uri must not be null"); + this.uri = uri; + this.count = null; + } + + public ContentProviderResult(int count) { + this.count = count; + this.uri = null; + } + + public ContentProviderResult(Parcel source) { + int type = source.readInt(); + if (type == 1) { + count = source.readInt(); + uri = null; + } else { + count = null; + uri = Uri.CREATOR.createFromParcel(source); + } + } + + public void writeToParcel(Parcel dest, int flags) { + if (uri == null) { + dest.writeInt(1); + dest.writeInt(count); + } else { + dest.writeInt(2); + uri.writeToParcel(dest, 0); + } + } + + public int describeContents() { + return 0; + } + + public static final Creator<ContentProviderResult> CREATOR = + new Creator<ContentProviderResult>() { + public ContentProviderResult createFromParcel(Parcel source) { + return new ContentProviderResult(source); + } + + public ContentProviderResult[] newArray(int size) { + return new ContentProviderResult[size]; + } + }; + + public String toString() { + if (uri != null) { + return "ContentProviderResult(uri=" + uri.toString() + ")"; + } + return "ContentProviderResult(count=" + count + ")"; + } +}
\ No newline at end of file diff --git a/core/java/android/content/ContentResolver.java b/core/java/android/content/ContentResolver.java index 74144fc..b915803 100644 --- a/core/java/android/content/ContentResolver.java +++ b/core/java/android/content/ContentResolver.java @@ -30,6 +30,7 @@ import android.os.ParcelFileDescriptor; import android.os.RemoteException; import android.os.ServiceManager; import android.text.TextUtils; +import android.accounts.Account; import android.util.Config; import android.util.Log; @@ -40,19 +41,40 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.List; +import java.util.ArrayList; /** * This class provides applications access to the content model. */ public abstract class ContentResolver { - public final static String SYNC_EXTRAS_ACCOUNT = "account"; + /** + * @deprecated instead use + * {@link #requestSync(android.accounts.Account, String, android.os.Bundle)} + */ + @Deprecated + public static final String SYNC_EXTRAS_ACCOUNT = "account"; public static final String SYNC_EXTRAS_EXPEDITED = "expedited"; + /** + * @deprecated instead use + * {@link #SYNC_EXTRAS_MANUAL} + */ + @Deprecated public static final String SYNC_EXTRAS_FORCE = "force"; + public static final String SYNC_EXTRAS_MANUAL = "force"; public static final String SYNC_EXTRAS_UPLOAD = "upload"; public static final String SYNC_EXTRAS_OVERRIDE_TOO_MANY_DELETIONS = "deletions_override"; public static final String SYNC_EXTRAS_DISCARD_LOCAL_DELETIONS = "discard_deletions"; + /** + * Set by the SyncManager to request that the SyncAdapter initialize itself for + * the given account/authority pair. One required initialization step is to + * ensure that {@link #setIsSyncable(android.accounts.Account, String, int)} has been + * called with a >= 0 value. When this flag is set the SyncAdapter does not need to + * do a full sync, though it is allowed to do so. + */ + public static final String SYNC_EXTRAS_INITIALIZE = "initialize"; + public static final String SCHEME_CONTENT = "content"; public static final String SCHEME_ANDROID_RESOURCE = "android.resource"; public static final String SCHEME_FILE = "file"; @@ -88,7 +110,35 @@ public abstract class ContentResolver { * in the cursor is the same. */ public static final String CURSOR_DIR_BASE_TYPE = "vnd.android.cursor.dir"; - + + /** @hide */ + public static final int SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS = 1; + /** @hide */ + public static final int SYNC_ERROR_AUTHENTICATION = 2; + /** @hide */ + public static final int SYNC_ERROR_IO = 3; + /** @hide */ + public static final int SYNC_ERROR_PARSE = 4; + /** @hide */ + public static final int SYNC_ERROR_CONFLICT = 5; + /** @hide */ + public static final int SYNC_ERROR_TOO_MANY_DELETIONS = 6; + /** @hide */ + public static final int SYNC_ERROR_TOO_MANY_RETRIES = 7; + /** @hide */ + public static final int SYNC_ERROR_INTERNAL = 8; + + /** @hide */ + public static final int SYNC_OBSERVER_TYPE_SETTINGS = 1<<0; + /** @hide */ + public static final int SYNC_OBSERVER_TYPE_PENDING = 1<<1; + /** @hide */ + public static final int SYNC_OBSERVER_TYPE_ACTIVE = 1<<2; + /** @hide */ + public static final int SYNC_OBSERVER_TYPE_STATUS = 1<<3; + /** @hide */ + public static final int SYNC_OBSERVER_TYPE_ALL = 0x7fffffff; + public ContentResolver(Context context) { mContext = context; } @@ -166,6 +216,94 @@ public abstract class ContentResolver { } /** + * EntityIterator wrapper that releases the associated ContentProviderClient when the + * iterator is closed. + */ + private class EntityIteratorWrapper implements EntityIterator { + private final EntityIterator mInner; + private final ContentProviderClient mClient; + private volatile boolean mClientReleased; + + EntityIteratorWrapper(EntityIterator inner, ContentProviderClient client) { + mInner = inner; + mClient = client; + mClientReleased = false; + } + + public boolean hasNext() throws RemoteException { + if (mClientReleased) { + throw new IllegalStateException("this iterator is already closed"); + } + return mInner.hasNext(); + } + + public Entity next() throws RemoteException { + if (mClientReleased) { + throw new IllegalStateException("this iterator is already closed"); + } + return mInner.next(); + } + + public void reset() throws RemoteException { + if (mClientReleased) { + throw new IllegalStateException("this iterator is already closed"); + } + mInner.reset(); + } + + public void close() { + mClient.release(); + mInner.close(); + mClientReleased = true; + } + + protected void finalize() throws Throwable { + if (!mClientReleased) { + mClient.release(); + } + super.finalize(); + } + } + + /** + * Query the given URI, returning an {@link EntityIterator} over the result set. + * + * @param uri The URI, using the content:// scheme, for the content to + * retrieve. + * @param selection A filter declaring which rows to return, formatted as an + * SQL WHERE clause (excluding the WHERE itself). Passing null will + * return all rows for the given URI. + * @param selectionArgs You may include ?s in selection, which will be + * replaced by the values from selectionArgs, in the order that they + * appear in the selection. The values will be bound as Strings. + * @param sortOrder How to order the rows, formatted as an SQL ORDER BY + * clause (excluding the ORDER BY itself). Passing null will use the + * default sort order, which may be unordered. + * @return An EntityIterator object + * @throws RemoteException thrown if a RemoteException is encountered while attempting + * to communicate with a remote provider. + * @throws IllegalArgumentException thrown if there is no provider that matches the uri + */ + public final EntityIterator queryEntities(Uri uri, + String selection, String[] selectionArgs, String sortOrder) throws RemoteException { + ContentProviderClient provider = acquireContentProviderClient(uri); + if (provider == null) { + throw new IllegalArgumentException("Unknown URL " + uri); + } + try { + EntityIterator entityIterator = + provider.queryEntities(uri, selection, selectionArgs, sortOrder); + return new EntityIteratorWrapper(entityIterator, provider); + } catch(RuntimeException e) { + provider.release(); + throw e; + } catch(RemoteException e) { + provider.release(); + throw e; + } + } + + /** * Open a stream on to the content associated with a content URI. If there * is no data associated with the URI, FileNotFoundException is thrown. * @@ -485,6 +623,36 @@ public abstract class ContentResolver { } /** + * Applies each of the {@link ContentProviderOperation} objects and returns an array + * of their results. Passes through OperationApplicationException, which may be thrown + * by the call to {@link ContentProviderOperation#apply}. + * If all the applications succeed then a {@link ContentProviderResult} array with the + * same number of elements as the operations will be returned. It is implementation-specific + * how many, if any, operations will have been successfully applied if a call to + * apply results in a {@link OperationApplicationException}. + * @param authority the authority of the ContentProvider to which this batch should be applied + * @param operations the operations to apply + * @return the results of the applications + * @throws OperationApplicationException thrown if an application fails. + * See {@link ContentProviderOperation#apply} for more information. + * @throws RemoteException thrown if a RemoteException is encountered while attempting + * to communicate with a remote provider. + */ + public ContentProviderResult[] applyBatch(String authority, + ArrayList<ContentProviderOperation> operations) + throws RemoteException, OperationApplicationException { + ContentProviderClient provider = acquireContentProviderClient(authority); + if (provider == null) { + throw new IllegalArgumentException("Unknown authority " + authority); + } + try { + return provider.applyBatch(operations); + } finally { + provider.release(); + } + } + + /** * Inserts multiple rows into a table at the given URL. * * This function make no guarantees about the atomicity of the insertions. @@ -592,6 +760,46 @@ public abstract class ContentResolver { } /** + * Returns a {@link ContentProviderClient} that is associated with the {@link ContentProvider} + * that services the content at uri, starting the provider if necessary. Returns + * null if there is no provider associated wih the uri. The caller must indicate that they are + * done with the provider by calling {@link ContentProviderClient#release} which will allow + * the system to release the provider it it determines that there is no other reason for + * keeping it active. + * @param uri specifies which provider should be acquired + * @return a {@link ContentProviderClient} that is associated with the {@link ContentProvider} + * that services the content at uri or null if there isn't one. + */ + public final ContentProviderClient acquireContentProviderClient(Uri uri) { + IContentProvider provider = acquireProvider(uri); + if (provider != null) { + return new ContentProviderClient(this, provider); + } + + return null; + } + + /** + * Returns a {@link ContentProviderClient} that is associated with the {@link ContentProvider} + * with the authority of name, starting the provider if necessary. Returns + * null if there is no provider associated wih the uri. The caller must indicate that they are + * done with the provider by calling {@link ContentProviderClient#release} which will allow + * the system to release the provider it it determines that there is no other reason for + * keeping it active. + * @param name specifies which provider should be acquired + * @return a {@link ContentProviderClient} that is associated with the {@link ContentProvider} + * with the authority of name or null if there isn't one. + */ + public final ContentProviderClient acquireContentProviderClient(String name) { + IContentProvider provider = acquireProvider(name); + if (provider != null) { + return new ContentProviderClient(this, provider); + } + + return null; + } + + /** * Register an observer class that gets callbacks when data identified by a * given content URI changes. * @@ -676,11 +884,42 @@ public abstract class ContentResolver { * * @param uri the uri of the provider to sync or null to sync all providers. * @param extras any extras to pass to the SyncAdapter. + * @deprecated instead use + * {@link #requestSync(android.accounts.Account, String, android.os.Bundle)} */ public void startSync(Uri uri, Bundle extras) { + Account account = null; + if (extras != null) { + String accountName = extras.getString(SYNC_EXTRAS_ACCOUNT); + if (!TextUtils.isEmpty(accountName)) { + account = new Account(accountName, "com.google.GAIA"); + } + extras.remove(SYNC_EXTRAS_ACCOUNT); + } + requestSync(account, uri != null ? uri.getAuthority() : null, extras); + } + + /** + * Start an asynchronous sync operation. If you want to monitor the progress + * of the sync you may register a SyncObserver. Only values of the following + * types may be used in the extras bundle: + * <ul> + * <li>Integer</li> + * <li>Long</li> + * <li>Boolean</li> + * <li>Float</li> + * <li>Double</li> + * <li>String</li> + * </ul> + * + * @param account which account should be synced + * @param authority which authority should be synced + * @param extras any extras to pass to the SyncAdapter. + */ + public static void requestSync(Account account, String authority, Bundle extras) { validateSyncExtrasBundle(extras); try { - getContentService().startSync(uri, extras); + getContentService().requestSync(account, authority, extras); } catch (RemoteException e) { } } @@ -694,6 +933,7 @@ public abstract class ContentResolver { * <li>Float</li> * <li>Double</li> * <li>String</li> + * <li>Account</li> * <li>null</li> * </ul> * @param extras the Bundle to check @@ -709,6 +949,7 @@ public abstract class ContentResolver { if (value instanceof Float) continue; if (value instanceof Double) continue; if (value instanceof String) continue; + if (value instanceof Account) continue; throw new IllegalArgumentException("unexpected value type: " + value.getClass().getName()); } @@ -719,13 +960,210 @@ public abstract class ContentResolver { } } + /** + * Cancel any active or pending syncs that match the Uri. If the uri is null then + * all syncs will be canceled. + * + * @param uri the uri of the provider to sync or null to sync all providers. + * @deprecated instead use {@link #cancelSync(android.accounts.Account, String)} + */ public void cancelSync(Uri uri) { + cancelSync(null /* all accounts */, uri != null ? uri.getAuthority() : null); + } + + /** + * Cancel any active or pending syncs that match account and authority. The account and + * authority can each independently be set to null, which means that syncs with any account + * or authority, respectively, will match. + * + * @param account filters the syncs that match by this account + * @param authority filters the syncs that match by this authority + */ + public static void cancelSync(Account account, String authority) { + try { + getContentService().cancelSync(account, authority); + } catch (RemoteException e) { + } + } + + /** + * Get information about the SyncAdapters that are known to the system. + * @return an array of SyncAdapters that have registered with the system + */ + public static SyncAdapterType[] getSyncAdapterTypes() { + try { + return getContentService().getSyncAdapterTypes(); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * Check if the provider should be synced when a network tickle is received + * + * @param account the account whose setting we are querying + * @param authority the provider whose setting we are querying + * @return true if the provider should be synced when a network tickle is received + */ + public static boolean getSyncAutomatically(Account account, String authority) { + try { + return getContentService().getSyncAutomatically(account, authority); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * Set whether or not the provider is synced when it receives a network tickle. + * + * @param account the account whose setting we are querying + * @param authority the provider whose behavior is being controlled + * @param sync true if the provider should be synced when tickles are received for it + */ + public static void setSyncAutomatically(Account account, String authority, boolean sync) { + try { + getContentService().setSyncAutomatically(account, authority, sync); + } catch (RemoteException e) { + // exception ignored; if this is thrown then it means the runtime is in the midst of + // being restarted + } + } + + /** + * Check if this account/provider is syncable. + * @return >0 if it is syncable, 0 if not, and <0 if the state isn't known yet. + */ + public static int getIsSyncable(Account account, String authority) { + try { + return getContentService().getIsSyncable(account, authority); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * Set whether this account/provider is syncable. + * @param syncable >0 denotes syncable, 0 means not syncable, <0 means unknown + */ + public static void setIsSyncable(Account account, String authority, int syncable) { + try { + getContentService().setIsSyncable(account, authority, syncable); + } catch (RemoteException e) { + // exception ignored; if this is thrown then it means the runtime is in the midst of + // being restarted + } + } + + /** + * Gets the master auto-sync setting that applies to all the providers and accounts. + * If this is false then the per-provider auto-sync setting is ignored. + * + * @return the master auto-sync setting that applies to all the providers and accounts + */ + public static boolean getMasterSyncAutomatically() { + try { + return getContentService().getMasterSyncAutomatically(); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * Sets the master auto-sync setting that applies to all the providers and accounts. + * If this is false then the per-provider auto-sync setting is ignored. + * + * @param sync the master auto-sync setting that applies to all the providers and accounts + */ + public static void setMasterSyncAutomatically(boolean sync) { + try { + getContentService().setMasterSyncAutomatically(sync); + } catch (RemoteException e) { + // exception ignored; if this is thrown then it means the runtime is in the midst of + // being restarted + } + } + + /** + * Returns true if there is currently a sync operation for the given + * account or authority in the pending list, or actively being processed. + * @param account the account whose setting we are querying + * @param authority the provider whose behavior is being queried + * @return true if a sync is active for the given account or authority. + */ + public static boolean isSyncActive(Account account, String authority) { + try { + return getContentService().isSyncActive(account, authority); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * If a sync is active returns the information about it, otherwise returns false. + * @return the ActiveSyncInfo for the currently active sync or null if one is not active. + * @hide + */ + public static ActiveSyncInfo getActiveSync() { try { - getContentService().cancelSync(uri); + return getContentService().getActiveSync(); } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); } } + /** + * Returns the status that matches the authority. + * @param account the account whose setting we are querying + * @param authority the provider whose behavior is being queried + * @return the SyncStatusInfo for the authority, or null if none exists + * @hide + */ + public static SyncStatusInfo getSyncStatus(Account account, String authority) { + try { + return getContentService().getSyncStatus(account, authority); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + /** + * Return true if the pending status is true of any matching authorities. + * @param account the account whose setting we are querying + * @param authority the provider whose behavior is being queried + * @return true if there is a pending sync with the matching account and authority + */ + public static boolean isSyncPending(Account account, String authority) { + try { + return getContentService().isSyncPending(account, authority); + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + public static Object addStatusChangeListener(int mask, final SyncStatusObserver callback) { + try { + ISyncStatusObserver.Stub observer = new ISyncStatusObserver.Stub() { + public void onStatusChanged(int which) throws RemoteException { + callback.onStatusChanged(which); + } + }; + getContentService().addStatusChangeListener(mask, observer); + return observer; + } catch (RemoteException e) { + throw new RuntimeException("the ContentService should always be reachable", e); + } + } + + public static void removeStatusChangeListener(Object handle) { + try { + getContentService().removeStatusChangeListener((ISyncStatusObserver.Stub) handle); + } catch (RemoteException e) { + // exception ignored; if this is thrown then it means the runtime is in the midst of + // being restarted + } + } + + private final class CursorWrapperInner extends CursorWrapper { private IContentProvider mContentProvider; public static final String TAG="CursorWrapperInner"; diff --git a/core/java/android/content/ContentService.java b/core/java/android/content/ContentService.java index 6cd2c54..f742448 100644 --- a/core/java/android/content/ContentService.java +++ b/core/java/android/content/ContentService.java @@ -16,6 +16,7 @@ package android.content; +import android.accounts.Account; import android.database.IContentObserver; import android.database.sqlite.SQLiteException; import android.net.Uri; @@ -160,7 +161,9 @@ public final class ContentService extends IContentService.Stub { } if (syncToNetwork) { SyncManager syncManager = getSyncManager(); - if (syncManager != null) syncManager.scheduleLocalSync(uri); + if (syncManager != null) { + syncManager.scheduleLocalSync(null /* all accounts */, uri.getAuthority()); + } } } finally { restoreCallingIdentity(identityToken); @@ -186,14 +189,17 @@ public final class ContentService extends IContentService.Stub { } } - public void startSync(Uri url, Bundle extras) { + public void requestSync(Account account, String authority, Bundle extras) { ContentResolver.validateSyncExtrasBundle(extras); // This makes it so that future permission checks will be in the context of this // process rather than the caller's process. We will restore this before returning. long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); - if (syncManager != null) syncManager.startSync(url, extras); + if (syncManager != null) { + syncManager.scheduleSync(account, authority, extras, 0 /* no delay */, + false /* onlyThoseWithUnkownSyncableState */); + } } finally { restoreCallingIdentity(identityToken); } @@ -201,34 +207,50 @@ public final class ContentService extends IContentService.Stub { /** * Clear all scheduled sync operations that match the uri and cancel the active sync - * if it matches the uri. If the uri is null, clear all scheduled syncs and cancel - * the active one, if there is one. - * @param uri Filter on the sync operations to cancel, or all if null. + * if they match the authority and account, if they are present. + * @param account filter the pending and active syncs to cancel using this account + * @param authority filter the pending and active syncs to cancel using this authority */ - public void cancelSync(Uri uri) { + public void cancelSync(Account account, String authority) { // This makes it so that future permission checks will be in the context of this // process rather than the caller's process. We will restore this before returning. long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - syncManager.clearScheduledSyncOperations(uri); - syncManager.cancelActiveSync(uri); + syncManager.clearScheduledSyncOperations(account, authority); + syncManager.cancelActiveSync(account, authority); } } finally { restoreCallingIdentity(identityToken); } } - public boolean getSyncProviderAutomatically(String providerName) { + /** + * Get information about the SyncAdapters that are known to the system. + * @return an array of SyncAdapters that have registered with the system + */ + public SyncAdapterType[] getSyncAdapterTypes() { + // This makes it so that future permission checks will be in the context of this + // process rather than the caller's process. We will restore this before returning. + long identityToken = clearCallingIdentity(); + try { + SyncManager syncManager = getSyncManager(); + return syncManager.getSyncAdapterTypes(); + } finally { + restoreCallingIdentity(identityToken); + } + } + + public boolean getSyncAutomatically(Account account, String providerName) { mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, "no permission to read the sync settings"); long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - return syncManager.getSyncStorageEngine().getSyncProviderAutomatically( - null, providerName); + return syncManager.getSyncStorageEngine().getSyncAutomatically( + account, providerName); } } finally { restoreCallingIdentity(identityToken); @@ -236,29 +258,60 @@ public final class ContentService extends IContentService.Stub { return false; } - public void setSyncProviderAutomatically(String providerName, boolean sync) { + public void setSyncAutomatically(Account account, String providerName, boolean sync) { + mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, + "no permission to write the sync settings"); + long identityToken = clearCallingIdentity(); + try { + SyncManager syncManager = getSyncManager(); + if (syncManager != null) { + syncManager.getSyncStorageEngine().setSyncAutomatically( + account, providerName, sync); + } + } finally { + restoreCallingIdentity(identityToken); + } + } + + public int getIsSyncable(Account account, String providerName) { + mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, + "no permission to read the sync settings"); + long identityToken = clearCallingIdentity(); + try { + SyncManager syncManager = getSyncManager(); + if (syncManager != null) { + return syncManager.getSyncStorageEngine().getIsSyncable( + account, providerName); + } + } finally { + restoreCallingIdentity(identityToken); + } + return -1; + } + + public void setIsSyncable(Account account, String providerName, int syncable) { mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, "no permission to write the sync settings"); long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - syncManager.getSyncStorageEngine().setSyncProviderAutomatically( - null, providerName, sync); + syncManager.getSyncStorageEngine().setIsSyncable( + account, providerName, syncable); } } finally { restoreCallingIdentity(identityToken); } } - public boolean getListenForNetworkTickles() { + public boolean getMasterSyncAutomatically() { mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, "no permission to read the sync settings"); long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - return syncManager.getSyncStorageEngine().getListenForNetworkTickles(); + return syncManager.getSyncStorageEngine().getMasterSyncAutomatically(); } } finally { restoreCallingIdentity(identityToken); @@ -266,21 +319,21 @@ public final class ContentService extends IContentService.Stub { return false; } - public void setListenForNetworkTickles(boolean flag) { + public void setMasterSyncAutomatically(boolean flag) { mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, "no permission to write the sync settings"); long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - syncManager.getSyncStorageEngine().setListenForNetworkTickles(flag); + syncManager.getSyncStorageEngine().setMasterSyncAutomatically(flag); } } finally { restoreCallingIdentity(identityToken); } } - public boolean isSyncActive(String account, String authority) { + public boolean isSyncActive(Account account, String authority) { mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, "no permission to read the sync stats"); long identityToken = clearCallingIdentity(); @@ -311,7 +364,7 @@ public final class ContentService extends IContentService.Stub { return null; } - public SyncStatusInfo getStatusByAuthority(String authority) { + public SyncStatusInfo getSyncStatus(Account account, String authority) { mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, "no permission to read the sync stats"); long identityToken = clearCallingIdentity(); @@ -327,15 +380,14 @@ public final class ContentService extends IContentService.Stub { return null; } - public boolean isAuthorityPending(String account, String authority) { + public boolean isSyncPending(Account account, String authority) { mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, "no permission to read the sync stats"); long identityToken = clearCallingIdentity(); try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - return syncManager.getSyncStorageEngine().isAuthorityPending( - account, authority); + return syncManager.getSyncStorageEngine().isSyncPending(account, authority); } } finally { restoreCallingIdentity(identityToken); @@ -348,8 +400,7 @@ public final class ContentService extends IContentService.Stub { try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - syncManager.getSyncStorageEngine().addStatusChangeListener( - mask, callback); + syncManager.getSyncStorageEngine().addStatusChangeListener(mask, callback); } } finally { restoreCallingIdentity(identityToken); @@ -361,8 +412,7 @@ public final class ContentService extends IContentService.Stub { try { SyncManager syncManager = getSyncManager(); if (syncManager != null) { - syncManager.getSyncStorageEngine().removeStatusChangeListener( - callback); + syncManager.getSyncStorageEngine().removeStatusChangeListener(callback); } } finally { restoreCallingIdentity(identityToken); diff --git a/core/java/android/content/Context.java b/core/java/android/content/Context.java index 25b5de3..d86ab79 100644 --- a/core/java/android/content/Context.java +++ b/core/java/android/content/Context.java @@ -488,89 +488,44 @@ public abstract class Context { public abstract String[] databaseList(); /** - * Like {@link #peekWallpaper}, but always returns a valid Drawable. If - * no wallpaper is set, the system default wallpaper is returned. - * - * @return Returns a Drawable object that will draw the wallpaper. + * @deprecated Use {@link android.app.WallpaperManager#getDrawable + * WallpaperManager.get()} instead. */ public abstract Drawable getWallpaper(); /** - * Retrieve the current system wallpaper. This is returned as an - * abstract Drawable that you can install in a View to display whatever - * wallpaper the user has currently set. If there is no wallpaper set, - * a null pointer is returned. - * - * @return Returns a Drawable object that will draw the wallpaper or a - * null pointer if these is none. + * @deprecated Use {@link android.app.WallpaperManager#peekDrawable + * WallpaperManager.peek()} instead. */ public abstract Drawable peekWallpaper(); /** - * Returns the desired minimum width for the wallpaper. Callers of - * {@link #setWallpaper(android.graphics.Bitmap)} or - * {@link #setWallpaper(java.io.InputStream)} should check this value - * beforehand to make sure the supplied wallpaper respects the desired - * minimum width. - * - * If the returned value is <= 0, the caller should use the width of - * the default display instead. - * - * @return The desired minimum width for the wallpaper. This value should - * be honored by applications that set the wallpaper but it is not - * mandatory. + * @deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumWidth() + * WallpaperManager.getDesiredMinimumWidth()} instead. */ public abstract int getWallpaperDesiredMinimumWidth(); /** - * Returns the desired minimum height for the wallpaper. Callers of - * {@link #setWallpaper(android.graphics.Bitmap)} or - * {@link #setWallpaper(java.io.InputStream)} should check this value - * beforehand to make sure the supplied wallpaper respects the desired - * minimum height. - * - * If the returned value is <= 0, the caller should use the height of - * the default display instead. - * - * @return The desired minimum height for the wallpaper. This value should - * be honored by applications that set the wallpaper but it is not - * mandatory. + * @deprecated Use {@link android.app.WallpaperManager#getDesiredMinimumHeight() + * WallpaperManager.getDesiredMinimumHeight()} instead. */ public abstract int getWallpaperDesiredMinimumHeight(); /** - * Change the current system wallpaper to a bitmap. The given bitmap is - * converted to a PNG and stored as the wallpaper. On success, the intent - * {@link Intent#ACTION_WALLPAPER_CHANGED} is broadcast. - * - * @param bitmap The bitmap to save. - * - * @throws IOException If an error occurs reverting to the default - * wallpaper. + * @deprecated Use {@link android.app.WallpaperManager#setBitmap(Bitmap) + * WallpaperManager.set()} instead. */ public abstract void setWallpaper(Bitmap bitmap) throws IOException; /** - * Change the current system wallpaper to a specific byte stream. The - * give InputStream is copied into persistent storage and will now be - * used as the wallpaper. Currently it must be either a JPEG or PNG - * image. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} - * is broadcast. - * - * @param data A stream containing the raw data to install as a wallpaper. - * - * @throws IOException If an error occurs reverting to the default - * wallpaper. + * @deprecated Use {@link android.app.WallpaperManager#setStream(InputStream) + * WallpaperManager.set()} instead. */ public abstract void setWallpaper(InputStream data) throws IOException; /** - * Remove any currently set wallpaper, reverting to the system's default - * wallpaper. On success, the intent {@link Intent#ACTION_WALLPAPER_CHANGED} - * is broadcast. - * - * @throws IOException If an error occurs reverting to the default - * wallpaper. + * @deprecated Use {@link android.app.WallpaperManager#clear + * WallpaperManager.clear()} instead. */ public abstract void clearWallpaper() throws IOException; @@ -1110,6 +1065,16 @@ public abstract class Context { public static final String LAYOUT_INFLATER_SERVICE = "layout_inflater"; /** * Use with {@link #getSystemService} to retrieve a + * {@link android.accounts.AccountManager} for receiving intents at a + * time of your choosing. + * TODO STOPSHIP perform a final review of the the account apis before shipping + * + * @see #getSystemService + * @see android.accounts.AccountManager + */ + public static final String ACCOUNT_SERVICE = "account"; + /** + * Use with {@link #getSystemService} to retrieve a * {@link android.app.ActivityManager} for interacting with the global * system state. * @@ -1179,11 +1144,10 @@ public abstract class Context { public static final String SENSOR_SERVICE = "sensor"; /** * Use with {@link #getSystemService} to retrieve a {@link - * android.bluetooth.BluetoothDevice} for interacting with Bluetooth. + * android.bluetooth.BluetoothAdapter} for using Bluetooth. * * @see #getSystemService - * @see android.bluetooth.BluetoothDevice - * @hide + * @see android.bluetooth.BluetoothAdapter */ public static final String BLUETOOTH_SERVICE = "bluetooth"; /** diff --git a/core/java/android/content/Entity.aidl b/core/java/android/content/Entity.aidl new file mode 100644 index 0000000..fb201f3 --- /dev/null +++ b/core/java/android/content/Entity.aidl @@ -0,0 +1,20 @@ +/* //device/java/android/android/content/Entity.aidl +** +** Copyright 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.content; + +parcelable Entity; diff --git a/core/java/android/content/Entity.java b/core/java/android/content/Entity.java new file mode 100644 index 0000000..325dce5 --- /dev/null +++ b/core/java/android/content/Entity.java @@ -0,0 +1,104 @@ +/* + * Copyright (C) 2009 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.content; + +import android.os.Parcelable; +import android.os.Parcel; +import android.net.Uri; +import android.util.Log; + +import java.util.ArrayList; + +/** + * Objects that pass through the ContentProvider and ContentResolver's methods that deal with + * Entities must implement this abstract base class and thus themselves be Parcelable. + */ +public final class Entity implements Parcelable { + final private ContentValues mValues; + final private ArrayList<NamedContentValues> mSubValues; + + public Entity(ContentValues values) { + mValues = values; + mSubValues = new ArrayList<NamedContentValues>(); + } + + public ContentValues getEntityValues() { + return mValues; + } + + public ArrayList<NamedContentValues> getSubValues() { + return mSubValues; + } + + public void addSubValue(Uri uri, ContentValues values) { + mSubValues.add(new Entity.NamedContentValues(uri, values)); + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + mValues.writeToParcel(dest, 0); + dest.writeInt(mSubValues.size()); + for (NamedContentValues value : mSubValues) { + value.uri.writeToParcel(dest, 0); + value.values.writeToParcel(dest, 0); + } + } + + private Entity(Parcel source) { + mValues = ContentValues.CREATOR.createFromParcel(source); + final int numValues = source.readInt(); + mSubValues = new ArrayList<NamedContentValues>(numValues); + for (int i = 0; i < numValues; i++) { + final Uri uri = Uri.CREATOR.createFromParcel(source); + final ContentValues values = ContentValues.CREATOR.createFromParcel(source); + mSubValues.add(new NamedContentValues(uri, values)); + } + } + + public static final Creator<Entity> CREATOR = new Creator<Entity>() { + public Entity createFromParcel(Parcel source) { + return new Entity(source); + } + + public Entity[] newArray(int size) { + return new Entity[size]; + } + }; + + public static class NamedContentValues { + public final Uri uri; + public final ContentValues values; + + public NamedContentValues(Uri uri, ContentValues values) { + this.uri = uri; + this.values = values; + } + } + + public String toString() { + final StringBuilder sb = new StringBuilder(); + sb.append("Entity: ").append(getEntityValues()); + for (Entity.NamedContentValues namedValue : getSubValues()) { + sb.append("\n ").append(namedValue.uri); + sb.append("\n -> ").append(namedValue.values); + } + return sb.toString(); + } +} diff --git a/core/java/android/content/EntityIterator.java b/core/java/android/content/EntityIterator.java new file mode 100644 index 0000000..3cc1040 --- /dev/null +++ b/core/java/android/content/EntityIterator.java @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2009 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.content; + +import android.os.RemoteException; + +public interface EntityIterator { + /** + * Returns whether there are more elements to iterate, i.e. whether the + * iterator is positioned in front of an element. + * + * @return {@code true} if there are more elements, {@code false} otherwise. + * @see #next + * @since Android 1.0 + */ + public boolean hasNext() throws RemoteException; + + /** + * Returns the next object in the iteration, i.e. returns the element in + * front of the iterator and advances the iterator by one position. + * + * @return the next object. + * @throws java.util.NoSuchElementException + * if there are no more elements. + * @see #hasNext + * @since Android 1.0 + */ + public Entity next() throws RemoteException; + + public void reset() throws RemoteException; + + /** + * Indicates that this iterator is no longer needed and that any associated resources + * may be released (such as a SQLite cursor). + */ + public void close(); +} diff --git a/core/java/android/content/IContentProvider.java b/core/java/android/content/IContentProvider.java index 0606956..7e5aba5 100644 --- a/core/java/android/content/IContentProvider.java +++ b/core/java/android/content/IContentProvider.java @@ -28,6 +28,7 @@ import android.os.IInterface; import android.os.ParcelFileDescriptor; import java.io.FileNotFoundException; +import java.util.ArrayList; /** * The ipc interface to talk to a content provider. @@ -43,19 +44,25 @@ public interface IContentProvider extends IInterface { CursorWindow window) throws RemoteException; public Cursor query(Uri url, String[] projection, String selection, String[] selectionArgs, String sortOrder) throws RemoteException; + public EntityIterator queryEntities(Uri url, String selection, + String[] selectionArgs, String sortOrder) + throws RemoteException; public String getType(Uri url) throws RemoteException; public Uri insert(Uri url, ContentValues initialValues) throws RemoteException; public int bulkInsert(Uri url, ContentValues[] initialValues) throws RemoteException; + public Uri insertEntity(Uri uri, Entity entities) throws RemoteException; public int delete(Uri url, String selection, String[] selectionArgs) throws RemoteException; public int update(Uri url, ContentValues values, String selection, String[] selectionArgs) throws RemoteException; + public int updateEntity(Uri uri, Entity entity) throws RemoteException; public ParcelFileDescriptor openFile(Uri url, String mode) throws RemoteException, FileNotFoundException; public AssetFileDescriptor openAssetFile(Uri url, String mode) throws RemoteException, FileNotFoundException; - public ISyncAdapter getSyncAdapter() throws RemoteException; + public ContentProviderResult[] applyBatch(ArrayList<ContentProviderOperation> operations) + throws RemoteException, OperationApplicationException; /* IPC constants */ static final String descriptor = "android.content.IContentProvider"; @@ -65,8 +72,11 @@ public interface IContentProvider extends IInterface { static final int INSERT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 2; static final int DELETE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 3; static final int UPDATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 9; - static final int GET_SYNC_ADAPTER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 10; static final int BULK_INSERT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 12; static final int OPEN_FILE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 13; static final int OPEN_ASSET_FILE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 14; + static final int INSERT_ENTITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 16; + static final int UPDATE_ENTITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 17; + static final int QUERY_ENTITIES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 18; + static final int APPLY_BATCH_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 19; } diff --git a/core/java/android/content/IContentService.aidl b/core/java/android/content/IContentService.aidl index 8617d949..b0f14c1 100644 --- a/core/java/android/content/IContentService.aidl +++ b/core/java/android/content/IContentService.aidl @@ -16,8 +16,10 @@ package android.content; +import android.accounts.Account; import android.content.ActiveSyncInfo; import android.content.ISyncStatusObserver; +import android.content.SyncAdapterType; import android.content.SyncStatusInfo; import android.net.Uri; import android.os.Bundle; @@ -34,15 +36,15 @@ interface IContentService { void notifyChange(in Uri uri, IContentObserver observer, boolean observerWantsSelfNotifications, boolean syncToNetwork); - void startSync(in Uri url, in Bundle extras); - void cancelSync(in Uri uri); + void requestSync(in Account account, String authority, in Bundle extras); + void cancelSync(in Account account, String authority); /** * Check if the provider should be synced when a network tickle is received * @param providerName the provider whose setting we are querying * @return true of the provider should be synced when a network tickle is received */ - boolean getSyncProviderAutomatically(String providerName); + boolean getSyncAutomatically(in Account account, String providerName); /** * Set whether or not the provider is synced when it receives a network tickle. @@ -50,32 +52,50 @@ interface IContentService { * @param providerName the provider whose behavior is being controlled * @param sync true if the provider should be synced when tickles are received for it */ - void setSyncProviderAutomatically(String providerName, boolean sync); + void setSyncAutomatically(in Account account, String providerName, boolean sync); - void setListenForNetworkTickles(boolean flag); + /** + * Check if this account/provider is syncable. + * @return >0 if it is syncable, 0 if not, and <0 if the state isn't known yet. + */ + int getIsSyncable(in Account account, String providerName); + + /** + * Set whether this account/provider is syncable. + * @param syncable, >0 denotes syncable, 0 means not syncable, <0 means unknown + */ + void setIsSyncable(in Account account, String providerName, int syncable); - boolean getListenForNetworkTickles(); + void setMasterSyncAutomatically(boolean flag); + + boolean getMasterSyncAutomatically(); /** * Returns true if there is currently a sync operation for the given * account or authority in the pending list, or actively being processed. */ - boolean isSyncActive(String account, String authority); + boolean isSyncActive(in Account account, String authority); ActiveSyncInfo getActiveSync(); /** + * Returns the types of the SyncAdapters that are registered with the system. + * @return Returns the types of the SyncAdapters that are registered with the system. + */ + SyncAdapterType[] getSyncAdapterTypes(); + + /** * Returns the status that matches the authority. If there are multiples accounts for * the authority, the one with the latest "lastSuccessTime" status is returned. * @param authority the authority whose row should be selected * @return the SyncStatusInfo for the authority, or null if none exists */ - SyncStatusInfo getStatusByAuthority(String authority); + SyncStatusInfo getSyncStatus(in Account account, String authority); /** * Return true if the pending status is true of any matching authorities. */ - boolean isAuthorityPending(String account, String authority); + boolean isSyncPending(in Account account, String authority); void addStatusChangeListener(int mask, ISyncStatusObserver callback); diff --git a/core/java/android/content/IEntityIterator.java b/core/java/android/content/IEntityIterator.java new file mode 100644 index 0000000..068581e --- /dev/null +++ b/core/java/android/content/IEntityIterator.java @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2009 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.content; + +import android.os.Binder; +import android.os.IBinder; +import android.os.IInterface; +import android.os.Parcel; +import android.os.RemoteException; +import android.os.Parcelable; +import android.util.Log; + +/** + * ICPC interface methods for an iterator over Entity objects. + * @hide + */ +public interface IEntityIterator extends IInterface { + /** Local-side IPC implementation stub class. */ + public static abstract class Stub extends Binder implements IEntityIterator { + private static final String TAG = "IEntityIterator"; + private static final java.lang.String DESCRIPTOR = "android.content.IEntityIterator"; + + /** Construct the stub at attach it to the interface. */ + public Stub() { + this.attachInterface(this, DESCRIPTOR); + } + /** + * Cast an IBinder object into an IEntityIterator interface, + * generating a proxy if needed. + */ + public static IEntityIterator asInterface(IBinder obj) { + if ((obj==null)) { + return null; + } + IInterface iin = obj.queryLocalInterface(DESCRIPTOR); + if (((iin!=null)&&(iin instanceof IEntityIterator))) { + return ((IEntityIterator)iin); + } + return new IEntityIterator.Stub.Proxy(obj); + } + + public IBinder asBinder() { + return this; + } + + public boolean onTransact(int code, Parcel data, Parcel reply, int flags) + throws RemoteException { + switch (code) { + case INTERFACE_TRANSACTION: + { + reply.writeString(DESCRIPTOR); + return true; + } + + case TRANSACTION_hasNext: + { + data.enforceInterface(DESCRIPTOR); + boolean _result; + try { + _result = this.hasNext(); + } catch (Exception e) { + Log.e(TAG, "caught exception in hasNext()", e); + reply.writeException(e); + return true; + } + reply.writeNoException(); + reply.writeInt(((_result)?(1):(0))); + return true; + } + + case TRANSACTION_next: + { + data.enforceInterface(DESCRIPTOR); + Entity entity; + try { + entity = this.next(); + } catch (RemoteException e) { + Log.e(TAG, "caught exception in next()", e); + reply.writeException(e); + return true; + } + reply.writeNoException(); + entity.writeToParcel(reply, Parcelable.PARCELABLE_WRITE_RETURN_VALUE); + return true; + } + + case TRANSACTION_reset: + { + data.enforceInterface(DESCRIPTOR); + try { + this.reset(); + } catch (RemoteException e) { + Log.e(TAG, "caught exception in next()", e); + reply.writeException(e); + return true; + } + reply.writeNoException(); + return true; + } + + case TRANSACTION_close: + { + data.enforceInterface(DESCRIPTOR); + try { + this.close(); + } catch (RemoteException e) { + Log.e(TAG, "caught exception in close()", e); + reply.writeException(e); + return true; + } + reply.writeNoException(); + return true; + } + } + return super.onTransact(code, data, reply, flags); + } + + private static class Proxy implements IEntityIterator { + private IBinder mRemote; + Proxy(IBinder remote) { + mRemote = remote; + } + public IBinder asBinder() { + return mRemote; + } + public java.lang.String getInterfaceDescriptor() { + return DESCRIPTOR; + } + public boolean hasNext() throws RemoteException { + Parcel _data = Parcel.obtain(); + Parcel _reply = Parcel.obtain(); + boolean _result; + try { + _data.writeInterfaceToken(DESCRIPTOR); + mRemote.transact(Stub.TRANSACTION_hasNext, _data, _reply, 0); + _reply.readException(); + _result = (0!=_reply.readInt()); + } + finally { + _reply.recycle(); + _data.recycle(); + } + return _result; + } + + public Entity next() throws RemoteException { + Parcel _data = Parcel.obtain(); + Parcel _reply = Parcel.obtain(); + try { + _data.writeInterfaceToken(DESCRIPTOR); + mRemote.transact(Stub.TRANSACTION_next, _data, _reply, 0); + _reply.readException(); + return Entity.CREATOR.createFromParcel(_reply); + } finally { + _reply.recycle(); + _data.recycle(); + } + } + + public void reset() throws RemoteException { + Parcel _data = Parcel.obtain(); + Parcel _reply = Parcel.obtain(); + try { + _data.writeInterfaceToken(DESCRIPTOR); + mRemote.transact(Stub.TRANSACTION_reset, _data, _reply, 0); + _reply.readException(); + } finally { + _reply.recycle(); + _data.recycle(); + } + } + + public void close() throws RemoteException { + Parcel _data = Parcel.obtain(); + Parcel _reply = Parcel.obtain(); + try { + _data.writeInterfaceToken(DESCRIPTOR); + mRemote.transact(Stub.TRANSACTION_close, _data, _reply, 0); + _reply.readException(); + } + finally { + _reply.recycle(); + _data.recycle(); + } + } + } + static final int TRANSACTION_hasNext = (IBinder.FIRST_CALL_TRANSACTION + 0); + static final int TRANSACTION_next = (IBinder.FIRST_CALL_TRANSACTION + 1); + static final int TRANSACTION_close = (IBinder.FIRST_CALL_TRANSACTION + 2); + static final int TRANSACTION_reset = (IBinder.FIRST_CALL_TRANSACTION + 3); + } + public boolean hasNext() throws RemoteException; + public Entity next() throws RemoteException; + public void reset() throws RemoteException; + public void close() throws RemoteException; +} diff --git a/core/java/android/content/ISyncAdapter.aidl b/core/java/android/content/ISyncAdapter.aidl index 671188c..4660527 100644 --- a/core/java/android/content/ISyncAdapter.aidl +++ b/core/java/android/content/ISyncAdapter.aidl @@ -16,6 +16,7 @@ package android.content; +import android.accounts.Account; import android.os.Bundle; import android.content.ISyncContext; @@ -30,14 +31,17 @@ oneway interface ISyncAdapter { * * @param syncContext the ISyncContext used to indicate the progress of the sync. When * the sync is finished (successfully or not) ISyncContext.onFinished() must be called. + * @param authority the authority that should be synced * @param account the account that should be synced * @param extras SyncAdapter-specific parameters */ - void startSync(ISyncContext syncContext, String account, in Bundle extras); + void startSync(ISyncContext syncContext, String authority, + in Account account, in Bundle extras); /** * Cancel the most recently initiated sync. Due to race conditions, this may arrive * after the ISyncContext.onFinished() for that sync was called. + * @param syncContext the ISyncContext that was passed to {@link #startSync} */ - void cancelSync(); + void cancelSync(ISyncContext syncContext); } diff --git a/core/java/android/content/Intent.java b/core/java/android/content/Intent.java index c62d66b..a3517f8 100644 --- a/core/java/android/content/Intent.java +++ b/core/java/android/content/Intent.java @@ -75,10 +75,10 @@ import java.util.Set; * <p>Some examples of action/data pairs are:</p> * * <ul> - * <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/1</i></b> -- Display + * <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/1</i></b> -- Display * information about the person whose identifier is "1".</p> * </li> - * <li> <p><b>{@link #ACTION_DIAL} <i>content://contacts/1</i></b> -- Display + * <li> <p><b>{@link #ACTION_DIAL} <i>content://contacts/people/1</i></b> -- Display * the phone dialer with the person filled in.</p> * </li> * <li> <p><b>{@link #ACTION_VIEW} <i>tel:123</i></b> -- Display @@ -89,10 +89,10 @@ import java.util.Set; * <li> <p><b>{@link #ACTION_DIAL} <i>tel:123</i></b> -- Display * the phone dialer with the given number filled in.</p> * </li> - * <li> <p><b>{@link #ACTION_EDIT} <i>content://contacts/1</i></b> -- Edit + * <li> <p><b>{@link #ACTION_EDIT} <i>content://contacts/people/1</i></b> -- Edit * information about the person whose identifier is "1".</p> * </li> - * <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/</i></b> -- Display + * <li> <p><b>{@link #ACTION_VIEW} <i>content://contacts/people/</i></b> -- Display * a list of people, which the user can browse through. This example is a * typical top-level entry into the Contacts application, showing you the * list of people. Selecting a particular person to view would result in a @@ -156,7 +156,7 @@ import java.util.Set; * defined in the Intent class, but applications can also define their own. * These strings use java style scoping, to ensure they are unique -- for * example, the standard {@link #ACTION_VIEW} is called - * "android.app.action.VIEW".</p> + * "android.intent.action.VIEW".</p> * * <p>Put together, the set of actions, data types, categories, and extra data * defines a language for the system allowing for the expression of phrases @@ -347,7 +347,7 @@ import java.util.Set; * <li> <p><b>{ action=android.app.action.MAIN, * category=android.app.category.LAUNCHER }</b> is the actual intent * used by the Launcher to populate its top-level list.</p> - * <li> <p><b>{ action=android.app.action.VIEW + * <li> <p><b>{ action=android.intent.action.VIEW * data=content://com.google.provider.NotePad/notes }</b> * displays a list of all the notes under * "content://com.google.provider.NotePad/notes", which @@ -399,7 +399,7 @@ import java.util.Set; * NoteEditor activity:</p> * * <ul> - * <li> <p><b>{ action=android.app.action.VIEW + * <li> <p><b>{ action=android.intent.action.VIEW * data=content://com.google.provider.NotePad/notes/<var>{ID}</var> }</b> * shows the user the content of note <var>{ID}</var>.</p> * <li> <p><b>{ action=android.app.action.EDIT @@ -1382,7 +1382,7 @@ public class Intent implements Parcelable { * by the system. */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) - public static final String ACTION_POWER_CONNECTED = "android.intent.action.ACTION_POWER_CONNECTED"; + public static final String ACTION_POWER_CONNECTED = "android.intent.action.POWER_CONNECTED"; /** * Broadcast Action: External power has been removed from the device. * This is intended for applications that wish to register specifically to this notification. @@ -1394,7 +1394,8 @@ public class Intent implements Parcelable { * by the system. */ @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) - public static final String ACTION_POWER_DISCONNECTED = "android.intent.action.ACTION_POWER_DISCONNECTED"; + public static final String ACTION_POWER_DISCONNECTED = + "android.intent.action.POWER_DISCONNECTED"; /** * Broadcast Action: Device is shutting down. * This is broadcast when the device is being shut down (completely turned @@ -1408,6 +1409,17 @@ public class Intent implements Parcelable { @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION) public static final String ACTION_SHUTDOWN = "android.intent.action.ACTION_SHUTDOWN"; /** + * Activity Action: Start this activity to request system shutdown. + * The optional boolean extra field {@link #EXTRA_KEY_CONFIRM} can be set to true + * to request confirmation from the user before shutting down. + * + * <p class="note">This is a protected intent that can only be sent + * by the system. + * + * {@hide} + */ + public static final String ACTION_REQUEST_SHUTDOWN = "android.intent.action.ACTION_REQUEST_SHUTDOWN"; + /** * Broadcast Action: Indicates low memory condition on the device * * <p class="note">This is a protected intent that can only be sent @@ -1685,6 +1697,20 @@ public class Intent implements Parcelable { "android.intent.action.REBOOT"; + /** + * Broadcast Action: a remote intent is to be broadcasted. + * + * A remote intent is used for remote RPC between devices. The remote intent + * is serialized and sent from one device to another device. The receiving + * device parses the remote intent and broadcasts it. Note that anyone can + * broadcast a remote intent. However, if the intent receiver of the remote intent + * does not trust intent broadcasts from arbitrary intent senders, it should require + * the sender to hold certain permissions so only trusted sender's broadcast will be + * let through. + */ + public static final String ACTION_REMOTE_INTENT = + "android.intent.action.REMOTE_INTENT"; + // --------------------------------------------------------------------- // --------------------------------------------------------------------- // Standard intent categories (see addCategory()). @@ -1812,6 +1838,14 @@ public class Intent implements Parcelable { */ public static final String CATEGORY_FRAMEWORK_INSTRUMENTATION_TEST = "android.intent.category.FRAMEWORK_INSTRUMENTATION_TEST"; + + /** + * Broadcast Action: The phone was docked or undocked. Includes the extra + * field {@link #EXTRA_DOCK_STATE}, containing the current dock state. + * @hide + */ + public static final String ACTION_DOCK_EVENT = "android.intent.action.DOCK_EVENT"; + // --------------------------------------------------------------------- // --------------------------------------------------------------------- // Standard extra data keys. @@ -1878,6 +1912,14 @@ public class Intent implements Parcelable { public static final String EXTRA_KEY_EVENT = "android.intent.extra.KEY_EVENT"; /** + * Set to true in {@link #ACTION_REQUEST_SHUTDOWN} to request confirmation from the user + * before shutting down. + * + * {@hide} + */ + public static final String EXTRA_KEY_CONFIRM = "android.intent.extra.KEY_CONFIRM"; + + /** * Used as an boolean extra field in {@link android.content.Intent#ACTION_PACKAGE_REMOVED} or * {@link android.content.Intent#ACTION_PACKAGE_CHANGED} intents to override the default action * of restarting the application. @@ -1926,6 +1968,37 @@ public class Intent implements Parcelable { public static final String EXTRA_ALARM_COUNT = "android.intent.extra.ALARM_COUNT"; /** + * Used as an int extra field in {@link android.content.Intent#ACTION_DOCK_EVENT} + * intents to request the dock state. Possible values are + * {@link android.content.Intent#ACTION_DOCK_STATE_UNDOCKED}, + * {@link android.content.Intent#ACTION_DOCK_STATE_DESK}, or + * {@link android.content.Intent#ACTION_DOCK_STATE_CAR}. + * @hide + */ + public static final String EXTRA_DOCK_STATE = "android.intent.extra.DOCK_STATE"; + + /** + * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE} + * to represent that the phone is not in any dock. + * @hide + */ + public static final int EXTRA_DOCK_STATE_UNDOCKED = 0; + + /** + * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE} + * to represent that the phone is in a desk dock. + * @hide + */ + public static final int EXTRA_DOCK_STATE_DESK = 1; + + /** + * Used as an int value for {@link android.content.Intent#EXTRA_DOCK_STATE} + * to represent that the phone is in a car dock. + * @hide + */ + public static final int EXTRA_DOCK_STATE_CAR = 2; + + /** * Used as a parcelable extra field in {@link #ACTION_APP_ERROR}, containing * the bug report. * @@ -1943,6 +2016,13 @@ public class Intent implements Parcelable { public static final String EXTRA_INSTALLER_PACKAGE_NAME = "android.intent.extra.INSTALLER_PACKAGE_NAME"; + /** + * Used in the extra field in the remote intent. It's astring token passed with the + * remote intent. + */ + public static final String EXTRA_REMOTE_INTENT_TOKEN = + "android.intent.extra.remote_intent_token"; + // --------------------------------------------------------------------- // --------------------------------------------------------------------- // Intent flags (see mFlags variable). diff --git a/core/java/com/android/internal/backup/SystemBackupAgent.java b/core/java/android/content/OperationApplicationException.java index 6b396d7..d4101bf 100644 --- a/core/java/com/android/internal/backup/SystemBackupAgent.java +++ b/core/java/android/content/OperationApplicationException.java @@ -14,22 +14,23 @@ * limitations under the License. */ -package com.android.internal.backup; - -import android.backup.AbsoluteFileBackupHelper; -import android.backup.BackupHelperAgent; +package android.content; /** - * Backup agent for various system-managed data + * Thrown when an application of a {@link ContentProviderOperation} fails due the specified + * constraints. */ -public class SystemBackupAgent extends BackupHelperAgent { - // the set of files that we back up whole, as absolute paths - String[] mFiles = { - /* WallpaperService.WALLPAPER_FILE */ - "/data/data/com.android.settings/files/wallpaper", - }; - - public void onCreate() { - addHelper("system_files", new AbsoluteFileBackupHelper(this, mFiles)); +public class OperationApplicationException extends Exception { + public OperationApplicationException() { + super(); + } + public OperationApplicationException(String message) { + super(message); + } + public OperationApplicationException(String message, Throwable cause) { + super(message, cause); + } + public OperationApplicationException(Throwable cause) { + super(cause); } } diff --git a/core/java/android/content/SyncAdapter.java b/core/java/android/content/SyncAdapter.java index 7826e50..88dc332 100644 --- a/core/java/android/content/SyncAdapter.java +++ b/core/java/android/content/SyncAdapter.java @@ -18,6 +18,7 @@ package android.content; import android.os.Bundle; import android.os.RemoteException; +import android.accounts.Account; /** * @hide @@ -29,12 +30,12 @@ public abstract class SyncAdapter { public static final int LOG_SYNC_DETAILS = 2743; class Transport extends ISyncAdapter.Stub { - public void startSync(ISyncContext syncContext, String account, + public void startSync(ISyncContext syncContext, String authority, Account account, Bundle extras) throws RemoteException { - SyncAdapter.this.startSync(new SyncContext(syncContext), account, extras); + SyncAdapter.this.startSync(new SyncContext(syncContext), account, authority, extras); } - public void cancelSync() throws RemoteException { + public void cancelSync(ISyncContext syncContext) throws RemoteException { SyncAdapter.this.cancelSync(); } } @@ -42,9 +43,9 @@ public abstract class SyncAdapter { Transport mTransport = new Transport(); /** - * Get the Transport object. (note this is package private). + * Get the Transport object. */ - final ISyncAdapter getISyncAdapter() + public final ISyncAdapter getISyncAdapter() { return mTransport; } @@ -57,9 +58,11 @@ public abstract class SyncAdapter { * @param syncContext the ISyncContext used to indicate the progress of the sync. When * the sync is finished (successfully or not) ISyncContext.onFinished() must be called. * @param account the account that should be synced + * @param authority the authority if the sync request * @param extras SyncAdapter-specific parameters */ - public abstract void startSync(SyncContext syncContext, String account, Bundle extras); + public abstract void startSync(SyncContext syncContext, Account account, String authority, + Bundle extras); /** * Cancel the most recently initiated sync. Due to race conditions, this may arrive diff --git a/core/java/android/content/SyncAdapterType.aidl b/core/java/android/content/SyncAdapterType.aidl new file mode 100644 index 0000000..e67841f --- /dev/null +++ b/core/java/android/content/SyncAdapterType.aidl @@ -0,0 +1,20 @@ +/* + * Copyright (C) 2009 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.content; + +parcelable SyncAdapterType; + diff --git a/core/java/android/content/SyncAdapterType.java b/core/java/android/content/SyncAdapterType.java new file mode 100644 index 0000000..25cbdb1 --- /dev/null +++ b/core/java/android/content/SyncAdapterType.java @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2009 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.content; + +import android.text.TextUtils; +import android.os.Parcelable; +import android.os.Parcel; + +/** + * Value type that represents a SyncAdapterType. This object overrides {@link #equals} and + * {@link #hashCode}, making it suitable for use as the key of a {@link java.util.Map} + */ +public class SyncAdapterType implements Parcelable { + public final String authority; + public final String accountType; + public final boolean isKey; + private final boolean userVisible; + private final boolean supportsUploading; + + public SyncAdapterType(String authority, String accountType, boolean userVisible, + boolean supportsUploading) { + if (TextUtils.isEmpty(authority)) { + throw new IllegalArgumentException("the authority must not be empty: " + authority); + } + if (TextUtils.isEmpty(accountType)) { + throw new IllegalArgumentException("the accountType must not be empty: " + accountType); + } + this.authority = authority; + this.accountType = accountType; + this.userVisible = userVisible; + this.supportsUploading = supportsUploading; + this.isKey = false; + } + + private SyncAdapterType(String authority, String accountType) { + if (TextUtils.isEmpty(authority)) { + throw new IllegalArgumentException("the authority must not be empty: " + authority); + } + if (TextUtils.isEmpty(accountType)) { + throw new IllegalArgumentException("the accountType must not be empty: " + accountType); + } + this.authority = authority; + this.accountType = accountType; + this.userVisible = true; + this.supportsUploading = true; + this.isKey = true; + } + + public boolean supportsUploading() { + if (isKey) { + throw new IllegalStateException( + "this method is not allowed to be called when this is a key"); + } + return supportsUploading; + } + + public boolean isUserVisible() { + if (isKey) { + throw new IllegalStateException( + "this method is not allowed to be called when this is a key"); + } + return userVisible; + } + + public static SyncAdapterType newKey(String authority, String accountType) { + return new SyncAdapterType(authority, accountType); + } + + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof SyncAdapterType)) return false; + final SyncAdapterType other = (SyncAdapterType)o; + // don't include userVisible or supportsUploading in the equality check + return authority.equals(other.authority) && accountType.equals(other.accountType); + } + + public int hashCode() { + int result = 17; + result = 31 * result + authority.hashCode(); + result = 31 * result + accountType.hashCode(); + // don't include userVisible or supportsUploading the hash + return result; + } + + public String toString() { + if (isKey) { + return "SyncAdapterType Key {name=" + authority + + ", type=" + accountType + + "}"; + } else { + return "SyncAdapterType {name=" + authority + + ", type=" + accountType + + ", userVisible=" + userVisible + + ", supportsUploading=" + supportsUploading + + "}"; + } + } + + public int describeContents() { + return 0; + } + + public void writeToParcel(Parcel dest, int flags) { + if (isKey) { + throw new IllegalStateException("keys aren't parcelable"); + } + + dest.writeString(authority); + dest.writeString(accountType); + dest.writeInt(userVisible ? 1 : 0); + dest.writeInt(supportsUploading ? 1 : 0); + } + + public SyncAdapterType(Parcel source) { + this( + source.readString(), + source.readString(), + source.readInt() != 0, + source.readInt() != 0); + } + + public static final Creator<SyncAdapterType> CREATOR = new Creator<SyncAdapterType>() { + public SyncAdapterType createFromParcel(Parcel source) { + return new SyncAdapterType(source); + } + + public SyncAdapterType[] newArray(int size) { + return new SyncAdapterType[size]; + } + }; +}
\ No newline at end of file diff --git a/core/java/android/content/SyncAdaptersCache.java b/core/java/android/content/SyncAdaptersCache.java new file mode 100644 index 0000000..7d9f1de --- /dev/null +++ b/core/java/android/content/SyncAdaptersCache.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 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.content; + +import android.content.pm.RegisteredServicesCache; +import android.content.res.TypedArray; +import android.content.Context; +import android.util.AttributeSet; + +/** + * A cache of services that export the {@link android.content.ISyncAdapter} interface. + * @hide + */ +/* package private */ class SyncAdaptersCache extends RegisteredServicesCache<SyncAdapterType> { + private static final String TAG = "Account"; + + private static final String SERVICE_INTERFACE = "android.content.SyncAdapter"; + private static final String SERVICE_META_DATA = "android.content.SyncAdapter"; + private static final String ATTRIBUTES_NAME = "sync-adapter"; + + SyncAdaptersCache(Context context) { + super(context, SERVICE_INTERFACE, SERVICE_META_DATA, ATTRIBUTES_NAME); + } + + public SyncAdapterType parseServiceAttributes(String packageName, AttributeSet attrs) { + TypedArray sa = mContext.getResources().obtainAttributes(attrs, + com.android.internal.R.styleable.SyncAdapter); + try { + final String authority = + sa.getString(com.android.internal.R.styleable.SyncAdapter_contentAuthority); + final String accountType = + sa.getString(com.android.internal.R.styleable.SyncAdapter_accountType); + if (authority == null || accountType == null) { + return null; + } + final boolean userVisible = + sa.getBoolean(com.android.internal.R.styleable.SyncAdapter_userVisible, true); + final boolean supportsUploading = + sa.getBoolean(com.android.internal.R.styleable.SyncAdapter_supportsUploading, + true); + return new SyncAdapterType(authority, accountType, userVisible, supportsUploading); + } finally { + sa.recycle(); + } + } +}
\ No newline at end of file diff --git a/core/java/android/content/SyncManager.java b/core/java/android/content/SyncManager.java index 4d2cce8..82cf23f 100644 --- a/core/java/android/content/SyncManager.java +++ b/core/java/android/content/SyncManager.java @@ -21,8 +21,9 @@ import com.google.android.collect.Maps; import com.android.internal.R; import com.android.internal.util.ArrayUtils; -import android.accounts.AccountMonitor; -import android.accounts.AccountMonitorListener; +import android.accounts.Account; +import android.accounts.AccountManager; +import android.accounts.OnAccountsUpdatedListener; import android.app.AlarmManager; import android.app.Notification; import android.app.NotificationManager; @@ -30,11 +31,10 @@ import android.app.PendingIntent; import android.content.pm.ApplicationInfo; import android.content.pm.IPackageManager; import android.content.pm.PackageManager; -import android.content.pm.ProviderInfo; import android.content.pm.ResolveInfo; +import android.content.pm.RegisteredServicesCache; import android.net.ConnectivityManager; import android.net.NetworkInfo; -import android.net.Uri; import android.os.Bundle; import android.os.Handler; import android.os.HandlerThread; @@ -48,7 +48,6 @@ import android.os.ServiceManager; import android.os.SystemClock; import android.os.SystemProperties; import android.provider.Settings; -import android.text.TextUtils; import android.text.format.DateUtils; import android.text.format.Time; import android.util.Config; @@ -72,11 +71,12 @@ import java.util.List; import java.util.Map; import java.util.PriorityQueue; import java.util.Random; +import java.util.Collection; /** * @hide */ -class SyncManager { +class SyncManager implements OnAccountsUpdatedListener { private static final String TAG = "SyncManager"; // used during dumping of the Sync history @@ -117,14 +117,11 @@ class SyncManager { private static final String HANDLE_SYNC_ALARM_WAKE_LOCK = "SyncManagerHandleSyncAlarmWakeLock"; private Context mContext; - private ContentResolver mContentResolver; private String mStatusText = ""; private long mHeartbeatTime = 0; - private AccountMonitor mAccountMonitor; - - private volatile String[] mAccounts = null; + private volatile Account[] mAccounts = null; volatile private PowerManager.WakeLock mSyncWakeLock; volatile private PowerManager.WakeLock mHandleAlarmWakeLock; @@ -151,17 +148,18 @@ class SyncManager { private final PendingIntent mSyncAlarmIntent; private final PendingIntent mSyncPollAlarmIntent; + private final SyncAdaptersCache mSyncAdapters; + private BroadcastReceiver mStorageIntentReceiver = new BroadcastReceiver() { public void onReceive(Context context, Intent intent) { - ensureContentResolver(); String action = intent.getAction(); if (Intent.ACTION_DEVICE_STORAGE_LOW.equals(action)) { if (Log.isLoggable(TAG, Log.VERBOSE)) { Log.v(TAG, "Internal storage is low."); } mStorageIsLow = true; - cancelActiveSync(null /* no url */); + cancelActiveSync(null /* any account */, null /* any authority */); } else if (Intent.ACTION_DEVICE_STORAGE_OK.equals(action)) { if (Log.isLoggable(TAG, Log.VERBOSE)) { Log.v(TAG, "Internal storage is ok."); @@ -172,6 +170,56 @@ class SyncManager { } }; + private BroadcastReceiver mBootCompletedReceiver = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + if (!mFactoryTest) { + AccountManager.get(mContext).addOnAccountsUpdatedListener(SyncManager.this, + mSyncHandler, true /* updateImmediately */); + } + } + }; + + public void onAccountsUpdated(Account[] accounts) { + // remember if this was the first time this was called after an update + final boolean justBootedUp = mAccounts == null; + mAccounts = accounts; + + // if a sync is in progress yet it is no longer in the accounts list, + // cancel it + ActiveSyncContext activeSyncContext = mActiveSyncContext; + if (activeSyncContext != null) { + if (!ArrayUtils.contains(accounts, activeSyncContext.mSyncOperation.account)) { + Log.d(TAG, "canceling sync since the account has been removed"); + sendSyncFinishedOrCanceledMessage(activeSyncContext, + null /* no result since this is a cancel */); + } + } + + // we must do this since we don't bother scheduling alarms when + // the accounts are not set yet + sendCheckAlarmsMessage(); + + mSyncStorageEngine.doDatabaseCleanup(accounts); + + if (accounts.length > 0) { + // If this is the first time this was called after a bootup then + // the accounts haven't really changed, instead they were just loaded + // from the AccountManager. Otherwise at least one of the accounts + // has a change. + // + // If there was a real account change then force a sync of all accounts. + // This is a bit of overkill, but at least it will end up retrying syncs + // that failed due to an authentication failure and thus will recover if the + // account change was a password update. + // + // If this was the bootup case then don't sync everything, instead only + // sync those that have an unknown syncable state, which will give them + // a chance to set their syncable state. + boolean onlyThoseWithUnkownSyncableState = !justBootedUp; + scheduleSync(null, null, null, 0 /* no delay */, onlyThoseWithUnkownSyncableState); + } + } + private BroadcastReceiver mConnectivityIntentReceiver = new BroadcastReceiver() { public void onReceive(Context context, Intent intent) { @@ -229,7 +277,11 @@ class SyncManager { private static final String SYNCMANAGER_PREFS_FILENAME = "/data/system/syncmanager.prefs"; + private final boolean mFactoryTest; + public SyncManager(Context context, boolean factoryTest) { + mFactoryTest = factoryTest; + // Initialize the SyncStorageEngine first, before registering observers // and creating threads and so on; it may fail if the disk is full. SyncStorageEngine.init(context); @@ -244,6 +296,8 @@ class SyncManager { mPackageManager = null; + mSyncAdapters = new SyncAdaptersCache(mContext); + mSyncAlarmIntent = PendingIntent.getBroadcast( mContext, 0 /* ignored */, new Intent(ACTION_SYNC_ALARM), 0); @@ -253,6 +307,9 @@ class SyncManager { IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION); context.registerReceiver(mConnectivityIntentReceiver, intentFilter); + intentFilter = new IntentFilter(Intent.ACTION_BOOT_COMPLETED); + context.registerReceiver(mBootCompletedReceiver, intentFilter); + intentFilter = new IntentFilter(Intent.ACTION_DEVICE_STORAGE_LOW); intentFilter.addAction(Intent.ACTION_DEVICE_STORAGE_OK); context.registerReceiver(mStorageIntentReceiver, intentFilter); @@ -282,48 +339,12 @@ class SyncManager { mHandleAlarmWakeLock.setReferenceCounted(false); mSyncStorageEngine.addStatusChangeListener( - SyncStorageEngine.CHANGE_SETTINGS, new ISyncStatusObserver.Stub() { + ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, new ISyncStatusObserver.Stub() { public void onStatusChanged(int which) { // force the sync loop to run if the settings change sendCheckAlarmsMessage(); } }); - - if (!factoryTest) { - AccountMonitorListener listener = new AccountMonitorListener() { - public void onAccountsUpdated(String[] accounts) { - final boolean hadAccountsAlready = mAccounts != null; - // copy the accounts into a new array and change mAccounts to point to it - String[] newAccounts = new String[accounts.length]; - System.arraycopy(accounts, 0, newAccounts, 0, accounts.length); - mAccounts = newAccounts; - - // if a sync is in progress yet it is no longer in the accounts list, cancel it - ActiveSyncContext activeSyncContext = mActiveSyncContext; - if (activeSyncContext != null) { - if (!ArrayUtils.contains(newAccounts, - activeSyncContext.mSyncOperation.account)) { - Log.d(TAG, "canceling sync since the account has been removed"); - sendSyncFinishedOrCanceledMessage(activeSyncContext, - null /* no result since this is a cancel */); - } - } - - // we must do this since we don't bother scheduling alarms when - // the accounts are not set yet - sendCheckAlarmsMessage(); - - mSyncStorageEngine.doDatabaseCleanup(accounts); - - if (hadAccountsAlready && mAccounts.length > 0) { - // request a sync so that if the password was changed we will retry any sync - // that failed when it was wrong - startSync(null /* all providers */, null /* no extras */); - } - } - }; - mAccountMonitor = new AccountMonitor(context, listener); - } } private synchronized void initializeSyncPoll() { @@ -397,7 +418,8 @@ class SyncManager { scheduleSyncPollAlarm(nextRelativePollTimeMs); // perform a poll - scheduleSync(null /* sync all syncable providers */, new Bundle(), 0 /* no delay */); + scheduleSync(null /* sync all syncable accounts */, null /* sync all syncable providers */, + new Bundle(), 0 /* no delay */, false /* onlyThoseWithUnkownSyncableState */); } private void writeSyncPollTime(long when) { @@ -452,19 +474,13 @@ class SyncManager { return mSyncStorageEngine; } - private void ensureContentResolver() { - if (mContentResolver == null) { - mContentResolver = mContext.getContentResolver(); - } - } - private void ensureAlarmService() { if (mAlarmService == null) { mAlarmService = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE); } } - public String getSyncingAccount() { + public Account getSyncingAccount() { ActiveSyncContext activeSyncContext = mActiveSyncContext; return (activeSyncContext != null) ? activeSyncContext.mSyncOperation.account : null; } @@ -499,22 +515,17 @@ class SyncManager { * * <p>You'll start getting callbacks after this. * - * @param url The Uri of a specific provider to be synced, or - * null to sync all providers. + * @param requestedAccount the account to sync, may be null to signify all accounts + * @param requestedAuthority the authority to sync, may be null to indicate all authorities * @param extras a Map of SyncAdapter-specific information to control * syncs of a specific provider. Can be null. Is ignored * if the url is null. * @param delay how many milliseconds in the future to wait before performing this - * sync. -1 means to make this the next sync to perform. + * @param onlyThoseWithUnkownSyncableState */ - public void scheduleSync(Uri url, Bundle extras, long delay) { + public void scheduleSync(Account requestedAccount, String requestedAuthority, + Bundle extras, long delay, boolean onlyThoseWithUnkownSyncableState) { boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE); - if (isLoggable) { - Log.v(TAG, "scheduleSync:" - + " delay " + delay - + ", url " + ((url == null) ? "(null)" : url) - + ", extras " + ((extras == null) ? "(null)" : extras)); - } if (!isSyncEnabled()) { if (isLoggable) { @@ -535,10 +546,9 @@ class SyncManager { delay = -1; // this means schedule at the front of the queue } - String[] accounts; - String accountFromExtras = extras.getString(ContentResolver.SYNC_EXTRAS_ACCOUNT); - if (!TextUtils.isEmpty(accountFromExtras)) { - accounts = new String[]{accountFromExtras}; + Account[] accounts; + if (requestedAccount != null) { + accounts = new Account[]{requestedAccount}; } else { // if the accounts aren't configured yet then we can't support an account-less // sync request @@ -560,14 +570,14 @@ class SyncManager { } final boolean uploadOnly = extras.getBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, false); - final boolean force = extras.getBoolean(ContentResolver.SYNC_EXTRAS_FORCE, false); + final boolean manualSync = extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false); int source; if (uploadOnly) { source = SyncStorageEngine.SOURCE_LOCAL; - } else if (force) { + } else if (manualSync) { source = SyncStorageEngine.SOURCE_USER; - } else if (url == null) { + } else if (requestedAuthority == null) { source = SyncStorageEngine.SOURCE_POLL; } else { // this isn't strictly server, since arbitrary callers can (and do) request @@ -575,20 +585,54 @@ class SyncManager { source = SyncStorageEngine.SOURCE_SERVER; } - List<String> names = new ArrayList<String>(); - List<ProviderInfo> providers = new ArrayList<ProviderInfo>(); - populateProvidersList(url, names, providers); + // Compile a list of authorities that have sync adapters. + // For each authority sync each account that matches a sync adapter. + final HashSet<String> syncableAuthorities = new HashSet<String>(); + for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapter : + mSyncAdapters.getAllServices()) { + syncableAuthorities.add(syncAdapter.type.authority); + } - final int numProviders = providers.size(); - for (int i = 0; i < numProviders; i++) { - if (!providers.get(i).isSyncable) continue; - final String name = names.get(i); - for (String account : accounts) { - scheduleSyncOperation(new SyncOperation(account, source, name, extras, delay)); - // TODO: remove this when Calendar supports multiple accounts. Until then - // pretend that only the first account exists when syncing calendar. - if ("calendar".equals(name)) { - break; + // if the url was specified then replace the list of authorities with just this authority + // or clear it if this authority isn't syncable + if (requestedAuthority != null) { + final boolean hasSyncAdapter = syncableAuthorities.contains(requestedAuthority); + syncableAuthorities.clear(); + if (hasSyncAdapter) syncableAuthorities.add(requestedAuthority); + } + + for (String authority : syncableAuthorities) { + for (Account account : accounts) { + int isSyncable = mSyncStorageEngine.getIsSyncable(account, authority); + if (isSyncable == 0) { + continue; + } + if (onlyThoseWithUnkownSyncableState && isSyncable >= 0) { + continue; + } + final RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo = + mSyncAdapters.getServiceInfo( + SyncAdapterType.newKey(authority, account.type)); + if (syncAdapterInfo != null) { + if (!syncAdapterInfo.type.supportsUploading() && uploadOnly) { + continue; + } + // make this an initialization sync if the isSyncable state is unknown + Bundle extrasCopy = extras; + if (isSyncable < 0) { + extrasCopy = new Bundle(extras); + extrasCopy.putBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, true); + } + if (isLoggable) { + Log.v(TAG, "scheduleSync:" + + " delay " + delay + + ", source " + source + + ", account " + account + + ", authority " + authority + + ", extras " + extrasCopy); + } + scheduleSyncOperation( + new SyncOperation(account, source, authority, extrasCopy, delay)); } } } @@ -598,36 +642,11 @@ class SyncManager { mStatusText = message; } - private void populateProvidersList(Uri url, List<String> names, List<ProviderInfo> providers) { - try { - final IPackageManager packageManager = getPackageManager(); - if (url == null) { - packageManager.querySyncProviders(names, providers); - } else { - final String authority = url.getAuthority(); - ProviderInfo info = packageManager.resolveContentProvider(url.getAuthority(), 0); - if (info != null) { - // only set this provider if the requested authority is the primary authority - String[] providerNames = info.authority.split(";"); - if (url.getAuthority().equals(providerNames[0])) { - names.add(authority); - providers.add(info); - } - } - } - } catch (RemoteException ex) { - // we should really never get this, but if we do then clear the lists, which - // will result in the dropping of the sync request - Log.e(TAG, "error trying to get the ProviderInfo for " + url, ex); - names.clear(); - providers.clear(); - } - } - - public void scheduleLocalSync(Uri url) { + public void scheduleLocalSync(Account account, String authority) { final Bundle extras = new Bundle(); extras.putBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, true); - scheduleSync(url, extras, LOCAL_SYNC_DELAY); + scheduleSync(account, authority, extras, LOCAL_SYNC_DELAY, + false /* onlyThoseWithUnkownSyncableState */); } private IPackageManager getPackageManager() { @@ -641,18 +660,16 @@ class SyncManager { return mPackageManager; } - /** - * Initiate a sync for this given URL, or pass null for a full sync. - * - * <p>You'll start getting callbacks after this. - * - * @param url The Uri of a specific provider to be synced, or - * null to sync all providers. - * @param extras a Map of SyncAdapter specific information to control - * syncs of a specific provider. Can be null. Is ignored - */ - public void startSync(Uri url, Bundle extras) { - scheduleSync(url, extras, 0 /* no delay */); + public SyncAdapterType[] getSyncAdapterTypes() { + final Collection<RegisteredServicesCache.ServiceInfo<SyncAdapterType>> serviceInfos = + mSyncAdapters.getAllServices(); + SyncAdapterType[] types = new SyncAdapterType[serviceInfos.size()]; + int i = 0; + for (RegisteredServicesCache.ServiceInfo<SyncAdapterType> serviceInfo : serviceInfos) { + types[i] = serviceInfo.type; + ++i; + } + return types; } public void updateHeartbeatTime() { @@ -721,8 +738,7 @@ class SyncManager { } // Cap the delay - ensureContentResolver(); - long maxSyncRetryTimeInSeconds = Settings.Gservices.getLong(mContentResolver, + long maxSyncRetryTimeInSeconds = Settings.Gservices.getLong(mContext.getContentResolver(), Settings.Gservices.SYNC_MAX_RETRY_DELAY_IN_SECONDS, DEFAULT_MAX_SYNC_RETRY_TIME_IN_SECONDS); if (newDelayInMs > maxSyncRetryTimeInSeconds * 1000) { @@ -736,17 +752,22 @@ class SyncManager { } /** - * Cancel the active sync if it matches the uri. The uri corresponds to the one passed - * in to startSync(). - * @param uri If non-null, the active sync is only canceled if it matches the uri. - * If null, any active sync is canceled. + * Cancel the active sync if it matches the authority and account. + * @param account limit the cancelations to syncs with this account, if non-null + * @param authority limit the cancelations to syncs with this authority, if non-null */ - public void cancelActiveSync(Uri uri) { + public void cancelActiveSync(Account account, String authority) { ActiveSyncContext activeSyncContext = mActiveSyncContext; if (activeSyncContext != null) { - // if a Uri was specified then only cancel the sync if it matches the the uri - if (uri != null) { - if (!uri.getAuthority().equals(activeSyncContext.mSyncOperation.authority)) { + // if an authority was specified then only cancel the sync if it matches + if (account != null) { + if (!account.equals(activeSyncContext.mSyncOperation.account)) { + return; + } + } + // if an account was specified then only cancel the sync if it matches + if (authority != null) { + if (!authority.equals(activeSyncContext.mSyncOperation.authority)) { return; } } @@ -798,14 +819,13 @@ class SyncManager { } /** - * Remove any scheduled sync operations that match uri. The uri corresponds to the one passed - * in to startSync(). - * @param uri If non-null, only operations that match the uri are cleared. - * If null, all operations are cleared. + * Remove scheduled sync operations. + * @param account limit the removals to operations with this account, if non-null + * @param authority limit the removals to operations with this authority, if non-null */ - public void clearScheduledSyncOperations(Uri uri) { + public void clearScheduledSyncOperations(Account account, String authority) { synchronized (mSyncQueue) { - mSyncQueue.clear(null, uri != null ? uri.getAuthority() : null); + mSyncQueue.clear(account, authority); } } @@ -857,7 +877,7 @@ class SyncManager { * Value type that represents a sync operation. */ static class SyncOperation implements Comparable { - final String account; + final Account account; int syncSource; String authority; Bundle extras; @@ -866,7 +886,7 @@ class SyncManager { long delay; SyncStorageEngine.PendingOperation pendingOperation; - SyncOperation(String account, int source, String authority, Bundle extras, long delay) { + SyncOperation(Account account, int source, String authority, Bundle extras, long delay) { this.account = account; this.syncSource = source; this.authority = authority; @@ -937,21 +957,19 @@ class SyncManager { /** * @hide */ - class ActiveSyncContext extends ISyncContext.Stub { + class ActiveSyncContext extends ISyncContext.Stub implements ServiceConnection { final SyncOperation mSyncOperation; final long mHistoryRowId; - final IContentProvider mContentProvider; - final ISyncAdapter mSyncAdapter; + ISyncAdapter mSyncAdapter; final long mStartTime; long mTimeoutStartTime; - public ActiveSyncContext(SyncOperation syncOperation, IContentProvider contentProvider, - ISyncAdapter syncAdapter, long historyRowId) { + public ActiveSyncContext(SyncOperation syncOperation, + long historyRowId) { super(); mSyncOperation = syncOperation; mHistoryRowId = historyRowId; - mContentProvider = contentProvider; - mSyncAdapter = syncAdapter; + mSyncAdapter = null; mStartTime = SystemClock.elapsedRealtime(); mTimeoutStartTime = mStartTime; } @@ -977,6 +995,37 @@ class SyncManager { .append(", syncOperation ").append(mSyncOperation); } + public void onServiceConnected(ComponentName name, IBinder service) { + Message msg = mSyncHandler.obtainMessage(); + msg.what = SyncHandler.MESSAGE_SERVICE_CONNECTED; + msg.obj = new ServiceConnectionData(this, ISyncAdapter.Stub.asInterface(service)); + mSyncHandler.sendMessage(msg); + } + + public void onServiceDisconnected(ComponentName name) { + Message msg = mSyncHandler.obtainMessage(); + msg.what = SyncHandler.MESSAGE_SERVICE_DISCONNECTED; + msg.obj = new ServiceConnectionData(this, null); + mSyncHandler.sendMessage(msg); + } + + boolean bindToSyncAdapter(RegisteredServicesCache.ServiceInfo info) { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.d(TAG, "bindToSyncAdapter: " + info.componentName + ", connection " + this); + } + Intent intent = new Intent(); + intent.setAction("android.content.SyncAdapter"); + intent.setComponent(info.componentName); + return mContext.bindService(intent, this, Context.BIND_AUTO_CREATE); + } + + void unBindFromSyncAdapter() { + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.d(TAG, "unBindFromSyncAdapter: connection " + this); + } + mContext.unbindService(this); + } + @Override public String toString() { StringBuilder sb = new StringBuilder(); @@ -991,6 +1040,12 @@ class SyncManager { if (isSyncEnabled()) { dumpSyncHistory(pw, sb); } + + pw.println(); + pw.println("SyncAdapters:"); + for (RegisteredServicesCache.ServiceInfo info : mSyncAdapters.getAllServices()) { + pw.println(" " + info); + } } static String formatTime(long time) { @@ -1004,7 +1059,7 @@ class SyncManager { pw.print("data connected: "); pw.println(mDataConnectionIsConnected); pw.print("memory low: "); pw.println(mStorageIsLow); - final String[] accounts = mAccounts; + final Account[] accounts = mAccounts; pw.print("accounts: "); if (accounts != null) { pw.println(accounts.length); @@ -1068,7 +1123,8 @@ class SyncManager { for (int i=0; i<N; i++) { SyncStorageEngine.PendingOperation op = ops.get(i); pw.print(" #"); pw.print(i); pw.print(": account="); - pw.print(op.account); pw.print(" authority="); + pw.print(op.account.name); pw.print(":"); + pw.print(op.account.type); pw.print(" authority="); pw.println(op.authority); if (op.extras != null && op.extras.size() > 0) { sb.setLength(0); @@ -1078,7 +1134,7 @@ class SyncManager { } } - HashSet<String> processedAccounts = new HashSet<String>(); + HashSet<Account> processedAccounts = new HashSet<Account>(); ArrayList<SyncStatusInfo> statuses = mSyncStorageEngine.getSyncStatus(); if (statuses != null && statuses.size() > 0) { @@ -1090,7 +1146,7 @@ class SyncManager { SyncStorageEngine.AuthorityInfo authority = mSyncStorageEngine.getAuthority(status.authorityId); if (authority != null) { - String curAccount = authority.account; + Account curAccount = authority.account; if (processedAccounts.contains(curAccount)) { continue; @@ -1098,8 +1154,9 @@ class SyncManager { processedAccounts.add(curAccount); - pw.print(" Account "); pw.print(authority.account); - pw.println(":"); + pw.print(" Account "); pw.print(authority.account.name); + pw.print(" "); pw.print(authority.account.type); + pw.println(":"); for (int j=i; j<N; j++) { status = statuses.get(j); authority = mSyncStorageEngine.getAuthority(status.authorityId); @@ -1219,9 +1276,15 @@ class SyncManager { SyncStorageEngine.AuthorityInfo authority = mSyncStorageEngine.getAuthority(item.authorityId); pw.print(" #"); pw.print(i+1); pw.print(": "); - pw.print(authority != null ? authority.account : "<no account>"); - pw.print(" "); - pw.print(authority != null ? authority.authority : "<no account>"); + if (authority != null) { + pw.print(authority.account.name); + pw.print(":"); + pw.print(authority.account.type); + pw.print(" "); + pw.print(authority.authority); + } else { + pw.print("<no account>"); + } Time time = new Time(); time.set(item.eventTime); pw.print(" "); pw.print(SyncStorageEngine.SOURCES[item.source]); @@ -1278,6 +1341,15 @@ class SyncManager { } } + class ServiceConnectionData { + public final ActiveSyncContext activeSyncContext; + public final ISyncAdapter syncAdapter; + ServiceConnectionData(ActiveSyncContext activeSyncContext, ISyncAdapter syncAdapter) { + this.activeSyncContext = activeSyncContext; + this.syncAdapter = syncAdapter; + } + } + /** * Handles SyncOperation Messages that are posted to the associated * HandlerThread. @@ -1287,6 +1359,8 @@ class SyncManager { private static final int MESSAGE_SYNC_FINISHED = 1; private static final int MESSAGE_SYNC_ALARM = 2; private static final int MESSAGE_CHECK_ALARMS = 3; + private static final int MESSAGE_SERVICE_CONNECTED = 4; + private static final int MESSAGE_SERVICE_DISCONNECTED = 5; public final SyncNotificationInfo mSyncNotificationInfo = new SyncNotificationInfo(); private Long mAlarmScheduleTime = null; @@ -1301,7 +1375,7 @@ class SyncManager { */ class SyncNotificationInfo { // only valid if isActive is true - public String account; + public Account account; // only valid if isActive is true public String authority; @@ -1358,6 +1432,53 @@ class SyncManager { runStateIdle(); break; + case SyncHandler.MESSAGE_SERVICE_CONNECTED: { + ServiceConnectionData msgData = (ServiceConnectionData)msg.obj; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_SERVICE_CONNECTED: " + + msgData.activeSyncContext + + " active is " + mActiveSyncContext); + } + // check that this isn't an old message + if (mActiveSyncContext == msgData.activeSyncContext) { + runBoundToSyncAdapter(msgData.syncAdapter); + } + break; + } + + case SyncHandler.MESSAGE_SERVICE_DISCONNECTED: { + ServiceConnectionData msgData = (ServiceConnectionData)msg.obj; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.d(TAG, "handleSyncHandlerMessage: MESSAGE_SERVICE_DISCONNECTED: " + + msgData.activeSyncContext + + " active is " + mActiveSyncContext); + } + // check that this isn't an old message + if (mActiveSyncContext == msgData.activeSyncContext) { + // cancel the sync if we have a syncadapter, which means one is + // outstanding + if (mActiveSyncContext.mSyncAdapter != null) { + try { + mActiveSyncContext.mSyncAdapter.cancelSync(mActiveSyncContext); + } catch (RemoteException e) { + // we don't need to retry this in this case + } + } + + // pretend that the sync failed with an IOException, + // which is a soft error + SyncResult syncResult = new SyncResult(); + syncResult.stats.numIoExceptions++; + runSyncFinishedOrCanceled(syncResult); + + // since we are no longer syncing, check if it is time to start a new + // sync + runStateIdle(); + } + + break; + } + case SyncHandler.MESSAGE_SYNC_ALARM: { boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE); if (isLoggable) { @@ -1456,7 +1577,7 @@ class SyncManager { // If the accounts aren't known yet then we aren't ready to run. We will be kicked // when the account lookup request does complete. - String[] accounts = mAccounts; + Account[] accounts = mAccounts; if (accounts == null) { if (isLoggable) { Log.v(TAG, "runStateIdle: accounts not known, skipping"); @@ -1468,14 +1589,14 @@ class SyncManager { // Otherwise consume SyncOperations from the head of the SyncQueue until one is // found that is runnable (not disabled, etc). If that one is ready to run then // start it, otherwise just get out. - SyncOperation syncOperation; + SyncOperation op; final ConnectivityManager connManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE); - final boolean backgroundDataSetting = connManager.getBackgroundDataSetting(); + final boolean backgroundDataUsageAllowed = connManager.getBackgroundDataSetting(); synchronized (mSyncQueue) { while (true) { - syncOperation = mSyncQueue.head(); - if (syncOperation == null) { + op = mSyncQueue.head(); + if (op == null) { if (isLoggable) { Log.v(TAG, "runStateIdle: no more sync operations, returning"); } @@ -1485,39 +1606,49 @@ class SyncManager { // Sync is disabled, drop this operation. if (!isSyncEnabled()) { if (isLoggable) { - Log.v(TAG, "runStateIdle: sync disabled, dropping " + syncOperation); + Log.v(TAG, "runStateIdle: sync disabled, dropping " + op); } mSyncQueue.popHead(); continue; } - // skip the sync if it isn't a force and the settings are off for this provider - final boolean force = syncOperation.extras.getBoolean( - ContentResolver.SYNC_EXTRAS_FORCE, false); - if (!force && (!backgroundDataSetting - || !mSyncStorageEngine.getListenForNetworkTickles() - || !mSyncStorageEngine.getSyncProviderAutomatically( - null, syncOperation.authority))) { + // skip the sync if it isn't manual and auto sync is disabled + final boolean manualSync = op.extras.getBoolean( + ContentResolver.SYNC_EXTRAS_MANUAL, false); + final boolean syncAutomatically = + mSyncStorageEngine.getSyncAutomatically(op.account, op.authority) + && mSyncStorageEngine.getMasterSyncAutomatically(); + boolean syncAllowed = + manualSync || (backgroundDataUsageAllowed && syncAutomatically); + int isSyncable = mSyncStorageEngine.getIsSyncable(op.account, op.authority); + if (isSyncable == 0) { + // if not syncable, don't allow + syncAllowed = false; + } else if (isSyncable < 0) { + // if the syncable state is unknown, only allow initialization syncs + syncAllowed = + op.extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false); + } + if (!syncAllowed) { if (isLoggable) { - Log.v(TAG, "runStateIdle: sync off, dropping " + syncOperation); + Log.v(TAG, "runStateIdle: sync off, dropping " + op); } mSyncQueue.popHead(); continue; } // skip the sync if the account of this operation no longer exists - if (!ArrayUtils.contains(accounts, syncOperation.account)) { + if (!ArrayUtils.contains(accounts, op.account)) { mSyncQueue.popHead(); if (isLoggable) { - Log.v(TAG, "runStateIdle: account not present, dropping " - + syncOperation); + Log.v(TAG, "runStateIdle: account not present, dropping " + op); } continue; } // go ahead and try to sync this syncOperation if (isLoggable) { - Log.v(TAG, "runStateIdle: found sync candidate: " + syncOperation); + Log.v(TAG, "runStateIdle: found sync candidate: " + op); } break; } @@ -1525,11 +1656,10 @@ class SyncManager { // If the first SyncOperation isn't ready to run schedule a wakeup and // get out. final long now = SystemClock.elapsedRealtime(); - if (syncOperation.earliestRunTime > now) { + if (op.earliestRunTime > now) { if (Log.isLoggable(TAG, Log.DEBUG)) { Log.d(TAG, "runStateIdle: the time is " + now + " yet the next " - + "sync operation is for " + syncOperation.earliestRunTime - + ": " + syncOperation); + + "sync operation is for " + op.earliestRunTime + ": " + op); } return; } @@ -1537,72 +1667,72 @@ class SyncManager { // We will do this sync. Remove it from the queue and run it outside of the // synchronized block. if (isLoggable) { - Log.v(TAG, "runStateIdle: we are going to sync " + syncOperation); + Log.v(TAG, "runStateIdle: we are going to sync " + op); } mSyncQueue.popHead(); } - String providerName = syncOperation.authority; - ensureContentResolver(); - IContentProvider contentProvider; - - // acquire the provider and update the sync history - try { - contentProvider = mContentResolver.acquireProvider(providerName); - if (contentProvider == null) { - Log.e(TAG, "Provider " + providerName + " doesn't exist"); - return; - } - if (contentProvider.getSyncAdapter() == null) { - Log.e(TAG, "Provider " + providerName + " isn't syncable, " + contentProvider); - return; + // connect to the sync adapter + SyncAdapterType syncAdapterType = SyncAdapterType.newKey(op.authority, op.account.type); + RegisteredServicesCache.ServiceInfo<SyncAdapterType> syncAdapterInfo = + mSyncAdapters.getServiceInfo(syncAdapterType); + if (syncAdapterInfo == null) { + if (Config.LOGD) { + Log.d(TAG, "can't find a sync adapter for " + syncAdapterType); } - } catch (RemoteException remoteExc) { - Log.e(TAG, "Caught a RemoteException while preparing for sync, rescheduling " - + syncOperation, remoteExc); - rescheduleWithDelay(syncOperation); + runStateIdle(); return; - } catch (RuntimeException exc) { - Log.e(TAG, "Caught a RuntimeException while validating sync of " + providerName, - exc); + } + + ActiveSyncContext activeSyncContext = + new ActiveSyncContext(op, insertStartSyncEvent(op)); + mActiveSyncContext = activeSyncContext; + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "runStateIdle: setting mActiveSyncContext to " + mActiveSyncContext); + } + mSyncStorageEngine.setActiveSync(mActiveSyncContext); + if (!activeSyncContext.bindToSyncAdapter(syncAdapterInfo)) { + Log.e(TAG, "Bind attempt failed to " + syncAdapterInfo); + mActiveSyncContext = null; + mSyncStorageEngine.setActiveSync(mActiveSyncContext); + runStateIdle(); return; } - final long historyRowId = insertStartSyncEvent(syncOperation); + mSyncWakeLock.acquire(); + // no need to schedule an alarm, as that will be done by our caller. + // the next step will occur when we get either a timeout or a + // MESSAGE_SERVICE_CONNECTED or MESSAGE_SERVICE_DISCONNECTED message + } + + private void runBoundToSyncAdapter(ISyncAdapter syncAdapter) { + mActiveSyncContext.mSyncAdapter = syncAdapter; + final SyncOperation syncOperation = mActiveSyncContext.mSyncOperation; try { - ISyncAdapter syncAdapter = contentProvider.getSyncAdapter(); - ActiveSyncContext activeSyncContext = new ActiveSyncContext(syncOperation, - contentProvider, syncAdapter, historyRowId); - mSyncWakeLock.acquire(); - if (Log.isLoggable(TAG, Log.DEBUG)) { - Log.d(TAG, "starting sync of " + syncOperation); - } - syncAdapter.startSync(activeSyncContext, syncOperation.account, - syncOperation.extras); - mActiveSyncContext = activeSyncContext; - mSyncStorageEngine.setActiveSync(mActiveSyncContext); + syncAdapter.startSync(mActiveSyncContext, syncOperation.authority, + syncOperation.account, syncOperation.extras); } catch (RemoteException remoteExc) { if (Config.LOGD) { Log.d(TAG, "runStateIdle: caught a RemoteException, rescheduling", remoteExc); } + mActiveSyncContext.unBindFromSyncAdapter(); mActiveSyncContext = null; mSyncStorageEngine.setActiveSync(mActiveSyncContext); rescheduleWithDelay(syncOperation); } catch (RuntimeException exc) { + mActiveSyncContext.unBindFromSyncAdapter(); mActiveSyncContext = null; mSyncStorageEngine.setActiveSync(mActiveSyncContext); Log.e(TAG, "Caught a RuntimeException while starting the sync " + syncOperation, exc); } - - // no need to schedule an alarm, as that will be done by our caller. } private void runSyncFinishedOrCanceled(SyncResult syncResult) { boolean isLoggable = Log.isLoggable(TAG, Log.VERBOSE); if (isLoggable) Log.v(TAG, "runSyncFinishedOrCanceled"); - ActiveSyncContext activeSyncContext = mActiveSyncContext; + final ActiveSyncContext activeSyncContext = mActiveSyncContext; mActiveSyncContext = null; mSyncStorageEngine.setActiveSync(mActiveSyncContext); @@ -1642,10 +1772,12 @@ class SyncManager { Log.v(TAG, "runSyncFinishedOrCanceled: is a cancel: operation " + syncOperation); } - try { - activeSyncContext.mSyncAdapter.cancelSync(); - } catch (RemoteException e) { - // we don't need to retry this in this case + if (activeSyncContext.mSyncAdapter != null) { + try { + activeSyncContext.mSyncAdapter.cancelSync(activeSyncContext); + } catch (RemoteException e) { + // we don't need to retry this in this case + } } historyMessage = SyncStorageEngine.MESG_CANCELED; downstreamActivity = 0; @@ -1655,7 +1787,7 @@ class SyncManager { stopSyncEvent(activeSyncContext.mHistoryRowId, syncOperation, historyMessage, upstreamActivity, downstreamActivity, elapsedTime); - mContentResolver.releaseProvider(activeSyncContext.mContentProvider); + activeSyncContext.unBindFromSyncAdapter(); if (syncResult != null && syncResult.tooManyDeletions) { installHandleTooManyDeletesNotification(syncOperation.account, @@ -1683,21 +1815,21 @@ class SyncManager { */ private int syncResultToErrorNumber(SyncResult syncResult) { if (syncResult.syncAlreadyInProgress) - return SyncStorageEngine.ERROR_SYNC_ALREADY_IN_PROGRESS; + return ContentResolver.SYNC_ERROR_SYNC_ALREADY_IN_PROGRESS; if (syncResult.stats.numAuthExceptions > 0) - return SyncStorageEngine.ERROR_AUTHENTICATION; + return ContentResolver.SYNC_ERROR_AUTHENTICATION; if (syncResult.stats.numIoExceptions > 0) - return SyncStorageEngine.ERROR_IO; + return ContentResolver.SYNC_ERROR_IO; if (syncResult.stats.numParseExceptions > 0) - return SyncStorageEngine.ERROR_PARSE; + return ContentResolver.SYNC_ERROR_PARSE; if (syncResult.stats.numConflictDetectedExceptions > 0) - return SyncStorageEngine.ERROR_CONFLICT; + return ContentResolver.SYNC_ERROR_CONFLICT; if (syncResult.tooManyDeletions) - return SyncStorageEngine.ERROR_TOO_MANY_DELETIONS; + return ContentResolver.SYNC_ERROR_TOO_MANY_DELETIONS; if (syncResult.tooManyRetries) - return SyncStorageEngine.ERROR_TOO_MANY_RETRIES; + return ContentResolver.SYNC_ERROR_TOO_MANY_RETRIES; if (syncResult.databaseError) - return SyncStorageEngine.ERROR_INTERNAL; + return ContentResolver.SYNC_ERROR_INTERNAL; throw new IllegalStateException("we are not in an error state, " + syncResult); } @@ -1738,9 +1870,10 @@ class SyncManager { } else { final boolean timeToShowNotification = now > mSyncNotificationInfo.startTime + SYNC_NOTIFICATION_DELAY; - final boolean syncIsForced = syncOperation.extras - .getBoolean(ContentResolver.SYNC_EXTRAS_FORCE, false); - shouldInstall = timeToShowNotification || syncIsForced; + // show the notification immediately if this is a manual sync + final boolean manualSync = syncOperation.extras + .getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false); + shouldInstall = timeToShowNotification || manualSync; } } @@ -1860,7 +1993,7 @@ class SyncManager { mContext.sendBroadcast(syncStateIntent); } - private void installHandleTooManyDeletesNotification(String account, String authority, + private void installHandleTooManyDeletesNotification(Account account, String authority, long numDeletes) { if (mNotificationMgr == null) return; Intent clickIntent = new Intent(); @@ -1995,9 +2128,9 @@ class SyncManager { SyncOperation existingOperation = mOpsByKey.get(operationKey); // if this operation matches an existing operation that is being retried (delay > 0) - // and this operation isn't forced, ignore this operation + // and this isn't a manual sync operation, ignore this operation if (existingOperation != null && existingOperation.delay > 0) { - if (!operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_FORCE, false)) { + if (!operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false)) { return false; } } @@ -2071,7 +2204,7 @@ class SyncManager { if (DEBUG_CHECK_DATA_CONSISTENCY) debugCheckDataStructures(true /* check the DB */); } - public void clear(String account, String authority) { + public void clear(Account account, String authority) { Iterator<Map.Entry<String, SyncOperation>> entries = mOpsByKey.entrySet().iterator(); while (entries.hasNext()) { Map.Entry<String, SyncOperation> entry = entries.next(); diff --git a/core/java/android/content/SyncResult.java b/core/java/android/content/SyncResult.java index f3260f3..4c201e6 100644 --- a/core/java/android/content/SyncResult.java +++ b/core/java/android/content/SyncResult.java @@ -113,14 +113,19 @@ public final class SyncResult implements Parcelable { @Override public String toString() { StringBuilder sb = new StringBuilder(); - sb.append(" syncAlreadyInProgress: ").append(syncAlreadyInProgress); - sb.append(" tooManyDeletions: ").append(tooManyDeletions); - sb.append(" tooManyRetries: ").append(tooManyRetries); - sb.append(" databaseError: ").append(databaseError); - sb.append(" fullSyncRequested: ").append(fullSyncRequested); - sb.append(" partialSyncUnavailable: ").append(partialSyncUnavailable); - sb.append(" moreRecordsToGet: ").append(moreRecordsToGet); - sb.append(" stats: ").append(stats); + sb.append("SyncResult:"); + if (syncAlreadyInProgress) { + sb.append(" syncAlreadyInProgress: ").append(syncAlreadyInProgress); + } + if (tooManyDeletions) sb.append(" tooManyDeletions: ").append(tooManyDeletions); + if (tooManyRetries) sb.append(" tooManyRetries: ").append(tooManyRetries); + if (databaseError) sb.append(" databaseError: ").append(databaseError); + if (fullSyncRequested) sb.append(" fullSyncRequested: ").append(fullSyncRequested); + if (partialSyncUnavailable) { + sb.append(" partialSyncUnavailable: ").append(partialSyncUnavailable); + } + if (moreRecordsToGet) sb.append(" moreRecordsToGet: ").append(moreRecordsToGet); + sb.append(stats); return sb.toString(); } diff --git a/core/java/android/content/SyncStateContentProviderHelper.java b/core/java/android/content/SyncStateContentProviderHelper.java index f503e6f..64bbe25 100644 --- a/core/java/android/content/SyncStateContentProviderHelper.java +++ b/core/java/android/content/SyncStateContentProviderHelper.java @@ -23,6 +23,7 @@ import android.database.DatabaseUtils; import android.database.sqlite.SQLiteDatabase; import android.database.sqlite.SQLiteOpenHelper; import android.net.Uri; +import android.accounts.Account; /** * Extends the schema of a ContentProvider to include the _sync_state table @@ -43,14 +44,15 @@ public class SyncStateContentProviderHelper { private static final Uri CONTENT_URI = Uri.parse("content://" + SYNC_STATE_AUTHORITY + "/state"); - private static final String ACCOUNT_WHERE = "_sync_account = ?"; + private static final String ACCOUNT_WHERE = "_sync_account = ? AND _sync_account_type = ?"; private final Provider mInternalProviderInterface; private static final String SYNC_STATE_TABLE = "_sync_state"; - private static long DB_VERSION = 2; + private static long DB_VERSION = 3; - private static final String[] ACCOUNT_PROJECTION = new String[]{"_sync_account"}; + private static final String[] ACCOUNT_PROJECTION = + new String[]{"_sync_account", "_sync_account_type"}; static { sURIMatcher.addURI(SYNC_STATE_AUTHORITY, "state", STATE); @@ -70,8 +72,9 @@ public class SyncStateContentProviderHelper { db.execSQL("CREATE TABLE _sync_state (" + "_id INTEGER PRIMARY KEY," + "_sync_account TEXT," + + "_sync_account_type TEXT," + "data TEXT," + - "UNIQUE(_sync_account)" + + "UNIQUE(_sync_account, _sync_account_type)" + ");"); db.execSQL("DROP TABLE IF EXISTS _sync_state_metadata"); @@ -168,15 +171,17 @@ public class SyncStateContentProviderHelper { * @param account the account of the row that should be copied over. */ public void copySyncState(SQLiteDatabase dbSrc, SQLiteDatabase dbDest, - String account) { - final String[] whereArgs = new String[]{account}; - Cursor c = dbSrc.query(SYNC_STATE_TABLE, new String[]{"_sync_account", "data"}, + Account account) { + final String[] whereArgs = new String[]{account.name, account.type}; + Cursor c = dbSrc.query(SYNC_STATE_TABLE, + new String[]{"_sync_account", "_sync_account_type", "data"}, ACCOUNT_WHERE, whereArgs, null, null, null); try { if (c.moveToNext()) { ContentValues values = new ContentValues(); values.put("_sync_account", c.getString(0)); - values.put("data", c.getBlob(1)); + values.put("_sync_account_type", c.getString(1)); + values.put("data", c.getBlob(2)); dbDest.replace(SYNC_STATE_TABLE, "_sync_account", values); } } finally { @@ -184,14 +189,17 @@ public class SyncStateContentProviderHelper { } } - public void onAccountsChanged(String[] accounts) { + public void onAccountsChanged(Account[] accounts) { SQLiteDatabase db = mOpenHelper.getWritableDatabase(); Cursor c = db.query(SYNC_STATE_TABLE, ACCOUNT_PROJECTION, null, null, null, null, null); try { while (c.moveToNext()) { - final String account = c.getString(0); + final String accountName = c.getString(0); + final String accountType = c.getString(1); + Account account = new Account(accountName, accountType); if (!ArrayUtils.contains(accounts, account)) { - db.delete(SYNC_STATE_TABLE, ACCOUNT_WHERE, new String[]{account}); + db.delete(SYNC_STATE_TABLE, ACCOUNT_WHERE, + new String[]{accountName, accountType}); } } } finally { @@ -199,9 +207,9 @@ public class SyncStateContentProviderHelper { } } - public void discardSyncData(SQLiteDatabase db, String account) { + public void discardSyncData(SQLiteDatabase db, Account account) { if (account != null) { - db.delete(SYNC_STATE_TABLE, ACCOUNT_WHERE, new String[]{account}); + db.delete(SYNC_STATE_TABLE, ACCOUNT_WHERE, new String[]{account.name, account.type}); } else { db.delete(SYNC_STATE_TABLE, null, null); } @@ -210,9 +218,9 @@ public class SyncStateContentProviderHelper { /** * Retrieves the SyncData bytes for the given account. The byte array returned may be null. */ - public byte[] readSyncDataBytes(SQLiteDatabase db, String account) { + public byte[] readSyncDataBytes(SQLiteDatabase db, Account account) { Cursor c = db.query(SYNC_STATE_TABLE, null, ACCOUNT_WHERE, - new String[]{account}, null, null, null); + new String[]{account.name, account.type}, null, null, null); try { if (c.moveToFirst()) { return c.getBlob(c.getColumnIndexOrThrow("data")); @@ -226,9 +234,10 @@ public class SyncStateContentProviderHelper { /** * Sets the SyncData bytes for the given account. The bytes array may be null. */ - public void writeSyncDataBytes(SQLiteDatabase db, String account, byte[] data) { + public void writeSyncDataBytes(SQLiteDatabase db, Account account, byte[] data) { ContentValues values = new ContentValues(); values.put("data", data); - db.update(SYNC_STATE_TABLE, values, ACCOUNT_WHERE, new String[]{account}); + db.update(SYNC_STATE_TABLE, values, ACCOUNT_WHERE, + new String[]{account.name, account.type}); } } diff --git a/core/java/android/content/SyncStats.java b/core/java/android/content/SyncStats.java index b561b05..cc544c0 100644 --- a/core/java/android/content/SyncStats.java +++ b/core/java/android/content/SyncStats.java @@ -60,15 +60,18 @@ public class SyncStats implements Parcelable { @Override public String toString() { StringBuilder sb = new StringBuilder(); - sb.append("numAuthExceptions: ").append(numAuthExceptions); - sb.append(" numIoExceptions: ").append(numIoExceptions); - sb.append(" numParseExceptions: ").append(numParseExceptions); - sb.append(" numConflictDetectedExceptions: ").append(numConflictDetectedExceptions); - sb.append(" numInserts: ").append(numInserts); - sb.append(" numUpdates: ").append(numUpdates); - sb.append(" numDeletes: ").append(numDeletes); - sb.append(" numEntries: ").append(numEntries); - sb.append(" numSkippedEntries: ").append(numSkippedEntries); + sb.append(" stats ["); + if (numAuthExceptions > 0) sb.append(" numAuthExceptions: ").append(numAuthExceptions); + if (numIoExceptions > 0) sb.append(" numIoExceptions: ").append(numIoExceptions); + if (numParseExceptions > 0) sb.append(" numParseExceptions: ").append(numParseExceptions); + if (numConflictDetectedExceptions > 0) + sb.append(" numConflictDetectedExceptions: ").append(numConflictDetectedExceptions); + if (numInserts > 0) sb.append(" numInserts: ").append(numInserts); + if (numUpdates > 0) sb.append(" numUpdates: ").append(numUpdates); + if (numDeletes > 0) sb.append(" numDeletes: ").append(numDeletes); + if (numEntries > 0) sb.append(" numEntries: ").append(numEntries); + if (numSkippedEntries > 0) sb.append(" numSkippedEntries: ").append(numSkippedEntries); + sb.append("]"); return sb.toString(); } diff --git a/core/java/android/content/SyncStatusObserver.java b/core/java/android/content/SyncStatusObserver.java new file mode 100644 index 0000000..663378a --- /dev/null +++ b/core/java/android/content/SyncStatusObserver.java @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2009 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.content; + +public interface SyncStatusObserver { + void onStatusChanged(int which); +} diff --git a/core/java/android/content/SyncStorageEngine.java b/core/java/android/content/SyncStorageEngine.java index 756f35c..3ff13ae 100644 --- a/core/java/android/content/SyncStorageEngine.java +++ b/core/java/android/content/SyncStorageEngine.java @@ -24,6 +24,7 @@ import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import org.xmlpull.v1.XmlSerializer; +import android.accounts.Account; import android.backup.IBackupManager; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; @@ -88,6 +89,9 @@ public class SyncStorageEngine extends Handler { /** Enum value for a user-initiated sync. */ public static final int SOURCE_USER = 3; + private static final Intent SYNC_CONNECTION_SETTING_CHANGED_INTENT = + new Intent("com.android.sync.SYNC_CONN_STATUS_CHANGED"); + // TODO: i18n -- grab these out of resources. /** String names for the sync source types. */ public static final String[] SOURCES = { "SERVER", @@ -95,26 +99,10 @@ public class SyncStorageEngine extends Handler { "POLL", "USER" }; - // Error types - public static final int ERROR_SYNC_ALREADY_IN_PROGRESS = 1; - public static final int ERROR_AUTHENTICATION = 2; - public static final int ERROR_IO = 3; - public static final int ERROR_PARSE = 4; - public static final int ERROR_CONFLICT = 5; - public static final int ERROR_TOO_MANY_DELETIONS = 6; - public static final int ERROR_TOO_MANY_RETRIES = 7; - public static final int ERROR_INTERNAL = 8; - // The MESG column will contain one of these or one of the Error types. public static final String MESG_SUCCESS = "success"; public static final String MESG_CANCELED = "canceled"; - public static final int CHANGE_SETTINGS = 1<<0; - public static final int CHANGE_PENDING = 1<<1; - public static final int CHANGE_ACTIVE = 1<<2; - public static final int CHANGE_STATUS = 1<<3; - public static final int CHANGE_ALL = 0x7fffffff; - public static final int MAX_HISTORY = 15; private static final int MSG_WRITE_STATUS = 1; @@ -122,9 +110,11 @@ public class SyncStorageEngine extends Handler { private static final int MSG_WRITE_STATISTICS = 2; private static final long WRITE_STATISTICS_DELAY = 1000*60*30; // 1/2 hour + + private static final boolean SYNC_ENABLED_DEFAULT = false; public static class PendingOperation { - final String account; + final Account account; final int syncSource; final String authority; final Bundle extras; // note: read-only. @@ -132,7 +122,7 @@ public class SyncStorageEngine extends Handler { int authorityId; byte[] flatExtras; - PendingOperation(String account, int source, + PendingOperation(Account account, int source, String authority, Bundle extras) { this.account = account; this.syncSource = source; @@ -151,26 +141,28 @@ public class SyncStorageEngine extends Handler { } static class AccountInfo { - final String account; + final Account account; final HashMap<String, AuthorityInfo> authorities = new HashMap<String, AuthorityInfo>(); - AccountInfo(String account) { + AccountInfo(Account account) { this.account = account; } } public static class AuthorityInfo { - final String account; + final Account account; final String authority; final int ident; boolean enabled; - - AuthorityInfo(String account, String authority, int ident) { + int syncable; + + AuthorityInfo(Account account, String authority, int ident) { this.account = account; this.authority = authority; this.ident = ident; - enabled = true; + enabled = SYNC_ENABLED_DEFAULT; + syncable = -1; // default to "unknown" } } @@ -202,8 +194,8 @@ public class SyncStorageEngine extends Handler { private final SparseArray<AuthorityInfo> mAuthorities = new SparseArray<AuthorityInfo>(); - private final HashMap<String, AccountInfo> mAccounts = - new HashMap<String, AccountInfo>(); + private final HashMap<Account, AccountInfo> mAccounts = + new HashMap<Account, AccountInfo>(); private final ArrayList<PendingOperation> mPendingOperations = new ArrayList<PendingOperation>(); @@ -258,7 +250,7 @@ public class SyncStorageEngine extends Handler { private int mNumPendingFinished = 0; private int mNextHistoryId = 0; - private boolean mListenForTickles = true; + private boolean mMasterSyncAutomatically = true; private SyncStorageEngine(Context context) { mContext = context; @@ -366,14 +358,14 @@ public class SyncStorageEngine extends Handler { } } - public boolean getSyncProviderAutomatically(String account, String providerName) { + public boolean getSyncAutomatically(Account account, String providerName) { synchronized (mAuthorities) { if (account != null) { AuthorityInfo authority = getAuthorityLocked(account, providerName, - "getSyncProviderAutomatically"); - return authority != null ? authority.enabled : false; + "getSyncAutomatically"); + return authority != null && authority.enabled; } - + int i = mAuthorities.size(); while (i > 0) { i--; @@ -387,45 +379,86 @@ public class SyncStorageEngine extends Handler { } } - public void setSyncProviderAutomatically(String account, String providerName, boolean sync) { + public void setSyncAutomatically(Account account, String providerName, boolean sync) { + boolean wasEnabled; + synchronized (mAuthorities) { + AuthorityInfo authority = getOrCreateAuthorityLocked(account, providerName, -1, false); + wasEnabled = authority.enabled; + authority.enabled = sync; + writeAccountInfoLocked(); + } + + if (!wasEnabled && sync) { + mContext.getContentResolver().requestSync(account, providerName, new Bundle()); + } + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS); + } + + public int getIsSyncable(Account account, String providerName) { synchronized (mAuthorities) { if (account != null) { AuthorityInfo authority = getAuthorityLocked(account, providerName, - "setSyncProviderAutomatically"); - if (authority != null) { - authority.enabled = sync; + "getIsSyncable"); + if (authority == null) { + return -1; } - } else { - int i = mAuthorities.size(); - while (i > 0) { - i--; - AuthorityInfo authority = mAuthorities.get(i); - if (authority.authority.equals(providerName)) { - authority.enabled = sync; - } + return authority.syncable; + } + + int i = mAuthorities.size(); + while (i > 0) { + i--; + AuthorityInfo authority = mAuthorities.get(i); + if (authority.authority.equals(providerName)) { + return authority.syncable; } } + return -1; + } + } + + public void setIsSyncable(Account account, String providerName, int syncable) { + int oldState; + if (syncable > 1) { + syncable = 1; + } else if (syncable < -1) { + syncable = -1; + } + Log.d(TAG, "setIsSyncable: " + account + ", provider " + providerName + " -> " + syncable); + synchronized (mAuthorities) { + AuthorityInfo authority = getOrCreateAuthorityLocked(account, providerName, -1, false); + oldState = authority.syncable; + authority.syncable = syncable; writeAccountInfoLocked(); } - - reportChange(CHANGE_SETTINGS); + + if (oldState <= 0 && syncable > 0) { + mContext.getContentResolver().requestSync(account, providerName, new Bundle()); + } + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS); } - public void setListenForNetworkTickles(boolean flag) { + public void setMasterSyncAutomatically(boolean flag) { + boolean old; synchronized (mAuthorities) { - mListenForTickles = flag; + old = mMasterSyncAutomatically; + mMasterSyncAutomatically = flag; writeAccountInfoLocked(); } - reportChange(CHANGE_SETTINGS); + if (!old && flag) { + mContext.getContentResolver().requestSync(null, null, new Bundle()); + } + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS); + mContext.sendBroadcast(SYNC_CONNECTION_SETTING_CHANGED_INTENT); } - public boolean getListenForNetworkTickles() { + public boolean getMasterSyncAutomatically() { synchronized (mAuthorities) { - return mListenForTickles; + return mMasterSyncAutomatically; } } - public AuthorityInfo getAuthority(String account, String authority) { + public AuthorityInfo getAuthority(Account account, String authority) { synchronized (mAuthorities) { return getAuthorityLocked(account, authority, null); } @@ -441,7 +474,7 @@ public class SyncStorageEngine extends Handler { * Returns true if there is currently a sync operation for the given * account or authority in the pending list, or actively being processed. */ - public boolean isSyncActive(String account, String authority) { + public boolean isSyncActive(Account account, String authority) { synchronized (mAuthorities) { int i = mPendingOperations.size(); while (i > 0) { @@ -490,7 +523,7 @@ public class SyncStorageEngine extends Handler { status.pending = true; } - reportChange(CHANGE_PENDING); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_PENDING); return op; } @@ -536,7 +569,7 @@ public class SyncStorageEngine extends Handler { } } - reportChange(CHANGE_PENDING); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_PENDING); return res; } @@ -552,7 +585,7 @@ public class SyncStorageEngine extends Handler { } writePendingOperationsLocked(); } - reportChange(CHANGE_PENDING); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_PENDING); return num; } @@ -580,7 +613,7 @@ public class SyncStorageEngine extends Handler { * Called when the set of account has changed, given the new array of * active accounts. */ - public void doDatabaseCleanup(String[] accounts) { + public void doDatabaseCleanup(Account[] accounts) { synchronized (mAuthorities) { if (DEBUG) Log.w(TAG, "Updating for new accounts..."); SparseArray<AuthorityInfo> removing = new SparseArray<AuthorityInfo>(); @@ -659,20 +692,20 @@ public class SyncStorageEngine extends Handler { } } - reportChange(CHANGE_ACTIVE); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE); } /** * To allow others to send active change reports, to poke clients. */ public void reportActiveChange() { - reportChange(CHANGE_ACTIVE); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE); } /** * Note that sync has started for the given account and authority. */ - public long insertStartSyncEvent(String accountName, String authorityName, + public long insertStartSyncEvent(Account accountName, String authorityName, long now, int source) { long id; synchronized (mAuthorities) { @@ -698,7 +731,7 @@ public class SyncStorageEngine extends Handler { if (DEBUG) Log.v(TAG, "returning historyId " + id); } - reportChange(CHANGE_STATUS); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_STATUS); return id; } @@ -802,7 +835,7 @@ public class SyncStorageEngine extends Handler { } } - reportChange(CHANGE_STATUS); + reportChange(ContentResolver.SYNC_OBSERVER_TYPE_STATUS); } /** @@ -860,7 +893,7 @@ public class SyncStorageEngine extends Handler { /** * Return true if the pending status is true of any matching authorities. */ - public boolean isAuthorityPending(String account, String authority) { + public boolean isSyncPending(Account account, String authority) { synchronized (mAuthorities) { final int N = mSyncStatus.size(); for (int i=0; i<N; i++) { @@ -916,7 +949,7 @@ public class SyncStorageEngine extends Handler { */ public long getInitialSyncFailureTime() { synchronized (mAuthorities) { - if (!mListenForTickles) { + if (!mMasterSyncAutomatically) { return 0; } @@ -957,19 +990,23 @@ public class SyncStorageEngine extends Handler { * @param tag If non-null, this will be used in a log message if the * requested authority does not exist. */ - private AuthorityInfo getAuthorityLocked(String accountName, String authorityName, + private AuthorityInfo getAuthorityLocked(Account accountName, String authorityName, String tag) { AccountInfo account = mAccounts.get(accountName); if (account == null) { if (tag != null) { - Log.w(TAG, tag + ": unknown account " + accountName); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, tag + ": unknown account " + accountName); + } } return null; } AuthorityInfo authority = account.authorities.get(authorityName); if (authority == null) { if (tag != null) { - Log.w(TAG, tag + ": unknown authority " + authorityName); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, tag + ": unknown authority " + authorityName); + } } return null; } @@ -977,7 +1014,7 @@ public class SyncStorageEngine extends Handler { return authority; } - private AuthorityInfo getOrCreateAuthorityLocked(String accountName, + private AuthorityInfo getOrCreateAuthorityLocked(Account accountName, String authorityName, int ident, boolean doWrite) { AccountInfo account = mAccounts.get(accountName); if (account == null) { @@ -997,6 +1034,8 @@ public class SyncStorageEngine extends Handler { ident++; } } + Log.d(TAG, "created a new AuthorityInfo for " + accountName + + ", provider " + authorityName); authority = new AuthorityInfo(accountName, authorityName, ident); account.authorities.put(authorityName, authority); mAuthorities.put(ident, authority); @@ -1050,7 +1089,7 @@ public class SyncStorageEngine extends Handler { if ("accounts".equals(tagName)) { String listen = parser.getAttributeValue( null, "listen-for-tickles"); - mListenForTickles = listen == null + mMasterSyncAutomatically = listen == null || Boolean.parseBoolean(listen); eventType = parser.next(); do { @@ -1068,26 +1107,43 @@ public class SyncStorageEngine extends Handler { if (id >= 0) { String accountName = parser.getAttributeValue( null, "account"); + String accountType = parser.getAttributeValue( + null, "type"); + if (accountType == null) { + accountType = "com.google.GAIA"; + } String authorityName = parser.getAttributeValue( null, "authority"); String enabled = parser.getAttributeValue( null, "enabled"); - AuthorityInfo authority = mAuthorities.get(id); + String syncable = parser.getAttributeValue(null, "syncable"); + AuthorityInfo authority = mAuthorities.get(id); if (DEBUG_FILE) Log.v(TAG, "Adding authority: account=" + accountName + " auth=" + authorityName - + " enabled=" + enabled); + + " enabled=" + enabled + + " syncable=" + syncable); if (authority == null) { if (DEBUG_FILE) Log.v(TAG, "Creating entry"); authority = getOrCreateAuthorityLocked( - accountName, authorityName, id, false); + new Account(accountName, accountType), + authorityName, id, false); } if (authority != null) { authority.enabled = enabled == null || Boolean.parseBoolean(enabled); + if ("unknown".equals(syncable)) { + authority.syncable = -1; + } else { + authority.syncable = + (syncable == null || Boolean.parseBoolean(enabled)) + ? 1 + : 0; + } } else { Log.w(TAG, "Failure adding authority: account=" + accountName + " auth=" + authorityName - + " enabled=" + enabled); + + " enabled=" + enabled + + " syncable=" + syncable); } } } @@ -1125,7 +1181,7 @@ public class SyncStorageEngine extends Handler { out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); out.startTag(null, "accounts"); - if (!mListenForTickles) { + if (!mMasterSyncAutomatically) { out.attribute(null, "listen-for-tickles", "false"); } @@ -1134,11 +1190,17 @@ public class SyncStorageEngine extends Handler { AuthorityInfo authority = mAuthorities.get(i); out.startTag(null, "authority"); out.attribute(null, "id", Integer.toString(authority.ident)); - out.attribute(null, "account", authority.account); + out.attribute(null, "account", authority.account.name); + out.attribute(null, "type", authority.account.type); out.attribute(null, "authority", authority.authority); if (!authority.enabled) { out.attribute(null, "enabled", "false"); } + if (authority.syncable < 0) { + out.attribute(null, "syncable", "unknown"); + } else if (authority.syncable == 0) { + out.attribute(null, "syncable", "false"); + } out.endTag(null, "authority"); } @@ -1183,6 +1245,8 @@ public class SyncStorageEngine extends Handler { } if (db != null) { + final boolean hasType = db.getVersion() >= 11; + // Copy in all of the status information, as well as accounts. if (DEBUG_FILE) Log.v(TAG, "Reading legacy sync accounts db"); SQLiteQueryBuilder qb = new SQLiteQueryBuilder(); @@ -1190,6 +1254,9 @@ public class SyncStorageEngine extends Handler { HashMap<String,String> map = new HashMap<String,String>(); map.put("_id", "status._id as _id"); map.put("account", "stats.account as account"); + if (hasType) { + map.put("account_type", "stats.account_type as account_type"); + } map.put("authority", "stats.authority as authority"); map.put("totalElapsedTime", "totalElapsedTime"); map.put("numSyncs", "numSyncs"); @@ -1208,9 +1275,15 @@ public class SyncStorageEngine extends Handler { Cursor c = qb.query(db, null, null, null, null, null, null); while (c.moveToNext()) { String accountName = c.getString(c.getColumnIndex("account")); + String accountType = hasType + ? c.getString(c.getColumnIndex("account_type")) : null; + if (accountType == null) { + accountType = "com.google.GAIA"; + } String authorityName = c.getString(c.getColumnIndex("authority")); AuthorityInfo authority = this.getOrCreateAuthorityLocked( - accountName, authorityName, -1, false); + new Account(accountName, accountType), + authorityName, -1, false); if (authority != null) { int i = mSyncStatus.size(); boolean found = false; @@ -1253,13 +1326,19 @@ public class SyncStorageEngine extends Handler { String value = c.getString(c.getColumnIndex("value")); if (name == null) continue; if (name.equals("listen_for_tickles")) { - setListenForNetworkTickles(value == null - || Boolean.parseBoolean(value)); + setMasterSyncAutomatically(value == null || Boolean.parseBoolean(value)); } else if (name.startsWith("sync_provider_")) { String provider = name.substring("sync_provider_".length(), name.length()); - setSyncProviderAutomatically(null, provider, - value == null || Boolean.parseBoolean(value)); + int i = mAuthorities.size(); + while (i > 0) { + i--; + AuthorityInfo authority = mAuthorities.get(i); + if (authority.authority.equals(provider)) { + authority.enabled = value == null || Boolean.parseBoolean(value); + authority.syncable = 1; + } + } } } diff --git a/core/java/android/content/SyncableContentProvider.java b/core/java/android/content/SyncableContentProvider.java index e0cd786..ab4e91c 100644 --- a/core/java/android/content/SyncableContentProvider.java +++ b/core/java/android/content/SyncableContentProvider.java @@ -19,6 +19,7 @@ package android.content; import android.database.Cursor; import android.database.sqlite.SQLiteDatabase; import android.net.Uri; +import android.accounts.Account; import java.util.Map; @@ -32,6 +33,16 @@ import java.util.Map; public abstract class SyncableContentProvider extends ContentProvider { protected abstract boolean isTemporary(); + private volatile TempProviderSyncAdapter mTempProviderSyncAdapter; + + public void setTempProviderSyncAdapter(TempProviderSyncAdapter syncAdapter) { + mTempProviderSyncAdapter = syncAdapter; + } + + public TempProviderSyncAdapter getTempProviderSyncAdapter() { + return mTempProviderSyncAdapter; + } + /** * Close resources that must be closed. You must call this to properly release * the resources used by the SyncableContentProvider. @@ -110,7 +121,7 @@ public abstract class SyncableContentProvider extends ContentProvider { * @param context the sync context for the operation * @param account */ - public abstract void onSyncStart(SyncContext context, String account); + public abstract void onSyncStart(SyncContext context, Account account); /** * Called right after a sync is completed @@ -124,7 +135,7 @@ public abstract class SyncableContentProvider extends ContentProvider { * The account of the most recent call to onSyncStart() * @return the account */ - public abstract String getSyncingAccount(); + public abstract Account getSyncingAccount(); /** * Merge diffs from a sync source with this content provider. @@ -194,7 +205,7 @@ public abstract class SyncableContentProvider extends ContentProvider { * Make sure that there are no entries for accounts that no longer exist * @param accountsArray the array of currently-existing accounts */ - protected abstract void onAccountsChanged(String[] accountsArray); + protected abstract void onAccountsChanged(Account[] accountsArray); /** * A helper method to delete all rows whose account is not in the accounts @@ -203,26 +214,24 @@ public abstract class SyncableContentProvider extends ContentProvider { * * @param accounts a map of existing accounts * @param table the table to delete from - * @param accountColumnName the name of the column that is expected - * to hold the account. */ - protected abstract void deleteRowsForRemovedAccounts(Map<String, Boolean> accounts, - String table, String accountColumnName); + protected abstract void deleteRowsForRemovedAccounts(Map<Account, Boolean> accounts, + String table); /** * Called when the sync system determines that this provider should no longer * contain records for the specified account. */ - public abstract void wipeAccount(String account); + public abstract void wipeAccount(Account account); /** * Retrieves the SyncData bytes for the given account. The byte array returned may be null. */ - public abstract byte[] readSyncDataBytes(String account); + public abstract byte[] readSyncDataBytes(Account account); /** * Sets the SyncData bytes for the given account. The bytes array may be null. */ - public abstract void writeSyncDataBytes(String account, byte[] data); + public abstract void writeSyncDataBytes(Account account, byte[] data); } diff --git a/core/java/android/content/TempProviderSyncAdapter.java b/core/java/android/content/TempProviderSyncAdapter.java index eb3a5da..b46c545 100644 --- a/core/java/android/content/TempProviderSyncAdapter.java +++ b/core/java/android/content/TempProviderSyncAdapter.java @@ -12,6 +12,11 @@ import android.util.Config; import android.util.EventLog; import android.util.Log; import android.util.TimingLogger; +import android.accounts.Account; +import android.accounts.AuthenticatorException; +import android.accounts.OperationCanceledException; + +import java.io.IOException; /** * @hide @@ -62,12 +67,10 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { * * @param context allows you to publish status and interact with the * @param account the account to sync - * @param forced if true then the sync was forced + * @param manualSync true if this sync was requested manually by the user * @param result information to track what happened during this sync attempt - * @return true, if the sync was successfully started. One reason it can - * fail to start is if there is no user configured on the device. */ - public abstract void onSyncStarting(SyncContext context, String account, boolean forced, + public abstract void onSyncStarting(SyncContext context, Account account, boolean manualSync, SyncResult result); /** @@ -85,6 +88,9 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { */ public abstract boolean isReadOnly(); + public abstract boolean getIsSyncable(Account account) + throws IOException, AuthenticatorException, OperationCanceledException; + /** * Get diffs from the server since the last completed sync and put them * into a temporary provider. @@ -168,12 +174,13 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { * exist. * @param accounts the list of accounts */ - public abstract void onAccountsChanged(String[] accounts); + public abstract void onAccountsChanged(Account[] accounts); private Context mContext; private class SyncThread extends Thread { - private final String mAccount; + private final Account mAccount; + private final String mAuthority; private final Bundle mExtras; private final SyncContext mSyncContext; private volatile boolean mIsCanceled = false; @@ -181,9 +188,10 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { private long mInitialRxBytes; private final SyncResult mResult; - SyncThread(SyncContext syncContext, String account, Bundle extras) { + SyncThread(SyncContext syncContext, Account account, String authority, Bundle extras) { super("SyncThread"); mAccount = account; + mAuthority = authority; mExtras = extras; mSyncContext = syncContext; mResult = new SyncResult(); @@ -207,7 +215,7 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { mInitialTxBytes = NetStat.getUidTxBytes(uid); mInitialRxBytes = NetStat.getUidRxBytes(uid); try { - sync(mSyncContext, mAccount, mExtras); + sync(mSyncContext, mAccount, mAuthority, mExtras); } catch (SQLException e) { Log.e(TAG, "Sync failed", e); mResult.databaseError = true; @@ -221,19 +229,45 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { } } - private void sync(SyncContext syncContext, String account, Bundle extras) { + private void sync(SyncContext syncContext, Account account, String authority, + Bundle extras) { mIsCanceled = false; mProviderSyncStarted = false; mAdapterSyncStarted = false; String message = null; - boolean syncForced = extras.getBoolean(ContentResolver.SYNC_EXTRAS_FORCE, false); + // always attempt to initialize if the isSyncable state isn't set yet + int isSyncable = ContentResolver.getIsSyncable(account, authority); + if (isSyncable < 0) { + try { + isSyncable = (getIsSyncable(account)) ? 1 : 0; + ContentResolver.setIsSyncable(account, authority, isSyncable); + } catch (IOException e) { + ++mResult.stats.numIoExceptions; + } catch (AuthenticatorException e) { + ++mResult.stats.numParseExceptions; + } catch (OperationCanceledException e) { + // do nothing + } + } + + // if this is an initialization request then our work is done here + if (extras.getBoolean(ContentResolver.SYNC_EXTRAS_INITIALIZE, false)) { + return; + } + + // if we aren't syncable then get out + if (isSyncable <= 0) { + return; + } + + boolean manualSync = extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false); try { mProvider.onSyncStart(syncContext, account); mProviderSyncStarted = true; - onSyncStarting(syncContext, account, syncForced, mResult); + onSyncStarting(syncContext, account, manualSync, mResult); if (mResult.hasError()) { message = "SyncAdapter failed while trying to start sync"; return; @@ -273,7 +307,7 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { } } - private void runSyncLoop(SyncContext syncContext, String account, Bundle extras) { + private void runSyncLoop(SyncContext syncContext, Account account, Bundle extras) { TimingLogger syncTimer = new TimingLogger(TAG + "Profiling", "sync"); syncTimer.addSplit("start"); int loopCount = 0; @@ -518,13 +552,14 @@ public abstract class TempProviderSyncAdapter extends SyncAdapter { EventLog.writeEvent(SyncAdapter.LOG_SYNC_DETAILS, TAG, bytesSent, bytesReceived, ""); } - public void startSync(SyncContext syncContext, String account, Bundle extras) { + public void startSync(SyncContext syncContext, Account account, String authority, + Bundle extras) { if (mSyncThread != null) { syncContext.onFinished(SyncResult.ALREADY_IN_PROGRESS); return; } - mSyncThread = new SyncThread(syncContext, account, extras); + mSyncThread = new SyncThread(syncContext, account, authority, extras); mSyncThread.start(); } diff --git a/core/java/android/content/pm/IPackageManager.aidl b/core/java/android/content/pm/IPackageManager.aidl index e587ca7..7760612 100644 --- a/core/java/android/content/pm/IPackageManager.aidl +++ b/core/java/android/content/pm/IPackageManager.aidl @@ -75,6 +75,8 @@ interface IPackageManager { int checkSignatures(String pkg1, String pkg2); + int checkUidSignatures(int uid1, int uid2); + String[] getPackagesForUid(int uid); String getNameForUid(int uid); @@ -121,6 +123,7 @@ interface IPackageManager { * providers that can sync. * @param outInfo Filled in with a list of the ProviderInfo for each * name in 'outNames'. + * @deprecated */ void querySyncProviders(inout List<String> outNames, inout List<ProviderInfo> outInfo); diff --git a/core/java/android/content/pm/PackageManager.java b/core/java/android/content/pm/PackageManager.java index 67bd1ac..fca005c 100644 --- a/core/java/android/content/pm/PackageManager.java +++ b/core/java/android/content/pm/PackageManager.java @@ -865,6 +865,7 @@ public abstract class PackageManager { * {@link #SIGNATURE_SECOND_NOT_SIGNED}, {@link #SIGNATURE_NO_MATCH}, * or {@link #SIGNATURE_UNKNOWN_PACKAGE}. * + * @see #checkSignatures(int, int) * @see #SIGNATURE_MATCH * @see #SIGNATURE_NEITHER_SIGNED * @see #SIGNATURE_FIRST_NOT_SIGNED @@ -875,6 +876,34 @@ public abstract class PackageManager { public abstract int checkSignatures(String pkg1, String pkg2); /** + * Like {@link #checkSignatures(String, String)}, but takes UIDs of + * the two packages to be checked. This can be useful, for example, + * when doing the check in an IPC, where the UID is the only identity + * available. It is functionally identical to determining the package + * associated with the UIDs and checking their signatures. + * + * @param uid1 First UID whose signature will be compared. + * @param uid2 Second UID whose signature will be compared. + * @return Returns an integer indicating whether there is a matching + * signature: the value is >= 0 if there is a match (or neither package + * is signed), or < 0 if there is not a match. The match result can be + * further distinguished with the success (>= 0) constants + * {@link #SIGNATURE_MATCH}, {@link #SIGNATURE_NEITHER_SIGNED}; or + * failure (< 0) constants {@link #SIGNATURE_FIRST_NOT_SIGNED}, + * {@link #SIGNATURE_SECOND_NOT_SIGNED}, {@link #SIGNATURE_NO_MATCH}, + * or {@link #SIGNATURE_UNKNOWN_PACKAGE}. + * + * @see #checkSignatures(int, int) + * @see #SIGNATURE_MATCH + * @see #SIGNATURE_NEITHER_SIGNED + * @see #SIGNATURE_FIRST_NOT_SIGNED + * @see #SIGNATURE_SECOND_NOT_SIGNED + * @see #SIGNATURE_NO_MATCH + * @see #SIGNATURE_UNKNOWN_PACKAGE + */ + public abstract int checkSignatures(int uid1, int uid2); + + /** * Retrieve the names of all packages that are associated with a particular * user id. In most cases, this will be a single package name, the package * that has been assigned that user id. Where there are multiple packages @@ -1429,8 +1458,6 @@ public abstract class PackageManager { * which market the package came from. * * @param packageName The name of the package to query - * - * @hide */ public abstract String getInstallerPackageName(String packageName); diff --git a/core/java/android/content/pm/ProviderInfo.java b/core/java/android/content/pm/ProviderInfo.java index d01460e..d61e95b 100644 --- a/core/java/android/content/pm/ProviderInfo.java +++ b/core/java/android/content/pm/ProviderInfo.java @@ -74,7 +74,11 @@ public final class ProviderInfo extends ComponentInfo * running in the same process. Higher goes first. */ public int initOrder = 0; - /** Whether or not this provider is syncable. */ + /** + * Whether or not this provider is syncable. + * @deprecated This flag is now being ignored. The current way to make a provider + * syncable is to provide a SyncAdapter service for a given provider/account type. + */ public boolean isSyncable = false; public ProviderInfo() { diff --git a/core/java/android/content/pm/RegisteredServicesCache.java b/core/java/android/content/pm/RegisteredServicesCache.java new file mode 100644 index 0000000..342de2b --- /dev/null +++ b/core/java/android/content/pm/RegisteredServicesCache.java @@ -0,0 +1,238 @@ +/* + * Copyright (C) 2009 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.content.pm; + +import android.content.Context; +import android.content.BroadcastReceiver; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.ComponentName; +import android.content.res.XmlResourceParser; +import android.util.Log; +import android.util.AttributeSet; +import android.util.Xml; + +import java.util.Map; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.io.FileDescriptor; +import java.io.PrintWriter; +import java.io.IOException; + +import com.google.android.collect.Maps; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlPullParser; + +/** + * A cache of registered services. This cache + * is built by interrogating the {@link PackageManager} and is updated as packages are added, + * removed and changed. The services are referred to by type V and + * are made available via the {@link #getServiceInfo} method. + * @hide + */ +public abstract class RegisteredServicesCache<V> { + private static final String TAG = "PackageManager"; + + public final Context mContext; + private final String mInterfaceName; + private final String mMetaDataName; + private final String mAttributesName; + + // no need to be synchronized since the map is never changed once mService is written + private volatile Map<V, ServiceInfo<V>> mServices; + + // synchronized on "this" + private BroadcastReceiver mReceiver = null; + + public RegisteredServicesCache(Context context, String interfaceName, String metaDataName, + String attributeName) { + mContext = context; + mInterfaceName = interfaceName; + mMetaDataName = metaDataName; + mAttributesName = attributeName; + } + + public void dump(FileDescriptor fd, PrintWriter fout, String[] args) { + getAllServices(); + Map<V, ServiceInfo<V>> services = mServices; + fout.println("RegisteredServicesCache: " + services.size() + " services"); + for (ServiceInfo info : services.values()) { + fout.println(" " + info); + } + } + + private boolean maybeRegisterForPackageChanges() { + synchronized (this) { + if (mReceiver == null) { + synchronized (this) { + mReceiver = new BroadcastReceiver() { + public void onReceive(Context context, Intent intent) { + mServices = generateServicesMap(); + } + }; + } + + IntentFilter intentFilter = new IntentFilter(); + intentFilter.addAction(Intent.ACTION_PACKAGE_ADDED); + intentFilter.addAction(Intent.ACTION_PACKAGE_CHANGED); + intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED); + mContext.registerReceiver(mReceiver, intentFilter); + return true; + } + return false; + } + } + + private void maybeUnregisterForPackageChanges() { + synchronized (this) { + if (mReceiver != null) { + mContext.unregisterReceiver(mReceiver); + mReceiver = null; + } + } + } + + /** + * Value type that describes a Service. The information within can be used + * to bind to the service. + */ + public static class ServiceInfo<V> { + public final V type; + public final ComponentName componentName; + public final int uid; + + private ServiceInfo(V type, ComponentName componentName, int uid) { + this.type = type; + this.componentName = componentName; + this.uid = uid; + } + + public String toString() { + return "ServiceInfo: " + type + ", " + componentName; + } + } + + /** + * Accessor for the registered authenticators. + * @param type the account type of the authenticator + * @return the AuthenticatorInfo that matches the account type or null if none is present + */ + public ServiceInfo<V> getServiceInfo(V type) { + if (mServices == null) { + maybeRegisterForPackageChanges(); + mServices = generateServicesMap(); + } + return mServices.get(type); + } + + /** + * @return a collection of {@link RegisteredServicesCache.ServiceInfo} objects for all + * registered authenticators. + */ + public Collection<ServiceInfo<V>> getAllServices() { + if (mServices == null) { + maybeRegisterForPackageChanges(); + mServices = generateServicesMap(); + } + return Collections.unmodifiableCollection(mServices.values()); + } + + /** + * Stops the monitoring of package additions, removals and changes. + */ + public void close() { + maybeUnregisterForPackageChanges(); + } + + protected void finalize() throws Throwable { + synchronized (this) { + if (mReceiver != null) { + Log.e(TAG, "RegisteredServicesCache finalized without being closed"); + } + } + close(); + super.finalize(); + } + + private Map<V, ServiceInfo<V>> generateServicesMap() { + Map<V, ServiceInfo<V>> services = Maps.newHashMap(); + PackageManager pm = mContext.getPackageManager(); + + List<ResolveInfo> resolveInfos = + pm.queryIntentServices(new Intent(mInterfaceName), PackageManager.GET_META_DATA); + + for (ResolveInfo resolveInfo : resolveInfos) { + try { + ServiceInfo<V> info = parseServiceInfo(resolveInfo); + if (info != null) { + services.put(info.type, info); + } else { + Log.w(TAG, "Unable to load input method " + resolveInfo.toString()); + } + } catch (XmlPullParserException e) { + Log.w(TAG, "Unable to load input method " + resolveInfo.toString(), e); + } catch (IOException e) { + Log.w(TAG, "Unable to load input method " + resolveInfo.toString(), e); + } + } + + return services; + } + + private ServiceInfo<V> parseServiceInfo(ResolveInfo service) + throws XmlPullParserException, IOException { + android.content.pm.ServiceInfo si = service.serviceInfo; + ComponentName componentName = new ComponentName(si.packageName, si.name); + + PackageManager pm = mContext.getPackageManager(); + + XmlResourceParser parser = null; + try { + parser = si.loadXmlMetaData(pm, mMetaDataName); + if (parser == null) { + throw new XmlPullParserException("No " + mMetaDataName + " meta-data"); + } + + AttributeSet attrs = Xml.asAttributeSet(parser); + + int type; + while ((type=parser.next()) != XmlPullParser.END_DOCUMENT + && type != XmlPullParser.START_TAG) { + } + + String nodeName = parser.getName(); + if (!mAttributesName.equals(nodeName)) { + throw new XmlPullParserException( + "Meta-data does not start with " + mAttributesName + " tag"); + } + + V v = parseServiceAttributes(si.packageName, attrs); + if (v == null) { + return null; + } + final android.content.pm.ServiceInfo serviceInfo = service.serviceInfo; + final ApplicationInfo applicationInfo = serviceInfo.applicationInfo; + final int uid = applicationInfo.uid; + return new ServiceInfo<V>(v, componentName, uid); + } finally { + if (parser != null) parser.close(); + } + } + + public abstract V parseServiceAttributes(String packageName, AttributeSet attrs); +} diff --git a/core/java/android/content/res/Configuration.java b/core/java/android/content/res/Configuration.java index 5f44cc9..cbf8410 100644 --- a/core/java/android/content/res/Configuration.java +++ b/core/java/android/content/res/Configuration.java @@ -93,7 +93,8 @@ public final class Configuration implements Parcelable, Comparable<Configuration /** * The kind of keyboard attached to the device. - * One of: {@link #KEYBOARD_QWERTY}, {@link #KEYBOARD_12KEY}. + * One of: {@link #KEYBOARD_NOKEYS}, {@link #KEYBOARD_QWERTY}, + * {@link #KEYBOARD_12KEY}. */ public int keyboard; @@ -132,8 +133,8 @@ public final class Configuration implements Parcelable, Comparable<Configuration /** * The kind of navigation method available on the device. - * One of: {@link #NAVIGATION_DPAD}, {@link #NAVIGATION_TRACKBALL}, - * {@link #NAVIGATION_WHEEL}. + * One of: {@link #NAVIGATION_NONAV}, {@link #NAVIGATION_DPAD}, + * {@link #NAVIGATION_TRACKBALL}, {@link #NAVIGATION_WHEEL}. */ public int navigation; diff --git a/core/java/android/content/res/Resources.java b/core/java/android/content/res/Resources.java index 2354519..7d412a7 100644 --- a/core/java/android/content/res/Resources.java +++ b/core/java/android/content/res/Resources.java @@ -23,6 +23,7 @@ import org.xmlpull.v1.XmlPullParser; import org.xmlpull.v1.XmlPullParserException; import android.content.pm.ApplicationInfo; +import android.graphics.BitmapFactory; import android.graphics.Movie; import android.graphics.drawable.Drawable; import android.graphics.drawable.ColorDrawable; @@ -1707,7 +1708,8 @@ public class Resources { InputStream is = mAssets.openNonAsset( value.assetCookie, file, AssetManager.ACCESS_BUFFER); // System.out.println("Opened file " + file + ": " + is); - dr = Drawable.createFromResourceStream(this, value, is, file); + dr = Drawable.createFromResourceStream(this, value, is, + file, null); is.close(); // System.out.println("Created stream: " + dr); } catch (Exception e) { diff --git a/core/java/android/content/res/StringBlock.java b/core/java/android/content/res/StringBlock.java index e684cb8..8fb82be 100644 --- a/core/java/android/content/res/StringBlock.java +++ b/core/java/android/content/res/StringBlock.java @@ -202,7 +202,7 @@ final class StringBlock { sub = subtag(tag, ";size="); if (sub != null) { int size = Integer.parseInt(sub); - buffer.setSpan(new AbsoluteSizeSpan(size), + buffer.setSpan(new AbsoluteSizeSpan(size, true), style[i+1], style[i+2]+1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); } @@ -310,7 +310,7 @@ final class StringBlock { * the ascent if possible, or the descent if shrinking the ascent further * will make the text unreadable. */ - private static class Height implements LineHeightSpan { + private static class Height implements LineHeightSpan.WithDensity { private int mSize; private static float sProportion = 0; @@ -321,9 +321,21 @@ final class StringBlock { public void chooseHeight(CharSequence text, int start, int end, int spanstartv, int v, Paint.FontMetricsInt fm) { - if (fm.bottom - fm.top < mSize) { - fm.top = fm.bottom - mSize; - fm.ascent = fm.ascent - mSize; + // Should not get called, at least not by StaticLayout. + chooseHeight(text, start, end, spanstartv, v, fm, null); + } + + public void chooseHeight(CharSequence text, int start, int end, + int spanstartv, int v, + Paint.FontMetricsInt fm, TextPaint paint) { + int size = mSize; + if (paint != null) { + size *= paint.density; + } + + if (fm.bottom - fm.top < size) { + fm.top = fm.bottom - size; + fm.ascent = fm.ascent - size; } else { if (sProportion == 0) { /* @@ -343,27 +355,27 @@ final class StringBlock { int need = (int) Math.ceil(-fm.top * sProportion); - if (mSize - fm.descent >= need) { + if (size - fm.descent >= need) { /* * It is safe to shrink the ascent this much. */ - fm.top = fm.bottom - mSize; - fm.ascent = fm.descent - mSize; - } else if (mSize >= need) { + fm.top = fm.bottom - size; + fm.ascent = fm.descent - size; + } else if (size >= need) { /* * We can't show all the descent, but we can at least * show all the ascent. */ fm.top = fm.ascent = -need; - fm.bottom = fm.descent = fm.top + mSize; + fm.bottom = fm.descent = fm.top + size; } else { /* * Show as much of the ascent as we can, and no descent. */ - fm.top = fm.ascent = -mSize; + fm.top = fm.ascent = -size; fm.bottom = fm.descent = 0; } } diff --git a/core/java/android/database/AbstractWindowedCursor.java b/core/java/android/database/AbstractWindowedCursor.java index 4ac0aef..27a02e2 100644 --- a/core/java/android/database/AbstractWindowedCursor.java +++ b/core/java/android/database/AbstractWindowedCursor.java @@ -166,6 +166,48 @@ public abstract class AbstractWindowedCursor extends AbstractCursor return mWindow.isBlob(mPos, columnIndex); } + public boolean isString(int columnIndex) + { + checkPosition(); + + synchronized(mUpdatedRows) { + if (isFieldUpdated(columnIndex)) { + Object object = getUpdatedField(columnIndex); + return object == null || object instanceof String; + } + } + + return mWindow.isString(mPos, columnIndex); + } + + public boolean isLong(int columnIndex) + { + checkPosition(); + + synchronized(mUpdatedRows) { + if (isFieldUpdated(columnIndex)) { + Object object = getUpdatedField(columnIndex); + return object != null && (object instanceof Integer || object instanceof Long); + } + } + + return mWindow.isLong(mPos, columnIndex); + } + + public boolean isFloat(int columnIndex) + { + checkPosition(); + + synchronized(mUpdatedRows) { + if (isFieldUpdated(columnIndex)) { + Object object = getUpdatedField(columnIndex); + return object != null && (object instanceof Float || object instanceof Double); + } + } + + return mWindow.isFloat(mPos, columnIndex); + } + @Override protected void checkPosition() { diff --git a/core/java/android/database/CursorWindow.java b/core/java/android/database/CursorWindow.java index 8e26730..99db81b 100644 --- a/core/java/android/database/CursorWindow.java +++ b/core/java/android/database/CursorWindow.java @@ -263,7 +263,58 @@ public class CursorWindow extends SQLiteClosable implements Parcelable { } } + /** + * Checks if a field contains a long + * + * @param row the row to read from, row - getStartPosition() being the actual row in the window + * @param col the column to read from + * @return {@code true} if given field is a long + */ + public boolean isLong(int row, int col) { + acquireReference(); + try { + return isInteger_native(row - mStartPos, col); + } finally { + releaseReference(); + } + } + + /** + * Checks if a field contains a float. + * + * @param row the row to read from, row - getStartPosition() being the actual row in the window + * @param col the column to read from + * @return {@code true} if given field is a float + */ + public boolean isFloat(int row, int col) { + acquireReference(); + try { + return isFloat_native(row - mStartPos, col); + } finally { + releaseReference(); + } + } + + /** + * Checks if a field contains either a String or is null. + * + * @param row the row to read from, row - getStartPosition() being the actual row in the window + * @param col the column to read from + * @return {@code true} if given field is {@code NULL} or a String + */ + public boolean isString(int row, int col) { + acquireReference(); + try { + return isString_native(row - mStartPos, col); + } finally { + releaseReference(); + } + } + private native boolean isBlob_native(int row, int col); + private native boolean isString_native(int row, int col); + private native boolean isInteger_native(int row, int col); + private native boolean isFloat_native(int row, int col); /** * Returns a String for the given field. diff --git a/core/java/android/database/DatabaseUtils.java b/core/java/android/database/DatabaseUtils.java index 10f3806..4ca6601 100644 --- a/core/java/android/database/DatabaseUtils.java +++ b/core/java/android/database/DatabaseUtils.java @@ -20,6 +20,7 @@ import org.apache.commons.codec.binary.Hex; import android.content.ContentValues; import android.content.Context; +import android.content.OperationApplicationException; import android.database.sqlite.SQLiteAbortException; import android.database.sqlite.SQLiteConstraintException; import android.database.sqlite.SQLiteDatabase; @@ -82,6 +83,8 @@ public class DatabaseUtils { code = 8; } else if (e instanceof SQLiteException) { code = 9; + } else if (e instanceof OperationApplicationException) { + code = 10; } else { reply.writeException(e); Log.e(TAG, "Writing exception to parcel", e); @@ -123,6 +126,18 @@ public class DatabaseUtils { } } + public static void readExceptionWithOperationApplicationExceptionFromParcel( + Parcel reply) throws OperationApplicationException { + int code = reply.readInt(); + if (code == 0) return; + String msg = reply.readString(); + if (code == 10) { + throw new OperationApplicationException(msg); + } else { + DatabaseUtils.readExceptionFromParcel(reply, msg, code); + } + } + private static final void readExceptionFromParcel(Parcel reply, String msg, int code) { switch (code) { case 2: @@ -211,7 +226,7 @@ public class DatabaseUtils { sb.append(sqlString); sb.append('\''); } - + /** * SQL-escape a string. */ @@ -240,7 +255,7 @@ public class DatabaseUtils { appendEscapedSQLString(sql, value.toString()); } } - + /** * Concatenates two SQL WHERE clauses, handling empty or null values. * @hide @@ -252,12 +267,12 @@ public class DatabaseUtils { if (TextUtils.isEmpty(b)) { return a; } - + return "(" + a + ") AND (" + b + ")"; } - + /** - * return the collation key + * return the collation key * @param name * @return the collation key */ @@ -269,7 +284,7 @@ public class DatabaseUtils { return ""; } } - + /** * return the collation key in hex format * @param name @@ -280,7 +295,7 @@ public class DatabaseUtils { char[] keys = Hex.encodeHex(arr); return new String(keys, 0, getKeyLen(arr) * 2); } - + private static int getKeyLen(byte[] arr) { if (arr[arr.length - 1] != 0) { return arr.length; @@ -289,16 +304,16 @@ public class DatabaseUtils { return arr.length-1; } } - + private static byte[] getCollationKeyInBytes(String name) { if (mColl == null) { mColl = Collator.getInstance(); mColl.setStrength(Collator.PRIMARY); } - return mColl.getCollationKey(name).toByteArray(); + return mColl.getCollationKey(name).toByteArray(); } - - private static Collator mColl = null; + + private static Collator mColl = null; /** * Prints the contents of a Cursor to System.out. The position is restored * after printing. @@ -591,10 +606,12 @@ public class DatabaseUtils { public static long queryNumEntries(SQLiteDatabase db, String table) { Cursor cursor = db.query(table, countProjection, null, null, null, null, null); - cursor.moveToFirst(); - long count = cursor.getLong(0); - cursor.deactivate(); - return count; + try { + cursor.moveToFirst(); + return cursor.getLong(0); + } finally { + cursor.close(); + } } /** diff --git a/core/java/android/database/sqlite/SQLiteQueryBuilder.java b/core/java/android/database/sqlite/SQLiteQueryBuilder.java index 8a63919..af54a71 100644 --- a/core/java/android/database/sqlite/SQLiteQueryBuilder.java +++ b/core/java/android/database/sqlite/SQLiteQueryBuilder.java @@ -355,23 +355,26 @@ public class SQLiteQueryBuilder String groupBy, String having, String sortOrder, String limit) { String[] projection = computeProjection(projectionIn); + StringBuilder where = new StringBuilder(); + if (mWhereClause.length() > 0) { - mWhereClause.append(')'); + where.append(mWhereClause.toString()); + where.append(')'); } // Tack on the user's selection, if present. if (selection != null && selection.length() > 0) { if (mWhereClause.length() > 0) { - mWhereClause.append(" AND "); + where.append(" AND "); } - mWhereClause.append('('); - mWhereClause.append(selection); - mWhereClause.append(')'); + where.append('('); + where.append(selection); + where.append(')'); } return buildQueryString( - mDistinct, mTables, projection, mWhereClause.toString(), + mDistinct, mTables, projection, where.toString(), groupBy, having, sortOrder, limit); } diff --git a/core/java/android/hardware/Camera.java b/core/java/android/hardware/Camera.java index 091bc17..aa3b852 100644 --- a/core/java/android/hardware/Camera.java +++ b/core/java/android/hardware/Camera.java @@ -40,15 +40,16 @@ public class Camera { private static final String TAG = "Camera"; // These match the enums in frameworks/base/include/ui/Camera.h - private static final int CAMERA_MSG_ERROR = 0; - private static final int CAMERA_MSG_SHUTTER = 1; - private static final int CAMERA_MSG_FOCUS = 2; - private static final int CAMERA_MSG_ZOOM = 3; - private static final int CAMERA_MSG_PREVIEW_FRAME = 4; - private static final int CAMERA_MSG_VIDEO_FRAME = 5; - private static final int CAMERA_MSG_POSTVIEW_FRAME = 6; - private static final int CAMERA_MSG_RAW_IMAGE = 7; - private static final int CAMERA_MSG_COMPRESSED_IMAGE = 8; + private static final int CAMERA_MSG_ERROR = 0x001; + private static final int CAMERA_MSG_SHUTTER = 0x002; + private static final int CAMERA_MSG_FOCUS = 0x004; + private static final int CAMERA_MSG_ZOOM = 0x008; + private static final int CAMERA_MSG_PREVIEW_FRAME = 0x010; + private static final int CAMERA_MSG_VIDEO_FRAME = 0x020; + private static final int CAMERA_MSG_POSTVIEW_FRAME = 0x040; + private static final int CAMERA_MSG_RAW_IMAGE = 0x080; + private static final int CAMERA_MSG_COMPRESSED_IMAGE = 0x100; + private static final int CAMERA_MSG_ALL_MSGS = 0x1FF; private int mNativeContext; // accessed by native methods private EventHandler mEventHandler; @@ -56,7 +57,9 @@ public class Camera { private PictureCallback mRawImageCallback; private PictureCallback mJpegCallback; private PreviewCallback mPreviewCallback; + private PictureCallback mPostviewCallback; private AutoFocusCallback mAutoFocusCallback; + private ZoomCallback mZoomCallback; private ErrorCallback mErrorCallback; private boolean mOneShot; @@ -72,6 +75,8 @@ public class Camera { mRawImageCallback = null; mJpegCallback = null; mPreviewCallback = null; + mPostviewCallback = null; + mZoomCallback = null; Looper looper; if ((looper = Looper.myLooper()) != null) { @@ -245,13 +250,15 @@ public class Camera { return; case CAMERA_MSG_RAW_IMAGE: - if (mRawImageCallback != null) + if (mRawImageCallback != null) { mRawImageCallback.onPictureTaken((byte[])msg.obj, mCamera); + } return; case CAMERA_MSG_COMPRESSED_IMAGE: - if (mJpegCallback != null) + if (mJpegCallback != null) { mJpegCallback.onPictureTaken((byte[])msg.obj, mCamera); + } return; case CAMERA_MSG_PREVIEW_FRAME: @@ -263,15 +270,29 @@ public class Camera { } return; + case CAMERA_MSG_POSTVIEW_FRAME: + if (mPostviewCallback != null) { + mPostviewCallback.onPictureTaken((byte[])msg.obj, mCamera); + } + return; + case CAMERA_MSG_FOCUS: - if (mAutoFocusCallback != null) + if (mAutoFocusCallback != null) { mAutoFocusCallback.onAutoFocus(msg.arg1 == 0 ? false : true, mCamera); + } + return; + + case CAMERA_MSG_ZOOM: + if (mZoomCallback != null) { + mZoomCallback.onZoomUpdate(msg.arg1, mCamera); + } return; case CAMERA_MSG_ERROR : Log.e(TAG, "Error " + msg.arg1); - if (mErrorCallback != null) + if (mErrorCallback != null) { mErrorCallback.onError(msg.arg1, mCamera); + } return; default: @@ -364,13 +385,63 @@ public class Camera { */ public final void takePicture(ShutterCallback shutter, PictureCallback raw, PictureCallback jpeg) { + takePicture(shutter, raw, null, jpeg); + } + private native final void native_takePicture(); + + /** + * Triggers an asynchronous image capture. The camera service + * will initiate a series of callbacks to the application as the + * image capture progresses. The shutter callback occurs after + * the image is captured. This can be used to trigger a sound + * to let the user know that image has been captured. The raw + * callback occurs when the raw image data is available. The + * postview callback occurs when a scaled, fully processed + * postview image is available (NOTE: not all hardware supports + * this). The jpeg callback occurs when the compressed image is + * available. If the application does not need a particular + * callback, a null can be passed instead of a callback method. + * + * @param shutter callback after the image is captured, may be null + * @param raw callback with raw image data, may be null + * @param postview callback with postview image data, may be null + * @param jpeg callback with jpeg image data, may be null + */ + public final void takePicture(ShutterCallback shutter, PictureCallback raw, + PictureCallback postview, PictureCallback jpeg) { mShutterCallback = shutter; mRawImageCallback = raw; + mPostviewCallback = postview; mJpegCallback = jpeg; native_takePicture(); } - private native final void native_takePicture(); + /** + * Handles the zoom callback. + */ + public interface ZoomCallback + { + /** + * Callback for zoom updates + * @param zoomLevel new zoom level in 1/1000 increments, + * e.g. a zoom of 3.2x is stored as 3200. Accuracy of the + * value is dependent on the hardware implementation. Not + * all devices will generate this callback. + * @param camera the Camera service object + */ + void onZoomUpdate(int zoomLevel, Camera camera); + }; + + /** + * Registers a callback to be invoked when the zoom + * level is updated by the camera driver. + * @param cb the callback to run + */ + public final void setZoomCallback(ZoomCallback cb) + { + mZoomCallback = cb; + } + // These match the enum in include/ui/Camera.h /** Unspecified camerar error. @see #ErrorCallback */ public static final int CAMERA_ERROR_UNKNOWN = 1; diff --git a/core/java/android/inputmethodservice/InputMethodService.java b/core/java/android/inputmethodservice/InputMethodService.java index 6ee92ce..1f640ea 100644 --- a/core/java/android/inputmethodservice/InputMethodService.java +++ b/core/java/android/inputmethodservice/InputMethodService.java @@ -1992,8 +1992,9 @@ public class InputMethodService extends AbstractInputMethodService { req.flags = InputConnection.GET_TEXT_WITH_STYLES; req.hintMaxLines = 10; req.hintMaxChars = 10000; - mExtractedText = getCurrentInputConnection().getExtractedText(req, - InputConnection.GET_EXTRACTED_TEXT_MONITOR); + InputConnection ic = getCurrentInputConnection(); + mExtractedText = ic == null? null + : ic.getExtractedText(req, InputConnection.GET_EXTRACTED_TEXT_MONITOR); final EditorInfo ei = getCurrentInputEditorInfo(); diff --git a/core/java/android/inputmethodservice/Keyboard.java b/core/java/android/inputmethodservice/Keyboard.java index fea63be..4814b0a 100755 --- a/core/java/android/inputmethodservice/Keyboard.java +++ b/core/java/android/inputmethodservice/Keyboard.java @@ -142,7 +142,7 @@ public class Keyboard { private int[][] mGridNeighbors; private int mProximityThreshold; /** Number of key widths from current touch point to search for nearest keys. */ - private static float SEARCH_DISTANCE = 1.4f; + private static float SEARCH_DISTANCE = 1.8f; /** * Container for keys in the keyboard. All keys in a row are at the same Y-coordinate. diff --git a/core/java/android/inputmethodservice/KeyboardView.java b/core/java/android/inputmethodservice/KeyboardView.java index 9c9c143..a141a2a 100755 --- a/core/java/android/inputmethodservice/KeyboardView.java +++ b/core/java/android/inputmethodservice/KeyboardView.java @@ -30,7 +30,6 @@ import android.graphics.drawable.Drawable; import android.inputmethodservice.Keyboard.Key; import android.os.Handler; import android.os.Message; -import android.os.SystemClock; import android.util.AttributeSet; import android.util.TypedValue; import android.view.GestureDetector; @@ -38,6 +37,7 @@ import android.view.Gravity; import android.view.LayoutInflater; import android.view.MotionEvent; import android.view.View; +import android.view.ViewConfiguration; import android.view.ViewGroup.LayoutParams; import android.widget.PopupWindow; import android.widget.TextView; @@ -163,8 +163,8 @@ public class KeyboardView extends View implements View.OnClickListener { private static final int MSG_REPEAT = 3; private static final int MSG_LONGPRESS = 4; - private static final int DELAY_BEFORE_PREVIEW = 40; - private static final int DELAY_AFTER_PREVIEW = 60; + private static final int DELAY_BEFORE_PREVIEW = 0; + private static final int DELAY_AFTER_PREVIEW = 70; private int mVerticalCorrection; private int mProximityThreshold; @@ -202,13 +202,17 @@ public class KeyboardView extends View implements View.OnClickListener { private boolean mAbortKey; private Key mInvalidatedKey; private Rect mClipRegion = new Rect(0, 0, 0, 0); - + + // Variables for dealing with multiple pointers + private int mOldPointerCount = 1; + private float mOldPointerX; + private float mOldPointerY; + private Drawable mKeyBackground; private static final int REPEAT_INTERVAL = 50; // ~20 keys per second private static final int REPEAT_START_DELAY = 400; - private static final int LONGPRESS_TIMEOUT = 800; - // Deemed to be too short : ViewConfiguration.getLongPressTimeout(); + private static final int LONGPRESS_TIMEOUT = ViewConfiguration.getLongPressTimeout(); private static int MAX_NEARBY_KEYS = 12; private int[] mDistances = new int[MAX_NEARBY_KEYS]; @@ -227,6 +231,8 @@ public class KeyboardView extends View implements View.OnClickListener { private Rect mDirtyRect = new Rect(); /** The keyboard bitmap for faster updates */ private Bitmap mBuffer; + /** Notes if the keyboard just changed, so that we could possibly reallocate the mBuffer. */ + private boolean mKeyboardChanged; /** The canvas for the above mutable keyboard bitmap */ private Canvas mCanvas; @@ -340,6 +346,7 @@ public class KeyboardView extends View implements View.OnClickListener { mPaint.setAntiAlias(true); mPaint.setTextSize(keyTextSize); mPaint.setTextAlign(Align.CENTER); + mPaint.setAlpha(255); mPadding = new Rect(0, 0, 0, 0); mMiniKeyboardCache = new HashMap<Key,View>(); @@ -405,12 +412,14 @@ public class KeyboardView extends View implements View.OnClickListener { List<Key> keys = mKeyboard.getKeys(); mKeys = keys.toArray(new Key[keys.size()]); requestLayout(); - // Release buffer, just in case the new keyboard has a different size. - // It will be reallocated on the next draw. - mBuffer = null; + // Hint to reallocate the buffer if the size changed + mKeyboardChanged = true; invalidateAllKeys(); computeProximityThreshold(keyboard); mMiniKeyboardCache.clear(); // Not really necessary to do every time, but will free up views + // Switching to a different keyboard should abort any pending keys so that the key up + // doesn't get delivered to the old or new keyboard + mAbortKey = true; // Until the next ACTION_DOWN } /** @@ -564,17 +573,21 @@ public class KeyboardView extends View implements View.OnClickListener { @Override public void onDraw(Canvas canvas) { super.onDraw(canvas); - if (mDrawPending || mBuffer == null) { + if (mDrawPending || mBuffer == null || mKeyboardChanged) { onBufferDraw(); } canvas.drawBitmap(mBuffer, 0, 0, null); } - + private void onBufferDraw() { - if (mBuffer == null) { - mBuffer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); - mCanvas = new Canvas(mBuffer); + if (mBuffer == null || mKeyboardChanged) { + if (mBuffer == null || mKeyboardChanged && + (mBuffer.getWidth() != getWidth() || mBuffer.getHeight() != getHeight())) { + mBuffer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888); + mCanvas = new Canvas(mBuffer); + } invalidateAllKeys(); + mKeyboardChanged = false; } final Canvas canvas = mCanvas; canvas.clipRect(mDirtyRect, Op.REPLACE); @@ -590,7 +603,6 @@ public class KeyboardView extends View implements View.OnClickListener { final Key[] keys = mKeys; final Key invalidKey = mInvalidatedKey; - paint.setAlpha(255); paint.setColor(mKeyTextColor); boolean drawSingleKey = false; if (invalidKey != null && canvas.getClipBounds(clipRegion)) { @@ -611,7 +623,7 @@ public class KeyboardView extends View implements View.OnClickListener { } int[] drawableState = key.getCurrentDrawableState(); keyBackground.setState(drawableState); - + // Switch the character to uppercase if shift is pressed String label = key.label == null? null : adjustCase(key.label).toString(); @@ -680,7 +692,6 @@ public class KeyboardView extends View implements View.OnClickListener { private int getKeyIndices(int x, int y, int[] allKeys) { final Key[] keys = mKeys; - final boolean shifted = mKeyboard.isShifted(); int primaryIndex = NOT_A_KEY; int closestKey = NOT_A_KEY; int closestKeyDist = mProximityThreshold + 1; @@ -1011,19 +1022,56 @@ public class KeyboardView extends View implements View.OnClickListener { } return false; } - + @Override public boolean onTouchEvent(MotionEvent me) { + // Convert multi-pointer up/down events to single up/down events to + // deal with the typical multi-pointer behavior of two-thumb typing + int pointerCount = me.getPointerCount(); + boolean result = false; + if (pointerCount != mOldPointerCount) { + long now = me.getEventTime(); + if (pointerCount == 1) { + // Send a down event for the latest pointer + MotionEvent down = MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN, + me.getX(), me.getY(), me.getMetaState()); + result = onModifiedTouchEvent(down); + down.recycle(); + // If it's an up action, then deliver the up as well. + if (me.getAction() == MotionEvent.ACTION_UP) { + result = onModifiedTouchEvent(me); + } + } else { + // Send an up event for the last pointer + MotionEvent up = MotionEvent.obtain(now, now, MotionEvent.ACTION_UP, + mOldPointerX, mOldPointerY, me.getMetaState()); + result = onModifiedTouchEvent(up); + up.recycle(); + } + } else { + if (pointerCount == 1) { + mOldPointerX = me.getX(); + mOldPointerY = me.getY(); + result = onModifiedTouchEvent(me); + } else { + // Don't do anything when 2 pointers are down and moving. + result = true; + } + } + mOldPointerCount = pointerCount; + return result; + } + + private boolean onModifiedTouchEvent(MotionEvent me) { int touchX = (int) me.getX() - mPaddingLeft; int touchY = (int) me.getY() + mVerticalCorrection - mPaddingTop; int action = me.getAction(); long eventTime = me.getEventTime(); int keyIndex = getKeyIndices(touchX, touchY, null); - if (mGestureDetector.onTouchEvent(me)) { showPreview(NOT_A_KEY); mHandler.removeMessages(MSG_REPEAT); - mHandler.removeMessages(MSG_LONGPRESS); + mHandler.removeMessages(MSG_LONGPRESS); return true; } @@ -1072,7 +1120,7 @@ public class KeyboardView extends View implements View.OnClickListener { if (keyIndex == mCurrentKey) { mCurrentKeyTime += eventTime - mLastMoveTime; continueLongPress = true; - } else { + } else if (mRepeatKeyIndex == NOT_A_KEY) { resetMultiTap(); mLastKey = mCurrentKey; mLastCodeX = mLastX; @@ -1083,10 +1131,6 @@ public class KeyboardView extends View implements View.OnClickListener { mCurrentKeyTime = 0; } } - if (keyIndex != mRepeatKeyIndex) { - mHandler.removeMessages(MSG_REPEAT); - mRepeatKeyIndex = NOT_A_KEY; - } } if (!continueLongPress) { // Cancel old longpress @@ -1097,7 +1141,7 @@ public class KeyboardView extends View implements View.OnClickListener { mHandler.sendMessageDelayed(msg, LONGPRESS_TIMEOUT); } } - showPreview(keyIndex); + showPreview(mCurrentKey); break; case MotionEvent.ACTION_UP: diff --git a/core/java/android/net/ConnectivityManager.java b/core/java/android/net/ConnectivityManager.java index 1429bc1..a127df0 100644 --- a/core/java/android/net/ConnectivityManager.java +++ b/core/java/android/net/ConnectivityManager.java @@ -18,6 +18,7 @@ package android.net; import android.annotation.SdkConstant; import android.annotation.SdkConstant.SdkConstantType; +import android.os.Binder; import android.os.RemoteException; /** @@ -114,15 +115,64 @@ public class ConnectivityManager public static final String ACTION_BACKGROUND_DATA_SETTING_CHANGED = "android.net.conn.BACKGROUND_DATA_SETTING_CHANGED"; - public static final int TYPE_MOBILE = 0; - public static final int TYPE_WIFI = 1; + /** + * The Default Mobile data connection. When active, all data traffic + * will use this connection by default. Should not coexist with other + * default connections. + */ + public static final int TYPE_MOBILE = 0; + /** + * The Default WIFI data connection. When active, all data traffic + * will use this connection by default. Should not coexist with other + * default connections. + */ + public static final int TYPE_WIFI = 1; + /** + * An MMS-specific Mobile data connection. This connection may be the + * same as {@link #TYPEMOBILE} but it may be different. This is used + * by applications needing to talk to the carrier's Multimedia Messaging + * Service servers. It may coexist with default data connections. + * {@hide} + */ + public static final int TYPE_MOBILE_MMS = 2; + /** + * A SUPL-specific Mobile data connection. This connection may be the + * same as {@link #TYPEMOBILE} but it may be different. This is used + * by applications needing to talk to the carrier's Secure User Plane + * Location servers for help locating the device. It may coexist with + * default data connections. + * {@hide} + */ + public static final int TYPE_MOBILE_SUPL = 3; + /** + * A DUN-specific Mobile data connection. This connection may be the + * same as {@link #TYPEMOBILE} but it may be different. This is used + * by applicaitons performing a Dial Up Networking bridge so that + * the carrier is aware of DUN traffic. It may coexist with default data + * connections. + * {@hide} + */ + public static final int TYPE_MOBILE_DUN = 4; + /** + * A High Priority Mobile data connection. This connection is typically + * the same as {@link #TYPEMOBILE} but the routing setup is different. + * Only requesting processes will have access to the Mobile DNS servers + * and only IP's explicitly requested via {@link #requestRouteToHost} + * will route over this interface. + *{@hide} + */ + public static final int TYPE_MOBILE_HIPRI = 5; + /** {@hide} */ + public static final int MAX_RADIO_TYPE = TYPE_WIFI; + /** {@hide} */ + public static final int MAX_NETWORK_TYPE = TYPE_MOBILE_HIPRI; public static final int DEFAULT_NETWORK_PREFERENCE = TYPE_WIFI; private IConnectivityManager mService; static public boolean isNetworkTypeValid(int networkType) { - return networkType == TYPE_WIFI || networkType == TYPE_MOBILE; + return networkType >= 0 && networkType <= MAX_NETWORK_TYPE; } public void setNetworkPreference(int preference) { @@ -195,7 +245,8 @@ public class ConnectivityManager */ public int startUsingNetworkFeature(int networkType, String feature) { try { - return mService.startUsingNetworkFeature(networkType, feature); + return mService.startUsingNetworkFeature(networkType, feature, + new Binder()); } catch (RemoteException e) { return -1; } diff --git a/core/java/android/net/IConnectivityManager.aidl b/core/java/android/net/IConnectivityManager.aidl index de68598..9f59cce 100644 --- a/core/java/android/net/IConnectivityManager.aidl +++ b/core/java/android/net/IConnectivityManager.aidl @@ -17,6 +17,7 @@ package android.net; import android.net.NetworkInfo; +import android.os.IBinder; /** * Interface that answers queries about, and allows changing, the @@ -39,7 +40,8 @@ interface IConnectivityManager boolean setRadio(int networkType, boolean turnOn); - int startUsingNetworkFeature(int networkType, in String feature); + int startUsingNetworkFeature(int networkType, in String feature, + in IBinder binder); int stopUsingNetworkFeature(int networkType, in String feature); diff --git a/core/java/android/net/MobileDataStateTracker.java b/core/java/android/net/MobileDataStateTracker.java index 1064fb6..3e4bbd5 100644 --- a/core/java/android/net/MobileDataStateTracker.java +++ b/core/java/android/net/MobileDataStateTracker.java @@ -32,9 +32,6 @@ import android.telephony.TelephonyManager; import android.util.Log; import android.text.TextUtils; -import java.util.List; -import java.util.ArrayList; - /** * Track the state of mobile data connectivity. This is done by * receiving broadcast intents from the Phone process whenever @@ -45,36 +42,48 @@ import java.util.ArrayList; public class MobileDataStateTracker extends NetworkStateTracker { private static final String TAG = "MobileDataStateTracker"; - private static final boolean DBG = false; + private static final boolean DBG = true; private Phone.DataState mMobileDataState; private ITelephony mPhoneService; - private static final String[] sDnsPropNames = { - "net.rmnet0.dns1", - "net.rmnet0.dns2", - "net.eth0.dns1", - "net.eth0.dns2", - "net.eth0.dns3", - "net.eth0.dns4", - "net.gprs.dns1", - "net.gprs.dns2" - }; - private List<String> mDnsServers; - private String mInterfaceName; - private int mDefaultGatewayAddr; - private int mLastCallingPid = -1; + + private String mApnType; + private boolean mEnabled; + private BroadcastReceiver mStateReceiver; /** * Create a new MobileDataStateTracker * @param context the application context of the caller * @param target a message handler for getting callbacks about state changes + * @param netType the ConnectivityManager network type + * @param apnType the Phone apnType + * @param tag the name of this network */ - public MobileDataStateTracker(Context context, Handler target) { - super(context, target, ConnectivityManager.TYPE_MOBILE, - TelephonyManager.getDefault().getNetworkType(), "MOBILE", - TelephonyManager.getDefault().getNetworkTypeName()); + public MobileDataStateTracker(Context context, Handler target, + int netType, String apnType, String tag) { + super(context, target, netType, + TelephonyManager.getDefault().getNetworkType(), tag, + TelephonyManager.getDefault().getNetworkTypeName()); + mApnType = apnType; mPhoneService = null; - mDnsServers = new ArrayList<String>(); + if(netType == ConnectivityManager.TYPE_MOBILE) { + mEnabled = true; + } else { + mEnabled = false; + } + + mDnsPropNames = new String[] { + "net.rmnet0.dns1", + "net.rmnet0.dns2", + "net.eth0.dns1", + "net.eth0.dns2", + "net.eth0.dns3", + "net.eth0.dns4", + "net.gprs.dns1", + "net.gprs.dns2", + "net.ppp0.dns1", + "net.ppp0.dns2"}; + } /** @@ -86,105 +95,126 @@ public class MobileDataStateTracker extends NetworkStateTracker { filter.addAction(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED); filter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED); - Intent intent = mContext.registerReceiver(new MobileDataStateReceiver(), filter); + mStateReceiver = new MobileDataStateReceiver(); + Intent intent = mContext.registerReceiver(mStateReceiver, filter); if (intent != null) mMobileDataState = getMobileDataState(intent); else mMobileDataState = Phone.DataState.DISCONNECTED; } - private static Phone.DataState getMobileDataState(Intent intent) { + private Phone.DataState getMobileDataState(Intent intent) { String str = intent.getStringExtra(Phone.STATE_KEY); - if (str != null) - return Enum.valueOf(Phone.DataState.class, str); - else - return Phone.DataState.DISCONNECTED; - } - - private class MobileDataStateReceiver extends BroadcastReceiver { - public void onReceive(Context context, Intent intent) { - if (intent.getAction().equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) { - Phone.DataState state = getMobileDataState(intent); - String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY); - String apnName = intent.getStringExtra(Phone.DATA_APN_KEY); - boolean unavailable = intent.getBooleanExtra(Phone.NETWORK_UNAVAILABLE_KEY, false); - if (DBG) Log.d(TAG, "Received " + intent.getAction() + - " broadcast - state = " + state - + ", unavailable = " + unavailable - + ", reason = " + (reason == null ? "(unspecified)" : reason)); - mNetworkInfo.setIsAvailable(!unavailable); - if (mMobileDataState != state) { - mMobileDataState = state; - - switch (state) { - case DISCONNECTED: - setDetailedState(DetailedState.DISCONNECTED, reason, apnName); - if (mInterfaceName != null) { - NetworkUtils.resetConnections(mInterfaceName); - } - mInterfaceName = null; - mDefaultGatewayAddr = 0; - break; - case CONNECTING: - setDetailedState(DetailedState.CONNECTING, reason, apnName); - break; - case SUSPENDED: - setDetailedState(DetailedState.SUSPENDED, reason, apnName); - break; - case CONNECTED: - mInterfaceName = intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY); - if (mInterfaceName == null) { - Log.d(TAG, "CONNECTED event did not supply interface name."); - } - setupDnsProperties(); - setDetailedState(DetailedState.CONNECTED, reason, apnName); - break; - } - } - } else if (intent.getAction().equals(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED)) { - String reason = intent.getStringExtra(Phone.FAILURE_REASON_KEY); - String apnName = intent.getStringExtra(Phone.DATA_APN_KEY); - if (DBG) Log.d(TAG, "Received " + intent.getAction() + " broadcast" + - reason == null ? "" : "(" + reason + ")"); - setDetailedState(DetailedState.FAILED, reason, apnName); + if (str != null) { + String apnTypeList = + intent.getStringExtra(Phone.DATA_APN_TYPES_KEY); + if (isApnTypeIncluded(apnTypeList)) { + return Enum.valueOf(Phone.DataState.class, str); } - TelephonyManager tm = TelephonyManager.getDefault(); - setRoamingStatus(tm.isNetworkRoaming()); - setSubtype(tm.getNetworkType(), tm.getNetworkTypeName()); } + return Phone.DataState.DISCONNECTED; } - /** - * Make sure that route(s) exist to the carrier DNS server(s). - */ - public void addPrivateRoutes() { - if (mInterfaceName != null) { - for (String addrString : mDnsServers) { - int addr = NetworkUtils.lookupHost(addrString); - if (addr != -1) { - NetworkUtils.addHostRoute(mInterfaceName, addr); - } - } - } - } + private boolean isApnTypeIncluded(String typeList) { + /* comma seperated list - split and check */ + if (typeList == null) + return false; - public void removePrivateRoutes() { - if(mInterfaceName != null) { - NetworkUtils.removeHostRoutes(mInterfaceName); + String[] list = typeList.split(","); + for(int i=0; i< list.length; i++) { + if (TextUtils.equals(list[i], mApnType) || + TextUtils.equals(list[i], Phone.APN_TYPE_ALL)) { + return true; + } } + return false; } - public void removeDefaultRoute() { - if(mInterfaceName != null) { - mDefaultGatewayAddr = NetworkUtils.getDefaultRoute(mInterfaceName); - NetworkUtils.removeDefaultRoute(mInterfaceName); - } - } + private class MobileDataStateReceiver extends BroadcastReceiver { + public void onReceive(Context context, Intent intent) { + synchronized(this) { + if (intent.getAction().equals(TelephonyIntents. + ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) { + Phone.DataState state = getMobileDataState(intent); + String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY); + String apnName = intent.getStringExtra(Phone.DATA_APN_KEY); + String apnTypeList = intent.getStringExtra(Phone.DATA_APN_TYPES_KEY); + + boolean unavailable = intent.getBooleanExtra(Phone.NETWORK_UNAVAILABLE_KEY, + false); + if (DBG) Log.d(TAG, mApnType + " Received " + intent.getAction() + + " broadcast - state = " + state + ", oldstate = " + mMobileDataState + + ", unavailable = " + unavailable + ", reason = " + + (reason == null ? "(unspecified)" : reason)); + + if (isApnTypeIncluded(apnTypeList)) { + if (mEnabled == false) { + // if we're not enabled but the APN Type is supported by this connection + // we should record the interface name if one's provided. If the user + // turns on this network we will need the interfacename but won't get + // a fresh connected message - TODO fix this.. + if (state == Phone.DataState.CONNECTED) { + if (DBG) Log.d(TAG, "replacing old mInterfaceName (" + + mInterfaceName + ") with " + + intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY) + + " for " + mApnType); + mInterfaceName = intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY); + } + if (DBG) Log.d(TAG, " dropped - mEnabled = false"); + return; + } + } else { + if (DBG) Log.d(TAG, " dropped - wrong Apn"); + return; + } - public void restoreDefaultRoute() { - // 0 is not a valid address for a gateway - if (mInterfaceName != null && mDefaultGatewayAddr != 0) { - NetworkUtils.setDefaultRoute(mInterfaceName, mDefaultGatewayAddr); + mNetworkInfo.setIsAvailable(!unavailable); + if (mMobileDataState != state) { + mMobileDataState = state; + switch (state) { + case DISCONNECTED: + if(isTeardownRequested()) { + mEnabled = false; + setTeardownRequested(false); + } + + setDetailedState(DetailedState.DISCONNECTED, reason, apnName); + if (mInterfaceName != null) { + NetworkUtils.resetConnections(mInterfaceName); + } + if (DBG) Log.d(TAG, "clearing mInterfaceName for "+ mApnType + + " as it DISCONNECTED"); + mInterfaceName = null; + mDefaultGatewayAddr = 0; + break; + case CONNECTING: + setDetailedState(DetailedState.CONNECTING, reason, apnName); + break; + case SUSPENDED: + setDetailedState(DetailedState.SUSPENDED, reason, apnName); + break; + case CONNECTED: + mInterfaceName = intent.getStringExtra(Phone.DATA_IFACE_NAME_KEY); + if (mInterfaceName == null) { + Log.d(TAG, "CONNECTED event did not supply interface name."); + } + setDetailedState(DetailedState.CONNECTED, reason, apnName); + break; + } + } + } else if (intent.getAction(). + equals(TelephonyIntents.ACTION_DATA_CONNECTION_FAILED)) { + mEnabled = false; + String reason = intent.getStringExtra(Phone.FAILURE_REASON_KEY); + String apnName = intent.getStringExtra(Phone.DATA_APN_KEY); + if (DBG) Log.d(TAG, "Received " + intent.getAction() + " broadcast" + + reason == null ? "" : "(" + reason + ")"); + setDetailedState(DetailedState.FAILED, reason, apnName); + } + TelephonyManager tm = TelephonyManager.getDefault(); + setRoamingStatus(tm.isNetworkRoaming()); + setSubtype(tm.getNetworkType(), tm.getNetworkTypeName()); + } } } @@ -219,15 +249,6 @@ public class MobileDataStateTracker extends NetworkStateTracker { } /** - * Return the IP addresses of the DNS servers available for the mobile data - * network interface. - * @return a list of DNS addresses, with no holes. - */ - public String[] getNameServers() { - return getNameServerList(sDnsPropNames); - } - - /** * {@inheritDoc} * The mobile data network subtype indicates what generation network technology is in effect, * e.g., GPRS, EDGE, UMTS, etc. @@ -254,9 +275,21 @@ public class MobileDataStateTracker extends NetworkStateTracker { case TelephonyManager.NETWORK_TYPE_UMTS: networkTypeStr = "umts"; break; + case TelephonyManager.NETWORK_TYPE_HSDPA: + networkTypeStr = "hsdpa"; + break; + case TelephonyManager.NETWORK_TYPE_HSUPA: + networkTypeStr = "hsupa"; + break; + case TelephonyManager.NETWORK_TYPE_HSPA: + networkTypeStr = "hspa"; + break; case TelephonyManager.NETWORK_TYPE_CDMA: networkTypeStr = "cdma"; break; + case TelephonyManager.NETWORK_TYPE_1xRTT: + networkTypeStr = "1xrtt"; + break; case TelephonyManager.NETWORK_TYPE_EVDO_0: networkTypeStr = "evdo"; break; @@ -273,54 +306,50 @@ public class MobileDataStateTracker extends NetworkStateTracker { */ @Override public boolean teardown() { - getPhoneService(false); - /* - * If the phone process has crashed in the past, we'll get a - * RemoteException and need to re-reference the service. - */ - for (int retry = 0; retry < 2; retry++) { - if (mPhoneService == null) { - Log.w(TAG, - "Ignoring mobile data teardown request because could not acquire PhoneService"); - break; - } - - try { - return mPhoneService.disableDataConnectivity(); - } catch (RemoteException e) { - if (retry == 0) getPhoneService(true); - } - } - - Log.w(TAG, "Failed to tear down mobile data connectivity"); - return false; + setTeardownRequested(true); + return (setEnableApn(mApnType, false) != Phone.APN_REQUEST_FAILED); } /** * Re-enable mobile data connectivity after a {@link #teardown()}. */ public boolean reconnect() { - getPhoneService(false); - /* - * If the phone process has crashed in the past, we'll get a - * RemoteException and need to re-reference the service. - */ - for (int retry = 0; retry < 2; retry++) { - if (mPhoneService == null) { - Log.w(TAG, - "Ignoring mobile data connect request because could not acquire PhoneService"); + setTeardownRequested(false); + switch (setEnableApn(mApnType, true)) { + case Phone.APN_ALREADY_ACTIVE: + mEnabled = true; + // need to set self to CONNECTING so the below message is handled. + mMobileDataState = Phone.DataState.CONNECTING; + //send out a connected message + Intent intent = new Intent(TelephonyIntents. + ACTION_ANY_DATA_CONNECTION_STATE_CHANGED); + intent.putExtra(Phone.STATE_KEY, Phone.DataState.CONNECTED.toString()); + intent.putExtra(Phone.STATE_CHANGE_REASON_KEY, Phone.REASON_APN_CHANGED); + intent.putExtra(Phone.DATA_APN_TYPES_KEY, mApnType); + intent.putExtra(Phone.DATA_IFACE_NAME_KEY, mInterfaceName); + intent.putExtra(Phone.NETWORK_UNAVAILABLE_KEY, false); + if (mStateReceiver != null) mStateReceiver.onReceive(mContext, intent); + break; + case Phone.APN_REQUEST_STARTED: + mEnabled = true; + // no need to do anything - we're already due some status update intents + break; + case Phone.APN_REQUEST_FAILED: + if (mPhoneService == null && mApnType == Phone.APN_TYPE_DEFAULT) { + // on startup we may try to talk to the phone before it's ready + // just leave mEnabled as it is for the default apn. + return false; + } + // else fall through + case Phone.APN_TYPE_NOT_AVAILABLE: + mEnabled = false; + break; + default: + Log.e(TAG, "Error in reconnect - unexpected response."); + mEnabled = false; break; - } - - try { - return mPhoneService.enableDataConnectivity(); - } catch (RemoteException e) { - if (retry == 0) getPhoneService(true); - } } - - Log.w(TAG, "Failed to set up mobile data connectivity"); - return false; + return mEnabled; } /** @@ -374,14 +403,7 @@ public class MobileDataStateTracker extends NetworkStateTracker { * </ul> */ public int startUsingNetworkFeature(String feature, int callingPid, int callingUid) { - if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) { - mLastCallingPid = callingPid; - return setEnableApn(Phone.APN_TYPE_MMS, true); - } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_SUPL)) { - return setEnableApn(Phone.APN_TYPE_SUPL, true); - } else { - return -1; - } + return -1; } /** @@ -397,13 +419,7 @@ public class MobileDataStateTracker extends NetworkStateTracker { * the value {@code -1} always indicates failure. */ public int stopUsingNetworkFeature(String feature, int callingPid, int callingUid) { - if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) { - return setEnableApn(Phone.APN_TYPE_MMS, false); - } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_SUPL)) { - return setEnableApn(Phone.APN_TYPE_SUPL, false); - } else { - return -1; - } + return -1; } /** @@ -415,10 +431,11 @@ public class MobileDataStateTracker extends NetworkStateTracker { */ @Override public boolean requestRouteToHost(int hostAddress) { + if (DBG) { + Log.d(TAG, "Requested host route to " + Integer.toHexString(hostAddress) + + " for " + mApnType + "(" + mInterfaceName + ")"); + } if (mInterfaceName != null && hostAddress != -1) { - if (DBG) { - Log.d(TAG, "Requested host route to " + Integer.toHexString(hostAddress)); - } return NetworkUtils.addHostRoute(mInterfaceName, hostAddress) == 0; } else { return false; @@ -433,43 +450,6 @@ public class MobileDataStateTracker extends NetworkStateTracker { return sb.toString(); } - private void setupDnsProperties() { - mDnsServers.clear(); - // Set up per-process DNS server list on behalf of the MMS process - int i = 1; - if (mInterfaceName != null) { - for (String propName : sDnsPropNames) { - if (propName.indexOf(mInterfaceName) != -1) { - String propVal = SystemProperties.get(propName); - if (propVal != null && propVal.length() != 0 && !propVal.equals("0.0.0.0")) { - mDnsServers.add(propVal); - if (mLastCallingPid != -1) { - SystemProperties.set("net.dns" + i + "." + mLastCallingPid, propVal); - } - ++i; - } - } - } - } - if (i == 1) { - Log.d(TAG, "DNS server addresses are not known."); - } else if (mLastCallingPid != -1) { - /* - * Bump the property that tells the name resolver library - * to reread the DNS server list from the properties. - */ - String propVal = SystemProperties.get("net.dnschange"); - if (propVal.length() != 0) { - try { - int n = Integer.parseInt(propVal); - SystemProperties.set("net.dnschange", "" + (n+1)); - } catch (NumberFormatException e) { - } - } - } - mLastCallingPid = -1; - } - /** * Internal method supporting the ENABLE_MMS feature. * @param apnType the type of APN to be enabled or disabled (e.g., mms) diff --git a/core/java/android/net/NetworkStateTracker.java b/core/java/android/net/NetworkStateTracker.java index 37087ac..418f511 100644 --- a/core/java/android/net/NetworkStateTracker.java +++ b/core/java/android/net/NetworkStateTracker.java @@ -27,6 +27,7 @@ import android.text.TextUtils; import android.util.Config; import android.util.Log; + /** * Each subclass of this class keeps track of the state of connectivity * of a network interface. All state information for a network should @@ -40,11 +41,16 @@ public abstract class NetworkStateTracker extends Handler { protected NetworkInfo mNetworkInfo; protected Context mContext; protected Handler mTarget; + protected String mInterfaceName; + protected String[] mDnsPropNames; + private boolean mPrivateDnsRouteSet; + protected int mDefaultGatewayAddr; + private boolean mDefaultRouteSet; private boolean mTeardownRequested; - private static boolean DBG = Config.LOGV; + private static boolean DBG = Config.LOGV; private static final String TAG = "NetworkStateTracker"; - + public static final int EVENT_STATE_CHANGED = 1; public static final int EVENT_SCAN_RESULTS_AVAILABLE = 2; /** @@ -56,6 +62,7 @@ public abstract class NetworkStateTracker extends Handler { public static final int EVENT_CONFIGURATION_CHANGED = 4; public static final int EVENT_ROAMING_CHANGED = 5; public static final int EVENT_NETWORK_SUBTYPE_CHANGED = 6; + public static final int EVENT_RESTORE_DEFAULT_NETWORK = 7; public NetworkStateTracker(Context context, Handler target, @@ -67,6 +74,7 @@ public abstract class NetworkStateTracker extends Handler { mContext = context; mTarget = target; mTeardownRequested = false; + this.mNetworkInfo = new NetworkInfo(networkType, subType, typeName, subtypeName); } @@ -75,19 +83,21 @@ public abstract class NetworkStateTracker extends Handler { } /** - * Return the list of DNS servers associated with this network. - * @return a list of the IP addresses of the DNS servers available - * for the network. - */ - public abstract String[] getNameServers(); - - /** * Return the system properties name associated with the tcp buffer sizes * for this network. */ public abstract String getTcpBufferSizesPropName(); /** + * Return the IP addresses of the DNS servers available for the mobile data + * network interface. + * @return a list of DNS addresses, with no holes. + */ + public String[] getNameServers() { + return getNameServerList(mDnsPropNames); + } + + /** * Return the IP addresses of the DNS servers available for this * network interface. * @param propertyNames the names of the system properties whose values @@ -112,6 +122,50 @@ public abstract class NetworkStateTracker extends Handler { return dnsAddresses; } + public void addPrivateDnsRoutes() { + if (DBG) Log.d(TAG, "addPrivateDnsRoutes for " + this + + "(" + mInterfaceName + ")"); + if (mInterfaceName != null && !mPrivateDnsRouteSet) { + for (String addrString : getNameServers()) { + int addr = NetworkUtils.lookupHost(addrString); + if (addr != -1) { + NetworkUtils.addHostRoute(mInterfaceName, addr); + } + } + mPrivateDnsRouteSet = true; + } + } + + public void removePrivateDnsRoutes() { + if (DBG) Log.d(TAG, "removePrivateDnsRoutes for " + this + + "(" + mInterfaceName + ")"); + // TODO - we should do this explicitly but the NetUtils api doesnt + // support this yet - must remove all. No worse than before + if (mInterfaceName != null && mPrivateDnsRouteSet) { + NetworkUtils.removeHostRoutes(mInterfaceName); + mPrivateDnsRouteSet = false; + } + } + + public void addDefaultRoute() { + if (DBG) Log.d(TAG, "addDefaultRoute for " + this + "(" + + mInterfaceName + "), GatewayAddr=" + mDefaultGatewayAddr); + if ((mInterfaceName != null) && (mDefaultGatewayAddr != 0) && + mDefaultRouteSet == false) { + NetworkUtils.setDefaultRoute(mInterfaceName, mDefaultGatewayAddr); + mDefaultRouteSet = true; + } + } + + public void removeDefaultRoute() { + if (DBG) Log.d(TAG, "removeDefaultRoute for " + this + "(" + + mInterfaceName + ")"); + if (mInterfaceName != null && mDefaultRouteSet == true) { + NetworkUtils.removeDefaultRoute(mInterfaceName); + mDefaultRouteSet = false; + } + } + /** * Reads the network specific TCP buffer sizes from SystemProperties * net.tcp.buffersize.[default|wifi|umts|edge|gprs] and set them for system @@ -209,6 +263,7 @@ public abstract class NetworkStateTracker extends Handler { * @param extraInfo optional {@code String} providing extra information about the state change */ public void setDetailedState(NetworkInfo.DetailedState state, String reason, String extraInfo) { + if (DBG) Log.d(TAG, "setDetailed state, old ="+mNetworkInfo.getDetailedState()+" and new state="+state); if (state != mNetworkInfo.getDetailedState()) { boolean wasConnecting = (mNetworkInfo.getState() == NetworkInfo.State.CONNECTING); String lastReason = mNetworkInfo.getReason(); diff --git a/core/java/android/net/NetworkUtils.java b/core/java/android/net/NetworkUtils.java index 1153648..a3ae01b 100644 --- a/core/java/android/net/NetworkUtils.java +++ b/core/java/android/net/NetworkUtils.java @@ -25,6 +25,9 @@ import java.net.UnknownHostException; * {@hide} */ public class NetworkUtils { + /** Bring the named network interface up. */ + public native static int enableInterface(String interfaceName); + /** Bring the named network interface down. */ public native static int disableInterface(String interfaceName); diff --git a/core/java/android/net/Uri.java b/core/java/android/net/Uri.java index 421d013..298be3b 100644 --- a/core/java/android/net/Uri.java +++ b/core/java/android/net/Uri.java @@ -374,7 +374,7 @@ public abstract class Uri implements Parcelable, Comparable<Uri> { /** * Creates a Uri which parses the given encoded URI string. * - * @param uriString an RFC 3296-compliant, encoded URI + * @param uriString an RFC 2396-compliant, encoded URI * @throws NullPointerException if uriString is null * @return Uri for this given uri string */ diff --git a/core/java/android/net/WebAddress.java b/core/java/android/net/WebAddress.java index f4a2a6a..f6159de 100644 --- a/core/java/android/net/WebAddress.java +++ b/core/java/android/net/WebAddress.java @@ -54,7 +54,7 @@ public class WebAddress { static Pattern sAddressPattern = Pattern.compile( /* scheme */ "(?:(http|HTTP|https|HTTPS|file|FILE)\\:\\/\\/)?" + /* authority */ "(?:([-A-Za-z0-9$_.+!*'(),;?&=]+(?:\\:[-A-Za-z0-9$_.+!*'(),;?&=]+)?)@)?" + - /* host */ "([-A-Za-z0-9%]+(?:\\.[-A-Za-z0-9%]+)*)?" + + /* host */ "([-A-Za-z0-9%_]+(?:\\.[-A-Za-z0-9%_]+)*)?" + /* port */ "(?:\\:([0-9]+))?" + /* path */ "(\\/?.*)?"); diff --git a/core/java/android/net/http/ConnectionThread.java b/core/java/android/net/http/ConnectionThread.java index 8e759e2..0b30e58 100644 --- a/core/java/android/net/http/ConnectionThread.java +++ b/core/java/android/net/http/ConnectionThread.java @@ -32,8 +32,8 @@ class ConnectionThread extends Thread { static final int WAIT_TICK = 1000; // Performance probe - long mStartThreadTime; long mCurrentThreadTime; + long mTotalThreadTime; private boolean mWaiting; private volatile boolean mRunning = true; @@ -69,12 +69,21 @@ class ConnectionThread extends Thread { */ public void run() { android.os.Process.setThreadPriority( + android.os.Process.THREAD_PRIORITY_DEFAULT + android.os.Process.THREAD_PRIORITY_LESS_FAVORABLE); - mStartThreadTime = -1; - mCurrentThreadTime = SystemClock.currentThreadTimeMillis(); + // these are used to get performance data. When it is not in the timing, + // mCurrentThreadTime is 0. When it starts timing, mCurrentThreadTime is + // first set to -1, it will be set to the current thread time when the + // next request starts. + mCurrentThreadTime = 0; + mTotalThreadTime = 0; while (mRunning) { + if (mCurrentThreadTime == -1) { + mCurrentThreadTime = SystemClock.currentThreadTimeMillis(); + } + Request request; /* Get a request to process */ @@ -86,14 +95,14 @@ class ConnectionThread extends Thread { if (HttpLog.LOGV) HttpLog.v("ConnectionThread: Waiting for work"); mWaiting = true; try { - if (mStartThreadTime != -1) { - mCurrentThreadTime = SystemClock - .currentThreadTimeMillis(); - } mRequestFeeder.wait(); } catch (InterruptedException e) { } mWaiting = false; + if (mCurrentThreadTime != 0) { + mCurrentThreadTime = SystemClock + .currentThreadTimeMillis(); + } } } else { if (HttpLog.LOGV) HttpLog.v("ConnectionThread: new request " + @@ -123,6 +132,12 @@ class ConnectionThread extends Thread { mConnection.closeConnection(); } mConnection = null; + + if (mCurrentThreadTime > 0) { + long start = mCurrentThreadTime; + mCurrentThreadTime = SystemClock.currentThreadTimeMillis(); + mTotalThreadTime += mCurrentThreadTime - start; + } } } diff --git a/core/java/android/net/http/Request.java b/core/java/android/net/http/Request.java index df4fff0..1b6568e 100644 --- a/core/java/android/net/http/Request.java +++ b/core/java/android/net/http/Request.java @@ -67,9 +67,6 @@ class Request { /** Set if I'm using a proxy server */ HttpHost mProxyHost; - /** True if request is .html, .js, .css */ - boolean mHighPriority; - /** True if request has been cancelled */ volatile boolean mCancelled = false; @@ -102,26 +99,29 @@ class Request { * @param eventHandler request will make progress callbacks on * this interface * @param headers reqeust headers - * @param highPriority true for .html, css, .cs */ Request(String method, HttpHost host, HttpHost proxyHost, String path, InputStream bodyProvider, int bodyLength, EventHandler eventHandler, - Map<String, String> headers, boolean highPriority) { + Map<String, String> headers) { mEventHandler = eventHandler; mHost = host; mProxyHost = proxyHost; mPath = path; - mHighPriority = highPriority; mBodyProvider = bodyProvider; mBodyLength = bodyLength; - if (bodyProvider == null) { + if (bodyProvider == null && !"POST".equalsIgnoreCase(method)) { mHttpRequest = new BasicHttpRequest(method, getUri()); } else { mHttpRequest = new BasicHttpEntityEnclosingRequest( method, getUri()); - setBodyProvider(bodyProvider, bodyLength); + // it is ok to have null entity for BasicHttpEntityEnclosingRequest. + // By using BasicHttpEntityEnclosingRequest, it will set up the + // correct content-length, content-type and content-encoding. + if (bodyProvider != null) { + setBodyProvider(bodyProvider, bodyLength); + } } addHeader(HOST_HEADER, getHostPort()); @@ -255,6 +255,8 @@ class Request { // process gzip content encoding Header contentEncoding = entity.getContentEncoding(); InputStream nis = null; + byte[] buf = null; + int count = 0; try { if (contentEncoding != null && contentEncoding.getValue().equals("gzip")) { @@ -265,9 +267,8 @@ class Request { /* accumulate enough data to make it worth pushing it * up the stack */ - byte[] buf = mConnection.getBuf(); + buf = mConnection.getBuf(); int len = 0; - int count = 0; int lowWater = buf.length / 2; while (len != -1) { len = nis.read(buf, count, buf.length - count); @@ -284,6 +285,10 @@ class Request { /* InflaterInputStream throws an EOFException when the server truncates gzipped content. Handle this case as we do truncated non-gzipped content: no error */ + if (count > 0) { + // if there is uncommited content, we should commit them + mEventHandler.data(buf, count); + } if (HttpLog.LOGV) HttpLog.v( "readResponse() handling " + e); } catch(IOException e) { // don't throw if we have a non-OK status code @@ -346,7 +351,7 @@ class Request { * for debugging */ public String toString() { - return (mHighPriority ? "P*" : "") + mPath; + return mPath; } @@ -412,8 +417,7 @@ class Request { } return status >= HttpStatus.SC_OK && status != HttpStatus.SC_NO_CONTENT - && status != HttpStatus.SC_NOT_MODIFIED - && status != HttpStatus.SC_RESET_CONTENT; + && status != HttpStatus.SC_NOT_MODIFIED; } /** diff --git a/core/java/android/net/http/RequestHandle.java b/core/java/android/net/http/RequestHandle.java index 6a97951..190ae7a 100644 --- a/core/java/android/net/http/RequestHandle.java +++ b/core/java/android/net/http/RequestHandle.java @@ -419,6 +419,6 @@ public class RequestHandle { mRequest = mRequestQueue.queueRequest( mUrl, mUri, mMethod, mHeaders, mRequest.mEventHandler, mBodyProvider, - mBodyLength, mRequest.mHighPriority).mRequest; + mBodyLength).mRequest; } } diff --git a/core/java/android/net/http/RequestQueue.java b/core/java/android/net/http/RequestQueue.java index 66d5722..e14af66 100644 --- a/core/java/android/net/http/RequestQueue.java +++ b/core/java/android/net/http/RequestQueue.java @@ -57,9 +57,6 @@ public class RequestQueue implements RequestFeeder { */ private LinkedHashMap<HttpHost, LinkedList<Request>> mPending; - /* Support for notifying a client when queue is empty */ - private boolean mClientWaiting = false; - /** true if connected */ boolean mNetworkConnected = true; @@ -245,7 +242,9 @@ public class RequestQueue implements RequestFeeder { public void startTiming() { for (int i = 0; i < mConnectionCount; i++) { - mThreads[i].mStartThreadTime = mThreads[i].mCurrentThreadTime; + ConnectionThread rt = mThreads[i]; + rt.mCurrentThreadTime = -1; + rt.mTotalThreadTime = 0; } mTotalRequest = 0; mTotalConnection = 0; @@ -255,12 +254,14 @@ public class RequestQueue implements RequestFeeder { int totalTime = 0; for (int i = 0; i < mConnectionCount; i++) { ConnectionThread rt = mThreads[i]; - totalTime += (rt.mCurrentThreadTime - rt.mStartThreadTime); - rt.mStartThreadTime = -1; + if (rt.mCurrentThreadTime != -1) { + totalTime += rt.mTotalThreadTime; + } + rt.mCurrentThreadTime = 0; } Log.d("Http", "Http thread used " + totalTime + " ms " + " for " + mTotalRequest + " requests and " + mTotalConnection - + " connections"); + + " new connections"); } void logState() { @@ -434,16 +435,14 @@ public class RequestQueue implements RequestFeeder { * data. Callbacks will be made on the supplied instance. * @param bodyProvider InputStream providing HTTP body, null if none * @param bodyLength length of body, must be 0 if bodyProvider is null - * @param highPriority If true, queues before low priority - * requests if possible */ public RequestHandle queueRequest( String url, String method, Map<String, String> headers, EventHandler eventHandler, - InputStream bodyProvider, int bodyLength, boolean highPriority) { + InputStream bodyProvider, int bodyLength) { WebAddress uri = new WebAddress(url); return queueRequest(url, uri, method, headers, eventHandler, - bodyProvider, bodyLength, highPriority); + bodyProvider, bodyLength); } /** @@ -456,14 +455,11 @@ public class RequestQueue implements RequestFeeder { * data. Callbacks will be made on the supplied instance. * @param bodyProvider InputStream providing HTTP body, null if none * @param bodyLength length of body, must be 0 if bodyProvider is null - * @param highPriority If true, queues before low priority - * requests if possible */ public RequestHandle queueRequest( String url, WebAddress uri, String method, Map<String, String> headers, EventHandler eventHandler, - InputStream bodyProvider, int bodyLength, - boolean highPriority) { + InputStream bodyProvider, int bodyLength) { if (HttpLog.LOGV) HttpLog.v("RequestQueue.queueRequest " + uri); @@ -478,9 +474,9 @@ public class RequestQueue implements RequestFeeder { // set up request req = new Request(method, httpHost, mProxyHost, uri.mPath, bodyProvider, - bodyLength, eventHandler, headers, highPriority); + bodyLength, eventHandler, headers); - queueRequest(req, highPriority); + queueRequest(req, false); mActivePool.mTotalRequest++; diff --git a/core/java/android/os/Debug.java b/core/java/android/os/Debug.java index d40ea6b..b0fc78e 100644 --- a/core/java/android/os/Debug.java +++ b/core/java/android/os/Debug.java @@ -662,6 +662,25 @@ href="{@docRoot}guide/developing/tools/traceview.html">Traceview: A Graphical Lo public static final native int getBinderDeathObjectCount(); /** + * Primes the register map cache. + * + * Only works for classes in the bootstrap class loader. Does not + * cause classes to be loaded if they're not already present. + * + * The classAndMethodDesc argument is a concatentation of the VM-internal + * class descriptor, method name, and method descriptor. Examples: + * Landroid/os/Looper;.loop:()V + * Landroid/app/ActivityThread;.main:([Ljava/lang/String;)V + * + * @param classAndMethodDesc the method to prepare + * + * @hide + */ + public static final boolean cacheRegisterMap(String classAndMethodDesc) { + return VMDebug.cacheRegisterMap(classAndMethodDesc); + } + + /** * API for gathering and querying instruction counts. * * Example usage: diff --git a/core/java/android/os/Exec.java b/core/java/android/os/Exec.java deleted file mode 100644 index a50d5fe..0000000 --- a/core/java/android/os/Exec.java +++ /dev/null @@ -1,63 +0,0 @@ -/* - * 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.os; - -import java.io.FileDescriptor; - -/** - * @hide - * Tools for executing commands. Not for public consumption. - */ - -public class Exec -{ - /** - * @param cmd The command to execute - * @param arg0 The first argument to the command, may be null - * @param arg1 the second argument to the command, may be null - * @return the file descriptor of the started process. - * - */ - public static FileDescriptor createSubprocess( - String cmd, String arg0, String arg1) { - return createSubprocess(cmd, arg0, arg1, null); - } - - /** - * @param cmd The command to execute - * @param arg0 The first argument to the command, may be null - * @param arg1 the second argument to the command, may be null - * @param processId A one-element array to which the process ID of the - * started process will be written. - * @return the file descriptor of the started process. - * - */ - public static native FileDescriptor createSubprocess( - String cmd, String arg0, String arg1, int[] processId); - - public static native void setPtyWindowSize(FileDescriptor fd, - int row, int col, int xpixel, int ypixel); - /** - * Causes the calling thread to wait for the process associated with the - * receiver to finish executing. - * - * @return The exit value of the Process being waited on - * - */ - public static native int waitFor(int processId); -} - diff --git a/core/java/android/os/FileObserver.java b/core/java/android/os/FileObserver.java index d9804ea..38d252e 100644 --- a/core/java/android/os/FileObserver.java +++ b/core/java/android/os/FileObserver.java @@ -25,22 +25,35 @@ import java.util.ArrayList; import java.util.HashMap; public abstract class FileObserver { - public static final int ACCESS = 0x00000001; /* File was accessed */ - public static final int MODIFY = 0x00000002; /* File was modified */ - public static final int ATTRIB = 0x00000004; /* Metadata changed */ - public static final int CLOSE_WRITE = 0x00000008; /* Writtable file was closed */ - public static final int CLOSE_NOWRITE = 0x00000010; /* Unwrittable file closed */ - public static final int OPEN = 0x00000020; /* File was opened */ - public static final int MOVED_FROM = 0x00000040; /* File was moved from X */ - public static final int MOVED_TO = 0x00000080; /* File was moved to Y */ - public static final int CREATE = 0x00000100; /* Subfile was created */ - public static final int DELETE = 0x00000200; /* Subfile was deleted */ - public static final int DELETE_SELF = 0x00000400; /* Self was deleted */ - public static final int MOVE_SELF = 0x00000800; /* Self was moved */ + /** File was accessed */ + public static final int ACCESS = 0x00000001; + /** File was modified */ + public static final int MODIFY = 0x00000002; + /** Metadata changed */ + public static final int ATTRIB = 0x00000004; + /** Writable file was closed */ + public static final int CLOSE_WRITE = 0x00000008; + /** Unwrittable file closed */ + public static final int CLOSE_NOWRITE = 0x00000010; + /** File was opened */ + public static final int OPEN = 0x00000020; + /** File was moved from X */ + public static final int MOVED_FROM = 0x00000040; + /** File was moved to Y */ + public static final int MOVED_TO = 0x00000080; + /** Subfile was created */ + public static final int CREATE = 0x00000100; + /** Subfile was deleted */ + public static final int DELETE = 0x00000200; + /** Self was deleted */ + public static final int DELETE_SELF = 0x00000400; + /** Self was moved */ + public static final int MOVE_SELF = 0x00000800; + public static final int ALL_EVENTS = ACCESS | MODIFY | ATTRIB | CLOSE_WRITE | CLOSE_NOWRITE | OPEN | MOVED_FROM | MOVED_TO | DELETE | CREATE | DELETE_SELF | MOVE_SELF; - + private static final String LOG_TAG = "FileObserver"; private static class ObserverThread extends Thread { diff --git a/core/java/android/os/IHardwareService.aidl b/core/java/android/os/IHardwareService.aidl index fb121bb..aebcb3c 100755 --- a/core/java/android/os/IHardwareService.aidl +++ b/core/java/android/os/IHardwareService.aidl @@ -20,9 +20,9 @@ package android.os; interface IHardwareService { // Vibrator support - void vibrate(long milliseconds); + void vibrate(long milliseconds, IBinder token); void vibratePattern(in long[] pattern, int repeat, IBinder token); - void cancelVibrate(); + void cancelVibrate(IBinder token); // flashlight support boolean getFlashlightEnabled(); diff --git a/core/java/android/os/IPowerManager.aidl b/core/java/android/os/IPowerManager.aidl index 5486920..188e7ff 100644 --- a/core/java/android/os/IPowerManager.aidl +++ b/core/java/android/os/IPowerManager.aidl @@ -26,6 +26,7 @@ interface IPowerManager void userActivity(long when, boolean noChangeLights); void userActivityWithForce(long when, boolean noChangeLights, boolean force); void setPokeLock(int pokey, IBinder lock, String tag); + int getSupportedWakeLockFlags(); void setStayOnSetting(int val); long getScreenOnTime(); void preventScreenOn(boolean prevent); diff --git a/core/java/android/os/LatencyTimer.java b/core/java/android/os/LatencyTimer.java new file mode 100644 index 0000000..ed2f0f9e --- /dev/null +++ b/core/java/android/os/LatencyTimer.java @@ -0,0 +1,94 @@ +/* + * Copyright (C) 2009 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.os; + +import android.util.Log; + +import java.util.HashMap; + +/** + * A class to help with measuring latency in your code. + * + * Suggested usage: + * 1) Instanciate a LatencyTimer as a class field. + * private [static] LatencyTimer mLt = new LatencyTimer(100, 1000); + * 2) At various points in the code call sample with a string and the time delta to some fixed time. + * The string should be unique at each point of the code you are measuring. + * mLt.sample("before processing event", System.nanoTime() - event.getEventTimeNano()); + * processEvent(event); + * mLt.sample("after processing event ", System.nanoTime() - event.getEventTimeNano()); + * + * @hide + */ +public final class LatencyTimer +{ + final String TAG = "LatencyTimer"; + final int mSampleSize; + final int mScaleFactor; + volatile HashMap<String, long[]> store = new HashMap<String, long[]>(); + + /** + * Creates a LatencyTimer object + * @param sampleSize number of samples to collect before printing out the average + * @param scaleFactor divisor used to make each sample smaller to prevent overflow when + * (sampleSize * average sample value)/scaleFactor > Long.MAX_VALUE + */ + public LatencyTimer(int sampleSize, int scaleFactor) { + if (scaleFactor == 0) { + scaleFactor = 1; + } + mScaleFactor = scaleFactor; + mSampleSize = sampleSize; + } + + /** + * Add a sample delay for averaging. + * @param tag string used for printing out the result. This should be unique at each point of + * this called. + * @param delta time difference from an unique point of reference for a particular iteration + */ + public void sample(String tag, long delta) { + long[] array = getArray(tag); + + // array[mSampleSize] holds the number of used entries + final int index = (int) array[mSampleSize]++; + array[index] = delta; + if (array[mSampleSize] == mSampleSize) { + long totalDelta = 0; + for (long d : array) { + totalDelta += d/mScaleFactor; + } + array[mSampleSize] = 0; + Log.i(TAG, tag + " average = " + totalDelta / mSampleSize); + } + } + + private long[] getArray(String tag) { + long[] data = store.get(tag); + if (data == null) { + synchronized(store) { + data = store.get(tag); + if (data == null) { + data = new long[mSampleSize + 1]; + store.put(tag, data); + data[mSampleSize] = 0; + } + } + } + return data; + } +} diff --git a/core/java/android/os/MemoryFile.java b/core/java/android/os/MemoryFile.java index c14925c..03542dd 100644 --- a/core/java/android/os/MemoryFile.java +++ b/core/java/android/os/MemoryFile.java @@ -52,7 +52,7 @@ public class MemoryFile private static native void native_write(FileDescriptor fd, int address, byte[] buffer, int srcOffset, int destOffset, int count, boolean isUnpinned) throws IOException; private static native void native_pin(FileDescriptor fd, boolean pin) throws IOException; - private static native boolean native_is_ashmem_region(FileDescriptor fd) throws IOException; + private static native int native_get_mapped_size(FileDescriptor fd) throws IOException; private FileDescriptor mFD; // ashmem file descriptor private int mAddress; // address of ashmem memory @@ -300,7 +300,20 @@ public class MemoryFile * @hide */ public static boolean isMemoryFile(FileDescriptor fd) throws IOException { - return native_is_ashmem_region(fd); + return (native_get_mapped_size(fd) >= 0); + } + + /** + * Returns the size of the memory file, rounded up to a page boundary, that + * the file descriptor refers to, or -1 if the file descriptor does not + * refer to a memory file. + * + * @throws IOException If <code>fd</code> is not a valid file descriptor. + * + * @hide + */ + public static int getMappedSize(FileDescriptor fd) throws IOException { + return native_get_mapped_size(fd); } /** diff --git a/core/java/android/os/PowerManager.java b/core/java/android/os/PowerManager.java index bfcf2fc..d5934102 100644 --- a/core/java/android/os/PowerManager.java +++ b/core/java/android/os/PowerManager.java @@ -114,12 +114,14 @@ public class PowerManager private static final int WAKE_BIT_SCREEN_DIM = 4; private static final int WAKE_BIT_SCREEN_BRIGHT = 8; private static final int WAKE_BIT_KEYBOARD_BRIGHT = 16; + private static final int WAKE_BIT_PROXIMITY_SCREEN_OFF = 32; private static final int LOCK_MASK = WAKE_BIT_CPU_STRONG | WAKE_BIT_CPU_WEAK | WAKE_BIT_SCREEN_DIM | WAKE_BIT_SCREEN_BRIGHT - | WAKE_BIT_KEYBOARD_BRIGHT; + | WAKE_BIT_KEYBOARD_BRIGHT + | WAKE_BIT_PROXIMITY_SCREEN_OFF; /** * Wake lock that ensures that the CPU is running. The screen might @@ -147,6 +149,16 @@ public class PowerManager public static final int SCREEN_DIM_WAKE_LOCK = WAKE_BIT_CPU_WEAK | WAKE_BIT_SCREEN_DIM; /** + * Wake lock that turns the screen off when the proximity sensor activates. + * Since not all devices have proximity sensors, use + * {@link #getSupportedWakeLockFlags() getSupportedWakeLockFlags()} to determine if + * this wake lock mode is supported. + * + * {@hide} + */ + public static final int PROXIMITY_SCREEN_OFF_WAKE_LOCK = WAKE_BIT_PROXIMITY_SCREEN_OFF; + + /** * Normally wake locks don't actually wake the device, they just cause * it to remain on once it's already on. Think of the video player * app as the normal behavior. Notifications that pop up and want @@ -196,6 +208,7 @@ public class PowerManager case SCREEN_DIM_WAKE_LOCK: case SCREEN_BRIGHT_WAKE_LOCK: case FULL_WAKE_LOCK: + case PROXIMITY_SCREEN_OFF_WAKE_LOCK: break; default: throw new IllegalArgumentException(); @@ -365,7 +378,33 @@ public class PowerManager } catch (RemoteException e) { } } - + + /** + * Returns the set of flags for {@link #newWakeLock(int, String) newWakeLock()} + * that are supported on the device. + * For example, to test to see if the {@link #PROXIMITY_SCREEN_OFF_WAKE_LOCK} + * is supported: + * + * {@samplecode + * PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); + * int supportedFlags = pm.getSupportedWakeLockFlags(); + * boolean proximitySupported = ((supportedFlags & PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK) + * == PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK); + * } + * + * @return the set of supported WakeLock flags. + * + * {@hide} + */ + public int getSupportedWakeLockFlags() + { + try { + return mService.getSupportedWakeLockFlags(); + } catch (RemoteException e) { + return 0; + } + } + private PowerManager() { } diff --git a/core/java/android/os/Process.java b/core/java/android/os/Process.java index 4805193..980cff3 100644 --- a/core/java/android/os/Process.java +++ b/core/java/android/os/Process.java @@ -739,7 +739,7 @@ public class Process { public static final native void sendSignal(int pid, int signal); /** @hide */ - public static final native int getFreeMemory(); + public static final native long getFreeMemory(); /** @hide */ public static final native void readProcLines(String path, diff --git a/core/java/android/os/RemoteCallbackList.java b/core/java/android/os/RemoteCallbackList.java index 584224f..b74af16 100644 --- a/core/java/android/os/RemoteCallbackList.java +++ b/core/java/android/os/RemoteCallbackList.java @@ -22,7 +22,7 @@ import java.util.HashMap; * Takes care of the grunt work of maintaining a list of remote interfaces, * typically for the use of performing callbacks from a * {@link android.app.Service} to its clients. In particular, this: - * + * * <ul> * <li> Keeps track of a set of registered {@link IInterface} callbacks, * taking care to identify them through their underlying unique {@link IBinder} @@ -34,13 +34,13 @@ import java.util.HashMap; * multithreaded incoming calls, and a thread-safe way to iterate over a * snapshot of the list without holding its lock. * </ul> - * + * * <p>To use this class, simply create a single instance along with your * service, and call its {@link #register} and {@link #unregister} methods * as client register and unregister with your service. To call back on to * the registered clients, use {@link #beginBroadcast}, * {@link #getBroadcastItem}, and {@link #finishBroadcast}. - * + * * <p>If a registered callback's process goes away, this class will take * care of automatically removing it from the list. If you want to do * additional work in this situation, you can create a subclass that @@ -52,7 +52,7 @@ public class RemoteCallbackList<E extends IInterface> { private Object[] mActiveBroadcast; private int mBroadcastCount = -1; private boolean mKilled = false; - + private final class Callback implements IBinder.DeathRecipient { final E mCallback; final Object mCookie; @@ -61,7 +61,7 @@ public class RemoteCallbackList<E extends IInterface> { mCallback = callback; mCookie = cookie; } - + public void binderDied() { synchronized (mCallbacks) { mCallbacks.remove(mCallback.asBinder()); @@ -69,7 +69,7 @@ public class RemoteCallbackList<E extends IInterface> { onCallbackDied(mCallback, mCookie); } } - + /** * Simple version of {@link RemoteCallbackList#register(E, Object)} * that does not take a cookie object. @@ -86,19 +86,20 @@ public class RemoteCallbackList<E extends IInterface> { * object is already in the list), then it will be left as-is. * Registrations are not counted; a single call to {@link #unregister} * will remove a callback after any number calls to register it. - * + * * @param callback The callback interface to be added to the list. Must * not be null -- passing null here will cause a NullPointerException. * Most services will want to check for null before calling this with * an object given from a client, so that clients can't crash the * service with bad data. + * * @param cookie Optional additional data to be associated with this * callback. * * @return Returns true if the callback was successfully added to the list. * Returns false if it was not added, either because {@link #kill} had * previously been called or the callback's process has gone away. - * + * * @see #unregister * @see #kill * @see #onCallbackDied @@ -119,7 +120,7 @@ public class RemoteCallbackList<E extends IInterface> { } } } - + /** * Remove from the list a callback that was previously added with * {@link #register}. This uses the @@ -127,14 +128,14 @@ public class RemoteCallbackList<E extends IInterface> { * find the previous registration. * Registrations are not counted; a single unregister call will remove * a callback after any number calls to {@link #register} for it. - * + * * @param callback The callback to be removed from the list. Passing * null here will cause a NullPointerException, so you will generally want * to check for null before calling. - * + * * @return Returns true if the callback was found and unregistered. Returns * false if the given callback was not found on the list. - * + * * @see #register */ public boolean unregister(E callback) { @@ -147,13 +148,13 @@ public class RemoteCallbackList<E extends IInterface> { return false; } } - + /** * Disable this callback list. All registered callbacks are unregistered, * and the list is disabled so that future calls to {@link #register} will * fail. This should be used when a Service is stopping, to prevent clients * from registering callbacks after it is stopped. - * + * * @see #register */ public void kill() { @@ -165,7 +166,7 @@ public class RemoteCallbackList<E extends IInterface> { mKilled = true; } } - + /** * Old version of {@link #onCallbackDied(E, Object)} that * does not provide a cookie. @@ -190,7 +191,7 @@ public class RemoteCallbackList<E extends IInterface> { public void onCallbackDied(E callback, Object cookie) { onCallbackDied(callback); } - + /** * Prepare to start making calls to the currently registered callbacks. * This creates a copy of the callback list, which you can retrieve items @@ -199,12 +200,12 @@ public class RemoteCallbackList<E extends IInterface> { * same thread (usually by scheduling with {@link Handler}) or * do your own synchronization. You must call {@link #finishBroadcast} * when done. - * + * * <p>A typical loop delivering a broadcast looks like this: - * + * * <pre> * int i = callbacks.beginBroadcast(); - * while (i > 0) { + * while (i > 0) { * i--; * try { * callbacks.getBroadcastItem(i).somethingHappened(); @@ -214,11 +215,11 @@ public class RemoteCallbackList<E extends IInterface> { * } * } * callbacks.finishBroadcast();</pre> - * + * * @return Returns the number of callbacks in the broadcast, to be used * with {@link #getBroadcastItem} to determine the range of indices you * can supply. - * + * * @see #getBroadcastItem * @see #finishBroadcast */ @@ -244,26 +245,26 @@ public class RemoteCallbackList<E extends IInterface> { return i; } } - + /** * Retrieve an item in the active broadcast that was previously started * with {@link #beginBroadcast}. This can <em>only</em> be called after * the broadcast is started, and its data is no longer valid after * calling {@link #finishBroadcast}. - * + * * <p>Note that it is possible for the process of one of the returned * callbacks to go away before you call it, so you will need to catch * {@link RemoteException} when calling on to the returned object. * The callback list itself, however, will take care of unregistering * these objects once it detects that it is no longer valid, so you can * handle such an exception by simply ignoring it. - * + * * @param index Which of the registered callbacks you would like to * retrieve. Ranges from 0 to 1-{@link #beginBroadcast}. - * + * * @return Returns the callback interface that you can call. This will * always be non-null. - * + * * @see #beginBroadcast */ public E getBroadcastItem(int index) { @@ -279,12 +280,12 @@ public class RemoteCallbackList<E extends IInterface> { public Object getBroadcastCookie(int index) { return ((Callback)mActiveBroadcast[index]).mCookie; } - + /** * Clean up the state of a broadcast previously initiated by calling * {@link #beginBroadcast}. This must always be called when you are done * with a broadcast. - * + * * @see #beginBroadcast */ public void finishBroadcast() { diff --git a/core/java/android/os/SystemClock.java b/core/java/android/os/SystemClock.java index 2b57b39..2dd6749 100644 --- a/core/java/android/os/SystemClock.java +++ b/core/java/android/os/SystemClock.java @@ -30,7 +30,13 @@ package android.os; * backwards or forwards unpredictably. This clock should only be used * when correspondence with real-world dates and times is important, such * as in a calendar or alarm clock application. Interval or elapsed - * time measurements should use a different clock. + * time measurements should use a different clock. If you are using + * System.currentTimeMillis(), consider listening to the + * {@link android.content.Intent#ACTION_TIME_TICK ACTION_TIME_TICK}, + * {@link android.content.Intent#ACTION_TIME_CHANGED ACTION_TIME_CHANGED} + * and {@link android.content.Intent#ACTION_TIMEZONE_CHANGED + * ACTION_TIMEZONE_CHANGED} {@link android.content.Intent Intent} + * broadcasts to find out when the time changes. * * <li> <p> {@link #uptimeMillis} is counted in milliseconds since the * system was booted. This clock stops when the system enters deep diff --git a/core/java/android/os/SystemProperties.java b/core/java/android/os/SystemProperties.java index c3ae3c2..4a036ec 100644 --- a/core/java/android/os/SystemProperties.java +++ b/core/java/android/os/SystemProperties.java @@ -30,6 +30,9 @@ public class SystemProperties private static native String native_get(String key); private static native String native_get(String key, String def); + private static native int native_get_int(String key, int def); + private static native long native_get_long(String key, long def); + private static native boolean native_get_boolean(String key, boolean def); private static native void native_set(String key, String def); /** @@ -65,11 +68,10 @@ public class SystemProperties * @throws IllegalArgumentException if the key exceeds 32 characters */ public static int getInt(String key, int def) { - try { - return Integer.parseInt(get(key)); - } catch (NumberFormatException e) { - return def; + if (key.length() > PROP_NAME_MAX) { + throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX); } + return native_get_int(key, def); } /** @@ -81,11 +83,10 @@ public class SystemProperties * @throws IllegalArgumentException if the key exceeds 32 characters */ public static long getLong(String key, long def) { - try { - return Long.parseLong(get(key)); - } catch (NumberFormatException e) { - return def; + if (key.length() > PROP_NAME_MAX) { + throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX); } + return native_get_long(key, def); } /** @@ -102,27 +103,10 @@ public class SystemProperties * @throws IllegalArgumentException if the key exceeds 32 characters */ public static boolean getBoolean(String key, boolean def) { - String value = get(key); - // Deal with these quick cases first: not found, 0 and 1 - if (value.equals("")) { - return def; - } else if (value.equals("0")) { - return false; - } else if (value.equals("1")) { - return true; - // now for slower (and hopefully less common) cases - } else if (value.equalsIgnoreCase("n") || - value.equalsIgnoreCase("no") || - value.equalsIgnoreCase("false") || - value.equalsIgnoreCase("off")) { - return false; - } else if (value.equalsIgnoreCase("y") || - value.equalsIgnoreCase("yes") || - value.equalsIgnoreCase("true") || - value.equalsIgnoreCase("on")) { - return true; + if (key.length() > PROP_NAME_MAX) { + throw new IllegalArgumentException("key.length > " + PROP_NAME_MAX); } - return def; + return native_get_boolean(key, def); } /** diff --git a/core/java/android/os/Vibrator.java b/core/java/android/os/Vibrator.java index 0f75289..51dcff1 100644 --- a/core/java/android/os/Vibrator.java +++ b/core/java/android/os/Vibrator.java @@ -24,6 +24,7 @@ package android.os; public class Vibrator { IHardwareService mService; + private final Binder mToken = new Binder(); /** @hide */ public Vibrator() @@ -40,7 +41,7 @@ public class Vibrator public void vibrate(long milliseconds) { try { - mService.vibrate(milliseconds); + mService.vibrate(milliseconds, mToken); } catch (RemoteException e) { } } @@ -65,7 +66,7 @@ public class Vibrator // anyway if (repeat < pattern.length) { try { - mService.vibratePattern(pattern, repeat, new Binder()); + mService.vibratePattern(pattern, repeat, mToken); } catch (RemoteException e) { } } else { @@ -79,7 +80,7 @@ public class Vibrator public void cancel() { try { - mService.cancelVibrate(); + mService.cancelVibrate(mToken); } catch (RemoteException e) { } } diff --git a/core/java/android/pim/ContactsAsyncHelper.java b/core/java/android/pim/ContactsAsyncHelper.java index a21281e..342d208 100644 --- a/core/java/android/pim/ContactsAsyncHelper.java +++ b/core/java/android/pim/ContactsAsyncHelper.java @@ -27,8 +27,7 @@ import android.os.Handler; import android.os.HandlerThread; import android.os.Looper; import android.os.Message; -import android.provider.Contacts; -import android.provider.Contacts.People; +import android.provider.ContactsContract.Contacts; import android.util.Log; import android.view.View; import android.widget.ImageView; @@ -39,35 +38,35 @@ import java.io.InputStream; * Helper class for async access of images. */ public class ContactsAsyncHelper extends Handler { - + private static final boolean DBG = false; private static final String LOG_TAG = "ContactsAsyncHelper"; - + /** * Interface for a WorkerHandler result return. */ public interface OnImageLoadCompleteListener { /** * Called when the image load is complete. - * + * * @param imagePresent true if an image was found - */ + */ public void onImageLoadComplete(int token, Object cookie, ImageView iView, boolean imagePresent); } - + // constants private static final int EVENT_LOAD_IMAGE = 1; private static final int DEFAULT_TOKEN = -1; - + // static objects private static Handler sThreadHandler; private static ContactsAsyncHelper sInstance; - + static { sInstance = new ContactsAsyncHelper(); } - + private static final class WorkerArgs { public Context context; public ImageView view; @@ -78,12 +77,12 @@ public class ContactsAsyncHelper extends Handler { public OnImageLoadCompleteListener listener; public CallerInfo info; } - + /** - * public inner class to help out the ContactsAsyncHelper callers - * with tracking the state of the CallerInfo Queries and image + * public inner class to help out the ContactsAsyncHelper callers + * with tracking the state of the CallerInfo Queries and image * loading. - * + * * Logic contained herein is used to remove the race conditions * that exist as the CallerInfo queries run and mix with the image * loads, which then mix with the Phone state changes. @@ -94,11 +93,11 @@ public class ContactsAsyncHelper extends Handler { public static final int DISPLAY_UNDEFINED = 0; public static final int DISPLAY_IMAGE = -1; public static final int DISPLAY_DEFAULT = -2; - + // State of the image on the imageview. private CallerInfo mCurrentCallerInfo; private int displayMode; - + public ImageTracker() { mCurrentCallerInfo = null; displayMode = DISPLAY_UNDEFINED; @@ -107,17 +106,17 @@ public class ContactsAsyncHelper extends Handler { /** * Used to see if the requested call / connection has a * different caller attached to it than the one we currently - * have in the CallCard. + * have in the CallCard. */ public boolean isDifferentImageRequest(CallerInfo ci) { // note, since the connections are around for the lifetime of the - // call, and the CallerInfo-related items as well, we can + // call, and the CallerInfo-related items as well, we can // definitely use a simple != comparison. return (mCurrentCallerInfo != ci); } - + public boolean isDifferentImageRequest(Connection connection) { - // if the connection does not exist, see if the + // if the connection does not exist, see if the // mCurrentCallerInfo is also null to match. if (connection == null) { if (DBG) Log.d(LOG_TAG, "isDifferentImageRequest: connection is null"); @@ -133,57 +132,58 @@ public class ContactsAsyncHelper extends Handler { } return runQuery; } - + /** - * Simple setter for the CallerInfo object. + * Simple setter for the CallerInfo object. */ public void setPhotoRequest(CallerInfo ci) { - mCurrentCallerInfo = ci; + mCurrentCallerInfo = ci; } - + /** - * Convenience method used to retrieve the URI - * representing the Photo file recorded in the attached - * CallerInfo Object. + * Convenience method used to retrieve the URI + * representing the Photo file recorded in the attached + * CallerInfo Object. */ public Uri getPhotoUri() { if (mCurrentCallerInfo != null) { - return ContentUris.withAppendedId(People.CONTENT_URI, + return ContentUris.withAppendedId(Contacts.CONTENT_URI, mCurrentCallerInfo.person_id); } - return null; + return null; } - + /** - * Simple setter for the Photo state. + * Simple setter for the Photo state. */ public void setPhotoState(int state) { displayMode = state; } - + /** - * Simple getter for the Photo state. + * Simple getter for the Photo state. */ public int getPhotoState() { return displayMode; } } - + /** - * Thread worker class that handles the task of opening the stream and loading + * Thread worker class that handles the task of opening the stream and loading * the images. */ private class WorkerHandler extends Handler { public WorkerHandler(Looper looper) { super(looper); } - + + @Override public void handleMessage(Message msg) { WorkerArgs args = (WorkerArgs) msg.obj; - + switch (msg.arg1) { case EVENT_LOAD_IMAGE: - InputStream inputStream = Contacts.People.openContactPhotoInputStream( + InputStream inputStream = Contacts.openContactPhotoInputStream( args.context.getContentResolver(), args.uri); if (inputStream != null) { args.result = Drawable.createFromStream(inputStream, args.uri.toString()); @@ -192,22 +192,22 @@ public class ContactsAsyncHelper extends Handler { " token: " + msg.what + " image URI: " + args.uri); } else { args.result = null; - if (DBG) Log.d(LOG_TAG, "Problem with image: " + msg.arg1 + - " token: " + msg.what + " image URI: " + args.uri + + if (DBG) Log.d(LOG_TAG, "Problem with image: " + msg.arg1 + + " token: " + msg.what + " image URI: " + args.uri + ", using default image."); } break; default: } - - // send the reply to the enclosing class. + + // send the reply to the enclosing class. Message reply = ContactsAsyncHelper.this.obtainMessage(msg.what); reply.arg1 = msg.arg1; reply.obj = msg.obj; reply.sendToTarget(); } } - + /** * Private constructor for static class */ @@ -216,14 +216,14 @@ public class ContactsAsyncHelper extends Handler { thread.start(); sThreadHandler = new WorkerHandler(thread.getLooper()); } - + /** * Convenience method for calls that do not want to deal with listeners and tokens. */ - public static final void updateImageViewWithContactPhotoAsync(Context context, + public static final void updateImageViewWithContactPhotoAsync(Context context, ImageView imageView, Uri person, int placeholderImageResource) { // Added additional Cookie field in the callee. - updateImageViewWithContactPhotoAsync (null, DEFAULT_TOKEN, null, null, context, + updateImageViewWithContactPhotoAsync (null, DEFAULT_TOKEN, null, null, context, imageView, person, placeholderImageResource); } @@ -231,24 +231,24 @@ public class ContactsAsyncHelper extends Handler { * Convenience method for calls that do not want to deal with listeners and tokens, but have * a CallerInfo object to cache the image to. */ - public static final void updateImageViewWithContactPhotoAsync(CallerInfo info, Context context, + public static final void updateImageViewWithContactPhotoAsync(CallerInfo info, Context context, ImageView imageView, Uri person, int placeholderImageResource) { // Added additional Cookie field in the callee. - updateImageViewWithContactPhotoAsync (info, DEFAULT_TOKEN, null, null, context, + updateImageViewWithContactPhotoAsync (info, DEFAULT_TOKEN, null, null, context, imageView, person, placeholderImageResource); } - + /** * Start an image load, attach the result to the specified CallerInfo object. * Note, when the query is started, we make the ImageView INVISIBLE if the * placeholderImageResource value is -1. When we're given a valid (!= -1) * placeholderImageResource value, we make sure the image is visible. */ - public static final void updateImageViewWithContactPhotoAsync(CallerInfo info, int token, - OnImageLoadCompleteListener listener, Object cookie, Context context, + public static final void updateImageViewWithContactPhotoAsync(CallerInfo info, int token, + OnImageLoadCompleteListener listener, Object cookie, Context context, ImageView imageView, Uri person, int placeholderImageResource) { - + // in case the source caller info is null, the URI will be null as well. // just update using the placeholder image in this case. if (person == null) { @@ -257,10 +257,10 @@ public class ContactsAsyncHelper extends Handler { imageView.setImageResource(placeholderImageResource); return; } - + // Added additional Cookie field in the callee to handle arguments // sent to the callback function. - + // setup arguments WorkerArgs args = new WorkerArgs(); args.cookie = cookie; @@ -270,15 +270,15 @@ public class ContactsAsyncHelper extends Handler { args.defaultResource = placeholderImageResource; args.listener = listener; args.info = info; - + // setup message arguments Message msg = sThreadHandler.obtainMessage(token); msg.arg1 = EVENT_LOAD_IMAGE; msg.obj = args; - - if (DBG) Log.d(LOG_TAG, "Begin loading image: " + args.uri + + + if (DBG) Log.d(LOG_TAG, "Begin loading image: " + args.uri + ", displaying default image for now."); - + // set the default image first, when the query is complete, we will // replace the image with the correct one. if (placeholderImageResource != -1) { @@ -287,11 +287,11 @@ public class ContactsAsyncHelper extends Handler { } else { imageView.setVisibility(View.INVISIBLE); } - + // notify the thread to begin working sThreadHandler.sendMessage(msg); } - + /** * Called when loading is done. */ @@ -316,21 +316,21 @@ public class ContactsAsyncHelper extends Handler { args.view.setVisibility(View.VISIBLE); args.view.setImageResource(args.defaultResource); } - + // Note that the data is cached. if (args.info != null) { args.info.isCachedPhotoCurrent = true; } - + // notify the listener if it is there. if (args.listener != null) { - if (DBG) Log.d(LOG_TAG, "Notifying listener: " + args.listener.toString() + + if (DBG) Log.d(LOG_TAG, "Notifying listener: " + args.listener.toString() + " image: " + args.uri + " completed"); args.listener.onImageLoadComplete(msg.what, args.cookie, args.view, imagePresent); } break; - default: + default: } } } diff --git a/core/java/android/pim/RecurrenceSet.java b/core/java/android/pim/RecurrenceSet.java index 1a287c8..bd7924a 100644 --- a/core/java/android/pim/RecurrenceSet.java +++ b/core/java/android/pim/RecurrenceSet.java @@ -223,6 +223,7 @@ public class RecurrenceSet { return true; } + // This can be removed when the old CalendarSyncAdapter is removed. public static boolean populateComponent(Cursor cursor, ICalendar.Component component) { @@ -292,6 +293,64 @@ public class RecurrenceSet { return true; } +public static boolean populateComponent(ContentValues values, + ICalendar.Component component) { + long dtstart = -1; + if (values.containsKey(Calendar.Events.DTSTART)) { + dtstart = values.getAsLong(Calendar.Events.DTSTART); + } + String duration = values.getAsString(Calendar.Events.DURATION); + String tzid = values.getAsString(Calendar.Events.EVENT_TIMEZONE); + String rruleStr = values.getAsString(Calendar.Events.RRULE); + String rdateStr = values.getAsString(Calendar.Events.RDATE); + String exruleStr = values.getAsString(Calendar.Events.EXRULE); + String exdateStr = values.getAsString(Calendar.Events.EXDATE); + boolean allDay = values.getAsInteger(Calendar.Events.ALL_DAY) == 1; + + if ((dtstart == -1) || + (TextUtils.isEmpty(duration))|| + ((TextUtils.isEmpty(rruleStr))&& + (TextUtils.isEmpty(rdateStr)))) { + // no recurrence. + return false; + } + + ICalendar.Property dtstartProp = new ICalendar.Property("DTSTART"); + Time dtstartTime = null; + if (!TextUtils.isEmpty(tzid)) { + if (!allDay) { + dtstartProp.addParameter(new ICalendar.Parameter("TZID", tzid)); + } + dtstartTime = new Time(tzid); + } else { + // use the "floating" timezone + dtstartTime = new Time(Time.TIMEZONE_UTC); + } + + dtstartTime.set(dtstart); + // make sure the time is printed just as a date, if all day. + // TODO: android.pim.Time really should take care of this for us. + if (allDay) { + dtstartProp.addParameter(new ICalendar.Parameter("VALUE", "DATE")); + dtstartTime.allDay = true; + dtstartTime.hour = 0; + dtstartTime.minute = 0; + dtstartTime.second = 0; + } + + dtstartProp.setValue(dtstartTime.format2445()); + component.addProperty(dtstartProp); + ICalendar.Property durationProp = new ICalendar.Property("DURATION"); + durationProp.setValue(duration); + component.addProperty(durationProp); + + addPropertiesForRuleStr(component, "RRULE", rruleStr); + addPropertyForDateStr(component, "RDATE", rdateStr); + addPropertiesForRuleStr(component, "EXRULE", exruleStr); + addPropertyForDateStr(component, "EXDATE", exdateStr); + return true; + } + private static void addPropertiesForRuleStr(ICalendar.Component component, String propertyName, String ruleStr) { @@ -351,10 +410,14 @@ public class RecurrenceSet { Time end = new Time(endTzid); end.parse(dtendProperty.getValue()); - long durationMillis = end.toMillis(false /* use isDst */) + long durationMillis = end.toMillis(false /* use isDst */) - start.toMillis(false /* use isDst */); long durationSeconds = (durationMillis / 1000); - return "P" + durationSeconds + "S"; + if (start.allDay && (durationSeconds % 86400) == 0) { + return "P" + (durationSeconds / 86400) + "D"; // Server wants this instead of P86400S + } else { + return "P" + durationSeconds + "S"; + } } private static String flattenProperties(ICalendar.Component component, diff --git a/core/java/android/pim/vcard/ContactStruct.java b/core/java/android/pim/vcard/ContactStruct.java new file mode 100644 index 0000000..46725d3 --- /dev/null +++ b/core/java/android/pim/vcard/ContactStruct.java @@ -0,0 +1,1244 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.content.AbstractSyncableContentProvider; +import android.content.ContentResolver; +import android.content.ContentUris; +import android.content.ContentValues; +import android.net.Uri; +import android.provider.Contacts; +import android.provider.Contacts.ContactMethods; +import android.provider.Contacts.Extensions; +import android.provider.Contacts.GroupMembership; +import android.provider.Contacts.Organizations; +import android.provider.Contacts.People; +import android.provider.Contacts.Phones; +import android.provider.Contacts.Photos; +import android.telephony.PhoneNumberUtils; +import android.text.TextUtils; +import android.util.Log; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Map.Entry; + +/** + * This class bridges between data structure of Contact app and VCard data. + */ +public class ContactStruct { + private static final String LOG_TAG = "ContactStruct"; + + /** + * @hide only for testing + */ + static public class PhoneData { + public final int type; + public final String data; + public final String label; + // isPrimary is changable only when there's no appropriate one existing in + // the original VCard. + public boolean isPrimary; + public PhoneData(int type, String data, String label, boolean isPrimary) { + this.type = type; + this.data = data; + this.label = label; + this.isPrimary = isPrimary; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof PhoneData) { + return false; + } + PhoneData phoneData = (PhoneData)obj; + return (type == phoneData.type && data.equals(phoneData.data) && + label.equals(phoneData.label) && isPrimary == phoneData.isPrimary); + } + + @Override + public String toString() { + return String.format("type: %d, data: %s, label: %s, isPrimary: %s", + type, data, label, isPrimary); + } + } + + /** + * @hide only for testing + */ + static public class ContactMethod { + // Contacts.KIND_EMAIL, Contacts.KIND_POSTAL + public final int kind; + // e.g. Contacts.ContactMethods.TYPE_HOME, Contacts.PhoneColumns.TYPE_HOME + // If type == Contacts.PhoneColumns.TYPE_CUSTOM, label is used. + public final int type; + public final String data; + // Used only when TYPE is TYPE_CUSTOM. + public final String label; + // isPrimary is changable only when there's no appropriate one existing in + // the original VCard. + public boolean isPrimary; + public ContactMethod(int kind, int type, String data, String label, + boolean isPrimary) { + this.kind = kind; + this.type = type; + this.data = data; + this.label = data; + this.isPrimary = isPrimary; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof ContactMethod) { + return false; + } + ContactMethod contactMethod = (ContactMethod)obj; + return (kind == contactMethod.kind && type == contactMethod.type && + data.equals(contactMethod.data) && label.equals(contactMethod.label) && + isPrimary == contactMethod.isPrimary); + } + + @Override + public String toString() { + return String.format("kind: %d, type: %d, data: %s, label: %s, isPrimary: %s", + kind, type, data, label, isPrimary); + } + } + + /** + * @hide only for testing + */ + static public class OrganizationData { + public final int type; + public final String companyName; + // can be changed in some VCard format. + public String positionName; + // isPrimary is changable only when there's no appropriate one existing in + // the original VCard. + public boolean isPrimary; + public OrganizationData(int type, String companyName, String positionName, + boolean isPrimary) { + this.type = type; + this.companyName = companyName; + this.positionName = positionName; + this.isPrimary = isPrimary; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof OrganizationData) { + return false; + } + OrganizationData organization = (OrganizationData)obj; + return (type == organization.type && companyName.equals(organization.companyName) && + positionName.equals(organization.positionName) && + isPrimary == organization.isPrimary); + } + + @Override + public String toString() { + return String.format("type: %d, company: %s, position: %s, isPrimary: %s", + type, companyName, positionName, isPrimary); + } + } + + static class Property { + private String mPropertyName; + private Map<String, Collection<String>> mParameterMap = + new HashMap<String, Collection<String>>(); + private List<String> mPropertyValueList = new ArrayList<String>(); + private byte[] mPropertyBytes; + + public Property() { + clear(); + } + + public void setPropertyName(final String propertyName) { + mPropertyName = propertyName; + } + + public void addParameter(final String paramName, final String paramValue) { + Collection<String> values; + if (mParameterMap.containsKey(paramName)) { + if (paramName.equals("TYPE")) { + values = new HashSet<String>(); + } else { + values = new ArrayList<String>(); + } + mParameterMap.put(paramName, values); + } else { + values = mParameterMap.get(paramName); + } + } + + public void addToPropertyValueList(final String propertyValue) { + mPropertyValueList.add(propertyValue); + } + + public void setPropertyBytes(final byte[] propertyBytes) { + mPropertyBytes = propertyBytes; + } + + public final Collection<String> getParameters(String type) { + return mParameterMap.get(type); + } + + public final List<String> getPropertyValueList() { + return mPropertyValueList; + } + + public void clear() { + mPropertyName = null; + mParameterMap.clear(); + mPropertyValueList.clear(); + } + } + + private String mName; + private String mPhoneticName; + // private String mPhotoType; + private byte[] mPhotoBytes; + private List<String> mNotes; + private List<PhoneData> mPhoneList; + private List<ContactMethod> mContactMethodList; + private List<OrganizationData> mOrganizationList; + private Map<String, List<String>> mExtensionMap; + + private int mNameOrderType; + + /* private variables bellow is for temporary use. */ + + // For name, there are three fields in vCard: FN, N, NAME. + // We prefer FN, which is a required field in vCard 3.0 , but not in vCard 2.1. + // Next, we prefer NAME, which is defined only in vCard 3.0. + // Finally, we use N, which is a little difficult to parse. + private String mTmpFullName; + private String mTmpNameFromNProperty; + + // Some vCard has "X-PHONETIC-FIRST-NAME", "X-PHONETIC-MIDDLE-NAME", and + // "X-PHONETIC-LAST-NAME" + private String mTmpXPhoneticFirstName; + private String mTmpXPhoneticMiddleName; + private String mTmpXPhoneticLastName; + + // Each Column of four properties has ISPRIMARY field + // (See android.provider.Contacts) + // If false even after the following loop, we choose the first + // entry as a "primary" entry. + private boolean mPrefIsSet_Address; + private boolean mPrefIsSet_Phone; + private boolean mPrefIsSet_Email; + private boolean mPrefIsSet_Organization; + + public ContactStruct() { + mNameOrderType = VCardConfig.NAME_ORDER_TYPE_DEFAULT; + } + + public ContactStruct(int nameOrderType) { + mNameOrderType = nameOrderType; + } + + /** + * @hide only for test + */ + public ContactStruct(String name, + String phoneticName, + byte[] photoBytes, + List<String> notes, + List<PhoneData> phoneList, + List<ContactMethod> contactMethodList, + List<OrganizationData> organizationList, + Map<String, List<String>> extensionMap) { + mName = name; + mPhoneticName = phoneticName; + mPhotoBytes = photoBytes; + mContactMethodList = contactMethodList; + mOrganizationList = organizationList; + mExtensionMap = extensionMap; + } + + /** + * @hide only for test + */ + public String getName() { + return mName; + } + + /** + * @hide only for test + */ + public String getPhoneticName() { + return mPhoneticName; + } + + /** + * @hide only for test + */ + public final byte[] getPhotoBytes() { + return mPhotoBytes; + } + + /** + * @hide only for test + */ + public final List<String> getNotes() { + return mNotes; + } + + /** + * @hide only for test + */ + public final List<PhoneData> getPhoneList() { + return mPhoneList; + } + + /** + * @hide only for test + */ + public final List<ContactMethod> getContactMethodList() { + return mContactMethodList; + } + + /** + * @hide only for test + */ + public final List<OrganizationData> getOrganizationList() { + return mOrganizationList; + } + + /** + * @hide only for test + */ + public final Map<String, List<String>> getExtensionMap() { + return mExtensionMap; + } + + /** + * Add a phone info to phoneList. + * @param data phone number + * @param type type col of content://contacts/phones + * @param label lable col of content://contacts/phones + */ + private void addPhone(int type, String data, String label, boolean isPrimary){ + if (mPhoneList == null) { + mPhoneList = new ArrayList<PhoneData>(); + } + StringBuilder builder = new StringBuilder(); + String trimed = data.trim(); + int length = trimed.length(); + for (int i = 0; i < length; i++) { + char ch = trimed.charAt(i); + if (('0' <= ch && ch <= '9') || (i == 0 && ch == '+')) { + builder.append(ch); + } + } + + PhoneData phoneData = new PhoneData(type, + PhoneNumberUtils.formatNumber(builder.toString()), + label, isPrimary); + + mPhoneList.add(phoneData); + } + + /** + * Add a contactmethod info to contactmethodList. + * @param kind integer value defined in Contacts.java + * (e.g. Contacts.KIND_EMAIL) + * @param type type col of content://contacts/contact_methods + * @param data contact data + * @param label extra string used only when kind is Contacts.KIND_CUSTOM. + */ + private void addContactmethod(int kind, int type, String data, + String label, boolean isPrimary){ + if (mContactMethodList == null) { + mContactMethodList = new ArrayList<ContactMethod>(); + } + mContactMethodList.add(new ContactMethod(kind, type, data, label, isPrimary)); + } + + /** + * Add a Organization info to organizationList. + */ + private void addOrganization(int type, String companyName, String positionName, + boolean isPrimary) { + if (mOrganizationList == null) { + mOrganizationList = new ArrayList<OrganizationData>(); + } + mOrganizationList.add(new OrganizationData(type, companyName, positionName, isPrimary)); + } + + /** + * Set "position" value to the appropriate data. If there's more than one + * OrganizationData objects, the value is set to the last one. If there's no + * OrganizationData object, a new OrganizationData is created, whose company name is + * empty. + * + * TODO: incomplete logic. fix this: + * + * e.g. This assumes ORG comes earlier, but TITLE may come earlier like this, though we do not + * know how to handle it in general cases... + * ---- + * TITLE:Software Engineer + * ORG:Google + * ---- + */ + private void setPosition(String positionValue) { + if (mOrganizationList == null) { + mOrganizationList = new ArrayList<OrganizationData>(); + } + int size = mOrganizationList.size(); + if (size == 0) { + addOrganization(Contacts.OrganizationColumns.TYPE_OTHER, "", null, false); + size = 1; + } + OrganizationData lastData = mOrganizationList.get(size - 1); + lastData.positionName = positionValue; + } + + private void addExtension(String propName, Map<String, Collection<String>> paramMap, + List<String> propValueList) { + if (propValueList.size() == 0) { + return; + } + // Now store the string into extensionMap. + List<String> list; + if (mExtensionMap == null) { + mExtensionMap = new HashMap<String, List<String>>(); + } + if (!mExtensionMap.containsKey(propName)){ + list = new ArrayList<String>(); + mExtensionMap.put(propName, list); + } else { + list = mExtensionMap.get(propName); + } + + list.add(encodeProperty(propName, paramMap, propValueList)); + } + + private String encodeProperty(String propName, Map<String, Collection<String>> paramMap, + List<String> propValueList) { + // PropertyNode#toString() is for reading, not for parsing in the future. + // We construct appropriate String here. + StringBuilder builder = new StringBuilder(); + if (propName.length() > 0) { + builder.append("propName:["); + builder.append(propName); + builder.append("],"); + } + + if (paramMap.size() > 0) { + builder.append("paramMap:["); + int size = paramMap.size(); + int i = 0; + for (Map.Entry<String, Collection<String>> entry : paramMap.entrySet()) { + String key = entry.getKey(); + for (String value : entry.getValue()) { + // Assuming param-key does not contain NON-ASCII nor symbols. + // TODO: check it. + // + // According to vCard 3.0: + // param-name = iana-token / x-name + builder.append(key); + + // param-value may contain any value including NON-ASCIIs. + // We use the following replacing rule. + // \ -> \\ + // , -> \, + // In String#replaceAll(), "\\\\" means a single backslash. + builder.append("="); + + // TODO: fix this. + builder.append(value.replaceAll("\\\\", "\\\\\\\\").replaceAll(",", "\\\\,")); + if (i < size -1) { + builder.append(","); + } + i++; + } + } + + builder.append("],"); + } + + int size = propValueList.size(); + if (size > 0) { + builder.append("propValue:["); + List<String> list = propValueList; + for (int i = 0; i < size; i++) { + // TODO: fix this. + builder.append(list.get(i).replaceAll("\\\\", "\\\\\\\\").replaceAll(",", "\\\\,")); + if (i < size -1) { + builder.append(","); + } + } + builder.append("],"); + } + + return builder.toString(); + } + + private static String getNameFromNProperty(List<String> elems, int nameOrderType) { + // Family, Given, Middle, Prefix, Suffix. (1 - 5) + int size = elems.size(); + if (size > 1) { + StringBuilder builder = new StringBuilder(); + boolean builderIsEmpty = true; + // Prefix + if (size > 3 && elems.get(3).length() > 0) { + builder.append(elems.get(3)); + builderIsEmpty = false; + } + String first, second; + if (nameOrderType == VCardConfig.NAME_ORDER_TYPE_JAPANESE) { + first = elems.get(0); + second = elems.get(1); + } else { + first = elems.get(1); + second = elems.get(0); + } + if (first.length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(first); + builderIsEmpty = false; + } + // Middle name + if (size > 2 && elems.get(2).length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(elems.get(2)); + builderIsEmpty = false; + } + if (second.length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(second); + builderIsEmpty = false; + } + // Suffix + if (size > 4 && elems.get(4).length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(elems.get(4)); + builderIsEmpty = false; + } + return builder.toString(); + } else if (size == 1) { + return elems.get(0); + } else { + return ""; + } + } + + public void addProperty(Property property) { + String propName = property.mPropertyName; + final Map<String, Collection<String>> paramMap = property.mParameterMap; + final List<String> propValueList = property.mPropertyValueList; + byte[] propBytes = property.mPropertyBytes; + + if (propValueList.size() == 0) { + return; + } + + String propValue = listToString(propValueList); + + if (propName.equals("VERSION")) { + // vCard version. Ignore this. + } else if (propName.equals("FN")) { + mTmpFullName = propValue; + } else if (propName.equals("NAME") && mTmpFullName == null) { + // Only in vCard 3.0. Use this if FN does not exist. + // Though, note that vCard 3.0 requires FN. + mTmpFullName = propValue; + } else if (propName.equals("N")) { + mTmpNameFromNProperty = getNameFromNProperty(propValueList, mNameOrderType); + } else if (propName.equals("SORT-STRING")) { + mPhoneticName = propValue; + } else if (propName.equals("SOUND")) { + if ("X-IRMC-N".equals(paramMap.get("TYPE")) && mPhoneticName == null) { + // Some Japanese mobile phones use this field for phonetic name, + // since vCard 2.1 does not have "SORT-STRING" type. + // Also, in some cases, the field has some ';'s in it. + // We remove them. + StringBuilder builder = new StringBuilder(); + String value = propValue; + int length = value.length(); + for (int i = 0; i < length; i++) { + char ch = value.charAt(i); + if (ch != ';') { + builder.append(ch); + } + } + if (builder.length() > 0) { + mPhoneticName = builder.toString(); + } + } else { + addExtension(propName, paramMap, propValueList); + } + } else if (propName.equals("ADR")) { + boolean valuesAreAllEmpty = true; + for (String value : propValueList) { + if (value.length() > 0) { + valuesAreAllEmpty = false; + break; + } + } + if (valuesAreAllEmpty) { + return; + } + + int kind = Contacts.KIND_POSTAL; + int type = -1; + String label = ""; + boolean isPrimary = false; + Collection<String> typeCollection = paramMap.get("TYPE"); + if (typeCollection != null) { + for (String typeString : typeCollection) { + if (typeString.equals("PREF") && !mPrefIsSet_Address) { + // Only first "PREF" is considered. + mPrefIsSet_Address = true; + isPrimary = true; + } else if (typeString.equalsIgnoreCase("HOME")) { + type = Contacts.ContactMethodsColumns.TYPE_HOME; + label = ""; + } else if (typeString.equalsIgnoreCase("WORK") || + typeString.equalsIgnoreCase("COMPANY")) { + // "COMPANY" seems emitted by Windows Mobile, which is not + // specifically supported by vCard 2.1. We assume this is same + // as "WORK". + type = Contacts.ContactMethodsColumns.TYPE_WORK; + label = ""; + } else if (typeString.equalsIgnoreCase("POSTAL")) { + kind = Contacts.KIND_POSTAL; + } else if (typeString.equalsIgnoreCase("PARCEL") || + typeString.equalsIgnoreCase("DOM") || + typeString.equalsIgnoreCase("INTL")) { + // We do not have a kind or type matching these. + // TODO: fix this. We may need to split entries into two. + // (e.g. entries for KIND_POSTAL and KIND_PERCEL) + } else if (typeString.toUpperCase().startsWith("X-") && + type < 0) { + type = Contacts.ContactMethodsColumns.TYPE_CUSTOM; + label = typeString.substring(2); + } else if (type < 0) { + // vCard 3.0 allows iana-token. Also some vCard 2.1 exporters + // emit non-standard types. We do not handle their values now. + type = Contacts.ContactMethodsColumns.TYPE_CUSTOM; + label = typeString; + } + } + } + // We use "HOME" as default + if (type < 0) { + type = Contacts.ContactMethodsColumns.TYPE_HOME; + } + + // adr-value = 0*6(text-value ";") text-value + // ; PO Box, Extended Address, Street, Locality, Region, Postal + // ; Code, Country Name + String address; + int size = propValueList.size(); + if (size > 1) { + StringBuilder builder = new StringBuilder(); + boolean builderIsEmpty = true; + if (Locale.getDefault().getCountry().equals(Locale.JAPAN.getCountry())) { + // In Japan, the order is reversed. + for (int i = size - 1; i >= 0; i--) { + String addressPart = propValueList.get(i); + if (addressPart.length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(addressPart); + builderIsEmpty = false; + } + } + } else { + for (int i = 0; i < size; i++) { + String addressPart = propValueList.get(i); + if (addressPart.length() > 0) { + if (!builderIsEmpty) { + builder.append(' '); + } + builder.append(addressPart); + builderIsEmpty = false; + } + } + } + address = builder.toString().trim(); + } else { + address = propValue; + } + addContactmethod(kind, type, address, label, isPrimary); + } else if (propName.equals("ORG")) { + // vCard specification does not specify other types. + int type = Contacts.OrganizationColumns.TYPE_WORK; + boolean isPrimary = false; + + Collection<String> typeCollection = paramMap.get("TYPE"); + if (typeCollection != null) { + for (String typeString : typeCollection) { + if (typeString.equals("PREF") && !mPrefIsSet_Organization) { + // vCard specification officially does not have PREF in ORG. + // This is just for safety. + mPrefIsSet_Organization = true; + isPrimary = true; + } + // XXX: Should we cope with X- words? + } + } + + int size = propValueList.size(); + StringBuilder builder = new StringBuilder(); + for (Iterator<String> iter = propValueList.iterator(); iter.hasNext();) { + builder.append(iter.next()); + if (iter.hasNext()) { + builder.append(' '); + } + } + + addOrganization(type, builder.toString(), "", isPrimary); + } else if (propName.equals("TITLE")) { + setPosition(propValue); + } else if (propName.equals("ROLE")) { + setPosition(propValue); + } else if ((propName.equals("PHOTO") || (propName.equals("LOGO")) && mPhotoBytes == null)) { + // We prefer PHOTO to LOGO. + Collection<String> paramMapValue = paramMap.get("VALUE"); + if (paramMapValue != null && paramMapValue.contains("URL")) { + // TODO: do something. + } else { + // Assume PHOTO is stored in BASE64. In that case, + // data is already stored in propValue_bytes in binary form. + // It should be automatically done by VBuilder (VDataBuilder/VCardDatabuilder) + mPhotoBytes = propBytes; + /* + Collection<String> typeCollection = paramMap.get("TYPE"); + if (typeCollection != null) { + if (typeCollection.size() > 1) { + StringBuilder builder = new StringBuilder(); + int size = typeCollection.size(); + int i = 0; + for (String type : typeCollection) { + builder.append(type); + if (i < size - 1) { + builder.append(','); + } + i++; + } + Log.w(LOG_TAG, "There is more than TYPE: " + builder.toString()); + } + mPhotoType = typeCollection.iterator().next(); + }*/ + } + } else if (propName.equals("EMAIL")) { + int type = -1; + String label = null; + boolean isPrimary = false; + Collection<String> typeCollection = paramMap.get("TYPE"); + if (typeCollection != null) { + for (String typeString : typeCollection) { + if (typeString.equals("PREF") && !mPrefIsSet_Email) { + // Only first "PREF" is considered. + mPrefIsSet_Email = true; + isPrimary = true; + } else if (typeString.equalsIgnoreCase("HOME")) { + type = Contacts.ContactMethodsColumns.TYPE_HOME; + } else if (typeString.equalsIgnoreCase("WORK")) { + type = Contacts.ContactMethodsColumns.TYPE_WORK; + } else if (typeString.equalsIgnoreCase("CELL")) { + // We do not have Contacts.ContactMethodsColumns.TYPE_MOBILE yet. + type = Contacts.ContactMethodsColumns.TYPE_CUSTOM; + label = Contacts.ContactMethodsColumns.MOBILE_EMAIL_TYPE_NAME; + } else if (typeString.toUpperCase().startsWith("X-") && + type < 0) { + type = Contacts.ContactMethodsColumns.TYPE_CUSTOM; + label = typeString.substring(2); + } else if (type < 0) { + // vCard 3.0 allows iana-token. + // We may have INTERNET (specified in vCard spec), + // SCHOOL, etc. + type = Contacts.ContactMethodsColumns.TYPE_CUSTOM; + label = typeString; + } + } + } + if (type < 0) { + type = Contacts.ContactMethodsColumns.TYPE_OTHER; + } + addContactmethod(Contacts.KIND_EMAIL, type, propValue,label, isPrimary); + } else if (propName.equals("TEL")) { + int type = -1; + String label = null; + boolean isPrimary = false; + boolean isFax = false; + Collection<String> typeCollection = paramMap.get("TYPE"); + if (typeCollection != null) { + for (String typeString : typeCollection) { + if (typeString.equals("PREF") && !mPrefIsSet_Phone) { + // Only first "PREF" is considered. + mPrefIsSet_Phone = true; + isPrimary = true; + } else if (typeString.equalsIgnoreCase("HOME")) { + type = Contacts.PhonesColumns.TYPE_HOME; + } else if (typeString.equalsIgnoreCase("WORK")) { + type = Contacts.PhonesColumns.TYPE_WORK; + } else if (typeString.equalsIgnoreCase("CELL")) { + type = Contacts.PhonesColumns.TYPE_MOBILE; + } else if (typeString.equalsIgnoreCase("PAGER")) { + type = Contacts.PhonesColumns.TYPE_PAGER; + } else if (typeString.equalsIgnoreCase("FAX")) { + isFax = true; + } else if (typeString.equalsIgnoreCase("VOICE") || + typeString.equalsIgnoreCase("MSG")) { + // Defined in vCard 3.0. Ignore these because they + // conflict with "HOME", "WORK", etc. + // XXX: do something? + } else if (typeString.toUpperCase().startsWith("X-") && + type < 0) { + type = Contacts.PhonesColumns.TYPE_CUSTOM; + label = typeString.substring(2); + } else if (type < 0){ + // We may have MODEM, CAR, ISDN, etc... + type = Contacts.PhonesColumns.TYPE_CUSTOM; + label = typeString; + } + } + } + if (type < 0) { + type = Contacts.PhonesColumns.TYPE_HOME; + } + if (isFax) { + if (type == Contacts.PhonesColumns.TYPE_HOME) { + type = Contacts.PhonesColumns.TYPE_FAX_HOME; + } else if (type == Contacts.PhonesColumns.TYPE_WORK) { + type = Contacts.PhonesColumns.TYPE_FAX_WORK; + } + } + + addPhone(type, propValue, label, isPrimary); + } else if (propName.equals("NOTE")) { + if (mNotes == null) { + mNotes = new ArrayList<String>(1); + } + mNotes.add(propValue); + } else if (propName.equals("BDAY")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("URL")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("REV")) { + // Revision of this VCard entry. I think we can ignore this. + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("UID")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("KEY")) { + // Type is X509 or PGP? I don't know how to handle this... + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("MAILER")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("TZ")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("GEO")) { + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("NICKNAME")) { + // vCard 3.0 only. + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("CLASS")) { + // vCard 3.0 only. + // e.g. CLASS:CONFIDENTIAL + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("PROFILE")) { + // VCard 3.0 only. Must be "VCARD". I think we can ignore this. + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("CATEGORIES")) { + // VCard 3.0 only. + // e.g. CATEGORIES:INTERNET,IETF,INDUSTRY,INFORMATION TECHNOLOGY + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("SOURCE")) { + // VCard 3.0 only. + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("PRODID")) { + // VCard 3.0 only. + // To specify the identifier for the product that created + // the vCard object. + addExtension(propName, paramMap, propValueList); + } else if (propName.equals("X-PHONETIC-FIRST-NAME")) { + mTmpXPhoneticFirstName = propValue; + } else if (propName.equals("X-PHONETIC-MIDDLE-NAME")) { + mTmpXPhoneticMiddleName = propValue; + } else if (propName.equals("X-PHONETIC-LAST-NAME")) { + mTmpXPhoneticLastName = propValue; + } else { + // Unknown X- words and IANA token. + addExtension(propName, paramMap, propValueList); + } + } + + public String displayString() { + if (mName.length() > 0) { + return mName; + } + if (mContactMethodList != null && mContactMethodList.size() > 0) { + for (ContactMethod contactMethod : mContactMethodList) { + if (contactMethod.kind == Contacts.KIND_EMAIL && contactMethod.isPrimary) { + return contactMethod.data; + } + } + } + if (mPhoneList != null && mPhoneList.size() > 0) { + for (PhoneData phoneData : mPhoneList) { + if (phoneData.isPrimary) { + return phoneData.data; + } + } + } + return ""; + } + + /** + * Consolidate several fielsds (like mName) using name candidates, + */ + public void consolidateFields() { + if (mTmpFullName != null) { + mName = mTmpFullName; + } else if(mTmpNameFromNProperty != null) { + mName = mTmpNameFromNProperty; + } else { + mName = ""; + } + + if (mPhoneticName == null && + (mTmpXPhoneticFirstName != null || mTmpXPhoneticMiddleName != null || + mTmpXPhoneticLastName != null)) { + // Note: In Europe, this order should be "LAST FIRST MIDDLE". See the comment around + // NAME_ORDER_TYPE_* for more detail. + String first; + String second; + if (mNameOrderType == VCardConfig.NAME_ORDER_TYPE_JAPANESE) { + first = mTmpXPhoneticLastName; + second = mTmpXPhoneticFirstName; + } else { + first = mTmpXPhoneticFirstName; + second = mTmpXPhoneticLastName; + } + StringBuilder builder = new StringBuilder(); + if (first != null) { + builder.append(first); + } + if (mTmpXPhoneticMiddleName != null) { + builder.append(mTmpXPhoneticMiddleName); + } + if (second != null) { + builder.append(second); + } + mPhoneticName = builder.toString(); + } + + // Remove unnecessary white spaces. + // It is found that some mobile phone emits phonetic name with just one white space + // when a user does not specify one. + // This logic is effective toward such kind of weird data. + if (mPhoneticName != null) { + mPhoneticName = mPhoneticName.trim(); + } + + // If there is no "PREF", we choose the first entries as primary. + if (!mPrefIsSet_Phone && mPhoneList != null && mPhoneList.size() > 0) { + mPhoneList.get(0).isPrimary = true; + } + + if (!mPrefIsSet_Address && mContactMethodList != null) { + for (ContactMethod contactMethod : mContactMethodList) { + if (contactMethod.kind == Contacts.KIND_POSTAL) { + contactMethod.isPrimary = true; + break; + } + } + } + if (!mPrefIsSet_Email && mContactMethodList != null) { + for (ContactMethod contactMethod : mContactMethodList) { + if (contactMethod.kind == Contacts.KIND_EMAIL) { + contactMethod.isPrimary = true; + break; + } + } + } + if (!mPrefIsSet_Organization && mOrganizationList != null && mOrganizationList.size() > 0) { + mOrganizationList.get(0).isPrimary = true; + } + + } + + private void pushIntoContentProviderOrResolver(Object contentSomething, + long myContactsGroupId) { + ContentResolver resolver = null; + AbstractSyncableContentProvider provider = null; + if (contentSomething instanceof ContentResolver) { + resolver = (ContentResolver)contentSomething; + } else if (contentSomething instanceof AbstractSyncableContentProvider) { + provider = (AbstractSyncableContentProvider)contentSomething; + } else { + Log.e(LOG_TAG, "Unsupported object came."); + return; + } + + ContentValues contentValues = new ContentValues(); + contentValues.put(People.NAME, mName); + contentValues.put(People.PHONETIC_NAME, mPhoneticName); + + if (mNotes != null && mNotes.size() > 0) { + if (mNotes.size() > 1) { + StringBuilder builder = new StringBuilder(); + for (String note : mNotes) { + builder.append(note); + builder.append("\n"); + } + contentValues.put(People.NOTES, builder.toString()); + } else { + contentValues.put(People.NOTES, mNotes.get(0)); + } + } + + Uri personUri; + long personId = 0; + if (resolver != null) { + personUri = Contacts.People.createPersonInMyContactsGroup(resolver, contentValues); + if (personUri != null) { + personId = ContentUris.parseId(personUri); + } + } else { + personUri = provider.insert(People.CONTENT_URI, contentValues); + if (personUri != null) { + personId = ContentUris.parseId(personUri); + ContentValues values = new ContentValues(); + values.put(GroupMembership.PERSON_ID, personId); + values.put(GroupMembership.GROUP_ID, myContactsGroupId); + Uri resultUri = provider.insert(GroupMembership.CONTENT_URI, values); + if (resultUri == null) { + Log.e(LOG_TAG, "Faild to insert the person to MyContact."); + provider.delete(personUri, null, null); + personUri = null; + } + } + } + + if (personUri == null) { + Log.e(LOG_TAG, "Failed to create the contact."); + return; + } + + if (mPhotoBytes != null) { + if (resolver != null) { + People.setPhotoData(resolver, personUri, mPhotoBytes); + } else { + Uri photoUri = Uri.withAppendedPath(personUri, Contacts.Photos.CONTENT_DIRECTORY); + ContentValues values = new ContentValues(); + values.put(Photos.DATA, mPhotoBytes); + provider.update(photoUri, values, null, null); + } + } + + long primaryPhoneId = -1; + if (mPhoneList != null && mPhoneList.size() > 0) { + for (PhoneData phoneData : mPhoneList) { + ContentValues values = new ContentValues(); + values.put(Contacts.PhonesColumns.TYPE, phoneData.type); + if (phoneData.type == Contacts.PhonesColumns.TYPE_CUSTOM) { + values.put(Contacts.PhonesColumns.LABEL, phoneData.label); + } + // Already formatted. + values.put(Contacts.PhonesColumns.NUMBER, phoneData.data); + + // Not sure about Contacts.PhonesColumns.NUMBER_KEY ... + values.put(Contacts.PhonesColumns.ISPRIMARY, 1); + values.put(Contacts.Phones.PERSON_ID, personId); + Uri phoneUri; + if (resolver != null) { + phoneUri = resolver.insert(Phones.CONTENT_URI, values); + } else { + phoneUri = provider.insert(Phones.CONTENT_URI, values); + } + if (phoneData.isPrimary) { + primaryPhoneId = Long.parseLong(phoneUri.getLastPathSegment()); + } + } + } + + long primaryOrganizationId = -1; + if (mOrganizationList != null && mOrganizationList.size() > 0) { + for (OrganizationData organizationData : mOrganizationList) { + ContentValues values = new ContentValues(); + // Currently, we do not use TYPE_CUSTOM. + values.put(Contacts.OrganizationColumns.TYPE, + organizationData.type); + values.put(Contacts.OrganizationColumns.COMPANY, + organizationData.companyName); + values.put(Contacts.OrganizationColumns.TITLE, + organizationData.positionName); + values.put(Contacts.OrganizationColumns.ISPRIMARY, 1); + values.put(Contacts.OrganizationColumns.PERSON_ID, personId); + + Uri organizationUri; + if (resolver != null) { + organizationUri = resolver.insert(Organizations.CONTENT_URI, values); + } else { + organizationUri = provider.insert(Organizations.CONTENT_URI, values); + } + if (organizationData.isPrimary) { + primaryOrganizationId = Long.parseLong(organizationUri.getLastPathSegment()); + } + } + } + + long primaryEmailId = -1; + if (mContactMethodList != null && mContactMethodList.size() > 0) { + for (ContactMethod contactMethod : mContactMethodList) { + ContentValues values = new ContentValues(); + values.put(Contacts.ContactMethodsColumns.KIND, contactMethod.kind); + values.put(Contacts.ContactMethodsColumns.TYPE, contactMethod.type); + if (contactMethod.type == Contacts.ContactMethodsColumns.TYPE_CUSTOM) { + values.put(Contacts.ContactMethodsColumns.LABEL, contactMethod.label); + } + values.put(Contacts.ContactMethodsColumns.DATA, contactMethod.data); + values.put(Contacts.ContactMethodsColumns.ISPRIMARY, 1); + values.put(Contacts.ContactMethods.PERSON_ID, personId); + + if (contactMethod.kind == Contacts.KIND_EMAIL) { + Uri emailUri; + if (resolver != null) { + emailUri = resolver.insert(ContactMethods.CONTENT_URI, values); + } else { + emailUri = provider.insert(ContactMethods.CONTENT_URI, values); + } + if (contactMethod.isPrimary) { + primaryEmailId = Long.parseLong(emailUri.getLastPathSegment()); + } + } else { // probably KIND_POSTAL + if (resolver != null) { + resolver.insert(ContactMethods.CONTENT_URI, values); + } else { + provider.insert(ContactMethods.CONTENT_URI, values); + } + } + } + } + + if (mExtensionMap != null && mExtensionMap.size() > 0) { + ArrayList<ContentValues> contentValuesArray; + if (resolver != null) { + contentValuesArray = new ArrayList<ContentValues>(); + } else { + contentValuesArray = null; + } + for (Entry<String, List<String>> entry : mExtensionMap.entrySet()) { + String key = entry.getKey(); + List<String> list = entry.getValue(); + for (String value : list) { + ContentValues values = new ContentValues(); + values.put(Extensions.NAME, key); + values.put(Extensions.VALUE, value); + values.put(Extensions.PERSON_ID, personId); + if (resolver != null) { + contentValuesArray.add(values); + } else { + provider.insert(Extensions.CONTENT_URI, values); + } + } + } + if (resolver != null) { + resolver.bulkInsert(Extensions.CONTENT_URI, + contentValuesArray.toArray(new ContentValues[0])); + } + } + + if (primaryPhoneId >= 0 || primaryOrganizationId >= 0 || primaryEmailId >= 0) { + ContentValues values = new ContentValues(); + if (primaryPhoneId >= 0) { + values.put(People.PRIMARY_PHONE_ID, primaryPhoneId); + } + if (primaryOrganizationId >= 0) { + values.put(People.PRIMARY_ORGANIZATION_ID, primaryOrganizationId); + } + if (primaryEmailId >= 0) { + values.put(People.PRIMARY_EMAIL_ID, primaryEmailId); + } + if (resolver != null) { + resolver.update(personUri, values, null, null); + } else { + provider.update(personUri, values, null, null); + } + } + } + + /** + * Push this object into database in the resolver. + */ + public void pushIntoContentResolver(ContentResolver resolver) { + pushIntoContentProviderOrResolver(resolver, 0); + } + + /** + * Push this object into AbstractSyncableContentProvider object. + * {@link #consolidateFields() must be called before this method is called} + * @hide + */ + public void pushIntoAbstractSyncableContentProvider( + AbstractSyncableContentProvider provider, long myContactsGroupId) { + boolean successful = false; + provider.beginBatch(); + try { + pushIntoContentProviderOrResolver(provider, myContactsGroupId); + successful = true; + } finally { + provider.endBatch(successful); + } + } + + public boolean isIgnorable() { + return TextUtils.isEmpty(mName) && + TextUtils.isEmpty(mPhoneticName) && + (mPhoneList == null || mPhoneList.size() == 0) && + (mContactMethodList == null || mContactMethodList.size() == 0); + } + + private String listToString(List<String> list){ + final int size = list.size(); + if (size > 1) { + StringBuilder builder = new StringBuilder(); + int i = 0; + for (String type : list) { + builder.append(type); + if (i < size - 1) { + builder.append(";"); + } + } + return builder.toString(); + } else if (size == 1) { + return list.get(0); + } else { + return ""; + } + } +} diff --git a/core/java/android/pim/vcard/EntryCommitter.java b/core/java/android/pim/vcard/EntryCommitter.java new file mode 100644 index 0000000..e26fac5 --- /dev/null +++ b/core/java/android/pim/vcard/EntryCommitter.java @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.content.AbstractSyncableContentProvider; +import android.content.ContentProvider; +import android.content.ContentResolver; +import android.content.IContentProvider; +import android.provider.Contacts; +import android.util.Log; + +/** + * EntryHandler implementation which commits the entry to Contacts Provider + */ +public class EntryCommitter implements EntryHandler { + public static String LOG_TAG = "vcard.EntryComitter"; + + private ContentResolver mContentResolver; + + // Ideally, this should be ContactsProvider but it seems Class loader cannot find it, + // even when it is subclass of ContactsProvider... + private AbstractSyncableContentProvider mProvider; + private long mMyContactsGroupId; + + private long mTimeToCommit; + + public EntryCommitter(ContentResolver resolver) { + mContentResolver = resolver; + + tryGetOriginalProvider(); + } + + public void onFinal() { + if (VCardConfig.showPerformanceLog()) { + Log.d(LOG_TAG, + String.format("time to commit entries: %ld ms", mTimeToCommit)); + } + } + + private void tryGetOriginalProvider() { + final ContentResolver resolver = mContentResolver; + + if ((mMyContactsGroupId = Contacts.People.tryGetMyContactsGroupId(resolver)) == 0) { + Log.e(LOG_TAG, "Could not get group id of MyContact"); + return; + } + + IContentProvider iProviderForName = resolver.acquireProvider(Contacts.CONTENT_URI); + ContentProvider contentProvider = + ContentProvider.coerceToLocalContentProvider(iProviderForName); + if (contentProvider == null) { + Log.e(LOG_TAG, "Fail to get ContentProvider object."); + return; + } + + if (!(contentProvider instanceof AbstractSyncableContentProvider)) { + Log.e(LOG_TAG, + "Acquired ContentProvider object is not AbstractSyncableContentProvider."); + return; + } + + mProvider = (AbstractSyncableContentProvider)contentProvider; + } + + public void onEntryCreated(final ContactStruct contactStruct) { + long start = System.currentTimeMillis(); + if (mProvider != null) { + contactStruct.pushIntoAbstractSyncableContentProvider( + mProvider, mMyContactsGroupId); + } else { + contactStruct.pushIntoContentResolver(mContentResolver); + } + mTimeToCommit += System.currentTimeMillis() - start; + } +}
\ No newline at end of file diff --git a/core/java/android/pim/vcard/EntryHandler.java b/core/java/android/pim/vcard/EntryHandler.java new file mode 100644 index 0000000..4015cb5 --- /dev/null +++ b/core/java/android/pim/vcard/EntryHandler.java @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +/** + * Unlike VCardBuilderBase, this (and VCardDataBuilder) assumes + * "each VCard entry should be correctly parsed and passed to each EntryHandler object", + */ +public interface EntryHandler { + /** + * Able to be use this method for showing performance log, etc. + * TODO: better name? + */ + public void onFinal(); + + /** + * The method called when one VCard entry is successfully created + */ + public void onEntryCreated(final ContactStruct entry); +} diff --git a/core/java/android/pim/vcard/VCardBuilder.java b/core/java/android/pim/vcard/VCardBuilder.java new file mode 100644 index 0000000..e1c4b33 --- /dev/null +++ b/core/java/android/pim/vcard/VCardBuilder.java @@ -0,0 +1,64 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import java.util.List; + +public interface VCardBuilder { + void start(); + + void end(); + + /** + * BEGIN:VCARD + */ + void startRecord(String type); + + /** END:VXX */ + void endRecord(); + + void startProperty(); + + void endProperty(); + + /** + * @param group + */ + void propertyGroup(String group); + + /** + * @param name + * N <br> + * N + */ + void propertyName(String name); + + /** + * @param type + * LANGUAGE \ ENCODING <br> + * ;LANGUage= \ ;ENCODING= + */ + void propertyParamType(String type); + + /** + * @param value + * FR-EN \ GBK <br> + * FR-EN \ GBK + */ + void propertyParamValue(String value); + + void propertyValues(List<String> values); +} diff --git a/core/java/android/pim/vcard/VCardBuilderCollection.java b/core/java/android/pim/vcard/VCardBuilderCollection.java new file mode 100644 index 0000000..e3985b6 --- /dev/null +++ b/core/java/android/pim/vcard/VCardBuilderCollection.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import java.util.Collection; +import java.util.List; + +public class VCardBuilderCollection implements VCardBuilder { + + private final Collection<VCardBuilder> mVCardBuilderCollection; + + public VCardBuilderCollection(Collection<VCardBuilder> vBuilderCollection) { + mVCardBuilderCollection = vBuilderCollection; + } + + public Collection<VCardBuilder> getVCardBuilderBaseCollection() { + return mVCardBuilderCollection; + } + + public void start() { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.start(); + } + } + + public void end() { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.end(); + } + } + + public void startRecord(String type) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.startRecord(type); + } + } + + public void endRecord() { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.endRecord(); + } + } + + public void startProperty() { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.startProperty(); + } + } + + + public void endProperty() { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.endProperty(); + } + } + + public void propertyGroup(String group) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.propertyGroup(group); + } + } + + public void propertyName(String name) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.propertyName(name); + } + } + + public void propertyParamType(String type) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.propertyParamType(type); + } + } + + public void propertyParamValue(String value) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.propertyParamValue(value); + } + } + + public void propertyValues(List<String> values) { + for (VCardBuilder builder : mVCardBuilderCollection) { + builder.propertyValues(values); + } + } +} diff --git a/core/java/android/pim/vcard/VCardConfig.java b/core/java/android/pim/vcard/VCardConfig.java new file mode 100644 index 0000000..fef9dba --- /dev/null +++ b/core/java/android/pim/vcard/VCardConfig.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +/** + * The class representing VCard related configurations + */ +public class VCardConfig { + static final int LOG_LEVEL_NONE = 0; + static final int LOG_LEVEL_PERFORMANCE_MEASUREMENT = 0x1; + static final int LOG_LEVEL_SHOW_WARNING = 0x2; + static final int LOG_LEVEL_VERBOSE = + LOG_LEVEL_PERFORMANCE_MEASUREMENT | LOG_LEVEL_SHOW_WARNING; + + // Assumes that "iso-8859-1" is able to map "all" 8bit characters to some unicode and + // decode the unicode to the original charset. If not, this setting will cause some bug. + public static final String DEFAULT_CHARSET = "iso-8859-1"; + + // TODO: use this flag + public static boolean IGNORE_CASE_EXCEPT_VALUE = true; + + protected static final int LOG_LEVEL = LOG_LEVEL_PERFORMANCE_MEASUREMENT; + + // Note: phonetic name probably should be "LAST FIRST MIDDLE" for European languages, and + // space should be added between each element while it should not be in Japanese. + // But unfortunately, we currently do not have the data and are not sure whether we should + // support European version of name ordering. + // + // TODO: Implement the logic described above if we really need European version of + // phonetic name handling. Also, adding the appropriate test case of vCard would be + // highly appreciated. + public static final int NAME_ORDER_TYPE_ENGLISH = 0; + public static final int NAME_ORDER_TYPE_JAPANESE = 1; + + public static final int NAME_ORDER_TYPE_DEFAULT = NAME_ORDER_TYPE_ENGLISH; + + /** + * @hide temporal. may be deleted + */ + public static boolean showPerformanceLog() { + return (LOG_LEVEL & LOG_LEVEL_PERFORMANCE_MEASUREMENT) != 0; + } + + private VCardConfig() { + } +}
\ No newline at end of file diff --git a/core/java/android/pim/vcard/VCardDataBuilder.java b/core/java/android/pim/vcard/VCardDataBuilder.java new file mode 100644 index 0000000..4025f6c --- /dev/null +++ b/core/java/android/pim/vcard/VCardDataBuilder.java @@ -0,0 +1,319 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.util.CharsetUtils; +import android.util.Log; + +import org.apache.commons.codec.DecoderException; +import org.apache.commons.codec.binary.Base64; +import org.apache.commons.codec.net.QuotedPrintableCodec; + +import java.io.UnsupportedEncodingException; +import java.nio.ByteBuffer; +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +/** + * VBuilder for VCard. VCard may contain big photo images encoded by BASE64, + * If we store all VNode entries in memory like VDataBuilder.java, + * OutOfMemoryError may be thrown. Thus, this class push each VCard entry into + * ContentResolver immediately. + */ +public class VCardDataBuilder implements VCardBuilder { + static private String LOG_TAG = "VCardDataBuilder"; + + /** + * If there's no other information available, this class uses this charset for encoding + * byte arrays. + */ + static public String TARGET_CHARSET = "UTF-8"; + + private ContactStruct.Property mCurrentProperty = new ContactStruct.Property(); + private ContactStruct mCurrentContactStruct; + private String mParamType; + + /** + * The charset using which VParser parses the text. + */ + private String mSourceCharset; + + /** + * The charset with which byte array is encoded to String. + */ + private String mTargetCharset; + private boolean mStrictLineBreakParsing; + + private int mNameOrderType; + + // Just for testing. + private long mTimePushIntoContentResolver; + + private List<EntryHandler> mEntryHandlers = new ArrayList<EntryHandler>(); + + public VCardDataBuilder() { + this(null, null, false, VCardConfig.NAME_ORDER_TYPE_DEFAULT); + } + + /** + * @hide + */ + public VCardDataBuilder(int nameOrderType) { + this(null, null, false, nameOrderType); + } + + /** + * @hide + */ + public VCardDataBuilder(String charset, + boolean strictLineBreakParsing, + int nameOrderType) { + this(null, charset, strictLineBreakParsing, nameOrderType); + } + + /** + * @hide + */ + public VCardDataBuilder(String sourceCharset, + String targetCharset, + boolean strictLineBreakParsing, + int nameOrderType) { + if (sourceCharset != null) { + mSourceCharset = sourceCharset; + } else { + mSourceCharset = VCardConfig.DEFAULT_CHARSET; + } + if (targetCharset != null) { + mTargetCharset = targetCharset; + } else { + mTargetCharset = TARGET_CHARSET; + } + mStrictLineBreakParsing = strictLineBreakParsing; + mNameOrderType = nameOrderType; + } + + public void addEntryHandler(EntryHandler entryHandler) { + mEntryHandlers.add(entryHandler); + } + + public void start() { + } + + public void end() { + for (EntryHandler entryHandler : mEntryHandlers) { + entryHandler.onFinal(); + } + } + + /** + * Assume that VCard is not nested. In other words, this code does not accept + */ + public void startRecord(String type) { + // TODO: add the method clear() instead of using null for reducing GC? + if (mCurrentContactStruct != null) { + // This means startRecord() is called inside startRecord() - endRecord() block. + // TODO: should throw some Exception + Log.e(LOG_TAG, "Nested VCard code is not supported now."); + } + if (!type.equalsIgnoreCase("VCARD")) { + // TODO: add test case for this + Log.e(LOG_TAG, "This is not VCARD!"); + } + + mCurrentContactStruct = new ContactStruct(mNameOrderType); + } + + public void endRecord() { + mCurrentContactStruct.consolidateFields(); + for (EntryHandler entryHandler : mEntryHandlers) { + entryHandler.onEntryCreated(mCurrentContactStruct); + } + mCurrentContactStruct = null; + } + + public void startProperty() { + mCurrentProperty.clear(); + } + + public void endProperty() { + mCurrentContactStruct.addProperty(mCurrentProperty); + } + + public void propertyName(String name) { + mCurrentProperty.setPropertyName(name); + } + + public void propertyGroup(String group) { + // ContactStruct does not support Group. + } + + public void propertyParamType(String type) { + if (mParamType != null) { + Log.e(LOG_TAG, + "propertyParamType() is called more than once " + + "before propertyParamValue() is called"); + } + mParamType = type; + } + + public void propertyParamValue(String value) { + if (mParamType == null) { + mParamType = "TYPE"; + } + mCurrentProperty.addParameter(mParamType, value); + mParamType = null; + } + + private String encodeString(String originalString, String targetCharset) { + if (mSourceCharset.equalsIgnoreCase(targetCharset)) { + return originalString; + } + Charset charset = Charset.forName(mSourceCharset); + ByteBuffer byteBuffer = charset.encode(originalString); + // byteBuffer.array() "may" return byte array which is larger than + // byteBuffer.remaining(). Here, we keep on the safe side. + byte[] bytes = new byte[byteBuffer.remaining()]; + byteBuffer.get(bytes); + try { + return new String(bytes, targetCharset); + } catch (UnsupportedEncodingException e) { + Log.e(LOG_TAG, "Failed to encode: charset=" + targetCharset); + return null; + } + } + + private String handleOneValue(String value, String targetCharset, String encoding) { + if (encoding != null) { + if (encoding.equals("BASE64") || encoding.equals("B")) { + mCurrentProperty.setPropertyBytes(Base64.decodeBase64(value.getBytes())); + return value; + } else if (encoding.equals("QUOTED-PRINTABLE")) { + // "= " -> " ", "=\t" -> "\t". + // Previous code had done this replacement. Keep on the safe side. + StringBuilder builder = new StringBuilder(); + int length = value.length(); + for (int i = 0; i < length; i++) { + char ch = value.charAt(i); + if (ch == '=' && i < length - 1) { + char nextCh = value.charAt(i + 1); + if (nextCh == ' ' || nextCh == '\t') { + + builder.append(nextCh); + i++; + continue; + } + } + builder.append(ch); + } + String quotedPrintable = builder.toString(); + + String[] lines; + if (mStrictLineBreakParsing) { + lines = quotedPrintable.split("\r\n"); + } else { + builder = new StringBuilder(); + length = quotedPrintable.length(); + ArrayList<String> list = new ArrayList<String>(); + for (int i = 0; i < length; i++) { + char ch = quotedPrintable.charAt(i); + if (ch == '\n') { + list.add(builder.toString()); + builder = new StringBuilder(); + } else if (ch == '\r') { + list.add(builder.toString()); + builder = new StringBuilder(); + if (i < length - 1) { + char nextCh = quotedPrintable.charAt(i + 1); + if (nextCh == '\n') { + i++; + } + } + } else { + builder.append(ch); + } + } + String finalLine = builder.toString(); + if (finalLine.length() > 0) { + list.add(finalLine); + } + lines = list.toArray(new String[0]); + } + + builder = new StringBuilder(); + for (String line : lines) { + if (line.endsWith("=")) { + line = line.substring(0, line.length() - 1); + } + builder.append(line); + } + byte[] bytes; + try { + bytes = builder.toString().getBytes(mSourceCharset); + } catch (UnsupportedEncodingException e1) { + Log.e(LOG_TAG, "Failed to encode: charset=" + mSourceCharset); + bytes = builder.toString().getBytes(); + } + + try { + bytes = QuotedPrintableCodec.decodeQuotedPrintable(bytes); + } catch (DecoderException e) { + Log.e(LOG_TAG, "Failed to decode quoted-printable: " + e); + return ""; + } + + try { + return new String(bytes, targetCharset); + } catch (UnsupportedEncodingException e) { + Log.e(LOG_TAG, "Failed to encode: charset=" + targetCharset); + return new String(bytes); + } + } + // Unknown encoding. Fall back to default. + } + return encodeString(value, targetCharset); + } + + public void propertyValues(List<String> values) { + if (values == null || values.size() == 0) { + return; + } + + final Collection<String> charsetCollection = mCurrentProperty.getParameters("CHARSET"); + String charset = + ((charsetCollection != null) ? charsetCollection.iterator().next() : null); + String targetCharset = CharsetUtils.nameForDefaultVendor(charset); + + final Collection<String> encodingCollection = mCurrentProperty.getParameters("ENCODING"); + String encoding = + ((encodingCollection != null) ? encodingCollection.iterator().next() : null); + + if (targetCharset == null || targetCharset.length() == 0) { + targetCharset = mTargetCharset; + } + + for (String value : values) { + mCurrentProperty.addToPropertyValueList( + handleOneValue(value, targetCharset, encoding)); + } + } + + public void showPerformanceInfo() { + Log.d(LOG_TAG, "time for insert ContactStruct to database: " + + mTimePushIntoContentResolver + " ms"); + } +} diff --git a/core/java/android/pim/vcard/VCardEntryCounter.java b/core/java/android/pim/vcard/VCardEntryCounter.java new file mode 100644 index 0000000..f99b46c --- /dev/null +++ b/core/java/android/pim/vcard/VCardEntryCounter.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import java.util.List; + +public class VCardEntryCounter implements VCardBuilder { + private int mCount; + + public int getCount() { + return mCount; + } + + public void start() { + } + + public void end() { + } + + public void startRecord(String type) { + } + + public void endRecord() { + mCount++; + } + + public void startProperty() { + } + + public void endProperty() { + } + + public void propertyGroup(String group) { + } + + public void propertyName(String name) { + } + + public void propertyParamType(String type) { + } + + public void propertyParamValue(String value) { + } + + public void propertyValues(List<String> values) { + } +}
\ No newline at end of file diff --git a/core/java/android/pim/vcard/VCardParser.java b/core/java/android/pim/vcard/VCardParser.java new file mode 100644 index 0000000..b5e5049 --- /dev/null +++ b/core/java/android/pim/vcard/VCardParser.java @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.pim.vcard.exception.VCardException; + +import java.io.IOException; +import java.io.InputStream; + +public abstract class VCardParser { + + protected boolean mCanceled; + + /** + * Parses the given stream and send the VCard data into VCardBuilderBase object. + * + * Note that vCard 2.1 specification allows "CHARSET" parameter, and some career sets + * local encoding to it. For example, Japanese phone career uses Shift_JIS, which is + * formally allowed in VCard 2.1, but not recommended in VCard 3.0. In VCard 2.1, + * In some exreme case, some VCard may have different charsets in one VCard (though + * we do not see any device which emits such kind of malicious data) + * + * In order to avoid "misunderstanding" charset as much as possible, this method + * use "ISO-8859-1" for reading the stream. When charset is specified in some property + * (with "CHARSET=..." attribute), the string is decoded to raw bytes and encoded to + * the charset. This method assumes that "ISO-8859-1" has 1 to 1 mapping in all 8bit + * characters, which is not completely sure. In some cases, this "decoding-encoding" + * scheme may fail. To avoid the case, + * + * We recommend you to use VCardSourceDetector and detect which kind of source the + * VCard comes from and explicitly specify a charset using the result. + * + * @param is The source to parse. + * @param builder The VCardBuilderBase object which used to construct data. If you want to + * include multiple VCardBuilderBase objects in this field, consider using + * {#link VCardBuilderCollection} class. + * @return Returns true for success. Otherwise returns false. + * @throws IOException, VCardException + */ + public abstract boolean parse(InputStream is, VCardBuilder builder) + throws IOException, VCardException; + + /** + * The method variants which accept charset. + * + * RFC 2426 "recommends" (not forces) to use UTF-8, so it may be OK to use + * UTF-8 as an encoding when parsing vCard 3.0. But note that some Japanese + * phone uses Shift_JIS as a charset (e.g. W61SH), and another uses + * "CHARSET=SHIFT_JIS", which is explicitly prohibited in vCard 3.0 specification + * (e.g. W53K). + * + * @param is The source to parse. + * @param charset Charset to be used. + * @param builder The VCardBuilderBase object. + * @return Returns true when successful. Otherwise returns false. + * @throws IOException, VCardException + */ + public abstract boolean parse(InputStream is, String charset, VCardBuilder builder) + throws IOException, VCardException; + + /** + * The method variants which tells this object the operation is already canceled. + * XXX: Is this really necessary? + * @hide + */ + public abstract void parse(InputStream is, String charset, + VCardBuilder builder, boolean canceled) + throws IOException, VCardException; + + /** + * Cancel parsing. + * Actual cancel is done after the end of the current one vcard entry parsing. + */ + public void cancel() { + mCanceled = true; + } +} diff --git a/core/java/android/pim/vcard/VCardParser_V21.java b/core/java/android/pim/vcard/VCardParser_V21.java new file mode 100644 index 0000000..17a138f --- /dev/null +++ b/core/java/android/pim/vcard/VCardParser_V21.java @@ -0,0 +1,948 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.pim.vcard.exception.VCardException; +import android.pim.vcard.exception.VCardNestedException; +import android.pim.vcard.exception.VCardNotSupportedException; +import android.pim.vcard.exception.VCardVersionException; +import android.util.Log; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.Reader; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; + +/** + * This class is used to parse vcard. Please refer to vCard Specification 2.1. + */ +public class VCardParser_V21 extends VCardParser { + private static final String LOG_TAG = "VCardParser_V21"; + + /** Store the known-type */ + private static final HashSet<String> sKnownTypeSet = new HashSet<String>( + Arrays.asList("DOM", "INTL", "POSTAL", "PARCEL", "HOME", "WORK", + "PREF", "VOICE", "FAX", "MSG", "CELL", "PAGER", "BBS", + "MODEM", "CAR", "ISDN", "VIDEO", "AOL", "APPLELINK", + "ATTMAIL", "CIS", "EWORLD", "INTERNET", "IBMMAIL", + "MCIMAIL", "POWERSHARE", "PRODIGY", "TLX", "X400", "GIF", + "CGM", "WMF", "BMP", "MET", "PMB", "DIB", "PICT", "TIFF", + "PDF", "PS", "JPEG", "QTIME", "MPEG", "MPEG2", "AVI", + "WAVE", "AIFF", "PCM", "X509", "PGP")); + + /** Store the known-value */ + private static final HashSet<String> sKnownValueSet = new HashSet<String>( + Arrays.asList("INLINE", "URL", "CONTENT-ID", "CID")); + + /** Store the property names available in vCard 2.1 */ + private static final HashSet<String> sAvailablePropertyNameV21 = + new HashSet<String>(Arrays.asList( + "BEGIN", "LOGO", "PHOTO", "LABEL", "FN", "TITLE", "SOUND", + "VERSION", "TEL", "EMAIL", "TZ", "GEO", "NOTE", "URL", + "BDAY", "ROLE", "REV", "UID", "KEY", "MAILER")); + + // Though vCard 2.1 specification does not allow "B" encoding, some data may have it. + // We allow it for safety... + private static final HashSet<String> sAvailableEncodingV21 = + new HashSet<String>(Arrays.asList( + "7BIT", "8BIT", "QUOTED-PRINTABLE", "BASE64", "B")); + + // Used only for parsing END:VCARD. + private String mPreviousLine; + + /** The builder to build parsed data */ + protected VCardBuilder mBuilder = null; + + /** The encoding type */ + protected String mEncoding = null; + + protected final String sDefaultEncoding = "8BIT"; + + // Should not directly read a line from this. Use getLine() instead. + protected BufferedReader mReader; + + // In some cases, vCard is nested. Currently, we only consider the most interior vCard data. + // See v21_foma_1.vcf in test directory for more information. + private int mNestCount; + + // In order to reduce warning message as much as possible, we hold the value which made Logger + // emit a warning message. + protected HashSet<String> mWarningValueMap = new HashSet<String>(); + + // Just for debugging + private long mTimeTotal; + private long mTimeStartRecord; + private long mTimeEndRecord; + private long mTimeStartProperty; + private long mTimeEndProperty; + private long mTimeParseItems; + private long mTimeParseItem1; + private long mTimeParseItem2; + private long mTimeParseItem3; + private long mTimeHandlePropertyValue1; + private long mTimeHandlePropertyValue2; + private long mTimeHandlePropertyValue3; + + /** + * Create a new VCard parser. + */ + public VCardParser_V21() { + super(); + } + + public VCardParser_V21(VCardSourceDetector detector) { + super(); + if (detector != null && detector.getType() == VCardSourceDetector.TYPE_FOMA) { + mNestCount = 1; + } + } + + /** + * Parse the file at the given position + * vcard_file = [wsls] vcard [wsls] + */ + protected void parseVCardFile() throws IOException, VCardException { + boolean firstReading = true; + while (true) { + if (mCanceled) { + break; + } + if (!parseOneVCard(firstReading)) { + break; + } + firstReading = false; + } + + if (mNestCount > 0) { + boolean useCache = true; + for (int i = 0; i < mNestCount; i++) { + readEndVCard(useCache, true); + useCache = false; + } + } + } + + protected String getVersion() { + return "2.1"; + } + + /** + * @return true when the propertyName is a valid property name. + */ + protected boolean isValidPropertyName(String propertyName) { + if (!(sAvailablePropertyNameV21.contains(propertyName.toUpperCase()) || + propertyName.startsWith("X-")) && + !mWarningValueMap.contains(propertyName)) { + mWarningValueMap.add(propertyName); + Log.w(LOG_TAG, "Property name unsupported by vCard 2.1: " + propertyName); + } + return true; + } + + /** + * @return true when the encoding is a valid encoding. + */ + protected boolean isValidEncoding(String encoding) { + return sAvailableEncodingV21.contains(encoding.toUpperCase()); + } + + /** + * @return String. It may be null, or its length may be 0 + * @throws IOException + */ + protected String getLine() throws IOException { + return mReader.readLine(); + } + + /** + * @return String with it's length > 0 + * @throws IOException + * @throws VCardException when the stream reached end of line + */ + protected String getNonEmptyLine() throws IOException, VCardException { + String line; + while (true) { + line = getLine(); + if (line == null) { + throw new VCardException("Reached end of buffer."); + } else if (line.trim().length() > 0) { + return line; + } + } + } + + /** + * vcard = "BEGIN" [ws] ":" [ws] "VCARD" [ws] 1*CRLF + * items *CRLF + * "END" [ws] ":" [ws] "VCARD" + */ + private boolean parseOneVCard(boolean firstReading) throws IOException, VCardException { + boolean allowGarbage = false; + if (firstReading) { + if (mNestCount > 0) { + for (int i = 0; i < mNestCount; i++) { + if (!readBeginVCard(allowGarbage)) { + return false; + } + allowGarbage = true; + } + } + } + + if (!readBeginVCard(allowGarbage)) { + return false; + } + long start; + if (mBuilder != null) { + start = System.currentTimeMillis(); + mBuilder.startRecord("VCARD"); + mTimeStartRecord += System.currentTimeMillis() - start; + } + start = System.currentTimeMillis(); + parseItems(); + mTimeParseItems += System.currentTimeMillis() - start; + readEndVCard(true, false); + if (mBuilder != null) { + start = System.currentTimeMillis(); + mBuilder.endRecord(); + mTimeEndRecord += System.currentTimeMillis() - start; + } + return true; + } + + /** + * @return True when successful. False when reaching the end of line + * @throws IOException + * @throws VCardException + */ + protected boolean readBeginVCard(boolean allowGarbage) + throws IOException, VCardException { + String line; + do { + while (true) { + line = getLine(); + if (line == null) { + return false; + } else if (line.trim().length() > 0) { + break; + } + } + String[] strArray = line.split(":", 2); + int length = strArray.length; + + // Though vCard 2.1/3.0 specification does not allow lower cases, + // some data may have them, so we allow it (Actually, previous code + // had explicitly allowed "BEGIN:vCard" though there's no example). + // + // TODO: ignore non vCard entry (e.g. vcalendar). + // XXX: Not sure, but according to VDataBuilder.java, vcalendar + // entry + // may be nested. Just seeking "END:SOMETHING" may not be enough. + // e.g. + // BEGIN:VCARD + // ... (Valid. Must parse this) + // END:VCARD + // BEGIN:VSOMETHING + // ... (Must ignore this) + // BEGIN:VSOMETHING2 + // ... (Must ignore this) + // END:VSOMETHING2 + // ... (Must ignore this!) + // END:VSOMETHING + // BEGIN:VCARD + // ... (Valid. Must parse this) + // END:VCARD + // INVALID_STRING (VCardException should be thrown) + if (length == 2 && + strArray[0].trim().equalsIgnoreCase("BEGIN") && + strArray[1].trim().equalsIgnoreCase("VCARD")) { + return true; + } else if (!allowGarbage) { + if (mNestCount > 0) { + mPreviousLine = line; + return false; + } else { + throw new VCardException( + "Expected String \"BEGIN:VCARD\" did not come " + + "(Instead, \"" + line + "\" came)"); + } + } + } while(allowGarbage); + + throw new VCardException("Reached where must not be reached."); + } + + /** + * The arguments useCache and allowGarbase are usually true and false accordingly when + * this function is called outside this function itself. + * + * @param useCache When true, line is obtained from mPreviousline. Otherwise, getLine() + * is used. + * @param allowGarbage When true, ignore non "END:VCARD" line. + * @throws IOException + * @throws VCardException + */ + protected void readEndVCard(boolean useCache, boolean allowGarbage) + throws IOException, VCardException { + String line; + do { + if (useCache) { + // Though vCard specification does not allow lower cases, + // some data may have them, so we allow it. + line = mPreviousLine; + } else { + while (true) { + line = getLine(); + if (line == null) { + throw new VCardException("Expected END:VCARD was not found."); + } else if (line.trim().length() > 0) { + break; + } + } + } + + String[] strArray = line.split(":", 2); + if (strArray.length == 2 && + strArray[0].trim().equalsIgnoreCase("END") && + strArray[1].trim().equalsIgnoreCase("VCARD")) { + return; + } else if (!allowGarbage) { + throw new VCardException("END:VCARD != \"" + mPreviousLine + "\""); + } + useCache = false; + } while (allowGarbage); + } + + /** + * items = *CRLF item + * / item + */ + protected void parseItems() throws IOException, VCardException { + /* items *CRLF item / item */ + boolean ended = false; + + if (mBuilder != null) { + long start = System.currentTimeMillis(); + mBuilder.startProperty(); + mTimeStartProperty += System.currentTimeMillis() - start; + } + ended = parseItem(); + if (mBuilder != null && !ended) { + long start = System.currentTimeMillis(); + mBuilder.endProperty(); + mTimeEndProperty += System.currentTimeMillis() - start; + } + + while (!ended) { + // follow VCARD ,it wont reach endProperty + if (mBuilder != null) { + long start = System.currentTimeMillis(); + mBuilder.startProperty(); + mTimeStartProperty += System.currentTimeMillis() - start; + } + ended = parseItem(); + if (mBuilder != null && !ended) { + long start = System.currentTimeMillis(); + mBuilder.endProperty(); + mTimeEndProperty += System.currentTimeMillis() - start; + } + } + } + + /** + * item = [groups "."] name [params] ":" value CRLF + * / [groups "."] "ADR" [params] ":" addressparts CRLF + * / [groups "."] "ORG" [params] ":" orgparts CRLF + * / [groups "."] "N" [params] ":" nameparts CRLF + * / [groups "."] "AGENT" [params] ":" vcard CRLF + */ + protected boolean parseItem() throws IOException, VCardException { + mEncoding = sDefaultEncoding; + + String line = getNonEmptyLine(); + long start = System.currentTimeMillis(); + + String[] propertyNameAndValue = separateLineAndHandleGroup(line); + if (propertyNameAndValue == null) { + return true; + } + if (propertyNameAndValue.length != 2) { + throw new VCardException("Invalid line \"" + line + "\""); + } + String propertyName = propertyNameAndValue[0].toUpperCase(); + String propertyValue = propertyNameAndValue[1]; + + mTimeParseItem1 += System.currentTimeMillis() - start; + + if (propertyName.equals("ADR") || + propertyName.equals("ORG") || + propertyName.equals("N")) { + start = System.currentTimeMillis(); + handleMultiplePropertyValue(propertyName, propertyValue); + mTimeParseItem3 += System.currentTimeMillis() - start; + return false; + } else if (propertyName.equals("AGENT")) { + handleAgent(propertyValue); + return false; + } else if (isValidPropertyName(propertyName)) { + if (propertyName.equals("BEGIN")) { + if (propertyValue.equals("VCARD")) { + throw new VCardNestedException("This vCard has nested vCard data in it."); + } else { + throw new VCardException("Unknown BEGIN type: " + propertyValue); + } + } else if (propertyName.equals("VERSION") && + !propertyValue.equals(getVersion())) { + throw new VCardVersionException("Incompatible version: " + + propertyValue + " != " + getVersion()); + } + start = System.currentTimeMillis(); + handlePropertyValue(propertyName, propertyValue); + mTimeParseItem2 += System.currentTimeMillis() - start; + return false; + } + + throw new VCardException("Unknown property name: \"" + + propertyName + "\""); + } + + static private final int STATE_GROUP_OR_PROPNAME = 0; + static private final int STATE_PARAMS = 1; + // vCard 3.1 specification allows double-quoted param-value, while vCard 2.1 does not. + // This is just for safety. + static private final int STATE_PARAMS_IN_DQUOTE = 2; + + protected String[] separateLineAndHandleGroup(String line) throws VCardException { + int length = line.length(); + int state = STATE_GROUP_OR_PROPNAME; + int nameIndex = 0; + + String[] propertyNameAndValue = new String[2]; + + for (int i = 0; i < length; i++) { + char ch = line.charAt(i); + switch (state) { + case STATE_GROUP_OR_PROPNAME: + if (ch == ':') { + String propertyName = line.substring(nameIndex, i); + if (propertyName.equalsIgnoreCase("END")) { + mPreviousLine = line; + return null; + } + if (mBuilder != null) { + mBuilder.propertyName(propertyName); + } + propertyNameAndValue[0] = propertyName; + if (i < length - 1) { + propertyNameAndValue[1] = line.substring(i + 1); + } else { + propertyNameAndValue[1] = ""; + } + return propertyNameAndValue; + } else if (ch == '.') { + String groupName = line.substring(nameIndex, i); + if (mBuilder != null) { + mBuilder.propertyGroup(groupName); + } + nameIndex = i + 1; + } else if (ch == ';') { + String propertyName = line.substring(nameIndex, i); + if (propertyName.equalsIgnoreCase("END")) { + mPreviousLine = line; + return null; + } + if (mBuilder != null) { + mBuilder.propertyName(propertyName); + } + propertyNameAndValue[0] = propertyName; + nameIndex = i + 1; + state = STATE_PARAMS; + } + break; + case STATE_PARAMS: + if (ch == '"') { + state = STATE_PARAMS_IN_DQUOTE; + } else if (ch == ';') { + handleParams(line.substring(nameIndex, i)); + nameIndex = i + 1; + } else if (ch == ':') { + handleParams(line.substring(nameIndex, i)); + if (i < length - 1) { + propertyNameAndValue[1] = line.substring(i + 1); + } else { + propertyNameAndValue[1] = ""; + } + return propertyNameAndValue; + } + break; + case STATE_PARAMS_IN_DQUOTE: + if (ch == '"') { + state = STATE_PARAMS; + } + break; + } + } + + throw new VCardException("Invalid line: \"" + line + "\""); + } + + + /** + * params = ";" [ws] paramlist + * paramlist = paramlist [ws] ";" [ws] param + * / param + * param = "TYPE" [ws] "=" [ws] ptypeval + * / "VALUE" [ws] "=" [ws] pvalueval + * / "ENCODING" [ws] "=" [ws] pencodingval + * / "CHARSET" [ws] "=" [ws] charsetval + * / "LANGUAGE" [ws] "=" [ws] langval + * / "X-" word [ws] "=" [ws] word + * / knowntype + */ + protected void handleParams(String params) throws VCardException { + String[] strArray = params.split("=", 2); + if (strArray.length == 2) { + String paramName = strArray[0].trim(); + String paramValue = strArray[1].trim(); + if (paramName.equals("TYPE")) { + handleType(paramValue); + } else if (paramName.equals("VALUE")) { + handleValue(paramValue); + } else if (paramName.equals("ENCODING")) { + handleEncoding(paramValue); + } else if (paramName.equals("CHARSET")) { + handleCharset(paramValue); + } else if (paramName.equals("LANGUAGE")) { + handleLanguage(paramValue); + } else if (paramName.startsWith("X-")) { + handleAnyParam(paramName, paramValue); + } else { + throw new VCardException("Unknown type \"" + paramName + "\""); + } + } else { + handleType(strArray[0]); + } + } + + /** + * ptypeval = knowntype / "X-" word + */ + protected void handleType(String ptypeval) { + String upperTypeValue = ptypeval; + if (!(sKnownTypeSet.contains(upperTypeValue) || upperTypeValue.startsWith("X-")) && + !mWarningValueMap.contains(ptypeval)) { + mWarningValueMap.add(ptypeval); + Log.w(LOG_TAG, "Type unsupported by vCard 2.1: " + ptypeval); + } + if (mBuilder != null) { + mBuilder.propertyParamType("TYPE"); + mBuilder.propertyParamValue(upperTypeValue); + } + } + + /** + * pvalueval = "INLINE" / "URL" / "CONTENT-ID" / "CID" / "X-" word + */ + protected void handleValue(String pvalueval) throws VCardException { + if (sKnownValueSet.contains(pvalueval.toUpperCase()) || + pvalueval.startsWith("X-")) { + if (mBuilder != null) { + mBuilder.propertyParamType("VALUE"); + mBuilder.propertyParamValue(pvalueval); + } + } else { + throw new VCardException("Unknown value \"" + pvalueval + "\""); + } + } + + /** + * pencodingval = "7BIT" / "8BIT" / "QUOTED-PRINTABLE" / "BASE64" / "X-" word + */ + protected void handleEncoding(String pencodingval) throws VCardException { + if (isValidEncoding(pencodingval) || + pencodingval.startsWith("X-")) { + if (mBuilder != null) { + mBuilder.propertyParamType("ENCODING"); + mBuilder.propertyParamValue(pencodingval); + } + mEncoding = pencodingval; + } else { + throw new VCardException("Unknown encoding \"" + pencodingval + "\""); + } + } + + /** + * vCard specification only allows us-ascii and iso-8859-xxx (See RFC 1521), + * but some vCard contains other charset, so we allow them. + */ + protected void handleCharset(String charsetval) { + if (mBuilder != null) { + mBuilder.propertyParamType("CHARSET"); + mBuilder.propertyParamValue(charsetval); + } + } + + /** + * See also Section 7.1 of RFC 1521 + */ + protected void handleLanguage(String langval) throws VCardException { + String[] strArray = langval.split("-"); + if (strArray.length != 2) { + throw new VCardException("Invalid Language: \"" + langval + "\""); + } + String tmp = strArray[0]; + int length = tmp.length(); + for (int i = 0; i < length; i++) { + if (!isLetter(tmp.charAt(i))) { + throw new VCardException("Invalid Language: \"" + langval + "\""); + } + } + tmp = strArray[1]; + length = tmp.length(); + for (int i = 0; i < length; i++) { + if (!isLetter(tmp.charAt(i))) { + throw new VCardException("Invalid Language: \"" + langval + "\""); + } + } + if (mBuilder != null) { + mBuilder.propertyParamType("LANGUAGE"); + mBuilder.propertyParamValue(langval); + } + } + + /** + * Mainly for "X-" type. This accepts any kind of type without check. + */ + protected void handleAnyParam(String paramName, String paramValue) { + if (mBuilder != null) { + mBuilder.propertyParamType(paramName); + mBuilder.propertyParamValue(paramValue); + } + } + + protected void handlePropertyValue( + String propertyName, String propertyValue) throws + IOException, VCardException { + if (mEncoding.equalsIgnoreCase("QUOTED-PRINTABLE")) { + long start = System.currentTimeMillis(); + String result = getQuotedPrintable(propertyValue); + if (mBuilder != null) { + ArrayList<String> v = new ArrayList<String>(); + v.add(result); + mBuilder.propertyValues(v); + } + mTimeHandlePropertyValue2 += System.currentTimeMillis() - start; + } else if (mEncoding.equalsIgnoreCase("BASE64") || + mEncoding.equalsIgnoreCase("B")) { + long start = System.currentTimeMillis(); + // It is very rare, but some BASE64 data may be so big that + // OutOfMemoryError occurs. To ignore such cases, use try-catch. + try { + String result = getBase64(propertyValue); + if (mBuilder != null) { + ArrayList<String> v = new ArrayList<String>(); + v.add(result); + mBuilder.propertyValues(v); + } + } catch (OutOfMemoryError error) { + Log.e(LOG_TAG, "OutOfMemoryError happened during parsing BASE64 data!"); + if (mBuilder != null) { + mBuilder.propertyValues(null); + } + } + mTimeHandlePropertyValue3 += System.currentTimeMillis() - start; + } else { + if (!(mEncoding == null || mEncoding.equalsIgnoreCase("7BIT") + || mEncoding.equalsIgnoreCase("8BIT") + || mEncoding.toUpperCase().startsWith("X-"))) { + Log.w(LOG_TAG, "The encoding unsupported by vCard spec: \"" + mEncoding + "\"."); + } + + long start = System.currentTimeMillis(); + if (mBuilder != null) { + ArrayList<String> v = new ArrayList<String>(); + v.add(maybeUnescapeText(propertyValue)); + mBuilder.propertyValues(v); + } + mTimeHandlePropertyValue1 += System.currentTimeMillis() - start; + } + } + + protected String getQuotedPrintable(String firstString) throws IOException, VCardException { + // Specifically, there may be some padding between = and CRLF. + // See the following: + // + // qp-line := *(qp-segment transport-padding CRLF) + // qp-part transport-padding + // qp-segment := qp-section *(SPACE / TAB) "=" + // ; Maximum length of 76 characters + // + // e.g. (from RFC 2045) + // Now's the time = + // for all folk to come= + // to the aid of their country. + if (firstString.trim().endsWith("=")) { + // remove "transport-padding" + int pos = firstString.length() - 1; + while(firstString.charAt(pos) != '=') { + } + StringBuilder builder = new StringBuilder(); + builder.append(firstString.substring(0, pos + 1)); + builder.append("\r\n"); + String line; + while (true) { + line = getLine(); + if (line == null) { + throw new VCardException( + "File ended during parsing quoted-printable String"); + } + if (line.trim().endsWith("=")) { + // remove "transport-padding" + pos = line.length() - 1; + while(line.charAt(pos) != '=') { + } + builder.append(line.substring(0, pos + 1)); + builder.append("\r\n"); + } else { + builder.append(line); + break; + } + } + return builder.toString(); + } else { + return firstString; + } + } + + protected String getBase64(String firstString) throws IOException, VCardException { + StringBuilder builder = new StringBuilder(); + builder.append(firstString); + + while (true) { + String line = getLine(); + if (line == null) { + throw new VCardException( + "File ended during parsing BASE64 binary"); + } + if (line.length() == 0) { + break; + } + builder.append(line); + } + + return builder.toString(); + } + + /** + * Mainly for "ADR", "ORG", and "N" + * We do not care the number of strnosemi here. + * + * addressparts = 0*6(strnosemi ";") strnosemi + * ; PO Box, Extended Addr, Street, Locality, Region, + * Postal Code, Country Name + * orgparts = *(strnosemi ";") strnosemi + * ; First is Organization Name, + * remainder are Organization Units. + * nameparts = 0*4(strnosemi ";") strnosemi + * ; Family, Given, Middle, Prefix, Suffix. + * ; Example:Public;John;Q.;Reverend Dr.;III, Esq. + * strnosemi = *(*nonsemi ("\;" / "\" CRLF)) *nonsemi + * ; To include a semicolon in this string, it must be escaped + * ; with a "\" character. + * + * We are not sure whether we should add "\" CRLF to each value. + * For now, we exclude them. + */ + protected void handleMultiplePropertyValue( + String propertyName, String propertyValue) throws IOException, VCardException { + // vCard 2.1 does not allow QUOTED-PRINTABLE here, but some data have it. + if (mEncoding.equalsIgnoreCase("QUOTED-PRINTABLE")) { + propertyValue = getQuotedPrintable(propertyValue); + } + + if (mBuilder != null) { + // TODO: limit should be set in accordance with propertyName? + StringBuilder builder = new StringBuilder(); + ArrayList<String> list = new ArrayList<String>(); + int length = propertyValue.length(); + for (int i = 0; i < length; i++) { + char ch = propertyValue.charAt(i); + if (ch == '\\' && i < length - 1) { + char nextCh = propertyValue.charAt(i + 1); + String unescapedString = maybeUnescape(nextCh); + if (unescapedString != null) { + builder.append(unescapedString); + i++; + } else { + builder.append(ch); + } + } else if (ch == ';') { + list.add(builder.toString()); + builder = new StringBuilder(); + } else { + builder.append(ch); + } + } + list.add(builder.toString()); + mBuilder.propertyValues(list); + } + } + + /** + * vCard 2.1 specifies AGENT allows one vcard entry. It is not encoded at all. + * + * item = ... + * / [groups "."] "AGENT" + * [params] ":" vcard CRLF + * vcard = "BEGIN" [ws] ":" [ws] "VCARD" [ws] 1*CRLF + * items *CRLF "END" [ws] ":" [ws] "VCARD" + * + */ + protected void handleAgent(String propertyValue) throws VCardException { + throw new VCardNotSupportedException("AGENT Property is not supported now."); + /* This is insufficient support. Also, AGENT Property is very rare. + Ignore it for now. + TODO: fix this. + + String[] strArray = propertyValue.split(":", 2); + if (!(strArray.length == 2 || + strArray[0].trim().equalsIgnoreCase("BEGIN") && + strArray[1].trim().equalsIgnoreCase("VCARD"))) { + throw new VCardException("BEGIN:VCARD != \"" + propertyValue + "\""); + } + parseItems(); + readEndVCard(); + */ + } + + /** + * For vCard 3.0. + */ + protected String maybeUnescapeText(String text) { + return text; + } + + /** + * Returns unescaped String if the character should be unescaped. Return null otherwise. + * e.g. In vCard 2.1, "\;" should be unescaped into ";" while "\x" should not be. + */ + protected String maybeUnescape(char ch) { + // Original vCard 2.1 specification does not allow transformation + // "\:" -> ":", "\," -> ",", and "\\" -> "\", but previous implementation of + // this class allowed them, so keep it as is. + if (ch == '\\' || ch == ';' || ch == ':' || ch == ',') { + return String.valueOf(ch); + } else { + return null; + } + } + + @Override + public boolean parse(InputStream is, VCardBuilder builder) + throws IOException, VCardException { + return parse(is, VCardConfig.DEFAULT_CHARSET, builder); + } + + @Override + public boolean parse(InputStream is, String charset, VCardBuilder builder) + throws IOException, VCardException { + // TODO: make this count error entries instead of just throwing VCardException. + + { + // TODO: If we really need to allow only CRLF as line break, + // we will have to develop our own BufferedReader(). + final InputStreamReader tmpReader = new InputStreamReader(is, charset); + if (VCardConfig.showPerformanceLog()) { + mReader = new CustomBufferedReader(tmpReader); + } else { + mReader = new BufferedReader(tmpReader); + } + } + + mBuilder = builder; + + long start = System.currentTimeMillis(); + if (mBuilder != null) { + mBuilder.start(); + } + parseVCardFile(); + if (mBuilder != null) { + mBuilder.end(); + } + mTimeTotal += System.currentTimeMillis() - start; + + if (VCardConfig.showPerformanceLog()) { + showPerformanceInfo(); + } + + return true; + } + + @Override + public void parse(InputStream is, String charset, VCardBuilder builder, boolean canceled) + throws IOException, VCardException { + mCanceled = canceled; + parse(is, charset, builder); + } + + private void showPerformanceInfo() { + Log.d(LOG_TAG, "total parsing time: " + mTimeTotal + " ms"); + if (mReader instanceof CustomBufferedReader) { + Log.d(LOG_TAG, "total readLine time: " + + ((CustomBufferedReader)mReader).getTotalmillisecond() + " ms"); + } + Log.d(LOG_TAG, "mTimeStartRecord: " + mTimeStartRecord + " ms"); + Log.d(LOG_TAG, "mTimeEndRecord: " + mTimeEndRecord + " ms"); + Log.d(LOG_TAG, "mTimeParseItem1: " + mTimeParseItem1 + " ms"); + Log.d(LOG_TAG, "mTimeParseItem2: " + mTimeParseItem2 + " ms"); + Log.d(LOG_TAG, "mTimeParseItem3: " + mTimeParseItem3 + " ms"); + Log.d(LOG_TAG, "mTimeHandlePropertyValue1: " + mTimeHandlePropertyValue1 + " ms"); + Log.d(LOG_TAG, "mTimeHandlePropertyValue2: " + mTimeHandlePropertyValue2 + " ms"); + Log.d(LOG_TAG, "mTimeHandlePropertyValue3: " + mTimeHandlePropertyValue3 + " ms"); + } + + private boolean isLetter(char ch) { + if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) { + return true; + } + return false; + } +} + +class CustomBufferedReader extends BufferedReader { + private long mTime; + + public CustomBufferedReader(Reader in) { + super(in); + } + + @Override + public String readLine() throws IOException { + long start = System.currentTimeMillis(); + String ret = super.readLine(); + long end = System.currentTimeMillis(); + mTime += end - start; + return ret; + } + + public long getTotalmillisecond() { + return mTime; + } +} diff --git a/core/java/android/pim/vcard/VCardParser_V30.java b/core/java/android/pim/vcard/VCardParser_V30.java new file mode 100644 index 0000000..634d9f5 --- /dev/null +++ b/core/java/android/pim/vcard/VCardParser_V30.java @@ -0,0 +1,306 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import android.pim.vcard.exception.VCardException; +import android.util.Log; + +import java.io.IOException; +import java.util.Arrays; +import java.util.HashSet; + +/** + * This class is used to parse vcard3.0. <br> + * Please refer to vCard Specification 3.0 (http://tools.ietf.org/html/rfc2426) + */ +public class VCardParser_V30 extends VCardParser_V21 { + private static final String LOG_TAG = "VCardParser_V30"; + + private static final HashSet<String> sAcceptablePropsWithParam = new HashSet<String>( + Arrays.asList( + "BEGIN", "LOGO", "PHOTO", "LABEL", "FN", "TITLE", "SOUND", + "VERSION", "TEL", "EMAIL", "TZ", "GEO", "NOTE", "URL", + "BDAY", "ROLE", "REV", "UID", "KEY", "MAILER", // 2.1 + "NAME", "PROFILE", "SOURCE", "NICKNAME", "CLASS", + "SORT-STRING", "CATEGORIES", "PRODID")); // 3.0 + + // Although "7bit" and "BASE64" is not allowed in vCard 3.0, we allow it for safety. + private static final HashSet<String> sAcceptableEncodingV30 = new HashSet<String>( + Arrays.asList("7BIT", "8BIT", "BASE64", "B")); + + // Although RFC 2426 specifies some property must not have parameters, we allow it, + // since there may be some careers which violates the RFC... + private static final HashSet<String> acceptablePropsWithoutParam = new HashSet<String>(); + + private String mPreviousLine; + + @Override + protected String getVersion() { + return "3.0"; + } + + @Override + protected boolean isValidPropertyName(String propertyName) { + if (!(sAcceptablePropsWithParam.contains(propertyName) || + acceptablePropsWithoutParam.contains(propertyName) || + propertyName.startsWith("X-")) && + !mWarningValueMap.contains(propertyName)) { + mWarningValueMap.add(propertyName); + Log.w(LOG_TAG, "Property name unsupported by vCard 3.0: " + propertyName); + } + return true; + } + + @Override + protected boolean isValidEncoding(String encoding) { + return sAcceptableEncodingV30.contains(encoding.toUpperCase()); + } + + @Override + protected String getLine() throws IOException { + if (mPreviousLine != null) { + String ret = mPreviousLine; + mPreviousLine = null; + return ret; + } else { + return mReader.readLine(); + } + } + + /** + * vCard 3.0 requires that the line with space at the beginning of the line + * must be combined with previous line. + */ + @Override + protected String getNonEmptyLine() throws IOException, VCardException { + String line; + StringBuilder builder = null; + while (true) { + line = mReader.readLine(); + if (line == null) { + if (builder != null) { + return builder.toString(); + } else if (mPreviousLine != null) { + String ret = mPreviousLine; + mPreviousLine = null; + return ret; + } + throw new VCardException("Reached end of buffer."); + } else if (line.length() == 0) { + if (builder != null) { + return builder.toString(); + } else if (mPreviousLine != null) { + String ret = mPreviousLine; + mPreviousLine = null; + return ret; + } + } else if (line.charAt(0) == ' ' || line.charAt(0) == '\t') { + if (builder != null) { + // See Section 5.8.1 of RFC 2425 (MIME-DIR document). + // Following is the excerpts from it. + // + // DESCRIPTION:This is a long description that exists on a long line. + // + // Can be represented as: + // + // DESCRIPTION:This is a long description + // that exists on a long line. + // + // It could also be represented as: + // + // DESCRIPTION:This is a long descrip + // tion that exists o + // n a long line. + builder.append(line.substring(1)); + } else if (mPreviousLine != null) { + builder = new StringBuilder(); + builder.append(mPreviousLine); + mPreviousLine = null; + builder.append(line.substring(1)); + } else { + throw new VCardException("Space exists at the beginning of the line"); + } + } else { + if (mPreviousLine == null) { + mPreviousLine = line; + if (builder != null) { + return builder.toString(); + } + } else { + String ret = mPreviousLine; + mPreviousLine = line; + return ret; + } + } + } + } + + + /** + * vcard = [group "."] "BEGIN" ":" "VCARD" 1*CRLF + * 1*(contentline) + * ;A vCard object MUST include the VERSION, FN and N types. + * [group "."] "END" ":" "VCARD" 1*CRLF + */ + @Override + protected boolean readBeginVCard(boolean allowGarbage) throws IOException, VCardException { + // TODO: vCard 3.0 supports group. + return super.readBeginVCard(allowGarbage); + } + + @Override + protected void readEndVCard(boolean useCache, boolean allowGarbage) + throws IOException, VCardException { + // TODO: vCard 3.0 supports group. + super.readEndVCard(useCache, allowGarbage); + } + + /** + * vCard 3.0 allows iana-token as paramType, while vCard 2.1 does not. + */ + @Override + protected void handleParams(String params) throws VCardException { + try { + super.handleParams(params); + } catch (VCardException e) { + // maybe IANA type + String[] strArray = params.split("=", 2); + if (strArray.length == 2) { + handleAnyParam(strArray[0], strArray[1]); + } else { + // Must not come here in the current implementation. + throw new VCardException( + "Unknown params value: " + params); + } + } + } + + @Override + protected void handleAnyParam(String paramName, String paramValue) { + // vCard 3.0 accept comma-separated multiple values, but + // current PropertyNode does not accept it. + // For now, we do not split the values. + // + // TODO: fix this. + super.handleAnyParam(paramName, paramValue); + } + + /** + * vCard 3.0 defines + * + * param = param-name "=" param-value *("," param-value) + * param-name = iana-token / x-name + * param-value = ptext / quoted-string + * quoted-string = DQUOTE QSAFE-CHAR DQUOTE + */ + @Override + protected void handleType(String ptypevalues) { + String[] ptypeArray = ptypevalues.split(","); + mBuilder.propertyParamType("TYPE"); + for (String value : ptypeArray) { + int length = value.length(); + if (length >= 2 && value.startsWith("\"") && value.endsWith("\"")) { + mBuilder.propertyParamValue(value.substring(1, value.length() - 1)); + } else { + mBuilder.propertyParamValue(value); + } + } + } + + @Override + protected void handleAgent(String propertyValue) throws VCardException { + // The way how vCard 3.0 supports "AGENT" is completely different from vCard 2.0. + // + // e.g. + // AGENT:BEGIN:VCARD\nFN:Joe Friday\nTEL:+1-919-555-7878\n + // TITLE:Area Administrator\, Assistant\n EMAIL\;TYPE=INTERN\n + // ET:jfriday@host.com\nEND:VCARD\n + // + // TODO: fix this. + // + // issue: + // vCard 3.0 also allows this as an example. + // + // AGENT;VALUE=uri: + // CID:JQPUBLIC.part3.960129T083020.xyzMail@host3.com + // + // This is not VCARD. Should we support this? + throw new VCardException("AGENT in vCard 3.0 is not supported yet."); + } + + /** + * vCard 3.0 does not require two CRLF at the last of BASE64 data. + * It only requires that data should be MIME-encoded. + */ + @Override + protected String getBase64(String firstString) throws IOException, VCardException { + StringBuilder builder = new StringBuilder(); + builder.append(firstString); + + while (true) { + String line = getLine(); + if (line == null) { + throw new VCardException( + "File ended during parsing BASE64 binary"); + } + if (line.length() == 0) { + break; + } else if (!line.startsWith(" ") && !line.startsWith("\t")) { + mPreviousLine = line; + break; + } + builder.append(line); + } + + return builder.toString(); + } + + /** + * ESCAPED-CHAR = "\\" / "\;" / "\," / "\n" / "\N") + * ; \\ encodes \, \n or \N encodes newline + * ; \; encodes ;, \, encodes , + * + * Note: Apple escape ':' into '\:' while does not escape '\' + */ + @Override + protected String maybeUnescapeText(String text) { + StringBuilder builder = new StringBuilder(); + int length = text.length(); + for (int i = 0; i < length; i++) { + char ch = text.charAt(i); + if (ch == '\\' && i < length - 1) { + char next_ch = text.charAt(++i); + if (next_ch == 'n' || next_ch == 'N') { + builder.append("\r\n"); + } else { + builder.append(next_ch); + } + } else { + builder.append(ch); + } + } + return builder.toString(); + } + + @Override + protected String maybeUnescape(char ch) { + if (ch == 'n' || ch == 'N') { + return "\r\n"; + } else { + return String.valueOf(ch); + } + } +} diff --git a/core/java/android/pim/vcard/VCardSourceDetector.java b/core/java/android/pim/vcard/VCardSourceDetector.java new file mode 100644 index 0000000..7e2be2b --- /dev/null +++ b/core/java/android/pim/vcard/VCardSourceDetector.java @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2009 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.pim.vcard; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +/** + * Class which tries to detects the source of the vCard from its properties. + * Currently this implementation is very premature. + * @hide + */ +public class VCardSourceDetector implements VCardBuilder { + // Should only be used in package. + static final int TYPE_UNKNOWN = 0; + static final int TYPE_APPLE = 1; + static final int TYPE_JAPANESE_MOBILE_PHONE = 2; // Used in Japanese mobile phones. + static final int TYPE_FOMA = 3; // Used in some Japanese FOMA mobile phones. + static final int TYPE_WINDOWS_MOBILE_JP = 4; + // TODO: Excel, etc. + + private static Set<String> APPLE_SIGNS = new HashSet<String>(Arrays.asList( + "X-PHONETIC-FIRST-NAME", "X-PHONETIC-MIDDLE-NAME", "X-PHONETIC-LAST-NAME", + "X-ABADR", "X-ABUID")); + + private static Set<String> JAPANESE_MOBILE_PHONE_SIGNS = new HashSet<String>(Arrays.asList( + "X-GNO", "X-GN", "X-REDUCTION")); + + private static Set<String> WINDOWS_MOBILE_PHONE_SIGNS = new HashSet<String>(Arrays.asList( + "X-MICROSOFT-ASST_TEL", "X-MICROSOFT-ASSISTANT", "X-MICROSOFT-OFFICELOC")); + + // Note: these signes appears before the signs of the other type (e.g. "X-GN"). + // In other words, Japanese FOMA mobile phones are detected as FOMA, not JAPANESE_MOBILE_PHONES. + private static Set<String> FOMA_SIGNS = new HashSet<String>(Arrays.asList( + "X-SD-VERN", "X-SD-FORMAT_VER", "X-SD-CATEGORIES", "X-SD-CLASS", "X-SD-DCREATED", + "X-SD-DESCRIPTION")); + private static String TYPE_FOMA_CHARSET_SIGN = "X-SD-CHAR_CODE"; + + private int mType = TYPE_UNKNOWN; + // Some mobile phones (like FOMA) tells us the charset of the data. + private boolean mNeedParseSpecifiedCharset; + private String mSpecifiedCharset; + + public void start() { + } + + public void end() { + } + + public void startRecord(String type) { + } + + public void startProperty() { + mNeedParseSpecifiedCharset = false; + } + + public void endProperty() { + } + + public void endRecord() { + } + + public void propertyGroup(String group) { + } + + public void propertyName(String name) { + if (name.equalsIgnoreCase(TYPE_FOMA_CHARSET_SIGN)) { + mType = TYPE_FOMA; + mNeedParseSpecifiedCharset = true; + return; + } + if (mType != TYPE_UNKNOWN) { + return; + } + if (WINDOWS_MOBILE_PHONE_SIGNS.contains(name)) { + mType = TYPE_WINDOWS_MOBILE_JP; + } else if (FOMA_SIGNS.contains(name)) { + mType = TYPE_FOMA; + } else if (JAPANESE_MOBILE_PHONE_SIGNS.contains(name)) { + mType = TYPE_JAPANESE_MOBILE_PHONE; + } else if (APPLE_SIGNS.contains(name)) { + mType = TYPE_APPLE; + } + } + + public void propertyParamType(String type) { + } + + public void propertyParamValue(String value) { + } + + public void propertyValues(List<String> values) { + if (mNeedParseSpecifiedCharset && values.size() > 0) { + mSpecifiedCharset = values.get(0); + } + } + + int getType() { + return mType; + } + + /** + * Return charset String guessed from the source's properties. + * This method must be called after parsing target file(s). + * @return Charset String. Null is returned if guessing the source fails. + */ + public String getEstimatedCharset() { + if (mSpecifiedCharset != null) { + return mSpecifiedCharset; + } + switch (mType) { + case TYPE_WINDOWS_MOBILE_JP: + case TYPE_FOMA: + case TYPE_JAPANESE_MOBILE_PHONE: + return "SHIFT_JIS"; + case TYPE_APPLE: + return "UTF-8"; + default: + return null; + } + } +} diff --git a/core/java/android/pim/vcard/exception/VCardException.java b/core/java/android/pim/vcard/exception/VCardException.java new file mode 100644 index 0000000..e557219 --- /dev/null +++ b/core/java/android/pim/vcard/exception/VCardException.java @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2009 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.pim.vcard.exception; + +public class VCardException extends java.lang.Exception { + /** + * Constructs a VCardException object + */ + public VCardException() { + super(); + } + + /** + * Constructs a VCardException object + * + * @param message the error message + */ + public VCardException(String message) { + super(message); + } + +} diff --git a/core/java/android/pim/vcard/exception/VCardNestedException.java b/core/java/android/pim/vcard/exception/VCardNestedException.java new file mode 100644 index 0000000..503c2fb --- /dev/null +++ b/core/java/android/pim/vcard/exception/VCardNestedException.java @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2009 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.pim.vcard.exception; + +/** + * VCardException thrown when VCard is nested without VCardParser's being notified. + */ +public class VCardNestedException extends VCardNotSupportedException { + public VCardNestedException() { + super(); + } + public VCardNestedException(String message) { + super(message); + } +} diff --git a/core/java/android/pim/vcard/exception/VCardNotSupportedException.java b/core/java/android/pim/vcard/exception/VCardNotSupportedException.java new file mode 100644 index 0000000..616aa77 --- /dev/null +++ b/core/java/android/pim/vcard/exception/VCardNotSupportedException.java @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2009 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.pim.vcard.exception; + +/** + * The exception which tells that the input VCard is probably valid from the view of + * specification but not supported in the current framework for now. + * + * This is a kind of a good news from the view of development. + * It may be good to ask users to send a report with the VCard example + * for the future development. + */ +public class VCardNotSupportedException extends VCardException { + public VCardNotSupportedException() { + super(); + } + public VCardNotSupportedException(String message) { + super(message); + } +}
\ No newline at end of file diff --git a/core/java/android/pim/vcard/exception/VCardVersionException.java b/core/java/android/pim/vcard/exception/VCardVersionException.java new file mode 100644 index 0000000..9fe8b7f --- /dev/null +++ b/core/java/android/pim/vcard/exception/VCardVersionException.java @@ -0,0 +1,29 @@ +/* + * Copyright (C) 2009 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.pim.vcard.exception; + +/** + * VCardException used only when the version of the vCard is different. + */ +public class VCardVersionException extends VCardException { + public VCardVersionException() { + super(); + } + public VCardVersionException(String message) { + super(message); + } +} diff --git a/core/java/android/pim/vcard/exception/package.html b/core/java/android/pim/vcard/exception/package.html new file mode 100644 index 0000000..26b8a32 --- /dev/null +++ b/core/java/android/pim/vcard/exception/package.html @@ -0,0 +1,5 @@ +<HTML> +<BODY> +{@hide} +</BODY> +</HTML>
\ No newline at end of file diff --git a/core/java/android/pim/vcard/package.html b/core/java/android/pim/vcard/package.html new file mode 100644 index 0000000..26b8a32 --- /dev/null +++ b/core/java/android/pim/vcard/package.html @@ -0,0 +1,5 @@ +<HTML> +<BODY> +{@hide} +</BODY> +</HTML>
\ No newline at end of file diff --git a/core/java/android/preference/CheckBoxPreference.java b/core/java/android/preference/CheckBoxPreference.java index cf5664c..f16a7e4 100644 --- a/core/java/android/preference/CheckBoxPreference.java +++ b/core/java/android/preference/CheckBoxPreference.java @@ -149,14 +149,12 @@ public class CheckBoxPreference extends Preference { * @param checked The checked state. */ public void setChecked(boolean checked) { - - mChecked = checked; - - persistBoolean(checked); - - notifyDependencyChange(shouldDisableDependents()); - - notifyChanged(); + if (mChecked != checked) { + mChecked = checked; + persistBoolean(checked); + notifyDependencyChange(shouldDisableDependents()); + notifyChanged(); + } } /** diff --git a/core/java/android/preference/RingtonePreference.java b/core/java/android/preference/RingtonePreference.java index 6beb06d..b46f180 100644 --- a/core/java/android/preference/RingtonePreference.java +++ b/core/java/android/preference/RingtonePreference.java @@ -31,8 +31,9 @@ import android.util.Log; * The chosen ringtone's URI will be persisted as a string. * <p> * If the user chooses the "Default" item, the saved string will be one of - * {@link System#DEFAULT_RINGTONE_URI} or - * {@link System#DEFAULT_NOTIFICATION_URI}. If the user chooses the "Silent" + * {@link System#DEFAULT_RINGTONE_URI}, + * {@link System#DEFAULT_NOTIFICATION_URI}, or + * {@link System#DEFAULT_ALARM_ALERT_URI}. If the user chooses the "Silent" * item, the saved string will be an empty string. * * @attr ref android.R.styleable#RingtonePreference_ringtoneType diff --git a/core/java/android/preference/VolumePreference.java b/core/java/android/preference/VolumePreference.java index 20702a1..db25cfa 100644 --- a/core/java/android/preference/VolumePreference.java +++ b/core/java/android/preference/VolumePreference.java @@ -22,11 +22,13 @@ import android.database.ContentObserver; import android.media.Ringtone; import android.media.RingtoneManager; import android.media.AudioManager; +import android.net.Uri; import android.os.Handler; import android.preference.PreferenceManager; import android.provider.Settings; import android.provider.Settings.System; import android.util.AttributeSet; +import android.view.KeyEvent; import android.view.View; import android.widget.SeekBar; import android.widget.SeekBar.OnSeekBarChangeListener; @@ -35,7 +37,7 @@ import android.widget.SeekBar.OnSeekBarChangeListener; * @hide */ public class VolumePreference extends SeekBarPreference implements - PreferenceManager.OnActivityStopListener { + PreferenceManager.OnActivityStopListener, View.OnKeyListener { private static final String TAG = "VolumePreference"; @@ -65,6 +67,30 @@ public class VolumePreference extends SeekBarPreference implements mSeekBarVolumizer = new SeekBarVolumizer(getContext(), seekBar, mStreamType); getPreferenceManager().registerOnActivityStopListener(this); + + // grab focus and key events so that pressing the volume buttons in the + // dialog doesn't also show the normal volume adjust toast. + view.setOnKeyListener(this); + view.setFocusableInTouchMode(true); + view.requestFocus(); + } + + public boolean onKey(View v, int keyCode, KeyEvent event) { + boolean isdown = (event.getAction() == KeyEvent.ACTION_DOWN); + switch (keyCode) { + case KeyEvent.KEYCODE_VOLUME_DOWN: + if (isdown) { + mSeekBarVolumizer.changeVolumeBy(-1); + } + return true; + case KeyEvent.KEYCODE_VOLUME_UP: + if (isdown) { + mSeekBarVolumizer.changeVolumeBy(1); + } + return true; + default: + return false; + } } @Override @@ -147,11 +173,19 @@ public class VolumePreference extends SeekBarPreference implements System.getUriFor(System.VOLUME_SETTINGS[mStreamType]), false, mVolumeObserver); - mRingtone = RingtoneManager.getRingtone(mContext, - mStreamType == AudioManager.STREAM_NOTIFICATION - ? Settings.System.DEFAULT_NOTIFICATION_URI - : Settings.System.DEFAULT_RINGTONE_URI); - mRingtone.setStreamType(mStreamType); + Uri defaultUri = null; + if (mStreamType == AudioManager.STREAM_RING) { + defaultUri = Settings.System.DEFAULT_RINGTONE_URI; + } else if (mStreamType == AudioManager.STREAM_NOTIFICATION) { + defaultUri = Settings.System.DEFAULT_NOTIFICATION_URI; + } else { + defaultUri = Settings.System.DEFAULT_ALARM_ALERT_URI; + } + + mRingtone = RingtoneManager.getRingtone(mContext, defaultUri); + if (mRingtone != null) { + mRingtone.setStreamType(mStreamType); + } } public void stop() { @@ -208,5 +242,12 @@ public class VolumePreference extends SeekBarPreference implements return mSeekBar; } + public void changeVolumeBy(int amount) { + mSeekBar.incrementProgressBy(amount); + if (mRingtone != null && !mRingtone.isPlaying()) { + sample(); + } + postSetVolume(mSeekBar.getProgress()); + } } } diff --git a/core/java/android/provider/Browser.java b/core/java/android/provider/Browser.java index 1ba5e25..92bc814 100644 --- a/core/java/android/provider/Browser.java +++ b/core/java/android/provider/Browser.java @@ -107,7 +107,8 @@ public class Browser { public static final String[] HISTORY_PROJECTION = new String[] { BookmarkColumns._ID, BookmarkColumns.URL, BookmarkColumns.VISITS, BookmarkColumns.DATE, BookmarkColumns.BOOKMARK, BookmarkColumns.TITLE, - BookmarkColumns.FAVICON }; + BookmarkColumns.FAVICON, BookmarkColumns.THUMBNAIL, + BookmarkColumns.TOUCH_ICON }; /* these indices dependent on HISTORY_PROJECTION */ public static final int HISTORY_PROJECTION_ID_INDEX = 0; @@ -117,6 +118,14 @@ public class Browser { public static final int HISTORY_PROJECTION_BOOKMARK_INDEX = 4; public static final int HISTORY_PROJECTION_TITLE_INDEX = 5; public static final int HISTORY_PROJECTION_FAVICON_INDEX = 6; + /** + * @hide + */ + public static final int HISTORY_PROJECTION_THUMBNAIL_INDEX = 7; + /** + * @hide + */ + public static final int HISTORY_PROJECTION_TOUCH_ICON_INDEX = 8; /* columns needed to determine whether to truncate history */ public static final String[] TRUNCATE_HISTORY_PROJECTION = new String[] { @@ -513,6 +522,14 @@ public class Browser { public static final String TITLE = "title"; public static final String CREATED = "created"; public static final String FAVICON = "favicon"; + /** + * @hide + */ + public static final String THUMBNAIL = "thumbnail"; + /** + * @hide + */ + public static final String TOUCH_ICON = "touch_icon"; } public static class SearchColumns implements BaseColumns { diff --git a/core/java/android/provider/Calendar.java b/core/java/android/provider/Calendar.java index 4a709f6..d57155c 100644 --- a/core/java/android/provider/Calendar.java +++ b/core/java/android/provider/Calendar.java @@ -32,6 +32,7 @@ import android.text.format.DateUtils; import android.text.format.Time; import android.util.Config; import android.util.Log; +import android.accounts.Account; import com.android.internal.database.ArrayListCursor; import com.google.android.gdata.client.AndroidGDataClient; import com.google.android.gdata.client.AndroidXmlParserFactory; @@ -80,6 +81,11 @@ public final class Calendar { public interface CalendarsColumns { /** + * A string that uniquely identifies this contact to its source + */ + public static final String SOURCE_ID = "sourceid"; + + /** * The color of the calendar * <P>Type: INTEGER (color value)</P> */ @@ -124,6 +130,12 @@ public final class Calendar { * <p>Type: INTEGER (boolean)</p> */ public static final String SYNC_EVENTS = "sync_events"; + + /** + * Sync state data. + * <p>Type: String (blob)</p> + */ + public static final String SYNC_STATE = "sync_state"; } /** @@ -157,11 +169,12 @@ public final class Calendar { * @param account the account whose rows should be deleted * @return the count of rows that were deleted */ - public static int deleteCalendarsForAccount(ContentResolver cr, - String account) { + public static int deleteCalendarsForAccount(ContentResolver cr, Account account) { // delete all calendars that match this account - return Calendar.Calendars.delete(cr, Calendar.Calendars._SYNC_ACCOUNT + "=?", - new String[] {account}); + return Calendar.Calendars.delete(cr, + Calendar.Calendars._SYNC_ACCOUNT + "=? AND " + + Calendar.Calendars._SYNC_ACCOUNT_TYPE + "=?", + new String[] {account.name, account.type}); } /** @@ -170,9 +183,6 @@ public final class Calendar { public static final Uri CONTENT_URI = Uri.parse("content://calendar/calendars"); - public static final Uri LIVE_CONTENT_URI = - Uri.parse("content://calendar/calendars?update=1"); - /** * The default sort order for this table */ @@ -207,6 +217,13 @@ public final class Calendar { * <P>Type: INTEGER (boolean)</P> */ public static final String HIDDEN = "hidden"; + + /** + * The owner account for this calendar, based on the calendar feed. + * This will be different from the _SYNC_ACCOUNT for delegated calendars. + * <P>Type: String</P> + */ + public static final String OWNER_ACCOUNT = "ownerAccount"; } public interface AttendeesColumns { @@ -448,6 +465,47 @@ public final class Calendar { * <P>Type: INTEGER (long; millis since epoch)</P> */ public static final String LAST_DATE = "lastDate"; + + /** + * Whether the event has attendee information. True if the event + * has full attendee data, false if the event has information about + * self only. + * <P>Type: INTEGER (boolean)</P> + */ + public static final String HAS_ATTENDEE_DATA = "hasAttendeeData"; + + /** + * Whether guests can modify the event. + * <P>Type: INTEGER (boolean)</P> + */ + public static final String GUESTS_CAN_MODIFY = "guestsCanModify"; + + /** + * Whether guests can invite other guests. + * <P>Type: INTEGER (boolean)</P> + */ + public static final String GUESTS_CAN_INVITE_OTHERS = "guestsCanInviteOthers"; + + /** + * Whether guests can see the list of attendees. + * <P>Type: INTEGER (boolean)</P> + */ + public static final String GUESTS_CAN_SEE_GUESTS = "guestsCanSeeGuests"; + + /** + * Email of the organizer (owner) of the event. + * <P>Type: STRING</P> + */ + public static final String ORGANIZER = "organizer"; + + /** + * Whether the user can invite others to the event. + * The GUESTS_CAN_INVITE_OTHERS is a setting that applies to an arbitrary guest, + * while CAN_INVITE_OTHERS indicates if the user can invite others (either through + * GUESTS_CAN_INVITE_OTHERS or because the user has modify access to the event). + * <P>Type: INTEGER (boolean, readonly)</P> + */ + public static final String CAN_INVITE_OTHERS = "canInviteOthers"; } /** @@ -694,6 +752,8 @@ public final class Calendar { * The content:// style URL for this table */ public static final Uri CONTENT_URI = Uri.parse("content://calendar/instances/when"); + public static final Uri CONTENT_BY_DAY_URI = + Uri.parse("content://calendar/instances/whenbyday"); /** * The default sort order for this table. diff --git a/core/java/android/provider/CallLog.java b/core/java/android/provider/CallLog.java index afe219c..b54ad5d 100644 --- a/core/java/android/provider/CallLog.java +++ b/core/java/android/provider/CallLog.java @@ -73,7 +73,7 @@ public class CallLog { public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/calls"; /** - * The type of the the phone number. + * The type of the call (incoming, outgoing or missed). * <P>Type: INTEGER (int)</P> */ public static final String TYPE = "type"; diff --git a/core/java/android/provider/Contacts.java b/core/java/android/provider/Contacts.java index 84fe184..c0dbf4d 100644 --- a/core/java/android/provider/Contacts.java +++ b/core/java/android/provider/Contacts.java @@ -30,6 +30,7 @@ import android.net.Uri; import android.text.TextUtils; import android.util.Log; import android.widget.ImageView; +import android.accounts.Account; import java.io.ByteArrayInputStream; import java.io.InputStream; @@ -39,7 +40,7 @@ import java.io.InputStream; */ public class Contacts { private static final String TAG = "Contacts"; - + public static final String AUTHORITY = "contacts"; /** @@ -75,6 +76,12 @@ public class Contacts { public static final String _SYNC_ACCOUNT = "_sync_account"; /** + * The _SYNC_ACCOUNT_TYPE to which this setting corresponds. This may be null. + * <P>Type: TEXT</P> + */ + public static final String _SYNC_ACCOUNT_TYPE = "_sync_account_type"; + + /** * The key of this setting. * <P>Type: TEXT</P> */ @@ -134,6 +141,7 @@ public class Contacts { selectString = (account == null) ? "_sync_account is null AND key=?" : "_sync_account=? AND key=?"; +// : "_sync_account=? AND _sync_account_type=? AND key=?"; selectArgs = (account == null) ? new String[]{key} : new String[]{account, key}; @@ -158,7 +166,8 @@ public class Contacts { // the account name is, so we're using a global setting for SYNC_EVERYTHING. // Some day when we add multiple accounts to the UI this should honor the account // that was asked for. - //values.put(_SYNC_ACCOUNT, account); + //values.put(_SYNC_ACCOUNT, account.mName); + //values.put(_SYNC_ACCOUNT_TYPE, account.mType); values.put(KEY, key); values.put(VALUE, value); cr.update(Settings.CONTENT_URI, values, null, null); @@ -182,7 +191,7 @@ public class Contacts { * <p>Type: TEXT</P> */ public static final String PHONETIC_NAME = "phonetic_name"; - + /** * The display name. If name is not null name, else if number is not null number, * else if email is not null email. @@ -197,7 +206,7 @@ public class Contacts { * @hide Used only in Contacts application for now. */ public static final String SORT_STRING = "sort_string"; - + /** * Notes about the person. * <P>Type: TEXT</P> @@ -239,7 +248,7 @@ public class Contacts { * The server version of the photo * <P>Type: TEXT (the version number portion of the photo URI)</P> */ - public static final String PHOTO_VERSION = "photo_version"; + public static final String PHOTO_VERSION = "photo_version"; } /** @@ -278,14 +287,14 @@ public class Contacts { * additional path segment after this URI. This matches any people with * at least one E-mail or IM {@link ContactMethods} that match the * filter. - * + * * Not exposed because we expect significant changes in the contacts * schema and do not want to have to support this. * @hide */ public static final Uri WITH_EMAIL_OR_IM_FILTER_URI = Uri.parse("content://contacts/people/with_email_or_im_filter"); - + /** * The MIME type of {@link #CONTENT_URI} providing a directory of * people. @@ -370,13 +379,13 @@ public class Contacts { if (groupId == 0) { throw new IllegalStateException("Failed to find the My Contacts group"); } - + return addToGroup(resolver, personId, groupId); } /** * Adds a person to a group referred to by name. - * + * * @param resolver the resolver to use * @param personId the person to add to the group * @param groupName the name of the group to add the contact to @@ -400,13 +409,13 @@ public class Contacts { if (groupId == 0) { throw new IllegalStateException("Failed to find the My Contacts group"); } - + return addToGroup(resolver, personId, groupId); } /** * Adds a person to a group. - * + * * @param resolver the resolver to use * @param personId the person to add to the group * @param groupId the group to add the person to @@ -418,14 +427,14 @@ public class Contacts { values.put(GroupMembership.GROUP_ID, groupId); return resolver.insert(GroupMembership.CONTENT_URI, values); } - + private static final String[] GROUPS_PROJECTION = new String[] { Groups._ID, }; /** * Creates a new contacts and adds it to the "My Contacts" group. - * + * * @param resolver the ContentResolver to use * @param values the values to use when creating the contact * @return the URI of the contact, or null if the operation fails @@ -463,7 +472,7 @@ public class Contacts { values.put(Photos.DATA, data); cr.update(photoUri, values, null, null); } - + /** * Opens an InputStream for the person's photo and returns the photo as a Bitmap. * If the person's photo isn't present returns the placeholderImageResource instead. @@ -730,7 +739,7 @@ public class Contacts { CharSequence display = ""; if (type != People.Phones.TYPE_CUSTOM) { - CharSequence[] labels = labelArray != null? labelArray + CharSequence[] labels = labelArray != null? labelArray : context.getResources().getTextArray( com.android.internal.R.array.phoneTypes); try { @@ -750,7 +759,7 @@ public class Contacts { CharSequence label) { return getDisplayLabel(context, type, label, null); } - + /** * The content:// style URL for this table */ @@ -846,6 +855,12 @@ public class Contacts { public static final String GROUP_SYNC_ACCOUNT = "group_sync_account"; /** + * The account type of the group. + * <P>Type: TEXT</P> + */ + public static final String GROUP_SYNC_ACCOUNT_TYPE = "group_sync_account_type"; + + /** * The row id of the person. * <P>Type: TEXT</P> */ @@ -969,7 +984,7 @@ public class Contacts { throw new IllegalArgumentException( "the value is not a valid encoded protocol, " + encodedString); } - + /** * This looks up the provider name defined in * {@link android.provider.Im.ProviderNames} from the predefined IM protocol id. @@ -1022,13 +1037,7 @@ public class Contacts { } } else { if (!TextUtils.isEmpty(label)) { - if (label.toString().equals(MOBILE_EMAIL_TYPE_NAME)) { - display = - context.getString( - com.android.internal.R.string.mobileEmailTypeName); - } else { - display = label; - } + display = label; } } break; @@ -1188,7 +1197,7 @@ public class Contacts { /** * Gets the resource ID for the proper presence icon. - * + * * @param status the status to get the icon for * @return the resource ID for the proper presence icon */ @@ -1196,17 +1205,17 @@ public class Contacts { switch (status) { case Contacts.People.AVAILABLE: return com.android.internal.R.drawable.presence_online; - + case Contacts.People.IDLE: case Contacts.People.AWAY: return com.android.internal.R.drawable.presence_away; - + case Contacts.People.DO_NOT_DISTURB: return com.android.internal.R.drawable.presence_busy; - + case Contacts.People.INVISIBLE: return com.android.internal.R.drawable.presence_invisible; - + case Contacts.People.OFFLINE: default: return com.android.internal.R.drawable.presence_offline; @@ -1229,7 +1238,7 @@ public class Contacts { */ public interface OrganizationColumns { /** - * The type of the the phone number. + * The type of the organizations. * <P>Type: INTEGER (one of the constants below)</P> */ public static final String TYPE = "type"; @@ -1446,28 +1455,27 @@ public class Contacts { * This is the intent that is fired when a search suggestion is clicked on. */ public static final String SEARCH_SUGGESTION_CLICKED = - "android.provider.Contacts.SEARCH_SUGGESTION_CLICKED"; + ContactsContract.Intents.SEARCH_SUGGESTION_CLICKED; /** - * This is the intent that is fired when a search suggestion for dialing a number + * This is the intent that is fired when a search suggestion for dialing a number * is clicked on. */ public static final String SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED = - "android.provider.Contacts.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED"; + ContactsContract.Intents.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED; /** * This is the intent that is fired when a search suggestion for creating a contact * is clicked on. */ public static final String SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED = - "android.provider.Contacts.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED"; + ContactsContract.Intents.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED; /** * Starts an Activity that lets the user pick a contact to attach an image to. * After picking the contact it launches the image cropper in face detection mode. */ - public static final String ATTACH_IMAGE = - "com.android.contacts.action.ATTACH_IMAGE"; + public static final String ATTACH_IMAGE = ContactsContract.Intents.ATTACH_IMAGE; /** * Takes as input a data URI with a mailto: or tel: scheme. If a single @@ -1493,7 +1501,7 @@ public class Contacts { * prompting the user when the contact doesn't exist. */ public static final String SHOW_OR_CREATE_CONTACT = - "com.android.contacts.action.SHOW_OR_CREATE_CONTACT"; + ContactsContract.Intents.SHOW_OR_CREATE_CONTACT; /** * Used with {@link #SHOW_OR_CREATE_CONTACT} to force creating a new @@ -1502,9 +1510,8 @@ public class Contacts { * <p> * Type: BOOLEAN */ - public static final String EXTRA_FORCE_CREATE = - "com.android.contacts.action.FORCE_CREATE"; - + public static final String EXTRA_FORCE_CREATE = ContactsContract.Intents.EXTRA_FORCE_CREATE; + /** * Used with {@link #SHOW_OR_CREATE_CONTACT} to specify an exact * description to be shown when prompting user about creating a new @@ -1513,7 +1520,16 @@ public class Contacts { * Type: STRING */ public static final String EXTRA_CREATE_DESCRIPTION = - "com.android.contacts.action.CREATE_DESCRIPTION"; + ContactsContract.Intents.EXTRA_CREATE_DESCRIPTION; + + /** + * Optional extra used with {@link #SHOW_OR_CREATE_CONTACT} to specify a + * dialog location using screen coordinates. When not specified, the + * dialog will be centered. + * + * @hide pending API council review + */ + public static final String EXTRA_TARGET_RECT = ContactsContract.Intents.EXTRA_TARGET_RECT; /** * Intents related to the Contacts app UI. @@ -1522,43 +1538,42 @@ public class Contacts { /** * The action for the default contacts list tab. */ - public static final String LIST_DEFAULT = - "com.android.contacts.action.LIST_DEFAULT"; + public static final String LIST_DEFAULT = ContactsContract.Intents.UI.LIST_DEFAULT; /** * The action for the contacts list tab. */ public static final String LIST_GROUP_ACTION = - "com.android.contacts.action.LIST_GROUP"; + ContactsContract.Intents.UI.LIST_GROUP_ACTION; /** * When in LIST_GROUP_ACTION mode, this is the group to display. */ - public static final String GROUP_NAME_EXTRA_KEY = "com.android.contacts.extra.GROUP"; - + public static final String GROUP_NAME_EXTRA_KEY = + ContactsContract.Intents.UI.GROUP_NAME_EXTRA_KEY; /** * The action for the all contacts list tab. */ public static final String LIST_ALL_CONTACTS_ACTION = - "com.android.contacts.action.LIST_ALL_CONTACTS"; + ContactsContract.Intents.UI.LIST_ALL_CONTACTS_ACTION; /** * The action for the contacts with phone numbers list tab. */ public static final String LIST_CONTACTS_WITH_PHONES_ACTION = - "com.android.contacts.action.LIST_CONTACTS_WITH_PHONES"; + ContactsContract.Intents.UI.LIST_CONTACTS_WITH_PHONES_ACTION; /** * The action for the starred contacts list tab. */ public static final String LIST_STARRED_ACTION = - "com.android.contacts.action.LIST_STARRED"; + ContactsContract.Intents.UI.LIST_STARRED_ACTION; /** * The action for the frequent contacts list tab. */ public static final String LIST_FREQUENT_ACTION = - "com.android.contacts.action.LIST_FREQUENT"; + ContactsContract.Intents.UI.LIST_FREQUENT_ACTION; /** * The action for the "strequent" contacts list tab. It first lists the starred @@ -1566,15 +1581,15 @@ public class Contacts { * order of the number of times they have been contacted. */ public static final String LIST_STREQUENT_ACTION = - "com.android.contacts.action.LIST_STREQUENT"; + ContactsContract.Intents.UI.LIST_STREQUENT_ACTION; /** * A key for to be used as an intent extra to set the activity * title to a custom String value. */ public static final String TITLE_EXTRA_KEY = - "com.android.contacts.extra.TITLE_EXTRA"; - + ContactsContract.Intents.UI.TITLE_EXTRA_KEY; + /** * Activity Action: Display a filtered list of contacts * <p> @@ -1583,15 +1598,15 @@ public class Contacts { * <p> * Output: Nothing. */ - public static final String FILTER_CONTACTS_ACTION = - "com.android.contacts.action.FILTER_CONTACTS"; - + public static final String FILTER_CONTACTS_ACTION = + ContactsContract.Intents.UI.FILTER_CONTACTS_ACTION; + /** * Used as an int extra field in {@link #FILTER_CONTACTS_ACTION} * intents to supply the text on which to filter. */ - public static final String FILTER_TEXT_EXTRA_KEY = - "com.android.contacts.extra.FILTER_TEXT"; + public static final String FILTER_TEXT_EXTRA_KEY = + ContactsContract.Intents.UI.FILTER_TEXT_EXTRA_KEY; } /** @@ -1600,170 +1615,179 @@ public class Contacts { */ public static final class Insert { /** The action code to use when adding a contact */ - public static final String ACTION = Intent.ACTION_INSERT; - + public static final String ACTION = ContactsContract.Intents.Insert.ACTION; /** * If present, forces a bypass of quick insert mode. */ - public static final String FULL_MODE = "full_mode"; - + public static final String FULL_MODE = ContactsContract.Intents.Insert.FULL_MODE; /** * The extra field for the contact name. * <P>Type: String</P> */ - public static final String NAME = "name"; + public static final String NAME = ContactsContract.Intents.Insert.NAME; /** * The extra field for the contact phonetic name. * <P>Type: String</P> */ - public static final String PHONETIC_NAME = "phonetic_name"; + public static final String PHONETIC_NAME = + ContactsContract.Intents.Insert.PHONETIC_NAME; /** * The extra field for the contact company. * <P>Type: String</P> */ - public static final String COMPANY = "company"; + public static final String COMPANY = ContactsContract.Intents.Insert.COMPANY; /** * The extra field for the contact job title. * <P>Type: String</P> */ - public static final String JOB_TITLE = "job_title"; + public static final String JOB_TITLE = ContactsContract.Intents.Insert.JOB_TITLE; /** * The extra field for the contact notes. * <P>Type: String</P> */ - public static final String NOTES = "notes"; + public static final String NOTES = ContactsContract.Intents.Insert.NOTES; /** * The extra field for the contact phone number. * <P>Type: String</P> */ - public static final String PHONE = "phone"; + public static final String PHONE = ContactsContract.Intents.Insert.PHONE; /** * The extra field for the contact phone number type. * <P>Type: Either an integer value from {@link android.provider.Contacts.PhonesColumns PhonesColumns}, * or a string specifying a custom label.</P> */ - public static final String PHONE_TYPE = "phone_type"; + public static final String PHONE_TYPE = ContactsContract.Intents.Insert.PHONE_TYPE; /** * The extra field for the phone isprimary flag. * <P>Type: boolean</P> */ - public static final String PHONE_ISPRIMARY = "phone_isprimary"; + public static final String PHONE_ISPRIMARY = + ContactsContract.Intents.Insert.PHONE_ISPRIMARY; /** * The extra field for an optional second contact phone number. * <P>Type: String</P> */ - public static final String SECONDARY_PHONE = "secondary_phone"; + public static final String SECONDARY_PHONE = + ContactsContract.Intents.Insert.SECONDARY_PHONE; /** * The extra field for an optional second contact phone number type. * <P>Type: Either an integer value from {@link android.provider.Contacts.PhonesColumns PhonesColumns}, * or a string specifying a custom label.</P> */ - public static final String SECONDARY_PHONE_TYPE = "secondary_phone_type"; + public static final String SECONDARY_PHONE_TYPE = + ContactsContract.Intents.Insert.SECONDARY_PHONE_TYPE; /** * The extra field for an optional third contact phone number. * <P>Type: String</P> */ - public static final String TERTIARY_PHONE = "tertiary_phone"; + public static final String TERTIARY_PHONE = + ContactsContract.Intents.Insert.TERTIARY_PHONE; /** * The extra field for an optional third contact phone number type. * <P>Type: Either an integer value from {@link android.provider.Contacts.PhonesColumns PhonesColumns}, * or a string specifying a custom label.</P> */ - public static final String TERTIARY_PHONE_TYPE = "tertiary_phone_type"; + public static final String TERTIARY_PHONE_TYPE = + ContactsContract.Intents.Insert.TERTIARY_PHONE_TYPE; /** * The extra field for the contact email address. * <P>Type: String</P> */ - public static final String EMAIL = "email"; + public static final String EMAIL = ContactsContract.Intents.Insert.EMAIL; /** * The extra field for the contact email type. * <P>Type: Either an integer value from {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} * or a string specifying a custom label.</P> */ - public static final String EMAIL_TYPE = "email_type"; + public static final String EMAIL_TYPE = ContactsContract.Intents.Insert.EMAIL_TYPE; /** * The extra field for the email isprimary flag. * <P>Type: boolean</P> */ - public static final String EMAIL_ISPRIMARY = "email_isprimary"; + public static final String EMAIL_ISPRIMARY = + ContactsContract.Intents.Insert.EMAIL_ISPRIMARY; /** * The extra field for an optional second contact email address. * <P>Type: String</P> */ - public static final String SECONDARY_EMAIL = "secondary_email"; + public static final String SECONDARY_EMAIL = + ContactsContract.Intents.Insert.SECONDARY_EMAIL; /** * The extra field for an optional second contact email type. * <P>Type: Either an integer value from {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} * or a string specifying a custom label.</P> */ - public static final String SECONDARY_EMAIL_TYPE = "secondary_email_type"; + public static final String SECONDARY_EMAIL_TYPE = + ContactsContract.Intents.Insert.SECONDARY_EMAIL_TYPE; /** * The extra field for an optional third contact email address. * <P>Type: String</P> */ - public static final String TERTIARY_EMAIL = "tertiary_email"; + public static final String TERTIARY_EMAIL = + ContactsContract.Intents.Insert.TERTIARY_EMAIL; /** * The extra field for an optional third contact email type. * <P>Type: Either an integer value from {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} * or a string specifying a custom label.</P> */ - public static final String TERTIARY_EMAIL_TYPE = "tertiary_email_type"; + public static final String TERTIARY_EMAIL_TYPE = + ContactsContract.Intents.Insert.TERTIARY_EMAIL_TYPE; /** * The extra field for the contact postal address. * <P>Type: String</P> */ - public static final String POSTAL = "postal"; + public static final String POSTAL = ContactsContract.Intents.Insert.POSTAL; /** * The extra field for the contact postal address type. * <P>Type: Either an integer value from {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} * or a string specifying a custom label.</P> */ - public static final String POSTAL_TYPE = "postal_type"; + public static final String POSTAL_TYPE = ContactsContract.Intents.Insert.POSTAL_TYPE; /** * The extra field for the postal isprimary flag. * <P>Type: boolean</P> */ - public static final String POSTAL_ISPRIMARY = "postal_isprimary"; + public static final String POSTAL_ISPRIMARY = ContactsContract.Intents.Insert.POSTAL_ISPRIMARY; /** * The extra field for an IM handle. * <P>Type: String</P> */ - public static final String IM_HANDLE = "im_handle"; + public static final String IM_HANDLE = ContactsContract.Intents.Insert.IM_HANDLE; /** * The extra field for the IM protocol * <P>Type: the result of {@link Contacts.ContactMethods#encodePredefinedImProtocol} * or {@link Contacts.ContactMethods#encodeCustomImProtocol}.</P> */ - public static final String IM_PROTOCOL = "im_protocol"; + public static final String IM_PROTOCOL = ContactsContract.Intents.Insert.IM_PROTOCOL; /** * The extra field for the IM isprimary flag. * <P>Type: boolean</P> */ - public static final String IM_ISPRIMARY = "im_isprimary"; + public static final String IM_ISPRIMARY = ContactsContract.Intents.Insert.IM_ISPRIMARY; } } } diff --git a/core/java/android/provider/ContactsContract.java b/core/java/android/provider/ContactsContract.java new file mode 100644 index 0000000..1cf63c1 --- /dev/null +++ b/core/java/android/provider/ContactsContract.java @@ -0,0 +1,2053 @@ +/* + * Copyright (C) 2009 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.provider; + +import android.accounts.Account; +import android.content.ContentProviderClient; +import android.content.ContentProviderOperation; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.content.res.Resources; +import android.database.Cursor; +import android.graphics.BitmapFactory; +import android.net.Uri; +import android.os.RemoteException; +import android.text.TextUtils; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; + +/** + * The contract between the contacts provider and applications. Contains definitions + * for the supported URIs and columns. + * + * @hide + */ +public final class ContactsContract { + /** The authority for the contacts provider */ + public static final String AUTHORITY = "com.android.contacts"; + /** A content:// style uri to the authority for the contacts provider */ + public static final Uri AUTHORITY_URI = Uri.parse("content://" + AUTHORITY); + + public interface SyncStateColumns extends SyncStateContract.Columns { + } + + public static final class SyncState { + /** + * This utility class cannot be instantiated + */ + private SyncState() {} + + public static final String CONTENT_DIRECTORY = + SyncStateContract.Constants.CONTENT_DIRECTORY; + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = + Uri.withAppendedPath(AUTHORITY_URI, CONTENT_DIRECTORY); + + /** + * @see android.provider.SyncStateContract.Helpers#get + */ + public static byte[] get(ContentProviderClient provider, Account account) + throws RemoteException { + return SyncStateContract.Helpers.get(provider, CONTENT_URI, account); + } + + /** + * @see android.provider.SyncStateContract.Helpers#set + */ + public static void set(ContentProviderClient provider, Account account, byte[] data) + throws RemoteException { + SyncStateContract.Helpers.set(provider, CONTENT_URI, account, data); + } + + /** + * @see android.provider.SyncStateContract.Helpers#newSetOperation + */ + public static ContentProviderOperation newSetOperation(Account account, byte[] data) { + return SyncStateContract.Helpers.newSetOperation(CONTENT_URI, account, data); + } + } + + /** + * Generic columns for use by sync adapters. The specific functions of + * these columns are private to the sync adapter. Other clients of the API + * should not attempt to either read or write this column. + */ + private interface BaseSyncColumns { + + /** Generic column for use by sync adapters. */ + public static final String SYNC1 = "sync1"; + /** Generic column for use by sync adapters. */ + public static final String SYNC2 = "sync2"; + /** Generic column for use by sync adapters. */ + public static final String SYNC3 = "sync3"; + /** Generic column for use by sync adapters. */ + public static final String SYNC4 = "sync4"; + } + + /** + * Columns that appear when each row of a table belongs to a specific + * account, including sync information that an account may need. + */ + private interface SyncColumns extends BaseSyncColumns { + /** + * The name of the account instance to which this row belongs. + * <P>Type: TEXT</P> + */ + public static final String ACCOUNT_NAME = "account_name"; + + /** + * The type of account to which this row belongs, which when paired with + * {@link #ACCOUNT_NAME} identifies a specific account. + * <P>Type: TEXT</P> + */ + public static final String ACCOUNT_TYPE = "account_type"; + + /** + * String that uniquely identifies this row to its source account. + * <P>Type: TEXT</P> + */ + public static final String SOURCE_ID = "sourceid"; + + /** + * Version number that is updated whenever this row or its related data + * changes. + * <P>Type: INTEGER</P> + */ + public static final String VERSION = "version"; + + /** + * Flag indicating that {@link #VERSION} has changed, and this row needs + * to be synchronized by its owning account. + * <P>Type: INTEGER (boolean)</P> + */ + public static final String DIRTY = "dirty"; + } + + public interface ContactOptionsColumns { + /** + * The number of times a person has been contacted + * <P>Type: INTEGER</P> + */ + public static final String TIMES_CONTACTED = "times_contacted"; + + /** + * The last time a person was contacted. + * <P>Type: INTEGER</P> + */ + public static final String LAST_TIME_CONTACTED = "last_time_contacted"; + + /** + * Is the contact starred? + * <P>Type: INTEGER (boolean)</P> + */ + public static final String STARRED = "starred"; + + /** + * A custom ringtone associated with a person. Not always present. + * <P>Type: TEXT (URI to the ringtone)</P> + */ + public static final String CUSTOM_RINGTONE = "custom_ringtone"; + + /** + * Whether the person should always be sent to voicemail. Not always + * present. + * <P>Type: INTEGER (0 for false, 1 for true)</P> + */ + public static final String SEND_TO_VOICEMAIL = "send_to_voicemail"; + } + + private interface ContactsColumns { + /** + * The display name for the contact. + * <P>Type: TEXT</P> + */ + public static final String DISPLAY_NAME = "display_name"; + + /** + * Reference to the row in the data table holding the photo. + * <P>Type: INTEGER REFERENCES data(_id)</P> + */ + public static final String PHOTO_ID = "photo_id"; + + /** + * Lookup value that reflects the {@link Groups#GROUP_VISIBLE} state of + * any {@link CommonDataKinds.GroupMembership} for this contact. + */ + public static final String IN_VISIBLE_GROUP = "in_visible_group"; + + /** + * Contact presence status. See {@link android.provider.Im.CommonPresenceColumns} + * for individual status definitions. This column is only returned if explicitly + * requested in the query projection. + * <p>Type: NUMBER</p> + */ + public static final String PRESENCE_STATUS = Presence.PRESENCE_STATUS; + + /** + * Contact presence custom status. This column is only returned if explicitly + * requested in the query projection. + * <p>Type: TEXT</p> + */ + public static final String PRESENCE_CUSTOM_STATUS = Presence.PRESENCE_CUSTOM_STATUS; + + /** + * An indicator of whether this contact has at least one phone number. "1" if there is + * at least one phone number, "0" otherwise. + * <P>Type: INTEGER</P> + */ + public static final String HAS_PHONE_NUMBER = "has_phone_number"; + } + + /** + * Constants for the contacts table, which contains a record per group + * of raw contact representing the same person. + */ + public static class Contacts implements BaseColumns, ContactsColumns, + ContactOptionsColumns { + /** + * This utility class cannot be instantiated + */ + private Contacts() {} + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "contacts"); + + /** + * The content:// style URI for this table joined with useful data from + * {@link Data}. + */ + public static final Uri CONTENT_SUMMARY_URI = Uri.withAppendedPath(AUTHORITY_URI, + "contacts_summary"); + + /** + * The content:// style URI used for "type-to-filter" functionality on the + * {@link #CONTENT_SUMMARY_URI} URI. The filter string will be used to match + * various parts of the contact name. The filter argument should be passed + * as an additional path segment after this URI. + */ + public static final Uri CONTENT_SUMMARY_FILTER_URI = Uri.withAppendedPath( + CONTENT_SUMMARY_URI, "filter"); + + /** + * The content:// style URI for this table joined with useful data from + * {@link Data}, filtered to include only starred contacts + * and the most frequently contacted contacts. + */ + public static final Uri CONTENT_SUMMARY_STREQUENT_URI = Uri.withAppendedPath( + CONTENT_SUMMARY_URI, "strequent"); + + /** + * The content:// style URI used for "type-to-filter" functionality on the + * {@link #CONTENT_SUMMARY_STREQUENT_URI} URI. The filter string will be used to match + * various parts of the contact name. The filter argument should be passed + * as an additional path segment after this URI. + */ + public static final Uri CONTENT_SUMMARY_STREQUENT_FILTER_URI = Uri.withAppendedPath( + CONTENT_SUMMARY_STREQUENT_URI, "filter"); + + public static final Uri CONTENT_SUMMARY_GROUP_URI = Uri.withAppendedPath( + CONTENT_SUMMARY_URI, "group"); + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of + * people. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/contact"; + + /** + * The MIME type of a {@link #CONTENT_URI} subdirectory of a single + * person. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/contact"; + + /** + * A sub-directory of a single contact that contains all of the constituent raw contact + * {@link Data} rows. + */ + public static final class Data implements BaseColumns, DataColumns { + /** + * no public constructor since this is a utility class + */ + private Data() {} + + /** + * The directory twig for this sub-table + */ + public static final String CONTENT_DIRECTORY = "data"; + } + + /** + * A sub-directory of a single contact aggregate that contains all aggregation suggestions + * (other contacts). The aggregation suggestions are computed based on approximate + * data matches with this contact. + */ + public static final class AggregationSuggestions implements BaseColumns, ContactsColumns { + /** + * No public constructor since this is a utility class + */ + private AggregationSuggestions() {} + + /** + * The directory twig for this sub-table + */ + public static final String CONTENT_DIRECTORY = "suggestions"; + } + + /** + * A sub-directory of a single contact that contains the contact's primary photo. + */ + public static final class Photo implements BaseColumns, DataColumns { + /** + * no public constructor since this is a utility class + */ + private Photo() {} + + /** + * The directory twig for this sub-table + */ + public static final String CONTENT_DIRECTORY = "photo"; + } + + /** + * Opens an InputStream for the person's default photo and returns the + * photo as a Bitmap stream. + * + * @param contactUri the contact whose photo should be used + */ + public static InputStream openContactPhotoInputStream(ContentResolver cr, Uri contactUri) { + Uri photoUri = Uri.withAppendedPath(contactUri, Photo.CONTENT_DIRECTORY); + if (photoUri == null) { + return null; + } + Cursor cursor = cr.query(photoUri, + new String[]{ContactsContract.CommonDataKinds.Photo.PHOTO}, null, null, null); + try { + if (!cursor.moveToNext()) { + return null; + } + byte[] data = cursor.getBlob(0); + if (data == null) { + return null; + } + return new ByteArrayInputStream(data); + } finally { + cursor.close(); + } + } + } + + private interface RawContactsColumns { + /** + * A reference to the {@link android.provider.ContactsContract.Contacts#_ID} that this + * data belongs to. + * <P>Type: INTEGER</P> + */ + public static final String CONTACT_ID = "contact_id"; + + /** + * Flag indicating that this {@link RawContacts} entry and its children has + * been restricted to specific platform apps. + * <P>Type: INTEGER (boolean)</P> + * + * @hide until finalized in future platform release + */ + public static final String IS_RESTRICTED = "is_restricted"; + + /** + * The aggregation mode for this contact. + * <P>Type: INTEGER</P> + */ + public static final String AGGREGATION_MODE = "aggregation_mode"; + + /** + * The "deleted" flag: "0" by default, "1" if the row has been marked + * for deletion. When {@link android.content.ContentResolver#delete} is + * called on a raw contact, it is marked for deletion and removed from its + * aggregate contact. The sync adaptor deletes the raw contact on the server and + * then calls ContactResolver.delete once more, this time passing the + * {@link RawContacts#DELETE_PERMANENTLY} query parameter to finalize the data removal. + * <P>Type: INTEGER</P> + */ + public static final String DELETED = "deleted"; + } + + /** + * Constants for the raw_contacts table, which contains the base contact + * information per sync source. Sync adapters and contact management apps + * are the primary consumers of this API. + */ + public static final class RawContacts implements BaseColumns, RawContactsColumns, + ContactOptionsColumns, SyncColumns { + /** + * This utility class cannot be instantiated + */ + private RawContacts() { + } + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "raw_contacts"); + + /** + * The content:// style URL for filtering people by email address. The + * filter argument should be passed as an additional path segment after + * this URI. + * + * @hide + */ + @Deprecated + public static final Uri CONTENT_FILTER_EMAIL_URI = + Uri.withAppendedPath(CONTENT_URI, "filter_email"); + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of + * people. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/raw_contact"; + + /** + * The MIME type of a {@link #CONTENT_URI} subdirectory of a single + * person. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/raw_contact"; + + /** + * Query parameter that can be passed with the {@link #CONTENT_URI} URI + * to the {@link android.content.ContentResolver#delete} method to + * indicate that the raw contact can be deleted physically, rather than + * merely marked as deleted. + */ + public static final String DELETE_PERMANENTLY = "delete_permanently"; + + /** + * Aggregation mode: aggregate asynchronously. + */ + public static final int AGGREGATION_MODE_DEFAULT = 0; + + /** + * Aggregation mode: aggregate at the time the raw contact is inserted/updated. + */ + public static final int AGGREGATION_MODE_IMMEDITATE = 1; + + /** + * Aggregation mode: never aggregate this raw contact (note that the raw contact will not + * have a corresponding Aggregate and therefore will not be included in Aggregates + * query results.) + */ + public static final int AGGREGATION_MODE_DISABLED = 2; + + /** + * A sub-directory of a single raw contact that contains all of their {@link Data} rows. + * To access this directory append + */ + public static final class Data implements BaseColumns, DataColumns { + /** + * no public constructor since this is a utility class + */ + private Data() { + } + + /** + * The directory twig for this sub-table + */ + public static final String CONTENT_DIRECTORY = "data"; + } + } + + private interface DataColumns { + /** + * The package name to use when creating {@link Resources} objects for + * this data row. This value is only designed for use when building user + * interfaces, and should not be used to infer the owner. + */ + public static final String RES_PACKAGE = "res_package"; + + /** + * The MIME type of the item represented by this row. + */ + public static final String MIMETYPE = "mimetype"; + + /** + * A reference to the {@link RawContacts#_ID} + * that this data belongs to. + */ + public static final String RAW_CONTACT_ID = "raw_contact_id"; + + /** + * Whether this is the primary entry of its kind for the raw contact it belongs to + * <P>Type: INTEGER (if set, non-0 means true)</P> + */ + public static final String IS_PRIMARY = "is_primary"; + + /** + * Whether this is the primary entry of its kind for the aggregate + * contact it belongs to. Any data record that is "super primary" must + * also be "primary". + * <P>Type: INTEGER (if set, non-0 means true)</P> + */ + public static final String IS_SUPER_PRIMARY = "is_super_primary"; + + /** + * The version of this data record. This is a read-only value. The data column is + * guaranteed to not change without the version going up. This value is monotonically + * increasing. + * <P>Type: INTEGER</P> + */ + public static final String DATA_VERSION = "data_version"; + + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA1 = "data1"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA2 = "data2"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA3 = "data3"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA4 = "data4"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA5 = "data5"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA6 = "data6"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA7 = "data7"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA8 = "data8"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA9 = "data9"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA10 = "data10"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA11 = "data11"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA12 = "data12"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA13 = "data13"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA14 = "data14"; + /** Generic data column, the meaning is {@link #MIMETYPE} specific */ + public static final String DATA15 = "data15"; + + /** Generic column for use by sync adapters. */ + public static final String SYNC1 = "data_sync1"; + /** Generic column for use by sync adapters. */ + public static final String SYNC2 = "data_sync2"; + /** Generic column for use by sync adapters. */ + public static final String SYNC3 = "data_sync3"; + /** Generic column for use by sync adapters. */ + public static final String SYNC4 = "data_sync4"; + + /** + * An optional insert, update or delete URI parameter that determines if + * the corresponding raw contact should be marked as dirty. The default + * value is true. + */ + public static final String MARK_AS_DIRTY = "mark_as_dirty"; + } + + /** + * Constants for the data table, which contains data points tied to a raw contact. + * For example, a phone number or email address. Each row in this table contains a type + * definition and some generic columns. Each data type can define the meaning for each of + * the generic columns. + */ + public static final class Data implements BaseColumns, DataColumns { + /** + * This utility class cannot be instantiated + */ + private Data() {} + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "data"); + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of data. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/data"; + } + + private interface PhoneLookupColumns { + /** + * The phone number as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String NUMBER = "number"; + + /** + * The type of phone number, for example Home or Work. + * <P>Type: INTEGER</P> + */ + public static final String TYPE = "type"; + + /** + * The user defined label for the phone number. + * <P>Type: TEXT</P> + */ + public static final String LABEL = "label"; + } + + /** + * A table that represents the result of looking up a phone number, for + * example for caller ID. To perform a lookup you must append the number you + * want to find to {@link #CONTENT_FILTER_URI}. + */ + public static final class PhoneLookup implements BaseColumns, PhoneLookupColumns, + ContactsColumns, ContactOptionsColumns { + /** + * This utility class cannot be instantiated + */ + private PhoneLookup() {} + + /** + * The content:// style URI for this table. Append the phone number you want to lookup + * to this URI and query it to perform a lookup. For example: + * + * {@code + * Uri lookupUri = Uri.withAppendedPath(PhoneLookup.CONTENT_URI, phoneNumber); + * } + */ + public static final Uri CONTENT_FILTER_URI = Uri.withAppendedPath(AUTHORITY_URI, + "phone_lookup"); + } + + /** + * Additional data mixed in with {@link Im.CommonPresenceColumns} to link + * back to specific {@link ContactsContract.Contacts#_ID} entries. + */ + private interface PresenceColumns { + + /** + * The unique ID for a row. + * <P>Type: INTEGER (long)</P> + */ + public static final String _ID = "presence_id"; + + /** + * Reference to the {@link RawContacts#_ID} this presence references. + * <P>Type: INTEGER</P> + * + * TODO remove this from public API + * @hide + */ + @Deprecated + public static final String RAW_CONTACT_ID = "presence_raw_contact_id"; + + /** + * Reference to the {@link Data#_ID} entry that owns this presence. + * <P>Type: INTEGER</P> + */ + public static final String DATA_ID = "presence_data_id"; + + @Deprecated + public static final String IM_PROTOCOL = "im_protocol"; + + /** + * <p>Type: NUMBER</p> + */ + public static final String PROTOCOL = "protocol"; + + /** + * Name of the custom protocol. Should be supplied along with the {@link #PROTOCOL} value + * {@link ContactsContract.CommonDataKinds.Im#PROTOCOL_CUSTOM}. Should be null or + * omitted if {@link #PROTOCOL} value is not + * {@link ContactsContract.CommonDataKinds.Im#PROTOCOL_CUSTOM}. + * + * <p>Type: NUMBER</p> + */ + public static final String CUSTOM_PROTOCOL = "custom_protocol"; + + /** + * The IM handle the presence item is for. The handle is scoped to + * {@link #PROTOCOL}. + * <P>Type: TEXT</P> + */ + public static final String IM_HANDLE = "im_handle"; + + /** + * The IM account for the local user that the presence data came from. + * <P>Type: TEXT</P> + */ + public static final String IM_ACCOUNT = "im_account"; + } + + public static final class Presence implements PresenceColumns, Im.CommonPresenceColumns { + /** + * This utility class cannot be instantiated + */ + private Presence() { + } + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "presence"); + + /** + * Gets the resource ID for the proper presence icon. + * + * @param status the status to get the icon for + * @return the resource ID for the proper presence icon + */ + public static final int getPresenceIconResourceId(int status) { + switch (status) { + case AVAILABLE: + return android.R.drawable.presence_online; + case IDLE: + case AWAY: + return android.R.drawable.presence_away; + case DO_NOT_DISTURB: + return android.R.drawable.presence_busy; + case INVISIBLE: + return android.R.drawable.presence_invisible; + case OFFLINE: + default: + return android.R.drawable.presence_offline; + } + } + + /** + * Returns the precedence of the status code the higher number being the higher precedence. + * + * @param status The status code. + * @return An integer representing the precedence, 0 being the lowest. + */ + public static final int getPresencePrecedence(int status) { + // Keep this function here incase we want to enforce a different precedence than the + // natural order of the status constants. + return status; + } + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of + * presence details. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/im-presence"; + + /** + * The MIME type of a {@link #CONTENT_URI} subdirectory of a single + * presence detail. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/im-presence"; + } + + /** + * Container for definitions of common data types stored in the {@link Data} table. + */ + public static final class CommonDataKinds { + /** + * The {@link Data#RES_PACKAGE} value for common data that should be + * shown using a default style. + */ + public static final String PACKAGE_COMMON = "common"; + + /** + * Columns common across the specific types. + */ + private interface BaseCommonColumns { + /** + * The package name to use when creating {@link Resources} objects for + * this data row. This value is only designed for use when building user + * interfaces, and should not be used to infer the owner. + */ + public static final String RES_PACKAGE = "res_package"; + + /** + * The MIME type of the item represented by this row. + */ + public static final String MIMETYPE = "mimetype"; + + /** + * The {@link RawContacts#_ID} that this data belongs to. + */ + public static final String RAW_CONTACT_ID = "raw_contact_id"; + } + + /** + * The base types that all "Typed" data kinds support. + */ + public interface BaseTypes { + + /** + * A custom type. The custom label should be supplied by user. + */ + public static int TYPE_CUSTOM = 0; + } + + /** + * Columns common across the specific types. + */ + private interface CommonColumns extends BaseTypes{ + /** + * The type of data, for example Home or Work. + * <P>Type: INTEGER</P> + */ + public static final String TYPE = "data1"; + + /** + * The data for the contact method. + * <P>Type: TEXT</P> + */ + public static final String DATA = "data2"; + + /** + * The user defined label for the the contact method. + * <P>Type: TEXT</P> + */ + public static final String LABEL = "data3"; + } + + /** + * Parts of the name. + */ + public static final class StructuredName implements BaseCommonColumns { + private StructuredName() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/name"; + + /** + * The given name for the contact. + * <P>Type: TEXT</P> + */ + public static final String GIVEN_NAME = "data1"; + + /** + * The family name for the contact. + * <P>Type: TEXT</P> + */ + public static final String FAMILY_NAME = "data2"; + + /** + * The contact's honorific prefix, e.g. "Sir" + * <P>Type: TEXT</P> + */ + public static final String PREFIX = "data3"; + + /** + * The contact's middle name + * <P>Type: TEXT</P> + */ + public static final String MIDDLE_NAME = "data4"; + + /** + * The contact's honorific suffix, e.g. "Jr" + */ + public static final String SUFFIX = "data5"; + + /** + * The phonetic version of the given name for the contact. + * <P>Type: TEXT</P> + */ + public static final String PHONETIC_GIVEN_NAME = "data6"; + + /** + * The phonetic version of the additional name for the contact. + * <P>Type: TEXT</P> + */ + public static final String PHONETIC_MIDDLE_NAME = "data7"; + + /** + * The phonetic version of the family name for the contact. + * <P>Type: TEXT</P> + */ + public static final String PHONETIC_FAMILY_NAME = "data8"; + + /** + * The name that should be used to display the contact. + * <i>Unstructured component of the name should be consistent with + * its structured representation.</i> + * <p> + * Type: TEXT + */ + public static final String DISPLAY_NAME = "data9"; + } + + /** + * A nickname. + */ + public static final class Nickname implements CommonColumns, BaseCommonColumns { + private Nickname() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/nickname"; + + public static final int TYPE_DEFAULT = 1; + public static final int TYPE_OTHER_NAME = 2; + public static final int TYPE_MAINDEN_NAME = 3; + public static final int TYPE_SHORT_NAME = 4; + public static final int TYPE_INITIALS = 5; + + /** + * The name itself + */ + public static final String NAME = DATA; + } + + /** + * Common data definition for telephone numbers. + */ + public static final class Phone implements BaseCommonColumns, CommonColumns { + private Phone() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/phone"; + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of + * phones. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/phone"; + + /** + * The content:// style URI for all data records of the + * {@link Phone#CONTENT_ITEM_TYPE} MIME type, combined with the + * associated raw contact and aggregate contact data. + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(Data.CONTENT_URI, + "phones"); + + /** + * The content:// style URI for filtering data records of the + * {@link Phone#CONTENT_ITEM_TYPE} MIME type, combined with the + * associated raw contact and aggregate contact data. The filter argument should + * be passed as an additional path segment after this URI. + */ + public static final Uri CONTENT_FILTER_URI = Uri.withAppendedPath(CONTENT_URI, + "filter"); + + public static final int TYPE_HOME = 1; + public static final int TYPE_MOBILE = 2; + public static final int TYPE_WORK = 3; + public static final int TYPE_FAX_WORK = 4; + public static final int TYPE_FAX_HOME = 5; + public static final int TYPE_PAGER = 6; + public static final int TYPE_OTHER = 7; + public static final int TYPE_CALLBACK = 8; + public static final int TYPE_CAR = 9; + public static final int TYPE_COMPANY_MAIN = 10; + public static final int TYPE_ISDN = 11; + public static final int TYPE_MAIN = 12; + public static final int TYPE_OTHER_FAX = 13; + public static final int TYPE_RADIO = 14; + public static final int TYPE_TELEX = 15; + public static final int TYPE_TTY_TDD = 16; + public static final int TYPE_WORK_MOBILE = 17; + public static final int TYPE_WORK_PAGER = 18; + public static final int TYPE_ASSISTANT = 19; + + /** + * The phone number as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String NUMBER = DATA; + + public static final CharSequence getDisplayLabel(Context context, int type, + CharSequence label, CharSequence[] labelArray) { + CharSequence display = ""; + + if (type != Phone.TYPE_CUSTOM) { + CharSequence[] labels = labelArray != null? labelArray + : context.getResources().getTextArray( + com.android.internal.R.array.phoneTypes); + try { + display = labels[type - 1]; + } catch (ArrayIndexOutOfBoundsException e) { + display = labels[Phone.TYPE_CUSTOM]; + } + } else { + if (!TextUtils.isEmpty(label)) { + display = label; + } + } + return display; + } + + public static final CharSequence getDisplayLabel(Context context, int type, + CharSequence label) { + return getDisplayLabel(context, type, label, null); + } + } + + /** + * Common data definition for email addresses. + */ + public static final class Email implements BaseCommonColumns, CommonColumns { + private Email() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/email"; + + /** + * The content:// style URI for all data records of the + * {@link Email#CONTENT_ITEM_TYPE} MIME type, combined with the + * associated raw contact and aggregate contact data. + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(Data.CONTENT_URI, + "emails"); + + /** + * The content:// style URL for filtering data rows by email address. The + * filter argument should be passed as an additional path segment after + * this URI. + */ + public static final Uri CONTENT_FILTER_EMAIL_URI = Uri.withAppendedPath(CONTENT_URI, + "filter"); + + public static final int TYPE_HOME = 1; + public static final int TYPE_WORK = 2; + public static final int TYPE_OTHER = 3; + + /** + * The display name for the email address + * <P>Type: TEXT</P> + */ + public static final String DISPLAY_NAME = "data4"; + } + + /** + * Common data definition for postal addresses. + */ + public static final class StructuredPostal implements BaseCommonColumns, CommonColumns { + private StructuredPostal() { + } + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/postal-address"; + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of + * postal addresses. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/postal-address"; + + /** + * The content:// style URI for all data records of the + * {@link StructuredPostal#CONTENT_ITEM_TYPE} MIME type. + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(Data.CONTENT_URI, + "postals"); + + public static final int TYPE_HOME = 1; + public static final int TYPE_WORK = 2; + public static final int TYPE_OTHER = 3; + + /** + * The full, unstructured postal address. <i>This field must be + * consistent with any structured data.</i> + * <p> + * Type: TEXT + */ + public static final String FORMATTED_ADDRESS = DATA; + + /** + * The agent who actually receives the mail. Used in work addresses. + * Also for 'in care of' or 'c/o'. + * <p> + * Type: TEXT + * @deprecated since this isn't supported by gd:structuredPostalAddress + */ + @Deprecated + public static final String AGENT = "data4"; + + /** + * Used in places where houses or buildings have names (and not + * necessarily numbers), eg. "The Pillars". + * <p> + * Type: TEXT + * @deprecated since this isn't supported by gd:structuredPostalAddress + */ + @Deprecated + public static final String HOUSENAME = "data5"; + + /** + * Can be street, avenue, road, etc. This element also includes the + * house number and room/apartment/flat/floor number. + * <p> + * Type: TEXT + */ + public static final String STREET = "data6"; + + /** + * Covers actual P.O. boxes, drawers, locked bags, etc. This is + * usually but not always mutually exclusive with street. + * <p> + * Type: TEXT + */ + public static final String POBOX = "data7"; + + /** + * This is used to disambiguate a street address when a city + * contains more than one street with the same name, or to specify a + * small place whose mail is routed through a larger postal town. In + * China it could be a county or a minor city. + * <p> + * Type: TEXT + */ + public static final String NEIGHBORHOOD = "data8"; + + /** + * Can be city, village, town, borough, etc. This is the postal town + * and not necessarily the place of residence or place of business. + * <p> + * Type: TEXT + */ + public static final String CITY = "data9"; + + /** + * Handles administrative districts such as U.S. or U.K. counties + * that are not used for mail addressing purposes. Subregion is not + * intended for delivery addresses. + * <p> + * Type: TEXT + * @deprecated since this isn't supported by gd:structuredPostalAddress + */ + @Deprecated + public static final String SUBREGION = "data10"; + + /** + * A state, province, county (in Ireland), Land (in Germany), + * departement (in France), etc. + * <p> + * Type: TEXT + */ + public static final String REGION = "data11"; + + /** + * Postal code. Usually country-wide, but sometimes specific to the + * city (e.g. "2" in "Dublin 2, Ireland" addresses). + * <p> + * Type: TEXT + */ + public static final String POSTCODE = "data12"; + + /** + * The name or code of the country. + * <p> + * Type: TEXT + */ + public static final String COUNTRY = "data13"; + } + + /** + * Common data definition for IM addresses. + */ + public static final class Im implements BaseCommonColumns, CommonColumns { + private Im() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/im"; + + public static final int TYPE_HOME = 1; + public static final int TYPE_WORK = 2; + public static final int TYPE_OTHER = 3; + + /** + * This column should be populated with one of the defined + * constants, e.g. {@link #PROTOCOL_YAHOO}. If the value of this + * column is {@link #PROTOCOL_CUSTOM}, the {@link #CUSTOM_PROTOCOL} + * should contain the name of the custom protocol. + */ + public static final String PROTOCOL = "data5"; + + public static final String CUSTOM_PROTOCOL = "data6"; + + /* + * The predefined IM protocol types. + */ + public static final int PROTOCOL_CUSTOM = -1; + public static final int PROTOCOL_AIM = 0; + public static final int PROTOCOL_MSN = 1; + public static final int PROTOCOL_YAHOO = 2; + public static final int PROTOCOL_SKYPE = 3; + public static final int PROTOCOL_QQ = 4; + public static final int PROTOCOL_GOOGLE_TALK = 5; + public static final int PROTOCOL_ICQ = 6; + public static final int PROTOCOL_JABBER = 7; + public static final int PROTOCOL_NETMEETING = 8; + } + + /** + * Common data definition for organizations. + */ + public static final class Organization implements BaseCommonColumns, CommonColumns { + private Organization() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/organization"; + + public static final int TYPE_WORK = 1; + public static final int TYPE_OTHER = 2; + + /** + * The company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String COMPANY = DATA; + + /** + * The position title at this company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String TITLE = "data4"; + + /** + * The department at this company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String DEPARTMENT = "data5"; + + /** + * The job description at this company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String JOB_DESCRIPTION = "data6"; + + /** + * The symbol of this company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String SYMBOL = "data7"; + + /** + * The phonetic name of this company as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String PHONETIC_NAME = "data8"; + } + + /** + * Common data definition for miscellaneous information. + */ + public static final class Miscellaneous implements BaseCommonColumns { + private Miscellaneous() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/misc"; + + /** + * The birthday as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String BIRTHDAY = "data1"; + + /** + * The nickname as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String NICKNAME = "data2"; + } + + /** + * Common data definition for relations. + */ + public static final class Relation implements BaseCommonColumns, CommonColumns { + private Relation() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/relation"; + + public static final int TYPE_ASSISTANT = 1; + public static final int TYPE_BROTHER = 2; + public static final int TYPE_CHILD = 3; + public static final int TYPE_DOMESTIC_PARTNER = 4; + public static final int TYPE_FATHER = 5; + public static final int TYPE_FRIEND = 6; + public static final int TYPE_MANAGER = 7; + public static final int TYPE_MOTHER = 8; + public static final int TYPE_PARENT = 9; + public static final int TYPE_PARTNER = 10; + public static final int TYPE_REFERRED_BY = 11; + public static final int TYPE_RELATIVE = 12; + public static final int TYPE_SISTER = 13; + public static final int TYPE_SPOUSE = 14; + + /** + * The name of the relative as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String NAME = DATA; + } + + /** + * Common data definition for events. + */ + public static final class Event implements BaseCommonColumns, CommonColumns { + private Event() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/event"; + + public static final int TYPE_ANNIVERSARY = 1; + public static final int TYPE_OTHER = 2; + + /** + * The event start date as the user entered it. + * <P>Type: TEXT</P> + */ + public static final String START_DATE = DATA; + } + + /** + * Photo of the contact. + */ + public static final class Photo implements BaseCommonColumns { + private Photo() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/photo"; + + /** + * Thumbnail photo of the raw contact. This is the raw bytes of an image + * that could be inflated using {@link BitmapFactory}. + * <p> + * Type: BLOB + */ + public static final String PHOTO = "data1"; + } + + /** + * Notes about the contact. + */ + public static final class Note implements BaseCommonColumns { + private Note() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/note"; + + /** + * The note text. + * <P>Type: TEXT</P> + */ + public static final String NOTE = "data1"; + } + + /** + * Group Membership. + */ + public static final class GroupMembership implements BaseCommonColumns { + private GroupMembership() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = + "vnd.android.cursor.item/group_membership"; + + /** + * The row id of the group that this group membership refers to. Exactly one of + * this or {@link #GROUP_SOURCE_ID} must be set when inserting a row. + * <P>Type: INTEGER</P> + */ + public static final String GROUP_ROW_ID = "data1"; + + /** + * The sourceid of the group that this group membership refers to. Exactly one of + * this or {@link #GROUP_ROW_ID} must be set when inserting a row. + * <P>Type: TEXT</P> + */ + public static final String GROUP_SOURCE_ID = "group_sourceid"; + } + + /** + * Website related to the contact. + */ + public static final class Website implements BaseCommonColumns, CommonColumns { + private Website() {} + + /** MIME type used when storing this in data table. */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/website"; + + public static final int TYPE_HOMEPAGE = 1; + public static final int TYPE_BLOG = 2; + public static final int TYPE_PROFILE = 3; + public static final int TYPE_HOME = 4; + public static final int TYPE_WORK = 5; + public static final int TYPE_FTP = 6; + public static final int TYPE_OTHER = 7; + + /** + * The website URL string. + * <P>Type: TEXT</P> + */ + public static final String URL = "data1"; + } + } + + // TODO: make this private before unhiding + public interface GroupsColumns { + /** + * The display title of this group. + * <p> + * Type: TEXT + */ + public static final String TITLE = "title"; + + /** + * The package name to use when creating {@link Resources} objects for + * this group. This value is only designed for use when building user + * interfaces, and should not be used to infer the owner. + */ + public static final String RES_PACKAGE = "res_package"; + + /** + * The display title of this group to load as a resource from + * {@link #RES_PACKAGE}, which may be localized. + * <P>Type: TEXT</P> + */ + public static final String TITLE_RES = "title_res"; + + /** + * Notes about the group. + * <p> + * Type: TEXT + */ + public static final String NOTES = "notes"; + + /** + * The ID of this group if it is a System Group, i.e. a group that has a special meaning + * to the sync adapter, null otherwise. + * <P>Type: TEXT</P> + */ + public static final String SYSTEM_ID = "system_id"; + + /** + * The total number of {@link Contacts} that have + * {@link CommonDataKinds.GroupMembership} in this group. Read-only value that is only + * present when querying {@link Groups#CONTENT_SUMMARY_URI}. + * <p> + * Type: INTEGER + */ + public static final String SUMMARY_COUNT = "summ_count"; + + /** + * The total number of {@link Contacts} that have both + * {@link CommonDataKinds.GroupMembership} in this group, and also have phone numbers. + * Read-only value that is only present when querying + * {@link Groups#CONTENT_SUMMARY_URI}. + * <p> + * Type: INTEGER + */ + public static final String SUMMARY_WITH_PHONES = "summ_phones"; + + /** + * Flag indicating if the contacts belonging to this group should be + * visible in any user interface. + * <p> + * Type: INTEGER (boolean) + */ + public static final String GROUP_VISIBLE = "group_visible"; + + /** + * The "deleted" flag: "0" by default, "1" if the row has been marked + * for deletion. When {@link android.content.ContentResolver#delete} is + * called on a raw contact, it is marked for deletion and removed from its + * aggregate contact. The sync adaptor deletes the raw contact on the server and + * then calls ContactResolver.delete once more, this time passing the + * {@link RawContacts#DELETE_PERMANENTLY} query parameter to finalize the data removal. + * <P>Type: INTEGER</P> + */ + public static final String DELETED = "deleted"; + + /** + * Whether this group should be synced if the SYNC_EVERYTHING settings + * is false for this group's account. + * <p> + * Type: INTEGER (boolean) + */ + public static final String SHOULD_SYNC = "should_sync"; + } + + /** + * Constants for the groups table. + */ + public static final class Groups implements BaseColumns, GroupsColumns, SyncColumns { + /** + * This utility class cannot be instantiated + */ + private Groups() { + } + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "groups"); + + /** + * The content:// style URI for this table joined with details data from + * {@link Data}. + */ + public static final Uri CONTENT_SUMMARY_URI = Uri.withAppendedPath(AUTHORITY_URI, + "groups_summary"); + + /** + * The MIME type of a directory of groups. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/group"; + + /** + * The MIME type of a single group. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/group"; + + /** + * Query parameter that can be passed with the {@link #CONTENT_URI} URI + * to the {@link android.content.ContentResolver#delete} method to + * indicate that the raw contact can be deleted physically, rather than + * merely marked as deleted. + */ + public static final String DELETE_PERMANENTLY = "delete_permanently"; + + /** + * An optional update or insert URI parameter that determines if the + * group should be marked as dirty. The default value is true. + */ + public static final String MARK_AS_DIRTY = "mark_as_dirty"; + } + + /** + * Constants for the contact aggregation exceptions table, which contains + * aggregation rules overriding those used by automatic aggregation. This type only + * supports query and update. Neither insert nor delete are supported. + */ + public static final class AggregationExceptions implements BaseColumns { + /** + * This utility class cannot be instantiated + */ + private AggregationExceptions() {} + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = + Uri.withAppendedPath(AUTHORITY_URI, "aggregation_exceptions"); + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of data. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/aggregation_exception"; + + /** + * The MIME type of a {@link #CONTENT_URI} subdirectory of an aggregation exception + */ + public static final String CONTENT_ITEM_TYPE = + "vnd.android.cursor.item/aggregation_exception"; + + /** + * The type of exception: {@link #TYPE_KEEP_IN}, {@link #TYPE_KEEP_OUT} or + * {@link #TYPE_AUTOMATIC}. + * + * <P>Type: INTEGER</P> + */ + public static final String TYPE = "type"; + + /** + * Allows the provider to automatically decide whether the aggregate + * contact should include a particular raw contact or not. + */ + public static final int TYPE_AUTOMATIC = 0; + + /** + * Makes sure that the specified raw contact is included in the + * specified aggregate contact. + */ + public static final int TYPE_KEEP_IN = 1; + + /** + * Makes sure that the specified raw contact is NOT included in the + * specified aggregate contact. + */ + public static final int TYPE_KEEP_OUT = 2; + + /** + * A reference to the {@link android.provider.ContactsContract.Contacts#_ID} of the + * aggregate contact that the rule applies to. + */ + public static final String CONTACT_ID = "contact_id"; + + /** + * A reference to the {@link RawContacts#_ID} of the raw contact that the rule applies to. + */ + public static final String RAW_CONTACT_ID = "raw_contact_id"; + } + + private interface SettingsColumns { + /** + * The name of the account instance to which this row belongs. + * <P>Type: TEXT</P> + */ + public static final String ACCOUNT_NAME = "account_name"; + + /** + * The type of account to which this row belongs, which when paired with + * {@link #ACCOUNT_NAME} identifies a specific account. + * <P>Type: TEXT</P> + */ + public static final String ACCOUNT_TYPE = "account_type"; + + /** + * Setting to indicate how this source handles {@link #SHOULD_SYNC} and + * {@link Groups#SHOULD_SYNC} flags. This mode should be one of + * {@link Settings#SYNC_MODE_EVERYTHING}, + * {@link Settings#SYNC_MODE_UNGROUPED}, or + * {@link Settings#SYNC_MODE_UNSUPPORTED}. + * <p> + * Type: INTEGER + */ + public static final String SHOULD_SYNC_MODE = "should_sync_mode"; + + /** + * When modes is {@link Settings#SYNC_MODE_EVERYTHING}, this flag + * overrides any children {@link Groups#SHOULD_SYNC} when set. When mode + * is {@link Settings#SYNC_MODE_UNGROUPED}, this flag indicates the + * syncing behavior for contacts not belonging to any group. + * <p> + * Type: INTEGER (boolean) + */ + public static final String SHOULD_SYNC = "should_sync"; + + /** + * Flag indicating if contacts without any {@link CommonDataKinds.GroupMembership} + * entries should be visible in any user interface. + * <p> + * Type: INTEGER (boolean) + */ + public static final String UNGROUPED_VISIBLE = "ungrouped_visible"; + } + + /** + * Contacts-specific settings for various {@link Account}. + */ + public static final class Settings implements BaseColumns, SettingsColumns { + /** + * This utility class cannot be instantiated + */ + private Settings() { + } + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = + Uri.withAppendedPath(AUTHORITY_URI, "settings"); + + /** + * The MIME-type of {@link #CONTENT_URI} providing a directory of + * settings. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/setting"; + + /** + * The MIME-type of {@link #CONTENT_URI} providing a single setting. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/setting"; + + /** + * Mode for {@link #SHOULD_SYNC_MODE} that indicates this data source + * doesn't support per-group {@link Groups#SHOULD_SYNC} flags. + */ + public static final int SYNC_MODE_UNSUPPORTED = 0; + + /** + * Mode for {@link #SHOULD_SYNC_MODE} that indicates this data source + * fully supports per-group {@link Groups#SHOULD_SYNC} flags and assumes + * that {@link #SHOULD_SYNC} refers to contacts without any + * {@link CommonDataKinds.GroupMembership}. + */ + public static final int SYNC_MODE_UNGROUPED = 1; + + /** + * Mode for {@link #SHOULD_SYNC_MODE} that indicates this data source + * fully supports per-group {@link Groups#SHOULD_SYNC} flags but assumes + * that {@link #SHOULD_SYNC} overrides per-group flags when set. + */ + public static final int SYNC_MODE_EVERYTHING = 2; + } + + /** + * Contains helper classes used to create or manage {@link android.content.Intent Intents} + * that involve contacts. + */ + public static final class Intents { + /** + * This is the intent that is fired when a search suggestion is clicked on. + */ + public static final String SEARCH_SUGGESTION_CLICKED = + "android.provider.Contacts.SEARCH_SUGGESTION_CLICKED"; + + /** + * This is the intent that is fired when a search suggestion for dialing a number + * is clicked on. + */ + public static final String SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED = + "android.provider.Contacts.SEARCH_SUGGESTION_DIAL_NUMBER_CLICKED"; + + /** + * This is the intent that is fired when a search suggestion for creating a contact + * is clicked on. + */ + public static final String SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED = + "android.provider.Contacts.SEARCH_SUGGESTION_CREATE_CONTACT_CLICKED"; + + /** + * Starts an Activity that lets the user pick a contact to attach an image to. + * After picking the contact it launches the image cropper in face detection mode. + */ + public static final String ATTACH_IMAGE = + "com.android.contacts.action.ATTACH_IMAGE"; + + /** + * Takes as input a data URI with a mailto: or tel: scheme. If a single + * contact exists with the given data it will be shown. If no contact + * exists, a dialog will ask the user if they want to create a new + * contact with the provided details filled in. If multiple contacts + * share the data the user will be prompted to pick which contact they + * want to view. + * <p> + * For <code>mailto:</code> URIs, the scheme specific portion must be a + * raw email address, such as one built using + * {@link Uri#fromParts(String, String, String)}. + * <p> + * For <code>tel:</code> URIs, the scheme specific portion is compared + * to existing numbers using the standard caller ID lookup algorithm. + * The number must be properly encoded, for example using + * {@link Uri#fromParts(String, String, String)}. + * <p> + * Any extras from the {@link Insert} class will be passed along to the + * create activity if there are no contacts to show. + * <p> + * Passing true for the {@link #EXTRA_FORCE_CREATE} extra will skip + * prompting the user when the contact doesn't exist. + */ + public static final String SHOW_OR_CREATE_CONTACT = + "com.android.contacts.action.SHOW_OR_CREATE_CONTACT"; + + /** + * Used with {@link #SHOW_OR_CREATE_CONTACT} to force creating a new + * contact if no matching contact found. Otherwise, default behavior is + * to prompt user with dialog before creating. + * <p> + * Type: BOOLEAN + */ + public static final String EXTRA_FORCE_CREATE = + "com.android.contacts.action.FORCE_CREATE"; + + /** + * Used with {@link #SHOW_OR_CREATE_CONTACT} to specify an exact + * description to be shown when prompting user about creating a new + * contact. + * <p> + * Type: STRING + */ + public static final String EXTRA_CREATE_DESCRIPTION = + "com.android.contacts.action.CREATE_DESCRIPTION"; + + /** + * Optional extra used with {@link #SHOW_OR_CREATE_CONTACT} to specify a + * dialog location using screen coordinates. When not specified, the + * dialog will be centered. + */ + public static final String EXTRA_TARGET_RECT = "target_rect"; + + /** + * Optional extra used with {@link #SHOW_OR_CREATE_CONTACT} to specify a + * desired dialog style, usually a variation on size. One of + * {@link #MODE_SMALL}, {@link #MODE_MEDIUM}, or {@link #MODE_LARGE}. + */ + public static final String EXTRA_MODE = "mode"; + + /** + * Value for {@link #EXTRA_MODE} to show a small-sized dialog. + */ + public static final int MODE_SMALL = 1; + + /** + * Value for {@link #EXTRA_MODE} to show a medium-sized dialog. + */ + public static final int MODE_MEDIUM = 2; + + /** + * Value for {@link #EXTRA_MODE} to show a large-sized dialog. + */ + public static final int MODE_LARGE = 3; + + /** + * Intents related to the Contacts app UI. + */ + public static final class UI { + /** + * The action for the default contacts list tab. + */ + public static final String LIST_DEFAULT = + "com.android.contacts.action.LIST_DEFAULT"; + + /** + * The action for the contacts list tab. + */ + public static final String LIST_GROUP_ACTION = + "com.android.contacts.action.LIST_GROUP"; + + /** + * When in LIST_GROUP_ACTION mode, this is the group to display. + */ + public static final String GROUP_NAME_EXTRA_KEY = "com.android.contacts.extra.GROUP"; + + /** + * The action for the all contacts list tab. + */ + public static final String LIST_ALL_CONTACTS_ACTION = + "com.android.contacts.action.LIST_ALL_CONTACTS"; + + /** + * The action for the contacts with phone numbers list tab. + */ + public static final String LIST_CONTACTS_WITH_PHONES_ACTION = + "com.android.contacts.action.LIST_CONTACTS_WITH_PHONES"; + + /** + * The action for the starred contacts list tab. + */ + public static final String LIST_STARRED_ACTION = + "com.android.contacts.action.LIST_STARRED"; + + /** + * The action for the frequent contacts list tab. + */ + public static final String LIST_FREQUENT_ACTION = + "com.android.contacts.action.LIST_FREQUENT"; + + /** + * The action for the "strequent" contacts list tab. It first lists the starred + * contacts in alphabetical order and then the frequent contacts in descending + * order of the number of times they have been contacted. + */ + public static final String LIST_STREQUENT_ACTION = + "com.android.contacts.action.LIST_STREQUENT"; + + /** + * A key for to be used as an intent extra to set the activity + * title to a custom String value. + */ + public static final String TITLE_EXTRA_KEY = + "com.android.contacts.extra.TITLE_EXTRA"; + + /** + * Activity Action: Display a filtered list of contacts + * <p> + * Input: Extra field {@link #FILTER_TEXT_EXTRA_KEY} is the text to use for + * filtering + * <p> + * Output: Nothing. + */ + public static final String FILTER_CONTACTS_ACTION = + "com.android.contacts.action.FILTER_CONTACTS"; + + /** + * Used as an int extra field in {@link #FILTER_CONTACTS_ACTION} + * intents to supply the text on which to filter. + */ + public static final String FILTER_TEXT_EXTRA_KEY = + "com.android.contacts.extra.FILTER_TEXT"; + } + + /** + * Convenience class that contains string constants used + * to create contact {@link android.content.Intent Intents}. + */ + public static final class Insert { + /** The action code to use when adding a contact */ + public static final String ACTION = Intent.ACTION_INSERT; + + /** + * If present, forces a bypass of quick insert mode. + */ + public static final String FULL_MODE = "full_mode"; + + /** + * The extra field for the contact name. + * <P>Type: String</P> + */ + public static final String NAME = "name"; + + // TODO add structured name values here. + + /** + * The extra field for the contact phonetic name. + * <P>Type: String</P> + */ + public static final String PHONETIC_NAME = "phonetic_name"; + + /** + * The extra field for the contact company. + * <P>Type: String</P> + */ + public static final String COMPANY = "company"; + + /** + * The extra field for the contact job title. + * <P>Type: String</P> + */ + public static final String JOB_TITLE = "job_title"; + + /** + * The extra field for the contact notes. + * <P>Type: String</P> + */ + public static final String NOTES = "notes"; + + /** + * The extra field for the contact phone number. + * <P>Type: String</P> + */ + public static final String PHONE = "phone"; + + /** + * The extra field for the contact phone number type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.PhonesColumns PhonesColumns}, + * or a string specifying a custom label.</P> + */ + public static final String PHONE_TYPE = "phone_type"; + + /** + * The extra field for the phone isprimary flag. + * <P>Type: boolean</P> + */ + public static final String PHONE_ISPRIMARY = "phone_isprimary"; + + /** + * The extra field for an optional second contact phone number. + * <P>Type: String</P> + */ + public static final String SECONDARY_PHONE = "secondary_phone"; + + /** + * The extra field for an optional second contact phone number type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.PhonesColumns PhonesColumns}, + * or a string specifying a custom label.</P> + */ + public static final String SECONDARY_PHONE_TYPE = "secondary_phone_type"; + + /** + * The extra field for an optional third contact phone number. + * <P>Type: String</P> + */ + public static final String TERTIARY_PHONE = "tertiary_phone"; + + /** + * The extra field for an optional third contact phone number type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.PhonesColumns PhonesColumns}, + * or a string specifying a custom label.</P> + */ + public static final String TERTIARY_PHONE_TYPE = "tertiary_phone_type"; + + /** + * The extra field for the contact email address. + * <P>Type: String</P> + */ + public static final String EMAIL = "email"; + + /** + * The extra field for the contact email type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} + * or a string specifying a custom label.</P> + */ + public static final String EMAIL_TYPE = "email_type"; + + /** + * The extra field for the email isprimary flag. + * <P>Type: boolean</P> + */ + public static final String EMAIL_ISPRIMARY = "email_isprimary"; + + /** + * The extra field for an optional second contact email address. + * <P>Type: String</P> + */ + public static final String SECONDARY_EMAIL = "secondary_email"; + + /** + * The extra field for an optional second contact email type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} + * or a string specifying a custom label.</P> + */ + public static final String SECONDARY_EMAIL_TYPE = "secondary_email_type"; + + /** + * The extra field for an optional third contact email address. + * <P>Type: String</P> + */ + public static final String TERTIARY_EMAIL = "tertiary_email"; + + /** + * The extra field for an optional third contact email type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} + * or a string specifying a custom label.</P> + */ + public static final String TERTIARY_EMAIL_TYPE = "tertiary_email_type"; + + /** + * The extra field for the contact postal address. + * <P>Type: String</P> + */ + public static final String POSTAL = "postal"; + + /** + * The extra field for the contact postal address type. + * <P>Type: Either an integer value from + * {@link android.provider.Contacts.ContactMethodsColumns ContactMethodsColumns} + * or a string specifying a custom label.</P> + */ + public static final String POSTAL_TYPE = "postal_type"; + + /** + * The extra field for the postal isprimary flag. + * <P>Type: boolean</P> + */ + public static final String POSTAL_ISPRIMARY = "postal_isprimary"; + + /** + * The extra field for an IM handle. + * <P>Type: String</P> + */ + public static final String IM_HANDLE = "im_handle"; + + /** + * The extra field for the IM protocol + * <P>Type: the result of {@link CommonDataKinds.Im#encodePredefinedImProtocol(int)} + * or {@link CommonDataKinds.Im#encodeCustomImProtocol(String)}.</P> + */ + public static final String IM_PROTOCOL = "im_protocol"; + + /** + * The extra field for the IM isprimary flag. + * <P>Type: boolean</P> + */ + public static final String IM_ISPRIMARY = "im_isprimary"; + } + } + +} diff --git a/core/java/android/provider/Downloads.java b/core/java/android/provider/Downloads.java index 4c58e0d..790fe5c 100644 --- a/core/java/android/provider/Downloads.java +++ b/core/java/android/provider/Downloads.java @@ -63,7 +63,7 @@ public final class Downloads implements BaseColumns { * that had initiated a download when that download completes. The * download's content: uri is specified in the intent's data. */ - public static final String DOWNLOAD_COMPLETED_ACTION = + public static final String ACTION_DOWNLOAD_COMPLETED = "android.intent.action.DOWNLOAD_COMPLETED"; /** @@ -76,7 +76,7 @@ public final class Downloads implements BaseColumns { * Note: this is not currently sent for downloads that have completed * successfully. */ - public static final String NOTIFICATION_CLICKED_ACTION = + public static final String ACTION_NOTIFICATION_CLICKED = "android.intent.action.DOWNLOAD_NOTIFICATION_CLICKED"; /** @@ -84,14 +84,14 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read</P> */ - public static final String URI = "uri"; + public static final String COLUMN_URI = "uri"; /** * The name of the column containing application-specific data. * <P>Type: TEXT</P> * <P>Owner can Init/Read/Write</P> */ - public static final String APP_DATA = "entity"; + public static final String COLUMN_APP_DATA = "entity"; /** * The name of the column containing the flags that indicates whether @@ -104,7 +104,7 @@ public final class Downloads implements BaseColumns { * <P>Type: BOOLEAN</P> * <P>Owner can Init</P> */ - public static final String NO_INTEGRITY = "no_integrity"; + public static final String COLUMN_NO_INTEGRITY = "no_integrity"; /** * The name of the column containing the filename that the initiating @@ -113,7 +113,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init</P> */ - public static final String FILENAME_HINT = "hint"; + public static final String COLUMN_FILE_NAME_HINT = "hint"; /** * The name of the column containing the filename where the downloaded data @@ -128,7 +128,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read</P> */ - public static final String MIMETYPE = "mimetype"; + public static final String COLUMN_MIME_TYPE = "mimetype"; /** * The name of the column containing the flag that controls the destination @@ -136,7 +136,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Init</P> */ - public static final String DESTINATION = "destination"; + public static final String COLUMN_DESTINATION = "destination"; /** * The name of the column containing the flags that controls whether the @@ -145,7 +145,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Init/Read/Write</P> */ - public static final String VISIBILITY = "visibility"; + public static final String COLUMN_VISIBILITY = "visibility"; /** * The name of the column containing the current control state of the download. @@ -154,7 +154,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Read</P> */ - public static final String CONTROL = "control"; + public static final String COLUMN_CONTROL = "control"; /** * The name of the column containing the current status of the download. @@ -163,7 +163,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Read</P> */ - public static final String STATUS = "status"; + public static final String COLUMN_STATUS = "status"; /** * The name of the column containing the date at which some interesting @@ -172,7 +172,7 @@ public final class Downloads implements BaseColumns { * <P>Type: BIGINT</P> * <P>Owner can Read</P> */ - public static final String LAST_MODIFICATION = "lastmod"; + public static final String COLUMN_LAST_MODIFICATION = "lastmod"; /** * The name of the column containing the package name of the application @@ -181,7 +181,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read</P> */ - public static final String NOTIFICATION_PACKAGE = "notificationpackage"; + public static final String COLUMN_NOTIFICATION_PACKAGE = "notificationpackage"; /** * The name of the column containing the component name of the class that @@ -191,7 +191,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read</P> */ - public static final String NOTIFICATION_CLASS = "notificationclass"; + public static final String COLUMN_NOTIFICATION_CLASS = "notificationclass"; /** * If extras are specified when requesting a download they will be provided in the intent that @@ -199,7 +199,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init</P> */ - public static final String NOTIFICATION_EXTRAS = "notificationextras"; + public static final String COLUMN_NOTIFICATION_EXTRAS = "notificationextras"; /** * The name of the column contain the values of the cookie to be used for @@ -208,7 +208,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init</P> */ - public static final String COOKIE_DATA = "cookiedata"; + public static final String COLUMN_COOKIE_DATA = "cookiedata"; /** * The name of the column containing the user agent that the initiating @@ -216,7 +216,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init</P> */ - public static final String USER_AGENT = "useragent"; + public static final String COLUMN_USER_AGENT = "useragent"; /** * The name of the column containing the referer (sic) that the initiating @@ -224,7 +224,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init</P> */ - public static final String REFERER = "referer"; + public static final String COLUMN_REFERER = "referer"; /** * The name of the column containing the total size of the file being @@ -232,7 +232,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Read</P> */ - public static final String TOTAL_BYTES = "total_bytes"; + public static final String COLUMN_TOTAL_BYTES = "total_bytes"; /** * The name of the column containing the size of the part of the file that @@ -240,7 +240,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Read</P> */ - public static final String CURRENT_BYTES = "current_bytes"; + public static final String COLUMN_CURRENT_BYTES = "current_bytes"; /** * The name of the column where the initiating application can provide the @@ -252,7 +252,7 @@ public final class Downloads implements BaseColumns { * <P>Type: INTEGER</P> * <P>Owner can Init</P> */ - public static final String OTHER_UID = "otheruid"; + public static final String COLUMN_OTHER_UID = "otheruid"; /** * The name of the column where the initiating application can provided the @@ -261,7 +261,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read/Write</P> */ - public static final String TITLE = "title"; + public static final String COLUMN_TITLE = "title"; /** * The name of the column where the initiating application can provide the @@ -270,7 +270,7 @@ public final class Downloads implements BaseColumns { * <P>Type: TEXT</P> * <P>Owner can Init/Read/Write</P> */ - public static final String DESCRIPTION = "description"; + public static final String COLUMN_DESCRIPTION = "description"; /* * Lists the destinations that an application can specify for a download. diff --git a/core/java/android/provider/DrmStore.java b/core/java/android/provider/DrmStore.java index db71854..c438ac4 100644 --- a/core/java/android/provider/DrmStore.java +++ b/core/java/android/provider/DrmStore.java @@ -35,7 +35,7 @@ import java.io.OutputStream; /** * The DRM provider contains forward locked DRM content. - * + * * @hide */ public final class DrmStore @@ -43,13 +43,13 @@ public final class DrmStore private static final String TAG = "DrmStore"; public static final String AUTHORITY = "drm"; - + /** * This is in the Manifest class of the drm provider, but that isn't visible * in the framework. */ private static final String ACCESS_DRM_PERMISSION = "android.permission.ACCESS_DRM"; - + /** * Fields for DRM database */ @@ -82,18 +82,18 @@ public final class DrmStore } public interface Images extends Columns { - + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/images"); } - + public interface Audio extends Columns { - + public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/audio"); } /** * Utility function for inserting a file into the DRM content provider. - * + * * @param cr The content resolver to use * @param file The file to insert * @param title The title for the content (or null) @@ -101,12 +101,46 @@ public final class DrmStore */ public static final Intent addDrmFile(ContentResolver cr, File file, String title) { FileInputStream fis = null; - OutputStream os = null; Intent result = null; try { fis = new FileInputStream(file); - DrmRawContent content = new DrmRawContent(fis, (int) file.length(), + if (title == null) { + title = file.getName(); + int lastDot = title.lastIndexOf('.'); + if (lastDot > 0) { + title = title.substring(0, lastDot); + } + } + result = addDrmFile(cr, fis, title); + } catch (Exception e) { + Log.e(TAG, "pushing file failed", e); + } finally { + try { + if (fis != null) + fis.close(); + } catch (IOException e) { + Log.e(TAG, "IOException in DrmStore.addDrmFile()", e); + } + } + + return result; + } + + /** + * Utility function for inserting a file stream into the DRM content provider. + * + * @param cr The content resolver to use + * @param fileStream The FileInputStream to insert + * @param title The title for the content (or null) + * @return uri to the DRM record or null + */ + public static final Intent addDrmFile(ContentResolver cr, FileInputStream fis, String title) { + OutputStream os = null; + Intent result = null; + + try { + DrmRawContent content = new DrmRawContent(fis, (int) fis.available(), DrmRawContent.DRM_MIMETYPE_MESSAGE_STRING); String mimeType = content.getContentType(); @@ -126,14 +160,6 @@ public final class DrmStore if (contentUri != null) { ContentValues values = new ContentValues(3); - // compute title from file name, if it is not specified - if (title == null) { - title = file.getName(); - int lastDot = title.lastIndexOf('.'); - if (lastDot > 0) { - title = title.substring(0, lastDot); - } - } values.put(DrmStore.Columns.TITLE, title); values.put(DrmStore.Columns.SIZE, size); values.put(DrmStore.Columns.MIME_TYPE, mimeType); @@ -162,7 +188,7 @@ public final class DrmStore if (os != null) os.close(); } catch (IOException e) { - Log.e(TAG, "IOException in DrmTest.onCreate()", e); + Log.e(TAG, "IOException in DrmStore.addDrmFile()", e); } } @@ -172,7 +198,7 @@ public final class DrmStore /** * Utility function to enforce any permissions required to access DRM * content. - * + * * @param context A context used for checking calling permission. */ public static void enforceAccessDrmPermission(Context context) { @@ -181,5 +207,5 @@ public final class DrmStore throw new SecurityException("Requires DRM permission"); } } - + } diff --git a/core/java/android/provider/Gmail.java b/core/java/android/provider/Gmail.java index c4b29ae..5702e7c 100644 --- a/core/java/android/provider/Gmail.java +++ b/core/java/android/provider/Gmail.java @@ -83,7 +83,7 @@ public final class Gmail { public static final String LABEL_OUTBOX = "^^out"; public static final String AUTHORITY = "gmail-ls"; - private static final String TAG = "gmail-ls"; + private static final String TAG = "Gmail"; private static final String AUTHORITY_PLUS_CONVERSATIONS = "content://" + AUTHORITY + "/conversations/"; private static final String AUTHORITY_PLUS_LABELS = diff --git a/core/java/android/provider/Im.java b/core/java/android/provider/Im.java index 19ad158..d7e8f70 100644 --- a/core/java/android/provider/Im.java +++ b/core/java/android/provider/Im.java @@ -871,14 +871,22 @@ public class Im { } /** - * The common columns for both one-to-one chat messages or group chat messages. + * The common columns for messages table */ - public interface BaseMessageColumns { + public interface MessageColumns { /** - * The user this message belongs to - * <P>Type: TEXT</P> + * The thread_id column stores the contact id of the contact the message belongs to. + * For groupchat messages, the thread_id stores the group id, which is the contact id + * of the temporary group contact created for the groupchat. So there should be no + * collision between groupchat message thread id and regular message thread id. */ - String CONTACT = "contact"; + String THREAD_ID = "thread_id"; + + /** + * The nickname. This is used for groupchat messages to indicate the participant's + * nickname. For non groupchat messages, this field should be left empty. + */ + String NICKNAME = "nickname"; /** * The body @@ -917,68 +925,199 @@ public class Im { * <P>Type: STRING</P> */ String PACKET_ID = "packet_id"; - } - /** - * Columns from the Messages table. - */ - public interface MessagesColumns extends BaseMessageColumns{ /** - * The provider id - * <P> Type: INTEGER </P> + * Is groupchat message or not + * <P>Type: INTEGER</P> */ - String PROVIDER = "provider"; + String IS_GROUP_CHAT = "is_muc"; /** - * The account id - * <P> Type: INTEGER </P> + * A hint that the UI should show the sent time of this message + * <P>Type: INTEGER</P> */ - String ACCOUNT = "account"; + String DISPLAY_SENT_TIME = "show_ts"; } /** * This table contains messages. */ - public static final class Messages implements BaseColumns, MessagesColumns { + public static final class Messages implements BaseColumns, MessageColumns { /** * no public constructor since this is a utility class */ private Messages() {} /** - * Gets the Uri to query messages by contact. + * Gets the Uri to query messages by thread id. + * + * @param threadId the thread id of the message. + * @return the Uri + */ + public static final Uri getContentUriByThreadId(long threadId) { + Uri.Builder builder = CONTENT_URI_MESSAGES_BY_THREAD_ID.buildUpon(); + ContentUris.appendId(builder, threadId); + return builder.build(); + } + + /** + * @deprecated + * + * Gets the Uri to query messages by account and contact. * - * @param providerId the provider id of the contact. * @param accountId the account id of the contact. * @param username the user name of the contact. * @return the Uri */ - public static final Uri getContentUriByContact(long providerId, - long accountId, String username) { - Uri.Builder builder = CONTENT_URI_MESSAGES_BY.buildUpon(); + public static final Uri getContentUriByContact(long accountId, String username) { + Uri.Builder builder = CONTENT_URI_MESSAGES_BY_ACCOUNT_AND_CONTACT.buildUpon(); + ContentUris.appendId(builder, accountId); + builder.appendPath(username); + return builder.build(); + } + + /** + * Gets the Uri to query messages by provider. + * + * @param providerId the service provider id. + * @return the Uri + */ + public static final Uri getContentUriByProvider(long providerId) { + Uri.Builder builder = CONTENT_URI_MESSAGES_BY_PROVIDER.buildUpon(); ContentUris.appendId(builder, providerId); + return builder.build(); + } + + /** + * Gets the Uri to query off the record messages by account. + * + * @param accountId the account id. + * @return the Uri + */ + public static final Uri getContentUriByAccount(long accountId) { + Uri.Builder builder = CONTENT_URI_BY_ACCOUNT.buildUpon(); + ContentUris.appendId(builder, accountId); + return builder.build(); + } + + /** + * Gets the Uri to query off the record messages by thread id. + * + * @param threadId the thread id of the message. + * @return the Uri + */ + public static final Uri getOtrMessagesContentUriByThreadId(long threadId) { + Uri.Builder builder = OTR_MESSAGES_CONTENT_URI_BY_THREAD_ID.buildUpon(); + ContentUris.appendId(builder, threadId); + return builder.build(); + } + + /** + * @deprecated + * + * Gets the Uri to query off the record messages by account and contact. + * + * @param accountId the account id of the contact. + * @param username the user name of the contact. + * @return the Uri + */ + public static final Uri getOtrMessagesContentUriByContact(long accountId, String username) { + Uri.Builder builder = OTR_MESSAGES_CONTENT_URI_BY_ACCOUNT_AND_CONTACT.buildUpon(); ContentUris.appendId(builder, accountId); builder.appendPath(username); return builder.build(); } /** + * Gets the Uri to query off the record messages by provider. + * + * @param providerId the service provider id. + * @return the Uri + */ + public static final Uri getOtrMessagesContentUriByProvider(long providerId) { + Uri.Builder builder = OTR_MESSAGES_CONTENT_URI_BY_PROVIDER.buildUpon(); + ContentUris.appendId(builder, providerId); + return builder.build(); + } + + /** + * Gets the Uri to query off the record messages by account. + * + * @param accountId the account id. + * @return the Uri + */ + public static final Uri getOtrMessagesContentUriByAccount(long accountId) { + Uri.Builder builder = OTR_MESSAGES_CONTENT_URI_BY_ACCOUNT.buildUpon(); + ContentUris.appendId(builder, accountId); + return builder.build(); + } + + /** * The content:// style URL for this table */ public static final Uri CONTENT_URI = - Uri.parse("content://im/messages"); + Uri.parse("content://im/messages"); + + /** + * The content:// style URL for messages by thread id + */ + public static final Uri CONTENT_URI_MESSAGES_BY_THREAD_ID = + Uri.parse("content://im/messagesByThreadId"); + + /** + * The content:// style URL for messages by account and contact + */ + public static final Uri CONTENT_URI_MESSAGES_BY_ACCOUNT_AND_CONTACT = + Uri.parse("content://im/messagesByAcctAndContact"); + + /** + * The content:// style URL for messages by provider + */ + public static final Uri CONTENT_URI_MESSAGES_BY_PROVIDER = + Uri.parse("content://im/messagesByProvider"); + + /** + * The content:// style URL for messages by account + */ + public static final Uri CONTENT_URI_BY_ACCOUNT = + Uri.parse("content://im/messagesByAccount"); + + /** + * The content:// style url for off the record messages + */ + public static final Uri OTR_MESSAGES_CONTENT_URI = + Uri.parse("content://im/otrMessages"); + + /** + * The content:// style url for off the record messages by thread id + */ + public static final Uri OTR_MESSAGES_CONTENT_URI_BY_THREAD_ID = + Uri.parse("content://im/otrMessagesByThreadId"); + + /** + * The content:// style url for off the record messages by account and contact + */ + public static final Uri OTR_MESSAGES_CONTENT_URI_BY_ACCOUNT_AND_CONTACT = + Uri.parse("content://im/otrMessagesByAcctAndContact"); /** - * The content:// style URL for messages by provider and account + * The content:// style URL for off the record messages by provider */ - public static final Uri CONTENT_URI_MESSAGES_BY = - Uri.parse("content://im/messagesBy"); + public static final Uri OTR_MESSAGES_CONTENT_URI_BY_PROVIDER = + Uri.parse("content://im/otrMessagesByProvider"); + + /** + * The content:// style URL for off the record messages by account + */ + public static final Uri OTR_MESSAGES_CONTENT_URI_BY_ACCOUNT = + Uri.parse("content://im/otrMessagesByAccount"); /** * The MIME type of {@link #CONTENT_URI} providing a directory of * people. */ - public static final String CONTENT_TYPE = "vnd.android.cursor.dir/im-messages"; + public static final String CONTENT_TYPE = + "vnd.android.cursor.dir/im-messages"; /** * The MIME type of a {@link #CONTENT_URI} subdirectory of a single @@ -992,6 +1131,11 @@ public class Im { */ public static final String DEFAULT_SORT_ORDER = "date ASC"; + /** + * The "contact" column. This is not a real column in the messages table, but a + * temoprary column created when querying for messages (joined with the contacts table) + */ + public static final String CONTACT = "contact"; } /** @@ -1119,67 +1263,6 @@ public class Im { } /** - * Columns from the GroupMessages table - */ - public interface GroupMessageColumns extends BaseMessageColumns { - /** - * The group this message belongs to - * <p>Type: TEXT</p> - */ - String GROUP = "groupId"; - } - - /** - * This table contains group messages. - */ - public final static class GroupMessages implements BaseColumns, - GroupMessageColumns { - private GroupMessages() {} - - /** - * Gets the Uri to query group messages by group. - * - * @param groupId the group id. - * @return the Uri - */ - public static final Uri getContentUriByGroup(long groupId) { - Uri.Builder builder = CONTENT_URI_GROUP_MESSAGES_BY.buildUpon(); - ContentUris.appendId(builder, groupId); - return builder.build(); - } - - /** - * The content:// style URL for this table - */ - public static final Uri CONTENT_URI = - Uri.parse("content://im/groupMessages"); - - /** - * The content:// style URL for group messages by provider and account - */ - public static final Uri CONTENT_URI_GROUP_MESSAGES_BY = - Uri.parse("content://im/groupMessagesBy"); - - /** - * The MIME type of {@link #CONTENT_URI} providing a directory of - * group messages. - */ - public static final String CONTENT_TYPE = "vnd.android.cursor.dir/im-groupMessages"; - - /** - * The MIME type of a {@link #CONTENT_URI} subdirectory of a single - * group message. - */ - public static final String CONTENT_ITEM_TYPE = - "vnd.android.cursor.item/im-groupMessages"; - - /** - * The default sort order for this table - */ - public static final String DEFAULT_SORT_ORDER = "date ASC"; - } - - /** * Columns from the Avatars table */ public interface AvatarsColumns { @@ -1534,6 +1617,18 @@ public class Im { /** specifies whether or not to show mobile indicator to friends */ public static final String SETTING_SHOW_MOBILE_INDICATOR = "mobile_indicator"; + /** specifies whether or not to show as away when device is idle */ + public static final String SETTING_SHOW_AWAY_ON_IDLE = "show_away_on_idle"; + + /** specifies whether or not to upload heartbeat stat upon login */ + public static final String SETTING_UPLOAD_HEARTBEAT_STAT = "upload_heartbeat_stat"; + + /** specifies the last heartbeat interval received from the server */ + public static final String SETTING_HEARTBEAT_INTERVAL = "heartbeat_interval"; + + /** specifiy the JID resource used for Google Talk connection */ + public static final String SETTING_JID_RESOURCE = "jid_resource"; + /** * Used for reliable message queue (RMQ). This is for storing the last rmq id received * from the GTalk server @@ -1742,6 +1837,47 @@ public class Im { showMobileIndicator); } + /** + * A convenience method to set whether or not to show as away when device is idle. + * + * @param contentResolver The ContentResolver to use to access the setting table. + * @param showAway Whether or not to show as away when device is idle. + */ + public static void setShowAwayOnIdle(ContentResolver contentResolver, + long providerId, boolean showAway) { + putBooleanValue(contentResolver, providerId, SETTING_SHOW_AWAY_ON_IDLE, showAway); + } + + /** + * A convenience method to set whether or not to upload heartbeat stat. + * + * @param contentResolver The ContentResolver to use to access the setting table. + * @param uploadStat Whether or not to upload heartbeat stat. + */ + public static void setUploadHeartbeatStat(ContentResolver contentResolver, + long providerId, boolean uploadStat) { + putBooleanValue(contentResolver, providerId, SETTING_UPLOAD_HEARTBEAT_STAT, uploadStat); + } + + /** + * A convenience method to set the heartbeat interval last received from the server. + * + * @param contentResolver The ContentResolver to use to access the setting table. + * @param interval The heartbeat interval last received from the server. + */ + public static void setHeartbeatInterval(ContentResolver contentResolver, + long providerId, long interval) { + putLongValue(contentResolver, providerId, SETTING_HEARTBEAT_INTERVAL, interval); + } + + /** + * A convenience method to set the jid resource. + */ + public static void setJidResource(ContentResolver contentResolver, + long providerId, String jidResource) { + putStringValue(contentResolver, providerId, SETTING_JID_RESOURCE, jidResource); + } + public static class QueryMap extends ContentQueryMap { private ContentResolver mContentResolver; private long mProviderId; @@ -1872,6 +2008,79 @@ public class Im { } /** + * Set whether or not to show as away when device is idle. + * + * @param showAway whether or not to show as away when device is idle. + */ + public void setShowAwayOnIdle(boolean showAway) { + ProviderSettings.setShowAwayOnIdle(mContentResolver, mProviderId, showAway); + } + + /** + * Get whether or not to show as away when device is idle. + * + * @return Whether or not to show as away when device is idle. + */ + public boolean getShowAwayOnIdle() { + return getBoolean(SETTING_SHOW_AWAY_ON_IDLE, + true /* by default show as away on idle*/); + } + + /** + * Set whether or not to upload heartbeat stat. + * + * @param uploadStat whether or not to upload heartbeat stat. + */ + public void setUploadHeartbeatStat(boolean uploadStat) { + ProviderSettings.setUploadHeartbeatStat(mContentResolver, mProviderId, uploadStat); + } + + /** + * Get whether or not to upload heartbeat stat. + * + * @return Whether or not to upload heartbeat stat. + */ + public boolean getUploadHeartbeatStat() { + return getBoolean(SETTING_UPLOAD_HEARTBEAT_STAT, + false /* by default do not upload */); + } + + /** + * Set the last received heartbeat interval from the server. + * + * @param interval the last received heartbeat interval from the server. + */ + public void setHeartbeatInterval(long interval) { + ProviderSettings.setHeartbeatInterval(mContentResolver, mProviderId, interval); + } + + /** + * Get the last received heartbeat interval from the server. + * + * @return the last received heartbeat interval from the server. + */ + public long getHeartbeatInterval() { + return getLong(SETTING_HEARTBEAT_INTERVAL, 0L /* an invalid default interval */); + } + + /** + * Set the JID resource. + * + * @param jidResource the jid resource to be stored. + */ + public void setJidResource(String jidResource) { + ProviderSettings.setJidResource(mContentResolver, mProviderId, jidResource); + } + /** + * Get the JID resource used for the Google Talk connection + * + * @return the JID resource stored. + */ + public String getJidResource() { + return getString(SETTING_JID_RESOURCE, null); + } + + /** * Convenience function for retrieving a single settings value * as a boolean. * @@ -1909,21 +2118,77 @@ public class Im { ContentValues values = getValues(name); return values != null ? values.getAsInteger(VALUE) : def; } + + /** + * Convenience function for retrieving a single settings value + * as a Long. + * + * @param name The name of the setting to retrieve. + * @param def The value to return if the setting is not defined. + * @return The setting's current value or 'def' if it is not defined. + */ + private long getLong(String name, long def) { + ContentValues values = getValues(name); + return values != null ? values.getAsLong(VALUE) : def; + } } } + + /** + * Columns for IM branding resource map cache table. This table caches the result of + * loading the branding resources to speed up IM landing page start. + */ + public interface BrandingResourceMapCacheColumns { + /** + * The provider ID + * <P>Type: INTEGER</P> + */ + String PROVIDER_ID = "provider_id"; + /** + * The application resource ID + * <P>Type: INTEGER</P> + */ + String APP_RES_ID = "app_res_id"; + /** + * The plugin resource ID + * <P>Type: INTEGER</P> + */ + String PLUGIN_RES_ID = "plugin_res_id"; + } + + /** + * The table for caching the result of loading IM branding resources. + */ + public static final class BrandingResourceMapCache + implements BaseColumns, BrandingResourceMapCacheColumns { + /** + * The content:// style URL for this table. + */ + public static final Uri CONTENT_URI = Uri.parse("content://im/brandingResMapCache"); + } + + + + /** + * //TODO: move these to MCS specific provider. + * The following are MCS stuff, and should really live in a separate provider specific to + * MCS code. + */ + /** * Columns from OutgoingRmq table */ public interface OutgoingRmqColumns { String RMQ_ID = "rmq_id"; - String TYPE = "type"; String TIMESTAMP = "ts"; String DATA = "data"; + String PROTOBUF_TAG = "type"; } /** + * //TODO: we should really move these to their own provider and database. * The table for storing outgoing rmq packets. */ public static final class OutgoingRmq implements BaseColumns, OutgoingRmqColumns { @@ -1986,6 +2251,7 @@ public class Im { } /** + * //TODO: move these out into their own provider and database * The table for storing the last client rmq id sent to the server. */ public static final class LastRmqId implements BaseColumns, LastRmqIdColumns { @@ -2046,35 +2312,21 @@ public class Im { } /** - * Columns for IM branding resource map cache table. This table caches the result of - * loading the branding resources to speed up IM landing page start. + * Columns for the s2dRmqIds table, which stores the server-to-device message + * persistent ids. These are used in the RMQ2 protocol, where in the login request, the + * client selective acks these s2d ids to the server. */ - public interface BrandingResourceMapCacheColumns { - /** - * The provider ID - * <P>Type: INTEGER</P> - */ - String PROVIDER_ID = "provider_id"; - /** - * The application resource ID - * <P>Type: INTEGER</P> - */ - String APP_RES_ID = "app_res_id"; - /** - * The plugin resource ID - * <P>Type: INTEGER</P> - */ - String PLUGIN_RES_ID = "plugin_res_id"; + public interface ServerToDeviceRmqIdsColumn { + String RMQ_ID = "rmq_id"; } - /** - * The table for caching the result of loading IM branding resources. - */ - public static final class BrandingResourceMapCache - implements BaseColumns, BrandingResourceMapCacheColumns { + public static final class ServerToDeviceRmqIds implements BaseColumns, + ServerToDeviceRmqIdsColumn { + /** * The content:// style URL for this table. */ - public static final Uri CONTENT_URI = Uri.parse("content://im/brandingResMapCache"); + public static final Uri CONTENT_URI = Uri.parse("content://im/s2dids"); } + } diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java index 4a4d2de..588068e 100644 --- a/core/java/android/provider/Settings.java +++ b/core/java/android/provider/Settings.java @@ -413,8 +413,6 @@ public final class Settings { private static final String TAG = "Settings"; - private static String sJidResource = null; - public static class SettingNotFoundException extends AndroidException { public SettingNotFoundException(String msg) { super(msg); @@ -879,6 +877,17 @@ public final class Settings { public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; /** + * A comma separated list of radios that should to be disabled when airplane mode + * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is + * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi + * will be turned off when entering airplane mode, but the user will be able to reenable + * Wifi in the Settings app. + * + * {@hide} + */ + public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; + + /** * The policy for deciding when Wi-Fi should go to sleep (which will in * turn switch to using the mobile data as an Internet connection). * <p> @@ -1182,6 +1191,22 @@ public final class Settings { public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); /** + * Persistent store for the system-wide default alarm alert. + * + * @see #RINGTONE + * @see #DEFAULT_ALARM_ALERT_URI + */ + public static final String ALARM_ALERT = "alarm_alert"; + + /** + * A {@link Uri} that will point to the current default alarm alert at + * any given time. + * + * @see #DEFAULT_ALARM_ALERT_URI + */ + public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); + + /** * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off */ public static final String TEXT_AUTO_REPLACE = "auto_replace"; @@ -1968,6 +1993,12 @@ public final class Settings { public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; /** + * Whether assisted GPS should be enabled or not. + * @hide + */ + public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; + + /** * The Logging ID (a unique 64-bit value) as a hex string. * Used as a pseudonymous identifier for logging. * @deprecated This identifier is poorly initialized and has @@ -2695,7 +2726,14 @@ public final class Settings { * Controls how many attempts Gmail will try to upload an uphill operations before it * abandons the operation. Defaults to 20. */ - public static final String GMAIL_NUM_RETRY_UPHILL_OP = "gmail_discard_error_uphill_op"; + public static final String GMAIL_NUM_RETRY_UPHILL_OP = "gmail_num_retry_uphill_op"; + + /** + * How much time in seconds Gmail will try to upload an uphill operations before it + * abandons the operation. Defaults to 36400 (one day). + */ + public static final String GMAIL_WAIT_TIME_RETRY_UPHILL_OP = + "gmail_wait_time_retry_uphill_op"; /** * Controls if the protocol buffer version of the protocol will use a multipart request for @@ -2804,6 +2842,12 @@ public final class Settings { "gtalk_nosync_heartbeat_ping_interval_ms"; /** + * The maximum heartbeat interval used while on the WIFI network. + */ + public static final String GTALK_SERVICE_WIFI_MAX_HEARTBEAT_INTERVAL_MS = + "gtalk_wifi_max_heartbeat_ping_interval_ms"; + + /** * How long we wait to receive a heartbeat ping acknowledgement (or another packet) * from the GTalk server, before deeming the connection dead. */ @@ -2856,6 +2900,86 @@ public final class Settings { public static final String GTALK_USE_BARE_JID_TIMEOUT_MS = "gtalk_use_barejid_timeout_ms"; /** + * This is the threshold of retry number when there is an authentication expired failure + * for Google Talk. In some situation, e.g. when a Google Apps account is disabled chat + * service, the connection keeps failing. This threshold controls when we should stop + * the retrying. + */ + public static final String GTALK_MAX_RETRIES_FOR_AUTH_EXPIRED = + "gtalk_max_retries_for_auth_expired"; + + /** + * a boolean setting indicating whether the GTalkService should use RMQ2 protocol or not. + */ + public static final String GTALK_USE_RMQ2_PROTOCOL = + "gtalk_use_rmq2"; + + /** + * a boolean setting indicating whether the GTalkService should support both RMQ and + * RMQ2 protocols. This setting is true for the transitional period when we need to + * support both protocols. + */ + public static final String GTALK_SUPPORT_RMQ_AND_RMQ2_PROTOCOLS = + "gtalk_support_rmq_and_rmq2"; + + /** + * a boolean setting controlling whether the rmq2 protocol will include stream ids in + * the protobufs. This is used for debugging. + */ + public static final String GTALK_RMQ2_INCLUDE_STREAM_ID = + "gtalk_rmq2_include_stream_id"; + + /** + * when receiving a chat message from the server, the message could be an older message + * whose "time sent" is x seconds from now. If x is significant enough, we want to flag + * it so the UI can give it some special treatment when displaying the "time sent" for + * it. This setting is to control what x is. + */ + public static final String GTALK_OLD_CHAT_MESSAGE_THREADHOLD_IN_SEC = + "gtalk_old_chat_msg_threadhold_in_sec"; + + /** + * a setting to control the max connection history record GTalkService stores. + */ + public static final String GTALK_MAX_CONNECTION_HISTORY_RECORDS = + "gtalk_max_conn_history_records"; + + /** + * This is gdata url to lookup album and picture info from picasa web. + */ + public static final String GTALK_PICASA_ALBUM_URL = + "gtalk_picasa_album_url"; + + /** + * This is the url to lookup picture info from flickr. + */ + public static final String GTALK_FLICKR_PHOTO_INFO_URL = + "gtalk_flickr_photo_info_url"; + + /** + * This is the url to lookup an actual picture from flickr. + */ + public static final String GTALK_FLICKR_PHOTO_URL = + "gtalk_flickr_photo_url"; + + /** + * This is the gdata url to lookup info on a youtube video. + */ + public static final String GTALK_YOUTUBE_VIDEO_URL = + "gtalk_youtube_video_url"; + + /** + * This is the url for getting the app token for server-to-device push messaging. + */ + public static final String PUSH_MESSAGING_REGISTRATION_URL = + "push_messaging_registration_url"; + + /** + * Use android://<it> routing infos for Google Sync Server subcriptions. + */ + public static final String GSYNC_USE_RMQ2_ROUTING_INFO = "gsync_use_rmq2_routing_info"; + + /** * Enable use of ssl session caching. * 'db' - save each session in a (per process) database * 'file' - save each session in a (per process) file @@ -2907,6 +3031,12 @@ public final class Settings { "vending_require_sim_for_purchase"; /** + * Indicates the Vending Machine backup state. It is set if the + * Vending application has been backed up at least once. + */ + public static final String VENDING_BACKUP_STATE = "vending_backup_state"; + + /** * The current version id of the Vending Machine terms of service. */ public static final String VENDING_TOS_VERSION = "vending_tos_version"; @@ -3225,39 +3355,6 @@ public final class Settings { "short_keylight_delay_ms"; /** - * URL that points to the voice search servers. To be factored out of this class. - */ - public static final String VOICE_SEARCH_URL = "voice_search_url"; - - /** - * Speech encoding used with voice search on 3G networks. To be factored out of this class. - */ - public static final String VOICE_SEARCH_ENCODING_THREE_G = "voice_search_encoding_three_g"; - - /** - * Speech encoding used with voice search on WIFI networks. To be factored out of this class. - */ - public static final String VOICE_SEARCH_ENCODING_WIFI = "voice_search_encoding_wifi"; - - /** - * Whether to use automatic gain control in voice search (0 = disable, 1 = enable). - * To be factored out of this class. - */ - public static final String VOICE_SEARCH_ENABLE_AGC = "voice_search_enable_agc"; - - /** - * Whether to use noise suppression in voice search (0 = disable, 1 = enable). - * To be factored out of this class. - */ - public static final String VOICE_SEARCH_ENABLE_NS = "voice_search_enable_ns"; - - /** - * Whether to use the IIR filter in voice search (0 = disable, 1 = enable). - * To be factored out of this class. - */ - public static final String VOICE_SEARCH_ENABLE_IIR = "voice_search_enable_iir"; - - /** * List of test suites (local disk filename) for the automatic instrumentation test runner. * The file format is similar to automated_suites.xml, see AutoTesterService. * If this setting is missing or empty, the automatic test runner will not start. @@ -3300,6 +3397,21 @@ public final class Settings { public static final String USE_LOCATION_FOR_SERVICES = "use_location"; /** + * The length of the calendar sync window into the future. + * This specifies the number of days into the future for the sliding window sync. + * Setting this to zero will disable sliding sync. + */ + public static final String GOOGLE_CALENDAR_SYNC_WINDOW_DAYS = + "google_calendar_sync_window_days"; + + /** + * How often to update the calendar sync window. + * The window will be advanced every n days. + */ + public static final String GOOGLE_CALENDAR_SYNC_WINDOW_UPDATE_DAYS = + "google_calendar_sync_window_update_days"; + + /** * @deprecated * @hide */ @@ -3542,42 +3654,6 @@ public final class Settings { } /** - * Returns the GTalk JID resource associated with this device. - * - * @return String the JID resource of the device. It uses the device IMEI in the computation - * of the JID resource. If IMEI is not ready (i.e. telephony module not ready), we'll return - * an empty string. - * @hide - */ - // TODO: we shouldn't not have a permenant Jid resource, as that's an easy target for - // spams. We should change it once a while, like when we resubscribe to the subscription feeds - // server. - // (also, should this live in GTalkService?) - public static synchronized String getJidResource() { - if (sJidResource != null) { - return sJidResource; - } - - MessageDigest digest; - try { - digest = MessageDigest.getInstance("SHA-1"); - } catch (NoSuchAlgorithmException e) { - throw new RuntimeException("this should never happen"); - } - - String deviceId = TelephonyManager.getDefault().getDeviceId(); - if (TextUtils.isEmpty(deviceId)) { - return ""; - } - - byte[] hashedDeviceId = digest.digest(deviceId.getBytes()); - String id = new String(Base64.encodeBase64(hashedDeviceId), 0, 12); - id = id.replaceAll("/", "_"); - sJidResource = JID_RESOURCE_PREFIX + id; - return sJidResource; - } - - /** * Returns the device ID that we should use when connecting to the mobile gtalk server. * This is a string like "android-0x1242", where the hex string is the Android ID obtained * from the GoogleLoginService. diff --git a/core/java/android/provider/SocialContract.java b/core/java/android/provider/SocialContract.java new file mode 100644 index 0000000..ee271ba --- /dev/null +++ b/core/java/android/provider/SocialContract.java @@ -0,0 +1,187 @@ +/* + * Copyright (C) 2009 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.provider; + +import android.content.res.Resources; +import android.graphics.BitmapFactory; +import android.net.Uri; +import android.provider.ContactsContract.Contacts; +import android.provider.ContactsContract.Data; + +/** + * The contract between the social provider and applications. Contains + * definitions for the supported URIs and columns. + * + * @hide + */ +public class SocialContract { + /** The authority for the social provider */ + public static final String AUTHORITY = "com.android.social"; + + /** A content:// style uri to the authority for the contacts provider */ + public static final Uri AUTHORITY_URI = Uri.parse("content://" + AUTHORITY); + + private interface ActivitiesColumns { + /** + * The package name to use when creating {@link Resources} objects for + * this data row. This value is only designed for use when building user + * interfaces, and should not be used to infer the owner. + * <p> + * Type: TEXT + */ + public static final String RES_PACKAGE = "res_package"; + + /** + * The mime-type of this social activity. + * <p> + * Type: TEXT + */ + public static final String MIMETYPE = "mimetype"; + + /** + * Internal raw identifier for this social activity. This field is + * analogous to the <code>atom:id</code> element defined in RFC 4287. + * <p> + * Type: TEXT + */ + public static final String RAW_ID = "raw_id"; + + /** + * Reference to another {@link Activities#RAW_ID} that this social activity + * is replying to. This field is analogous to the + * <code>thr:in-reply-to</code> element defined in RFC 4685. + * <p> + * Type: TEXT + */ + public static final String IN_REPLY_TO = "in_reply_to"; + + /** + * Reference to the {@link android.provider.ContactsContract.Contacts#_ID} that authored + * this social activity. This field is analogous to the <code>atom:author</code> + * element defined in RFC 4287. + * <p> + * Type: INTEGER + */ + public static final String AUTHOR_CONTACT_ID = "author_contact_id"; + + /** + * Optional reference to the {@link android.provider.ContactsContract.Contacts#_ID} this + * social activity is targeted towards. If more than one direct target, this field may + * be left undefined. This field is analogous to the + * <code>activity:target</code> element defined in the Atom Activity + * Extensions Internet-Draft. + * <p> + * Type: INTEGER + */ + public static final String TARGET_CONTACT_ID = "target_contact_id"; + + /** + * Timestamp when this social activity was published, in a + * {@link System#currentTimeMillis()} time base. This field is analogous + * to the <code>atom:published</code> element defined in RFC 4287. + * <p> + * Type: INTEGER + */ + public static final String PUBLISHED = "published"; + + /** + * Timestamp when the original social activity in a thread was + * published. For activities that have an in-reply-to field specified, the + * content provider will automatically populate this field with the + * timestamp of the original activity. + * <p> + * This field is useful for sorting order of activities that keeps together all + * messages in each thread. + * <p> + * Type: INTEGER + */ + public static final String THREAD_PUBLISHED = "thread_published"; + + /** + * Title of this social activity. This field is analogous to the + * <code>atom:title</code> element defined in RFC 4287. + * <p> + * Type: TEXT + */ + public static final String TITLE = "title"; + + /** + * Summary of this social activity. This field is analogous to the + * <code>atom:summary</code> element defined in RFC 4287. + * <p> + * Type: TEXT + */ + public static final String SUMMARY = "summary"; + + /** + * A URI associated this social activity. This field is analogous to the + * <code>atom:link rel="alternate"</code> element defined in RFC 4287. + * <p> + * Type: TEXT + */ + public static final String LINK = "link"; + + /** + * Optional thumbnail specific to this social activity. This is the raw + * bytes of an image that could be inflated using {@link BitmapFactory}. + * <p> + * Type: BLOB + */ + public static final String THUMBNAIL = "thumbnail"; + } + + public static final class Activities implements BaseColumns, ActivitiesColumns { + /** + * This utility class cannot be instantiated + */ + private Activities() { + } + + /** + * The content:// style URI for this table + */ + public static final Uri CONTENT_URI = Uri.withAppendedPath(AUTHORITY_URI, "activities"); + + /** + * The content:// URI for this table filtered to the set of social activities + * authored by a specific {@link android.provider.ContactsContract.Contacts#_ID}. + */ + public static final Uri CONTENT_AUTHORED_BY_URI = + Uri.withAppendedPath(CONTENT_URI, "authored_by"); + + /** + * The {@link Uri} for the latest social activity performed by any + * raw contact aggregated under the specified {@link Contacts#_ID}. Will + * also join with most-present {@link Presence} for this aggregate. + */ + public static final Uri CONTENT_CONTACT_STATUS_URI = + Uri.withAppendedPath(AUTHORITY_URI, "contact_status"); + + /** + * The MIME type of {@link #CONTENT_URI} providing a directory of social + * activities. + */ + public static final String CONTENT_TYPE = "vnd.android.cursor.dir/activity"; + + /** + * The MIME type of a {@link #CONTENT_URI} subdirectory of a single + * social activity. + */ + public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/activity"; + } + +} diff --git a/core/java/android/provider/SubscribedFeeds.java b/core/java/android/provider/SubscribedFeeds.java index 4d430d5..8e9f402 100644 --- a/core/java/android/provider/SubscribedFeeds.java +++ b/core/java/android/provider/SubscribedFeeds.java @@ -20,6 +20,7 @@ import android.content.ContentResolver; import android.content.ContentValues; import android.database.Cursor; import android.net.Uri; +import android.accounts.Account; /** * The SubscribedFeeds provider stores all information about subscribed feeds. @@ -99,7 +100,7 @@ public class SubscribedFeeds { /** * The default sort order for this table */ - public static final String DEFAULT_SORT_ORDER = "_SYNC_ACCOUNT ASC"; + public static final String DEFAULT_SORT_ORDER = "_SYNC_ACCOUNT_TYPE, _SYNC_ACCOUNT ASC"; } /** @@ -114,38 +115,36 @@ public class SubscribedFeeds { * @return the Uri of the feed that was added */ public static Uri addFeed(ContentResolver resolver, - String feed, String account, + String feed, Account account, String authority, String service) { ContentValues values = new ContentValues(); values.put(SubscribedFeeds.Feeds.FEED, feed); - values.put(SubscribedFeeds.Feeds._SYNC_ACCOUNT, account); + values.put(SubscribedFeeds.Feeds._SYNC_ACCOUNT, account.name); + values.put(SubscribedFeeds.Feeds._SYNC_ACCOUNT_TYPE, account.type); values.put(SubscribedFeeds.Feeds.AUTHORITY, authority); values.put(SubscribedFeeds.Feeds.SERVICE, service); return resolver.insert(SubscribedFeeds.Feeds.CONTENT_URI, values); } public static int deleteFeed(ContentResolver resolver, - String feed, String account, String authority) { + String feed, Account account, String authority) { StringBuilder where = new StringBuilder(); where.append(SubscribedFeeds.Feeds._SYNC_ACCOUNT + "=?"); + where.append(" AND " + SubscribedFeeds.Feeds._SYNC_ACCOUNT_TYPE + "=?"); where.append(" AND " + SubscribedFeeds.Feeds.FEED + "=?"); where.append(" AND " + SubscribedFeeds.Feeds.AUTHORITY + "=?"); return resolver.delete(SubscribedFeeds.Feeds.CONTENT_URI, - where.toString(), new String[] {account, feed, authority}); + where.toString(), new String[] {account.name, account.type, feed, authority}); } public static int deleteFeeds(ContentResolver resolver, - String account, String authority) { + Account account, String authority) { StringBuilder where = new StringBuilder(); where.append(SubscribedFeeds.Feeds._SYNC_ACCOUNT + "=?"); + where.append(" AND " + SubscribedFeeds.Feeds._SYNC_ACCOUNT_TYPE + "=?"); where.append(" AND " + SubscribedFeeds.Feeds.AUTHORITY + "=?"); return resolver.delete(SubscribedFeeds.Feeds.CONTENT_URI, - where.toString(), new String[] {account, authority}); - } - - public static String gtalkServiceRoutingInfoFromAccountAndResource( - String account, String res) { - return Uri.parse("gtalk://" + account + "/" + res).toString(); + where.toString(), new String[] {account.name, account.type, authority}); } /** @@ -157,6 +156,12 @@ public class SubscribedFeeds { * <P>Type: TEXT</P> */ public static final String _SYNC_ACCOUNT = SyncConstValue._SYNC_ACCOUNT; + + /** + * The account type. + * <P>Type: TEXT</P> + */ + public static final String _SYNC_ACCOUNT_TYPE = SyncConstValue._SYNC_ACCOUNT_TYPE; } /** @@ -199,6 +204,6 @@ public class SubscribedFeeds { /** * The default sort order for this table */ - public static final String DEFAULT_SORT_ORDER = "_SYNC_ACCOUNT ASC"; + public static final String DEFAULT_SORT_ORDER = "_SYNC_ACCOUNT_TYPE, _SYNC_ACCOUNT ASC"; } } diff --git a/core/java/android/provider/SyncConstValue.java b/core/java/android/provider/SyncConstValue.java index 6eb4398..30966eb 100644 --- a/core/java/android/provider/SyncConstValue.java +++ b/core/java/android/provider/SyncConstValue.java @@ -29,6 +29,12 @@ public interface SyncConstValue public static final String _SYNC_ACCOUNT = "_sync_account"; /** + * The type of the account that was used to sync the entry to the device. + * <P>Type: TEXT</P> + */ + public static final String _SYNC_ACCOUNT_TYPE = "_sync_account_type"; + + /** * The unique ID for a row assigned by the sync source. NULL if the row has never been synced. * <P>Type: TEXT</P> */ @@ -68,4 +74,9 @@ public interface SyncConstValue * Used to indicate that this account is not synced */ public static final String NON_SYNCABLE_ACCOUNT = "non_syncable"; + + /** + * Used to indicate that this account is not synced + */ + public static final String NON_SYNCABLE_ACCOUNT_TYPE = "android.local"; } diff --git a/core/java/android/provider/SyncStateContract.java b/core/java/android/provider/SyncStateContract.java new file mode 100644 index 0000000..5c93af0 --- /dev/null +++ b/core/java/android/provider/SyncStateContract.java @@ -0,0 +1,125 @@ +/* + * Copyright (C) 2009 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.provider; + +import android.net.Uri; +import android.content.ContentProviderClient; +import android.content.ContentValues; +import android.content.ContentProviderOperation; +import android.accounts.Account; +import android.database.Cursor; +import android.os.RemoteException; + +/** + * The ContentProvider contract for associating data with ana data array account. + * This may be used by providers that want to store this data in a standard way. + */ +public class SyncStateContract { + public interface Columns extends BaseColumns { + /** + * A reference to the name of the account to which this data belongs + * <P>Type: STRING</P> + */ + public static final String ACCOUNT_NAME = "account_name"; + + /** + * A reference to the type of the account to which this data belongs + * <P>Type: STRING</P> + */ + public static final String ACCOUNT_TYPE = "account_type"; + + /** + * The sync data associated with this account. + * <P>Type: NONE</P> + */ + public static final String DATA = "data"; + } + + public static class Constants implements Columns { + public static final String CONTENT_DIRECTORY = "syncstate"; + } + + public static final class Helpers { + private static final String[] DATA_PROJECTION = new String[]{Columns.DATA}; + private static final String SELECT_BY_ACCOUNT = + Columns.ACCOUNT_NAME + "=? AND " + Columns.ACCOUNT_TYPE + "=?"; + + /** + * Get the sync state that is associated with the account or null. + * @param provider the {@link ContentProviderClient} that is to be used to communicate + * with the {@link android.content.ContentProvider} that contains the sync state. + * @param uri the uri of the sync state + * @param account the {@link Account} whose sync state should be returned + * @return the sync state or null if there is no sync state associated with the account + * @throws RemoteException if there is a failure communicating with the remote + * {@link android.content.ContentProvider} + */ + public static byte[] get(ContentProviderClient provider, Uri uri, + Account account) throws RemoteException { + Cursor c = provider.query(uri, DATA_PROJECTION, SELECT_BY_ACCOUNT, + new String[]{account.name, account.type}, null); + try { + if (c.moveToNext()) { + return c.getBlob(c.getColumnIndexOrThrow(Columns.DATA)); + } + } finally { + c.close(); + } + return null; + } + + /** + * Assigns the data array as the sync state for the given account. + * @param provider the {@link ContentProviderClient} that is to be used to communicate + * with the {@link android.content.ContentProvider} that contains the sync state. + * @param uri the uri of the sync state + * @param account the {@link Account} whose sync state should be set + * @param data the byte[] that contains the sync state + * @throws RemoteException if there is a failure communicating with the remote + * {@link android.content.ContentProvider} + */ + public static void set(ContentProviderClient provider, Uri uri, + Account account, byte[] data) throws RemoteException { + ContentValues values = new ContentValues(); + values.put(Columns.DATA, data); + values.put(Columns.ACCOUNT_NAME, account.name); + values.put(Columns.ACCOUNT_TYPE, account.type); + provider.insert(uri, values); + } + + /** + * Creates and returns a ContentProviderOperation that assigns the data array as the + * sync state for the given account. + * @param uri the uri of the sync state + * @param account the {@link Account} whose sync state should be set + * @param data the byte[] that contains the sync state + * @return the new ContentProviderOperation that assigns the data array as the + * account's sync state + */ + public static ContentProviderOperation newSetOperation(Uri uri, + Account account, byte[] data) { + ContentValues values = new ContentValues(); + values.put(Columns.DATA, data); + return ContentProviderOperation + .newInsert(uri) + .withValue(Columns.ACCOUNT_NAME, account.name) + .withValue(Columns.ACCOUNT_TYPE, account.type) + .withValues(values) + .build(); + } + } +} diff --git a/core/java/android/provider/Telephony.java b/core/java/android/provider/Telephony.java index c292c53..7a6f6bb 100644 --- a/core/java/android/provider/Telephony.java +++ b/core/java/android/provider/Telephony.java @@ -146,7 +146,13 @@ public final class Telephony { * <P>Type: TEXT</P> */ public static final String SERVICE_CENTER = "service_center"; - } + + /** + * Has the message been locked? + * <P>Type: INTEGER (boolean)</P> + */ + public static final String LOCKED = "locked"; +} /** * Contains all text based SMS messages. @@ -1008,6 +1014,12 @@ public final class Telephony { * <P>Type: INTEGER</P> */ public static final String THREAD_ID = "thread_id"; + + /** + * Has the message been locked? + * <P>Type: INTEGER (boolean)</P> + */ + public static final String LOCKED = "locked"; } /** @@ -1416,6 +1428,8 @@ public final class Telephony { */ public static final String _DATA = "_data"; + public static final String TEXT = "text"; + } public static final class Rate { @@ -1493,6 +1507,14 @@ public final class Telephony { public static final Uri CONTENT_DRAFT_URI = Uri.parse( "content://mms-sms/draft"); + /*** + * Pass in a query parameter called "pattern" which is the text + * to search for. + * The sort order is fixed to be thread_id ASC,date DESC. + */ + public static final Uri SEARCH_URI = Uri.parse( + "content://mms-sms/search"); + // Constants for message protocol types. public static final int SMS_PROTO = 0; public static final int MMS_PROTO = 1; diff --git a/core/java/android/server/BluetoothA2dpService.java b/core/java/android/server/BluetoothA2dpService.java index 5c4e56d..d9fcb53 100644 --- a/core/java/android/server/BluetoothA2dpService.java +++ b/core/java/android/server/BluetoothA2dpService.java @@ -23,17 +23,17 @@ package android.server; import android.bluetooth.BluetoothA2dp; +import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothError; import android.bluetooth.BluetoothIntent; +import android.bluetooth.BluetoothUuid; import android.bluetooth.IBluetoothA2dp; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; -import android.content.pm.PackageManager; import android.media.AudioManager; -import android.os.Binder; import android.os.Handler; import android.os.Message; import android.provider.Settings; @@ -41,9 +41,10 @@ import android.util.Log; import java.io.FileDescriptor; import java.io.PrintWriter; -import java.util.ArrayList; import java.util.HashMap; -import java.util.List; +import java.util.HashSet; +import java.util.Set; +import java.util.UUID; public class BluetoothA2dpService extends IBluetoothA2dp.Stub { private static final String TAG = "BluetoothA2dpService"; @@ -54,75 +55,40 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { private static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN; private static final String BLUETOOTH_PERM = android.Manifest.permission.BLUETOOTH; - private static final String A2DP_SINK_ADDRESS = "a2dp_sink_address"; private static final String BLUETOOTH_ENABLED = "bluetooth_enabled"; private static final int MESSAGE_CONNECT_TO = 1; - private static final int MESSAGE_DISCONNECT = 2; - private final Context mContext; - private final IntentFilter mIntentFilter; - private HashMap<String, SinkState> mAudioDevices; - private final AudioManager mAudioManager; - private final BluetoothDevice mBluetooth; - - // list of disconnected sinks to process after a delay - private final ArrayList<String> mPendingDisconnects = new ArrayList<String>(); - // number of active sinks - private int mSinkCount = 0; - - private class SinkState { - public String address; - public int state; - public SinkState(String a, int s) {address = a; state = s;} - } + private static final String PROPERTY_STATE = "State"; - public BluetoothA2dpService(Context context) { - mContext = context; + private static final String SINK_STATE_DISCONNECTED = "disconnected"; + private static final String SINK_STATE_CONNECTING = "connecting"; + private static final String SINK_STATE_CONNECTED = "connected"; + private static final String SINK_STATE_PLAYING = "playing"; - mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + private static int mSinkCount; - mBluetooth = (BluetoothDevice) mContext.getSystemService(Context.BLUETOOTH_SERVICE); - if (mBluetooth == null) { - throw new RuntimeException("Platform does not support Bluetooth"); - } - - if (!initNative()) { - throw new RuntimeException("Could not init BluetoothA2dpService"); - } - - mIntentFilter = new IntentFilter(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION); - mIntentFilter.addAction(BluetoothIntent.BOND_STATE_CHANGED_ACTION); - mIntentFilter.addAction(BluetoothIntent.REMOTE_DEVICE_CONNECTED_ACTION); - mContext.registerReceiver(mReceiver, mIntentFilter); - - if (mBluetooth.isEnabled()) { - onBluetoothEnable(); - } - } - - @Override - protected void finalize() throws Throwable { - try { - cleanupNative(); - } finally { - super.finalize(); - } - } + private final Context mContext; + private final IntentFilter mIntentFilter; + private HashMap<BluetoothDevice, Integer> mAudioDevices; + private final AudioManager mAudioManager; + private final BluetoothService mBluetoothService; + private final BluetoothAdapter mAdapter; private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override public void onReceive(Context context, Intent intent) { String action = intent.getAction(); - String address = intent.getStringExtra(BluetoothIntent.ADDRESS); + BluetoothDevice device = + intent.getParcelableExtra(BluetoothIntent.DEVICE); if (action.equals(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION)) { int state = intent.getIntExtra(BluetoothIntent.BLUETOOTH_STATE, BluetoothError.ERROR); switch (state) { - case BluetoothDevice.BLUETOOTH_STATE_ON: + case BluetoothAdapter.BLUETOOTH_STATE_ON: onBluetoothEnable(); break; - case BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF: + case BluetoothAdapter.BLUETOOTH_STATE_TURNING_OFF: onBluetoothDisable(); break; } @@ -131,99 +97,187 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { BluetoothError.ERROR); switch(bondState) { case BluetoothDevice.BOND_BONDED: - setSinkPriority(address, BluetoothA2dp.PRIORITY_AUTO); + setSinkPriority(device, BluetoothA2dp.PRIORITY_AUTO); break; case BluetoothDevice.BOND_BONDING: case BluetoothDevice.BOND_NOT_BONDED: - setSinkPriority(address, BluetoothA2dp.PRIORITY_OFF); + setSinkPriority(device, BluetoothA2dp.PRIORITY_OFF); break; } } else if (action.equals(BluetoothIntent.REMOTE_DEVICE_CONNECTED_ACTION)) { - if (getSinkPriority(address) > BluetoothA2dp.PRIORITY_OFF) { + if (getSinkPriority(device) > BluetoothA2dp.PRIORITY_OFF && + isSinkDevice(device)) { // This device is a preferred sink. Make an A2DP connection // after a delay. We delay to avoid connection collisions, // and to give other profiles such as HFP a chance to // connect first. - Message msg = Message.obtain(mHandler, MESSAGE_CONNECT_TO, address); + Message msg = Message.obtain(mHandler, MESSAGE_CONNECT_TO, device); mHandler.sendMessageDelayed(msg, 6000); } } } }; + public BluetoothA2dpService(Context context, BluetoothService bluetoothService) { + mContext = context; + + mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); + + mBluetoothService = bluetoothService; + if (mBluetoothService == null) { + throw new RuntimeException("Platform does not support Bluetooth"); + } + + if (!initNative()) { + throw new RuntimeException("Could not init BluetoothA2dpService"); + } + + mAdapter = (BluetoothAdapter) context.getSystemService(Context.BLUETOOTH_SERVICE); + + mIntentFilter = new IntentFilter(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION); + mIntentFilter.addAction(BluetoothIntent.BOND_STATE_CHANGED_ACTION); + mIntentFilter.addAction(BluetoothIntent.REMOTE_DEVICE_CONNECTED_ACTION); + mContext.registerReceiver(mReceiver, mIntentFilter); + + mAudioDevices = new HashMap<BluetoothDevice, Integer>(); + + if (mBluetoothService.isEnabled()) + onBluetoothEnable(); + } + + @Override + protected void finalize() throws Throwable { + try { + cleanupNative(); + } finally { + super.finalize(); + } + } + private final Handler mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_CONNECT_TO: - String address = (String)msg.obj; + BluetoothDevice device = (BluetoothDevice) msg.obj; // check bluetooth is still on, device is still preferred, and // nothing is currently connected - if (mBluetooth.isEnabled() && - getSinkPriority(address) > BluetoothA2dp.PRIORITY_OFF && + if (mBluetoothService.isEnabled() && + getSinkPriority(device) > BluetoothA2dp.PRIORITY_OFF && lookupSinksMatchingStates(new int[] { BluetoothA2dp.STATE_CONNECTING, BluetoothA2dp.STATE_CONNECTED, BluetoothA2dp.STATE_PLAYING, BluetoothA2dp.STATE_DISCONNECTING}).size() == 0) { - log("Auto-connecting A2DP to sink " + address); - connectSink(address); + log("Auto-connecting A2DP to sink " + device); + connectSink(device); } break; - case MESSAGE_DISCONNECT: - handleDeferredDisconnect((String)msg.obj); - break; } } }; + private int convertBluezSinkStringtoState(String value) { + if (value.equalsIgnoreCase("disconnected")) + return BluetoothA2dp.STATE_DISCONNECTED; + if (value.equalsIgnoreCase("connecting")) + return BluetoothA2dp.STATE_CONNECTING; + if (value.equalsIgnoreCase("connected")) + return BluetoothA2dp.STATE_CONNECTED; + if (value.equalsIgnoreCase("playing")) + return BluetoothA2dp.STATE_PLAYING; + return -1; + } + + private boolean isSinkDevice(BluetoothDevice device) { + String uuids[] = mBluetoothService.getRemoteUuids(device.getAddress()); + UUID uuid; + if (uuids != null) { + for (String deviceUuid: uuids) { + uuid = UUID.fromString(deviceUuid); + if (BluetoothUuid.isAudioSink(uuid)) { + return true; + } + } + } + return false; + } + + private synchronized boolean addAudioSink (BluetoothDevice device) { + String path = mBluetoothService.getObjectPathFromAddress(device.getAddress()); + String propValues[] = (String []) getSinkPropertiesNative(path); + if (propValues == null) { + Log.e(TAG, "Error while getting AudioSink properties for device: " + device); + return false; + } + Integer state = null; + // Properties are name-value pairs + for (int i = 0; i < propValues.length; i+=2) { + if (propValues[i].equals(PROPERTY_STATE)) { + state = new Integer(convertBluezSinkStringtoState(propValues[i+1])); + break; + } + } + mAudioDevices.put(device, state); + handleSinkStateChange(device, BluetoothA2dp.STATE_DISCONNECTED, state); + return true; + } + private synchronized void onBluetoothEnable() { - mAudioDevices = new HashMap<String, SinkState>(); - String[] paths = (String[])listHeadsetsNative(); - if (paths != null) { - for (String path : paths) { - mAudioDevices.put(path, new SinkState(getAddressNative(path), - isSinkConnectedNative(path) ? BluetoothA2dp.STATE_CONNECTED : - BluetoothA2dp.STATE_DISCONNECTED)); + String devices = mBluetoothService.getProperty("Devices"); + mSinkCount = 0; + if (devices != null) { + String [] paths = devices.split(","); + for (String path: paths) { + String address = mBluetoothService.getAddressFromObjectPath(path); + BluetoothDevice device = mAdapter.getRemoteDevice(address); + String []uuids = mBluetoothService.getRemoteUuids(address); + if (uuids != null) + for (String uuid: uuids) { + UUID remoteUuid = UUID.fromString(uuid); + if (BluetoothUuid.isAudioSink(remoteUuid) || + BluetoothUuid.isAudioSource(remoteUuid) || + BluetoothUuid.isAdvAudioDist(remoteUuid)) { + addAudioSink(device); + break; + } + } } } - mAudioManager.setParameter(BLUETOOTH_ENABLED, "true"); + mAudioManager.setParameters(BLUETOOTH_ENABLED+"=true"); } private synchronized void onBluetoothDisable() { - if (mAudioDevices != null) { - // copy to allow modification during iteration - String[] paths = new String[mAudioDevices.size()]; - paths = mAudioDevices.keySet().toArray(paths); - for (String path : paths) { - switch (mAudioDevices.get(path).state) { + if (!mAudioDevices.isEmpty()) { + BluetoothDevice[] devices = new BluetoothDevice[mAudioDevices.size()]; + devices = mAudioDevices.keySet().toArray(devices); + for (BluetoothDevice device : devices) { + int state = getSinkState(device); + switch (state) { case BluetoothA2dp.STATE_CONNECTING: case BluetoothA2dp.STATE_CONNECTED: case BluetoothA2dp.STATE_PLAYING: - disconnectSinkNative(path); - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); + disconnectSinkNative(mBluetoothService.getObjectPathFromAddress( + device.getAddress())); + handleSinkStateChange(device, state, BluetoothA2dp.STATE_DISCONNECTED); break; case BluetoothA2dp.STATE_DISCONNECTING: - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); + handleSinkStateChange(device, BluetoothA2dp.STATE_DISCONNECTING, + BluetoothA2dp.STATE_DISCONNECTED); break; } } - mAudioDevices = null; + mAudioDevices.clear(); } - mAudioManager.setBluetoothA2dpOn(false); - mAudioManager.setParameter(BLUETOOTH_ENABLED, "false"); + + mAudioManager.setParameters(BLUETOOTH_ENABLED + "=false"); } - public synchronized int connectSink(String address) { + public synchronized int connectSink(BluetoothDevice device) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - if (DBG) log("connectSink(" + address + ")"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return BluetoothError.ERROR; - } - if (mAudioDevices == null) { - return BluetoothError.ERROR; - } + if (DBG) log("connectSink(" + device + ")"); + // ignore if there are any active sinks if (lookupSinksMatchingStates(new int[] { BluetoothA2dp.STATE_CONNECTING, @@ -233,20 +287,11 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { return BluetoothError.ERROR; } - String path = lookupPath(address); - if (path == null) { - path = createHeadsetNative(address); - if (DBG) log("new bluez sink: " + address + " (" + path + ")"); - } - if (path == null) { + if (mAudioDevices.get(device) == null && !addAudioSink(device)) return BluetoothError.ERROR; - } - SinkState sink = mAudioDevices.get(path); - int state = BluetoothA2dp.STATE_DISCONNECTED; - if (sink != null) { - state = sink.state; - } + int state = mAudioDevices.get(device); + switch (state) { case BluetoothA2dp.STATE_CONNECTED: case BluetoothA2dp.STATE_PLAYING: @@ -256,29 +301,28 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { return BluetoothError.SUCCESS; } + String path = mBluetoothService.getObjectPathFromAddress(device.getAddress()); + if (path == null) + return BluetoothError.ERROR; + // State is DISCONNECTED if (!connectSinkNative(path)) { return BluetoothError.ERROR; } - updateState(path, BluetoothA2dp.STATE_CONNECTING); return BluetoothError.SUCCESS; } - public synchronized int disconnectSink(String address) { + public synchronized int disconnectSink(BluetoothDevice device) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - if (DBG) log("disconnectSink(" + address + ")"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return BluetoothError.ERROR; - } - if (mAudioDevices == null) { - return BluetoothError.ERROR; - } - String path = lookupPath(address); + if (DBG) log("disconnectSink(" + device + ")"); + + String path = mBluetoothService.getObjectPathFromAddress(device.getAddress()); if (path == null) { return BluetoothError.ERROR; } - switch (mAudioDevices.get(path).state) { + + switch (getSinkState(device)) { case BluetoothA2dp.STATE_DISCONNECTED: return BluetoothError.ERROR; case BluetoothA2dp.STATE_DISCONNECTING: @@ -289,151 +333,106 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { if (!disconnectSinkNative(path)) { return BluetoothError.ERROR; } else { - updateState(path, BluetoothA2dp.STATE_DISCONNECTING); return BluetoothError.SUCCESS; } } - public synchronized List<String> listConnectedSinks() { + public synchronized BluetoothDevice[] getConnectedSinks() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return lookupSinksMatchingStates(new int[] {BluetoothA2dp.STATE_CONNECTED, - BluetoothA2dp.STATE_PLAYING}); + Set<BluetoothDevice> sinks = lookupSinksMatchingStates( + new int[] {BluetoothA2dp.STATE_CONNECTED, BluetoothA2dp.STATE_PLAYING}); + return sinks.toArray(new BluetoothDevice[sinks.size()]); } - public synchronized int getSinkState(String address) { + public synchronized int getSinkState(BluetoothDevice device) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return BluetoothError.ERROR; - } - if (mAudioDevices == null) { + Integer state = mAudioDevices.get(device); + if (state == null) return BluetoothA2dp.STATE_DISCONNECTED; - } - for (SinkState sink : mAudioDevices.values()) { - if (address.equals(sink.address)) { - return sink.state; - } - } - return BluetoothA2dp.STATE_DISCONNECTED; + return state; } - public synchronized int getSinkPriority(String address) { + public synchronized int getSinkPriority(BluetoothDevice device) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return BluetoothError.ERROR; - } return Settings.Secure.getInt(mContext.getContentResolver(), - Settings.Secure.getBluetoothA2dpSinkPriorityKey(address), + Settings.Secure.getBluetoothA2dpSinkPriorityKey(device.getAddress()), BluetoothA2dp.PRIORITY_OFF); } - public synchronized int setSinkPriority(String address, int priority) { + public synchronized int setSinkPriority(BluetoothDevice device, int priority) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { + if (!BluetoothDevice.checkBluetoothAddress(device.getAddress())) { return BluetoothError.ERROR; } return Settings.Secure.putInt(mContext.getContentResolver(), - Settings.Secure.getBluetoothA2dpSinkPriorityKey(address), priority) ? + Settings.Secure.getBluetoothA2dpSinkPriorityKey(device.getAddress()), priority) ? BluetoothError.SUCCESS : BluetoothError.ERROR; } - private synchronized void onHeadsetCreated(String path) { - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); - } - - private synchronized void onHeadsetRemoved(String path) { - if (mAudioDevices == null) return; - mAudioDevices.remove(path); - } - - private synchronized void onSinkConnected(String path) { - // if we are reconnected, do not process previous disconnect event. - mPendingDisconnects.remove(path); - - if (mAudioDevices == null) return; - // bluez 3.36 quietly disconnects the previous sink when a new sink - // is connected, so we need to mark all previously connected sinks as - // disconnected - - // copy to allow modification during iteration - String[] paths = new String[mAudioDevices.size()]; - paths = mAudioDevices.keySet().toArray(paths); - for (String oldPath : paths) { - if (path.equals(oldPath)) { - continue; - } - int state = mAudioDevices.get(oldPath).state; - if (state == BluetoothA2dp.STATE_CONNECTED || state == BluetoothA2dp.STATE_PLAYING) { - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); - } + private synchronized void onSinkPropertyChanged(String path, String []propValues) { + if (!mBluetoothService.isEnabled()) { + return; } - updateState(path, BluetoothA2dp.STATE_CONNECTING); - mAudioManager.setParameter(A2DP_SINK_ADDRESS, lookupAddress(path)); - mAudioManager.setBluetoothA2dpOn(true); - updateState(path, BluetoothA2dp.STATE_CONNECTED); - } + String name = propValues[0]; + String address = mBluetoothService.getAddressFromObjectPath(path); + if (address == null) { + Log.e(TAG, "onSinkPropertyChanged: Address of the remote device in null"); + return; + } - private synchronized void onSinkDisconnected(String path) { - // This is to work around a problem in bluez that results - // sink disconnect events being sent, immediately followed by a reconnect. - // To avoid unnecessary audio routing changes, we defer handling - // sink disconnects until after a short delay. - mPendingDisconnects.add(path); - Message msg = Message.obtain(mHandler, MESSAGE_DISCONNECT, path); - mHandler.sendMessageDelayed(msg, 2000); - } + BluetoothDevice device = mAdapter.getRemoteDevice(address); - private synchronized void handleDeferredDisconnect(String path) { - if (mPendingDisconnects.contains(path)) { - mPendingDisconnects.remove(path); - if (mSinkCount == 1) { - mAudioManager.setBluetoothA2dpOn(false); + if (name.equals(PROPERTY_STATE)) { + int state = convertBluezSinkStringtoState(propValues[1]); + if (mAudioDevices.get(device) == null) { + // This is for an incoming connection for a device not known to us. + // We have authorized it and bluez state has changed. + addAudioSink(device); + } else { + int prevState = mAudioDevices.get(device); + handleSinkStateChange(device, prevState, state); } - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); } } - private synchronized void onSinkPlaying(String path) { - updateState(path, BluetoothA2dp.STATE_PLAYING); - } + private void handleSinkStateChange(BluetoothDevice device, int prevState, int state) { + if (state != prevState) { + if (state == BluetoothA2dp.STATE_DISCONNECTED || + state == BluetoothA2dp.STATE_DISCONNECTING) { + if (prevState == BluetoothA2dp.STATE_CONNECTED || + prevState == BluetoothA2dp.STATE_PLAYING) { + // disconnecting or disconnected + Intent intent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY); + mContext.sendBroadcast(intent); + } + mSinkCount--; + } else if (state == BluetoothA2dp.STATE_CONNECTED) { + mSinkCount ++; + } + mAudioDevices.put(device, state); - private synchronized void onSinkStopped(String path) { - updateState(path, BluetoothA2dp.STATE_CONNECTED); - } + Intent intent = new Intent(BluetoothA2dp.SINK_STATE_CHANGED_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, device); + intent.putExtra(BluetoothA2dp.SINK_PREVIOUS_STATE, prevState); + intent.putExtra(BluetoothA2dp.SINK_STATE, state); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); - private synchronized final String lookupAddress(String path) { - if (mAudioDevices == null) return null; - SinkState sink = mAudioDevices.get(path); - if (sink == null) { - Log.w(TAG, "lookupAddress() called for unknown device " + path); - updateState(path, BluetoothA2dp.STATE_DISCONNECTED); + if (DBG) log("A2DP state : device: " + device + " State:" + prevState + "->" + state); } - String address = mAudioDevices.get(path).address; - if (address == null) Log.e(TAG, "Can't find address for " + path); - return address; } - private synchronized final String lookupPath(String address) { - if (mAudioDevices == null) return null; - - for (String path : mAudioDevices.keySet()) { - if (address.equals(mAudioDevices.get(path).address)) { - return path; - } - } - return null; - } - - private synchronized List<String> lookupSinksMatchingStates(int[] states) { - List<String> sinks = new ArrayList<String>(); - if (mAudioDevices == null) { + private synchronized Set<BluetoothDevice> lookupSinksMatchingStates(int[] states) { + Set<BluetoothDevice> sinks = new HashSet<BluetoothDevice>(); + if (mAudioDevices.isEmpty()) { return sinks; } - for (SinkState sink : mAudioDevices.values()) { + for (BluetoothDevice device: mAudioDevices.keySet()) { + int sinkState = getSinkState(device); for (int state : states) { - if (sink.state == state) { - sinks.add(sink.address); + if (state == sinkState) { + sinks.add(device); break; } } @@ -441,57 +440,13 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { return sinks; } - private synchronized void updateState(String path, int state) { - if (mAudioDevices == null) return; - - SinkState s = mAudioDevices.get(path); - int prevState; - String address; - if (s == null) { - address = getAddressNative(path); - mAudioDevices.put(path, new SinkState(address, state)); - prevState = BluetoothA2dp.STATE_DISCONNECTED; - } else { - address = lookupAddress(path); - prevState = s.state; - s.state = state; - } - - if (state != prevState) { - if (DBG) log("state " + address + " (" + path + ") " + prevState + "->" + state); - - // keep track of the number of active sinks - if (prevState == BluetoothA2dp.STATE_DISCONNECTED) { - mSinkCount++; - } else if (state == BluetoothA2dp.STATE_DISCONNECTED) { - mSinkCount--; - } - - Intent intent = new Intent(BluetoothA2dp.SINK_STATE_CHANGED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - intent.putExtra(BluetoothA2dp.SINK_PREVIOUS_STATE, prevState); - intent.putExtra(BluetoothA2dp.SINK_STATE, state); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - - if ((prevState == BluetoothA2dp.STATE_CONNECTED || - prevState == BluetoothA2dp.STATE_PLAYING) && - (state != BluetoothA2dp.STATE_CONNECTING && - state != BluetoothA2dp.STATE_CONNECTED && - state != BluetoothA2dp.STATE_PLAYING)) { - // disconnected - intent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY); - mContext.sendBroadcast(intent); - } - } - } - @Override protected synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) { - if (mAudioDevices == null) return; + if (mAudioDevices.isEmpty()) return; pw.println("Cached audio devices:"); - for (String path : mAudioDevices.keySet()) { - SinkState sink = mAudioDevices.get(path); - pw.println(path + " " + sink.address + " " + BluetoothA2dp.stateToString(sink.state)); + for (BluetoothDevice device : mAudioDevices.keySet()) { + int state = mAudioDevices.get(device); + pw.println(device + " " + BluetoothA2dp.stateToString(state)); } } @@ -501,11 +456,7 @@ public class BluetoothA2dpService extends IBluetoothA2dp.Stub { private native boolean initNative(); private native void cleanupNative(); - private synchronized native String[] listHeadsetsNative(); - private synchronized native String createHeadsetNative(String address); - private synchronized native boolean removeHeadsetNative(String path); - private synchronized native String getAddressNative(String path); private synchronized native boolean connectSinkNative(String path); private synchronized native boolean disconnectSinkNative(String path); - private synchronized native boolean isSinkConnectedNative(String path); + private synchronized native Object []getSinkPropertiesNative(String path); } diff --git a/core/java/android/server/BluetoothEventLoop.java b/core/java/android/server/BluetoothEventLoop.java index 8cc229b..6610d0e 100644 --- a/core/java/android/server/BluetoothEventLoop.java +++ b/core/java/android/server/BluetoothEventLoop.java @@ -18,18 +18,19 @@ package android.server; import android.bluetooth.BluetoothA2dp; import android.bluetooth.BluetoothClass; +import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothError; import android.bluetooth.BluetoothIntent; -import android.bluetooth.IBluetoothDeviceCallback; +import android.bluetooth.BluetoothUuid; import android.content.Context; import android.content.Intent; import android.os.Handler; import android.os.Message; -import android.os.RemoteException; import android.util.Log; import java.util.HashMap; +import java.util.UUID; /** * TODO: Move this to @@ -46,9 +47,10 @@ class BluetoothEventLoop { private Thread mThread; private boolean mStarted; private boolean mInterrupted; + private final HashMap<String, Integer> mPasskeyAgentRequestData; - private final HashMap<String, IBluetoothDeviceCallback> mGetRemoteServiceChannelCallbacks; - private final BluetoothDeviceService mBluetoothService; + private final BluetoothService mBluetoothService; + private final BluetoothAdapter mAdapter; private final Context mContext; private static final int EVENT_AUTO_PAIRING_FAILURE_ATTEMPT_DELAY = 1; @@ -85,14 +87,14 @@ class BluetoothEventLoop { static { classInitNative(); } private static native void classInitNative(); - /* pacakge */ BluetoothEventLoop(Context context, BluetoothDeviceService bluetoothService) { + /* pacakge */ BluetoothEventLoop(Context context, BluetoothAdapter adapter, + BluetoothService bluetoothService) { mBluetoothService = bluetoothService; mContext = context; mPasskeyAgentRequestData = new HashMap(); - mGetRemoteServiceChannelCallbacks = new HashMap(); + mAdapter = adapter; initializeNativeDataNative(); } - private native void initializeNativeDataNative(); protected void finalize() throws Throwable { try { @@ -101,20 +103,11 @@ class BluetoothEventLoop { super.finalize(); } } - private native void cleanupNativeDataNative(); - - /* pacakge */ HashMap<String, IBluetoothDeviceCallback> getRemoteServiceChannelCallbacks() { - return mGetRemoteServiceChannelCallbacks; - } - /* pacakge */ HashMap<String, Integer> getPasskeyAgentRequestData() { + /* package */ HashMap<String, Integer> getPasskeyAgentRequestData() { return mPasskeyAgentRequestData; } - private native void startEventLoopNative(); - private native void stopEventLoopNative(); - private native boolean isEventLoopRunningNative(); - /* package */ void start() { if (!isEventLoopRunningNative()) { @@ -134,79 +127,47 @@ class BluetoothEventLoop { return isEventLoopRunningNative(); } - /*package*/ void onModeChanged(String bluezMode) { - int mode = BluetoothDeviceService.bluezStringToScanMode(bluezMode); - if (mode >= 0) { - Intent intent = new Intent(BluetoothIntent.SCAN_MODE_CHANGED_ACTION); - intent.putExtra(BluetoothIntent.SCAN_MODE, mode); - intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); + private void addDevice(String address, String[] properties) { + mBluetoothService.addRemoteDeviceProperties(address, properties); + String rssi = mBluetoothService.getRemoteDeviceProperty(address, "RSSI"); + String classValue = mBluetoothService.getRemoteDeviceProperty(address, "Class"); + String name = mBluetoothService.getRemoteDeviceProperty(address, "Name"); + short rssiValue; + // For incoming connections, we don't get the RSSI value. Use a default of MIN_VALUE. + // If we accept the pairing, we will automatically show it at the top of the list. + if (rssi != null) { + rssiValue = (short)Integer.valueOf(rssi).intValue(); + } else { + rssiValue = Short.MIN_VALUE; + } + if (classValue != null) { + Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_FOUND_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); + intent.putExtra(BluetoothIntent.CLASS, Integer.valueOf(classValue)); + intent.putExtra(BluetoothIntent.RSSI, rssiValue); + intent.putExtra(BluetoothIntent.NAME, name); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + } else { + log ("ClassValue: " + classValue + " for remote device: " + address + " is null"); } } - private void onDiscoveryStarted() { - mBluetoothService.setIsDiscovering(true); - Intent intent = new Intent(BluetoothIntent.DISCOVERY_STARTED_ACTION); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onDiscoveryCompleted() { - mBluetoothService.setIsDiscovering(false); - Intent intent = new Intent(BluetoothIntent.DISCOVERY_COMPLETED_ACTION); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); + private void onDeviceFound(String address, String[] properties) { + if (properties == null) { + Log.e(TAG, "ERROR: Remote device properties are null"); + return; + } + addDevice(address, properties); } - private void onRemoteDeviceFound(String address, int deviceClass, short rssi) { - Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_FOUND_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - intent.putExtra(BluetoothIntent.CLASS, deviceClass); - intent.putExtra(BluetoothIntent.RSSI, rssi); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteDeviceDisappeared(String address) { + private void onDeviceDisappeared(String address) { Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_DISAPPEARED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteClassUpdated(String address, int deviceClass) { - Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_CLASS_UPDATED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - intent.putExtra(BluetoothIntent.CLASS, deviceClass); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteDeviceConnected(String address) { - Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_CONNECTED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteDeviceDisconnectRequested(String address) { - Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_DISCONNECT_REQUESTED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteDeviceDisconnected(String address) { - Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_DISCONNECTED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteNameUpdated(String address, String name) { - Intent intent = new Intent(BluetoothIntent.REMOTE_NAME_UPDATED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - intent.putExtra(BluetoothIntent.NAME, name); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteNameFailed(String address) { - Intent intent = new Intent(BluetoothIntent.REMOTE_NAME_FAILED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); - } - private void onRemoteNameChanged(String address, String name) { - Intent intent = new Intent(BluetoothIntent.REMOTE_NAME_UPDATED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - intent.putExtra(BluetoothIntent.NAME, name); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); mContext.sendBroadcast(intent, BLUETOOTH_PERM); } - private void onCreateBondingResult(String address, int result) { + private void onCreatePairedDeviceResult(String address, int result) { address = address.toUpperCase(); if (result == BluetoothError.SUCCESS) { mBluetoothService.getBondState().setBondState(address, BluetoothDevice.BOND_BONDED); @@ -259,31 +220,178 @@ class BluetoothEventLoop { mBluetoothService.getBondState().attempt(address); } - private void onBondingCreated(String address) { - mBluetoothService.getBondState().setBondState(address.toUpperCase(), - BluetoothDevice.BOND_BONDED); + private void onDeviceCreated(String deviceObjectPath) { + String address = mBluetoothService.getAddressFromObjectPath(deviceObjectPath); + if (!mBluetoothService.isRemoteDeviceInCache(address)) { + // Incoming connection, we haven't seen this device, add to cache. + String[] properties = mBluetoothService.getRemoteDeviceProperties(address); + if (properties != null) { + addDevice(address, properties); + } + } + return; } - private void onBondingRemoved(String address) { - mBluetoothService.getBondState().setBondState(address.toUpperCase(), - BluetoothDevice.BOND_NOT_BONDED, BluetoothDevice.UNBOND_REASON_REMOVED); + private void onDeviceRemoved(String deviceObjectPath) { + String address = mBluetoothService.getAddressFromObjectPath(deviceObjectPath); + if (address != null) + mBluetoothService.getBondState().setBondState(address.toUpperCase(), + BluetoothDevice.BOND_NOT_BONDED, BluetoothDevice.UNBOND_REASON_REMOVED); } - private void onNameChanged(String name) { - Intent intent = new Intent(BluetoothIntent.NAME_CHANGED_ACTION); - intent.putExtra(BluetoothIntent.NAME, name); - mContext.sendBroadcast(intent, BLUETOOTH_PERM); + /*package*/ void onPropertyChanged(String[] propValues) { + String name = propValues[0]; + if (name.equals("Name")) { + Intent intent = new Intent(BluetoothIntent.NAME_CHANGED_ACTION); + intent.putExtra(BluetoothIntent.NAME, propValues[1]); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + mBluetoothService.setProperty(name, propValues[1]); + } else if (name.equals("Pairable") || name.equals("Discoverable")) { + String pairable = name.equals("Pairable") ? propValues[1] : + mBluetoothService.getProperty("Pairable"); + String discoverable = name.equals("Discoverable") ? propValues[1] : + mBluetoothService.getProperty("Discoverable"); + + // This shouldn't happen, unless Adapter Properties are null. + if (pairable == null || discoverable == null) + return; + + int mode = BluetoothService.bluezStringToScanMode( + pairable.equals("true"), + discoverable.equals("true")); + if (mode >= 0) { + Intent intent = new Intent(BluetoothIntent.SCAN_MODE_CHANGED_ACTION); + intent.putExtra(BluetoothIntent.SCAN_MODE, mode); + intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + } + mBluetoothService.setProperty(name, propValues[1]); + } else if (name.equals("Discovering")) { + Intent intent; + if (propValues[1].equals("true")) { + mBluetoothService.setIsDiscovering(true); + intent = new Intent(BluetoothIntent.DISCOVERY_STARTED_ACTION); + } else { + // Stop the discovery. + mBluetoothService.cancelDiscovery(); + mBluetoothService.setIsDiscovering(false); + intent = new Intent(BluetoothIntent.DISCOVERY_COMPLETED_ACTION); + } + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + mBluetoothService.setProperty(name, propValues[1]); + } else if (name.equals("Devices")) { + String value = null; + int len = Integer.valueOf(propValues[1]); + if (len > 0) { + value = ""; + for (int i = 2; i < propValues.length; i++) { + value = value + propValues[i] + ','; + } + } + mBluetoothService.setProperty(name, value); + } else if (name.equals("Powered")) { + // bluetoothd has restarted, re-read all our properties. + // Note: bluez only sends this property change when it restarts. + if (propValues[1].equals("true")) + onRestartRequired(); + } } - private void onPasskeyAgentRequest(String address, int nativeData) { + private void onDevicePropertyChanged(String deviceObjectPath, String[] propValues) { + String name = propValues[0]; + String address = mBluetoothService.getAddressFromObjectPath(deviceObjectPath); + if (address == null) { + Log.e(TAG, "onDevicePropertyChanged: Address of the remote device in null"); + return; + } + BluetoothDevice device = mAdapter.getRemoteDevice(address); + if (name.equals("Name")) { + Intent intent = new Intent(BluetoothIntent.REMOTE_NAME_UPDATED_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, device); + intent.putExtra(BluetoothIntent.NAME, propValues[1]); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + mBluetoothService.setRemoteDeviceProperty(address, name, propValues[1]); + } else if (name.equals("Class")) { + Intent intent = new Intent(BluetoothIntent.REMOTE_DEVICE_CLASS_UPDATED_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, device); + intent.putExtra(BluetoothIntent.CLASS, propValues[1]); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + mBluetoothService.setRemoteDeviceProperty(address, name, propValues[1]); + } else if (name.equals("Connected")) { + Intent intent = null; + if (propValues[1].equals("true")) { + intent = new Intent(BluetoothIntent.REMOTE_DEVICE_CONNECTED_ACTION); + } else { + intent = new Intent(BluetoothIntent.REMOTE_DEVICE_DISCONNECTED_ACTION); + } + intent.putExtra(BluetoothIntent.DEVICE, device); + mContext.sendBroadcast(intent, BLUETOOTH_PERM); + mBluetoothService.setRemoteDeviceProperty(address, name, propValues[1]); + } else if (name.equals("UUIDs")) { + String uuid = null; + int len = Integer.valueOf(propValues[1]); + if (len > 0) { + uuid = ""; + for (int i = 2; i < propValues.length; i++) { + uuid = uuid + propValues[i] + ","; + } + } + mBluetoothService.setRemoteDeviceProperty(address, name, uuid); + } else if (name.equals("Paired")) { + if (propValues[1].equals("true")) { + mBluetoothService.getBondState().setBondState(address, BluetoothDevice.BOND_BONDED); + } else { + mBluetoothService.getBondState().setBondState(address, + BluetoothDevice.BOND_NOT_BONDED); + } + } + } + + private String checkPairingRequestAndGetAddress(String objectPath, int nativeData) { + String address = mBluetoothService.getAddressFromObjectPath(objectPath); + if (address == null) { + Log.e(TAG, "Unable to get device address in checkPairingRequestAndGetAddress, " + + "returning null"); + return null; + } address = address.toUpperCase(); mPasskeyAgentRequestData.put(address, new Integer(nativeData)); - if (mBluetoothService.getBluetoothState() == BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF) { + if (mBluetoothService.getBluetoothState() == BluetoothAdapter.BLUETOOTH_STATE_TURNING_OFF) { // shutdown path - mBluetoothService.cancelPin(address); - return; + mBluetoothService.cancelPairingUserInput(address); + return null; } + return address; + } + + private void onRequestConfirmation(String objectPath, int passkey, int nativeData) { + String address = checkPairingRequestAndGetAddress(objectPath, nativeData); + if (address == null) return; + + Intent intent = new Intent(BluetoothIntent.PAIRING_REQUEST_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); + intent.putExtra(BluetoothIntent.PASSKEY, passkey); + intent.putExtra(BluetoothIntent.PAIRING_VARIANT, + BluetoothDevice.PAIRING_VARIANT_CONFIRMATION); + mContext.sendBroadcast(intent, BLUETOOTH_ADMIN_PERM); + return; + } + + private void onRequestPasskey(String objectPath, int nativeData) { + String address = checkPairingRequestAndGetAddress(objectPath, nativeData); + if (address == null) return; + + Intent intent = new Intent(BluetoothIntent.PAIRING_REQUEST_ACTION); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); + intent.putExtra(BluetoothIntent.PAIRING_VARIANT, BluetoothDevice.PAIRING_VARIANT_PASSKEY); + mContext.sendBroadcast(intent, BLUETOOTH_ADMIN_PERM); + return; + } + + private void onRequestPinCode(String objectPath, int nativeData) { + String address = checkPairingRequestAndGetAddress(objectPath, nativeData); + if (address == null) return; if (mBluetoothService.getBondState().getBondState(address) == BluetoothDevice.BOND_BONDING) { @@ -307,55 +415,48 @@ class BluetoothEventLoop { } } Intent intent = new Intent(BluetoothIntent.PAIRING_REQUEST_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); + intent.putExtra(BluetoothIntent.PAIRING_VARIANT, BluetoothDevice.PAIRING_VARIANT_PIN); mContext.sendBroadcast(intent, BLUETOOTH_ADMIN_PERM); + return; } - private void onPasskeyAgentCancel(String address) { - address = address.toUpperCase(); - mBluetoothService.cancelPin(address); - Intent intent = new Intent(BluetoothIntent.PAIRING_CANCEL_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); - mContext.sendBroadcast(intent, BLUETOOTH_ADMIN_PERM); - mBluetoothService.getBondState().setBondState(address, BluetoothDevice.BOND_NOT_BONDED, - BluetoothDevice.UNBOND_REASON_AUTH_CANCELED); - } + private boolean onAgentAuthorize(String objectPath, String deviceUuid) { + String address = mBluetoothService.getAddressFromObjectPath(objectPath); + if (address == null) { + Log.e(TAG, "Unable to get device address in onAuthAgentAuthorize"); + return false; + } - private boolean onAuthAgentAuthorize(String address, String service, String uuid) { boolean authorized = false; - if (mBluetoothService.isEnabled() && service.endsWith("service_audio")) { + UUID uuid = UUID.fromString(deviceUuid); + if (mBluetoothService.isEnabled() && + (BluetoothUuid.isAudioSink(uuid) || BluetoothUuid.isAvrcpController(uuid) + || BluetoothUuid.isAdvAudioDist(uuid))) { BluetoothA2dp a2dp = new BluetoothA2dp(mContext); - authorized = a2dp.getSinkPriority(address) > BluetoothA2dp.PRIORITY_OFF; + BluetoothDevice device = mAdapter.getRemoteDevice(address); + authorized = a2dp.getSinkPriority(device) > BluetoothA2dp.PRIORITY_OFF; if (authorized) { - Log.i(TAG, "Allowing incoming A2DP connection from " + address); + Log.i(TAG, "Allowing incoming A2DP / AVRCP connection from " + address); } else { - Log.i(TAG, "Rejecting incoming A2DP connection from " + address); + Log.i(TAG, "Rejecting incoming A2DP / AVRCP connection from " + address); } } else { - Log.i(TAG, "Rejecting incoming " + service + " connection from " + address); + Log.i(TAG, "Rejecting incoming " + deviceUuid + " connection from " + address); } return authorized; } - private void onAuthAgentCancel(String address, String service, String uuid) { - // We immediately response to DBUS Authorize() so this should not - // usually happen - log("onAuthAgentCancel(" + address + ", " + service + ", " + uuid + ")"); - } - - private void onGetRemoteServiceChannelResult(String address, int channel) { - IBluetoothDeviceCallback callback = mGetRemoteServiceChannelCallbacks.get(address); - if (callback != null) { - mGetRemoteServiceChannelCallbacks.remove(address); - try { - callback.onGetRemoteServiceChannelResult(address, channel); - } catch (RemoteException e) {} - } + private void onAgentCancel() { + Intent intent = new Intent(BluetoothIntent.PAIRING_CANCEL_ACTION); + mContext.sendBroadcast(intent, BLUETOOTH_ADMIN_PERM); + return; } private void onRestartRequired() { if (mBluetoothService.isEnabled()) { - Log.e(TAG, "*** A serious error occured (did hcid crash?) - restarting Bluetooth ***"); + Log.e(TAG, "*** A serious error occured (did bluetoothd crash?) - " + + "restarting Bluetooth ***"); mHandler.sendEmptyMessage(EVENT_RESTART_BLUETOOTH); } } @@ -363,4 +464,10 @@ class BluetoothEventLoop { private static void log(String msg) { Log.d(TAG, msg); } + + private native void initializeNativeDataNative(); + private native void startEventLoopNative(); + private native void stopEventLoopNative(); + private native boolean isEventLoopRunningNative(); + private native void cleanupNativeDataNative(); } diff --git a/core/java/android/server/BluetoothDeviceService.java b/core/java/android/server/BluetoothService.java index 8c843ef..a7c0425 100644 --- a/core/java/android/server/BluetoothDeviceService.java +++ b/core/java/android/server/BluetoothService.java @@ -16,7 +16,7 @@ /** * TODO: Move this to - * java/services/com/android/server/BluetoothDeviceService.java + * java/services/com/android/server/BluetoothService.java * and make the contructor package private again. * * @hide @@ -25,12 +25,12 @@ package android.server; import android.bluetooth.BluetoothClass; +import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothError; import android.bluetooth.BluetoothHeadset; import android.bluetooth.BluetoothIntent; -import android.bluetooth.IBluetoothDevice; -import android.bluetooth.IBluetoothDeviceCallback; +import android.bluetooth.IBluetooth; import android.content.BroadcastReceiver; import android.content.ContentResolver; import android.content.Context; @@ -38,7 +38,6 @@ import android.content.Intent; import android.content.IntentFilter; import android.os.Binder; import android.os.Handler; -import android.os.IBinder; import android.os.Message; import android.os.RemoteException; import android.os.ServiceManager; @@ -46,6 +45,8 @@ import android.os.SystemService; import android.provider.Settings; import android.util.Log; +import com.android.internal.app.IBatteryStats; + import java.io.FileDescriptor; import java.io.PrintWriter; import java.io.UnsupportedEncodingException; @@ -55,10 +56,8 @@ import java.util.HashMap; import java.util.Iterator; import java.util.Map; -import com.android.internal.app.IBatteryStats; - -public class BluetoothDeviceService extends IBluetoothDevice.Stub { - private static final String TAG = "BluetoothDeviceService"; +public class BluetoothService extends IBluetooth.Stub { + private static final String TAG = "BluetoothService"; private static final boolean DBG = true; private int mNativeData; @@ -67,11 +66,11 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { private boolean mIsAirplaneSensitive; private int mBluetoothState; private boolean mRestart = false; // need to call enable() after disable() + private boolean mIsDiscovering; + private BluetoothAdapter mAdapter; // constant after init() private final BondState mBondState = new BondState(); // local cache of bondings - private boolean mIsDiscovering; private final IBatteryStats mBatteryStats; - private final Context mContext; private static final String BLUETOOTH_ADMIN_PERM = android.Manifest.permission.BLUETOOTH_ADMIN; @@ -80,12 +79,14 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { private static final int MESSAGE_REGISTER_SDP_RECORDS = 1; private static final int MESSAGE_FINISH_DISABLE = 2; + private final Map<String, String> mAdapterProperties; + private final HashMap <String, Map<String, String>> mDeviceProperties; + static { classInitNative(); } - private native static void classInitNative(); - public BluetoothDeviceService(Context context) { + public BluetoothService(Context context) { mContext = context; // Need to do this in place of: @@ -93,11 +94,7 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { // Since we can not import BatteryStatsService from here. This class really needs to be // moved to java/services/com/android/server/ mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService("batteryinfo")); - } - /** Must be called after construction, and before any other method. - */ - public synchronized void init() { initializeNativeDataNative(); if (isEnabledNative() == 1) { @@ -105,12 +102,17 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { disableNative(); } - setBluetoothState(BluetoothDevice.BLUETOOTH_STATE_OFF); + mBluetoothState = BluetoothAdapter.BLUETOOTH_STATE_OFF; mIsDiscovering = false; - mEventLoop = new BluetoothEventLoop(mContext, this); + mAdapterProperties = new HashMap<String, String>(); + mDeviceProperties = new HashMap<String, Map<String,String>>(); registerForAirplaneMode(); } - private native void initializeNativeDataNative(); + + public synchronized void initAfterRegistration() { + mAdapter = (BluetoothAdapter) mContext.getSystemService(Context.BLUETOOTH_SERVICE); + mEventLoop = new BluetoothEventLoop(mContext, mAdapter, this); + } @Override protected void finalize() throws Throwable { @@ -123,13 +125,11 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { super.finalize(); } } - private native void cleanupNativeDataNative(); public boolean isEnabled() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return mBluetoothState == BluetoothDevice.BLUETOOTH_STATE_ON; + return mBluetoothState == BluetoothAdapter.BLUETOOTH_STATE_ON; } - private native int isEnabledNative(); public int getBluetoothState() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); @@ -150,13 +150,12 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { * @param saveSetting If true, disable BT in settings */ public synchronized boolean disable(boolean saveSetting) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, - "Need BLUETOOTH_ADMIN permission"); + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); switch (mBluetoothState) { - case BluetoothDevice.BLUETOOTH_STATE_OFF: + case BluetoothAdapter.BLUETOOTH_STATE_OFF: return true; - case BluetoothDevice.BLUETOOTH_STATE_ON: + case BluetoothAdapter.BLUETOOTH_STATE_ON: break; default: return false; @@ -164,11 +163,11 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (mEnableThread != null && mEnableThread.isAlive()) { return false; } - setBluetoothState(BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF); + setBluetoothState(BluetoothAdapter.BLUETOOTH_STATE_TURNING_OFF); // Allow 3 seconds for profiles to gracefully disconnect // TODO: Introduce a callback mechanism so that each profile can notify - // BluetoothDeviceService when it is done shutting down + // BluetoothService when it is done shutting down mHandler.sendMessageDelayed( mHandler.obtainMessage(MESSAGE_FINISH_DISABLE, saveSetting ? 1 : 0, 0), 3000); return true; @@ -176,10 +175,11 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { private synchronized void finishDisable(boolean saveSetting) { - if (mBluetoothState != BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF) { + if (mBluetoothState != BluetoothAdapter.BLUETOOTH_STATE_TURNING_OFF) { return; } mEventLoop.stop(); + tearDownNativeDataNative(); disableNative(); // mark in progress bondings as cancelled @@ -188,31 +188,19 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { BluetoothDevice.UNBOND_REASON_AUTH_CANCELED); } - // Remove remoteServiceChannelCallbacks - HashMap<String, IBluetoothDeviceCallback> callbacksMap = - mEventLoop.getRemoteServiceChannelCallbacks(); - - for (Iterator<String> i = callbacksMap.keySet().iterator(); i.hasNext();) { - String address = i.next(); - IBluetoothDeviceCallback callback = callbacksMap.get(address); - try { - callback.onGetRemoteServiceChannelResult(address, BluetoothError.ERROR_DISABLED); - } catch (RemoteException e) {} - i.remove(); - } - // update mode Intent intent = new Intent(BluetoothIntent.SCAN_MODE_CHANGED_ACTION); - intent.putExtra(BluetoothIntent.SCAN_MODE, BluetoothDevice.SCAN_MODE_NONE); + intent.putExtra(BluetoothIntent.SCAN_MODE, BluetoothAdapter.SCAN_MODE_NONE); mContext.sendBroadcast(intent, BLUETOOTH_PERM); mIsDiscovering = false; + mAdapterProperties.clear(); if (saveSetting) { persistBluetoothOnSetting(false); } - setBluetoothState(BluetoothDevice.BLUETOOTH_STATE_OFF); + setBluetoothState(BluetoothAdapter.BLUETOOTH_STATE_OFF); // Log bluetooth off to battery stats. long ident = Binder.clearCallingIdentity(); @@ -249,13 +237,13 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (mIsAirplaneSensitive && isAirplaneModeOn()) { return false; } - if (mBluetoothState != BluetoothDevice.BLUETOOTH_STATE_OFF) { + if (mBluetoothState != BluetoothAdapter.BLUETOOTH_STATE_OFF) { return false; } if (mEnableThread != null && mEnableThread.isAlive()) { return false; } - setBluetoothState(BluetoothDevice.BLUETOOTH_STATE_TURNING_ON); + setBluetoothState(BluetoothAdapter.BLUETOOTH_STATE_TURNING_ON); mEnableThread = new EnableThread(saveSetting); mEnableThread.start(); return true; @@ -263,14 +251,14 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { /** Forcibly restart Bluetooth if it is on */ /* package */ synchronized void restart() { - if (mBluetoothState != BluetoothDevice.BLUETOOTH_STATE_ON) { + if (mBluetoothState != BluetoothAdapter.BLUETOOTH_STATE_ON) { return; } mRestart = true; if (!disable(false)) { mRestart = false; } - } + } private synchronized void setBluetoothState(int state) { if (state == mBluetoothState) { @@ -298,6 +286,8 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (isEnabled()) { SystemService.start("hsag"); SystemService.start("hfag"); + SystemService.start("opush"); + SystemService.start("pbap"); } break; case MESSAGE_FINISH_DISABLE: @@ -343,6 +333,9 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (res) { + if (!setupNativeDataNative()) { + return; + } if (mSaveSetting) { persistBluetoothOnSetting(true); } @@ -364,12 +357,13 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { mEnableThread = null; setBluetoothState(res ? - BluetoothDevice.BLUETOOTH_STATE_ON : - BluetoothDevice.BLUETOOTH_STATE_OFF); + BluetoothAdapter.BLUETOOTH_STATE_ON : + BluetoothAdapter.BLUETOOTH_STATE_OFF); if (res) { // Update mode - mEventLoop.onModeChanged(getModeNative()); + String[] propVal = {"Pairable", getProperty("Pairable")}; + mEventLoop.onPropertyChanged(propVal); } if (mIsAirplaneSensitive && isAirplaneModeOn()) { @@ -386,9 +380,6 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { Binder.restoreCallingIdentity(origCallerIdentityToken); } - private native int enableNative(); - private native int disableNative(); - /* package */ BondState getBondState() { return mBondState; } @@ -420,17 +411,22 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { )); public synchronized void loadBondState() { - if (mBluetoothState != BluetoothDevice.BLUETOOTH_STATE_TURNING_ON) { + if (mBluetoothState != BluetoothAdapter.BLUETOOTH_STATE_TURNING_ON) { return; } - String[] bonds = listBondingsNative(); + String []bonds = null; + String val = getProperty("Devices"); + if (val != null) { + bonds = val.split(","); + } if (bonds == null) { return; } mState.clear(); if (DBG) log("found " + bonds.length + " bonded devices"); - for (String address : bonds) { - mState.put(address.toUpperCase(), BluetoothDevice.BOND_BONDED); + for (String device : bonds) { + mState.put(getAddressFromObjectPath(device).toUpperCase(), + BluetoothDevice.BOND_BONDED); } } @@ -447,7 +443,7 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (DBG) log(address + " bond state " + oldState + " -> " + state + " (" + reason + ")"); Intent intent = new Intent(BluetoothIntent.BOND_STATE_CHANGED_ACTION); - intent.putExtra(BluetoothIntent.ADDRESS, address); + intent.putExtra(BluetoothIntent.DEVICE, mAdapter.getRemoteDevice(address)); intent.putExtra(BluetoothIntent.BOND_STATE, state); intent.putExtra(BluetoothIntent.BOND_PREVIOUS_STATE, oldState); if (state == BluetoothDevice.BOND_NOT_BONDED) { @@ -528,7 +524,6 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { } } - private native String[] listBondingsNative(); private static String toBondStateString(int bondState) { switch (bondState) { @@ -543,17 +538,49 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { } } - public synchronized String getAddress() { + /*package*/synchronized void getAllProperties() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getAddressNative(); + mAdapterProperties.clear(); + + String properties[] = (String [])getAdapterPropertiesNative(); + // The String Array consists of key-value pairs. + if (properties == null) { + Log.e(TAG, "*Error*: GetAdapterProperties returned NULL"); + return; + } + + for (int i = 0; i < properties.length; i++) { + String name = properties[i]; + String newValue; + int len; + if (name == null) { + Log.e(TAG, "Error:Adapter Property at index" + i + "is null"); + continue; + } + if (name.equals("Devices")) { + len = Integer.valueOf(properties[++i]); + if (len != 0) + newValue = ""; + else + newValue = null; + for (int j = 0; j < len; j++) { + newValue += properties[++i] + ","; + } + } else { + newValue = properties[++i]; + } + mAdapterProperties.put(name, newValue); + } + + // Add adapter object path property. + String adapterPath = getAdapterPathNative(); + if (adapterPath != null) + mAdapterProperties.put("ObjectPath", adapterPath + "/dev_"); } - private native String getAddressNative(); - public synchronized String getName() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getNameNative(); + /* package */ synchronized void setProperty(String name, String value) { + mAdapterProperties.put(name, value); } - private native String getNameNative(); public synchronized boolean setName(String name) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, @@ -561,90 +588,101 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (name == null) { return false; } - // hcid handles persistance of the bluetooth name - return setNameNative(name); + return setPropertyString("Name", name); } - private native boolean setNameNative(String name); - /** - * Returns the user-friendly name of a remote device. This value is - * retrned from our local cache, which is updated during device discovery. - * Do not expect to retrieve the updated remote name immediately after - * changing the name on the remote device. - * - * @param address Bluetooth address of remote device. - * - * @return The user-friendly name of the specified remote device. - */ - public synchronized String getRemoteName(String address) { + //TODO(): setPropertyString, setPropertyInteger, setPropertyBoolean + // Either have a single property function with Object as the parameter + // or have a function for each property and then obfuscate in the JNI layer. + // The following looks dirty. + private boolean setPropertyString(String key, String value) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; - } - return getRemoteNameNative(address); + return setAdapterPropertyStringNative(key, value); } - private native String getRemoteNameNative(String address); - /* pacakge */ native String getAdapterPathNative(); + private boolean setPropertyInteger(String key, int value) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); + return setAdapterPropertyIntegerNative(key, value); + } - public synchronized boolean startDiscovery(boolean resolveNames) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, - "Need BLUETOOTH_ADMIN permission"); - return startDiscoveryNative(resolveNames); + private boolean setPropertyBoolean(String key, boolean value) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); + return setAdapterPropertyBooleanNative(key, value ? 1 : 0); } - private native boolean startDiscoveryNative(boolean resolveNames); - public synchronized boolean cancelDiscovery() { + /** + * Set the discoverability window for the device. A timeout of zero + * makes the device permanently discoverable (if the device is + * discoverable). Setting the timeout to a nonzero value does not make + * a device discoverable; you need to call setMode() to make the device + * explicitly discoverable. + * + * @param timeout_s The discoverable timeout in seconds. + */ + public synchronized boolean setDiscoverableTimeout(int timeout) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - return cancelDiscoveryNative(); + return setPropertyInteger("DiscoverableTimeout", timeout); } - private native boolean cancelDiscoveryNative(); - public synchronized boolean isDiscovering() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return mIsDiscovering; - } + public synchronized boolean setScanMode(int mode) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, + "Need BLUETOOTH_ADMIN permission"); + boolean pairable = false, discoverable = false; + String modeString = scanModeToBluezString(mode); + if (modeString.equals("off")) { + pairable = false; + discoverable = false; + } else if (modeString.equals("pariable")) { + pairable = true; + discoverable = false; + } else if (modeString.equals("discoverable")) { + pairable = true; + discoverable = true; + } + setPropertyBoolean("Pairable", pairable); + setPropertyBoolean("Discoverable", discoverable); - /* package */ void setIsDiscovering(boolean isDiscovering) { - mIsDiscovering = isDiscovering; + return true; } - public synchronized boolean startPeriodicDiscovery() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, - "Need BLUETOOTH_ADMIN permission"); - return startPeriodicDiscoveryNative(); + /*package*/ synchronized String getProperty (String name) { + if (!mAdapterProperties.isEmpty()) + return mAdapterProperties.get(name); + getAllProperties(); + return mAdapterProperties.get(name); } - private native boolean startPeriodicDiscoveryNative(); - public synchronized boolean stopPeriodicDiscovery() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, - "Need BLUETOOTH_ADMIN permission"); - return stopPeriodicDiscoveryNative(); + public synchronized String getAddress() { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); + return getProperty("Address"); } - private native boolean stopPeriodicDiscoveryNative(); - public synchronized boolean isPeriodicDiscovery() { + public synchronized String getName() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return isPeriodicDiscoveryNative(); + return getProperty("Name"); } - private native boolean isPeriodicDiscoveryNative(); /** - * Set the discoverability window for the device. A timeout of zero - * makes the device permanently discoverable (if the device is - * discoverable). Setting the timeout to a nonzero value does not make - * a device discoverable; you need to call setMode() to make the device - * explicitly discoverable. + * Returns the user-friendly name of a remote device. This value is + * returned from our local cache, which is updated when onPropertyChange + * event is received. + * Do not expect to retrieve the updated remote name immediately after + * changing the name on the remote device. * - * @param timeout_s The discoverable timeout in seconds. + * @param address Bluetooth address of remote device. + * + * @return The user-friendly name of the specified remote device. */ - public synchronized boolean setDiscoverableTimeout(int timeout) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, - "Need BLUETOOTH_ADMIN permission"); - return setDiscoverableTimeoutNative(timeout); + public synchronized String getRemoteName(String address) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); + if (!BluetoothDevice.checkBluetoothAddress(address)) { + return null; + } + Map <String, String> properties = mDeviceProperties.get(address); + if (properties != null) return properties.get("Name"); + return null; } - private native boolean setDiscoverableTimeoutNative(int timeout_s); /** * Get the discoverability window for the device. A timeout of zero @@ -656,45 +694,46 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { */ public synchronized int getDiscoverableTimeout() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getDiscoverableTimeoutNative(); + String timeout = getProperty("DiscoverableTimeout"); + if (timeout != null) + return Integer.valueOf(timeout); + else + return -1; } - private native int getDiscoverableTimeoutNative(); - - public synchronized boolean isAclConnected(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return false; - } - return isConnectedNative(address); - } - private native boolean isConnectedNative(String address); public synchronized int getScanMode() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return bluezStringToScanMode(getModeNative()); + if (!isEnabled()) + return BluetoothError.ERROR; + + boolean pairable = getProperty("Pairable").equals("true"); + boolean discoverable = getProperty("Discoverable").equals("true"); + return bluezStringToScanMode (pairable, discoverable); } - private native String getModeNative(); - public synchronized boolean setScanMode(int mode) { + public synchronized boolean startDiscovery() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - String bluezMode = scanModeToBluezString(mode); - if (bluezMode != null) { - return setModeNative(bluezMode); + if (!isEnabled()) { + return false; } - return false; + return startDiscoveryNative(); } - private native boolean setModeNative(String mode); - public synchronized boolean disconnectRemoteDeviceAcl(String address) { + public synchronized boolean cancelDiscovery() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return false; - } - return disconnectRemoteDeviceNative(address); + return stopDiscoveryNative(); + } + + public synchronized boolean isDiscovering() { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); + return mIsDiscovering; + } + + /* package */ void setIsDiscovering(boolean isDiscovering) { + mIsDiscovering = isDiscovering; } - private native boolean disconnectRemoteDeviceNative(String address); public synchronized boolean createBond(String address) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, @@ -719,14 +758,13 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { return false; } - if (!createBondingNative(address, 60000 /* 1 minute */)) { + if (!createPairedDeviceNative(address, 60000 /* 1 minute */)) { return false; } mBondState.setBondState(address, BluetoothDevice.BOND_BONDING); return true; } - private native boolean createBondingNative(String address, int timeout_ms); public synchronized boolean cancelBondProcess(String address) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, @@ -741,10 +779,9 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { mBondState.setBondState(address, BluetoothDevice.BOND_NOT_BONDED, BluetoothDevice.UNBOND_REASON_AUTH_CANCELED); - cancelBondingProcessNative(address); + cancelDeviceCreationNative(address); return true; } - private native boolean cancelBondingProcessNative(String address); public synchronized boolean removeBond(String address) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, @@ -752,9 +789,8 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { if (!BluetoothDevice.checkBluetoothAddress(address)) { return false; } - return removeBondingNative(address); + return removeDeviceNative(getObjectPathFromAddress(address)); } - private native boolean removeBondingNative(String address); public synchronized String[] listBonds() { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); @@ -769,198 +805,86 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { return mBondState.getBondState(address.toUpperCase()); } - public synchronized String[] listAclConnections() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return listConnectionsNative(); - } - private native String[] listConnectionsNative(); - - /** - * This method lists all remote devices that this adapter is aware of. - * This is a list not only of all most-recently discovered devices, but of - * all devices discovered by this adapter up to some point in the past. - * Note that many of these devices may not be in the neighborhood anymore, - * and attempting to connect to them will result in an error. - * - * @return An array of strings representing the Bluetooth addresses of all - * remote devices that this adapter is aware of. - */ - public synchronized String[] listRemoteDevices() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return listRemoteDevicesNative(); - } - private native String[] listRemoteDevicesNative(); - - /** - * Returns the version of the Bluetooth chip. This version is compiled from - * the LMP version. In case of EDR the features attribute must be checked. - * Example: "Bluetooth 2.0 + EDR". - * - * @return a String representation of the this Adapter's underlying - * Bluetooth-chip version. - */ - public synchronized String getVersion() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getVersionNative(); - } - private native String getVersionNative(); - - /** - * Returns the revision of the Bluetooth chip. This is a vendor-specific - * value and in most cases it represents the firmware version. This might - * derive from the HCI revision and LMP subversion values or via extra - * vendord specific commands. - * In case the revision of a chip is not available. This method should - * return the LMP subversion value as a string. - * Example: "HCI 19.2" - * - * @return The HCI revision of this adapter. - */ - public synchronized String getRevision() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getRevisionNative(); - } - private native String getRevisionNative(); - - /** - * Returns the manufacturer of the Bluetooth chip. If the company id is not - * known the sting "Company ID %d" where %d should be replaced with the - * numeric value from the manufacturer field. - * Example: "Cambridge Silicon Radio" - * - * @return Manufacturer name. - */ - public synchronized String getManufacturer() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getManufacturerNative(); - } - private native String getManufacturerNative(); - - /** - * Returns the company name from the OUI database of the Bluetooth device - * address. This function will need a valid and up-to-date oui.txt from - * the IEEE. This value will be different from the manufacturer string in - * the most cases. - * If the oui.txt file is not present or the OUI part of the Bluetooth - * address is not listed, it should return the string "OUI %s" where %s is - * the actual OUI. - * - * Example: "Apple Computer" - * - * @return company name - */ - public synchronized String getCompany() { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - return getCompanyNative(); + /*package*/ boolean isRemoteDeviceInCache(String address) { + return (mDeviceProperties.get(address) != null); } - private native String getCompanyNative(); - /** - * Like getVersion(), but for a remote device. - * - * @param address The Bluetooth address of the remote device. - * - * @return remote-device Bluetooth version - * - * @see #getVersion - */ - public synchronized String getRemoteVersion(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; - } - return getRemoteVersionNative(address); + /*package*/ String[] getRemoteDeviceProperties(String address) { + String objectPath = getObjectPathFromAddress(address); + return (String [])getDevicePropertiesNative(objectPath); } - private native String getRemoteVersionNative(String address); - /** - * Like getRevision(), but for a remote device. - * - * @param address The Bluetooth address of the remote device. - * - * @return remote-device HCI revision - * - * @see #getRevision - */ - public synchronized String getRemoteRevision(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; + /*package*/ synchronized String getRemoteDeviceProperty(String address, String property) { + Map<String, String> properties = mDeviceProperties.get(address); + if (properties != null) { + return properties.get(property); + } else { + // Query for remote device properties, again. + // We will need to reload the cache when we switch Bluetooth on / off + // or if we crash. + String[] propValues = getRemoteDeviceProperties(address); + if (propValues != null) { + addRemoteDeviceProperties(address, propValues); + return getRemoteDeviceProperty(address, property); + } } - return getRemoteRevisionNative(address); + Log.e(TAG, "getRemoteDeviceProperty: " + property + "not present:" + address); + return null; } - private native String getRemoteRevisionNative(String address); - /** - * Like getManufacturer(), but for a remote device. - * - * @param address The Bluetooth address of the remote device. - * - * @return remote-device Bluetooth chip manufacturer - * - * @see #getManufacturer - */ - public synchronized String getRemoteManufacturer(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; + /* package */ synchronized void addRemoteDeviceProperties(String address, String[] properties) { + /* + * We get a DeviceFound signal every time RSSI changes or name changes. + * Don't create a new Map object every time */ + Map<String, String> propertyValues = mDeviceProperties.get(address); + if (propertyValues != null) { + propertyValues.clear(); + } else { + propertyValues = new HashMap<String, String>(); } - return getRemoteManufacturerNative(address); - } - private native String getRemoteManufacturerNative(String address); - /** - * Like getCompany(), but for a remote device. - * - * @param address The Bluetooth address of the remote device. - * - * @return remote-device company - * - * @see #getCompany - */ - public synchronized String getRemoteCompany(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; + for (int i = 0; i < properties.length; i++) { + String name = properties[i]; + String newValue; + int len; + if (name == null) { + Log.e(TAG, "Error: Remote Device Property at index" + i + "is null"); + continue; + } + if (name.equals("UUIDs") || name.equals("Nodes")) { + len = Integer.valueOf(properties[++i]); + if (len != 0) + newValue = ""; + else + newValue = null; + for (int j = 0; j < len; j++) { + newValue += properties[++i] + ","; + } + } else { + newValue = properties[++i]; + } + propertyValues.put(name, newValue); } - return getRemoteCompanyNative(address); + mDeviceProperties.put(address, propertyValues); } - private native String getRemoteCompanyNative(String address); - /** - * Returns the date and time when the specified remote device has been seen - * by a discover procedure. - * Example: "2006-02-08 12:00:00 GMT" - * - * @return a String with the timestamp. - */ - public synchronized String lastSeen(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; - } - return lastSeenNative(address); + /* package */ void removeRemoteDeviceProperties(String address) { + mDeviceProperties.remove(address); } - private native String lastSeenNative(String address); - /** - * Returns the date and time when the specified remote device has last been - * connected to - * Example: "2006-02-08 12:00:00 GMT" - * - * @return a String with the timestamp. - */ - public synchronized String lastUsed(String address) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; + /* package */ synchronized void setRemoteDeviceProperty(String address, String name, + String value) { + Map <String, String> propVal = mDeviceProperties.get(address); + if (propVal != null) { + propVal.put(name, value); + mDeviceProperties.put(address, propVal); + } else { + Log.e(TAG, "setRemoteDeviceProperty for a device not in cache:" + address); } - return lastUsedNative(address); } - private native String lastUsedNative(String address); /** - * Gets the remote major, minor, and service classes encoded as a 32-bit + * Gets the remote major, minor classes encoded as a 32-bit * integer. * * Note: this value is retrieved from cache, because we get it during @@ -968,120 +892,56 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { * * @return 32-bit integer encoding the remote major, minor, and service * classes. - * - * @see #getRemoteMajorClass - * @see #getRemoteMinorClass - * @see #getRemoteServiceClasses */ public synchronized int getRemoteClass(String address) { if (!BluetoothDevice.checkBluetoothAddress(address)) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); return BluetoothClass.ERROR; } - return getRemoteClassNative(address); + String val = getRemoteDeviceProperty(address, "Class"); + if (val == null) + return BluetoothClass.ERROR; + else { + return Integer.valueOf(val); + } } - private native int getRemoteClassNative(String address); + /** * Gets the remote features encoded as bit mask. * * Note: This method may be obsoleted soon. * - * @return byte array of features. + * @return String array of 128bit UUIDs */ - public synchronized byte[] getRemoteFeatures(String address) { + public synchronized String[] getRemoteUuids(String address) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); if (!BluetoothDevice.checkBluetoothAddress(address)) { return null; } - return getRemoteFeaturesNative(address); + String value = getRemoteDeviceProperty(address, "UUIDs"); + String[] uuids = null; + // The UUIDs are stored as a "," separated string. + if (value != null) + uuids = value.split(","); + return uuids; } - private native byte[] getRemoteFeaturesNative(String address); /** - * This method and {@link #getRemoteServiceRecord} query the SDP service - * on a remote device. They do not interpret the data, but simply return - * it raw to the user. To read more about SDP service handles and records, - * consult the Bluetooth core documentation (www.bluetooth.com). - * - * @param address Bluetooth address of remote device. - * @param match a String match to narrow down the service-handle search. - * The only supported value currently is "hsp" for the headset - * profile. To retrieve all service handles, simply pass an empty - * match string. + * Gets the rfcomm channel associated with the UUID. * - * @return all service handles corresponding to the string match. + * @param address Address of the remote device + * @param uuid UUID of the service attribute * - * @see #getRemoteServiceRecord + * @return rfcomm channel associated with the service attribute */ - public synchronized int[] getRemoteServiceHandles(String address, String match) { + public int getRemoteServiceChannel(String address, String uuid) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; - } - if (match == null) { - match = ""; + return BluetoothError.ERROR_IPC; } - return getRemoteServiceHandlesNative(address, match); + return getDeviceServiceChannelNative(getObjectPathFromAddress(address), uuid, 0x0004); } - private native int[] getRemoteServiceHandlesNative(String address, String match); - - /** - * This method retrieves the service records corresponding to a given - * service handle (method {@link #getRemoteServiceHandles} retrieves the - * service handles.) - * - * This method and {@link #getRemoteServiceHandles} do not interpret their - * data, but simply return it raw to the user. To read more about SDP - * service handles and records, consult the Bluetooth core documentation - * (www.bluetooth.com). - * - * @param address Bluetooth address of remote device. - * @param handle Service handle returned by {@link #getRemoteServiceHandles} - * - * @return a byte array of all service records corresponding to the - * specified service handle. - * - * @see #getRemoteServiceHandles - */ - public synchronized byte[] getRemoteServiceRecord(String address, int handle) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return null; - } - return getRemoteServiceRecordNative(address, handle); - } - private native byte[] getRemoteServiceRecordNative(String address, int handle); - - private static final int MAX_OUTSTANDING_ASYNC = 32; - - // AIDL does not yet support short's - public synchronized boolean getRemoteServiceChannel(String address, int uuid16, - IBluetoothDeviceCallback callback) { - mContext.enforceCallingOrSelfPermission(BLUETOOTH_PERM, "Need BLUETOOTH permission"); - if (!BluetoothDevice.checkBluetoothAddress(address)) { - return false; - } - HashMap<String, IBluetoothDeviceCallback> callbacks = - mEventLoop.getRemoteServiceChannelCallbacks(); - if (callbacks.containsKey(address)) { - Log.w(TAG, "SDP request already in progress for " + address); - return false; - } - // Protect from malicious clients - only allow 32 bonding requests per minute. - if (callbacks.size() > MAX_OUTSTANDING_ASYNC) { - Log.w(TAG, "Too many outstanding SDP requests, dropping request for " + address); - return false; - } - callbacks.put(address, callback); - - if (!getRemoteServiceChannelNative(address, (short)uuid16)) { - callbacks.remove(address); - return false; - } - return true; - } - private native boolean getRemoteServiceChannelNative(String address, short uuid16); public synchronized boolean setPin(String address, byte[] pin) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, @@ -1108,25 +968,56 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { } return setPinNative(address, pinString, data.intValue()); } - private native boolean setPinNative(String address, String pin, int nativeData); - public synchronized boolean cancelPin(String address) { + public synchronized boolean setPasskey(String address, int passkey) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, + "Need BLUETOOTH_ADMIN permission"); + if (passkey < 0 || passkey > 999999 || !BluetoothDevice.checkBluetoothAddress(address)) { + return false; + } + address = address.toUpperCase(); + Integer data = mEventLoop.getPasskeyAgentRequestData().remove(address); + if (data == null) { + Log.w(TAG, "setPasskey(" + address + ") called but no native data available, " + + "ignoring. Maybe the PasskeyAgent Request was cancelled by the remote device" + + " or by bluez.\n"); + return false; + } + return setPasskeyNative(address, passkey, data.intValue()); + } + + public synchronized boolean setPairingConfirmation(String address, boolean confirm) { + mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, + "Need BLUETOOTH_ADMIN permission"); + address = address.toUpperCase(); + Integer data = mEventLoop.getPasskeyAgentRequestData().remove(address); + if (data == null) { + Log.w(TAG, "setPasskey(" + address + ") called but no native data available, " + + "ignoring. Maybe the PasskeyAgent Request was cancelled by the remote device" + + " or by bluez.\n"); + return false; + } + return setPairingConfirmationNative(address, confirm, data.intValue()); + } + + public synchronized boolean cancelPairingUserInput(String address) { mContext.enforceCallingOrSelfPermission(BLUETOOTH_ADMIN_PERM, "Need BLUETOOTH_ADMIN permission"); if (!BluetoothDevice.checkBluetoothAddress(address)) { return false; } + mBondState.setBondState(address, BluetoothDevice.BOND_NOT_BONDED, + BluetoothDevice.UNBOND_REASON_AUTH_CANCELED); address = address.toUpperCase(); Integer data = mEventLoop.getPasskeyAgentRequestData().remove(address); if (data == null) { - Log.w(TAG, "cancelPin(" + address + ") called but no native data available, " + - "ignoring. Maybe the PasskeyAgent Request was already cancelled by the remote " + - "or by bluez.\n"); + Log.w(TAG, "cancelUserInputNative(" + address + ") called but no native data " + + "available, ignoring. Maybe the PasskeyAgent Request was already cancelled " + + "by the remote or by bluez.\n"); return false; } - return cancelPinNative(address, data.intValue()); + return cancelPairingUserInputNative(address, data.intValue()); } - private native boolean cancelPinNative(String address, int natveiData); private final BroadcastReceiver mReceiver = new BroadcastReceiver() { @Override @@ -1171,16 +1062,16 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { pw.println("\nmIsAirplaneSensitive = " + mIsAirplaneSensitive + "\n"); switch(mBluetoothState) { - case BluetoothDevice.BLUETOOTH_STATE_OFF: + case BluetoothAdapter.BLUETOOTH_STATE_OFF: pw.println("\nBluetooth OFF\n"); return; - case BluetoothDevice.BLUETOOTH_STATE_TURNING_ON: + case BluetoothAdapter.BLUETOOTH_STATE_TURNING_ON: pw.println("\nBluetooth TURNING ON\n"); return; - case BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF: + case BluetoothAdapter.BLUETOOTH_STATE_TURNING_OFF: pw.println("\nBluetooth TURNING OFF\n"); return; - case BluetoothDevice.BLUETOOTH_STATE_ON: + case BluetoothAdapter.BLUETOOTH_STATE_ON: pw.println("\nBluetooth ON\n"); } @@ -1190,20 +1081,22 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { BluetoothHeadset headset = new BluetoothHeadset(mContext, null); - String[] addresses = listRemoteDevices(); - pw.println("\n--Known devices--"); - for (String address : addresses) { + for (String address : mDeviceProperties.keySet()) { pw.printf("%s %10s (%d) %s\n", address, toBondStateString(mBondState.getBondState(address)), mBondState.getAttempt(address), getRemoteName(address)); } - addresses = listAclConnections(); + String value = getProperty("Devices"); + String []devicesObjectPath = null; + if (value != null) { + devicesObjectPath = value.split(","); + } pw.println("\n--ACL connected devices--"); - for (String address : addresses) { - pw.println(address); + for (String device : devicesObjectPath) { + pw.println(getAddressFromObjectPath(device)); } // Rather not do this from here, but no-where else and I need this @@ -1223,41 +1116,97 @@ public class BluetoothDeviceService extends IBluetoothDevice.Stub { pw.println("getState() = STATE_ERROR"); break; } - pw.println("getHeadsetAddress() = " + headset.getHeadsetAddress()); + pw.println("getCurrentHeadset() = " + headset.getCurrentHeadset()); pw.println("getBatteryUsageHint() = " + headset.getBatteryUsageHint()); headset.close(); } - /* package */ static int bluezStringToScanMode(String mode) { - if (mode == null) { - return BluetoothError.ERROR; - } - mode = mode.toLowerCase(); - if (mode.equals("off")) { - return BluetoothDevice.SCAN_MODE_NONE; - } else if (mode.equals("connectable")) { - return BluetoothDevice.SCAN_MODE_CONNECTABLE; - } else if (mode.equals("discoverable")) { - return BluetoothDevice.SCAN_MODE_CONNECTABLE_DISCOVERABLE; - } else { - return BluetoothError.ERROR; - } + /* package */ static int bluezStringToScanMode(boolean pairable, boolean discoverable) { + if (pairable && discoverable) + return BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE; + else if (pairable && !discoverable) + return BluetoothAdapter.SCAN_MODE_CONNECTABLE; + else + return BluetoothAdapter.SCAN_MODE_NONE; } /* package */ static String scanModeToBluezString(int mode) { switch (mode) { - case BluetoothDevice.SCAN_MODE_NONE: + case BluetoothAdapter.SCAN_MODE_NONE: return "off"; - case BluetoothDevice.SCAN_MODE_CONNECTABLE: + case BluetoothAdapter.SCAN_MODE_CONNECTABLE: return "connectable"; - case BluetoothDevice.SCAN_MODE_CONNECTABLE_DISCOVERABLE: + case BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE: return "discoverable"; } return null; } + /*package*/ String getAddressFromObjectPath(String objectPath) { + String adapterObjectPath = getProperty("ObjectPath"); + if (adapterObjectPath == null || objectPath == null) { + Log.e(TAG, "getAddressFromObjectPath: AdpaterObjectPath:" + adapterObjectPath + + " or deviceObjectPath:" + objectPath + " is null"); + return null; + } + if (!objectPath.startsWith(adapterObjectPath)) { + Log.e(TAG, "getAddressFromObjectPath: AdpaterObjectPath:" + adapterObjectPath + + " is not a prefix of deviceObjectPath:" + objectPath + + "bluetoothd crashed ?"); + return null; + } + String address = objectPath.substring(adapterObjectPath.length()); + if (address != null) return address.replace('_', ':'); + + Log.e(TAG, "getAddressFromObjectPath: Address being returned is null"); + return null; + } + + /*package*/ String getObjectPathFromAddress(String address) { + String path = getProperty("ObjectPath"); + if (path == null) { + Log.e(TAG, "Error: Object Path is null"); + return null; + } + path = path + address.replace(":", "_"); + return path; + } + private static void log(String msg) { Log.d(TAG, msg); } + + private native static void classInitNative(); + private native void initializeNativeDataNative(); + private native boolean setupNativeDataNative(); + private native boolean tearDownNativeDataNative(); + private native void cleanupNativeDataNative(); + private native String getAdapterPathNative(); + + private native int isEnabledNative(); + private native int enableNative(); + private native int disableNative(); + + private native Object[] getAdapterPropertiesNative(); + private native Object[] getDevicePropertiesNative(String objectPath); + private native boolean setAdapterPropertyStringNative(String key, String value); + private native boolean setAdapterPropertyIntegerNative(String key, int value); + private native boolean setAdapterPropertyBooleanNative(String key, int value); + + private native boolean startDiscoveryNative(); + private native boolean stopDiscoveryNative(); + + private native boolean createPairedDeviceNative(String address, int timeout_ms); + private native boolean cancelDeviceCreationNative(String address); + private native boolean removeDeviceNative(String objectPath); + private native int getDeviceServiceChannelNative(String objectPath, String uuid, + int attributeId); + + private native boolean cancelPairingUserInputNative(String address, int nativeData); + private native boolean setPinNative(String address, String pin, int nativeData); + private native boolean setPasskeyNative(String address, int passkey, int nativeData); + private native boolean setPairingConfirmationNative(String address, boolean confirm, + int nativeData); + } diff --git a/core/java/android/server/search/SearchDialogWrapper.java b/core/java/android/server/search/SearchDialogWrapper.java index 49718cb..9ee64af 100644 --- a/core/java/android/server/search/SearchDialogWrapper.java +++ b/core/java/android/server/search/SearchDialogWrapper.java @@ -58,6 +58,7 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { // data[KEY_INITIAL_QUERY]: initial query // data[KEY_LAUNCH_ACTIVITY]: launch activity // data[KEY_APP_SEARCH_DATA]: app search data + // data[KEY_TRIGGER]: 0 = false, 1 = true private static final int MSG_START_SEARCH = 1; // Takes no arguments private static final int MSG_STOP_SEARCH = 2; @@ -69,7 +70,8 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { private static final String KEY_INITIAL_QUERY = "q"; private static final String KEY_LAUNCH_ACTIVITY = "a"; private static final String KEY_APP_SEARCH_DATA = "d"; - private static final String KEY_IDENT= "i"; + private static final String KEY_IDENT = "i"; + private static final String KEY_TRIGGER = "t"; // Context used for getting search UI resources private final Context mContext; @@ -173,7 +175,8 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { final Bundle appSearchData, final boolean globalSearch, final ISearchManagerCallback searchManagerCallback, - int ident) { + int ident, + boolean trigger) { if (DBG) debug("startSearch()"); Message msg = Message.obtain(); msg.what = MSG_START_SEARCH; @@ -185,6 +188,7 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { msgData.putParcelable(KEY_LAUNCH_ACTIVITY, launchActivity); msgData.putBundle(KEY_APP_SEARCH_DATA, appSearchData); msgData.putInt(KEY_IDENT, ident); + msgData.putInt(KEY_TRIGGER, trigger ? 1 : 0); mSearchUiThread.sendMessage(msg); // be a little more eager in setting this so isVisible will return the correct value if // called immediately after startSearch @@ -268,8 +272,9 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { boolean globalSearch = msg.arg2 != 0; ISearchManagerCallback searchManagerCallback = (ISearchManagerCallback) msg.obj; int ident = msgData.getInt(KEY_IDENT); + boolean trigger = msgData.getInt(KEY_TRIGGER) != 0; performStartSearch(initialQuery, selectInitialQuery, launchActivity, - appSearchData, globalSearch, searchManagerCallback, ident); + appSearchData, globalSearch, searchManagerCallback, ident, trigger); } } @@ -284,7 +289,8 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { Bundle appSearchData, boolean globalSearch, ISearchManagerCallback searchManagerCallback, - int ident) { + int ident, + boolean trigger) { if (DBG) debug("performStartSearch()"); registerBroadcastReceiver(); @@ -301,6 +307,9 @@ implements DialogInterface.OnCancelListener, DialogInterface.OnDismissListener { mSearchDialog.show(initialQuery, selectInitialQuery, launchActivity, appSearchData, globalSearch); mVisible = true; + if (trigger) { + mSearchDialog.launchQuerySearch(); + } } /** diff --git a/core/java/android/server/search/SearchManagerService.java b/core/java/android/server/search/SearchManagerService.java index afed4a4..5e0b3d2 100644 --- a/core/java/android/server/search/SearchManagerService.java +++ b/core/java/android/server/search/SearchManagerService.java @@ -233,7 +233,31 @@ public class SearchManagerService extends ISearchManager.Stub { appSearchData, globalSearch, searchManagerCallback, - ident); + ident, + false); // don't trigger + } + + /** + * Launches the search UI and triggers the search, as if the user had clicked on the + * search button within the dialog. + * + * @see SearchManager#triggerSearch(String, android.content.ComponentName, android.os.Bundle) + */ + public void triggerSearch(String query, + ComponentName launchActivity, + Bundle appSearchData, + ISearchManagerCallback searchManagerCallback, + boolean globalSearch, + int ident) { + getSearchDialog().startSearch( + query, + false, + launchActivity, + appSearchData, + globalSearch, + searchManagerCallback, + ident, + true); // triger search after launching } /** diff --git a/core/java/android/service/wallpaper/IWallpaperConnection.aidl b/core/java/android/service/wallpaper/IWallpaperConnection.aidl new file mode 100644 index 0000000..b09ccab --- /dev/null +++ b/core/java/android/service/wallpaper/IWallpaperConnection.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2009 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.service.wallpaper; + +import android.os.ParcelFileDescriptor; +import android.service.wallpaper.IWallpaperEngine; + +/** + * @hide + */ +interface IWallpaperConnection { + void attachEngine(IWallpaperEngine engine); + ParcelFileDescriptor setWallpaper(String name); +} diff --git a/core/java/android/service/wallpaper/IWallpaperEngine.aidl b/core/java/android/service/wallpaper/IWallpaperEngine.aidl new file mode 100644 index 0000000..9586e34 --- /dev/null +++ b/core/java/android/service/wallpaper/IWallpaperEngine.aidl @@ -0,0 +1,24 @@ +/* + * Copyright (C) 2009 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.service.wallpaper; + +/** + * @hide + */ +oneway interface IWallpaperEngine { + void destroy(); +} diff --git a/core/java/android/service/wallpaper/IWallpaperService.aidl b/core/java/android/service/wallpaper/IWallpaperService.aidl new file mode 100644 index 0000000..bc7a1d7 --- /dev/null +++ b/core/java/android/service/wallpaper/IWallpaperService.aidl @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2009 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.service.wallpaper; + +import android.service.wallpaper.IWallpaperConnection; + +/** + * @hide + */ +oneway interface IWallpaperService { + void attach(IWallpaperConnection connection, + IBinder windowToken, int windowType, boolean isPreview, + int reqWidth, int reqHeight); +} diff --git a/core/java/android/service/wallpaper/WallpaperService.java b/core/java/android/service/wallpaper/WallpaperService.java new file mode 100644 index 0000000..629e97e --- /dev/null +++ b/core/java/android/service/wallpaper/WallpaperService.java @@ -0,0 +1,600 @@ +/* + * Copyright (C) 2009 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.service.wallpaper; + +import com.android.internal.os.HandlerCaller; +import com.android.internal.view.BaseIWindow; +import com.android.internal.view.BaseSurfaceHolder; + +import android.app.Service; +import android.app.WallpaperManager; +import android.content.Intent; +import android.graphics.Rect; +import android.os.IBinder; +import android.os.Message; +import android.os.RemoteException; +import android.util.Log; +import android.view.Gravity; +import android.view.IWindowSession; +import android.view.MotionEvent; +import android.view.SurfaceHolder; +import android.view.View; +import android.view.ViewGroup; +import android.view.ViewRoot; +import android.view.WindowManager; +import android.view.WindowManagerImpl; + +/** + * A wallpaper service is responsible for showing a live wallpaper behind + * applications that would like to sit on top of it. + * @hide Live Wallpaper + */ +public abstract class WallpaperService extends Service { + /** + * The {@link Intent} that must be declared as handled by the service. + */ + public static final String SERVICE_INTERFACE = + "android.service.wallpaper.WallpaperService"; + + static final String TAG = "WallpaperService"; + static final boolean DEBUG = false; + + private static final int DO_ATTACH = 10; + private static final int DO_DETACH = 20; + + private static final int MSG_UPDATE_SURFACE = 10000; + private static final int MSG_VISIBILITY_CHANGED = 10010; + private static final int MSG_WALLPAPER_OFFSETS = 10020; + private static final int MSG_WINDOW_RESIZED = 10030; + private static final int MSG_TOUCH_EVENT = 10040; + + /** + * The actual implementation of a wallpaper. A wallpaper service may + * have multiple instances running (for example as a real wallpaper + * and as a preview), each of which is represented by its own Engine + * instance. You must implement {@link WallpaperService#onCreateEngine()} + * to return your concrete Engine implementation. + */ + public class Engine { + IWallpaperEngineWrapper mIWallpaperEngine; + + // Copies from mIWallpaperEngine. + HandlerCaller mCaller; + IWallpaperConnection mConnection; + IBinder mWindowToken; + + boolean mInitializing = true; + + // Current window state. + boolean mCreated; + boolean mIsCreating; + boolean mDrawingAllowed; + int mWidth; + int mHeight; + int mFormat; + int mType; + int mCurWidth; + int mCurHeight; + int mWindowFlags = WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; + int mCurWindowFlags = mWindowFlags; + boolean mDestroyReportNeeded; + final Rect mVisibleInsets = new Rect(); + final Rect mWinFrame = new Rect(); + final Rect mContentInsets = new Rect(); + + final WindowManager.LayoutParams mLayout + = new WindowManager.LayoutParams(); + IWindowSession mSession; + + final Object mLock = new Object(); + boolean mOffsetMessageEnqueued; + float mPendingXOffset; + float mPendingYOffset; + MotionEvent mPendingMove; + + final BaseSurfaceHolder mSurfaceHolder = new BaseSurfaceHolder() { + + @Override + public boolean onAllowLockCanvas() { + return mDrawingAllowed; + } + + @Override + public void onRelayoutContainer() { + Message msg = mCaller.obtainMessage(MSG_UPDATE_SURFACE); + mCaller.sendMessage(msg); + } + + @Override + public void onUpdateSurface() { + Message msg = mCaller.obtainMessage(MSG_UPDATE_SURFACE); + mCaller.sendMessage(msg); + } + + public boolean isCreating() { + return mIsCreating; + } + + public void setKeepScreenOn(boolean screenOn) { + // Ignore. + } + + }; + + final BaseIWindow mWindow = new BaseIWindow() { + @Override + public boolean onDispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { + synchronized (mLock) { + if (event.getAction() == MotionEvent.ACTION_MOVE) { + if (mPendingMove != null) { + mCaller.removeMessages(MSG_TOUCH_EVENT, mPendingMove); + mPendingMove.recycle(); + } + mPendingMove = event; + } else { + mPendingMove = null; + } + Message msg = mCaller.obtainMessageO(MSG_TOUCH_EVENT, + event); + mCaller.sendMessage(msg); + } + return false; + } + + @Override + public void resized(int w, int h, Rect coveredInsets, + Rect visibleInsets, boolean reportDraw) { + Message msg = mCaller.obtainMessageI(MSG_WINDOW_RESIZED, + reportDraw ? 1 : 0); + mCaller.sendMessage(msg); + } + + @Override + public void dispatchAppVisibility(boolean visible) { + Message msg = mCaller.obtainMessageI(MSG_VISIBILITY_CHANGED, + visible ? 1 : 0); + mCaller.sendMessage(msg); + } + + @Override + public void dispatchWallpaperOffsets(float x, float y) { + synchronized (mLock) { + mPendingXOffset = x; + mPendingYOffset = y; + if (!mOffsetMessageEnqueued) { + mOffsetMessageEnqueued = true; + Message msg = mCaller.obtainMessage(MSG_WALLPAPER_OFFSETS); + mCaller.sendMessage(msg); + } + } + } + + }; + + /** + * Provides access to the surface in which this wallpaper is drawn. + */ + public SurfaceHolder getSurfaceHolder() { + return mSurfaceHolder; + } + + /** + * Convenience for {@link WallpaperManager#getDesiredMinimumWidth() + * WallpaperManager.getDesiredMinimumWidth()}, returning the width + * that the system would like this wallpaper to run in. + */ + public int getDesiredMinimumWidth() { + return mIWallpaperEngine.mReqWidth; + } + + /** + * Convenience for {@link WallpaperManager#getDesiredMinimumHeight() + * WallpaperManager.getDesiredMinimumHeight()}, returning the height + * that the system would like this wallpaper to run in. + */ + public int getDesiredMinimumHeight() { + return mIWallpaperEngine.mReqHeight; + } + + /** + * Returns true if this engine is running in preview mode -- that is, + * it is being shown to the user before they select it as the actual + * wallpaper. + */ + public boolean isPreview() { + return mIWallpaperEngine.mIsPreview; + } + + /** + * Control whether this wallpaper will receive raw touch events + * from the window manager as the user interacts with the window + * that is currently displaying the wallpaper. By default they + * are turned off. If enabled, the events will be received in + * {@link #onTouchEvent(MotionEvent)}. + */ + public void setTouchEventsEnabled(boolean enabled) { + mWindowFlags = enabled + ? (mWindowFlags&~WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE) + : (mWindowFlags|WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE); + if (mCreated) { + updateSurface(false, false); + } + } + + /** + * Called once to initialize the engine. After returning, the + * engine's surface will be created by the framework. + */ + public void onCreate(SurfaceHolder surfaceHolder) { + } + + /** + * Called right before the engine is going away. After this the + * surface will be destroyed and this Engine object is no longer + * valid. + */ + public void onDestroy() { + } + + /** + * Called to inform you of the wallpaper becoming visible or + * hidden. <em>It is very important that a wallpaper only use + * CPU while it is visible.</em>. + */ + public void onVisibilityChanged(boolean visible) { + } + + /** + * Called as the user performs touch-screen interaction with the + * window that is currently showing this wallpaper. Note that the + * events you receive here are driven by the actual application the + * user is interacting with, so if it is slow you will get viewer + * move events. + */ + public void onTouchEvent(MotionEvent event) { + } + + /** + * Called to inform you of the wallpaper's offsets changing + * within its contain, corresponding to the container's + * call to {@link WallpaperManager#setWallpaperOffsets(IBinder, float, float) + * WallpaperManager.setWallpaperOffsets()}. + */ + public void onOffsetsChanged(float xOffset, float yOffset, + int xPixelOffset, int yPixelOffset) { + } + + /** + * Convenience for {@link SurfaceHolder.Callback#surfaceChanged + * SurfaceHolder.Callback.surfaceChanged()}. + */ + public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) { + } + + /** + * Convenience for {@link SurfaceHolder.Callback#surfaceCreated + * SurfaceHolder.Callback.surfaceCreated()}. + */ + public void onSurfaceCreated(SurfaceHolder holder) { + } + + /** + * Convenience for {@link SurfaceHolder.Callback#surfaceDestroyed + * SurfaceHolder.Callback.surfaceDestroyed()}. + */ + public void onSurfaceDestroyed(SurfaceHolder holder) { + } + + void updateSurface(boolean forceRelayout, boolean forceReport) { + int myWidth = mSurfaceHolder.getRequestedWidth(); + if (myWidth <= 0) myWidth = ViewGroup.LayoutParams.FILL_PARENT; + int myHeight = mSurfaceHolder.getRequestedHeight(); + if (myHeight <= 0) myHeight = ViewGroup.LayoutParams.FILL_PARENT; + + final boolean creating = !mCreated; + final boolean formatChanged = mFormat != mSurfaceHolder.getRequestedFormat(); + boolean sizeChanged = mWidth != myWidth || mHeight != myHeight; + final boolean typeChanged = mType != mSurfaceHolder.getRequestedType(); + final boolean flagsChanged = mCurWindowFlags != mWindowFlags; + if (forceRelayout || creating || formatChanged || sizeChanged + || typeChanged || flagsChanged) { + + if (DEBUG) Log.i(TAG, "Changes: creating=" + creating + + " format=" + formatChanged + " size=" + sizeChanged); + + try { + mWidth = myWidth; + mHeight = myHeight; + mFormat = mSurfaceHolder.getRequestedFormat(); + mType = mSurfaceHolder.getRequestedType(); + + mLayout.x = 0; + mLayout.y = 0; + mLayout.width = myWidth; + mLayout.height = myHeight; + + mLayout.format = mFormat; + + mCurWindowFlags = mWindowFlags; + mLayout.flags = mWindowFlags + | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS + | WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN + | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE + ; + + mLayout.memoryType = mType; + mLayout.token = mWindowToken; + + if (!mCreated) { + mLayout.type = mIWallpaperEngine.mWindowType; + mLayout.gravity = Gravity.LEFT|Gravity.TOP; + mSession.add(mWindow, mLayout, View.VISIBLE, mContentInsets); + } + + mSurfaceHolder.mSurfaceLock.lock(); + mDrawingAllowed = true; + + final int relayoutResult = mSession.relayout( + mWindow, mLayout, mWidth, mHeight, + View.VISIBLE, false, mWinFrame, mContentInsets, + mVisibleInsets, mSurfaceHolder.mSurface); + + if (DEBUG) Log.i(TAG, "New surface: " + mSurfaceHolder.mSurface + + ", frame=" + mWinFrame); + + int w = mWinFrame.width(); + if (mCurWidth != w) { + sizeChanged = true; + mCurWidth = w; + } + int h = mWinFrame.height(); + if (mCurHeight != h) { + sizeChanged = true; + mCurHeight = h; + } + + mSurfaceHolder.mSurfaceLock.unlock(); + + try { + mDestroyReportNeeded = true; + + SurfaceHolder.Callback callbacks[] = null; + synchronized (mSurfaceHolder.mCallbacks) { + final int N = mSurfaceHolder.mCallbacks.size(); + if (N > 0) { + callbacks = new SurfaceHolder.Callback[N]; + mSurfaceHolder.mCallbacks.toArray(callbacks); + } + } + + if (!mCreated) { + mIsCreating = true; + onSurfaceCreated(mSurfaceHolder); + if (callbacks != null) { + for (SurfaceHolder.Callback c : callbacks) { + c.surfaceCreated(mSurfaceHolder); + } + } + } + if (forceReport || creating || formatChanged || sizeChanged) { + if (DEBUG) { + RuntimeException e = new RuntimeException(); + e.fillInStackTrace(); + Log.w(TAG, "forceReport=" + forceReport + " creating=" + creating + + " formatChanged=" + formatChanged + + " sizeChanged=" + sizeChanged, e); + } + onSurfaceChanged(mSurfaceHolder, mFormat, + mCurWidth, mCurHeight); + if (callbacks != null) { + for (SurfaceHolder.Callback c : callbacks) { + c.surfaceChanged(mSurfaceHolder, mFormat, + mCurWidth, mCurHeight); + } + } + } + } finally { + mIsCreating = false; + mCreated = true; + if (creating || (relayoutResult&WindowManagerImpl.RELAYOUT_FIRST_TIME) != 0) { + mSession.finishDrawing(mWindow); + } + } + } catch (RemoteException ex) { + } + if (DEBUG) Log.v( + TAG, "Layout: x=" + mLayout.x + " y=" + mLayout.y + + " w=" + mLayout.width + " h=" + mLayout.height); + } + } + + void attach(IWallpaperEngineWrapper wrapper) { + if (DEBUG) Log.v(TAG, "attach: " + this + " wrapper=" + wrapper); + mIWallpaperEngine = wrapper; + mCaller = wrapper.mCaller; + mConnection = wrapper.mConnection; + mWindowToken = wrapper.mWindowToken; + // XXX temp -- should run in size from layout (screen) mode. + mSurfaceHolder.setFixedSize(mIWallpaperEngine.mReqWidth, + mIWallpaperEngine.mReqHeight); + //mSurfaceHolder.setSizeFromLayout(); + mInitializing = true; + mSession = ViewRoot.getWindowSession(getMainLooper()); + mWindow.setSession(mSession); + + onCreate(mSurfaceHolder); + + mInitializing = false; + updateSurface(false, false); + } + + void detach() { + onDestroy(); + if (mDestroyReportNeeded) { + mDestroyReportNeeded = false; + SurfaceHolder.Callback callbacks[]; + synchronized (mSurfaceHolder.mCallbacks) { + callbacks = new SurfaceHolder.Callback[ + mSurfaceHolder.mCallbacks.size()]; + mSurfaceHolder.mCallbacks.toArray(callbacks); + } + for (SurfaceHolder.Callback c : callbacks) { + c.surfaceDestroyed(mSurfaceHolder); + } + } + if (mCreated) { + try { + mSession.remove(mWindow); + } catch (RemoteException e) { + } + mSurfaceHolder.mSurface.clear(); + mCreated = false; + } + } + } + + class IWallpaperEngineWrapper extends IWallpaperEngine.Stub + implements HandlerCaller.Callback { + private final HandlerCaller mCaller; + + final IWallpaperConnection mConnection; + final IBinder mWindowToken; + final int mWindowType; + final boolean mIsPreview; + int mReqWidth; + int mReqHeight; + + Engine mEngine; + + IWallpaperEngineWrapper(WallpaperService context, + IWallpaperConnection conn, IBinder windowToken, + int windowType, boolean isPreview, int reqWidth, int reqHeight) { + mCaller = new HandlerCaller(context, this); + mConnection = conn; + mWindowToken = windowToken; + mWindowType = windowType; + mIsPreview = isPreview; + mReqWidth = reqWidth; + mReqHeight = reqHeight; + + try { + conn.attachEngine(this); + } catch (RemoteException e) { + destroy(); + } + + Message msg = mCaller.obtainMessage(DO_ATTACH); + mCaller.sendMessage(msg); + } + + public void destroy() { + Message msg = mCaller.obtainMessage(DO_DETACH); + mCaller.sendMessage(msg); + } + + public void executeMessage(Message message) { + switch (message.what) { + case DO_ATTACH: { + Engine engine = onCreateEngine(); + mEngine = engine; + engine.attach(this); + return; + } + case DO_DETACH: { + mEngine.detach(); + return; + } + case MSG_UPDATE_SURFACE: + mEngine.updateSurface(true, false); + break; + case MSG_VISIBILITY_CHANGED: + if (DEBUG) Log.v(TAG, "Visibility change in " + mEngine + + ": " + message.arg1); + mEngine.onVisibilityChanged(message.arg1 != 0); + break; + case MSG_WALLPAPER_OFFSETS: { + float xOffset; + float yOffset; + synchronized (mEngine.mLock) { + xOffset = mEngine.mPendingXOffset; + yOffset = mEngine.mPendingYOffset; + mEngine.mOffsetMessageEnqueued = false; + } + if (DEBUG) Log.v(TAG, "Offsets change in " + mEngine + + ": " + xOffset + "," + yOffset); + final int availw = mReqWidth-mEngine.mCurWidth; + final int xPixels = availw > 0 ? -(int)(availw*xOffset+.5f) : 0; + final int availh = mReqHeight-mEngine.mCurHeight; + final int yPixels = availh > 0 ? -(int)(availh*yOffset+.5f) : 0; + mEngine.onOffsetsChanged(xOffset, yOffset, xPixels, yPixels); + } break; + case MSG_WINDOW_RESIZED: { + final boolean reportDraw = message.arg1 != 0; + mEngine.updateSurface(true, false); + if (reportDraw) { + try { + mEngine.mSession.finishDrawing(mEngine.mWindow); + } catch (RemoteException e) { + } + } + } break; + case MSG_TOUCH_EVENT: { + MotionEvent ev = (MotionEvent)message.obj; + synchronized (mEngine.mLock) { + if (mEngine.mPendingMove == ev) { + mEngine.mPendingMove = null; + } + } + mEngine.onTouchEvent(ev); + ev.recycle(); + } break; + default : + Log.w(TAG, "Unknown message type " + message.what); + } + } + } + + /** + * Implements the internal {@link IWallpaperService} interface to convert + * incoming calls to it back to calls on an {@link WallpaperService}. + */ + class IWallpaperServiceWrapper extends IWallpaperService.Stub { + private final WallpaperService mTarget; + + public IWallpaperServiceWrapper(WallpaperService context) { + mTarget = context; + } + + public void attach(IWallpaperConnection conn, IBinder windowToken, + int windowType, boolean isPreview, int reqWidth, int reqHeight) { + new IWallpaperEngineWrapper(mTarget, conn, windowToken, + windowType, isPreview, reqWidth, reqHeight); + } + } + + /** + * Implement to return the implementation of the internal accessibility + * service interface. Subclasses should not override. + */ + @Override + public final IBinder onBind(Intent intent) { + return new IWallpaperServiceWrapper(this); + } + + public abstract Engine onCreateEngine(); +} diff --git a/core/java/android/speech/IRecognitionListener.aidl b/core/java/android/speech/IRecognitionListener.aidl deleted file mode 100644 index 2da2258..0000000 --- a/core/java/android/speech/IRecognitionListener.aidl +++ /dev/null @@ -1,60 +0,0 @@ -/* - * Copyright (C) 2009 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.speech; - -import android.os.Bundle; -import android.speech.RecognitionResult; - -/** - * Listener for speech recognition events, used with RecognitionService. - * This gives you both the final recognition results, as well as various - * intermediate events that can be used to show visual feedback to the user. - * {@hide} - */ -interface IRecognitionListener { - /** Called when the endpointer is ready for the user to start speaking. */ - void onReadyForSpeech(in Bundle noiseParams); - - /** The user has started to speak. */ - void onBeginningOfSpeech(); - - /** The sound level in the audio stream has changed. */ - void onRmsChanged(in float rmsdB); - - /** - * More sound has been received. Buffer is a byte buffer containing - * a sequence of 16-bit shorts. - */ - void onBufferReceived(in byte[] buffer); - - /** Called after the user stops speaking. */ - void onEndOfSpeech(); - - /** - * A network or recognition error occurred. The code is defined in - * {@link android.speech.RecognitionResult} - */ - void onError(in int error); - - /** - * Called when recognition results are ready. - * @param results: an ordered list of the most likely results (N-best list). - * @param key: a key associated with the results. The same results can - * be retrieved asynchronously later using the key, if available. - */ - void onResults(in List<RecognitionResult> results, long key); -} diff --git a/core/java/android/speech/IRecognitionService.aidl b/core/java/android/speech/IRecognitionService.aidl deleted file mode 100644 index a18c380..0000000 --- a/core/java/android/speech/IRecognitionService.aidl +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (C) 2009 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.speech; - -import android.content.Intent; -import android.speech.IRecognitionListener; -import android.speech.RecognitionResult; - -// A Service interface to speech recognition. Call startListening when -// you want to begin capturing audio; RecognitionService will automatically -// determine when the user has finished speaking, stream the audio to the -// recognition servers, and notify you when results are ready. -/** {@hide} */ -interface IRecognitionService { - // Start listening for speech. Can only call this from one thread at once. - // see RecognizerIntent.java for constants used to specify the intent. - void startListening(in Intent recognizerIntent, - in IRecognitionListener listener); - - List<RecognitionResult> getRecognitionResults(in long key); - - void cancel(); -} diff --git a/core/java/android/speech/RecognitionResult.java b/core/java/android/speech/RecognitionResult.java deleted file mode 100644 index 978106b..0000000 --- a/core/java/android/speech/RecognitionResult.java +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (C) 2008 Google Inc. - * - * 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.speech; - -import android.os.Parcel; -import android.os.Parcelable; - -/** - * RecognitionResult is a passive object that stores a single recognized - * query and its search result. - * TODO: revisit and improve. May be we should have a separate result - * object for each type, and put them (type/value) in bundle? - * - * {@hide} - */ -public class RecognitionResult implements Parcelable { - /** - * Status of the recognize request. - */ - public static final int NETWORK_TIMEOUT = 1; // Network operation timed out. - public static final int NETWORK_ERROR = 2; // Other networkrelated errors. - public static final int AUDIO_ERROR = 3; // Audio recording error. - public static final int SERVER_ERROR = 4; // Server sends error status. - public static final int CLIENT_ERROR = 5; // Other client side errors. - public static final int SPEECH_TIMEOUT = 6; // No speech input - public static final int NO_MATCH = 7; // No recognition result matched. - public static final int SERVICE_BUSY = 8; // RecognitionService busy. - - /** - * Type of the recognition results. - */ - public static final int RAW_RECOGNITION_RESULT = 0; - public static final int WEB_SEARCH_RESULT = 1; - public static final int CONTACT_RESULT = 2; - - /** - * A factory method to create a raw RecognitionResult - * - * @param sentence the recognized text. - */ - public static RecognitionResult newRawRecognitionResult(String sentence) { - return new RecognitionResult(RAW_RECOGNITION_RESULT, sentence, null, null); - } - - /** - * A factory method to create RecognitionResult for contacts. - * - * @param contact the contact name. - * @param phoneType the phone type. - * @param callAction whether this result included a command to "call", or just the contact name. - */ - public static RecognitionResult newContactResult(String contact, int phoneType, - boolean callAction) { - return new RecognitionResult(CONTACT_RESULT, contact, phoneType, callAction); - } - - /** - * A factory method to create a RecognitionResult for Web Search Query. - * - * @param query the query string. - * @param html the html page of the search result. - * @param url the url that performs the search with the query. - */ - public static RecognitionResult newWebResult(String query, String html, String url) { - return new RecognitionResult(WEB_SEARCH_RESULT, query, html, url); - } - - public static final Parcelable.Creator<RecognitionResult> CREATOR - = new Parcelable.Creator<RecognitionResult>() { - - public RecognitionResult createFromParcel(Parcel in) { - return new RecognitionResult(in); - } - - public RecognitionResult[] newArray(int size) { - return new RecognitionResult[size]; - } - }; - - /** - * Result type. - */ - public final int mResultType; - - /** - * The recognized string when mResultType is WEB_SEARCH_RESULT. - * The name of the contact when mResultType is CONTACT_RESULT. - */ - public final String mText; - - /** - * The HTML result page for the query. If this is null, then the - * application must use the url field to get the HTML result page. - */ - public final String mHtml; - - /** - * The url to get the result page for the query string. The - * application must use this url instead of performing the search - * with the query. - */ - public final String mUrl; - - /** - * Phone number type. This is valid only when mResultType == CONTACT_RESULT. - */ - public final int mPhoneType; - - /** - * Whether a contact recognition result included a command to "call". This is valid only - * when mResultType == CONTACT_RESULT. - */ - public final boolean mCallAction; - - private RecognitionResult(int type, String query, String html, String url) { - mResultType = type; - mText = query; - mHtml = html; - mUrl = url; - mPhoneType = -1; - mCallAction = false; - } - - private RecognitionResult(int type, String query, int phoneType, boolean callAction) { - mResultType = type; - mText = query; - mPhoneType = phoneType; - mHtml = null; - mUrl = null; - mCallAction = callAction; - } - - private RecognitionResult(Parcel in) { - mResultType = in.readInt(); - mText = in.readString(); - mHtml= in.readString(); - mUrl= in.readString(); - mPhoneType = in.readInt(); - mCallAction = (in.readInt() == 1); - } - - public void writeToParcel(Parcel out, int flags) { - out.writeInt(mResultType); - out.writeString(mText); - out.writeString(mHtml); - out.writeString(mUrl); - out.writeInt(mPhoneType); - out.writeInt(mCallAction ? 1 : 0); - } - - - @Override - public String toString() { - String resultType[] = { "RAW", "WEB", "CONTACT" }; - return "[type=" + resultType[mResultType] + - ", text=" + mText+ ", mUrl=" + mUrl + ", html=" + mHtml + "]"; - } - - public int describeContents() { - // no special description - return 0; - } -} diff --git a/core/java/android/speech/RecognitionServiceUtil.java b/core/java/android/speech/RecognitionServiceUtil.java deleted file mode 100644 index a8c7868..0000000 --- a/core/java/android/speech/RecognitionServiceUtil.java +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2009 Google Inc. - * - * 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.speech; - -import android.content.ComponentName; -import android.content.Intent; -import android.content.ServiceConnection; -import android.os.Bundle; -import android.os.IBinder; -import android.os.RemoteException; -import android.speech.RecognitionResult; -import android.util.Log; - -import java.util.List; - -/** - * Utils for Google's network-based speech recognizer, which lets you perform - * speech-to-text translation through RecognitionService. IRecognitionService - * and IRecognitionListener are the core interfaces; you begin recognition - * through IRecognitionService and subscribe to callbacks about when the user - * stopped speaking, results come in, errors, etc. through IRecognitionListener. - * RecognitionServiceUtil includes default IRecognitionListener and - * ServiceConnection implementations to reduce the amount of boilerplate. - * - * The Service provides no user interface. See RecognitionActivity if you - * want the standard voice search UI. - * - * Below is a small skeleton of how to use the recognizer: - * - * ServiceConnection conn = new RecognitionServiceUtil.Connection(); - * mContext.bindService(RecognitionServiceUtil.sDefaultIntent, - * conn, Context.BIND_AUTO_CREATE); - * IRecognitionListener listener = new RecognitionServiceWrapper.NullListener() { - * public void onResults(List<String> results) { - * // Do something with recognition transcripts - * } - * } - * - * // Must wait for conn.mService to be populated, then call below - * conn.mService.startListening(null, listener); - * - * {@hide} - */ -public class RecognitionServiceUtil { - public static final Intent sDefaultIntent = new Intent( - RecognizerIntent.ACTION_RECOGNIZE_SPEECH); - - // Recognize request parameters - public static final String USE_LOCATION = "useLocation"; - public static final String CONTACT_AUTH_TOKEN = "contactAuthToken"; - - // Bundles - public static final String NOISE_LEVEL = "NoiseLevel"; - public static final String SIGNAL_NOISE_RATIO = "SignalNoiseRatio"; - - private RecognitionServiceUtil() {} - - /** - * IRecognitionListener which does nothing in response to recognition - * callbacks. You can subclass from this and override only the methods - * whose events you want to respond to. - */ - public static class NullListener extends IRecognitionListener.Stub { - public void onReadyForSpeech(Bundle bundle) {} - public void onBeginningOfSpeech() {} - public void onRmsChanged(float rmsdB) {} - public void onBufferReceived(byte[] buf) {} - public void onEndOfSpeech() {} - public void onError(int error) {} - public void onResults(List<RecognitionResult> results, long key) {} - } - - /** - * Basic ServiceConnection which just records mService variable. - */ - public static class Connection implements ServiceConnection { - public IRecognitionService mService; - - public synchronized void onServiceConnected(ComponentName name, IBinder service) { - mService = IRecognitionService.Stub.asInterface(service); - } - - public void onServiceDisconnected(ComponentName name) { - mService = null; - } - } -} diff --git a/core/java/android/syncml/pim/vcard/ContactStruct.java b/core/java/android/syncml/pim/vcard/ContactStruct.java index ecd719d..4b4c394 100644 --- a/core/java/android/syncml/pim/vcard/ContactStruct.java +++ b/core/java/android/syncml/pim/vcard/ContactStruct.java @@ -17,6 +17,7 @@ package android.syncml.pim.vcard; import android.content.AbstractSyncableContentProvider; +import android.content.ContentProviderOperation; import android.content.ContentResolver; import android.content.ContentUris; import android.content.ContentValues; @@ -780,17 +781,16 @@ public class ContactStruct { personId = ContentUris.parseId(personUri); } } else { - personUri = provider.nonTransactionalInsert(People.CONTENT_URI, contentValues); + personUri = provider.insert(People.CONTENT_URI, contentValues); if (personUri != null) { personId = ContentUris.parseId(personUri); ContentValues values = new ContentValues(); values.put(GroupMembership.PERSON_ID, personId); values.put(GroupMembership.GROUP_ID, myContactsGroupId); - Uri resultUri = provider.nonTransactionalInsert( - GroupMembership.CONTENT_URI, values); + Uri resultUri = provider.insert(GroupMembership.CONTENT_URI, values); if (resultUri == null) { Log.e(LOG_TAG, "Faild to insert the person to MyContact."); - provider.nonTransactionalDelete(personUri, null, null); + provider.delete(personUri, null, null); personUri = null; } } @@ -830,7 +830,7 @@ public class ContactStruct { if (resolver != null) { phoneUri = resolver.insert(Phones.CONTENT_URI, values); } else { - phoneUri = provider.nonTransactionalInsert(Phones.CONTENT_URI, values); + phoneUri = provider.insert(Phones.CONTENT_URI, values); } if (phoneData.isPrimary) { primaryPhoneId = Long.parseLong(phoneUri.getLastPathSegment()); @@ -856,8 +856,7 @@ public class ContactStruct { if (resolver != null) { organizationUri = resolver.insert(Organizations.CONTENT_URI, values); } else { - organizationUri = provider.nonTransactionalInsert( - Organizations.CONTENT_URI, values); + organizationUri = provider.insert(Organizations.CONTENT_URI, values); } if (organizationData.isPrimary) { primaryOrganizationId = Long.parseLong(organizationUri.getLastPathSegment()); @@ -883,8 +882,7 @@ public class ContactStruct { if (resolver != null) { emailUri = resolver.insert(ContactMethods.CONTENT_URI, values); } else { - emailUri = provider.nonTransactionalInsert( - ContactMethods.CONTENT_URI, values); + emailUri = provider.insert(ContactMethods.CONTENT_URI, values); } if (contactMethod.isPrimary) { primaryEmailId = Long.parseLong(emailUri.getLastPathSegment()); @@ -893,8 +891,7 @@ public class ContactStruct { if (resolver != null) { resolver.insert(ContactMethods.CONTENT_URI, values); } else { - provider.nonTransactionalInsert( - ContactMethods.CONTENT_URI, values); + provider.insert(ContactMethods.CONTENT_URI, values); } } } @@ -918,7 +915,7 @@ public class ContactStruct { if (resolver != null) { contentValuesArray.add(values); } else { - provider.nonTransactionalInsert(Extensions.CONTENT_URI, values); + provider.insert(Extensions.CONTENT_URI, values); } } } @@ -942,7 +939,7 @@ public class ContactStruct { if (resolver != null) { resolver.update(personUri, values, null, null); } else { - provider.nonTransactionalUpdate(personUri, values, null, null); + provider.update(personUri, values, null, null); } } } @@ -960,12 +957,12 @@ public class ContactStruct { public void pushIntoAbstractSyncableContentProvider( AbstractSyncableContentProvider provider, long myContactsGroupId) { boolean successful = false; - provider.beginTransaction(); + provider.beginBatch(); try { pushIntoContentProviderOrResolver(provider, myContactsGroupId); successful = true; } finally { - provider.endTransaction(successful); + provider.endBatch(successful); } } diff --git a/core/java/android/test/AndroidTestCase.java b/core/java/android/test/AndroidTestCase.java index de0587a..1015506 100644 --- a/core/java/android/test/AndroidTestCase.java +++ b/core/java/android/test/AndroidTestCase.java @@ -30,6 +30,7 @@ import java.lang.reflect.Field; public class AndroidTestCase extends TestCase { protected Context mContext; + private Context mTestContext; @Override protected void setUp() throws Exception { @@ -43,7 +44,7 @@ public class AndroidTestCase extends TestCase { public void testAndroidTestCaseSetupProperly() { assertNotNull("Context is null. setContext should be called before tests are run", - mContext); + mContext); } public void setContext(Context context) { @@ -55,6 +56,25 @@ public class AndroidTestCase extends TestCase { } /** + * Test context can be used to access resources from the test's own package + * as opposed to the resources from the test target package. Access to the + * latter is provided by the context set with the {@link #setContext} + * method. + * + * @hide + */ + public void setTestContext(Context context) { + mTestContext = context; + } + + /** + * @hide + */ + public Context getTestContext() { + return mTestContext; + } + + /** * Asserts that launching a given activity is protected by a particular permission by * attempting to start the activity and validating that a {@link SecurityException} * is thrown that mentions the permission in its error message. @@ -125,9 +145,9 @@ public class AndroidTestCase extends TestCase { * to scrub out any class variables. This protects against memory leaks in the case where a * test case creates a non-static inner class (thus referencing the test case) and gives it to * someone else to hold onto. - * + * * @param testCaseClass The class of the derived TestCase implementation. - * + * * @throws IllegalAccessException */ protected void scrubClass(final Class<?> testCaseClass) diff --git a/core/java/android/text/BoringLayout.java b/core/java/android/text/BoringLayout.java index 843754b..944f735 100644 --- a/core/java/android/text/BoringLayout.java +++ b/core/java/android/text/BoringLayout.java @@ -19,6 +19,7 @@ package android.text; import android.graphics.Canvas; import android.graphics.Paint; import android.graphics.Path; +import android.text.style.ParagraphStyle; import android.util.FloatMath; /** @@ -262,6 +263,14 @@ public class BoringLayout extends Layout implements TextUtils.EllipsizeCallback TextUtils.recycle(temp); + if (boring && text instanceof Spanned) { + Spanned sp = (Spanned) text; + Object[] styles = sp.getSpans(0, text.length(), ParagraphStyle.class); + if (styles.length > 0) { + boring = false; + } + } + if (boring) { Metrics fm = metrics; if (fm == null) { diff --git a/core/java/android/text/StaticLayout.java b/core/java/android/text/StaticLayout.java index c133cf2..f0a5ffd 100644 --- a/core/java/android/text/StaticLayout.java +++ b/core/java/android/text/StaticLayout.java @@ -968,7 +968,13 @@ extends Layout fm.bottom = bottom; for (int i = 0; i < chooseht.length; i++) { - chooseht[i].chooseHeight(text, start, end, choosehtv[i], v, fm); + if (chooseht[i] instanceof LineHeightSpan.WithDensity) { + ((LineHeightSpan.WithDensity) chooseht[i]). + chooseHeight(text, start, end, choosehtv[i], v, fm, paint); + + } else { + chooseht[i].chooseHeight(text, start, end, choosehtv[i], v, fm); + } } above = fm.ascent; diff --git a/core/java/android/text/TextPaint.java b/core/java/android/text/TextPaint.java index f13820d..f9e7cac 100644 --- a/core/java/android/text/TextPaint.java +++ b/core/java/android/text/TextPaint.java @@ -27,6 +27,7 @@ public class TextPaint extends Paint { public int baselineShift; public int linkColor; public int[] drawableState; + public float density = 1.0f; public TextPaint() { super(); @@ -51,5 +52,6 @@ public class TextPaint extends Paint { baselineShift = tp.baselineShift; linkColor = tp.linkColor; drawableState = tp.drawableState; + density = tp.density; } } diff --git a/core/java/android/text/format/DateUtils.java b/core/java/android/text/format/DateUtils.java index 1a4eb69..9dd8ceb 100644 --- a/core/java/android/text/format/DateUtils.java +++ b/core/java/android/text/format/DateUtils.java @@ -25,7 +25,9 @@ import android.pim.DateException; import java.util.Calendar; import java.util.Date; +import java.util.Formatter; import java.util.GregorianCalendar; +import java.util.Locale; import java.util.TimeZone; /** @@ -1040,6 +1042,31 @@ public class DateUtils /** * Formats a date or a time range according to the local conventions. + * <p> + * Note that this is a convenience method. Using it involves creating an + * internal {@link java.util.Formatter} instance on-the-fly, which is + * somewhat costly in terms of memory and time. This is probably acceptable + * if you use the method only rarely, but if you rely on it for formatting a + * large number of dates, consider creating and reusing your own + * {@link java.util.Formatter} instance and use the version of + * {@link #formatDateRange(Context, long, long, int) formatDateRange} + * that takes a {@link java.util.Formatter}. + * + * @param context the context is required only if the time is shown + * @param startMillis the start time in UTC milliseconds + * @param endMillis the end time in UTC milliseconds + * @param flags a bit mask of options See + * {@link #formatDateRange(Context, long, long, int) formatDateRange} + * @return a string containing the formatted date/time range. + */ + public static String formatDateRange(Context context, long startMillis, + long endMillis, int flags) { + Formatter f = new Formatter(new StringBuilder(50), Locale.getDefault()); + return formatDateRange(context, f, startMillis, endMillis, flags).toString(); + } + + /** + * Formats a date or a time range according to the local conventions. * * <p> * Example output strings (date formats in these examples are shown using @@ -1181,14 +1208,17 @@ public class DateUtils * instead of "December 31, 2008". * * @param context the context is required only if the time is shown + * @param formatter the Formatter used for formatting the date range. + * Note: be sure to call setLength(0) on StringBuilder passed to + * the Formatter constructor unless you want the results to accumulate. * @param startMillis the start time in UTC milliseconds * @param endMillis the end time in UTC milliseconds * @param flags a bit mask of options * - * @return a string containing the formatted date/time range. + * @return the formatter with the formatted date/time range appended to the string buffer. */ - public static String formatDateRange(Context context, long startMillis, - long endMillis, int flags) { + public static Formatter formatDateRange(Context context, Formatter formatter, long startMillis, + long endMillis, int flags) { Resources res = Resources.getSystem(); boolean showTime = (flags & FORMAT_SHOW_TIME) != 0; boolean showWeekDay = (flags & FORMAT_SHOW_WEEKDAY) != 0; @@ -1423,8 +1453,7 @@ public class DateUtils if (noMonthDay && startMonthNum == endMonthNum) { // Example: "January, 2008" - String startDateString = startDate.format(defaultDateFormat); - return startDateString; + return formatter.format("%s", startDate.format(defaultDateFormat)); } if (startYear != endYear || noMonthDay) { @@ -1436,10 +1465,9 @@ public class DateUtils // The values that are used in a fullFormat string are specified // by position. - dateRange = String.format(fullFormat, + return formatter.format(fullFormat, startWeekDayString, startDateString, startTimeString, endWeekDayString, endDateString, endTimeString); - return dateRange; } // Get the month, day, and year strings for the start and end dates @@ -1476,12 +1504,11 @@ public class DateUtils // The values that are used in a fullFormat string are specified // by position. - dateRange = String.format(fullFormat, + return formatter.format(fullFormat, startWeekDayString, startMonthString, startMonthDayString, startYearString, startTimeString, endWeekDayString, endMonthString, endMonthDayString, endYearString, endTimeString); - return dateRange; } if (startDay != endDay) { @@ -1496,12 +1523,11 @@ public class DateUtils // The values that are used in a fullFormat string are specified // by position. - dateRange = String.format(fullFormat, + return formatter.format(fullFormat, startWeekDayString, startMonthString, startMonthDayString, startYearString, startTimeString, endWeekDayString, endMonthString, endMonthDayString, endYearString, endTimeString); - return dateRange; } // Same start and end day @@ -1522,6 +1548,7 @@ public class DateUtils } else { // Example: "10:00 - 11:00 am" String timeFormat = res.getString(com.android.internal.R.string.time1_time2); + // Don't use the user supplied Formatter because the result will pollute the buffer. timeString = String.format(timeFormat, startTimeString, endTimeString); } } @@ -1545,7 +1572,7 @@ public class DateUtils fullFormat = res.getString(com.android.internal.R.string.time_date); } else { // Example: "Oct 9" - return dateString; + return formatter.format("%s", dateString); } } } else if (showWeekDay) { @@ -1554,16 +1581,15 @@ public class DateUtils fullFormat = res.getString(com.android.internal.R.string.time_wday); } else { // Example: "Tue" - return startWeekDayString; + return formatter.format("%s", startWeekDayString); } } else if (showTime) { - return timeString; + return formatter.format("%s", timeString); } // The values that are used in a fullFormat string are specified // by position. - dateRange = String.format(fullFormat, timeString, startWeekDayString, dateString); - return dateRange; + return formatter.format(fullFormat, timeString, startWeekDayString, dateString); } /** diff --git a/core/java/android/text/method/ArrowKeyMovementMethod.java b/core/java/android/text/method/ArrowKeyMovementMethod.java index 92f6289..ab33cb3 100644 --- a/core/java/android/text/method/ArrowKeyMovementMethod.java +++ b/core/java/android/text/method/ArrowKeyMovementMethod.java @@ -22,6 +22,7 @@ import android.graphics.Rect; import android.text.*; import android.widget.TextView; import android.view.View; +import android.view.ViewConfiguration; import android.view.MotionEvent; // XXX this doesn't extend MetaKeyKeyListener because the signatures @@ -256,8 +257,32 @@ implements MovementMethod (MetaKeyKeyListener.getMetaState(buffer, MetaKeyKeyListener.META_SELECTING) != 0); + DoubleTapState[] tap = buffer.getSpans(0, buffer.length(), + DoubleTapState.class); + boolean doubletap = false; + + if (tap.length > 0) { + if (event.getEventTime() - tap[0].mWhen <= + ViewConfiguration.getDoubleTapTimeout()) { + if (sameWord(buffer, off, Selection.getSelectionEnd(buffer))) { + doubletap = true; + } + } + + tap[0].mWhen = event.getEventTime(); + } else { + DoubleTapState newtap = new DoubleTapState(); + newtap.mWhen = event.getEventTime(); + buffer.setSpan(newtap, 0, buffer.length(), + Spannable.SPAN_INCLUSIVE_INCLUSIVE); + } + if (cap) { Selection.extendSelection(buffer, off); + } else if (doubletap) { + Selection.setSelection(buffer, + findWordStart(buffer, off), + findWordEnd(buffer, off)); } else { Selection.setSelection(buffer, off); } @@ -272,6 +297,62 @@ implements MovementMethod return handled; } + private static class DoubleTapState implements NoCopySpan { + long mWhen; + } + + private static boolean sameWord(CharSequence text, int one, int two) { + int start = findWordStart(text, one); + int end = findWordEnd(text, one); + + if (end == start) { + return false; + } + + return start == findWordStart(text, two) && + end == findWordEnd(text, two); + } + + // TODO: Unify with TextView.getWordForDictionary() + private static int findWordStart(CharSequence text, int start) { + for (; start > 0; start--) { + char c = text.charAt(start - 1); + int type = Character.getType(c); + + if (c != '\'' && + type != Character.UPPERCASE_LETTER && + type != Character.LOWERCASE_LETTER && + type != Character.TITLECASE_LETTER && + type != Character.MODIFIER_LETTER && + type != Character.DECIMAL_DIGIT_NUMBER) { + break; + } + } + + return start; + } + + // TODO: Unify with TextView.getWordForDictionary() + private static int findWordEnd(CharSequence text, int end) { + int len = text.length(); + + for (; end < len; end++) { + char c = text.charAt(end); + int type = Character.getType(c); + + if (c != '\'' && + type != Character.UPPERCASE_LETTER && + type != Character.LOWERCASE_LETTER && + type != Character.TITLECASE_LETTER && + type != Character.MODIFIER_LETTER && + type != Character.DECIMAL_DIGIT_NUMBER) { + break; + } + } + + return end; + } + public boolean canSelectArbitrarily() { return true; } diff --git a/core/java/android/text/method/QwertyKeyListener.java b/core/java/android/text/method/QwertyKeyListener.java index e420c27..172e9ac 100644 --- a/core/java/android/text/method/QwertyKeyListener.java +++ b/core/java/android/text/method/QwertyKeyListener.java @@ -434,7 +434,7 @@ public class QwertyKeyListener extends BaseKeyListener { PICKER_SETS.put('y', "\u00FD\u00FF"); PICKER_SETS.put('z', "\u017A\u017C\u017E"); PICKER_SETS.put(KeyCharacterMap.PICKER_DIALOG_INPUT, - "\u2026\u00A5\u2022\u00AE\u00A9\u00B1"); + "\u2026\u00A5\u2022\u00AE\u00A9\u00B1[]{}\\"); }; private boolean showCharacterPicker(View view, Editable content, char c, diff --git a/core/java/android/text/style/AbsoluteSizeSpan.java b/core/java/android/text/style/AbsoluteSizeSpan.java index 484f8ce..1214040 100644 --- a/core/java/android/text/style/AbsoluteSizeSpan.java +++ b/core/java/android/text/style/AbsoluteSizeSpan.java @@ -24,13 +24,28 @@ import android.text.TextUtils; public class AbsoluteSizeSpan extends MetricAffectingSpan implements ParcelableSpan { private final int mSize; + private boolean mDip; + /** + * Set the text size to <code>size</code> physical pixels. + */ public AbsoluteSizeSpan(int size) { mSize = size; } + /** + * Set the text size to <code>size</code> physical pixels, + * or to <code>size</code> device-independent pixels if + * <code>dip</code> is true. + */ + public AbsoluteSizeSpan(int size, boolean dip) { + mSize = size; + mDip = dip; + } + public AbsoluteSizeSpan(Parcel src) { mSize = src.readInt(); + mDip = src.readInt() != 0; } public int getSpanTypeId() { @@ -43,19 +58,32 @@ public class AbsoluteSizeSpan extends MetricAffectingSpan implements ParcelableS public void writeToParcel(Parcel dest, int flags) { dest.writeInt(mSize); + dest.writeInt(mDip ? 1 : 0); } public int getSize() { return mSize; } + public boolean getDip() { + return mDip; + } + @Override public void updateDrawState(TextPaint ds) { - ds.setTextSize(mSize); + if (mDip) { + ds.setTextSize(mSize * ds.density); + } else { + ds.setTextSize(mSize); + } } @Override public void updateMeasureState(TextPaint ds) { - ds.setTextSize(mSize); + if (mDip) { + ds.setTextSize(mSize * ds.density); + } else { + ds.setTextSize(mSize); + } } } diff --git a/core/java/android/text/style/LineHeightSpan.java b/core/java/android/text/style/LineHeightSpan.java index c0ef97c..44a1706 100644 --- a/core/java/android/text/style/LineHeightSpan.java +++ b/core/java/android/text/style/LineHeightSpan.java @@ -19,6 +19,7 @@ package android.text.style; import android.graphics.Paint; import android.graphics.Canvas; import android.text.Layout; +import android.text.TextPaint; public interface LineHeightSpan extends ParagraphStyle, WrapTogetherSpan @@ -26,4 +27,10 @@ extends ParagraphStyle, WrapTogetherSpan public void chooseHeight(CharSequence text, int start, int end, int spanstartv, int v, Paint.FontMetricsInt fm); + + public interface WithDensity extends LineHeightSpan { + public void chooseHeight(CharSequence text, int start, int end, + int spanstartv, int v, + Paint.FontMetricsInt fm, TextPaint paint); + } } diff --git a/core/java/android/util/EventLog.java b/core/java/android/util/EventLog.java index 24b4f73..81dd96e 100644 --- a/core/java/android/util/EventLog.java +++ b/core/java/android/util/EventLog.java @@ -73,7 +73,7 @@ import java.util.List; * </ul> * </li> * <li> '\n': 1 byte - an automatically generated newline, used to help detect and recover from log - * corruption and enable stansard unix tools like grep, tail and wc to operate + * corruption and enable standard unix tools like grep, tail and wc to operate * on event logs. </li> * </ul> * @@ -124,10 +124,6 @@ public class EventLog { "A List must have fewer than " + Byte.MAX_VALUE + " items in it."); } - if (items.length < 1) { - throw new IllegalArgumentException( - "A List must have at least one item in it."); - } for (int i = 0; i < items.length; i++) { final Object item = items[i]; if (item == null) { @@ -192,17 +188,21 @@ public class EventLog { return decodeObject(); } + public byte[] getRawData() { + return mBuffer.array(); + } + /** @return the loggable item at the current position in mBuffer. */ private Object decodeObject() { if (mBuffer.remaining() < 1) return null; switch (mBuffer.get()) { case INT: if (mBuffer.remaining() < 4) return null; - return mBuffer.getInt(); + return (Integer) mBuffer.getInt(); case LONG: if (mBuffer.remaining() < 8) return null; - return mBuffer.getLong(); + return (Long) mBuffer.getLong(); case STRING: try { @@ -219,7 +219,7 @@ public class EventLog { case LIST: if (mBuffer.remaining() < 1) return null; int length = mBuffer.get(); - if (length <= 0) return null; + if (length < 0) return null; Object[] array = new Object[length]; for (int i = 0; i < length; ++i) { array[i] = decodeObject(); @@ -285,4 +285,13 @@ public class EventLog { */ public static native void readEvents(int[] tags, Collection<Event> output) throws IOException; + + /** + * Read events from a file. + * @param path to read from + * @param output container to add events into + * @throws IOException if something goes wrong reading events + */ + public static native void readEvents(String path, Collection<Event> output) + throws IOException; } diff --git a/core/java/android/util/MathUtils.java b/core/java/android/util/MathUtils.java new file mode 100644 index 0000000..b35dd1e --- /dev/null +++ b/core/java/android/util/MathUtils.java @@ -0,0 +1,176 @@ +/* + * Copyright (C) 2009 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.util; + +import java.util.Random; + +/** + * A class that contains utility methods related to numbers. + * + * @hide Pending API council approval + */ +public final class MathUtils { + private static final Random sRandom = new Random(); + private static final float DEG_TO_RAD = 3.1415926f / 180.0f; + private static final float RAD_TO_DEG = 180.0f / 3.1415926f; + + private MathUtils() { + } + + public static float abs(float v) { + return v > 0 ? v : -v; + } + + public static int constrain(int amount, int low, int high) { + return amount < low ? low : (amount > high ? high : amount); + } + + public static float constrain(float amount, float low, float high) { + return amount < low ? low : (amount > high ? high : amount); + } + + public static float log(float a) { + return (float) Math.log(a); + } + + public static float exp(float a) { + return (float) Math.exp(a); + } + + public static float pow(float a, float b) { + return (float) Math.pow(a, b); + } + + public static float max(float a, float b) { + return a > b ? a : b; + } + + public static float max(int a, int b) { + return a > b ? a : b; + } + + public static float max(float a, float b, float c) { + return a > b ? (a > c ? a : c) : (b > c ? b : c); + } + + public static float max(int a, int b, int c) { + return a > b ? (a > c ? a : c) : (b > c ? b : c); + } + + public static float min(float a, float b) { + return a < b ? a : b; + } + + public static float min(int a, int b) { + return a < b ? a : b; + } + + public static float min(float a, float b, float c) { + return a < b ? (a < c ? a : c) : (b < c ? b : c); + } + + public static float min(int a, int b, int c) { + return a < b ? (a < c ? a : c) : (b < c ? b : c); + } + + public static float dist(float x1, float y1, float x2, float y2) { + final float x = (x2 - x1); + final float y = (y2 - y1); + return (float) Math.sqrt(x * x + y * y); + } + + public static float dist(float x1, float y1, float z1, float x2, float y2, float z2) { + final float x = (x2 - x1); + final float y = (y2 - y1); + final float z = (z2 - z1); + return (float) Math.sqrt(x * x + y * y + z * z); + } + + public static float mag(float a, float b) { + return (float) Math.sqrt(a * a + b * b); + } + + public static float mag(float a, float b, float c) { + return (float) Math.sqrt(a * a + b * b + c * c); + } + + public static float sq(float v) { + return v * v; + } + + public static float radians(float degrees) { + return degrees * DEG_TO_RAD; + } + + public static float degrees(float radians) { + return radians * RAD_TO_DEG; + } + + public static float acos(float value) { + return (float) Math.acos(value); + } + + public static float asin(float value) { + return (float) Math.asin(value); + } + + public static float atan(float value) { + return (float) Math.atan(value); + } + + public static float atan2(float a, float b) { + return (float) Math.atan2(a, b); + } + + public static float tan(float angle) { + return (float) Math.tan(angle); + } + + public static float lerp(float start, float stop, float amount) { + return start + (stop - start) * amount; + } + + public static float norm(float start, float stop, float value) { + return (value - start) / (stop - start); + } + + public static float map(float minStart, float minStop, float maxStart, float maxStop, float value) { + return maxStart + (maxStart - maxStop) * ((value - minStart) / (minStop - minStart)); + } + + public static int random(int howbig) { + return (int) (sRandom.nextFloat() * howbig); + } + + public static int random(int howsmall, int howbig) { + if (howsmall >= howbig) return howsmall; + return (int) (sRandom.nextFloat() * (howbig - howsmall) + howsmall); + } + + public static float random(float howbig) { + return sRandom.nextFloat() * howbig; + } + + public static float random(float howsmall, float howbig) { + if (howsmall >= howbig) return howsmall; + return sRandom.nextFloat() * (howbig - howsmall) + howsmall; + } + + public static void randomSeed(long seed) { + sRandom.setSeed(seed); + } +} diff --git a/core/java/android/util/Pair.java b/core/java/android/util/Pair.java new file mode 100644 index 0000000..bf25306 --- /dev/null +++ b/core/java/android/util/Pair.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2009 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.util; + +/** + * Container to ease passing around a tuple of two objects. This object provides a sensible + * implementation of equals(), returning true if equals() is true on each of the contained + * objects. + */ +public class Pair<F, S> { + public final F first; + public final S second; + + /** + * Constructor for a Pair. If either are null then equals() and hashCode() will throw + * a NullPointerException. + * @param first the first object in the Pair + * @param second the second object in the pair + */ + public Pair(F first, S second) { + this.first = first; + this.second = second; + } + + /** + * Checks the two objects for equality by delegating to their respective equals() methods. + * @param o the Pair to which this one is to be checked for equality + * @return true if the underlying objects of the Pair are both considered equals() + */ + public boolean equals(Object o) { + if (o == this) return true; + if (!(o instanceof Pair)) return false; + final Pair<F, S> other; + try { + other = (Pair<F, S>) o; + } catch (ClassCastException e) { + return false; + } + return first.equals(other.first) && second.equals(other.second); + } + + /** + * Compute a hash code using the hash codes of the underlying objects + * @return a hashcode of the Pair + */ + public int hashCode() { + int result = 17; + result = 31 * result + first.hashCode(); + result = 31 * result + second.hashCode(); + return result; + } + + /** + * Convenience method for creating an appropriately typed pair. + * @param a the first object in the Pair + * @param b the second object in the pair + * @return a Pair that is templatized with the types of a and b + */ + public static <A, B> Pair <A, B> create(A a, B b) { + return new Pair<A, B>(a, b); + } +} diff --git a/core/java/android/view/HapticFeedbackConstants.java b/core/java/android/view/HapticFeedbackConstants.java index 841066c..f936f65 100644 --- a/core/java/android/view/HapticFeedbackConstants.java +++ b/core/java/android/view/HapticFeedbackConstants.java @@ -24,9 +24,18 @@ public class HapticFeedbackConstants { private HapticFeedbackConstants() {} + /** + * The user has performed a long press on an object that is resulting + * in an action being performed. + */ public static final int LONG_PRESS = 0; /** + * The user has pressed on a virtual on-screen key. + */ + public static final int VIRTUAL_KEY = 1; + + /** * Flag for {@link View#performHapticFeedback(int, int) * View.performHapticFeedback(int, int)}: Ignore the setting in the * view for whether to perform haptic feedback, do it always. diff --git a/core/java/android/view/IWindow.aidl b/core/java/android/view/IWindow.aidl index 99d5c0c..ebc5f7b 100644 --- a/core/java/android/view/IWindow.aidl +++ b/core/java/android/view/IWindow.aidl @@ -46,8 +46,8 @@ oneway interface IWindow { void resized(int w, int h, in Rect coveredInsets, in Rect visibleInsets, boolean reportDraw); void dispatchKey(in KeyEvent event); - void dispatchPointer(in MotionEvent event, long eventTime); - void dispatchTrackball(in MotionEvent event, long eventTime); + void dispatchPointer(in MotionEvent event, long eventTime, boolean callWhenDone); + void dispatchTrackball(in MotionEvent event, long eventTime, boolean callWhenDone); void dispatchAppVisibility(boolean visible); void dispatchGetNewSurface(); @@ -56,4 +56,9 @@ oneway interface IWindow { * to date on the current state showing navigational focus (touch mode) too. */ void windowFocusChanged(boolean hasFocus, boolean inTouchMode); + + /** + * Called for wallpaper windows when their offsets change. + */ + void dispatchWallpaperOffsets(float x, float y); } diff --git a/core/java/android/view/IWindowManager.aidl b/core/java/android/view/IWindowManager.aidl index 5607d4b..3e6cdc2 100644 --- a/core/java/android/view/IWindowManager.aidl +++ b/core/java/android/view/IWindowManager.aidl @@ -90,7 +90,6 @@ interface IWindowManager void exitKeyguardSecurely(IOnKeyguardExitResult callback); boolean inKeyguardRestrictedInputMode(); - // These can only be called with the SET_ANIMATON_SCALE permission. float getAnimationScale(int which); float[] getAnimationScales(); diff --git a/core/java/android/view/IWindowSession.aidl b/core/java/android/view/IWindowSession.aidl index 1156856..4d662d2 100644 --- a/core/java/android/view/IWindowSession.aidl +++ b/core/java/android/view/IWindowSession.aidl @@ -108,4 +108,10 @@ interface IWindowSession { boolean getInTouchMode(); boolean performHapticFeedback(IWindow window, int effectId, boolean always); + + /** + * For windows with the wallpaper behind them, and the wallpaper is + * larger than the screen, set the offset within the screen. + */ + void setWallpaperPosition(IBinder windowToken, float x, float y); } diff --git a/core/java/android/view/KeyEvent.java b/core/java/android/view/KeyEvent.java index 6349288..f9b16fc 100644 --- a/core/java/android/view/KeyEvent.java +++ b/core/java/android/view/KeyEvent.java @@ -258,6 +258,25 @@ public class KeyEvent implements Parcelable { public static final int FLAG_EDITOR_ACTION = 0x10; /** + * When associated with up key events, this indicates that the key press + * has been canceled. Typically this is used with virtual touch screen + * keys, where the user can slide from the virtual key area on to the + * display: in that case, the application will receive a canceled up + * event and should not perform the action normally associated with the + * key. Note that for this to work, the application can not perform an + * action for a key until it receives an up or the long press timeout has + * expired. + */ + public static final int FLAG_CANCELED = 0x20; + + /** + * This key event was generated by a virtual (on-screen) hard key area. + * Typically this is an area of the touchscreen, outside of the regular + * display, dedicated to "hardware" buttons. + */ + public static final int FLAG_VIRTUAL_HARD_KEY = 0x40; + + /** * Returns the maximum keycode. */ public static int getMaxKeyCode() { @@ -694,6 +713,14 @@ public class KeyEvent implements Parcelable { } /** + * For {@link #ACTION_UP} events, indicates that the event has been + * canceled as per {@link #FLAG_CANCELED}. + */ + public final boolean isCanceled() { + return (mFlags&FLAG_CANCELED) != 0; + } + + /** * Retrieve the key code of the key event. This is the physical key that * was pressed, <em>not</em> the Unicode character. * diff --git a/core/java/android/view/MotionEvent.java b/core/java/android/view/MotionEvent.java index a224ed3..b2f0c60 100644 --- a/core/java/android/view/MotionEvent.java +++ b/core/java/android/view/MotionEvent.java @@ -19,7 +19,7 @@ package android.view; import android.os.Parcel; import android.os.Parcelable; import android.os.SystemClock; -import android.util.Config; +import android.util.Log; /** * Object used to report movement (mouse, pen, finger, trackball) events. This @@ -27,17 +27,26 @@ import android.util.Config; * it is being used for. */ public final class MotionEvent implements Parcelable { + static final boolean DEBUG_POINTERS = false; + + /** + * Bit mask of the parts of the action code that are the action itself. + */ + public static final int ACTION_MASK = 0xff; + /** * Constant for {@link #getAction}: A pressed gesture has started, the * motion contains the initial starting location. */ public static final int ACTION_DOWN = 0; + /** * Constant for {@link #getAction}: A pressed gesture has finished, the * motion contains the final release location as well as any intermediate * points since the last down or move event. */ public static final int ACTION_UP = 1; + /** * Constant for {@link #getAction}: A change has happened during a * press gesture (between {@link #ACTION_DOWN} and {@link #ACTION_UP}). @@ -45,12 +54,14 @@ public final class MotionEvent implements Parcelable { * points since the last down or move event. */ public static final int ACTION_MOVE = 2; + /** * Constant for {@link #getAction}: The current gesture has been aborted. * You will not receive any more points in it. You should treat this as * an up event, but not perform any action that you normally would. */ public static final int ACTION_CANCEL = 3; + /** * Constant for {@link #getAction}: A movement has happened outside of the * normal bounds of the UI element. This does not provide a full gesture, @@ -58,6 +69,70 @@ public final class MotionEvent implements Parcelable { */ public static final int ACTION_OUTSIDE = 4; + /** + * A non-primary pointer has gone down. The bits in + * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed. + */ + public static final int ACTION_POINTER_DOWN = 5; + + /** + * Synonym for {@link #ACTION_POINTER_DOWN} with + * {@link #ACTION_POINTER_ID_MASK} of 0: the primary pointer has gone done. + */ + public static final int ACTION_POINTER_1_DOWN = ACTION_POINTER_DOWN | 0x0000; + + /** + * Synonym for {@link #ACTION_POINTER_DOWN} with + * {@link #ACTION_POINTER_ID_MASK} of 1: the secondary pointer has gone done. + */ + public static final int ACTION_POINTER_2_DOWN = ACTION_POINTER_DOWN | 0x0100; + + /** + * Synonym for {@link #ACTION_POINTER_DOWN} with + * {@link #ACTION_POINTER_ID_MASK} of 2: the tertiary pointer has gone done. + */ + public static final int ACTION_POINTER_3_DOWN = ACTION_POINTER_DOWN | 0x0200; + + /** + * A non-primary pointer has gone up. The bits in + * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed. + */ + public static final int ACTION_POINTER_UP = 6; + + /** + * Synonym for {@link #ACTION_POINTER_UP} with + * {@link #ACTION_POINTER_ID_MASK} of 0: the primary pointer has gone up. + */ + public static final int ACTION_POINTER_1_UP = ACTION_POINTER_UP | 0x0000; + + /** + * Synonym for {@link #ACTION_POINTER_UP} with + * {@link #ACTION_POINTER_ID_MASK} of 1: the secondary pointer has gone up. + */ + public static final int ACTION_POINTER_2_UP = ACTION_POINTER_UP | 0x0100; + + /** + * Synonym for {@link #ACTION_POINTER_UP} with + * {@link #ACTION_POINTER_ID_MASK} of 2: the tertiary pointer has gone up. + */ + public static final int ACTION_POINTER_3_UP = ACTION_POINTER_UP | 0x0200; + + /** + * Bits in the action code that represent a pointer ID, used with + * {@link #ACTION_POINTER_DOWN} and {@link #ACTION_POINTER_UP}. Pointer IDs + * start at 0, with 0 being the primary (first) pointer in the motion. Note + * that this not <em>not</em> an index into the array of pointer values, + * which is compacted to only contain pointers that are down; the pointer + * ID for a particular index can be found with {@link #findPointerIndex}. + */ + public static final int ACTION_POINTER_ID_MASK = 0xff00; + + /** + * Bit shift for the action bits holding the pointer identifier as + * defined by {@link #ACTION_POINTER_ID_MASK}. + */ + public static final int ACTION_POINTER_ID_SHIFT = 8; + private static final boolean TRACK_RECYCLED_LOCATION = false; /** @@ -80,34 +155,83 @@ public final class MotionEvent implements Parcelable { */ public static final int EDGE_RIGHT = 0x00000008; + /** + * Offset for the sample's X coordinate. + * @hide + */ + static public final int SAMPLE_X = 0; + + /** + * Offset for the sample's Y coordinate. + * @hide + */ + static public final int SAMPLE_Y = 1; + + /** + * Offset for the sample's X coordinate. + * @hide + */ + static public final int SAMPLE_PRESSURE = 2; + + /** + * Offset for the sample's X coordinate. + * @hide + */ + static public final int SAMPLE_SIZE = 3; + + /** + * Number of data items for each sample. + * @hide + */ + static public final int NUM_SAMPLE_DATA = 4; + + /** + * Number of possible pointers. + * @hide + */ + static public final int BASE_AVAIL_POINTERS = 5; + + static private final int BASE_AVAIL_SAMPLES = 8; + static private final int MAX_RECYCLED = 10; static private Object gRecyclerLock = new Object(); static private int gRecyclerUsed = 0; static private MotionEvent gRecyclerTop = null; private long mDownTime; - private long mEventTime; + private long mEventTimeNano; private int mAction; - private float mX; - private float mY; private float mRawX; private float mRawY; - private float mPressure; - private float mSize; - private int mMetaState; - private int mNumHistory; - private float[] mHistory; - private long[] mHistoryTimes; private float mXPrecision; private float mYPrecision; private int mDeviceId; private int mEdgeFlags; + private int mMetaState; + + // Here is the actual event data. Note that the order of the array + // is a little odd: the first entry is the most recent, and the ones + // following it are the historical data from oldest to newest. This + // allows us to easily retrieve the most recent data, without having + // to copy the arrays every time a new sample is added. + + private int mNumPointers; + private int mNumSamples; + // Array of mNumPointers size of identifiers for each pointer of data. + private int[] mPointerIdentifiers; + // Array of (mNumSamples * mNumPointers * NUM_SAMPLE_DATA) size of event data. + private float[] mDataSamples; + // Array of mNumSamples size of time stamps. + private long[] mTimeSamples; private MotionEvent mNext; private RuntimeException mRecycledLocation; private boolean mRecycled; private MotionEvent() { + mPointerIdentifiers = new int[BASE_AVAIL_POINTERS]; + mDataSamples = new float[BASE_AVAIL_POINTERS*BASE_AVAIL_SAMPLES*NUM_SAMPLE_DATA]; + mTimeSamples = new long[BASE_AVAIL_SAMPLES]; } static private MotionEvent obtain() { @@ -127,6 +251,86 @@ public final class MotionEvent implements Parcelable { /** * Create a new MotionEvent, filling in all of the basic values that * define the motion. + * + * @param downTime The time (in ms) when the user originally pressed down to start + * a stream of position events. This must be obtained from {@link SystemClock#uptimeMillis()}. + * @param eventTime The the time (in ms) when this specific event was generated. This + * must be obtained from {@link SystemClock#uptimeMillis()}. + * @param eventTimeNano The the time (in ns) when this specific event was generated. This + * must be obtained from {@link System#nanoTime()}. + * @param action The kind of action being performed -- one of either + * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or + * {@link #ACTION_CANCEL}. + * @param pointers The number of points that will be in this event. + * @param inPointerIds An array of <em>pointers</em> values providing + * an identifier for each pointer. + * @param inData An array of <em>pointers*NUM_SAMPLE_DATA</em> of initial + * data samples for the event. + * @param metaState The state of any meta / modifier keys that were in effect when + * the event was generated. + * @param xPrecision The precision of the X coordinate being reported. + * @param yPrecision The precision of the Y coordinate being reported. + * @param deviceId The id for the device that this event came from. An id of + * zero indicates that the event didn't come from a physical device; other + * numbers are arbitrary and you shouldn't depend on the values. + * @param edgeFlags A bitfield indicating which edges, if any, where touched by this + * MotionEvent. + * + * @hide + */ + static public MotionEvent obtainNano(long downTime, long eventTime, long eventTimeNano, + int action, int pointers, int[] inPointerIds, float[] inData, int metaState, + float xPrecision, float yPrecision, int deviceId, int edgeFlags) { + MotionEvent ev = obtain(); + ev.mDeviceId = deviceId; + ev.mEdgeFlags = edgeFlags; + ev.mDownTime = downTime; + ev.mEventTimeNano = eventTimeNano; + ev.mAction = action; + ev.mMetaState = metaState; + ev.mRawX = inData[SAMPLE_X]; + ev.mRawY = inData[SAMPLE_Y]; + ev.mXPrecision = xPrecision; + ev.mYPrecision = yPrecision; + ev.mNumPointers = pointers; + ev.mNumSamples = 1; + + int[] pointerIdentifiers = ev.mPointerIdentifiers; + if (pointerIdentifiers.length < pointers) { + ev.mPointerIdentifiers = pointerIdentifiers = new int[pointers]; + } + System.arraycopy(inPointerIds, 0, pointerIdentifiers, 0, pointers); + + final int ND = pointers * NUM_SAMPLE_DATA; + float[] dataSamples = ev.mDataSamples; + if (dataSamples.length < ND) { + ev.mDataSamples = dataSamples = new float[ND]; + } + System.arraycopy(inData, 0, dataSamples, 0, ND); + + ev.mTimeSamples[0] = eventTime; + + if (DEBUG_POINTERS) { + StringBuilder sb = new StringBuilder(128); + sb.append("New:"); + for (int i=0; i<pointers; i++) { + sb.append(" #"); + sb.append(ev.mPointerIdentifiers[i]); + sb.append("("); + sb.append(ev.mDataSamples[(i*NUM_SAMPLE_DATA) + SAMPLE_X]); + sb.append(","); + sb.append(ev.mDataSamples[(i*NUM_SAMPLE_DATA) + SAMPLE_Y]); + sb.append(")"); + } + Log.v("MotionEvent", sb.toString()); + } + + return ev; + } + + /** + * Create a new MotionEvent, filling in all of the basic values that + * define the motion. * * @param downTime The time (in ms) when the user originally pressed down to start * a stream of position events. This must be obtained from {@link SystemClock#uptimeMillis()}. @@ -162,16 +366,83 @@ public final class MotionEvent implements Parcelable { ev.mDeviceId = deviceId; ev.mEdgeFlags = edgeFlags; ev.mDownTime = downTime; - ev.mEventTime = eventTime; + ev.mEventTimeNano = eventTime * 1000000; ev.mAction = action; - ev.mX = ev.mRawX = x; - ev.mY = ev.mRawY = y; - ev.mPressure = pressure; - ev.mSize = size; ev.mMetaState = metaState; ev.mXPrecision = xPrecision; ev.mYPrecision = yPrecision; + ev.mNumPointers = 1; + ev.mNumSamples = 1; + int[] pointerIds = ev.mPointerIdentifiers; + pointerIds[0] = 0; + float[] data = ev.mDataSamples; + data[SAMPLE_X] = ev.mRawX = x; + data[SAMPLE_Y] = ev.mRawY = y; + data[SAMPLE_PRESSURE] = pressure; + data[SAMPLE_SIZE] = size; + ev.mTimeSamples[0] = eventTime; + + return ev; + } + + /** + * Create a new MotionEvent, filling in all of the basic values that + * define the motion. + * + * @param downTime The time (in ms) when the user originally pressed down to start + * a stream of position events. This must be obtained from {@link SystemClock#uptimeMillis()}. + * @param eventTime The the time (in ms) when this specific event was generated. This + * must be obtained from {@link SystemClock#uptimeMillis()}. + * @param action The kind of action being performed -- one of either + * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or + * {@link #ACTION_CANCEL}. + * @param pointers The number of pointers that are active in this event. + * @param x The X coordinate of this event. + * @param y The Y coordinate of this event. + * @param pressure The current pressure of this event. The pressure generally + * ranges from 0 (no pressure at all) to 1 (normal pressure), however + * values higher than 1 may be generated depending on the calibration of + * the input device. + * @param size A scaled value of the approximate size of the area being pressed when + * touched with the finger. The actual value in pixels corresponding to the finger + * touch is normalized with a device specific range of values + * and scaled to a value between 0 and 1. + * @param metaState The state of any meta / modifier keys that were in effect when + * the event was generated. + * @param xPrecision The precision of the X coordinate being reported. + * @param yPrecision The precision of the Y coordinate being reported. + * @param deviceId The id for the device that this event came from. An id of + * zero indicates that the event didn't come from a physical device; other + * numbers are arbitrary and you shouldn't depend on the values. + * @param edgeFlags A bitfield indicating which edges, if any, where touched by this + * MotionEvent. + */ + static public MotionEvent obtain(long downTime, long eventTime, int action, + int pointers, float x, float y, float pressure, float size, int metaState, + float xPrecision, float yPrecision, int deviceId, int edgeFlags) { + MotionEvent ev = obtain(); + ev.mDeviceId = deviceId; + ev.mEdgeFlags = edgeFlags; + ev.mDownTime = downTime; + ev.mEventTimeNano = eventTime * 1000000; + ev.mAction = action; + ev.mNumPointers = pointers; + ev.mMetaState = metaState; + ev.mXPrecision = xPrecision; + ev.mYPrecision = yPrecision; + + ev.mNumPointers = 1; + ev.mNumSamples = 1; + int[] pointerIds = ev.mPointerIdentifiers; + pointerIds[0] = 0; + float[] data = ev.mDataSamples; + data[SAMPLE_X] = ev.mRawX = x; + data[SAMPLE_Y] = ev.mRawY = y; + data[SAMPLE_PRESSURE] = pressure; + data[SAMPLE_SIZE] = size; + ev.mTimeSamples[0] = eventTime; + return ev; } @@ -198,16 +469,24 @@ public final class MotionEvent implements Parcelable { ev.mDeviceId = 0; ev.mEdgeFlags = 0; ev.mDownTime = downTime; - ev.mEventTime = eventTime; + ev.mEventTimeNano = eventTime * 1000000; ev.mAction = action; - ev.mX = ev.mRawX = x; - ev.mY = ev.mRawY = y; - ev.mPressure = 1.0f; - ev.mSize = 1.0f; + ev.mNumPointers = 1; ev.mMetaState = metaState; ev.mXPrecision = 1.0f; ev.mYPrecision = 1.0f; + ev.mNumPointers = 1; + ev.mNumSamples = 1; + int[] pointerIds = ev.mPointerIdentifiers; + pointerIds[0] = 0; + float[] data = ev.mDataSamples; + data[SAMPLE_X] = ev.mRawX = x; + data[SAMPLE_Y] = ev.mRawY = y; + data[SAMPLE_PRESSURE] = 1.0f; + data[SAMPLE_SIZE] = 1.0f; + ev.mTimeSamples[0] = eventTime; + return ev; } @@ -217,72 +496,96 @@ public final class MotionEvent implements Parcelable { * @hide */ public void scale(float scale) { - mX *= scale; - mY *= scale; mRawX *= scale; mRawY *= scale; - mSize *= scale; mXPrecision *= scale; mYPrecision *= scale; - if (mHistory != null) { - float[] history = mHistory; - int length = history.length; - for (int i = 0; i < length; i += 4) { - history[i] *= scale; // X - history[i + 1] *= scale; // Y - // no need to scale pressure ([i+2]) - history[i + 3] *= scale; // Size, TODO: square this? - } + float[] history = mDataSamples; + final int length = mNumPointers * mNumSamples * NUM_SAMPLE_DATA; + for (int i = 0; i < length; i += NUM_SAMPLE_DATA) { + history[i + SAMPLE_X] *= scale; + history[i + SAMPLE_Y] *= scale; + // no need to scale pressure + history[i + SAMPLE_SIZE] *= scale; // TODO: square this? } } /** - * Translate the coordination of the event by given x and y. - * - * @hide + * Create a new MotionEvent, copying from an existing one. */ - public void translate(float dx, float dy) { - mX += dx; - mY += dy; - mRawX += dx; - mRawY += dx; - if (mHistory != null) { - float[] history = mHistory; - int length = history.length; - for (int i = 0; i < length; i += 4) { - history[i] += dx; // X - history[i + 1] += dy; // Y - // no need to translate pressure (i+2) and size (i+3) - } + static public MotionEvent obtain(MotionEvent o) { + MotionEvent ev = obtain(); + ev.mDeviceId = o.mDeviceId; + ev.mEdgeFlags = o.mEdgeFlags; + ev.mDownTime = o.mDownTime; + ev.mEventTimeNano = o.mEventTimeNano; + ev.mAction = o.mAction; + ev.mNumPointers = o.mNumPointers; + ev.mRawX = o.mRawX; + ev.mRawY = o.mRawY; + ev.mMetaState = o.mMetaState; + ev.mXPrecision = o.mXPrecision; + ev.mYPrecision = o.mYPrecision; + + final int NS = ev.mNumSamples = o.mNumSamples; + if (ev.mTimeSamples.length >= NS) { + System.arraycopy(o.mTimeSamples, 0, ev.mTimeSamples, 0, NS); + } else { + ev.mTimeSamples = (long[])o.mTimeSamples.clone(); } + + final int NP = (ev.mNumPointers=o.mNumPointers); + if (ev.mPointerIdentifiers.length >= NP) { + System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, NP); + } else { + ev.mPointerIdentifiers = (int[])o.mPointerIdentifiers.clone(); + } + + final int ND = NP * NS * NUM_SAMPLE_DATA; + if (ev.mDataSamples.length >= ND) { + System.arraycopy(o.mDataSamples, 0, ev.mDataSamples, 0, ND); + } else { + ev.mDataSamples = (float[])o.mDataSamples.clone(); + } + + return ev; } /** - * Create a new MotionEvent, copying from an existing one. + * Create a new MotionEvent, copying from an existing one, but not including + * any historical point information. */ - static public MotionEvent obtain(MotionEvent o) { + static public MotionEvent obtainNoHistory(MotionEvent o) { MotionEvent ev = obtain(); ev.mDeviceId = o.mDeviceId; ev.mEdgeFlags = o.mEdgeFlags; ev.mDownTime = o.mDownTime; - ev.mEventTime = o.mEventTime; + ev.mEventTimeNano = o.mEventTimeNano; ev.mAction = o.mAction; - ev.mX = o.mX; + ev.mNumPointers = o.mNumPointers; ev.mRawX = o.mRawX; - ev.mY = o.mY; ev.mRawY = o.mRawY; - ev.mPressure = o.mPressure; - ev.mSize = o.mSize; ev.mMetaState = o.mMetaState; ev.mXPrecision = o.mXPrecision; ev.mYPrecision = o.mYPrecision; - final int N = o.mNumHistory; - ev.mNumHistory = N; - if (N > 0) { - // could be more efficient about this... - ev.mHistory = (float[])o.mHistory.clone(); - ev.mHistoryTimes = (long[])o.mHistoryTimes.clone(); + + ev.mNumSamples = 1; + ev.mTimeSamples[0] = o.mTimeSamples[0]; + + final int NP = (ev.mNumPointers=o.mNumPointers); + if (ev.mPointerIdentifiers.length >= NP) { + System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, NP); + } else { + ev.mPointerIdentifiers = (int[])o.mPointerIdentifiers.clone(); } + + final int ND = NP * NUM_SAMPLE_DATA; + if (ev.mDataSamples.length >= ND) { + System.arraycopy(o.mDataSamples, 0, ev.mDataSamples, 0, ND); + } else { + ev.mDataSamples = (float[])o.mDataSamples.clone(); + } + return ev; } @@ -305,7 +608,7 @@ public final class MotionEvent implements Parcelable { synchronized (gRecyclerLock) { if (gRecyclerUsed < MAX_RECYCLED) { gRecyclerUsed++; - mNumHistory = 0; + mNumSamples = 0; mNext = gRecyclerTop; gRecyclerTop = this; } @@ -333,44 +636,145 @@ public final class MotionEvent implements Parcelable { * Returns the time (in ms) when this specific event was generated. */ public final long getEventTime() { - return mEventTime; + return mTimeSamples[0]; } /** - * Returns the X coordinate of this event. Whole numbers are pixels; the - * value may have a fraction for input devices that are sub-pixel precise. + * Returns the time (in ns) when this specific event was generated. + * The value is in nanosecond precision but it may not have nanosecond accuracy. + * + * @hide + */ + public final long getEventTimeNano() { + return mEventTimeNano; + } + + /** + * {@link #getX(int)} for the first pointer index (may be an + * arbitrary pointer identifier). */ public final float getX() { - return mX; + return mDataSamples[SAMPLE_X]; } /** - * Returns the Y coordinate of this event. Whole numbers are pixels; the - * value may have a fraction for input devices that are sub-pixel precise. + * {@link #getY(int)} for the first pointer index (may be an + * arbitrary pointer identifier). */ public final float getY() { - return mY; + return mDataSamples[SAMPLE_Y]; + } + + /** + * {@link #getPressure(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getPressure() { + return mDataSamples[SAMPLE_PRESSURE]; + } + + /** + * {@link #getSize(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getSize() { + return mDataSamples[SAMPLE_SIZE]; + } + + /** + * The number of pointers of data contained in this event. Always + * >= 1. + */ + public final int getPointerCount() { + return mNumPointers; + } + + /** + * Return the pointer identifier associated with a particular pointer + * data index is this event. The identifier tells you the actual pointer + * number associated with the data, accounting for individual pointers + * going up and down since the start of the current gesture. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. + */ + public final int getPointerId(int pointerIndex) { + return mPointerIdentifiers[pointerIndex]; + } + + /** + * Given a pointer identifier, find the index of its data in the event. + * + * @param pointerId The identifier of the pointer to be found. + * @return Returns either the index of the pointer (for use with + * {@link #getX(int) et al.), or -1 if there is no data available for + * that pointer identifier. + */ + public final int findPointerIndex(int pointerId) { + int i = mNumPointers; + while (i > 0) { + i--; + if (mPointerIdentifiers[i] == pointerId) { + return i; + } + } + return -1; + } + + /** + * Returns the X coordinate of this event for the given pointer + * <em>index</em> (use {@link #getPointerId(int)} to find the pointer + * identifier for this index). + * Whole numbers are pixels; the + * value may have a fraction for input devices that are sub-pixel precise. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. + */ + public final float getX(int pointerIndex) { + return mDataSamples[(pointerIndex*NUM_SAMPLE_DATA) + SAMPLE_X]; } /** - * Returns the current pressure of this event. The pressure generally + * Returns the Y coordinate of this event for the given pointer + * <em>index</em> (use {@link #getPointerId(int)} to find the pointer + * identifier for this index). + * Whole numbers are pixels; the + * value may have a fraction for input devices that are sub-pixel precise. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. + */ + public final float getY(int pointerIndex) { + return mDataSamples[(pointerIndex*NUM_SAMPLE_DATA) + SAMPLE_Y]; + } + + /** + * Returns the current pressure of this event for the given pointer + * <em>index</em> (use {@link #getPointerId(int)} to find the pointer + * identifier for this index). + * The pressure generally * ranges from 0 (no pressure at all) to 1 (normal pressure), however * values higher than 1 may be generated depending on the calibration of * the input device. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. */ - public final float getPressure() { - return mPressure; + public final float getPressure(int pointerIndex) { + return mDataSamples[(pointerIndex*NUM_SAMPLE_DATA) + SAMPLE_PRESSURE]; } /** - * Returns a scaled value of the approximate size, of the area being pressed when - * touched with the finger. The actual value in pixels corresponding to the finger - * touch is normalized with the device specific range of values + * Returns a scaled value of the approximate size for the given pointer + * <em>index</em> (use {@link #getPointerId(int)} to find the pointer + * identifier for this index). + * This represents some approximation of the area of the screen being + * pressed; the actual value in pixels corresponding to the + * touch is normalized with the device specific range of values * and scaled to a value between 0 and 1. The value of size can be used to * determine fat touch events. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. */ - public final float getSize() { - return mSize; + public final float getSize(int pointerIndex) { + return mDataSamples[(pointerIndex*NUM_SAMPLE_DATA) + SAMPLE_SIZE]; } /** @@ -436,7 +840,7 @@ public final class MotionEvent implements Parcelable { * @return Returns the number of historical points in the event. */ public final int getHistorySize() { - return mNumHistory; + return mNumSamples - 1; } /** @@ -450,63 +854,111 @@ public final class MotionEvent implements Parcelable { * @see #getEventTime */ public final long getHistoricalEventTime(int pos) { - return mHistoryTimes[pos]; + return mTimeSamples[pos + 1]; } /** - * Returns a historical X coordinate that occurred between this event - * and the previous event. Only applies to ACTION_MOVE events. + * {@link #getHistoricalX(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getHistoricalX(int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + SAMPLE_X]; + } + + /** + * {@link #getHistoricalY(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getHistoricalY(int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + SAMPLE_Y]; + } + + /** + * {@link #getHistoricalPressure(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getHistoricalPressure(int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + SAMPLE_PRESSURE]; + } + + /** + * {@link #getHistoricalSize(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + */ + public final float getHistoricalSize(int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + SAMPLE_SIZE]; + } + + /** + * Returns a historical X coordinate, as per {@link #getX(int)}, that + * occurred between this event and the previous event for the given pointer. + * Only applies to ACTION_MOVE events. * + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. * @param pos Which historical value to return; must be less than * {@link #getHistorySize} * * @see #getHistorySize * @see #getX */ - public final float getHistoricalX(int pos) { - return mHistory[pos*4]; + public final float getHistoricalX(int pointerIndex, int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + + (pointerIndex * NUM_SAMPLE_DATA) + SAMPLE_X]; } /** - * Returns a historical Y coordinate that occurred between this event - * and the previous event. Only applies to ACTION_MOVE events. + * Returns a historical Y coordinate, as per {@link #getY(int)}, that + * occurred between this event and the previous event for the given pointer. + * Only applies to ACTION_MOVE events. * + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. * @param pos Which historical value to return; must be less than * {@link #getHistorySize} * * @see #getHistorySize * @see #getY */ - public final float getHistoricalY(int pos) { - return mHistory[pos*4 + 1]; + public final float getHistoricalY(int pointerIndex, int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + + (pointerIndex * NUM_SAMPLE_DATA) + SAMPLE_Y]; } /** - * Returns a historical pressure coordinate that occurred between this event - * and the previous event. Only applies to ACTION_MOVE events. + * Returns a historical pressure coordinate, as per {@link #getPressure(int)}, + * that occurred between this event and the previous event for the given + * pointer. Only applies to ACTION_MOVE events. * + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. * @param pos Which historical value to return; must be less than * {@link #getHistorySize} - * + * * @see #getHistorySize * @see #getPressure */ - public final float getHistoricalPressure(int pos) { - return mHistory[pos*4 + 2]; + public final float getHistoricalPressure(int pointerIndex, int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + + (pointerIndex * NUM_SAMPLE_DATA) + SAMPLE_PRESSURE]; } /** - * Returns a historical size coordinate that occurred between this event - * and the previous event. Only applies to ACTION_MOVE events. + * Returns a historical size coordinate, as per {@link #getSize(int)}, that + * occurred between this event and the previous event for the given pointer. + * Only applies to ACTION_MOVE events. * + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. * @param pos Which historical value to return; must be less than * {@link #getHistorySize} - * + * * @see #getHistorySize * @see #getSize */ - public final float getHistoricalSize(int pos) { - return mHistory[pos*4 + 3]; + public final float getHistoricalSize(int pointerIndex, int pos) { + return mDataSamples[((pos + 1) * NUM_SAMPLE_DATA * mNumPointers) + + (pointerIndex * NUM_SAMPLE_DATA) + SAMPLE_SIZE]; } /** @@ -556,16 +1008,11 @@ public final class MotionEvent implements Parcelable { * @param deltaY Amount to add to the current Y coordinate of the event. */ public final void offsetLocation(float deltaX, float deltaY) { - mX += deltaX; - mY += deltaY; - final int N = mNumHistory*4; - if (N <= 0) { - return; - } - final float[] pos = mHistory; - for (int i=0; i<N; i+=4) { - pos[i] += deltaX; - pos[i+1] += deltaY; + final int N = mNumPointers*mNumSamples*4; + final float[] pos = mDataSamples; + for (int i=0; i<N; i+=NUM_SAMPLE_DATA) { + pos[i+SAMPLE_X] += deltaX; + pos[i+SAMPLE_Y] += deltaY; } } @@ -577,8 +1024,8 @@ public final class MotionEvent implements Parcelable { * @param y New absolute Y location. */ public final void setLocation(float x, float y) { - float deltaX = x-mX; - float deltaY = y-mY; + float deltaX = x-mDataSamples[SAMPLE_X]; + float deltaY = y-mDataSamples[SAMPLE_Y]; if (deltaX != 0 || deltaY != 0) { offsetLocation(deltaX, deltaY); } @@ -590,58 +1037,119 @@ public final class MotionEvent implements Parcelable { * the future, the current values in the event will be added to a list of * historic values. * + * @param eventTime The time stamp for this data. * @param x The new X position. * @param y The new Y position. * @param pressure The new pressure. * @param size The new size. + * @param metaState Meta key state. */ public final void addBatch(long eventTime, float x, float y, float pressure, float size, int metaState) { - float[] history = mHistory; - long[] historyTimes = mHistoryTimes; - int N; - int avail; - if (history == null) { - mHistory = history = new float[8*4]; - mHistoryTimes = historyTimes = new long[8]; - mNumHistory = N = 0; - avail = 8; - } else { - N = mNumHistory; - avail = history.length/4; - if (N == avail) { - avail += 8; - float[] newHistory = new float[avail*4]; - System.arraycopy(history, 0, newHistory, 0, N*4); - mHistory = history = newHistory; - long[] newHistoryTimes = new long[avail]; - System.arraycopy(historyTimes, 0, newHistoryTimes, 0, N); - mHistoryTimes = historyTimes = newHistoryTimes; - } + float[] data = mDataSamples; + long[] times = mTimeSamples; + + final int NP = mNumPointers; + final int NS = mNumSamples; + final int NI = NP*NS; + final int ND = NI * NUM_SAMPLE_DATA; + if (data.length <= ND) { + final int NEW_ND = ND + (NP * (BASE_AVAIL_SAMPLES * NUM_SAMPLE_DATA)); + float[] newData = new float[NEW_ND]; + System.arraycopy(data, 0, newData, 0, ND); + mDataSamples = data = newData; + } + if (times.length <= NS) { + final int NEW_NS = NS + BASE_AVAIL_SAMPLES; + long[] newHistoryTimes = new long[NEW_NS]; + System.arraycopy(times, 0, newHistoryTimes, 0, NS); + mTimeSamples = times = newHistoryTimes; } + + times[NS] = times[0]; + times[0] = eventTime; + + final int pos = NS*NUM_SAMPLE_DATA; + data[pos+SAMPLE_X] = data[SAMPLE_X]; + data[pos+SAMPLE_Y] = data[SAMPLE_Y]; + data[pos+SAMPLE_PRESSURE] = data[SAMPLE_PRESSURE]; + data[pos+SAMPLE_SIZE] = data[SAMPLE_SIZE]; + data[SAMPLE_X] = x; + data[SAMPLE_Y] = y; + data[SAMPLE_PRESSURE] = pressure; + data[SAMPLE_SIZE] = size; + mNumSamples = NS+1; - historyTimes[N] = mEventTime; + mRawX = x; + mRawY = y; + mMetaState |= metaState; + } - final int pos = N*4; - history[pos] = mX; - history[pos+1] = mY; - history[pos+2] = mPressure; - history[pos+3] = mSize; - mNumHistory = N+1; + /** + * Add a new movement to the batch of movements in this event. The + * input data must contain (NUM_SAMPLE_DATA * {@link #getPointerCount()}) + * samples of data. + * + * @param eventTime The time stamp for this data. + * @param inData The actual data. + * @param metaState Meta key state. + * + * @hide + */ + public final void addBatch(long eventTime, float[] inData, int metaState) { + float[] data = mDataSamples; + long[] times = mTimeSamples; + + final int NP = mNumPointers; + final int NS = mNumSamples; + final int NI = NP*NS; + final int ND = NI * NUM_SAMPLE_DATA; + if (data.length <= ND) { + final int NEW_ND = ND + (NP * (BASE_AVAIL_SAMPLES * NUM_SAMPLE_DATA)); + float[] newData = new float[NEW_ND]; + System.arraycopy(data, 0, newData, 0, ND); + mDataSamples = data = newData; + } + if (times.length <= NS) { + final int NEW_NS = NS + BASE_AVAIL_SAMPLES; + long[] newHistoryTimes = new long[NEW_NS]; + System.arraycopy(times, 0, newHistoryTimes, 0, NS); + mTimeSamples = times = newHistoryTimes; + } + + times[NS] = times[0]; + times[0] = eventTime; + + System.arraycopy(data, 0, data, ND, mNumPointers*NUM_SAMPLE_DATA); + System.arraycopy(inData, 0, data, 0, mNumPointers*NUM_SAMPLE_DATA); + + mNumSamples = NS+1; - mEventTime = eventTime; - mX = mRawX = x; - mY = mRawY = y; - mPressure = pressure; - mSize = size; + mRawX = inData[SAMPLE_X]; + mRawY = inData[SAMPLE_Y]; mMetaState |= metaState; + + if (DEBUG_POINTERS) { + StringBuilder sb = new StringBuilder(128); + sb.append("Add:"); + for (int i=0; i<mNumPointers; i++) { + sb.append(" #"); + sb.append(mPointerIdentifiers[i]); + sb.append("("); + sb.append(mDataSamples[(i*NUM_SAMPLE_DATA) + SAMPLE_X]); + sb.append(","); + sb.append(mDataSamples[(i*NUM_SAMPLE_DATA) + SAMPLE_Y]); + sb.append(")"); + } + Log.v("MotionEvent", sb.toString()); + } } @Override public String toString() { return "MotionEvent{" + Integer.toHexString(System.identityHashCode(this)) - + " action=" + mAction + " x=" + mX - + " y=" + mY + " pressure=" + mPressure + " size=" + mSize + "}"; + + " action=" + mAction + " x=" + getX() + + " y=" + getY() + " pressure=" + getPressure() + " size=" + getSize() + "}"; } public static final Parcelable.Creator<MotionEvent> CREATOR @@ -663,26 +1171,29 @@ public final class MotionEvent implements Parcelable { public void writeToParcel(Parcel out, int flags) { out.writeLong(mDownTime); - out.writeLong(mEventTime); + out.writeLong(mEventTimeNano); out.writeInt(mAction); - out.writeFloat(mX); - out.writeFloat(mY); - out.writeFloat(mPressure); - out.writeFloat(mSize); out.writeInt(mMetaState); out.writeFloat(mRawX); out.writeFloat(mRawY); - final int N = mNumHistory; - out.writeInt(N); - if (N > 0) { - final int N4 = N*4; + final int NP = mNumPointers; + out.writeInt(NP); + final int NS = mNumSamples; + out.writeInt(NS); + final int NI = NP*NS; + if (NI > 0) { int i; - float[] history = mHistory; - for (i=0; i<N4; i++) { + int[] state = mPointerIdentifiers; + for (i=0; i<NP; i++) { + out.writeInt(state[i]); + } + final int ND = NI*NUM_SAMPLE_DATA; + float[] history = mDataSamples; + for (i=0; i<ND; i++) { out.writeFloat(history[i]); } - long[] times = mHistoryTimes; - for (i=0; i<N; i++) { + long[] times = mTimeSamples; + for (i=0; i<NS; i++) { out.writeLong(times[i]); } } @@ -694,30 +1205,37 @@ public final class MotionEvent implements Parcelable { private void readFromParcel(Parcel in) { mDownTime = in.readLong(); - mEventTime = in.readLong(); + mEventTimeNano = in.readLong(); mAction = in.readInt(); - mX = in.readFloat(); - mY = in.readFloat(); - mPressure = in.readFloat(); - mSize = in.readFloat(); mMetaState = in.readInt(); mRawX = in.readFloat(); mRawY = in.readFloat(); - final int N = in.readInt(); - if ((mNumHistory=N) > 0) { - final int N4 = N*4; - float[] history = mHistory; - if (history == null || history.length < N4) { - mHistory = history = new float[N4 + (4*4)]; + final int NP = in.readInt(); + mNumPointers = NP; + final int NS = in.readInt(); + mNumSamples = NS; + final int NI = NP*NS; + if (NI > 0) { + int[] ids = mPointerIdentifiers; + if (ids.length < NP) { + mPointerIdentifiers = ids = new int[NP]; + } + for (int i=0; i<NP; i++) { + ids[i] = in.readInt(); + } + float[] history = mDataSamples; + final int ND = NI*NUM_SAMPLE_DATA; + if (history.length < ND) { + mDataSamples = history = new float[ND]; } - for (int i=0; i<N4; i++) { + for (int i=0; i<ND; i++) { history[i] = in.readFloat(); } - long[] times = mHistoryTimes; - if (times == null || times.length < N) { - mHistoryTimes = times = new long[N + 4]; + long[] times = mTimeSamples; + if (times == null || times.length < NS) { + mTimeSamples = times = new long[NS]; } - for (int i=0; i<N; i++) { + for (int i=0; i<NS; i++) { times[i] = in.readLong(); } } diff --git a/core/java/android/view/RawInputEvent.java b/core/java/android/view/RawInputEvent.java index 30da83e..db024b4 100644 --- a/core/java/android/view/RawInputEvent.java +++ b/core/java/android/view/RawInputEvent.java @@ -13,6 +13,8 @@ public class RawInputEvent { public static final int CLASS_ALPHAKEY = 0x00000002; public static final int CLASS_TOUCHSCREEN = 0x00000004; public static final int CLASS_TRACKBALL = 0x00000008; + public static final int CLASS_TOUCHSCREEN_MT = 0x00000010; + public static final int CLASS_DPAD = 0x00000020; // More special classes for QueuedEvent below. public static final int CLASS_CONFIGURATION_CHANGED = 0x10000000; @@ -158,8 +160,21 @@ public class RawInputEvent { public static final int ABS_TOOL_WIDTH = 0x1c; public static final int ABS_VOLUME = 0x20; public static final int ABS_MISC = 0x28; + public static final int ABS_MT_TOUCH_MAJOR = 0x30; + public static final int ABS_MT_TOUCH_MINOR = 0x31; + public static final int ABS_MT_WIDTH_MAJOR = 0x32; + public static final int ABS_MT_WIDTH_MINOR = 0x33; + public static final int ABS_MT_ORIENTATION = 0x34; + public static final int ABS_MT_POSITION_X = 0x35; + public static final int ABS_MT_POSITION_Y = 0x36; + public static final int ABS_MT_TOOL_TYPE = 0x37; + public static final int ABS_MT_BLOB_ID = 0x38; public static final int ABS_MAX = 0x3f; + public static final int SYN_REPORT = 0; + public static final int SYN_CONFIG = 1; + public static final int SYN_MT_REPORT = 2; + public int deviceId; public int type; public int scancode; diff --git a/core/java/android/view/Surface.java b/core/java/android/view/Surface.java index 5100fff..5cecac3 100644 --- a/core/java/android/view/Surface.java +++ b/core/java/android/view/Surface.java @@ -34,12 +34,18 @@ public class Surface implements Parcelable { /** Surface is created hidden */ public static final int HIDDEN = 0x00000004; - /** The surface is to be used by hardware accelerators or DMA engines */ + /** The surface is to be used by hardware accelerators or DMA engines + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int HARDWARE = 0x00000010; /** Implies "HARDWARE", the surface is to be used by the GPU * additionally the backbuffer is never preserved for these - * surfaces. */ + * surfaces. + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int GPU = 0x00000028; /** The surface contains secure content, special measures will @@ -135,6 +141,8 @@ public class Surface implements Parcelable { @SuppressWarnings("unused") private int mSurface; @SuppressWarnings("unused") + private int mSurfaceControl; + @SuppressWarnings("unused") private int mSaveCount; @SuppressWarnings("unused") private Canvas mCanvas; @@ -238,7 +246,7 @@ public class Surface implements Parcelable { }; /** - * Sets the display metrics used to provide canva's width/height in comaptibility mode. + * Sets the display metrics used to provide canva's width/height in compatibility mode. */ void setCompatibleDisplayMetrics(DisplayMetrics metrics, Translator translator) { mCompatibleDisplayMetrics = metrics; @@ -267,7 +275,8 @@ public class Surface implements Parcelable { public native void clear(); /** draw into a surface */ - public Canvas lockCanvas(Rect dirty) throws OutOfResourcesException { + public Canvas lockCanvas(Rect dirty) throws OutOfResourcesException, IllegalArgumentException + { /* the dirty rectangle may be expanded to the surface's size, if * for instance it has been resized or if the bits were lost, since * the last call. @@ -349,7 +358,7 @@ public class Surface implements Parcelable { @Override public String toString() { - return "Surface(native-token=" + mSurface + ")"; + return "Surface(native-token=" + mSurfaceControl + ")"; } private Surface(Parcel source) throws OutOfResourcesException { @@ -362,7 +371,7 @@ public class Surface implements Parcelable { public native void readFromParcel(Parcel source); public native void writeToParcel(Parcel dest, int flags); - + public static final Parcelable.Creator<Surface> CREATOR = new Parcelable.Creator<Surface>() { @@ -383,7 +392,7 @@ public class Surface implements Parcelable { /* no user serviceable parts here ... */ @Override protected void finalize() throws Throwable { - clear(); + release(); } private native void init(SurfaceSession s, @@ -391,4 +400,6 @@ public class Surface implements Parcelable { throws OutOfResourcesException; private native void init(Parcel source); + + private native void release(); } diff --git a/core/java/android/view/SurfaceHolder.java b/core/java/android/view/SurfaceHolder.java index 3d0dda3..64a10d1 100644 --- a/core/java/android/view/SurfaceHolder.java +++ b/core/java/android/view/SurfaceHolder.java @@ -38,8 +38,6 @@ public interface SurfaceHolder { * Surface type. * * @see #SURFACE_TYPE_NORMAL - * @see #SURFACE_TYPE_HARDWARE - * @see #SURFACE_TYPE_GPU * @see #SURFACE_TYPE_PUSH_BUFFERS */ @@ -47,9 +45,15 @@ public interface SurfaceHolder { * contiguous, cached/buffered RAM. */ public static final int SURFACE_TYPE_NORMAL = MEMORY_TYPE_NORMAL; /** Surface type: creates a suited to be used with DMA engines and - * hardware accelerators. */ + * hardware accelerators. + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int SURFACE_TYPE_HARDWARE = MEMORY_TYPE_HARDWARE; - /** Surface type: creates a surface suited to be used with the GPU */ + /** Surface type: creates a surface suited to be used with the GPU + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int SURFACE_TYPE_GPU = MEMORY_TYPE_GPU; /** Surface type: creates a "push" surface, that is a surface that * doesn't owns its buffers. With such a surface lockCanvas will fail. */ @@ -139,11 +143,7 @@ public interface SurfaceHolder { public boolean isCreating(); /** - * Sets the surface's type. Surfaces intended to be used with OpenGL ES - * should be of SURFACE_TYPE_GPU, surfaces accessed by DMA engines and - * hardware accelerators should be of type SURFACE_TYPE_HARDWARE. - * Failing to set the surface's type appropriately could result in - * degraded performance or failure. + * Sets the surface's type. * * @param type The surface's memory type. */ diff --git a/core/java/android/view/SurfaceView.java b/core/java/android/view/SurfaceView.java index 9cf7092..ea879ed9 100644 --- a/core/java/android/view/SurfaceView.java +++ b/core/java/android/view/SurfaceView.java @@ -16,6 +16,8 @@ package android.view; +import com.android.internal.view.BaseIWindow; + import android.content.Context; import android.content.res.Resources; import android.content.res.CompatibilityInfo.Translator; @@ -32,8 +34,9 @@ import android.os.ParcelFileDescriptor; import android.util.AttributeSet; import android.util.Config; import android.util.Log; -import java.util.ArrayList; +import java.lang.ref.WeakReference; +import java.util.ArrayList; import java.util.concurrent.locks.ReentrantLock; import java.lang.ref.WeakReference; @@ -279,7 +282,9 @@ public class SurfaceView extends View { return; } ViewRoot viewRoot = (ViewRoot) getRootView().getParent(); - mTranslator = viewRoot.mTranslator; + if (viewRoot != null) { + mTranslator = viewRoot.mTranslator; + } Resources res = getContext().getResources(); if (mTranslator != null || !res.getCompatibilityInfo().supportsScreen()) { @@ -434,7 +439,7 @@ public class SurfaceView extends View { updateWindow(false); } - private static class MyWindow extends IWindow.Stub { + private static class MyWindow extends BaseIWindow { private final WeakReference<SurfaceView> mSurfaceView; public MyWindow(SurfaceView surfaceView) { @@ -476,7 +481,8 @@ public class SurfaceView extends View { } } - public void dispatchPointer(MotionEvent event, long eventTime) { + public void dispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { Log.w("SurfaceView", "Unexpected pointer event in surface: " + event); //if (mSession != null && mSurface != null) { // try { @@ -486,7 +492,8 @@ public class SurfaceView extends View { //} } - public void dispatchTrackball(MotionEvent event, long eventTime) { + public void dispatchTrackball(MotionEvent event, long eventTime, + boolean callWhenDone) { Log.w("SurfaceView", "Unexpected trackball event in surface: " + event); //if (mSession != null && mSurface != null) { // try { @@ -568,9 +575,14 @@ public class SurfaceView extends View { public void setType(int type) { switch (type) { - case SURFACE_TYPE_NORMAL: case SURFACE_TYPE_HARDWARE: case SURFACE_TYPE_GPU: + // these are deprecated, treat as "NORMAL" + type = SURFACE_TYPE_NORMAL; + break; + } + switch (type) { + case SURFACE_TYPE_NORMAL: case SURFACE_TYPE_PUSH_BUFFERS: mRequestedType = type; if (mWindow != null) { diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java index 7ed2712..1dd0096 100644 --- a/core/java/android/view/View.java +++ b/core/java/android/view/View.java @@ -2983,6 +2983,8 @@ public class View implements Drawable.Callback, KeyEvent.Callback, Accessibility * @param enabled True if this view is enabled, false otherwise. */ public void setEnabled(boolean enabled) { + if (enabled == isEnabled()) return; + setFlags(enabled ? ENABLED : DISABLED, ENABLED_MASK); /* @@ -6911,7 +6913,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, Accessibility /** * Set the background to a given resource. The resource should refer to - * a Drawable object. + * a Drawable object or 0 to remove the background. * @param resid The identifier of the resource. * @attr ref android.R.styleable#View_background */ diff --git a/core/java/android/view/ViewRoot.java b/core/java/android/view/ViewRoot.java index f7cb06b..fe3f47f 100644 --- a/core/java/android/view/ViewRoot.java +++ b/core/java/android/view/ViewRoot.java @@ -79,6 +79,9 @@ public final class ViewRoot extends Handler implements ViewParent, private static final boolean DEBUG_IMF = false || LOCAL_LOGV; private static final boolean WATCH_POINTER = false; + private static final boolean MEASURE_LATENCY = false; + private static LatencyTimer lt; + /** * Maximum time we allow the user to roll the trackball enough to generate * a key event, before resetting the counters. @@ -148,7 +151,8 @@ public final class ViewRoot extends Handler implements ViewParent, boolean mWindowAttributesChanged = false; // These can be accessed by any thread, must be protected with a lock. - Surface mSurface; + // Surface can never be reassigned or cleared (use Surface.clear()). + private final Surface mSurface = new Surface(); boolean mAdded; boolean mAddedTouchMode; @@ -188,18 +192,11 @@ public final class ViewRoot extends Handler implements ViewParent, private final int mDensity; - public ViewRoot(Context context) { - super(); - - ++sInstanceCount; - - // Initialize the statics when this class is first instantiated. This is - // done here instead of in the static block because Zygote does not - // allow the spawning of threads. + public static IWindowSession getWindowSession(Looper mainLooper) { synchronized (mStaticInit) { if (!mInitialized) { try { - InputMethodManager imm = InputMethodManager.getInstance(context); + InputMethodManager imm = InputMethodManager.getInstance(mainLooper); sWindowSession = IWindowManager.Stub.asInterface( ServiceManager.getService("window")) .openSession(imm.getClient(), imm.getInputContext()); @@ -207,8 +204,24 @@ public final class ViewRoot extends Handler implements ViewParent, } catch (RemoteException e) { } } + return sWindowSession; } + } + + public ViewRoot(Context context) { + super(); + + if (MEASURE_LATENCY && lt == null) { + lt = new LatencyTimer(100, 1000); + } + + ++sInstanceCount; + // Initialize the statics when this class is first instantiated. This is + // done here instead of in the static block because Zygote does not + // allow the spawning of threads. + getWindowSession(context.getMainLooper()); + mThread = Thread.currentThread(); mLocation = new WindowLeaked(null); mLocation.fillInStackTrace(); @@ -224,7 +237,6 @@ public final class ViewRoot extends Handler implements ViewParent, mTransparentRegion = new Region(); mPreviousTransparentRegion = new Region(); mFirst = true; // true for the first time the view is added - mSurface = new Surface(); mAdded = false; mAttachInfo = new View.AttachInfo(sWindowSession, mWindow, this, this); mViewConfiguration = ViewConfiguration.get(context); @@ -674,7 +686,6 @@ public final class ViewRoot extends Handler implements ViewParent, attachInfo.mKeepScreenOn = false; viewVisibilityChanged = false; host.dispatchAttachedToWindow(attachInfo, 0); - getRunQueue().executeActions(attachInfo.mHandler); //Log.i(TAG, "Screen on initialized: " + attachInfo.mKeepScreenOn); } else { @@ -707,6 +718,10 @@ public final class ViewRoot extends Handler implements ViewParent, boolean insetsChanged = false; if (mLayoutRequested) { + // Execute enqueued actions on every layout in case a view that was detached + // enqueued an action after being detached + getRunQueue().executeActions(attachInfo.mHandler); + if (mFirst) { host.fitSystemWindows(mAttachInfo.mContentInsets); // make sure touch mode code executes by setting cached value @@ -1550,10 +1565,12 @@ public final class ViewRoot extends Handler implements ViewParent, mView = null; mAttachInfo.mRootView = null; + mAttachInfo.mSurface = null; if (mUseGL) { destroyGL(); } + mSurface.clear(); try { sWindowSession.remove(mWindow); @@ -1623,16 +1640,24 @@ public final class ViewRoot extends Handler implements ViewParent, break; case DISPATCH_POINTER: { MotionEvent event = (MotionEvent)msg.obj; - - boolean didFinish; + boolean callWhenDone = msg.arg1 != 0; + if (event == null) { try { + long timeBeforeGettingEvents; + if (MEASURE_LATENCY) { + timeBeforeGettingEvents = System.nanoTime(); + } + event = sWindowSession.getPendingPointerMove(mWindow); + + if (MEASURE_LATENCY && event != null) { + lt.sample("9 Client got events ", System.nanoTime() - event.getEventTimeNano()); + lt.sample("8 Client getting events ", timeBeforeGettingEvents - event.getEventTimeNano()); + } } catch (RemoteException e) { } - didFinish = true; - } else { - didFinish = event.getAction() == MotionEvent.ACTION_OUTSIDE; + callWhenDone = false; } if (event != null && mTranslator != null) { mTranslator.translateEventInScreenToAppWindow(event); @@ -1649,8 +1674,16 @@ public final class ViewRoot extends Handler implements ViewParent, if(Config.LOGV) { captureMotionLog("captureDispatchPointer", event); } - event.offsetLocation(0, mCurScrollY); + if (mCurScrollY != 0) { + event.offsetLocation(0, mCurScrollY); + } + if (MEASURE_LATENCY) { + lt.sample("A Dispatching TouchEvents", System.nanoTime() - event.getEventTimeNano()); + } handled = mView.dispatchTouchEvent(event); + if (MEASURE_LATENCY) { + lt.sample("B Dispatched TouchEvents ", System.nanoTime() - event.getEventTimeNano()); + } if (!handled && isDown) { int edgeSlop = mViewConfiguration.getScaledEdgeSlop(); @@ -1696,7 +1729,7 @@ public final class ViewRoot extends Handler implements ViewParent, } } } finally { - if (!didFinish) { + if (callWhenDone) { try { sWindowSession.finishKey(mWindow); } catch (RemoteException e) { @@ -1711,7 +1744,7 @@ public final class ViewRoot extends Handler implements ViewParent, } } break; case DISPATCH_TRACKBALL: - deliverTrackballEvent((MotionEvent)msg.obj); + deliverTrackballEvent((MotionEvent)msg.obj, msg.arg1 != 0); break; case DISPATCH_APP_VISIBILITY: handleAppVisibility(msg.arg1 != 0); @@ -1953,16 +1986,13 @@ public final class ViewRoot extends Handler implements ViewParent, } - private void deliverTrackballEvent(MotionEvent event) { - boolean didFinish; + private void deliverTrackballEvent(MotionEvent event, boolean callWhenDone) { if (event == null) { try { event = sWindowSession.getPendingTrackballMove(mWindow); } catch (RemoteException e) { } - didFinish = true; - } else { - didFinish = false; + callWhenDone = false; } if (DEBUG_TRACKBALL) Log.v(TAG, "Motion event:" + event); @@ -1980,7 +2010,7 @@ public final class ViewRoot extends Handler implements ViewParent, } } finally { if (handled) { - if (!didFinish) { + if (callWhenDone) { try { sWindowSession.finishKey(mWindow); } catch (RemoteException e) { @@ -2096,7 +2126,7 @@ public final class ViewRoot extends Handler implements ViewParent, mLastTrackballTime = curTime; } } finally { - if (!didFinish) { + if (callWhenDone) { try { sWindowSession.finishKey(mWindow); } catch (RemoteException e) { @@ -2497,7 +2527,7 @@ public final class ViewRoot extends Handler implements ViewParent, } } - mSurface = null; + mSurface.clear(); } if (mAdded) { mAdded = false; @@ -2559,15 +2589,19 @@ public final class ViewRoot extends Handler implements ViewParent, sendMessageAtTime(msg, event.getEventTime()); } - public void dispatchPointer(MotionEvent event, long eventTime) { + public void dispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { Message msg = obtainMessage(DISPATCH_POINTER); msg.obj = event; + msg.arg1 = callWhenDone ? 1 : 0; sendMessageAtTime(msg, eventTime); } - public void dispatchTrackball(MotionEvent event, long eventTime) { + public void dispatchTrackball(MotionEvent event, long eventTime, + boolean callWhenDone) { Message msg = obtainMessage(DISPATCH_TRACKBALL); msg.obj = event; + msg.arg1 = callWhenDone ? 1 : 0; sendMessageAtTime(msg, eventTime); } @@ -2740,19 +2774,25 @@ public final class ViewRoot extends Handler implements ViewParent, } } - public void dispatchPointer(MotionEvent event, long eventTime) { + public void dispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { final ViewRoot viewRoot = mViewRoot.get(); - if (viewRoot != null) { - viewRoot.dispatchPointer(event, eventTime); + if (viewRoot != null) { + if (MEASURE_LATENCY) { + // Note: eventTime is in milliseconds + ViewRoot.lt.sample("* ViewRoot b4 dispatchPtr", System.nanoTime() - eventTime * 1000000); + } + viewRoot.dispatchPointer(event, eventTime, callWhenDone); } else { new EventCompletion(mMainLooper, this, null, true, event); } } - public void dispatchTrackball(MotionEvent event, long eventTime) { + public void dispatchTrackball(MotionEvent event, long eventTime, + boolean callWhenDone) { final ViewRoot viewRoot = mViewRoot.get(); if (viewRoot != null) { - viewRoot.dispatchTrackball(event, eventTime); + viewRoot.dispatchTrackball(event, eventTime, callWhenDone); } else { new EventCompletion(mMainLooper, this, null, false, event); } @@ -2822,6 +2862,9 @@ public final class ViewRoot extends Handler implements ViewParent, } } } + + public void dispatchWallpaperOffsets(float x, float y) { + } } /** @@ -3102,7 +3145,7 @@ public final class ViewRoot extends Handler implements ViewParent, handler.postDelayed(handlerAction.action, handlerAction.delay); } - mActions.clear(); + actions.clear(); } } @@ -3116,7 +3159,6 @@ public final class ViewRoot extends Handler implements ViewParent, if (o == null || getClass() != o.getClass()) return false; HandlerAction that = (HandlerAction) o; - return !(action != null ? !action.equals(that.action) : that.action != null); } diff --git a/core/java/android/view/ViewStub.java b/core/java/android/view/ViewStub.java index e159de4..703a38f 100644 --- a/core/java/android/view/ViewStub.java +++ b/core/java/android/view/ViewStub.java @@ -23,6 +23,8 @@ import android.util.AttributeSet; import com.android.internal.R; +import java.lang.ref.WeakReference; + /** * A ViewStub is an invisible, zero-sized View that can be used to lazily inflate * layout resources at runtime. @@ -68,6 +70,8 @@ public final class ViewStub extends View { private int mLayoutResource = 0; private int mInflatedId; + private WeakReference<View> mInflatedViewRef; + private OnInflateListener mInflateListener; public ViewStub(Context context) { @@ -196,9 +200,15 @@ public final class ViewStub extends View { */ @Override public void setVisibility(int visibility) { - super.setVisibility(visibility); - - if (visibility == VISIBLE || visibility == INVISIBLE) { + if (mInflatedViewRef != null) { + View view = mInflatedViewRef.get(); + if (view != null) { + view.setVisibility(visibility); + } else { + throw new IllegalStateException("setVisibility called on un-referenced view"); + } + } else if (visibility == VISIBLE || visibility == INVISIBLE) { + super.setVisibility(visibility); inflate(); } } @@ -234,6 +244,8 @@ public final class ViewStub extends View { parent.addView(view, index); } + mInflatedViewRef = new WeakReference(view); + if (mInflateListener != null) { mInflateListener.onInflate(this, view); } diff --git a/core/java/android/view/VolumePanel.java b/core/java/android/view/VolumePanel.java index a573983..e21824e 100644 --- a/core/java/android/view/VolumePanel.java +++ b/core/java/android/view/VolumePanel.java @@ -23,7 +23,9 @@ import android.content.res.Resources; import android.media.AudioManager; import android.media.AudioService; import android.media.AudioSystem; +import android.media.RingtoneManager; import android.media.ToneGenerator; +import android.net.Uri; import android.os.Handler; import android.os.Message; import android.os.Vibrator; @@ -44,7 +46,7 @@ import android.widget.Toast; public class VolumePanel extends Handler { private static final String TAG = "VolumePanel"; - private static boolean LOGD = false || Config.LOGD; + private static boolean LOGD = false; /** * The delay before playing a sound. This small period exists so the user @@ -86,6 +88,7 @@ public class VolumePanel extends Handler protected Context mContext; private AudioManager mAudioManager; protected AudioService mAudioService; + private boolean mRingIsSilent; private final Toast mToast; private final View mView; @@ -138,7 +141,7 @@ public class VolumePanel extends Handler onShowVolumeChanged(streamType, flags); } - if ((flags & AudioManager.FLAG_PLAY_SOUND) != 0) { + if ((flags & AudioManager.FLAG_PLAY_SOUND) != 0 && ! mRingIsSilent) { removeMessages(MSG_PLAY_SOUND); sendMessageDelayed(obtainMessage(MSG_PLAY_SOUND, streamType, flags), PLAY_SOUND_DELAY); } @@ -157,6 +160,7 @@ public class VolumePanel extends Handler int index = mAudioService.getStreamVolume(streamType); int message = UNKNOWN_VOLUME_TEXT; int additionalMessage = 0; + mRingIsSilent = false; if (LOGD) { Log.d(TAG, "onShowVolumeChanged(streamType: " + streamType @@ -169,8 +173,15 @@ public class VolumePanel extends Handler switch (streamType) { case AudioManager.STREAM_RING: { + setRingerIcon(); message = RINGTONE_VOLUME_TEXT; - setRingerIcon(index); + Uri ringuri = RingtoneManager.getActualDefaultRingtoneUri( + mContext, RingtoneManager.TYPE_RINGTONE); + if (ringuri == null) { + additionalMessage = + com.android.internal.R.string.volume_music_hint_silent_ringtone_selected; + mRingIsSilent = true; + } break; } @@ -208,6 +219,13 @@ public class VolumePanel extends Handler case AudioManager.STREAM_NOTIFICATION: { message = NOTIFICATION_VOLUME_TEXT; setSmallIcon(index); + Uri ringuri = RingtoneManager.getActualDefaultRingtoneUri( + mContext, RingtoneManager.TYPE_NOTIFICATION); + if (ringuri == null) { + additionalMessage = + com.android.internal.R.string.volume_music_hint_silent_ringtone_selected; + mRingIsSilent = true; + } break; } @@ -254,7 +272,6 @@ public class VolumePanel extends Handler mAudioService.shouldVibrate(AudioManager.VIBRATE_TYPE_RINGER)) { sendMessageDelayed(obtainMessage(MSG_VIBRATE), VIBRATE_DELAY); } - } protected void onPlaySound(int streamType, int flags) { @@ -337,17 +354,15 @@ public class VolumePanel extends Handler /** * Makes the ringer icon visible with an icon that is chosen * based on the current ringer mode. - * - * @param index */ - private void setRingerIcon(int index) { + private void setRingerIcon() { mSmallStreamIcon.setVisibility(View.GONE); mLargeStreamIcon.setVisibility(View.VISIBLE); int ringerMode = mAudioService.getRingerMode(); int icon; - if (LOGD) Log.d(TAG, "setRingerIcon(index: " + index+ "), ringerMode: " + ringerMode); + if (LOGD) Log.d(TAG, "setRingerIcon(), ringerMode: " + ringerMode); if (ringerMode == AudioManager.RINGER_MODE_SILENT) { icon = com.android.internal.R.drawable.ic_volume_off; diff --git a/core/java/android/view/Window.java b/core/java/android/view/Window.java index 576c8c1..1932765 100644 --- a/core/java/android/view/Window.java +++ b/core/java/android/view/Window.java @@ -56,11 +56,11 @@ public abstract class Window { public static final int FEATURE_CONTEXT_MENU = 6; /** Flag for custom title. You cannot combine this feature with other title features. */ public static final int FEATURE_CUSTOM_TITLE = 7; - /* Flag for asking for an OpenGL enabled window. + /** Flag for asking for an OpenGL enabled window. All 2D graphics will be handled by OpenGL ES. - Private for now, until it is better tested (not shipping in 1.0) + @hide */ - private static final int FEATURE_OPENGL = 8; + public static final int FEATURE_OPENGL = 8; /** Flag for setting the progress bar's visibility to VISIBLE */ public static final int PROGRESS_VISIBILITY_ON = -1; /** Flag for setting the progress bar's visibility to GONE */ @@ -237,7 +237,6 @@ public abstract class Window { /** * This is called whenever the current window attributes change. * - */ public void onWindowAttributesChanged(WindowManager.LayoutParams attrs); @@ -252,13 +251,29 @@ public abstract class Window { public void onContentChanged(); /** - * This hook is called whenever the window focus changes. + * This hook is called whenever the window focus changes. See + * {@link View#onWindowFocusChanged(boolean) + * View.onWindowFocusChanged(boolean)} for more information. * * @param hasFocus Whether the window now has focus. */ public void onWindowFocusChanged(boolean hasFocus); /** + * Called when the window has been attached to the window manager. + * See {@link View#onAttachedToWindow() View.onAttachedToWindow()} + * for more information. + */ + public void onAttachedToWindow(); + + /** + * Called when the window has been attached to the window manager. + * See {@link View#onDetachedFromWindow() View.onDetachedFromWindow()} + * for more information. + */ + public void onDetachedFromWindow(); + + /** * Called when a panel is being closed. If another logical subsequent * panel is being opened (and this panel is being closed to make room for the subsequent * panel), this method will NOT be called. diff --git a/core/java/android/view/WindowManager.java b/core/java/android/view/WindowManager.java index c0be9e8..8c12656 100644 --- a/core/java/android/view/WindowManager.java +++ b/core/java/android/view/WindowManager.java @@ -314,6 +314,12 @@ public interface WindowManager extends ViewManager { public static final int TYPE_INPUT_METHOD_DIALOG= FIRST_SYSTEM_WINDOW+12; /** + * Window type: wallpaper window, placed behind any window that wants + * to sit on top of the wallpaper. + */ + public static final int TYPE_WALLPAPER = FIRST_SYSTEM_WINDOW+13; + + /** * End of types of system windows. */ public static final int LAST_SYSTEM_WINDOW = 2999; @@ -323,8 +329,6 @@ public interface WindowManager extends ViewManager { * Default is normal. * * @see #MEMORY_TYPE_NORMAL - * @see #MEMORY_TYPE_HARDWARE - * @see #MEMORY_TYPE_GPU * @see #MEMORY_TYPE_PUSH_BUFFERS */ public int memoryType; @@ -332,10 +336,16 @@ public interface WindowManager extends ViewManager { /** Memory type: The window's surface is allocated in main memory. */ public static final int MEMORY_TYPE_NORMAL = 0; /** Memory type: The window's surface is configured to be accessible - * by DMA engines and hardware accelerators. */ + * by DMA engines and hardware accelerators. + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int MEMORY_TYPE_HARDWARE = 1; /** Memory type: The window's surface is configured to be accessible - * by graphics accelerators. */ + * by graphics accelerators. + * @deprecated this is ignored, this value is set automatically when needed. + */ + @Deprecated public static final int MEMORY_TYPE_GPU = 2; /** Memory type: The window's surface doesn't own its buffers and * therefore cannot be locked. Instead the buffers are pushed to @@ -479,16 +489,23 @@ public interface WindowManager extends ViewManager { * key guard or any other lock screens. Can be used with * {@link #FLAG_KEEP_SCREEN_ON} to turn screen on and display windows * directly before showing the key guard window - * - * {@hide} */ + */ public static final int FLAG_SHOW_WHEN_LOCKED = 0x00080000; + /** Window flag: ask that the system wallpaper be shown behind + * your window. The window surface must be translucent to be able + * to actually see the wallpaper behind it; this flag just ensures + * that the wallpaper surface will be there if this window actually + * has translucent regions. + */ + public static final int FLAG_SHOW_WALLPAPER = 0x00100000; + /** Window flag: special flag to limit the size of the window to be * original size ([320x480] x density). Used to create window for applications * running under compatibility mode. * * {@hide} */ - public static final int FLAG_COMPATIBLE_WINDOW = 0x00100000; + public static final int FLAG_COMPATIBLE_WINDOW = 0x20000000; /** Window flag: a special option intended for system dialogs. When * this flag is set, the window will demand focus unconditionally when diff --git a/core/java/android/view/WindowManagerPolicy.java b/core/java/android/view/WindowManagerPolicy.java index 1371932..ea08f33 100644 --- a/core/java/android/view/WindowManagerPolicy.java +++ b/core/java/android/view/WindowManagerPolicy.java @@ -344,6 +344,12 @@ public interface WindowManagerPolicy { public final int TRANSIT_TASK_TO_FRONT = 10; /** A window in an existing task is being put below all other tasks. */ public final int TRANSIT_TASK_TO_BACK = 11; + /** A window in a new activity is being opened on top of an existing one, + * and both are on top of the wallpaper. */ + public final int TRANSIT_WALLPAPER_ACTIVITY_OPEN = 12; + /** The window in the top-most activity is being closed to reveal the + * previous activity, and both are on top of he wallpaper. */ + public final int TRANSIT_WALLPAPER_ACTIVITY_CLOSE = 13; /** Screen turned off because of power button */ public final int OFF_BECAUSE_OF_USER = 1; @@ -533,14 +539,15 @@ public interface WindowManagerPolicy { * @param win The window that currently has focus. This is where the key * event will normally go. * @param code Key code. - * @param metaKeys TODO + * @param metaKeys bit mask of meta keys that are held. * @param down Is this a key press (true) or release (false)? * @param repeatCount Number of times a key down has repeated. + * @param flags event's flags. * @return Returns true if the policy consumed the event and it should * not be further dispatched. */ public boolean interceptKeyTi(WindowState win, int code, - int metaKeys, boolean down, int repeatCount); + int metaKeys, boolean down, int repeatCount, int flags); /** * Called when layout of the windows is about to start. @@ -792,6 +799,13 @@ public interface WindowManagerPolicy { public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always); /** + * A special function that is called from the very low-level input queue + * to provide feedback to the user. Currently only called for virtual + * keys. + */ + public void keyFeedbackFromInput(KeyEvent event); + + /** * Called when we have stopped keeping the screen on because a window * requesting this is no longer visible. */ diff --git a/core/java/android/view/inputmethod/InputMethodManager.java b/core/java/android/view/inputmethod/InputMethodManager.java index d797890..e30687f 100644 --- a/core/java/android/view/inputmethod/InputMethodManager.java +++ b/core/java/android/view/inputmethod/InputMethodManager.java @@ -446,13 +446,22 @@ public final class InputMethodManager { * @hide */ static public InputMethodManager getInstance(Context context) { + return getInstance(context.getMainLooper()); + } + + /** + * Internally, the input method manager can't be context-dependent, so + * we have this here for the places that need it. + * @hide + */ + static public InputMethodManager getInstance(Looper mainLooper) { synchronized (mInstanceSync) { if (mInstance != null) { return mInstance; } IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE); IInputMethodManager service = IInputMethodManager.Stub.asInterface(b); - mInstance = new InputMethodManager(service, context.getMainLooper()); + mInstance = new InputMethodManager(service, mainLooper); } return mInstance; } diff --git a/core/java/android/webkit/BrowserFrame.java b/core/java/android/webkit/BrowserFrame.java index dbd2682..afa2c35 100644 --- a/core/java/android/webkit/BrowserFrame.java +++ b/core/java/android/webkit/BrowserFrame.java @@ -109,6 +109,8 @@ class BrowserFrame extends Handler { CacheManager.init(context); // create CookieSyncManager with current Context CookieSyncManager.createInstance(context); + // create PluginManager with current Context + PluginManager.getInstance(context); } AssetManager am = context.getAssets(); nativeCreateFrame(w, am, proxy.getBackForwardList()); @@ -119,7 +121,7 @@ class BrowserFrame extends Handler { mDatabase = WebViewDatabase.getInstance(context); mWebViewCore = w; - if (WebView.LOGV_ENABLED) { + if (DebugFlags.BROWSER_FRAME) { Log.v(LOGTAG, "BrowserFrame constructor: this=" + this); } } @@ -341,7 +343,7 @@ class BrowserFrame extends Handler { switch (msg.what) { case FRAME_COMPLETED: { if (mSettings.getSavePassword() && hasPasswordField()) { - if (WebView.DEBUG) { + if (DebugFlags.BROWSER_FRAME) { Assert.assertNotNull(mCallbackProxy.getBackForwardList() .getCurrentItem()); } @@ -463,8 +465,6 @@ class BrowserFrame extends Handler { * @param postData If the method is "POST" postData is sent as the request * body. Is null when empty. * @param cacheMode The cache mode to use when loading this resource. - * @param isHighPriority True if this resource needs to be put at the front - * of the network queue. * @param synchronous True if the load is synchronous. * @return A newly created LoadListener object. */ @@ -474,7 +474,6 @@ class BrowserFrame extends Handler { HashMap headers, byte[] postData, int cacheMode, - boolean isHighPriority, boolean synchronous) { PerfChecker checker = new PerfChecker(); @@ -490,7 +489,7 @@ class BrowserFrame extends Handler { } if (mSettings.getSavePassword() && hasPasswordField()) { try { - if (WebView.DEBUG) { + if (DebugFlags.BROWSER_FRAME) { Assert.assertNotNull(mCallbackProxy.getBackForwardList() .getCurrentItem()); } @@ -538,10 +537,10 @@ class BrowserFrame extends Handler { // is this resource the main-frame top-level page? boolean isMainFramePage = mIsMainFrame; - if (WebView.LOGV_ENABLED) { + if (DebugFlags.BROWSER_FRAME) { Log.v(LOGTAG, "startLoadingResource: url=" + url + ", method=" - + method + ", postData=" + postData + ", isHighPriority=" - + isHighPriority + ", isMainFramePage=" + isMainFramePage); + + method + ", postData=" + postData + ", isMainFramePage=" + + isMainFramePage); } // Create a LoadListener @@ -551,23 +550,17 @@ class BrowserFrame extends Handler { mCallbackProxy.onLoadResource(url); if (LoadListener.getNativeLoaderCount() > MAX_OUTSTANDING_REQUESTS) { + // send an error message, so that loadListener can be deleted + // after this is returned. This is important as LoadListener's + // nativeError will remove the request from its DocLoader's request + // list. But the set up is not done until this method is returned. loadListener.error( android.net.http.EventHandler.ERROR, mContext.getString( com.android.internal.R.string.httpErrorTooManyRequests)); - loadListener.notifyError(); - loadListener.tearDown(); - return null; + return loadListener; } - // during synchronous load, the WebViewCore thread is blocked, so we - // need to endCacheTransaction first so that http thread won't be - // blocked in setupFile() when createCacheFile. - if (synchronous) { - CacheManager.endCacheTransaction(); - } - - FrameLoader loader = new FrameLoader(loadListener, mSettings, - method, isHighPriority); + FrameLoader loader = new FrameLoader(loadListener, mSettings, method); loader.setHeaders(headers); loader.setPostData(postData); // Set the load mode to the mode used for the current page. @@ -581,10 +574,6 @@ class BrowserFrame extends Handler { } checker.responseAlert("startLoadingResource succeed"); - if (synchronous) { - CacheManager.startCacheTransaction(); - } - return !synchronous ? loadListener : null; } @@ -615,6 +604,11 @@ class BrowserFrame extends Handler { mCallbackProxy.onReceivedIcon(icon); } + // Called by JNI when an apple-touch-icon attribute was found. + private void didReceiveTouchIconUrl(String url) { + mCallbackProxy.onReceivedTouchIconUrl(url); + } + /** * Request a new window from the client. * @return The BrowserFrame object stored in the new WebView. @@ -691,7 +685,7 @@ class BrowserFrame extends Handler { default: Log.e(LOGTAG, "getRawResFilename got incompatible resource ID"); - return new String(); + return ""; } TypedValue value = new TypedValue(); mContext.getResources().getValue(resid, value, true); diff --git a/core/java/android/webkit/CacheLoader.java b/core/java/android/webkit/CacheLoader.java index 3e1b602..de8f888 100644 --- a/core/java/android/webkit/CacheLoader.java +++ b/core/java/android/webkit/CacheLoader.java @@ -17,6 +17,7 @@ package android.webkit; import android.net.http.Headers; +import android.text.TextUtils; /** * This class is a concrete implementation of StreamLoader that uses a @@ -49,17 +50,22 @@ class CacheLoader extends StreamLoader { @Override protected void buildHeaders(Headers headers) { StringBuilder sb = new StringBuilder(mCacheResult.mimeType); - if (mCacheResult.encoding != null && - mCacheResult.encoding.length() > 0) { + if (!TextUtils.isEmpty(mCacheResult.encoding)) { sb.append(';'); sb.append(mCacheResult.encoding); } headers.setContentType(sb.toString()); - if (mCacheResult.location != null && - mCacheResult.location.length() > 0) { + if (!TextUtils.isEmpty(mCacheResult.location)) { headers.setLocation(mCacheResult.location); } - } + if (!TextUtils.isEmpty(mCacheResult.expiresString)) { + headers.setExpires(mCacheResult.expiresString); + } + + if (!TextUtils.isEmpty(mCacheResult.contentdisposition)) { + headers.setContentDisposition(mCacheResult.contentdisposition); + } + } } diff --git a/core/java/android/webkit/CacheManager.java b/core/java/android/webkit/CacheManager.java index 7897435..02e8d6f 100644 --- a/core/java/android/webkit/CacheManager.java +++ b/core/java/android/webkit/CacheManager.java @@ -51,7 +51,6 @@ public final class CacheManager { private static final String NO_STORE = "no-store"; private static final String NO_CACHE = "no-cache"; - private static final String PRIVATE = "private"; private static final String MAX_AGE = "max-age"; private static long CACHE_THRESHOLD = 6 * 1024 * 1024; @@ -80,12 +79,14 @@ public final class CacheManager { int httpStatusCode; long contentLength; long expires; + String expiresString; String localPath; String lastModified; String etag; String mimeType; String location; String encoding; + String contentdisposition; // these fields are NOT saved to the database InputStream inStream; @@ -108,6 +109,13 @@ public final class CacheManager { return expires; } + /** + * @hide Pending API council approval + */ + public String getExpiresString() { + return expiresString; + } + public String getLastModified() { return lastModified; } @@ -128,6 +136,13 @@ public final class CacheManager { return encoding; } + /** + * @hide Pending API council approval + */ + public String getContentDisposition() { + return contentdisposition; + } + // For out-of-package access to the underlying streams. public InputStream getInputStream() { return inStream; @@ -321,7 +336,7 @@ public final class CacheManager { } } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.CACHE_MANAGER) { Log.v(LOGTAG, "getCacheFile for url " + url); } @@ -340,7 +355,7 @@ public final class CacheManager { * @hide - hide createCacheFile since it has a parameter of type headers, which is * in a hidden package. */ - // can be called from any thread + // only called from WebCore thread public static CacheResult createCacheFile(String url, int statusCode, Headers headers, String mimeType, boolean forceCache) { if (!forceCache && mDisabled) { @@ -349,17 +364,25 @@ public final class CacheManager { // according to the rfc 2616, the 303 response MUST NOT be cached. if (statusCode == 303) { + // remove the saved cache if there is any + mDataBase.removeCache(url); return null; } // like the other browsers, do not cache redirects containing a cookie // header. if (checkCacheRedirect(statusCode) && !headers.getSetCookie().isEmpty()) { + // remove the saved cache if there is any + mDataBase.removeCache(url); return null; } CacheResult ret = parseHeaders(statusCode, headers, mimeType); - if (ret != null) { + if (ret == null) { + // this should only happen if the headers has "no-store" in the + // cache-control. remove the saved cache if there is any + mDataBase.removeCache(url); + } else { setupFiles(url, ret); try { ret.outStream = new FileOutputStream(ret.outFile); @@ -403,19 +426,23 @@ public final class CacheManager { } cacheRet.contentLength = cacheRet.outFile.length(); - if (checkCacheRedirect(cacheRet.httpStatusCode)) { + boolean redirect = checkCacheRedirect(cacheRet.httpStatusCode); + if (redirect) { // location is in database, no need to keep the file cacheRet.contentLength = 0; - cacheRet.localPath = new String(); - cacheRet.outFile.delete(); - } else if (cacheRet.contentLength == 0) { - cacheRet.outFile.delete(); + cacheRet.localPath = ""; + } + if ((redirect || cacheRet.contentLength == 0) + && !cacheRet.outFile.delete()) { + Log.e(LOGTAG, cacheRet.outFile.getPath() + " delete failed."); + } + if (cacheRet.contentLength == 0) { return; } mDataBase.addCache(url, cacheRet); - if (WebView.LOGV_ENABLED) { + if (DebugFlags.CACHE_MANAGER) { Log.v(LOGTAG, "saveCacheFile for url " + url); } } @@ -444,7 +471,10 @@ public final class CacheManager { // if mBaseDir doesn't exist, files can be null. if (files != null) { for (int i = 0; i < files.length; i++) { - new File(mBaseDir, files[i]).delete(); + File f = new File(mBaseDir, files[i]); + if (!f.delete()) { + Log.e(LOGTAG, f.getPath() + " delete failed."); + } } } } catch (SecurityException e) { @@ -472,7 +502,10 @@ public final class CacheManager { ArrayList<String> pathList = mDataBase.trimCache(CACHE_TRIM_AMOUNT); int size = pathList.size(); for (int i = 0; i < size; i++) { - new File(mBaseDir, pathList.get(i)).delete(); + File f = new File(mBaseDir, pathList.get(i)); + if (!f.delete()) { + Log.e(LOGTAG, f.getPath() + " delete failed."); + } } } } @@ -511,12 +544,7 @@ public final class CacheManager { // cache file. If it is not, resolve the collision. while (file.exists()) { if (checkOldPath) { - // as this is called from http thread through - // createCacheFile, we need endCacheTransaction before - // database access. - WebViewCore.endCacheTransaction(); CacheResult oldResult = mDataBase.getCache(url); - WebViewCore.startCacheTransaction(); if (oldResult != null && oldResult.contentLength > 0) { if (path.equals(oldResult.localPath)) { path = oldResult.localPath; @@ -596,21 +624,27 @@ public final class CacheManager { if (location != null) ret.location = location; ret.expires = -1; - String expires = headers.getExpires(); - if (expires != null) { + ret.expiresString = headers.getExpires(); + if (ret.expiresString != null) { try { - ret.expires = HttpDateTime.parse(expires); + ret.expires = HttpDateTime.parse(ret.expiresString); } catch (IllegalArgumentException ex) { // Take care of the special "-1" and "0" cases - if ("-1".equals(expires) || "0".equals(expires)) { + if ("-1".equals(ret.expiresString) + || "0".equals(ret.expiresString)) { // make it expired, but can be used for history navigation ret.expires = 0; } else { - Log.e(LOGTAG, "illegal expires: " + expires); + Log.e(LOGTAG, "illegal expires: " + ret.expiresString); } } } + String contentDisposition = headers.getContentDisposition(); + if (contentDisposition != null) { + ret.contentdisposition = contentDisposition; + } + String lastModified = headers.getLastModified(); if (lastModified != null) ret.lastModified = lastModified; @@ -628,7 +662,7 @@ public final class CacheManager { // must be re-validated on every load. It does not mean that // the content can not be cached. set to expire 0 means it // can only be used in CACHE_MODE_CACHE_ONLY case - if (NO_CACHE.equals(controls[i]) || PRIVATE.equals(controls[i])) { + if (NO_CACHE.equals(controls[i])) { ret.expires = 0; } else if (controls[i].startsWith(MAX_AGE)) { int separator = controls[i].indexOf('='); diff --git a/core/java/android/webkit/CallbackProxy.java b/core/java/android/webkit/CallbackProxy.java index 17d3f94..e77d29b 100644 --- a/core/java/android/webkit/CallbackProxy.java +++ b/core/java/android/webkit/CallbackProxy.java @@ -70,42 +70,51 @@ class CallbackProxy extends Handler { private final WebBackForwardList mBackForwardList; // Used to call startActivity during url override. private final Context mContext; + // Stores the URL being loaded and the viewing mode to switch into when + // the URL finishes loading. + private ChangeViewModeOnFinishedLoad mChange; // 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 TOO_MANY_REDIRECTS = 117; - 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 JS_TIMEOUT = 126; + 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 TOO_MANY_REDIRECTS = 117; + 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; // Message triggered by the client to resume execution - private static final int NOTIFY = 200; + private static final int NOTIFY = 200; // Result transportation object for returning results across thread // boundaries. - private class ResultTransport<E> { + private static class ResultTransport<E> { // Private result object private E mResult; @@ -145,6 +154,16 @@ class CallbackProxy extends Handler { } /** + * Get the WebChromeClient. + * @return the current WebChromeClient instance. + * + *@hide pending API council approval. + */ + public WebChromeClient getWebChromeClient() { + return mWebChromeClient; + } + + /** * Set the client DownloadListener. * @param client An implementation of DownloadListener. */ @@ -161,6 +180,37 @@ class CallbackProxy extends Handler { } /** + * Tell the host application that the WebView has changed viewing modes. + * @param toZoomedOut If true, the WebView has zoomed out so that the page + * fits the screen. If false, it is zoomed to the setting + * specified by the user. + */ + /* package */ void uiOnChangeViewingMode(boolean toZoomOverview) { + if (mWebChromeClient != null) { + mWebChromeClient.onChangeViewingMode(toZoomOverview); + } + } + + private static class ChangeViewModeOnFinishedLoad { + boolean mToZoomOverView; + String mOriginalUrl; + ChangeViewModeOnFinishedLoad(boolean toZoomOverview, + String originalUrl) { + mToZoomOverView = toZoomOverview; + mOriginalUrl = originalUrl; + } + } + + /** + * Keep track of the url and the viewing mode to change into. If/when that + * url finishes loading, this will change the viewing mode. + */ + /* package */ void uiChangeViewingModeOnFinishedLoad( + boolean toZoomOverview, String originalUrl) { + if (mWebChromeClient == null) return; + mChange = new ChangeViewModeOnFinishedLoad(toZoomOverview, originalUrl); + } + /** * Called by the UI side. Calling overrideUrlLoading from the WebCore * side will post a message to call this method. */ @@ -221,6 +271,15 @@ class CallbackProxy extends Handler { if (mWebViewClient != null) { mWebViewClient.onPageFinished(mWebView, (String) msg.obj); } + if (mChange != null) { + if (mWebView.getOriginalUrl().equals(mChange.mOriginalUrl)) { + uiOnChangeViewingMode(mChange.mToZoomOverView); + } else { + // The user has gone to a different page, so there is + // no need to hang on to the old object. + mChange = null; + } + } break; case RECEIVED_ICON: @@ -229,6 +288,13 @@ class CallbackProxy extends Handler { } break; + case RECEIVED_TOUCH_ICON_URL: + if (mWebChromeClient != null) { + mWebChromeClient.onReceivedTouchIconUrl(mWebView, + (String) msg.obj); + } + break; + case RECEIVED_TITLE: if (mWebChromeClient != null) { mWebChromeClient.onReceivedTitle(mWebView, @@ -389,6 +455,61 @@ class CallbackProxy extends Handler { } 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 currentQuota = + ((Long) map.get("currentQuota")).longValue(); + long totalUsedQuota = + ((Long) map.get("totalUsedQuota")).longValue(); + WebStorage.QuotaUpdater quotaUpdater = + (WebStorage.QuotaUpdater) map.get("quotaUpdater"); + + mWebChromeClient.onExceededDatabaseQuota(url, + databaseIdentifier, currentQuota, totalUsedQuota, + quotaUpdater); + } + break; + + case REACHED_APPCACHE_MAXSIZE: + if (mWebChromeClient != null) { + HashMap<String, Object> map = + (HashMap<String, Object>) msg.obj; + long spaceNeeded = + ((Long) map.get("spaceNeeded")).longValue(); + long totalUsedQuota = + ((Long) map.get("totalUsedQuota")).longValue(); + WebStorage.QuotaUpdater quotaUpdater = + (WebStorage.QuotaUpdater) map.get("quotaUpdater"); + + mWebChromeClient.onReachedMaxAppCacheSize(spaceNeeded, + totalUsedQuota, 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 JsResult res = (JsResult) msg.obj; @@ -563,6 +684,13 @@ class CallbackProxy extends Handler { case SWITCH_OUT_HISTORY: mWebView.switchOutDrawHistory(); break; + + case ADD_MESSAGE_TO_CONSOLE: + String message = msg.getData().getString("message"); + String sourceID = msg.getData().getString("sourceID"); + int lineNumber = msg.getData().getInt("lineNumber"); + mWebChromeClient.addMessageToConsole(message, lineNumber, sourceID); + break; } } @@ -605,7 +733,40 @@ class CallbackProxy extends Handler { //-------------------------------------------------------------------------- // 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) { // Do an unsynchronized quick check to avoid posting if no callback has @@ -614,9 +775,12 @@ class CallbackProxy extends Handler { return; } // Performance probe - if (false) { + if (PERF_PROBE) { mWebCoreThreadTime = SystemClock.currentThreadTimeMillis(); + mWebCoreIdleTime = 0; Network.getInstance(mContext).startTiming(); + // un-comment this if PERF_PROBE is true +// Looper.myQueue().setWaitCallback(mIdleCallback); } Message msg = obtainMessage(PAGE_STARTED); msg.obj = favicon; @@ -631,10 +795,12 @@ class CallbackProxy extends Handler { return; } // Performance probe - if (false) { + 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"); + + " ms and idled " + mWebCoreIdleTime + " ms"); Network.getInstance(mContext).stopTiming(); } Message msg = obtainMessage(PAGE_FINISHED, url); @@ -834,7 +1000,7 @@ class CallbackProxy extends Handler { String password, Message resumeMsg) { // resumeMsg should be null at this point because we want to create it // within the CallbackProxy. - if (WebView.DEBUG) { + if (DebugFlags.CALLBACK_PROXY) { junit.framework.Assert.assertNull(resumeMsg); } resumeMsg = obtainMessage(NOTIFY); @@ -939,6 +1105,21 @@ class CallbackProxy extends Handler { sendMessage(obtainMessage(RECEIVED_ICON, icon)); } + /* package */ void onReceivedTouchIconUrl(String url) { + // We should have a current item but we do not want to crash so check + // for null. + WebHistoryItem i = mBackForwardList.getCurrentItem(); + if (i != null) { + i.setTouchIconUrl(url); + } + // Do an unsynchronized quick check to avoid posting if no callback has + // been set. + if (mWebChromeClient == null) { + return; + } + sendMessage(obtainMessage(RECEIVED_TOUCH_ICON_URL, url)); + } + public void onReceivedTitle(String title) { // Do an unsynchronized quick check to avoid posting if no callback has // been set. @@ -1037,6 +1218,127 @@ class CallbackProxy extends Handler { } /** + * 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 currentQuota The current quota the origin is allowed. + * @param totalUsedQuota 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 currentQuota, + long totalUsedQuota, WebStorage.QuotaUpdater quotaUpdater) { + if (mWebChromeClient == null) { + quotaUpdater.updateQuota(currentQuota); + return; + } + + Message exceededQuota = obtainMessage(EXCEEDED_DATABASE_QUOTA); + HashMap<String, Object> map = new HashMap(); + map.put("databaseIdentifier", databaseIdentifier); + map.put("url", url); + map.put("currentQuota", currentQuota); + map.put("totalUsedQuota", totalUsedQuota); + 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 spaceNeeded is the amount of disk space that would be needed + * in order for the last appcache operation to succeed. + * @param totalUsedQuota 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 a bigger + * app cache size has been made. + * @hide pending API council approval. + */ + public void onReachedMaxAppCacheSize(long spaceNeeded, + long totalUsedQuota, WebStorage.QuotaUpdater quotaUpdater) { + if (mWebChromeClient == null) { + quotaUpdater.updateQuota(0); + return; + } + + Message msg = obtainMessage(REACHED_APPCACHE_MAXSIZE); + HashMap<String, Object> map = new HashMap(); + map.put("spaceNeeded", spaceNeeded); + map.put("totalUsedQuota", totalUsedQuota); + 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. + * @hide pending API council review. + */ + 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. + * origin. + * @hide pending API council review. + */ + 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. + * @hide pending API counsel. + */ + public void addMessageToConsole(String message, int lineNumber, String sourceID) { + 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); + sendMessage(msg); + } + + /** * @hide pending API council approval */ public boolean onJsTimeout() { diff --git a/core/java/android/webkit/CookieManager.java b/core/java/android/webkit/CookieManager.java index e8c2279..fca591f 100644 --- a/core/java/android/webkit/CookieManager.java +++ b/core/java/android/webkit/CookieManager.java @@ -23,9 +23,12 @@ import android.util.Log; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; +import java.util.Comparator; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; +import java.util.SortedSet; +import java.util.TreeSet; /** * CookieManager manages cookies according to RFC2109 spec. @@ -190,6 +193,31 @@ public final class CookieManager { } } + private static final CookieComparator COMPARATOR = new CookieComparator(); + + private static final class CookieComparator implements Comparator<Cookie> { + public int compare(Cookie cookie1, Cookie cookie2) { + // According to RFC 2109, multiple cookies are ordered in a way such + // that those with more specific Path attributes precede those with + // less specific. Ordering with respect to other attributes (e.g., + // Domain) is unspecified. + // As Set is not modified if the two objects are same, we do want to + // assign different value for each cookie. + int diff = cookie2.path.length() - cookie1.path.length(); + if (diff == 0) { + diff = cookie2.domain.length() - cookie1.domain.length(); + if (diff == 0) { + diff = cookie2.name.hashCode() - cookie1.name.hashCode(); + if (diff == 0) { + Log.w(LOGTAG, "Found two cookies with the same value." + + "cookie1=" + cookie1 + " , cookie2=" + cookie2); + } + } + } + return diff; + } + } + private CookieManager() { } @@ -262,7 +290,7 @@ public final class CookieManager { if (!mAcceptCookie || uri == null) { return; } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_MANAGER) { Log.v(LOGTAG, "setCookie: uri: " + uri + " value: " + value); } @@ -401,8 +429,8 @@ public final class CookieManager { long now = System.currentTimeMillis(); boolean secure = HTTPS.equals(uri.mScheme); Iterator<Cookie> iter = cookieList.iterator(); - StringBuilder ret = new StringBuilder(256); + SortedSet<Cookie> cookieSet = new TreeSet<Cookie>(COMPARATOR); while (iter.hasNext()) { Cookie cookie = iter.next(); if (cookie.domainMatch(hostAndPath[0]) && @@ -413,26 +441,33 @@ public final class CookieManager { && (!cookie.secure || secure) && cookie.mode != Cookie.MODE_DELETED) { cookie.lastAcessTime = now; + cookieSet.add(cookie); + } + } - if (ret.length() > 0) { - ret.append(SEMICOLON); - // according to RC2109, SEMICOLON is office separator, - // but when log in yahoo.com, it needs WHITE_SPACE too. - ret.append(WHITE_SPACE); - } - - ret.append(cookie.name); - ret.append(EQUAL); - ret.append(cookie.value); + StringBuilder ret = new StringBuilder(256); + Iterator<Cookie> setIter = cookieSet.iterator(); + while (setIter.hasNext()) { + Cookie cookie = setIter.next(); + if (ret.length() > 0) { + ret.append(SEMICOLON); + // according to RC2109, SEMICOLON is official separator, + // but when log in yahoo.com, it needs WHITE_SPACE too. + ret.append(WHITE_SPACE); } + + ret.append(cookie.name); + ret.append(EQUAL); + ret.append(cookie.value); } + if (ret.length() > 0) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_MANAGER) { Log.v(LOGTAG, "getCookie: uri: " + uri + " value: " + ret); } return ret.toString(); } else { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_MANAGER) { Log.v(LOGTAG, "getCookie: uri: " + uri + " But can't find cookie."); } @@ -588,7 +623,7 @@ public final class CookieManager { Iterator<ArrayList<Cookie>> listIter = cookieLists.iterator(); while (listIter.hasNext() && count < MAX_RAM_COOKIES_COUNT) { ArrayList<Cookie> list = listIter.next(); - if (WebView.DEBUG) { + if (DebugFlags.COOKIE_MANAGER) { Iterator<Cookie> iter = list.iterator(); while (iter.hasNext() && count < MAX_RAM_COOKIES_COUNT) { Cookie cookie = iter.next(); @@ -608,7 +643,7 @@ public final class CookieManager { ArrayList<Cookie> retlist = new ArrayList<Cookie>(); if (mapSize >= MAX_RAM_DOMAIN_COUNT || count >= MAX_RAM_COOKIES_COUNT) { - if (WebView.DEBUG) { + if (DebugFlags.COOKIE_MANAGER) { Log.v(LOGTAG, count + " cookies used " + byteCount + " bytes with " + mapSize + " domains"); } @@ -616,7 +651,7 @@ public final class CookieManager { int toGo = mapSize / 10 + 1; while (toGo-- > 0){ String domain = domains[toGo].toString(); - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_MANAGER) { Log.v(LOGTAG, "delete domain: " + domain + " from RAM cache"); } @@ -798,22 +833,24 @@ public final class CookieManager { // "secure" is a known attribute doesn't use "="; // while sites like live.com uses "secure=" - if (length - index > SECURE_LENGTH + if (length - index >= SECURE_LENGTH && cookieString.substring(index, index + SECURE_LENGTH). equalsIgnoreCase(SECURE)) { index += SECURE_LENGTH; cookie.secure = true; + if (index == length) break; if (cookieString.charAt(index) == EQUAL) index++; continue; } // "httponly" is a known attribute doesn't use "="; // while sites like live.com uses "httponly=" - if (length - index > HTTP_ONLY_LENGTH + if (length - index >= HTTP_ONLY_LENGTH && cookieString.substring(index, index + HTTP_ONLY_LENGTH). equalsIgnoreCase(HTTP_ONLY)) { index += HTTP_ONLY_LENGTH; + if (index == length) break; if (cookieString.charAt(index) == EQUAL) index++; // FIXME: currently only parse the attribute continue; diff --git a/core/java/android/webkit/CookieSyncManager.java b/core/java/android/webkit/CookieSyncManager.java index 8d66529..14375d2 100644 --- a/core/java/android/webkit/CookieSyncManager.java +++ b/core/java/android/webkit/CookieSyncManager.java @@ -24,30 +24,39 @@ import java.util.ArrayList; import java.util.Iterator; /** - * The class CookieSyncManager is used to synchronize the browser cookies - * between RAM and FLASH. To get the best performance, browser cookie is saved - * in RAM. We use a separate thread to sync the cookies between RAM and FLASH on - * a timer base. + * The CookieSyncManager is used to synchronize the browser cookie store + * between RAM and permanent storage. To get the best performance, browser cookies are + * saved in RAM. A separate thread saves the cookies between, driven by a timer. * <p> + * * To use the CookieSyncManager, the host application has to call the following - * when the application starts. - * <p> - * CookieSyncManager.createInstance(context) - * <p> - * To set up for sync, the host application has to call - * <p> - * CookieSyncManager.getInstance().startSync() + * when the application starts: * <p> - * in its Activity.onResume(), and call + * + * <pre class="prettyprint">CookieSyncManager.createInstance(context)</pre><p> + * + * To set up for sync, the host application has to call<p> + * <pre class="prettyprint">CookieSyncManager.getInstance().startSync()</pre><p> + * + * in Activity.onResume(), and call * <p> + * + * <pre class="prettyprint"> * CookieSyncManager.getInstance().stopSync() - * <p> - * in its Activity.onStop(). - * <p> + * </pre><p> + * + * in Activity.onPause().<p> + * * To get instant sync instead of waiting for the timer to trigger, the host can * call * <p> - * CookieSyncManager.getInstance().sync() + * <pre class="prettyprint">CookieSyncManager.getInstance().sync()</pre><p> + * + * The sync interval is 5 minutes, so you will want to force syncs + * manually anyway, for instance in {@link + * WebViewClient#onPageFinished}. Note that even sync() happens + * asynchronously, so don't do it just as your activity is shutting + * down. */ public final class CookieSyncManager extends WebSyncManager { @@ -90,7 +99,7 @@ public final class CookieSyncManager extends WebSyncManager { } /** - * Package level api, called from CookieManager Get all the cookies which + * Package level api, called from CookieManager. Get all the cookies which * matches a given base domain. * @param domain * @return A list of Cookie @@ -161,7 +170,7 @@ public final class CookieSyncManager extends WebSyncManager { } protected void syncFromRamToFlash() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_SYNC_MANAGER) { Log.v(LOGTAG, "CookieSyncManager::syncFromRamToFlash STARTS"); } @@ -178,7 +187,7 @@ public final class CookieSyncManager extends WebSyncManager { CookieManager.getInstance().deleteLRUDomain(); syncFromRamToFlash(lruList); - if (WebView.LOGV_ENABLED) { + if (DebugFlags.COOKIE_SYNC_MANAGER) { Log.v(LOGTAG, "CookieSyncManager::syncFromRamToFlash DONE"); } } diff --git a/core/java/android/webkit/DataLoader.java b/core/java/android/webkit/DataLoader.java index dcdc949..6c5d10d 100644 --- a/core/java/android/webkit/DataLoader.java +++ b/core/java/android/webkit/DataLoader.java @@ -16,12 +16,10 @@ package android.webkit; -import org.apache.http.protocol.HTTP; - -import android.net.http.Headers; - import java.io.ByteArrayInputStream; +import org.apache.harmony.luni.util.Base64; + /** * This class is a concrete implementation of StreamLoader that uses the * content supplied as a URL as the source for the stream. The mimetype @@ -30,8 +28,6 @@ import java.io.ByteArrayInputStream; */ class DataLoader extends StreamLoader { - private String mContentType; // Content mimetype, if supplied in URL - /** * Constructor uses the dataURL as the source for an InputStream * @param dataUrl data: URL string optionally containing a mimetype @@ -41,16 +37,20 @@ class DataLoader extends StreamLoader { super(loadListener); String url = dataUrl.substring("data:".length()); - String content; + byte[] data = null; int commaIndex = url.indexOf(','); if (commaIndex != -1) { - mContentType = url.substring(0, commaIndex); - content = url.substring(commaIndex + 1); + String contentType = url.substring(0, commaIndex); + data = url.substring(commaIndex + 1).getBytes(); + loadListener.parseContentTypeHeader(contentType); + if ("base64".equals(loadListener.transferEncoding())) { + data = Base64.decode(data); + } } else { - content = url; + data = url.getBytes(); } - mDataStream = new ByteArrayInputStream(content.getBytes()); - mContentLength = content.length(); + mDataStream = new ByteArrayInputStream(data); + mContentLength = data.length; } @Override @@ -60,10 +60,7 @@ class DataLoader extends StreamLoader { } @Override - protected void buildHeaders(Headers headers) { - if (mContentType != null) { - headers.setContentType(mContentType); - } + protected void buildHeaders(android.net.http.Headers h) { } /** diff --git a/core/java/android/webkit/DateSorter.java b/core/java/android/webkit/DateSorter.java index 750403b..c46702e 100644 --- a/core/java/android/webkit/DateSorter.java +++ b/core/java/android/webkit/DateSorter.java @@ -43,9 +43,6 @@ public class DateSorter { private static final int NUM_DAYS_AGO = 5; - Date mDate = new Date(); - Calendar mCal = Calendar.getInstance(); - /** * @param context Application context */ diff --git a/core/java/android/webkit/DebugFlags.java b/core/java/android/webkit/DebugFlags.java new file mode 100644 index 0000000..8e25395 --- /dev/null +++ b/core/java/android/webkit/DebugFlags.java @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2009 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; + +/** + * This class is a container for all of the debug flags used in the Java + * components of webkit. These flags must be final in order to ensure that + * the compiler optimizes the code that uses them out of the final executable. + * + * The name of each flags maps directly to the name of the class in which that + * flag is used. + * + */ +class DebugFlags { + + public static final boolean BROWSER_FRAME = false; + public static final boolean CACHE_MANAGER = false; + public static final boolean CALLBACK_PROXY = false; + public static final boolean COOKIE_MANAGER = false; + public static final boolean COOKIE_SYNC_MANAGER = false; + public static final boolean FRAME_LOADER = false; + public static final boolean J_WEB_CORE_JAVA_BRIDGE = false;// HIGHLY VERBOSE + public static final boolean LOAD_LISTENER = false; + public static final boolean NETWORK = false; + public static final boolean SSL_ERROR_HANDLER = false; + public static final boolean STREAM_LOADER = false; + public static final boolean URL_UTIL = false; + public static final boolean WEB_BACK_FORWARD_LIST = false; + public static final boolean WEB_SETTINGS = false; + public static final boolean WEB_SYNC_MANAGER = false; + public static final boolean WEB_TEXT_VIEW = false; + public static final boolean WEB_VIEW = false; + public static final boolean WEB_VIEW_CORE = false; + +} diff --git a/core/java/android/webkit/FrameLoader.java b/core/java/android/webkit/FrameLoader.java index 66ab021..c1eeb3b 100644 --- a/core/java/android/webkit/FrameLoader.java +++ b/core/java/android/webkit/FrameLoader.java @@ -28,7 +28,6 @@ class FrameLoader { private final LoadListener mListener; private final String mMethod; - private final boolean mIsHighPriority; private final WebSettings mSettings; private Map<String, String> mHeaders; private byte[] mPostData; @@ -52,11 +51,10 @@ class FrameLoader { private static final String LOGTAG = "webkit"; FrameLoader(LoadListener listener, WebSettings settings, - String method, boolean highPriority) { + String method) { mListener = listener; mHeaders = null; mMethod = method; - mIsHighPriority = highPriority; mCacheMode = WebSettings.LOAD_NORMAL; mSettings = settings; } @@ -97,17 +95,6 @@ class FrameLoader { public boolean executeLoad() { String url = mListener.url(); - // Attempt to decode the percent-encoded url. - try { - url = new String(URLUtil.decode(url.getBytes())); - } catch (IllegalArgumentException e) { - // Fail with a bad url error if the decode fails. - mListener.error(EventHandler.ERROR_BAD_URL, - mListener.getContext().getString( - com.android.internal.R.string.httpErrorBadUrl)); - return false; - } - if (URLUtil.isNetworkUrl(url)){ if (mSettings.getBlockNetworkLoads()) { mListener.error(EventHandler.ERROR_BAD_URL, @@ -115,12 +102,19 @@ class FrameLoader { com.android.internal.R.string.httpErrorBadUrl)); return false; } + // Make sure it is correctly URL encoded before sending the request + if (!URLUtil.verifyURLEncoding(url)) { + mListener.error(EventHandler.ERROR_BAD_URL, + mListener.getContext().getString( + com.android.internal.R.string.httpErrorBadUrl)); + return false; + } mNetwork = Network.getInstance(mListener.getContext()); return handleHTTPLoad(); } else if (handleLocalFile(url, mListener, mSettings)) { return true; } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.FRAME_LOADER) { Log.v(LOGTAG, "FrameLoader.executeLoad: url protocol not supported:" + mListener.url()); } @@ -134,6 +128,18 @@ class FrameLoader { /* package */ static boolean handleLocalFile(String url, LoadListener loadListener, WebSettings settings) { + // Attempt to decode the percent-encoded url before passing to the + // local loaders. + try { + url = new String(URLUtil.decode(url.getBytes())); + } catch (IllegalArgumentException e) { + loadListener.error(EventHandler.ERROR_BAD_URL, + loadListener.getContext().getString( + com.android.internal.R.string.httpErrorBadUrl)); + // Return true here so we do not trigger an unsupported scheme + // error. + return true; + } if (URLUtil.isAssetUrl(url)) { FileLoader.requestUrl(url, loadListener, loadListener.getContext(), true, settings.getAllowFileAccess()); @@ -166,21 +172,17 @@ class FrameLoader { populateStaticHeaders(); populateHeaders(); - // response was handled by UrlIntercept, don't issue HTTP request - if (handleUrlIntercept()) return true; - // response was handled by Cache, don't issue HTTP request if (handleCache()) { // push the request data down to the LoadListener // as response from the cache could be a redirect // and we may need to initiate a network request if the cache // can't satisfy redirect URL - mListener.setRequestData(mMethod, mHeaders, mPostData, - mIsHighPriority); + mListener.setRequestData(mMethod, mHeaders, mPostData); return true; } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.FRAME_LOADER) { Log.v(LOGTAG, "FrameLoader: http " + mMethod + " load for: " + mListener.url()); } @@ -190,7 +192,7 @@ class FrameLoader { try { ret = mNetwork.requestURL(mMethod, mHeaders, - mPostData, mListener, mIsHighPriority); + mPostData, mListener); } catch (android.net.ParseException ex) { error = EventHandler.ERROR_BAD_URL; } catch (java.lang.RuntimeException ex) { @@ -207,11 +209,11 @@ class FrameLoader { } /* - * This function is used by handleUrlInterecpt and handleCache to + * This function is used by handleCache to * setup a load from the byte stream in a CacheResult. */ private void startCacheLoad(CacheResult result) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.FRAME_LOADER) { Log.v(LOGTAG, "FrameLoader: loading from cache: " + mListener.url()); } @@ -223,30 +225,6 @@ class FrameLoader { } /* - * This function is used by handleHTTPLoad to allow URL - * interception. This can be used to provide alternative load - * methods such as locally stored versions or for debugging. - * - * Returns true if the response was handled by UrlIntercept. - */ - private boolean handleUrlIntercept() { - // Check if the URL can be served from UrlIntercept. If - // successful, return the data just like a cache hit. - - PluginData data = UrlInterceptRegistry.getPluginData( - mListener.url(), mHeaders); - - if(data != null) { - PluginContentLoader loader = - new PluginContentLoader(mListener, data); - loader.load(); - return true; - } - // Not intercepted. Carry on as normal. - return false; - } - - /* * This function is used by the handleHTTPLoad to setup the cache headers * correctly. * Returns true if the response was handled from the cache @@ -285,7 +263,7 @@ class FrameLoader { // of it's state. If it is not in the cache, then go to the // network. case WebSettings.LOAD_CACHE_ELSE_NETWORK: { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.FRAME_LOADER) { Log.v(LOGTAG, "FrameLoader: checking cache: " + mListener.url()); } diff --git a/core/java/android/webkit/GearsPermissionsManager.java b/core/java/android/webkit/GearsPermissionsManager.java deleted file mode 100644 index 6549cb8..0000000 --- a/core/java/android/webkit/GearsPermissionsManager.java +++ /dev/null @@ -1,246 +0,0 @@ -/* - * Copyright (C) 2009 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.ContentResolver; -import android.content.ContentValues; -import android.content.Context; -import android.content.SharedPreferences; -import android.content.SharedPreferences.Editor; -import android.database.ContentObserver; -import android.database.sqlite.SQLiteDatabase; -import android.database.sqlite.SQLiteException; -import android.database.sqlite.SQLiteStatement; -import android.os.Handler; -import android.preference.PreferenceManager; -import android.provider.Settings; -import android.util.Log; - -import java.io.File; -import java.util.HashSet; - -/** - * Donut-specific hack to keep Gears permissions in sync with the - * system location setting. - */ -class GearsPermissionsManager { - // The application context. - Context mContext; - // The path to gears.so. - private String mGearsPath; - - // The Gears permissions database directory. - private final static String GEARS_DATABASE_DIR = "gears"; - // The Gears permissions database file name. - private final static String GEARS_DATABASE_FILE = "permissions.db"; - // The Gears location permissions table. - private final static String GEARS_LOCATION_ACCESS_TABLE_NAME = - "LocationAccess"; - // The Gears storage access permissions table. - private final static String GEARS_STORAGE_ACCESS_TABLE_NAME = "Access"; - // The Gears permissions db schema version table. - private final static String GEARS_SCHEMA_VERSION_TABLE_NAME = - "VersionInfo"; - // The Gears permission value that denotes "allow access to location". - private static final int GEARS_ALLOW_LOCATION_ACCESS = 1; - // The shared pref name. - private static final String LAST_KNOWN_LOCATION_SETTING = - "lastKnownLocationSystemSetting"; - // The Browser package name. - private static final String BROWSER_PACKAGE_NAME = "com.android.browser"; - // The Secure Settings observer that will be notified when the system - // location setting changes. - private SecureSettingsObserver mSettingsObserver; - // The Google URLs whitelisted for Gears location access. - private static HashSet<String> sGearsWhiteList; - - static { - sGearsWhiteList = new HashSet<String>(); - // NOTE: DO NOT ADD A "/" AT THE END! - sGearsWhiteList.add("http://www.google.com"); - sGearsWhiteList.add("http://www.google.co.uk"); - } - - private static final String LOGTAG = "webcore"; - static final boolean DEBUG = false; - static final boolean LOGV_ENABLED = DEBUG; - - GearsPermissionsManager(Context context, String gearsPath) { - mContext = context; - mGearsPath = gearsPath; - } - - public void doCheckAndStartObserver() { - // Are we running in the browser? - if (!BROWSER_PACKAGE_NAME.equals(mContext.getPackageName())) { - return; - } - // Do the check. - checkGearsPermissions(); - // Install the observer. - mSettingsObserver = new SecureSettingsObserver(); - mSettingsObserver.observe(); - } - - private void checkGearsPermissions() { - // Get the current system settings. - int setting = Settings.Secure.getInt(mContext.getContentResolver(), - Settings.Secure.USE_LOCATION_FOR_SERVICES, -1); - // Check if we need to set the Gears permissions. - if (setting != -1 && locationSystemSettingChanged(setting)) { - setGearsPermissionForGoogleDomains(setting); - } - } - - private boolean locationSystemSettingChanged(int newSetting) { - SharedPreferences prefs = - PreferenceManager.getDefaultSharedPreferences(mContext); - int oldSetting = 0; - oldSetting = prefs.getInt(LAST_KNOWN_LOCATION_SETTING, oldSetting); - if (oldSetting == newSetting) { - return false; - } - Editor ed = prefs.edit(); - ed.putInt(LAST_KNOWN_LOCATION_SETTING, newSetting); - ed.commit(); - return true; - } - - private void setGearsPermissionForGoogleDomains(int systemPermission) { - // Transform the system permission into a boolean flag. When this - // flag is true, it means the origins in gGearsWhiteList are added - // to the Gears location permission table with permission 1 (allowed). - // When the flag is false, the origins in gGearsWhiteList are removed - // from the Gears location permission table. Next time the user - // navigates to one of these origins, she will see the normal Gears - // permission prompt. - boolean addToGearsLocationTable = (systemPermission == 1 ? true : false); - // Build the path to the Gears library. - - File file = new File(mGearsPath).getParentFile(); - if (file == null) { - return; - } - // Build the Gears database file name. - file = new File(file.getAbsolutePath() + File.separator - + GEARS_DATABASE_DIR + File.separator + GEARS_DATABASE_FILE); - // Remember whether or not we need to create the LocationAccess table. - boolean needToCreateTables = false; - if (!file.exists()) { - needToCreateTables = true; - // Create the path or else SQLiteDatabase.openOrCreateDatabase() - // may throw on the device. - file.getParentFile().mkdirs(); - } - // If the database file does not yet exist and the system location - // setting says that the Gears origins need to be removed from the - // location permission table, it means that we don't actually need - // to do anything at all. - if (needToCreateTables && !addToGearsLocationTable) { - return; - } - // Try opening the Gears database. - SQLiteDatabase permissions; - try { - permissions = SQLiteDatabase.openOrCreateDatabase(file, null); - } catch (SQLiteException e) { - if (LOGV_ENABLED) { - Log.v(LOGTAG, "Could not open Gears permission DB: " - + e.getMessage()); - } - // Just bail out. - return; - } - // We now have a database open. Begin a transaction. - permissions.beginTransaction(); - try { - if (needToCreateTables) { - // Create the tables. Note that this creates the - // Gears tables for the permissions DB schema version 2. - // The Gears schema upgrade process will take care of the rest. - // First, the storage access table. - SQLiteStatement statement = permissions.compileStatement( - "CREATE TABLE IF NOT EXISTS " - + GEARS_STORAGE_ACCESS_TABLE_NAME - + " (Name TEXT UNIQUE, Value)"); - statement.execute(); - // Next the location access table. - statement = permissions.compileStatement( - "CREATE TABLE IF NOT EXISTS " - + GEARS_LOCATION_ACCESS_TABLE_NAME - + " (Name TEXT UNIQUE, Value)"); - statement.execute(); - // Finally, the schema version table. - statement = permissions.compileStatement( - "CREATE TABLE IF NOT EXISTS " - + GEARS_SCHEMA_VERSION_TABLE_NAME - + " (Name TEXT UNIQUE, Value)"); - statement.execute(); - // Set the schema version to 2. - ContentValues schema = new ContentValues(); - schema.put("Name", "Version"); - schema.put("Value", 2); - permissions.insert(GEARS_SCHEMA_VERSION_TABLE_NAME, null, - schema); - } - - if (addToGearsLocationTable) { - ContentValues permissionValues = new ContentValues(); - - for (String url : sGearsWhiteList) { - permissionValues.put("Name", url); - permissionValues.put("Value", GEARS_ALLOW_LOCATION_ACCESS); - permissions.replace(GEARS_LOCATION_ACCESS_TABLE_NAME, null, - permissionValues); - permissionValues.clear(); - } - } else { - for (String url : sGearsWhiteList) { - permissions.delete(GEARS_LOCATION_ACCESS_TABLE_NAME, "Name=?", - new String[] { url }); - } - } - // Commit the transaction. - permissions.setTransactionSuccessful(); - } catch (SQLiteException e) { - if (LOGV_ENABLED) { - Log.v(LOGTAG, "Could not set the Gears permissions: " - + e.getMessage()); - } - } finally { - permissions.endTransaction(); - permissions.close(); - } - } - - class SecureSettingsObserver extends ContentObserver { - SecureSettingsObserver() { - super(new Handler()); - } - - void observe() { - ContentResolver resolver = mContext.getContentResolver(); - resolver.registerContentObserver(Settings.Secure.getUriFor( - Settings.Secure.USE_LOCATION_FOR_SERVICES), false, this); - } - - @Override - public void onChange(boolean selfChange) { - checkGearsPermissions(); - } - } -} diff --git a/core/java/android/webkit/GeolocationPermissions.java b/core/java/android/webkit/GeolocationPermissions.java new file mode 100755 index 0000000..d06d7e2 --- /dev/null +++ b/core/java/android/webkit/GeolocationPermissions.java @@ -0,0 +1,202 @@ +/* + * Copyright (C) 2009 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.os.Handler; +import android.os.Message; +import android.util.Log; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.Set; + + +/** + * Implements the Java side of GeolocationPermissions. Simply marshalls calls + * from the UI thread to the WebKit thread. + * @hide + */ +public final class GeolocationPermissions { + /** + * Callback interface used by the browser to report a Geolocation permission + * state set by the user in response to a permissions prompt. + */ + public interface Callback { + public void invoke(String origin, boolean allow, boolean remember); + }; + + // Log tag + private static final String TAG = "geolocationPermissions"; + + // Global instance + private static GeolocationPermissions sInstance; + + private Handler mHandler; + + // Members used to transfer the origins and permissions between threads. + private Set<String> mOrigins; + private boolean mAllowed; + private static Lock mLock = new ReentrantLock(); + private static boolean mUpdated; + private static Condition mUpdatedCondition = mLock.newCondition(); + + // Message ids + static final int GET_ORIGINS = 0; + static final int GET_ALLOWED = 1; + static final int CLEAR = 2; + static final int CLEAR_ALL = 3; + + /** + * Gets the singleton instance of the class. + */ + public static GeolocationPermissions getInstance() { + if (sInstance == null) { + sInstance = new GeolocationPermissions(); + } + return sInstance; + } + + /** + * Creates the message handler. Must be called on the WebKit thread. + */ + public void createHandler() { + if (mHandler == null) { + mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + // Runs on the WebKit thread. + switch (msg.what) { + case GET_ORIGINS: + getOriginsImpl(); + break; + case GET_ALLOWED: + getAllowedImpl((String) msg.obj); + break; + case CLEAR: + nativeClear((String) msg.obj); + break; + case CLEAR_ALL: + nativeClearAll(); + break; + } + } + }; + } + } + + /** + * Utility function to send a message to our handler. + */ + private void postMessage(Message msg) { + assert(mHandler != null); + mHandler.sendMessage(msg); + } + + /** + * Gets the set of origins for which Geolocation permissions are stored. + * Note that we represent the origins as strings. These are created using + * WebCore::SecurityOrigin::toString(). As long as all 'HTML 5 modules' + * (Database, Geolocation etc) do so, it's safe to match up origins for the + * purposes of displaying UI. + */ + public Set getOrigins() { + // Called on the UI thread. + Set origins = null; + mLock.lock(); + try { + mUpdated = false; + postMessage(Message.obtain(null, GET_ORIGINS)); + while (!mUpdated) { + mUpdatedCondition.await(); + } + origins = mOrigins; + } catch (InterruptedException e) { + Log.e(TAG, "Exception while waiting for update", e); + } finally { + mLock.unlock(); + } + return origins; + } + + /** + * Helper method to get the set of origins. + */ + private void getOriginsImpl() { + // Called on the WebKit thread. + mLock.lock(); + mOrigins = nativeGetOrigins(); + mUpdated = true; + mUpdatedCondition.signal(); + mLock.unlock(); + } + + /** + * Gets the permission state for the specified origin. + */ + public boolean getAllowed(String origin) { + // Called on the UI thread. + boolean allowed = false; + mLock.lock(); + try { + mUpdated = false; + postMessage(Message.obtain(null, GET_ALLOWED, origin)); + while (!mUpdated) { + mUpdatedCondition.await(); + } + allowed = mAllowed; + } catch (InterruptedException e) { + Log.e(TAG, "Exception while waiting for update", e); + } finally { + mLock.unlock(); + } + return allowed; + } + + /** + * Helper method to get the permission state. + */ + private void getAllowedImpl(String origin) { + // Called on the WebKit thread. + mLock.lock(); + mAllowed = nativeGetAllowed(origin); + mUpdated = true; + mUpdatedCondition.signal(); + mLock.unlock(); + } + + /** + * Clears the permission state for the specified origin. + */ + public void clear(String origin) { + // Called on the UI thread. + postMessage(Message.obtain(null, CLEAR, origin)); + } + + /** + * Clears the permission state for all origins. + */ + public void clearAll() { + // Called on the UI thread. + postMessage(Message.obtain(null, CLEAR_ALL)); + } + + // Native functions, run on the WebKit thread. + private static native Set nativeGetOrigins(); + private static native boolean nativeGetAllowed(String origin); + private static native void nativeClear(String origin); + private static native void nativeClearAll(); +} diff --git a/core/java/android/webkit/GeolocationService.java b/core/java/android/webkit/GeolocationService.java new file mode 100755 index 0000000..78b25ba --- /dev/null +++ b/core/java/android/webkit/GeolocationService.java @@ -0,0 +1,189 @@ +/* + * Copyright (C) 2009 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.ActivityThread; +import android.content.Context; +import android.location.Location; +import android.location.LocationListener; +import android.location.LocationManager; +import android.location.LocationProvider; +import android.os.Bundle; +import android.util.Log; +import android.webkit.WebView; +import android.webkit.WebViewCore; + + +/** + * Implements the Java side of GeolocationServiceAndroid. + * @hide Pending API council review. + */ +public final class GeolocationService implements LocationListener { + + // Log tag + private static final String TAG = "geolocationService"; + + private long mNativeObject; + private LocationManager mLocationManager; + private boolean mIsGpsEnabled; + private boolean mIsRunning; + private boolean mIsNetworkProviderAvailable; + private boolean mIsGpsProviderAvailable; + + /** + * Constructor + * @param nativeObject The native object to which this object will report position updates and + * errors. + */ + public GeolocationService(long nativeObject) { + mNativeObject = nativeObject; + // Register newLocationAvailable with platform service. + ActivityThread thread = ActivityThread.systemMain(); + Context context = thread.getApplication(); + mLocationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE); + if (mLocationManager == null) { + Log.e(TAG, "Could not get location manager."); + } + } + + /** + * Start listening for location updates. + */ + public void start() { + registerForLocationUpdates(); + mIsRunning = true; + } + + /** + * Stop listening for location updates. + */ + public void stop() { + unregisterFromLocationUpdates(); + mIsRunning = false; + } + + /** + * Sets whether to use the GPS. + * @param enable Whether to use the GPS. + */ + public void setEnableGps(boolean enable) { + if (mIsGpsEnabled != enable) { + mIsGpsEnabled = enable; + if (mIsRunning) { + // There's no way to unregister from a single provider, so we can + // only unregister from all, then reregister with all but the GPS. + unregisterFromLocationUpdates(); + registerForLocationUpdates(); + } + } + } + + /** + * LocationListener implementation. + * Called when the location has changed. + * @param location The new location, as a Location object. + */ + public void onLocationChanged(Location location) { + // Callbacks from the system location sevice are queued to this thread, so it's possible + // that we receive callbacks after unregistering. At this point, the native object will no + // longer exist. + if (mIsRunning) { + nativeNewLocationAvailable(mNativeObject, location); + } + } + + /** + * LocationListener implementation. + * Called when the provider status changes. + * @param provider The name of the provider. + * @param status The new status of the provider. + * @param extras an optional Bundle with provider specific data. + */ + public void onStatusChanged(String providerName, int status, Bundle extras) { + boolean isAvailable = (status == LocationProvider.AVAILABLE); + if (LocationManager.NETWORK_PROVIDER.equals(providerName)) { + mIsNetworkProviderAvailable = isAvailable; + } else if (LocationManager.GPS_PROVIDER.equals(providerName)) { + mIsGpsProviderAvailable = isAvailable; + } + maybeReportError("The last location provider is no longer available"); + } + + /** + * LocationListener implementation. + * Called when the provider is enabled. + * @param provider The name of the location provider that is now enabled. + */ + public void onProviderEnabled(String providerName) { + // No need to notify the native side. It's enough to start sending + // valid position fixes again. + if (LocationManager.NETWORK_PROVIDER.equals(providerName)) { + mIsNetworkProviderAvailable = true; + } else if (LocationManager.GPS_PROVIDER.equals(providerName)) { + mIsGpsProviderAvailable = true; + } + } + + /** + * LocationListener implementation. + * Called when the provider is disabled. + * @param provider The name of the location provider that is now disabled. + */ + public void onProviderDisabled(String providerName) { + if (LocationManager.NETWORK_PROVIDER.equals(providerName)) { + mIsNetworkProviderAvailable = false; + } else if (LocationManager.GPS_PROVIDER.equals(providerName)) { + mIsGpsProviderAvailable = false; + } + maybeReportError("The last location provider was disabled"); + } + + /** + * Registers this object with the location service. + */ + private void registerForLocationUpdates() { + mLocationManager.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 0, 0, this); + mIsNetworkProviderAvailable = true; + if (mIsGpsEnabled) { + mLocationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, this); + mIsGpsProviderAvailable = true; + } + } + + /** + * Unregisters this object from the location service. + */ + private void unregisterFromLocationUpdates() { + mLocationManager.removeUpdates(this); + } + + /** + * Reports an error if neither the network nor the GPS provider is available. + */ + private void maybeReportError(String message) { + // Callbacks from the system location sevice are queued to this thread, so it's possible + // that we receive callbacks after unregistering. At this point, the native object will no + // longer exist. + if (mIsRunning && !mIsNetworkProviderAvailable && !mIsGpsProviderAvailable) { + nativeNewErrorAvailable(mNativeObject, message); + } + } + + // Native functions + private static native void nativeNewLocationAvailable(long nativeObject, Location location); + private static native void nativeNewErrorAvailable(long nativeObject, String message); +} diff --git a/core/java/android/webkit/HTML5VideoViewProxy.java b/core/java/android/webkit/HTML5VideoViewProxy.java new file mode 100644 index 0000000..5a164f8 --- /dev/null +++ b/core/java/android/webkit/HTML5VideoViewProxy.java @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2009 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.media.MediaPlayer; +import android.media.MediaPlayer.OnPreparedListener; +import android.net.Uri; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.util.Log; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewGroup; +import android.webkit.ViewManager.ChildView; +import android.widget.AbsoluteLayout; +import android.widget.MediaController; +import android.widget.VideoView; + +import java.util.HashMap; + +/** + * <p>Proxy for HTML5 video views. + */ +class HTML5VideoViewProxy extends Handler { + // Logging tag. + private static final String LOGTAG = "HTML5VideoViewProxy"; + + // Message Ids for WebCore thread -> UI thread communication. + private static final int INIT = 100; + private static final int PLAY = 101; + + // The WebView instance that created this view. + private WebView mWebView; + // The ChildView instance used by the ViewManager. + private ChildView mChildView; + // The VideoView instance. Note that we could + // also access this via mChildView.mView but it would + // always require cast, so it is more convenient to store + // it here as well. + private HTML5VideoView mVideoView; + + // A VideoView subclass that responds to double-tap + // events by going fullscreen. + class HTML5VideoView extends VideoView { + // Used to save the layout parameters if the view + // is changed to fullscreen. + private AbsoluteLayout.LayoutParams mEmbeddedLayoutParams; + // Flag that denotes whether the view is fullscreen or not. + private boolean mIsFullscreen; + // Used to save the current playback position when + // transitioning to/from fullscreen. + private int mPlaybackPosition; + // The callback object passed to the host application. This callback + // is invoked when the host application dismisses our VideoView + // (e.g. the user presses the back key). + private WebChromeClient.CustomViewCallback mCallback = + new WebChromeClient.CustomViewCallback() { + public void onCustomViewHidden() { + playEmbedded(); + } + }; + + // The OnPreparedListener, used to automatically resume + // playback when transitioning to/from fullscreen. + private MediaPlayer.OnPreparedListener mPreparedListener = + new MediaPlayer.OnPreparedListener() { + public void onPrepared(MediaPlayer mp) { + resumePlayback(); + } + }; + + HTML5VideoView(Context context) { + super(context); + } + + void savePlaybackPosition() { + if (isPlaying()) { + mPlaybackPosition = getCurrentPosition(); + } + } + + void resumePlayback() { + seekTo(mPlaybackPosition); + start(); + setOnPreparedListener(null); + } + + void playEmbedded() { + // Attach to the WebView. + mChildView.attachViewOnUIThread(mEmbeddedLayoutParams); + // Make sure we're visible + setVisibility(View.VISIBLE); + // Set the onPrepared listener so we start + // playing when the video view is reattached + // and its surface is recreated. + setOnPreparedListener(mPreparedListener); + mIsFullscreen = false; + } + + void playFullScreen() { + WebChromeClient client = mWebView.getWebChromeClient(); + if (client == null) { + return; + } + // Save the current layout params. + mEmbeddedLayoutParams = + (AbsoluteLayout.LayoutParams) getLayoutParams(); + // Detach from the WebView. + mChildView.removeViewOnUIThread(); + // Attach to the browser UI. + client.onShowCustomView(this, mCallback); + // Set the onPrepared listener so we start + // playing when after the video view is reattached + // and its surface is recreated. + setOnPreparedListener(mPreparedListener); + mIsFullscreen = true; + } + + @Override + public boolean onTouchEvent(MotionEvent ev) { + // TODO: implement properly (i.e. detect double tap) + if (mIsFullscreen || !isPlaying()) { + return super.onTouchEvent(ev); + } + playFullScreen(); + return true; + } + + @Override + public void onDetachedFromWindow() { + super.onDetachedFromWindow(); + savePlaybackPosition(); + } + } + + /** + * Private constructor. + * @param context is the application context. + */ + private HTML5VideoViewProxy(WebView webView) { + // This handler is for the main (UI) thread. + super(Looper.getMainLooper()); + // Save the WebView object. + mWebView = webView; + } + + @Override + public void handleMessage(Message msg) { + // This executes on the UI thread. + switch (msg.what) { + case INIT: + // Create the video view and set a default controller. + mVideoView = new HTML5VideoView(mWebView.getContext()); + // This is needed because otherwise there will be a black square + // stuck on the screen. + mVideoView.setWillNotDraw(false); + mVideoView.setMediaController(new MediaController(mWebView.getContext())); + mChildView.mView = mVideoView; + break; + case PLAY: + if (mVideoView == null) { + return; + } + HashMap<String, Object> map = + (HashMap<String, Object>) msg.obj; + String url = (String) map.get("url"); + mVideoView.setVideoURI(Uri.parse(url)); + mVideoView.start(); + break; + } + } + + /** + * Play a video stream. + * @param url is the URL of the video stream. + * @param webview is the WebViewCore that is requesting the playback. + */ + public void play(String url) { + // We need to know the webview that is requesting the playback. + Message message = obtainMessage(PLAY); + HashMap<String, Object> map = new HashMap(); + map.put("url", url); + message.obj = map; + sendMessage(message); + } + + public void createView() { + mChildView = mWebView.mViewManager.createView(); + sendMessage(obtainMessage(INIT)); + } + + public void attachView(int x, int y, int width, int height) { + if (mChildView == null) { + return; + } + mChildView.attachView(x, y, width, height); + } + + public void removeView() { + if (mChildView == null) { + return; + } + mChildView.removeView(); + } + + /** + * The factory for HTML5VideoViewProxy instances. + * @param webViewCore is the WebViewCore that is requesting the proxy. + * + * @return a new HTML5VideoViewProxy object. + */ + public static HTML5VideoViewProxy getInstance(WebViewCore webViewCore) { + return new HTML5VideoViewProxy(webViewCore.getWebView()); + } +} diff --git a/core/java/android/webkit/HttpAuthHandler.java b/core/java/android/webkit/HttpAuthHandler.java index 84dc9f0..1c17575 100644 --- a/core/java/android/webkit/HttpAuthHandler.java +++ b/core/java/android/webkit/HttpAuthHandler.java @@ -49,8 +49,8 @@ public class HttpAuthHandler extends Handler { // Message id for handling the user response - private final int AUTH_PROCEED = 100; - private final int AUTH_CANCEL = 200; + private static final int AUTH_PROCEED = 100; + private static final int AUTH_CANCEL = 200; /** * Creates a new HTTP authentication handler with an empty diff --git a/core/java/android/webkit/HttpDateTime.java b/core/java/android/webkit/HttpDateTime.java index c6ec2d2..00b2731 100644 --- a/core/java/android/webkit/HttpDateTime.java +++ b/core/java/android/webkit/HttpDateTime.java @@ -23,7 +23,8 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -class HttpDateTime { +/** {@hide} */ +public final class HttpDateTime { /* * Regular expression for parsing HTTP-date. @@ -47,14 +48,16 @@ class HttpDateTime { * Wdy, DD Mon YYYY HH:MM:SS * Wdy Mon (SP)D HH:MM:SS YYYY * Wdy Mon DD HH:MM:SS YYYY GMT + * + * HH can be H if the first digit is zero. */ private static final String HTTP_DATE_RFC_REGEXP = "([0-9]{1,2})[- ]([A-Za-z]{3,3})[- ]([0-9]{2,4})[ ]" - + "([0-9][0-9]:[0-9][0-9]:[0-9][0-9])"; + + "([0-9]{1,2}:[0-9][0-9]:[0-9][0-9])"; private static final String HTTP_DATE_ANSIC_REGEXP = "[ ]([A-Za-z]{3,3})[ ]+([0-9]{1,2})[ ]" - + "([0-9][0-9]:[0-9][0-9]:[0-9][0-9])[ ]([0-9]{2,4})"; + + "([0-9]{1,2}:[0-9][0-9]:[0-9][0-9])[ ]([0-9]{2,4})"; /** * The compiled version of the HTTP-date regular expressions. @@ -65,6 +68,12 @@ class HttpDateTime { Pattern.compile(HTTP_DATE_ANSIC_REGEXP); private static class TimeOfDay { + TimeOfDay(int h, int m, int s) { + this.hour = h; + this.minute = m; + this.second = s; + } + int hour; int minute; int second; @@ -76,7 +85,7 @@ class HttpDateTime { int date = 1; int month = Calendar.JANUARY; int year = 1970; - TimeOfDay timeOfDay = new TimeOfDay(); + TimeOfDay timeOfDay; Matcher rfcMatcher = HTTP_DATE_RFC_PATTERN.matcher(timeString); if (rfcMatcher.find()) { @@ -183,13 +192,22 @@ class HttpDateTime { } private static TimeOfDay getTime(String timeString) { - TimeOfDay time = new TimeOfDay(); - time.hour = (timeString.charAt(0) - '0') * 10 - + (timeString.charAt(1) - '0'); - time.minute = (timeString.charAt(3) - '0') * 10 - + (timeString.charAt(4) - '0'); - time.second = (timeString.charAt(6) - '0') * 10 - + (timeString.charAt(7) - '0'); - return time; + // HH might be H + int i = 0; + int hour = timeString.charAt(i++) - '0'; + if (timeString.charAt(i) != ':') + hour = hour * 10 + (timeString.charAt(i++) - '0'); + // Skip ':' + i++; + + int minute = (timeString.charAt(i++) - '0') * 10 + + (timeString.charAt(i++) - '0'); + // Skip ':' + i++; + + int second = (timeString.charAt(i++) - '0') * 10 + + (timeString.charAt(i++) - '0'); + + return new TimeOfDay(hour, minute, second); } } diff --git a/core/java/android/webkit/JWebCoreJavaBridge.java b/core/java/android/webkit/JWebCoreJavaBridge.java index 1dbd007..ddc2da1 100644 --- a/core/java/android/webkit/JWebCoreJavaBridge.java +++ b/core/java/android/webkit/JWebCoreJavaBridge.java @@ -34,9 +34,16 @@ final class JWebCoreJavaBridge extends Handler { // Instant timer is used to implement a timer that needs to fire almost // immediately. private boolean mHasInstantTimer; + // Reference count the pause/resume of timers private int mPauseTimerRefCount; + private boolean mTimerPaused; + private boolean mHasDeferredTimers; + + /* package */ + static final int REFRESH_PLUGINS = 100; + /** * Construct a new JWebCoreJavaBridge to interface with * WebCore timers and cookies. @@ -51,6 +58,17 @@ final class JWebCoreJavaBridge extends Handler { } /** + * Call native timer callbacks. + */ + private void fireSharedTimer() { + PerfChecker checker = new PerfChecker(); + // clear the flag so that sharedTimerFired() can set a new timer + mHasInstantTimer = false; + sharedTimerFired(); + checker.responseAlert("sharedTimer"); + } + + /** * handleMessage * @param msg The dispatched message. * @@ -60,16 +78,21 @@ final class JWebCoreJavaBridge extends Handler { public void handleMessage(Message msg) { switch (msg.what) { case TIMER_MESSAGE: { - PerfChecker checker = new PerfChecker(); - // clear the flag so that sharedTimerFired() can set a new timer - mHasInstantTimer = false; - sharedTimerFired(); - checker.responseAlert("sharedTimer"); + if (mTimerPaused) { + mHasDeferredTimers = true; + } else { + fireSharedTimer(); + } break; } case FUNCPTR_MESSAGE: nativeServiceFuncPtrQueue(); break; + case REFRESH_PLUGINS: + nativeUpdatePluginDirectories(PluginManager.getInstance(null) + .getPluginDirectories(), ((Boolean) msg.obj) + .booleanValue()); + break; } } @@ -86,7 +109,8 @@ final class JWebCoreJavaBridge extends Handler { */ public void pause() { if (--mPauseTimerRefCount == 0) { - setDeferringTimers(true); + mTimerPaused = true; + mHasDeferredTimers = false; } } @@ -95,7 +119,11 @@ final class JWebCoreJavaBridge extends Handler { */ public void resume() { if (++mPauseTimerRefCount == 1) { - setDeferringTimers(false); + mTimerPaused = false; + if (mHasDeferredTimers) { + mHasDeferredTimers = false; + fireSharedTimer(); + } } } @@ -108,10 +136,9 @@ final class JWebCoreJavaBridge extends Handler { /** * Store a cookie string associated with a url. * @param url The url to be used as a key for the cookie. - * @param docUrl The policy base url used by WebCore. * @param value The cookie string to be stored. */ - private void setCookies(String url, String docUrl, String value) { + private void setCookies(String url, String value) { if (value.contains("\r") || value.contains("\n")) { // for security reason, filter out '\r' and '\n' from the cookie int size = value.length(); @@ -152,11 +179,25 @@ final class JWebCoreJavaBridge extends Handler { } /** + * Returns an array of plugin directoies + */ + private String[] getPluginDirectories() { + return PluginManager.getInstance(null).getPluginDirectories(); + } + + /** + * Returns the path of the plugin data directory + */ + private String getPluginSharedDataDirectory() { + return PluginManager.getInstance(null).getPluginSharedDataDirectory(); + } + + /** * setSharedTimer * @param timemillis The relative time when the timer should fire */ private void setSharedTimer(long timemillis) { - if (WebView.LOGV_ENABLED) Log.v(LOGTAG, "setSharedTimer " + timemillis); + if (DebugFlags.J_WEB_CORE_JAVA_BRIDGE) Log.v(LOGTAG, "setSharedTimer " + timemillis); if (timemillis <= 0) { // we don't accumulate the sharedTimer unless it is a delayed @@ -180,11 +221,12 @@ final class JWebCoreJavaBridge extends Handler { * Stop the shared timer. */ private void stopSharedTimer() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.J_WEB_CORE_JAVA_BRIDGE) { Log.v(LOGTAG, "stopSharedTimer removing all timers"); } removeMessages(TIMER_MESSAGE); mHasInstantTimer = false; + mHasDeferredTimers = false; } private String[] getKeyStrengthList() { @@ -199,6 +241,7 @@ final class JWebCoreJavaBridge extends Handler { private native void nativeConstructor(); private native void nativeFinalize(); private native void sharedTimerFired(); - private native void setDeferringTimers(boolean defer); + private native void nativeUpdatePluginDirectories(String[] directories, + boolean reload); public native void setNetworkOnLine(boolean online); } diff --git a/core/java/android/webkit/LoadListener.java b/core/java/android/webkit/LoadListener.java index c3f3594..7fff014 100644 --- a/core/java/android/webkit/LoadListener.java +++ b/core/java/android/webkit/LoadListener.java @@ -43,8 +43,6 @@ import java.util.Vector; import java.util.regex.Pattern; import java.util.regex.Matcher; -import org.apache.commons.codec.binary.Base64; - class LoadListener extends Handler implements EventHandler { private static final String LOGTAG = "webkit"; @@ -113,7 +111,6 @@ class LoadListener extends Handler implements EventHandler { private String mMethod; private Map<String, String> mRequestHeaders; private byte[] mPostData; - private boolean mIsHighPriority; // Flag to indicate that this load is synchronous. private boolean mSynchronous; private Vector<Message> mMessageQueue; @@ -142,15 +139,13 @@ class LoadListener extends Handler implements EventHandler { LoadListener(Context context, BrowserFrame frame, String url, int nativeLoader, boolean synchronous, boolean isMainPageLoader) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener constructor url=" + url); } mContext = context; mBrowserFrame = frame; setUrl(url); mNativeLoader = nativeLoader; - mMimeType = ""; - mEncoding = ""; mSynchronous = synchronous; if (synchronous) { mMessageQueue = new Vector<Message>(); @@ -293,7 +288,7 @@ class LoadListener extends Handler implements EventHandler { * directly */ public void headers(Headers headers) { - if (WebView.LOGV_ENABLED) Log.v(LOGTAG, "LoadListener.headers"); + if (DebugFlags.LOAD_LISTENER) Log.v(LOGTAG, "LoadListener.headers"); sendMessageInternal(obtainMessage(MSG_CONTENT_HEADERS, headers)); } @@ -301,8 +296,6 @@ class LoadListener extends Handler implements EventHandler { private void handleHeaders(Headers headers) { if (mCancelled) return; mHeaders = headers; - mMimeType = ""; - mEncoding = ""; ArrayList<String> cookies = headers.getSetCookie(); for (int i = 0; i < cookies.size(); ++i) { @@ -322,8 +315,8 @@ class LoadListener extends Handler implements EventHandler { // If we have one of "generic" MIME types, try to deduce // the right MIME type from the file extension (if any): - if (mMimeType.equalsIgnoreCase("text/plain") || - mMimeType.equalsIgnoreCase("application/octet-stream")) { + if (mMimeType.equals("text/plain") || + mMimeType.equals("application/octet-stream")) { // for attachment, use the filename in the Content-Disposition // to guess the mimetype @@ -339,17 +332,14 @@ class LoadListener extends Handler implements EventHandler { if (newMimeType != null) { mMimeType = newMimeType; } - } else if (mMimeType.equalsIgnoreCase("text/vnd.wap.wml")) { + } else if (mMimeType.equals("text/vnd.wap.wml")) { // As we don't support wml, render it as plain text mMimeType = "text/plain"; } else { - // XXX: Until the servers send us either correct xhtml or - // text/html, treat application/xhtml+xml as text/html. // It seems that xhtml+xml and vnd.wap.xhtml+xml mime // subtypes are used interchangeably. So treat them the same. - if (mMimeType.equalsIgnoreCase("application/xhtml+xml") || - mMimeType.equals("application/vnd.wap.xhtml+xml")) { - mMimeType = "text/html"; + if (mMimeType.equals("application/vnd.wap.xhtml+xml")) { + mMimeType = "application/xhtml+xml"; } } } else { @@ -450,7 +440,7 @@ class LoadListener extends Handler implements EventHandler { */ public void status(int majorVersion, int minorVersion, int code, /* Status-Code value */ String reasonPhrase) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener: from: " + mUrl + " major: " + majorVersion + " minor: " + minorVersion @@ -464,6 +454,9 @@ class LoadListener extends Handler implements EventHandler { status.put("reason", reasonPhrase); // New status means new data. Clear the old. mDataBuilder.clear(); + mMimeType = ""; + mEncoding = ""; + mTransferEncoding = ""; sendMessageInternal(obtainMessage(MSG_STATUS, status)); } @@ -507,7 +500,7 @@ class LoadListener extends Handler implements EventHandler { * directly */ public void error(int id, String description) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.error url:" + url() + " id:" + id + " description:" + description); } @@ -535,23 +528,10 @@ class LoadListener extends Handler implements EventHandler { * mDataBuilder is a thread-safe structure. */ public void data(byte[] data, int length) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.data(): url: " + url()); } - // Decode base64 data - // Note: It's fine that we only decode base64 here and not in the other - // data call because the only caller of the stream version is not - // base64 encoded. - if ("base64".equalsIgnoreCase(mTransferEncoding)) { - if (length < data.length) { - byte[] trimmedData = new byte[length]; - System.arraycopy(data, 0, trimmedData, 0, length); - data = trimmedData; - } - data = Base64.decodeBase64(data); - length = data.length; - } // Synchronize on mData because commitLoad may write mData to WebCore // and we don't want to replace mData or mDataLength at the same time // as a write. @@ -573,7 +553,7 @@ class LoadListener extends Handler implements EventHandler { * directly */ public void endData() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.endData(): url: " + url()); } sendMessageInternal(obtainMessage(MSG_CONTENT_FINISHED)); @@ -626,7 +606,7 @@ class LoadListener extends Handler implements EventHandler { // before calling it. if (mCacheLoader != null) { mCacheLoader.load(); - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener cache load url=" + url()); } return; @@ -676,7 +656,7 @@ class LoadListener extends Handler implements EventHandler { CacheManager.HEADER_KEY_IFNONEMATCH) && !headers.containsKey( CacheManager.HEADER_KEY_IFMODIFIEDSINCE)) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "FrameLoader: HTTP URL in cache " + "and usable: " + url()); } @@ -695,7 +675,7 @@ class LoadListener extends Handler implements EventHandler { * directly */ public boolean handleSslErrorRequest(SslError error) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.handleSslErrorRequest(): url:" + url() + " primary error: " + error.getPrimaryError() + @@ -773,7 +753,7 @@ class LoadListener extends Handler implements EventHandler { * are null, cancel the request. */ void handleAuthResponse(String username, String password) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.handleAuthResponse: url: " + mUrl + " username: " + username + " password: " + password); @@ -823,14 +803,12 @@ class LoadListener extends Handler implements EventHandler { * @param method * @param headers * @param postData - * @param isHighPriority */ void setRequestData(String method, Map<String, String> headers, - byte[] postData, boolean isHighPriority) { + byte[] postData) { mMethod = method; mRequestHeaders = headers; mPostData = postData; - mIsHighPriority = isHighPriority; } /** @@ -870,7 +848,7 @@ class LoadListener extends Handler implements EventHandler { } void attachRequestHandle(RequestHandle requestHandle) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.attachRequestHandle(): " + "requestHandle: " + requestHandle); } @@ -878,7 +856,7 @@ class LoadListener extends Handler implements EventHandler { } void detachRequestHandle() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.detachRequestHandle(): " + "requestHandle: " + mRequestHandle); } @@ -917,7 +895,7 @@ class LoadListener extends Handler implements EventHandler { */ static boolean willLoadFromCache(String url) { boolean inCache = CacheManager.getCacheFile(url, null) != null; - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "willLoadFromCache: " + url + " in cache: " + inCache); } @@ -938,6 +916,10 @@ class LoadListener extends Handler implements EventHandler { return mMimeType; } + String transferEncoding() { + return mTransferEncoding; + } + /* * Return the size of the content being downloaded. This represents the * full content size, even under the situation where the download has been @@ -992,8 +974,7 @@ class LoadListener extends Handler implements EventHandler { // pass content-type content-length and content-encoding final int nativeResponse = nativeCreateResponse( mUrl, statusCode, mStatusText, - mMimeType, mContentLength, mEncoding, - mCacheResult == null ? 0 : mCacheResult.expires / 1000); + mMimeType, mContentLength, mEncoding); if (mHeaders != null) { mHeaders.getHeaders(new Headers.HeaderCallback() { public void header(String name, String value) { @@ -1115,7 +1096,7 @@ class LoadListener extends Handler implements EventHandler { * EventHandler's method call. */ public void cancel() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { if (mRequestHandle == null) { Log.v(LOGTAG, "LoadListener.cancel(): no requestHandle"); } else { @@ -1221,7 +1202,7 @@ class LoadListener extends Handler implements EventHandler { // Network.requestURL. Network network = Network.getInstance(getContext()); if (!network.requestURL(mMethod, mRequestHeaders, - mPostData, this, mIsHighPriority)) { + mPostData, this)) { // Signal a bad url error if we could not load the // redirection. handleError(EventHandler.ERROR_BAD_URL, @@ -1247,7 +1228,7 @@ class LoadListener extends Handler implements EventHandler { tearDown(); } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.onRedirect(): redirect to: " + redirectTo); } @@ -1260,8 +1241,8 @@ class LoadListener extends Handler implements EventHandler { private static final Pattern CONTENT_TYPE_PATTERN = Pattern.compile("^((?:[xX]-)?[a-zA-Z\\*]+/[\\w\\+\\*-]+[\\.[\\w\\+-]+]*)$"); - private void parseContentTypeHeader(String contentType) { - if (WebView.LOGV_ENABLED) { + /* package */ void parseContentTypeHeader(String contentType) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "LoadListener.parseContentTypeHeader: " + "contentType: " + contentType); } @@ -1282,13 +1263,14 @@ class LoadListener extends Handler implements EventHandler { mEncoding = contentType.substring(i + 1); } // Trim excess whitespace. - mEncoding = mEncoding.trim(); + mEncoding = mEncoding.trim().toLowerCase(); if (i < contentType.length() - 1) { // for data: uri the mimeType and encoding have // the form image/jpeg;base64 or text/plain;charset=utf-8 // or text/html;charset=utf-8;base64 - mTransferEncoding = contentType.substring(i + 1).trim(); + mTransferEncoding = + contentType.substring(i + 1).trim().toLowerCase(); } } else { mMimeType = contentType; @@ -1308,6 +1290,8 @@ class LoadListener extends Handler implements EventHandler { guessMimeType(); } } + // Ensure mMimeType is lower case. + mMimeType = mMimeType.toLowerCase(); } /** @@ -1397,7 +1381,8 @@ class LoadListener extends Handler implements EventHandler { */ private boolean ignoreCallbacks() { return (mCancelled || mAuthHeader != null || - (mStatusCode > 300 && mStatusCode < 400)); + // Allow 305 (Use Proxy) to call through. + (mStatusCode > 300 && mStatusCode < 400 && mStatusCode != 305)); } /** @@ -1438,7 +1423,7 @@ class LoadListener extends Handler implements EventHandler { mMimeType = "text/html"; String newMimeType = guessMimeTypeFromExtension(mUrl); if (newMimeType != null) { - mMimeType = newMimeType; + mMimeType = newMimeType; } } } @@ -1448,23 +1433,12 @@ class LoadListener extends Handler implements EventHandler { */ private String guessMimeTypeFromExtension(String url) { // PENDING: need to normalize url - if (WebView.LOGV_ENABLED) { + if (DebugFlags.LOAD_LISTENER) { Log.v(LOGTAG, "guessMimeTypeFromExtension: url = " + url); } - String mimeType = - MimeTypeMap.getSingleton().getMimeTypeFromExtension( - MimeTypeMap.getFileExtensionFromUrl(url)); - - if (mimeType != null) { - // XXX: Until the servers send us either correct xhtml or - // text/html, treat application/xhtml+xml as text/html. - if (mimeType.equals("application/xhtml+xml")) { - mimeType = "text/html"; - } - } - - return mimeType; + return MimeTypeMap.getSingleton().getMimeTypeFromExtension( + MimeTypeMap.getFileExtensionFromUrl(url)); } /** @@ -1483,7 +1457,7 @@ class LoadListener extends Handler implements EventHandler { * Cycle through our messages for synchronous loads. */ /* package */ void loadSynchronousMessages() { - if (WebView.DEBUG && !mSynchronous) { + if (DebugFlags.LOAD_LISTENER && !mSynchronous) { throw new AssertionError(); } // Note: this can be called twice if it is a synchronous network load, @@ -1510,12 +1484,11 @@ class LoadListener extends Handler implements EventHandler { * @param expectedLength An estimate of the content length or the length * given by the server. * @param encoding HTTP encoding. - * @param expireTime HTTP expires converted to seconds since the epoch. * @return The native response pointer. */ private native int nativeCreateResponse(String url, int statusCode, String statusText, String mimeType, long expectedLength, - String encoding, long expireTime); + String encoding); /** * Add a response header to the native object. diff --git a/core/java/android/webkit/MimeTypeMap.java b/core/java/android/webkit/MimeTypeMap.java index 9fdde61..a55dbc8 100644 --- a/core/java/android/webkit/MimeTypeMap.java +++ b/core/java/android/webkit/MimeTypeMap.java @@ -22,7 +22,7 @@ import java.util.regex.Pattern; /** * Two-way map that maps MIME-types to file extensions and vice versa. */ -public /* package */ class MimeTypeMap { +public class MimeTypeMap { /** * Singleton MIME-type map instance: @@ -39,7 +39,6 @@ public /* package */ class MimeTypeMap { */ private HashMap<String, String> mExtensionToMimeTypeMap; - /** * Creates a new MIME-type map. */ @@ -50,7 +49,10 @@ public /* package */ class MimeTypeMap { /** * Returns the file extension or an empty string iff there is no - * extension. + * extension. This method is a convenience method for obtaining the + * extension of a url and has undefined results for other Strings. + * @param url + * @return The file extension of the given url. */ public static String getFileExtensionFromUrl(String url) { if (url != null && url.length() > 0) { @@ -80,8 +82,7 @@ public /* package */ class MimeTypeMap { * Load an entry into the map. This does not check if the item already * exists, it trusts the caller! */ - private void loadEntry(String mimeType, String extension, - boolean textType) { + private void loadEntry(String mimeType, String extension) { // // if we have an existing x --> y mapping, we do not want to // override it with another mapping x --> ? @@ -94,18 +95,12 @@ public /* package */ class MimeTypeMap { mMimeTypeToExtensionMap.put(mimeType, extension); } - // - // here, we don't want to map extensions to text MIME types; - // otherwise, we will start replacing generic text/plain and - // text/html with text MIME types that our platform does not - // understand. - // - if (!textType) { - mExtensionToMimeTypeMap.put(extension, mimeType); - } + mExtensionToMimeTypeMap.put(extension, mimeType); } /** + * Return true if the given MIME type has an entry in the map. + * @param mimeType A MIME type (i.e. text/plain) * @return True iff there is a mimeType entry in the map. */ public boolean hasMimeType(String mimeType) { @@ -117,7 +112,9 @@ public /* package */ class MimeTypeMap { } /** - * @return The extension for the MIME type or null iff there is none. + * Return the MIME type for the given extension. + * @param extension A file extension without the leading '.' + * @return The MIME type for the given extension or null iff there is none. */ public String getMimeTypeFromExtension(String extension) { if (extension != null && extension.length() > 0) { @@ -128,18 +125,23 @@ public /* package */ class MimeTypeMap { } /** + * Return true if the given extension has a registered MIME type. + * @param extension A file extension without the leading '.' * @return True iff there is an extension entry in the map. */ public boolean hasExtension(String extension) { if (extension != null && extension.length() > 0) { return mExtensionToMimeTypeMap.containsKey(extension); } - return false; } /** - * @return The MIME type for the extension or null iff there is none. + * Return the registered extension for the given MIME type. Note that some + * MIME types map to multiple extensions. This call will return the most + * common extension for the given MIME type. + * @param mimeType A MIME type (i.e. text/plain) + * @return The extension for the given MIME type or null iff there is none. */ public String getExtensionFromMimeType(String mimeType) { if (mimeType != null && mimeType.length() > 0) { @@ -150,6 +152,7 @@ public /* package */ class MimeTypeMap { } /** + * Get the singleton instance of MimeTypeMap. * @return The singleton instance of the MIME-type map. */ public static MimeTypeMap getSingleton() { @@ -164,341 +167,312 @@ public /* package */ class MimeTypeMap { // mail.google.com/a/google.com // // and "active" MIME types (due to potential security issues). - // - // Also, notice that not all data from this table is actually - // added (see loadEntry method for more details). - sMimeTypeMap.loadEntry("application/andrew-inset", "ez", false); - sMimeTypeMap.loadEntry("application/dsptype", "tsp", false); - sMimeTypeMap.loadEntry("application/futuresplash", "spl", false); - sMimeTypeMap.loadEntry("application/hta", "hta", false); - sMimeTypeMap.loadEntry("application/mac-binhex40", "hqx", false); - sMimeTypeMap.loadEntry("application/mac-compactpro", "cpt", false); - sMimeTypeMap.loadEntry("application/mathematica", "nb", false); - sMimeTypeMap.loadEntry("application/msaccess", "mdb", false); - sMimeTypeMap.loadEntry("application/oda", "oda", false); - sMimeTypeMap.loadEntry("application/ogg", "ogg", false); - sMimeTypeMap.loadEntry("application/pdf", "pdf", false); - sMimeTypeMap.loadEntry("application/pgp-keys", "key", false); - sMimeTypeMap.loadEntry("application/pgp-signature", "pgp", false); - sMimeTypeMap.loadEntry("application/pics-rules", "prf", false); - sMimeTypeMap.loadEntry("application/rar", "rar", false); - sMimeTypeMap.loadEntry("application/rdf+xml", "rdf", false); - sMimeTypeMap.loadEntry("application/rss+xml", "rss", false); - sMimeTypeMap.loadEntry("application/zip", "zip", false); + sMimeTypeMap.loadEntry("application/andrew-inset", "ez"); + sMimeTypeMap.loadEntry("application/dsptype", "tsp"); + sMimeTypeMap.loadEntry("application/futuresplash", "spl"); + sMimeTypeMap.loadEntry("application/hta", "hta"); + sMimeTypeMap.loadEntry("application/mac-binhex40", "hqx"); + sMimeTypeMap.loadEntry("application/mac-compactpro", "cpt"); + sMimeTypeMap.loadEntry("application/mathematica", "nb"); + sMimeTypeMap.loadEntry("application/msaccess", "mdb"); + sMimeTypeMap.loadEntry("application/oda", "oda"); + sMimeTypeMap.loadEntry("application/ogg", "ogg"); + sMimeTypeMap.loadEntry("application/pdf", "pdf"); + sMimeTypeMap.loadEntry("application/pgp-keys", "key"); + sMimeTypeMap.loadEntry("application/pgp-signature", "pgp"); + sMimeTypeMap.loadEntry("application/pics-rules", "prf"); + sMimeTypeMap.loadEntry("application/rar", "rar"); + sMimeTypeMap.loadEntry("application/rdf+xml", "rdf"); + sMimeTypeMap.loadEntry("application/rss+xml", "rss"); + sMimeTypeMap.loadEntry("application/zip", "zip"); sMimeTypeMap.loadEntry("application/vnd.android.package-archive", - "apk", false); - sMimeTypeMap.loadEntry("application/vnd.cinderella", "cdy", false); - sMimeTypeMap.loadEntry("application/vnd.ms-pki.stl", "stl", false); + "apk"); + sMimeTypeMap.loadEntry("application/vnd.cinderella", "cdy"); + sMimeTypeMap.loadEntry("application/vnd.ms-pki.stl", "stl"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.database", "odb", - false); + "application/vnd.oasis.opendocument.database", "odb"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.formula", "odf", - false); + "application/vnd.oasis.opendocument.formula", "odf"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.graphics", "odg", - false); + "application/vnd.oasis.opendocument.graphics", "odg"); sMimeTypeMap.loadEntry( "application/vnd.oasis.opendocument.graphics-template", - "otg", false); + "otg"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.image", "odi", false); + "application/vnd.oasis.opendocument.image", "odi"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.spreadsheet", "ods", - false); + "application/vnd.oasis.opendocument.spreadsheet", "ods"); sMimeTypeMap.loadEntry( "application/vnd.oasis.opendocument.spreadsheet-template", - "ots", false); - sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.text", "odt", false); + "ots"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.text-master", "odm", - false); + "application/vnd.oasis.opendocument.text", "odt"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.text-template", "ott", - false); + "application/vnd.oasis.opendocument.text-master", "odm"); sMimeTypeMap.loadEntry( - "application/vnd.oasis.opendocument.text-web", "oth", - false); - sMimeTypeMap.loadEntry("application/vnd.rim.cod", "cod", false); - sMimeTypeMap.loadEntry("application/vnd.smaf", "mmf", false); - sMimeTypeMap.loadEntry("application/vnd.stardivision.calc", "sdc", - false); - sMimeTypeMap.loadEntry("application/vnd.stardivision.draw", "sda", - false); + "application/vnd.oasis.opendocument.text-template", "ott"); sMimeTypeMap.loadEntry( - "application/vnd.stardivision.impress", "sdd", false); + "application/vnd.oasis.opendocument.text-web", "oth"); + sMimeTypeMap.loadEntry("application/vnd.rim.cod", "cod"); + sMimeTypeMap.loadEntry("application/vnd.smaf", "mmf"); + sMimeTypeMap.loadEntry("application/vnd.stardivision.calc", "sdc"); + sMimeTypeMap.loadEntry("application/vnd.stardivision.draw", "sda"); sMimeTypeMap.loadEntry( - "application/vnd.stardivision.impress", "sdp", false); - sMimeTypeMap.loadEntry("application/vnd.stardivision.math", "smf", - false); - sMimeTypeMap.loadEntry("application/vnd.stardivision.writer", "sdw", - false); - sMimeTypeMap.loadEntry("application/vnd.stardivision.writer", "vor", - false); + "application/vnd.stardivision.impress", "sdd"); sMimeTypeMap.loadEntry( - "application/vnd.stardivision.writer-global", "sgl", false); - sMimeTypeMap.loadEntry("application/vnd.sun.xml.calc", "sxc", - false); + "application/vnd.stardivision.impress", "sdp"); + sMimeTypeMap.loadEntry("application/vnd.stardivision.math", "smf"); + sMimeTypeMap.loadEntry("application/vnd.stardivision.writer", + "sdw"); + sMimeTypeMap.loadEntry("application/vnd.stardivision.writer", + "vor"); sMimeTypeMap.loadEntry( - "application/vnd.sun.xml.calc.template", "stc", false); - sMimeTypeMap.loadEntry("application/vnd.sun.xml.draw", "sxd", - false); + "application/vnd.stardivision.writer-global", "sgl"); + sMimeTypeMap.loadEntry("application/vnd.sun.xml.calc", "sxc"); sMimeTypeMap.loadEntry( - "application/vnd.sun.xml.draw.template", "std", false); - sMimeTypeMap.loadEntry("application/vnd.sun.xml.impress", "sxi", - false); + "application/vnd.sun.xml.calc.template", "stc"); + sMimeTypeMap.loadEntry("application/vnd.sun.xml.draw", "sxd"); sMimeTypeMap.loadEntry( - "application/vnd.sun.xml.impress.template", "sti", false); - sMimeTypeMap.loadEntry("application/vnd.sun.xml.math", "sxm", - false); - sMimeTypeMap.loadEntry("application/vnd.sun.xml.writer", "sxw", - false); + "application/vnd.sun.xml.draw.template", "std"); + sMimeTypeMap.loadEntry("application/vnd.sun.xml.impress", "sxi"); sMimeTypeMap.loadEntry( - "application/vnd.sun.xml.writer.global", "sxg", false); + "application/vnd.sun.xml.impress.template", "sti"); + sMimeTypeMap.loadEntry("application/vnd.sun.xml.math", "sxm"); + sMimeTypeMap.loadEntry("application/vnd.sun.xml.writer", "sxw"); sMimeTypeMap.loadEntry( - "application/vnd.sun.xml.writer.template", "stw", false); - sMimeTypeMap.loadEntry("application/vnd.visio", "vsd", false); - sMimeTypeMap.loadEntry("application/x-abiword", "abw", false); - sMimeTypeMap.loadEntry("application/x-apple-diskimage", "dmg", - false); - sMimeTypeMap.loadEntry("application/x-bcpio", "bcpio", false); - sMimeTypeMap.loadEntry("application/x-bittorrent", "torrent", - false); - sMimeTypeMap.loadEntry("application/x-cdf", "cdf", false); - sMimeTypeMap.loadEntry("application/x-cdlink", "vcd", false); - sMimeTypeMap.loadEntry("application/x-chess-pgn", "pgn", false); - sMimeTypeMap.loadEntry("application/x-cpio", "cpio", false); - sMimeTypeMap.loadEntry("application/x-debian-package", "deb", - false); - sMimeTypeMap.loadEntry("application/x-debian-package", "udeb", - false); - sMimeTypeMap.loadEntry("application/x-director", "dcr", false); - sMimeTypeMap.loadEntry("application/x-director", "dir", false); - sMimeTypeMap.loadEntry("application/x-director", "dxr", false); - sMimeTypeMap.loadEntry("application/x-dms", "dms", false); - sMimeTypeMap.loadEntry("application/x-doom", "wad", false); - sMimeTypeMap.loadEntry("application/x-dvi", "dvi", false); - sMimeTypeMap.loadEntry("application/x-flac", "flac", false); - sMimeTypeMap.loadEntry("application/x-font", "pfa", false); - sMimeTypeMap.loadEntry("application/x-font", "pfb", false); - sMimeTypeMap.loadEntry("application/x-font", "gsf", false); - sMimeTypeMap.loadEntry("application/x-font", "pcf", false); - sMimeTypeMap.loadEntry("application/x-font", "pcf.Z", false); - sMimeTypeMap.loadEntry("application/x-freemind", "mm", false); - sMimeTypeMap.loadEntry("application/x-futuresplash", "spl", false); - sMimeTypeMap.loadEntry("application/x-gnumeric", "gnumeric", false); - sMimeTypeMap.loadEntry("application/x-go-sgf", "sgf", false); - sMimeTypeMap.loadEntry("application/x-graphing-calculator", "gcf", - false); - sMimeTypeMap.loadEntry("application/x-gtar", "gtar", false); - sMimeTypeMap.loadEntry("application/x-gtar", "tgz", false); - sMimeTypeMap.loadEntry("application/x-gtar", "taz", false); - sMimeTypeMap.loadEntry("application/x-hdf", "hdf", false); - sMimeTypeMap.loadEntry("application/x-ica", "ica", false); - sMimeTypeMap.loadEntry("application/x-internet-signup", "ins", - false); - sMimeTypeMap.loadEntry("application/x-internet-signup", "isp", - false); - sMimeTypeMap.loadEntry("application/x-iphone", "iii", false); - sMimeTypeMap.loadEntry("application/x-iso9660-image", "iso", false); - sMimeTypeMap.loadEntry("application/x-jmol", "jmz", false); - sMimeTypeMap.loadEntry("application/x-kchart", "chrt", false); - sMimeTypeMap.loadEntry("application/x-killustrator", "kil", false); - sMimeTypeMap.loadEntry("application/x-koan", "skp", false); - sMimeTypeMap.loadEntry("application/x-koan", "skd", false); - sMimeTypeMap.loadEntry("application/x-koan", "skt", false); - sMimeTypeMap.loadEntry("application/x-koan", "skm", false); - sMimeTypeMap.loadEntry("application/x-kpresenter", "kpr", false); - sMimeTypeMap.loadEntry("application/x-kpresenter", "kpt", false); - sMimeTypeMap.loadEntry("application/x-kspread", "ksp", false); - sMimeTypeMap.loadEntry("application/x-kword", "kwd", false); - sMimeTypeMap.loadEntry("application/x-kword", "kwt", false); - sMimeTypeMap.loadEntry("application/x-latex", "latex", false); - sMimeTypeMap.loadEntry("application/x-lha", "lha", false); - sMimeTypeMap.loadEntry("application/x-lzh", "lzh", false); - sMimeTypeMap.loadEntry("application/x-lzx", "lzx", false); - sMimeTypeMap.loadEntry("application/x-maker", "frm", false); - sMimeTypeMap.loadEntry("application/x-maker", "maker", false); - sMimeTypeMap.loadEntry("application/x-maker", "frame", false); - sMimeTypeMap.loadEntry("application/x-maker", "fb", false); - sMimeTypeMap.loadEntry("application/x-maker", "book", false); - sMimeTypeMap.loadEntry("application/x-maker", "fbdoc", false); - sMimeTypeMap.loadEntry("application/x-mif", "mif", false); - sMimeTypeMap.loadEntry("application/x-ms-wmd", "wmd", false); - sMimeTypeMap.loadEntry("application/x-ms-wmz", "wmz", false); - sMimeTypeMap.loadEntry("application/x-msi", "msi", false); - sMimeTypeMap.loadEntry("application/x-ns-proxy-autoconfig", "pac", - false); - sMimeTypeMap.loadEntry("application/x-nwc", "nwc", false); - sMimeTypeMap.loadEntry("application/x-object", "o", false); - sMimeTypeMap.loadEntry("application/x-oz-application", "oza", - false); - sMimeTypeMap.loadEntry("application/x-pkcs12", "p12", false); - sMimeTypeMap.loadEntry("application/x-pkcs7-certreqresp", "p7r", - false); - sMimeTypeMap.loadEntry("application/x-pkcs7-crl", "crl", false); - sMimeTypeMap.loadEntry("application/x-quicktimeplayer", "qtl", - false); - sMimeTypeMap.loadEntry("application/x-shar", "shar", false); - sMimeTypeMap.loadEntry("application/x-stuffit", "sit", false); - sMimeTypeMap.loadEntry("application/x-sv4cpio", "sv4cpio", false); - sMimeTypeMap.loadEntry("application/x-sv4crc", "sv4crc", false); - sMimeTypeMap.loadEntry("application/x-tar", "tar", false); - sMimeTypeMap.loadEntry("application/x-texinfo", "texinfo", false); - sMimeTypeMap.loadEntry("application/x-texinfo", "texi", false); - sMimeTypeMap.loadEntry("application/x-troff", "t", false); - sMimeTypeMap.loadEntry("application/x-troff", "roff", false); - sMimeTypeMap.loadEntry("application/x-troff-man", "man", false); - sMimeTypeMap.loadEntry("application/x-ustar", "ustar", false); - sMimeTypeMap.loadEntry("application/x-wais-source", "src", false); - sMimeTypeMap.loadEntry("application/x-wingz", "wz", false); + "application/vnd.sun.xml.writer.global", "sxg"); sMimeTypeMap.loadEntry( - "application/x-webarchive", "webarchive", false); // added - sMimeTypeMap.loadEntry("application/x-x509-ca-cert", "crt", false); - sMimeTypeMap.loadEntry("application/x-x509-user-cert", "crt", false); - sMimeTypeMap.loadEntry("application/x-xcf", "xcf", false); - sMimeTypeMap.loadEntry("application/x-xfig", "fig", false); - sMimeTypeMap.loadEntry("audio/basic", "snd", false); - sMimeTypeMap.loadEntry("audio/midi", "mid", false); - sMimeTypeMap.loadEntry("audio/midi", "midi", false); - sMimeTypeMap.loadEntry("audio/midi", "kar", false); - sMimeTypeMap.loadEntry("audio/mpeg", "mpga", false); - sMimeTypeMap.loadEntry("audio/mpeg", "mpega", false); - sMimeTypeMap.loadEntry("audio/mpeg", "mp2", false); - sMimeTypeMap.loadEntry("audio/mpeg", "mp3", false); - sMimeTypeMap.loadEntry("audio/mpeg", "m4a", false); - sMimeTypeMap.loadEntry("audio/mpegurl", "m3u", false); - sMimeTypeMap.loadEntry("audio/prs.sid", "sid", false); - sMimeTypeMap.loadEntry("audio/x-aiff", "aif", false); - sMimeTypeMap.loadEntry("audio/x-aiff", "aiff", false); - sMimeTypeMap.loadEntry("audio/x-aiff", "aifc", false); - sMimeTypeMap.loadEntry("audio/x-gsm", "gsm", false); - sMimeTypeMap.loadEntry("audio/x-mpegurl", "m3u", false); - sMimeTypeMap.loadEntry("audio/x-ms-wma", "wma", false); - sMimeTypeMap.loadEntry("audio/x-ms-wax", "wax", false); - sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "ra", false); - sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "rm", false); - sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "ram", false); - sMimeTypeMap.loadEntry("audio/x-realaudio", "ra", false); - sMimeTypeMap.loadEntry("audio/x-scpls", "pls", false); - sMimeTypeMap.loadEntry("audio/x-sd2", "sd2", false); - sMimeTypeMap.loadEntry("audio/x-wav", "wav", false); - sMimeTypeMap.loadEntry("image/bmp", "bmp", false); // added - sMimeTypeMap.loadEntry("image/gif", "gif", false); - sMimeTypeMap.loadEntry("image/ico", "cur", false); // added - sMimeTypeMap.loadEntry("image/ico", "ico", false); // added - sMimeTypeMap.loadEntry("image/ief", "ief", false); - sMimeTypeMap.loadEntry("image/jpeg", "jpeg", false); - sMimeTypeMap.loadEntry("image/jpeg", "jpg", false); - sMimeTypeMap.loadEntry("image/jpeg", "jpe", false); - sMimeTypeMap.loadEntry("image/pcx", "pcx", false); - sMimeTypeMap.loadEntry("image/png", "png", false); - sMimeTypeMap.loadEntry("image/svg+xml", "svg", false); - sMimeTypeMap.loadEntry("image/svg+xml", "svgz", false); - sMimeTypeMap.loadEntry("image/tiff", "tiff", false); - sMimeTypeMap.loadEntry("image/tiff", "tif", false); - sMimeTypeMap.loadEntry("image/vnd.djvu", "djvu", false); - sMimeTypeMap.loadEntry("image/vnd.djvu", "djv", false); - sMimeTypeMap.loadEntry("image/vnd.wap.wbmp", "wbmp", false); - sMimeTypeMap.loadEntry("image/x-cmu-raster", "ras", false); - sMimeTypeMap.loadEntry("image/x-coreldraw", "cdr", false); - sMimeTypeMap.loadEntry("image/x-coreldrawpattern", "pat", false); - sMimeTypeMap.loadEntry("image/x-coreldrawtemplate", "cdt", false); - sMimeTypeMap.loadEntry("image/x-corelphotopaint", "cpt", false); - sMimeTypeMap.loadEntry("image/x-icon", "ico", false); - sMimeTypeMap.loadEntry("image/x-jg", "art", false); - sMimeTypeMap.loadEntry("image/x-jng", "jng", false); - sMimeTypeMap.loadEntry("image/x-ms-bmp", "bmp", false); - sMimeTypeMap.loadEntry("image/x-photoshop", "psd", false); - sMimeTypeMap.loadEntry("image/x-portable-anymap", "pnm", false); - sMimeTypeMap.loadEntry("image/x-portable-bitmap", "pbm", false); - sMimeTypeMap.loadEntry("image/x-portable-graymap", "pgm", false); - sMimeTypeMap.loadEntry("image/x-portable-pixmap", "ppm", false); - sMimeTypeMap.loadEntry("image/x-rgb", "rgb", false); - sMimeTypeMap.loadEntry("image/x-xbitmap", "xbm", false); - sMimeTypeMap.loadEntry("image/x-xpixmap", "xpm", false); - sMimeTypeMap.loadEntry("image/x-xwindowdump", "xwd", false); - sMimeTypeMap.loadEntry("model/iges", "igs", false); - sMimeTypeMap.loadEntry("model/iges", "iges", false); - sMimeTypeMap.loadEntry("model/mesh", "msh", false); - sMimeTypeMap.loadEntry("model/mesh", "mesh", false); - sMimeTypeMap.loadEntry("model/mesh", "silo", false); - sMimeTypeMap.loadEntry("text/calendar", "ics", true); - sMimeTypeMap.loadEntry("text/calendar", "icz", true); - sMimeTypeMap.loadEntry("text/comma-separated-values", "csv", true); - sMimeTypeMap.loadEntry("text/css", "css", true); - sMimeTypeMap.loadEntry("text/h323", "323", true); - sMimeTypeMap.loadEntry("text/iuls", "uls", true); - sMimeTypeMap.loadEntry("text/mathml", "mml", true); + "application/vnd.sun.xml.writer.template", "stw"); + sMimeTypeMap.loadEntry("application/vnd.visio", "vsd"); + sMimeTypeMap.loadEntry("application/x-abiword", "abw"); + sMimeTypeMap.loadEntry("application/x-apple-diskimage", "dmg"); + sMimeTypeMap.loadEntry("application/x-bcpio", "bcpio"); + sMimeTypeMap.loadEntry("application/x-bittorrent", "torrent"); + sMimeTypeMap.loadEntry("application/x-cdf", "cdf"); + sMimeTypeMap.loadEntry("application/x-cdlink", "vcd"); + sMimeTypeMap.loadEntry("application/x-chess-pgn", "pgn"); + sMimeTypeMap.loadEntry("application/x-cpio", "cpio"); + sMimeTypeMap.loadEntry("application/x-debian-package", "deb"); + sMimeTypeMap.loadEntry("application/x-debian-package", "udeb"); + sMimeTypeMap.loadEntry("application/x-director", "dcr"); + sMimeTypeMap.loadEntry("application/x-director", "dir"); + sMimeTypeMap.loadEntry("application/x-director", "dxr"); + sMimeTypeMap.loadEntry("application/x-dms", "dms"); + sMimeTypeMap.loadEntry("application/x-doom", "wad"); + sMimeTypeMap.loadEntry("application/x-dvi", "dvi"); + sMimeTypeMap.loadEntry("application/x-flac", "flac"); + sMimeTypeMap.loadEntry("application/x-font", "pfa"); + sMimeTypeMap.loadEntry("application/x-font", "pfb"); + sMimeTypeMap.loadEntry("application/x-font", "gsf"); + sMimeTypeMap.loadEntry("application/x-font", "pcf"); + sMimeTypeMap.loadEntry("application/x-font", "pcf.Z"); + sMimeTypeMap.loadEntry("application/x-freemind", "mm"); + sMimeTypeMap.loadEntry("application/x-futuresplash", "spl"); + sMimeTypeMap.loadEntry("application/x-gnumeric", "gnumeric"); + sMimeTypeMap.loadEntry("application/x-go-sgf", "sgf"); + sMimeTypeMap.loadEntry("application/x-graphing-calculator", "gcf"); + sMimeTypeMap.loadEntry("application/x-gtar", "gtar"); + sMimeTypeMap.loadEntry("application/x-gtar", "tgz"); + sMimeTypeMap.loadEntry("application/x-gtar", "taz"); + sMimeTypeMap.loadEntry("application/x-hdf", "hdf"); + sMimeTypeMap.loadEntry("application/x-ica", "ica"); + sMimeTypeMap.loadEntry("application/x-internet-signup", "ins"); + sMimeTypeMap.loadEntry("application/x-internet-signup", "isp"); + sMimeTypeMap.loadEntry("application/x-iphone", "iii"); + sMimeTypeMap.loadEntry("application/x-iso9660-image", "iso"); + sMimeTypeMap.loadEntry("application/x-jmol", "jmz"); + sMimeTypeMap.loadEntry("application/x-kchart", "chrt"); + sMimeTypeMap.loadEntry("application/x-killustrator", "kil"); + sMimeTypeMap.loadEntry("application/x-koan", "skp"); + sMimeTypeMap.loadEntry("application/x-koan", "skd"); + sMimeTypeMap.loadEntry("application/x-koan", "skt"); + sMimeTypeMap.loadEntry("application/x-koan", "skm"); + sMimeTypeMap.loadEntry("application/x-kpresenter", "kpr"); + sMimeTypeMap.loadEntry("application/x-kpresenter", "kpt"); + sMimeTypeMap.loadEntry("application/x-kspread", "ksp"); + sMimeTypeMap.loadEntry("application/x-kword", "kwd"); + sMimeTypeMap.loadEntry("application/x-kword", "kwt"); + sMimeTypeMap.loadEntry("application/x-latex", "latex"); + sMimeTypeMap.loadEntry("application/x-lha", "lha"); + sMimeTypeMap.loadEntry("application/x-lzh", "lzh"); + sMimeTypeMap.loadEntry("application/x-lzx", "lzx"); + sMimeTypeMap.loadEntry("application/x-maker", "frm"); + sMimeTypeMap.loadEntry("application/x-maker", "maker"); + sMimeTypeMap.loadEntry("application/x-maker", "frame"); + sMimeTypeMap.loadEntry("application/x-maker", "fb"); + sMimeTypeMap.loadEntry("application/x-maker", "book"); + sMimeTypeMap.loadEntry("application/x-maker", "fbdoc"); + sMimeTypeMap.loadEntry("application/x-mif", "mif"); + sMimeTypeMap.loadEntry("application/x-ms-wmd", "wmd"); + sMimeTypeMap.loadEntry("application/x-ms-wmz", "wmz"); + sMimeTypeMap.loadEntry("application/x-msi", "msi"); + sMimeTypeMap.loadEntry("application/x-ns-proxy-autoconfig", "pac"); + sMimeTypeMap.loadEntry("application/x-nwc", "nwc"); + sMimeTypeMap.loadEntry("application/x-object", "o"); + sMimeTypeMap.loadEntry("application/x-oz-application", "oza"); + sMimeTypeMap.loadEntry("application/x-pkcs12", "p12"); + sMimeTypeMap.loadEntry("application/x-pkcs7-certreqresp", "p7r"); + sMimeTypeMap.loadEntry("application/x-pkcs7-crl", "crl"); + sMimeTypeMap.loadEntry("application/x-quicktimeplayer", "qtl"); + sMimeTypeMap.loadEntry("application/x-shar", "shar"); + sMimeTypeMap.loadEntry("application/x-stuffit", "sit"); + sMimeTypeMap.loadEntry("application/x-sv4cpio", "sv4cpio"); + sMimeTypeMap.loadEntry("application/x-sv4crc", "sv4crc"); + sMimeTypeMap.loadEntry("application/x-tar", "tar"); + sMimeTypeMap.loadEntry("application/x-texinfo", "texinfo"); + sMimeTypeMap.loadEntry("application/x-texinfo", "texi"); + sMimeTypeMap.loadEntry("application/x-troff", "t"); + sMimeTypeMap.loadEntry("application/x-troff", "roff"); + sMimeTypeMap.loadEntry("application/x-troff-man", "man"); + sMimeTypeMap.loadEntry("application/x-ustar", "ustar"); + sMimeTypeMap.loadEntry("application/x-wais-source", "src"); + sMimeTypeMap.loadEntry("application/x-wingz", "wz"); + sMimeTypeMap.loadEntry("application/x-webarchive", "webarchive"); + sMimeTypeMap.loadEntry("application/x-x509-ca-cert", "crt"); + sMimeTypeMap.loadEntry("application/x-x509-user-cert", "crt"); + sMimeTypeMap.loadEntry("application/x-xcf", "xcf"); + sMimeTypeMap.loadEntry("application/x-xfig", "fig"); + sMimeTypeMap.loadEntry("application/xhtml+xml", "xhtml"); + sMimeTypeMap.loadEntry("audio/basic", "snd"); + sMimeTypeMap.loadEntry("audio/midi", "mid"); + sMimeTypeMap.loadEntry("audio/midi", "midi"); + sMimeTypeMap.loadEntry("audio/midi", "kar"); + sMimeTypeMap.loadEntry("audio/mpeg", "mpga"); + sMimeTypeMap.loadEntry("audio/mpeg", "mpega"); + sMimeTypeMap.loadEntry("audio/mpeg", "mp2"); + sMimeTypeMap.loadEntry("audio/mpeg", "mp3"); + sMimeTypeMap.loadEntry("audio/mpeg", "m4a"); + sMimeTypeMap.loadEntry("audio/mpegurl", "m3u"); + sMimeTypeMap.loadEntry("audio/prs.sid", "sid"); + sMimeTypeMap.loadEntry("audio/x-aiff", "aif"); + sMimeTypeMap.loadEntry("audio/x-aiff", "aiff"); + sMimeTypeMap.loadEntry("audio/x-aiff", "aifc"); + sMimeTypeMap.loadEntry("audio/x-gsm", "gsm"); + sMimeTypeMap.loadEntry("audio/x-mpegurl", "m3u"); + sMimeTypeMap.loadEntry("audio/x-ms-wma", "wma"); + sMimeTypeMap.loadEntry("audio/x-ms-wax", "wax"); + sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "ra"); + sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "rm"); + sMimeTypeMap.loadEntry("audio/x-pn-realaudio", "ram"); + sMimeTypeMap.loadEntry("audio/x-realaudio", "ra"); + sMimeTypeMap.loadEntry("audio/x-scpls", "pls"); + sMimeTypeMap.loadEntry("audio/x-sd2", "sd2"); + sMimeTypeMap.loadEntry("audio/x-wav", "wav"); + sMimeTypeMap.loadEntry("image/bmp", "bmp"); + sMimeTypeMap.loadEntry("image/gif", "gif"); + sMimeTypeMap.loadEntry("image/ico", "cur"); + sMimeTypeMap.loadEntry("image/ico", "ico"); + sMimeTypeMap.loadEntry("image/ief", "ief"); + sMimeTypeMap.loadEntry("image/jpeg", "jpeg"); + sMimeTypeMap.loadEntry("image/jpeg", "jpg"); + sMimeTypeMap.loadEntry("image/jpeg", "jpe"); + sMimeTypeMap.loadEntry("image/pcx", "pcx"); + sMimeTypeMap.loadEntry("image/png", "png"); + sMimeTypeMap.loadEntry("image/svg+xml", "svg"); + sMimeTypeMap.loadEntry("image/svg+xml", "svgz"); + sMimeTypeMap.loadEntry("image/tiff", "tiff"); + sMimeTypeMap.loadEntry("image/tiff", "tif"); + sMimeTypeMap.loadEntry("image/vnd.djvu", "djvu"); + sMimeTypeMap.loadEntry("image/vnd.djvu", "djv"); + sMimeTypeMap.loadEntry("image/vnd.wap.wbmp", "wbmp"); + sMimeTypeMap.loadEntry("image/x-cmu-raster", "ras"); + sMimeTypeMap.loadEntry("image/x-coreldraw", "cdr"); + sMimeTypeMap.loadEntry("image/x-coreldrawpattern", "pat"); + sMimeTypeMap.loadEntry("image/x-coreldrawtemplate", "cdt"); + sMimeTypeMap.loadEntry("image/x-corelphotopaint", "cpt"); + sMimeTypeMap.loadEntry("image/x-icon", "ico"); + sMimeTypeMap.loadEntry("image/x-jg", "art"); + sMimeTypeMap.loadEntry("image/x-jng", "jng"); + sMimeTypeMap.loadEntry("image/x-ms-bmp", "bmp"); + sMimeTypeMap.loadEntry("image/x-photoshop", "psd"); + sMimeTypeMap.loadEntry("image/x-portable-anymap", "pnm"); + sMimeTypeMap.loadEntry("image/x-portable-bitmap", "pbm"); + sMimeTypeMap.loadEntry("image/x-portable-graymap", "pgm"); + sMimeTypeMap.loadEntry("image/x-portable-pixmap", "ppm"); + sMimeTypeMap.loadEntry("image/x-rgb", "rgb"); + sMimeTypeMap.loadEntry("image/x-xbitmap", "xbm"); + sMimeTypeMap.loadEntry("image/x-xpixmap", "xpm"); + sMimeTypeMap.loadEntry("image/x-xwindowdump", "xwd"); + sMimeTypeMap.loadEntry("model/iges", "igs"); + sMimeTypeMap.loadEntry("model/iges", "iges"); + sMimeTypeMap.loadEntry("model/mesh", "msh"); + sMimeTypeMap.loadEntry("model/mesh", "mesh"); + sMimeTypeMap.loadEntry("model/mesh", "silo"); + sMimeTypeMap.loadEntry("text/calendar", "ics"); + sMimeTypeMap.loadEntry("text/calendar", "icz"); + sMimeTypeMap.loadEntry("text/comma-separated-values", "csv"); + sMimeTypeMap.loadEntry("text/css", "css"); + sMimeTypeMap.loadEntry("text/h323", "323"); + sMimeTypeMap.loadEntry("text/iuls", "uls"); + sMimeTypeMap.loadEntry("text/mathml", "mml"); // add it first so it will be the default for ExtensionFromMimeType - sMimeTypeMap.loadEntry("text/plain", "txt", true); - sMimeTypeMap.loadEntry("text/plain", "asc", true); - sMimeTypeMap.loadEntry("text/plain", "text", true); - sMimeTypeMap.loadEntry("text/plain", "diff", true); - sMimeTypeMap.loadEntry("text/plain", "pot", true); - sMimeTypeMap.loadEntry("text/richtext", "rtx", true); - sMimeTypeMap.loadEntry("text/rtf", "rtf", true); - sMimeTypeMap.loadEntry("text/texmacs", "ts", true); - sMimeTypeMap.loadEntry("text/text", "phps", true); - sMimeTypeMap.loadEntry("text/tab-separated-values", "tsv", true); - sMimeTypeMap.loadEntry("text/x-bibtex", "bib", true); - sMimeTypeMap.loadEntry("text/x-boo", "boo", true); - sMimeTypeMap.loadEntry("text/x-c++hdr", "h++", true); - sMimeTypeMap.loadEntry("text/x-c++hdr", "hpp", true); - sMimeTypeMap.loadEntry("text/x-c++hdr", "hxx", true); - sMimeTypeMap.loadEntry("text/x-c++hdr", "hh", true); - sMimeTypeMap.loadEntry("text/x-c++src", "c++", true); - sMimeTypeMap.loadEntry("text/x-c++src", "cpp", true); - sMimeTypeMap.loadEntry("text/x-c++src", "cxx", true); - sMimeTypeMap.loadEntry("text/x-chdr", "h", true); - sMimeTypeMap.loadEntry("text/x-component", "htc", true); - sMimeTypeMap.loadEntry("text/x-csh", "csh", true); - sMimeTypeMap.loadEntry("text/x-csrc", "c", true); - sMimeTypeMap.loadEntry("text/x-dsrc", "d", true); - sMimeTypeMap.loadEntry("text/x-haskell", "hs", true); - sMimeTypeMap.loadEntry("text/x-java", "java", true); - sMimeTypeMap.loadEntry("text/x-literate-haskell", "lhs", true); - sMimeTypeMap.loadEntry("text/x-moc", "moc", true); - sMimeTypeMap.loadEntry("text/x-pascal", "p", true); - sMimeTypeMap.loadEntry("text/x-pascal", "pas", true); - sMimeTypeMap.loadEntry("text/x-pcs-gcd", "gcd", true); - sMimeTypeMap.loadEntry("text/x-setext", "etx", true); - sMimeTypeMap.loadEntry("text/x-tcl", "tcl", true); - sMimeTypeMap.loadEntry("text/x-tex", "tex", true); - sMimeTypeMap.loadEntry("text/x-tex", "ltx", true); - sMimeTypeMap.loadEntry("text/x-tex", "sty", true); - sMimeTypeMap.loadEntry("text/x-tex", "cls", true); - sMimeTypeMap.loadEntry("text/x-vcalendar", "vcs", true); - sMimeTypeMap.loadEntry("text/x-vcard", "vcf", true); - sMimeTypeMap.loadEntry("video/3gpp", "3gp", false); - sMimeTypeMap.loadEntry("video/3gpp", "3g2", false); - sMimeTypeMap.loadEntry("video/dl", "dl", false); - sMimeTypeMap.loadEntry("video/dv", "dif", false); - sMimeTypeMap.loadEntry("video/dv", "dv", false); - sMimeTypeMap.loadEntry("video/fli", "fli", false); - sMimeTypeMap.loadEntry("video/mpeg", "mpeg", false); - sMimeTypeMap.loadEntry("video/mpeg", "mpg", false); - sMimeTypeMap.loadEntry("video/mpeg", "mpe", false); - sMimeTypeMap.loadEntry("video/mp4", "mp4", false); - sMimeTypeMap.loadEntry("video/mpeg", "VOB", false); - sMimeTypeMap.loadEntry("video/quicktime", "qt", false); - sMimeTypeMap.loadEntry("video/quicktime", "mov", false); - sMimeTypeMap.loadEntry("video/vnd.mpegurl", "mxu", false); - sMimeTypeMap.loadEntry("video/x-la-asf", "lsf", false); - sMimeTypeMap.loadEntry("video/x-la-asf", "lsx", false); - sMimeTypeMap.loadEntry("video/x-mng", "mng", false); - sMimeTypeMap.loadEntry("video/x-ms-asf", "asf", false); - sMimeTypeMap.loadEntry("video/x-ms-asf", "asx", false); - sMimeTypeMap.loadEntry("video/x-ms-wm", "wm", false); - sMimeTypeMap.loadEntry("video/x-ms-wmv", "wmv", false); - sMimeTypeMap.loadEntry("video/x-ms-wmx", "wmx", false); - sMimeTypeMap.loadEntry("video/x-ms-wvx", "wvx", false); - sMimeTypeMap.loadEntry("video/x-msvideo", "avi", false); - sMimeTypeMap.loadEntry("video/x-sgi-movie", "movie", false); - sMimeTypeMap.loadEntry("x-conference/x-cooltalk", "ice", false); - sMimeTypeMap.loadEntry("x-epoc/x-sisx-app", "sisx", false); + sMimeTypeMap.loadEntry("text/plain", "txt"); + sMimeTypeMap.loadEntry("text/plain", "asc"); + sMimeTypeMap.loadEntry("text/plain", "text"); + sMimeTypeMap.loadEntry("text/plain", "diff"); + sMimeTypeMap.loadEntry("text/plain", "pot"); + sMimeTypeMap.loadEntry("text/richtext", "rtx"); + sMimeTypeMap.loadEntry("text/rtf", "rtf"); + sMimeTypeMap.loadEntry("text/texmacs", "ts"); + sMimeTypeMap.loadEntry("text/text", "phps"); + sMimeTypeMap.loadEntry("text/tab-separated-values", "tsv"); + sMimeTypeMap.loadEntry("text/x-bibtex", "bib"); + sMimeTypeMap.loadEntry("text/x-boo", "boo"); + sMimeTypeMap.loadEntry("text/x-c++hdr", "h++"); + sMimeTypeMap.loadEntry("text/x-c++hdr", "hpp"); + sMimeTypeMap.loadEntry("text/x-c++hdr", "hxx"); + sMimeTypeMap.loadEntry("text/x-c++hdr", "hh"); + sMimeTypeMap.loadEntry("text/x-c++src", "c++"); + sMimeTypeMap.loadEntry("text/x-c++src", "cpp"); + sMimeTypeMap.loadEntry("text/x-c++src", "cxx"); + sMimeTypeMap.loadEntry("text/x-chdr", "h"); + sMimeTypeMap.loadEntry("text/x-component", "htc"); + sMimeTypeMap.loadEntry("text/x-csh", "csh"); + sMimeTypeMap.loadEntry("text/x-csrc", "c"); + sMimeTypeMap.loadEntry("text/x-dsrc", "d"); + sMimeTypeMap.loadEntry("text/x-haskell", "hs"); + sMimeTypeMap.loadEntry("text/x-java", "java"); + sMimeTypeMap.loadEntry("text/x-literate-haskell", "lhs"); + sMimeTypeMap.loadEntry("text/x-moc", "moc"); + sMimeTypeMap.loadEntry("text/x-pascal", "p"); + sMimeTypeMap.loadEntry("text/x-pascal", "pas"); + sMimeTypeMap.loadEntry("text/x-pcs-gcd", "gcd"); + sMimeTypeMap.loadEntry("text/x-setext", "etx"); + sMimeTypeMap.loadEntry("text/x-tcl", "tcl"); + sMimeTypeMap.loadEntry("text/x-tex", "tex"); + sMimeTypeMap.loadEntry("text/x-tex", "ltx"); + sMimeTypeMap.loadEntry("text/x-tex", "sty"); + sMimeTypeMap.loadEntry("text/x-tex", "cls"); + sMimeTypeMap.loadEntry("text/x-vcalendar", "vcs"); + sMimeTypeMap.loadEntry("text/x-vcard", "vcf"); + sMimeTypeMap.loadEntry("video/3gpp", "3gp"); + sMimeTypeMap.loadEntry("video/3gpp", "3g2"); + sMimeTypeMap.loadEntry("video/dl", "dl"); + sMimeTypeMap.loadEntry("video/dv", "dif"); + sMimeTypeMap.loadEntry("video/dv", "dv"); + sMimeTypeMap.loadEntry("video/fli", "fli"); + sMimeTypeMap.loadEntry("video/mpeg", "mpeg"); + sMimeTypeMap.loadEntry("video/mpeg", "mpg"); + sMimeTypeMap.loadEntry("video/mpeg", "mpe"); + sMimeTypeMap.loadEntry("video/mp4", "mp4"); + sMimeTypeMap.loadEntry("video/mpeg", "VOB"); + sMimeTypeMap.loadEntry("video/quicktime", "qt"); + sMimeTypeMap.loadEntry("video/quicktime", "mov"); + sMimeTypeMap.loadEntry("video/vnd.mpegurl", "mxu"); + sMimeTypeMap.loadEntry("video/x-la-asf", "lsf"); + sMimeTypeMap.loadEntry("video/x-la-asf", "lsx"); + sMimeTypeMap.loadEntry("video/x-mng", "mng"); + sMimeTypeMap.loadEntry("video/x-ms-asf", "asf"); + sMimeTypeMap.loadEntry("video/x-ms-asf", "asx"); + sMimeTypeMap.loadEntry("video/x-ms-wm", "wm"); + sMimeTypeMap.loadEntry("video/x-ms-wmv", "wmv"); + sMimeTypeMap.loadEntry("video/x-ms-wmx", "wmx"); + sMimeTypeMap.loadEntry("video/x-ms-wvx", "wvx"); + sMimeTypeMap.loadEntry("video/x-msvideo", "avi"); + sMimeTypeMap.loadEntry("video/x-sgi-movie", "movie"); + sMimeTypeMap.loadEntry("x-conference/x-cooltalk", "ice"); + sMimeTypeMap.loadEntry("x-epoc/x-sisx-app", "sisx"); } return sMimeTypeMap; diff --git a/core/java/android/webkit/MockGeolocation.java b/core/java/android/webkit/MockGeolocation.java new file mode 100644 index 0000000..028cb19 --- /dev/null +++ b/core/java/android/webkit/MockGeolocation.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2009 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; + +/** + * This class is simply a container for the methods used to configure WebKit's + * mock Geolocation service for use in LayoutTests. + * @hide Pending API council review. + */ +public final class MockGeolocation { + + // Global instance of a MockGeolocation + private static MockGeolocation sMockGeolocation; + + /** + * Set the position for the mock Geolocation service. + */ + public void setPosition(double latitude, double longitude, double accuracy) { + // This should only ever be called on the WebKit thread. + nativeSetPosition(latitude, longitude, accuracy); + } + + /** + * Set the error for the mock Geolocation service. + */ + public void setError(int code, String message) { + // This should only ever be called on the WebKit thread. + nativeSetError(code, message); + } + + /** + * Get the global instance of MockGeolocation. + * @return The global MockGeolocation instance. + */ + public static MockGeolocation getInstance() { + if (sMockGeolocation == null) { + sMockGeolocation = new MockGeolocation(); + } + return sMockGeolocation; + } + + // Native functions + private static native void nativeSetPosition(double latitude, double longitude, double accuracy); + private static native void nativeSetError(int code, String message); +} diff --git a/core/java/android/webkit/Network.java b/core/java/android/webkit/Network.java index c9b80ce..0b9e596 100644 --- a/core/java/android/webkit/Network.java +++ b/core/java/android/webkit/Network.java @@ -132,11 +132,11 @@ class Network { * XXX: Must be created in the same thread as WebCore!!!!! */ private Network(Context context) { - if (WebView.DEBUG) { + if (DebugFlags.NETWORK) { Assert.assertTrue(Thread.currentThread(). getName().equals(WebViewCore.THREAD_NAME)); } - mSslErrorHandler = new SslErrorHandler(this); + mSslErrorHandler = new SslErrorHandler(); mHttpAuthHandler = new HttpAuthHandler(this); mRequestQueue = new RequestQueue(context); @@ -149,14 +149,12 @@ class Network { * @param headers The http headers. * @param postData The body of the request. * @param loader A LoadListener for receiving the results of the request. - * @param isHighPriority True if this is high priority request. * @return True if the request was successfully queued. */ public boolean requestURL(String method, Map<String, String> headers, byte [] postData, - LoadListener loader, - boolean isHighPriority) { + LoadListener loader) { String url = loader.url(); @@ -188,7 +186,7 @@ class Network { RequestHandle handle = q.queueRequest( url, loader.getWebAddress(), method, headers, loader, - bodyProvider, bodyLength, isHighPriority); + bodyProvider, bodyLength); loader.attachRequestHandle(handle); if (loader.isSynchronous()) { @@ -232,7 +230,7 @@ class Network { * connecting through the proxy. */ public synchronized void setProxyUsername(String proxyUsername) { - if (WebView.DEBUG) { + if (DebugFlags.NETWORK) { Assert.assertTrue(isValidProxySet()); } @@ -252,7 +250,7 @@ class Network { * connecting through the proxy. */ public synchronized void setProxyPassword(String proxyPassword) { - if (WebView.DEBUG) { + if (DebugFlags.NETWORK) { Assert.assertTrue(isValidProxySet()); } @@ -266,7 +264,7 @@ class Network { * @return True iff succeeds. */ public boolean saveState(Bundle outState) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.NETWORK) { Log.v(LOGTAG, "Network.saveState()"); } @@ -280,7 +278,7 @@ class Network { * @return True iff succeeds. */ public boolean restoreState(Bundle inState) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.NETWORK) { Log.v(LOGTAG, "Network.restoreState()"); } @@ -300,7 +298,7 @@ class Network { * @param loader The loader that resulted in SSL errors. */ public void handleSslErrorRequest(LoadListener loader) { - if (WebView.DEBUG) Assert.assertNotNull(loader); + if (DebugFlags.NETWORK) Assert.assertNotNull(loader); if (loader != null) { mSslErrorHandler.handleSslErrorRequest(loader); } @@ -313,7 +311,7 @@ class Network { * authentication request. */ public void handleAuthRequest(LoadListener loader) { - if (WebView.DEBUG) Assert.assertNotNull(loader); + if (DebugFlags.NETWORK) Assert.assertNotNull(loader); if (loader != null) { mHttpAuthHandler.handleAuthRequest(loader); } diff --git a/core/java/android/webkit/Plugin.java b/core/java/android/webkit/Plugin.java index f83da99..302bea2 100644 --- a/core/java/android/webkit/Plugin.java +++ b/core/java/android/webkit/Plugin.java @@ -26,7 +26,11 @@ import android.webkit.WebView; /** * Represents a plugin (Java equivalent of the PluginPackageAndroid * C++ class in libs/WebKitLib/WebKit/WebCore/plugins/android/) + * + * @deprecated This interface was inteded to be used by Gears. Since Gears was + * deprecated, so is this class. */ +@Deprecated public class Plugin { public interface PreferencesClickHandler { public void handleClickEvent(Context context); @@ -38,6 +42,10 @@ public class Plugin { private String mDescription; private PreferencesClickHandler mHandler; + /** + * @deprecated + */ + @Deprecated public Plugin(String name, String path, String fileName, @@ -49,49 +57,92 @@ public class Plugin { mHandler = new DefaultClickHandler(); } + /** + * @deprecated + */ + @Deprecated public String toString() { return mName; } + /** + * @deprecated + */ + @Deprecated public String getName() { return mName; } + /** + * @deprecated + */ + @Deprecated public String getPath() { return mPath; } + /** + * @deprecated + */ + @Deprecated public String getFileName() { return mFileName; } + /** + * @deprecated + */ + @Deprecated public String getDescription() { return mDescription; } + /** + * @deprecated + */ + @Deprecated public void setName(String name) { mName = name; } + /** + * @deprecated + */ + @Deprecated public void setPath(String path) { mPath = path; } + /** + * @deprecated + */ + @Deprecated public void setFileName(String fileName) { mFileName = fileName; } + /** + * @deprecated + */ + @Deprecated public void setDescription(String description) { mDescription = description; } + /** + * @deprecated + */ + @Deprecated public void setClickHandler(PreferencesClickHandler handler) { mHandler = handler; } /** * Invokes the click handler for this plugin. + * + * @deprecated */ + @Deprecated public void dispatchClickEvent(Context context) { if (mHandler != null) { mHandler.handleClickEvent(context); @@ -100,11 +151,14 @@ public class Plugin { /** * Default click handler. The plugins should implement their own. + * + * @deprecated */ + @Deprecated private class DefaultClickHandler implements PreferencesClickHandler, DialogInterface.OnClickListener { private AlertDialog mDialog; - + @Deprecated public void handleClickEvent(Context context) { // Show a simple popup dialog containing the description // string of the plugin. @@ -117,7 +171,10 @@ public class Plugin { .show(); } } - + /** + * @deprecated + */ + @Deprecated public void onClick(DialogInterface dialog, int which) { mDialog.dismiss(); mDialog = null; diff --git a/core/java/android/webkit/PluginContentLoader.java b/core/java/android/webkit/PluginContentLoader.java deleted file mode 100644 index 2069599..0000000 --- a/core/java/android/webkit/PluginContentLoader.java +++ /dev/null @@ -1,96 +0,0 @@ -/* - * Copyright (C) 2009 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.net.http.Headers; - -import java.io.InputStream; -import java.util.*; - -import org.apache.http.util.CharArrayBuffer; - -/** - * This class is a concrete implementation of StreamLoader that uses a - * PluginData object as the source for the stream. - */ -class PluginContentLoader extends StreamLoader { - - private PluginData mData; // Content source - - /** - * Constructs a PluginDataLoader for use when loading content from - * a plugin. - * - * @param loadListener LoadListener to pass the content to - * @param data PluginData used as the source for the content. - */ - PluginContentLoader(LoadListener loadListener, PluginData data) { - super(loadListener); - mData = data; - } - - @Override - protected boolean setupStreamAndSendStatus() { - mDataStream = mData.getInputStream(); - mContentLength = mData.getContentLength(); - mHandler.status(1, 1, mData.getStatusCode(), "OK"); - return true; - } - - @Override - protected void buildHeaders(Headers headers) { - // Crate a CharArrayBuffer with an arbitrary initial capacity. - CharArrayBuffer buffer = new CharArrayBuffer(100); - Iterator<Map.Entry<String, String[]>> responseHeadersIt = - mData.getHeaders().entrySet().iterator(); - while (responseHeadersIt.hasNext()) { - Map.Entry<String, String[]> entry = responseHeadersIt.next(); - // Headers.parseHeader() expects lowercase keys, so keys - // such as "Accept-Ranges" will fail to parse. - // - // UrlInterceptHandler instances supply a mapping of - // lowercase key to [ unmodified key, value ], so for - // Headers.parseHeader() to succeed, we need to construct - // a string using the key (i.e. entry.getKey()) and the - // element denoting the header value in the - // [ unmodified key, value ] pair (i.e. entry.getValue()[1). - // - // The reason why UrlInterceptHandler instances supply such a - // mapping in the first place is historical. Early versions of - // the Gears plugin used java.net.HttpURLConnection, which always - // returned headers names as capitalized strings. When these were - // fed back into webkit, they failed to parse. - // - // Mewanwhile, Gears was modified to use Apache HTTP library - // instead, so this design is now obsolete. Changing it however, - // would require changes to the Gears C++ codebase and QA-ing and - // submitting a new binary to the Android tree. Given the - // timelines for the next Android release, we will not do this - // for now. - // - // TODO: fix C++ Gears to remove the need for this - // design. - String keyValue = entry.getKey() + ": " + entry.getValue()[1]; - buffer.ensureCapacity(keyValue.length()); - buffer.append(keyValue); - // Parse it into the header container. - headers.parseHeader(buffer); - // Clear the buffer - buffer.clear(); - } - } -} diff --git a/core/java/android/webkit/PluginData.java b/core/java/android/webkit/PluginData.java index 2b539fe..d9b196a 100644 --- a/core/java/android/webkit/PluginData.java +++ b/core/java/android/webkit/PluginData.java @@ -28,7 +28,10 @@ import java.util.Map; * status code. The PluginData class is the container for all these * parts. * + * @deprecated This class was inteded to be used by Gears. Since Gears was + * deprecated, so is this class. */ +@Deprecated public final class PluginData { /** * The content stream. @@ -47,10 +50,6 @@ public final class PluginData { private Map<String, String[]> mHeaders; /** - * The index of the header value in the above mapping. - */ - private int mHeaderValueIndex; - /** * The associated HTTP response code. */ private int mStatusCode; @@ -63,7 +62,10 @@ public final class PluginData { * @param headers The response headers. Map of * lowercase header name to [ unmodified header name, header value] * @param length The HTTP response status code. + * + * @deprecated */ + @Deprecated public PluginData( InputStream stream, long length, @@ -79,7 +81,10 @@ public final class PluginData { * Returns the input stream that contains the plugin content. * * @return An InputStream instance with the plugin content. + * + * @deprecated */ + @Deprecated public InputStream getInputStream() { return mStream; } @@ -88,7 +93,10 @@ public final class PluginData { * Returns the length of the plugin content. * * @return the length of the plugin content. + * + * @deprecated */ + @Deprecated public long getContentLength() { return mContentLength; } @@ -100,7 +108,10 @@ public final class PluginData { * @return A Map<String, String[]> containing all headers. The * mapping is 'lowercase header name' to ['unmodified header * name', header value]. + * + * @deprecated */ + @Deprecated public Map<String, String[]> getHeaders() { return mHeaders; } @@ -109,7 +120,10 @@ public final class PluginData { * Returns the HTTP status code for the response. * * @return The HTTP statue code, e.g 200. + * + * @deprecated */ + @Deprecated public int getStatusCode() { return mStatusCode; } diff --git a/core/java/android/webkit/PluginList.java b/core/java/android/webkit/PluginList.java index a9d3d8c..5b65b9a 100644 --- a/core/java/android/webkit/PluginList.java +++ b/core/java/android/webkit/PluginList.java @@ -24,27 +24,40 @@ import java.util.List; * A simple list of initialized plugins. This list gets * populated when the plugins are initialized (at * browser startup, at the moment). + * + * @deprecated This interface was inteded to be used by Gears. Since Gears was + * deprecated, so is this class. */ +@Deprecated public class PluginList { private ArrayList<Plugin> mPlugins; /** * Public constructor. Initializes the list of plugins. + * + * @deprecated */ + @Deprecated public PluginList() { mPlugins = new ArrayList<Plugin>(); } /** * Returns the list of plugins as a java.util.List. + * + * @deprecated */ + @Deprecated public synchronized List getList() { return mPlugins; } /** * Adds a plugin to the list. + * + * @deprecated */ + @Deprecated public synchronized void addPlugin(Plugin plugin) { if (!mPlugins.contains(plugin)) { mPlugins.add(plugin); @@ -53,7 +66,10 @@ public class PluginList { /** * Removes a plugin from the list. + * + * @deprecated */ + @Deprecated public synchronized void removePlugin(Plugin plugin) { int location = mPlugins.indexOf(plugin); if (location != -1) { @@ -63,14 +79,20 @@ public class PluginList { /** * Clears the plugin list. + * + * @deprecated */ + @Deprecated public synchronized void clear() { mPlugins.clear(); } /** * Dispatches the click event to the appropriate plugin. + * + * @deprecated */ + @Deprecated public synchronized void pluginClicked(Context context, int position) { try { Plugin plugin = mPlugins.get(position); diff --git a/core/java/android/webkit/PluginManager.java b/core/java/android/webkit/PluginManager.java new file mode 100644 index 0000000..32eea5f --- /dev/null +++ b/core/java/android/webkit/PluginManager.java @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2009 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 java.util.ArrayList; +import java.util.List; + +import android.annotation.SdkConstant; +import android.annotation.SdkConstant.SdkConstantType; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.content.pm.ServiceInfo; +import android.content.pm.Signature; +import android.content.pm.PackageManager.NameNotFoundException; +import android.util.Log; + +/** + * Class for managing the relationship between the {@link WebView} and installed + * plugins in the system. You can find this class through + * {@link PluginManager#getInstance}. + * + * @hide pending API solidification + */ +public class PluginManager { + + /** + * Service Action: A plugin wishes to be loaded in the WebView must provide + * {@link android.content.IntentFilter IntentFilter} that accepts this + * action in their AndroidManifest.xml. + * <p> + * TODO: we may change this to a new PLUGIN_ACTION if this is going to be + * public. + */ + @SdkConstant(SdkConstantType.SERVICE_ACTION) + public static final String PLUGIN_ACTION = "android.webkit.PLUGIN"; + + /** + * A plugin wishes to be loaded in the WebView must provide this permission + * in their AndroidManifest.xml. + */ + public static final String PLUGIN_PERMISSION = "android.webkit.permission.PLUGIN"; + + private static final String LOGTAG = "webkit"; + + private static PluginManager mInstance = null; + + private final Context mContext; + + private PluginManager(Context context) { + mContext = context; + } + + public static synchronized PluginManager getInstance(Context context) { + if (mInstance == null) { + if (context == null) { + throw new IllegalStateException( + "First call to PluginManager need a valid context."); + } + mInstance = new PluginManager(context); + } + return mInstance; + } + + /** + * Signal the WebCore thread to refresh its list of plugins. Use this if the + * directory contents of one of the plugin directories has been modified and + * needs its changes reflecting. May cause plugin load and/or unload. + * + * @param reloadOpenPages Set to true to reload all open pages. + */ + public void refreshPlugins(boolean reloadOpenPages) { + BrowserFrame.sJavaBridge.obtainMessage( + JWebCoreJavaBridge.REFRESH_PLUGINS, reloadOpenPages) + .sendToTarget(); + } + + String[] getPluginDirectories() { + ArrayList<String> directories = new ArrayList<String>(); + PackageManager pm = mContext.getPackageManager(); + List<ResolveInfo> plugins = pm.queryIntentServices(new Intent( + PLUGIN_ACTION), PackageManager.GET_SERVICES); + for (ResolveInfo info : plugins) { + ServiceInfo serviceInfo = info.serviceInfo; + if (serviceInfo == null) { + Log.w(LOGTAG, "Ignore bad plugin"); + continue; + } + PackageInfo pkgInfo; + try { + pkgInfo = pm.getPackageInfo(serviceInfo.packageName, + PackageManager.GET_PERMISSIONS + | PackageManager.GET_SIGNATURES); + } catch (NameNotFoundException e) { + Log.w(LOGTAG, "Cant find plugin: " + serviceInfo.packageName); + continue; + } + if (pkgInfo == null) { + continue; + } + String directory = pkgInfo.applicationInfo.dataDir + "/lib"; + if (directories.contains(directory)) { + continue; + } + String permissions[] = pkgInfo.requestedPermissions; + if (permissions == null) { + continue; + } + boolean permissionOk = false; + for (String permit : permissions) { + if (PLUGIN_PERMISSION.equals(permit)) { + permissionOk = true; + break; + } + } + if (!permissionOk) { + continue; + } + Signature signatures[] = pkgInfo.signatures; + if (signatures == null) { + continue; + } + boolean signatureMatch = false; + for (Signature signature : signatures) { + // TODO: check signature against Google provided one + signatureMatch = true; + break; + } + if (!signatureMatch) { + continue; + } + directories.add(directory); + } + + return directories.toArray(new String[directories.size()]); + } + + String getPluginSharedDataDirectory() { + return mContext.getDir("plugins", 0).getPath(); + } +} diff --git a/core/java/android/webkit/SslErrorHandler.java b/core/java/android/webkit/SslErrorHandler.java index 5f84bbe..5011244 100644 --- a/core/java/android/webkit/SslErrorHandler.java +++ b/core/java/android/webkit/SslErrorHandler.java @@ -42,11 +42,6 @@ public class SslErrorHandler extends Handler { private static final String LOGTAG = "network"; /** - * Network. - */ - private Network mNetwork; - - /** * Queue of loaders that experience SSL-related problems. */ private LinkedList<LoadListener> mLoaderQueue; @@ -57,7 +52,7 @@ public class SslErrorHandler extends Handler { private Bundle mSslPrefTable; // Message id for handling the response - private final int HANDLE_RESPONSE = 100; + private static final int HANDLE_RESPONSE = 100; @Override public void handleMessage(Message msg) { @@ -72,9 +67,7 @@ public class SslErrorHandler extends Handler { /** * Creates a new error handler with an empty loader queue. */ - /* package */ SslErrorHandler(Network network) { - mNetwork = network; - + /* package */ SslErrorHandler() { mLoaderQueue = new LinkedList<LoadListener>(); mSslPrefTable = new Bundle(); } @@ -120,7 +113,7 @@ public class SslErrorHandler extends Handler { * Handles SSL error(s) on the way up to the user. */ /* package */ synchronized void handleSslErrorRequest(LoadListener loader) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.SSL_ERROR_HANDLER) { Log.v(LOGTAG, "SslErrorHandler.handleSslErrorRequest(): " + "url=" + loader.url()); } @@ -157,14 +150,14 @@ public class SslErrorHandler extends Handler { SslError error = loader.sslError(); - if (WebView.DEBUG) { + if (DebugFlags.SSL_ERROR_HANDLER) { Assert.assertNotNull(error); } int primary = error.getPrimaryError(); String host = loader.host(); - if (WebView.DEBUG) { + if (DebugFlags.SSL_ERROR_HANDLER) { Assert.assertTrue(host != null && primary != 0); } @@ -205,11 +198,11 @@ public class SslErrorHandler extends Handler { */ /* package */ synchronized void handleSslErrorResponse(boolean proceed) { LoadListener loader = mLoaderQueue.poll(); - if (WebView.DEBUG) { + if (DebugFlags.SSL_ERROR_HANDLER) { Assert.assertNotNull(loader); } - if (WebView.LOGV_ENABLED) { + if (DebugFlags.SSL_ERROR_HANDLER) { Log.v(LOGTAG, "SslErrorHandler.handleSslErrorResponse():" + " proceed: " + proceed + " url:" + loader.url()); @@ -221,13 +214,13 @@ public class SslErrorHandler extends Handler { int primary = loader.sslError().getPrimaryError(); String host = loader.host(); - if (WebView.DEBUG) { + if (DebugFlags.SSL_ERROR_HANDLER) { Assert.assertTrue(host != null && primary != 0); } boolean hasKey = mSslPrefTable.containsKey(host); if (!hasKey || primary > mSslPrefTable.getInt(host)) { - mSslPrefTable.putInt(host, new Integer(primary)); + mSslPrefTable.putInt(host, primary); } } loader.handleSslErrorResponse(proceed); diff --git a/core/java/android/webkit/StreamLoader.java b/core/java/android/webkit/StreamLoader.java index 705157c..eab3350 100644 --- a/core/java/android/webkit/StreamLoader.java +++ b/core/java/android/webkit/StreamLoader.java @@ -102,7 +102,7 @@ abstract class StreamLoader extends Handler { // to pass data to the loader mData = new byte[8192]; sendHeaders(); - while (!sendData()); + while (!sendData() && !mHandler.cancelled()); closeStreamAndSendEndData(); mHandler.loadSynchronousMessages(); } @@ -113,9 +113,13 @@ abstract class StreamLoader extends Handler { * @see android.os.Handler#handleMessage(android.os.Message) */ public void handleMessage(Message msg) { - if (WebView.DEBUG && mHandler.isSynchronous()) { + if (DebugFlags.STREAM_LOADER && mHandler.isSynchronous()) { throw new AssertionError(); } + if (mHandler.cancelled()) { + closeStreamAndSendEndData(); + return; + } switch(msg.what) { case MSG_STATUS: if (setupStreamAndSendStatus()) { diff --git a/core/java/android/webkit/URLUtil.java b/core/java/android/webkit/URLUtil.java index 9889fe9..5ed42e9 100644 --- a/core/java/android/webkit/URLUtil.java +++ b/core/java/android/webkit/URLUtil.java @@ -61,7 +61,7 @@ public final class URLUtil { webAddress = new WebAddress(inUrl); } catch (ParseException ex) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.URL_UTIL) { Log.v(LOGTAG, "smartUrlFilter: failed to parse url = " + inUrl); } return retVal; @@ -126,6 +126,32 @@ public final class URLUtil { return retData; } + /** + * @return True iff the url is correctly URL encoded + */ + static boolean verifyURLEncoding(String url) { + int count = url.length(); + if (count == 0) { + return false; + } + + int index = url.indexOf('%'); + while (index >= 0 && index < count) { + if (index < count - 2) { + try { + parseHex((byte) url.charAt(++index)); + parseHex((byte) url.charAt(++index)); + } catch (IllegalArgumentException e) { + return false; + } + } else { + return false; + } + index = url.indexOf('%', index + 1); + } + return true; + } + private static int parseHex(byte b) { if (b >= '0' && b <= '9') return (b - '0'); if (b >= 'A' && b <= 'F') return (b - 'A' + 10); diff --git a/core/java/android/webkit/UrlInterceptHandler.java b/core/java/android/webkit/UrlInterceptHandler.java index 9216413..78bab04 100644 --- a/core/java/android/webkit/UrlInterceptHandler.java +++ b/core/java/android/webkit/UrlInterceptHandler.java @@ -20,6 +20,11 @@ import android.webkit.CacheManager.CacheResult; import android.webkit.PluginData; import java.util.Map; +/** + * @deprecated This interface was inteded to be used by Gears. Since Gears was + * deprecated, so is this class. + */ +@Deprecated public interface UrlInterceptHandler { /** @@ -30,8 +35,8 @@ public interface UrlInterceptHandler { * @param url URL string. * @param headers The headers associated with the request. May be null. * @return The CacheResult containing the surrogate response. - * @Deprecated Use PluginData getPluginData(String url, - * Map<String, String> headers); instead + * + * @deprecated Do not use, this interface is deprecated. */ @Deprecated public CacheResult service(String url, Map<String, String> headers); @@ -44,6 +49,9 @@ public interface UrlInterceptHandler { * @param url URL string. * @param headers The headers associated with the request. May be null. * @return The PluginData containing the surrogate response. + * + * @deprecated Do not use, this interface is deprecated. */ + @Deprecated public PluginData getPluginData(String url, Map<String, String> headers); } diff --git a/core/java/android/webkit/UrlInterceptRegistry.java b/core/java/android/webkit/UrlInterceptRegistry.java index 6051f29..6e2a482 100644 --- a/core/java/android/webkit/UrlInterceptRegistry.java +++ b/core/java/android/webkit/UrlInterceptRegistry.java @@ -24,6 +24,11 @@ import java.util.Iterator; import java.util.LinkedList; import java.util.Map; +/** + * @deprecated This class was inteded to be used by Gears. Since Gears was + * deprecated, so is this class. + */ +@Deprecated public final class UrlInterceptRegistry { private final static String LOGTAG = "intercept"; @@ -42,7 +47,10 @@ public final class UrlInterceptRegistry { * set the flag to control whether url intercept is enabled or disabled * * @param disabled true to disable the cache + * + * @deprecated */ + @Deprecated public static synchronized void setUrlInterceptDisabled(boolean disabled) { mDisabled = disabled; } @@ -51,7 +59,10 @@ public final class UrlInterceptRegistry { * get the state of the url intercept, enabled or disabled * * @return return if it is disabled + * + * @deprecated */ + @Deprecated public static synchronized boolean urlInterceptDisabled() { return mDisabled; } @@ -62,7 +73,10 @@ public final class UrlInterceptRegistry { * * @param handler The new UrlInterceptHandler object * @return true if the handler was not previously registered. + * + * @deprecated */ + @Deprecated public static synchronized boolean registerHandler( UrlInterceptHandler handler) { if (!getHandlers().contains(handler)) { @@ -78,7 +92,10 @@ public final class UrlInterceptRegistry { * * @param handler A previously registered UrlInterceptHandler. * @return true if the handler was found and removed from the list. + * + * @deprecated */ + @Deprecated public static synchronized boolean unregisterHandler( UrlInterceptHandler handler) { return getHandlers().remove(handler); @@ -89,8 +106,8 @@ public final class UrlInterceptRegistry { * UrlInterceptHandler interested, or null if none are. * * @return A CacheResult containing surrogate content. - * @Deprecated Use PluginData getPluginData( String url, - * Map<String, String> headers) instead. + * + * @deprecated */ @Deprecated public static synchronized CacheResult getSurrogate( @@ -115,7 +132,10 @@ public final class UrlInterceptRegistry { * intercepts are disabled. * * @return A PluginData instance containing surrogate content. + * + * @deprecated */ + @Deprecated public static synchronized PluginData getPluginData( String url, Map<String, String> headers) { if (urlInterceptDisabled()) { diff --git a/core/java/android/webkit/ViewManager.java b/core/java/android/webkit/ViewManager.java new file mode 100644 index 0000000..af33b4f --- /dev/null +++ b/core/java/android/webkit/ViewManager.java @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2009 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.view.View; +import android.widget.AbsoluteLayout; + +import java.util.ArrayList; + +class ViewManager { + private final WebView mWebView; + private final ArrayList<ChildView> mChildren = new ArrayList<ChildView>(); + private boolean mHidden; + + class ChildView { + int x; + int y; + int width; + int height; + View mView; // generic view to show + + ChildView() { + } + + void setBounds(int x, int y, int width, int height) { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + void attachView(int x, int y, int width, int height) { + if (mView == null) { + return; + } + setBounds(x, y, width, height); + final AbsoluteLayout.LayoutParams lp = + new AbsoluteLayout.LayoutParams(ctv(width), ctv(height), + ctv(x), ctv(y)); + mWebView.mPrivateHandler.post(new Runnable() { + public void run() { + // This method may be called multiple times. If the view is + // already attached, just set the new LayoutParams, + // otherwise attach the view and add it to the list of + // children. + if (mView.getParent() != null) { + mView.setLayoutParams(lp); + } else { + attachViewOnUIThread(lp); + } + } + }); + } + + void attachViewOnUIThread(AbsoluteLayout.LayoutParams lp) { + mWebView.addView(mView, lp); + mChildren.add(this); + } + + void removeView() { + if (mView == null) { + return; + } + mWebView.mPrivateHandler.post(new Runnable() { + public void run() { + removeViewOnUIThread(); + } + }); + } + + void removeViewOnUIThread() { + mWebView.removeView(mView); + mChildren.remove(this); + } + } + + ViewManager(WebView w) { + mWebView = w; + } + + ChildView createView() { + return new ChildView(); + } + + // contentToView shorthand. + private int ctv(int val) { + return mWebView.contentToView(val); + } + + void scaleAll() { + for (ChildView v : mChildren) { + View view = v.mView; + AbsoluteLayout.LayoutParams lp = + (AbsoluteLayout.LayoutParams) view.getLayoutParams(); + lp.width = ctv(v.width); + lp.height = ctv(v.height); + lp.x = ctv(v.x); + lp.y = ctv(v.y); + view.setLayoutParams(lp); + } + } + + void hideAll() { + if (mHidden) { + return; + } + for (ChildView v : mChildren) { + v.mView.setVisibility(View.GONE); + } + mHidden = true; + } + + void showAll() { + if (!mHidden) { + return; + } + for (ChildView v : mChildren) { + v.mView.setVisibility(View.VISIBLE); + } + mHidden = false; + } +} diff --git a/core/java/android/webkit/WebBackForwardList.java b/core/java/android/webkit/WebBackForwardList.java index ffd6a11..62a5531 100644 --- a/core/java/android/webkit/WebBackForwardList.java +++ b/core/java/android/webkit/WebBackForwardList.java @@ -137,7 +137,7 @@ public class WebBackForwardList implements Cloneable, Serializable { // when removing the first item, we can assert that the index is 0. // This lets us change the current index without having to query the // native BackForwardList. - if (WebView.DEBUG && (index != 0)) { + if (DebugFlags.WEB_BACK_FORWARD_LIST && (index != 0)) { throw new AssertionError(); } final WebHistoryItem h = mArray.remove(index); diff --git a/core/java/android/webkit/WebChromeClient.java b/core/java/android/webkit/WebChromeClient.java index 9d9763c..e1c8d4d 100644 --- a/core/java/android/webkit/WebChromeClient.java +++ b/core/java/android/webkit/WebChromeClient.java @@ -18,10 +18,20 @@ package android.webkit; import android.graphics.Bitmap; import android.os.Message; +import android.view.View; public class WebChromeClient { /** + * Tell the host application that the WebView has changed viewing modes. + * @param toZoomedOut If true, the WebView has zoomed out so that the page + * fits the screen. If false, it is zoomed to the setting + * specified by the user. + * @hide + */ + public void onChangeViewingMode(boolean toZoomedOut) {} + + /** * Tell the host application the current progress of loading a page. * @param view The WebView that initiated the callback. * @param newProgress Current page loading progress, represented by @@ -44,6 +54,47 @@ public class WebChromeClient { public void onReceivedIcon(WebView view, Bitmap icon) {} /** + * Notify the host application of the url for an apple-touch-icon. + * @param view The WebView that initiated the callback. + * @param url The icon url. + * @hide pending council approval + */ + public void onReceivedTouchIconUrl(WebView view, String url) {} + + /** + * A callback interface used by the host application to notify + * the current page that its custom view has been dismissed. + * + * @hide pending council approval + */ + public interface CustomViewCallback { + /** + * Invoked when the host application dismisses the + * custom view. + */ + public void onCustomViewHidden(); + } + + /** + * Notify the host application that the current page would + * like to show a custom View. + * @param view is the View object to be shown. + * @param callback is the callback to be invoked if and when the view + * is dismissed. + * + * @hide pending council approval + */ + public void onShowCustomView(View view, CustomViewCallback callback) {}; + + /** + * Notify the host application that the current page would + * like to hide its custom view. + * + * @hide pending council approval + */ + public void onHideCustomView() {} + + /** * Request the host application to create a new Webview. The host * application should handle placement of the new WebView in the view * system. The default behavior returns null. @@ -158,6 +209,54 @@ public class WebChromeClient { return false; } + /** + * Tell the client that the database quota for the origin has been exceeded. + * @param url The URL that triggered the notification + * @param databaseIdentifier The identifier of the database that caused the + * quota overflow. + * @param currentQuota The current quota for the origin. + * @param totalUsedQuota is the sum of all origins' quota. + * @param quotaUpdater A callback to inform the WebCore thread that a new + * quota is available. This callback must always be executed at some + * point to ensure that the sleeping WebCore thread is woken up. + */ + public void onExceededDatabaseQuota(String url, String databaseIdentifier, + long currentQuota, long totalUsedQuota, + WebStorage.QuotaUpdater quotaUpdater) { + // This default implementation passes the current quota back to WebCore. + // WebCore will interpret this that new quota was declined. + quotaUpdater.updateQuota(currentQuota); + } + + /** + * Tell the client that the Application Cache has exceeded its max size. + * @param spaceNeeded is the amount of disk space that would be needed + * in order for the last appcache operation to succeed. + * @param totalUsedQuota is the sum of all origins' quota. + * @param quotaUpdater A callback to inform the WebCore thread that a new + * app cache size is available. This callback must always be executed at + * some point to ensure that the sleeping WebCore thread is woken up. + * @hide pending API council approval. + */ + public void onReachedMaxAppCacheSize(long spaceNeeded, long totalUsedQuota, + WebStorage.QuotaUpdater quotaUpdater) { + quotaUpdater.updateQuota(0); + } + + /** + * Instructs the client to show a prompt to ask the user to set the + * Geolocation permission state for the specified origin. + * @hide pending API council approval. + */ + public void onGeolocationPermissionsShowPrompt(String origin, + GeolocationPermissions.Callback callback) {} + + /** + * Instructs the client to hide the Geolocation permissions prompt. + * @hide pending API council approval. + */ + public void onGeolocationPermissionsHidePrompt() {} + /** * Tell the client that a JavaScript execution timeout has occured. And the * client may decide whether or not to interrupt the execution. If the @@ -172,4 +271,14 @@ public class WebChromeClient { public boolean onJsTimeout() { return true; } + + /** + * Add a JavaScript error message to the console. Clients should override + * this to process the log message as they see fit. + * @param message The error message to report. + * @param lineNumber The line number of the error. + * @param sourceID The name of the source file that caused the error. + * @hide pending API council. + */ + public void addMessageToConsole(String message, int lineNumber, String sourceID) {} } diff --git a/core/java/android/webkit/WebHistoryItem.java b/core/java/android/webkit/WebHistoryItem.java index fd26b98..abd8237 100644 --- a/core/java/android/webkit/WebHistoryItem.java +++ b/core/java/android/webkit/WebHistoryItem.java @@ -39,6 +39,8 @@ public class WebHistoryItem implements Cloneable { private Bitmap mFavicon; // The pre-flattened data used for saving the state. private byte[] mFlattenedData; + // The apple-touch-icon url for use when adding the site to the home screen + private String mTouchIconUrl; /** * Basic constructor that assigns a unique id to the item. Called by JNI @@ -127,6 +129,14 @@ public class WebHistoryItem implements Cloneable { } /** + * Return the touch icon url. + * @hide + */ + public String getTouchIconUrl() { + return mTouchIconUrl; + } + + /** * Set the favicon. * @param icon A Bitmap containing the favicon for this history item. * Note: The VM ensures 32-bit atomic read/write operations so we don't have @@ -137,6 +147,14 @@ public class WebHistoryItem implements Cloneable { } /** + * Set the touch icon url. + * @hide + */ + /*package*/ void setTouchIconUrl(String url) { + mTouchIconUrl = url; + } + + /** * Get the pre-flattened data. * Note: The VM ensures 32-bit atomic read/write operations so we don't have * to synchronize this method. diff --git a/core/java/android/webkit/WebIconDatabase.java b/core/java/android/webkit/WebIconDatabase.java index d284f5e..6cc6bb4 100644 --- a/core/java/android/webkit/WebIconDatabase.java +++ b/core/java/android/webkit/WebIconDatabase.java @@ -37,7 +37,7 @@ public final class WebIconDatabase { private final EventHandler mEventHandler = new EventHandler(); // Class to handle messages before WebCore is ready - private class EventHandler extends Handler { + private static class EventHandler extends Handler { // Message ids static final int OPEN = 0; static final int CLOSE = 1; diff --git a/core/java/android/webkit/WebSettings.java b/core/java/android/webkit/WebSettings.java index a038b55..eeac1d2 100644 --- a/core/java/android/webkit/WebSettings.java +++ b/core/java/android/webkit/WebSettings.java @@ -22,9 +22,7 @@ import android.os.Build; import android.os.Handler; import android.os.Message; import android.provider.Checkin; - import java.lang.SecurityException; - import java.util.Locale; /** @@ -130,9 +128,13 @@ public class WebSettings { private boolean mSyncPending = false; // Custom handler that queues messages until the WebCore thread is active. private final EventHandler mEventHandler; + // Private settings so we don't have to go into native code to // retrieve the values. After setXXX, postSync() needs to be called. - // XXX: The default values need to match those in WebSettings.cpp + // + // The default values need to match those in WebSettings.cpp + // If the defaults change, please also update the JavaDocs so developers + // know what they are. private LayoutAlgorithm mLayoutAlgorithm = LayoutAlgorithm.NARROW_COLUMNS; private Context mContext; private TextSize mTextSize = TextSize.NORMAL; @@ -146,7 +148,6 @@ public class WebSettings { private String mUserAgent; private boolean mUseDefaultUserAgent; private String mAcceptLanguage; - private String mPluginsPath = ""; private int mMinimumFontSize = 8; private int mMinimumLogicalFontSize = 8; private int mDefaultFontSize = 16; @@ -161,6 +162,15 @@ public class WebSettings { private boolean mUseWideViewport = false; private boolean mSupportMultipleWindows = false; private boolean mShrinksStandaloneImagesToFit = false; + // HTML5 API flags + private boolean mAppCacheEnabled = false; + private boolean mDatabaseEnabled = false; + private boolean mDomStorageEnabled = false; + private boolean mWorkersEnabled = false; // only affects V8. + // HTML5 configuration parameters + private long mAppCacheMaxSize = Long.MAX_VALUE; + private String mAppCachePath = ""; + private String mDatabasePath = ""; // Don't need to synchronize the get/set methods as they // are basic types, also none of these values are used in // native WebCore code. @@ -175,9 +185,7 @@ public class WebSettings { private boolean mSupportZoom = true; private boolean mBuiltInZoomControls = false; private boolean mAllowFileAccess = true; - - // The Gears permissions manager. Only in Donut. - static GearsPermissionsManager sGearsPermissionsManager; + private boolean mLoadWithOverviewMode = true; // Class to handle messages before WebCore is ready. private class EventHandler { @@ -199,7 +207,6 @@ public class WebSettings { switch (msg.what) { case SYNC: synchronized (WebSettings.this) { - checkGearsPermissions(); if (mBrowserFrame.mNativeFrame != 0) { nativeSync(mBrowserFrame.mNativeFrame); } @@ -247,13 +254,13 @@ public class WebSettings { // User agent strings. private static final String DESKTOP_USERAGENT = - "Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en)" - + " AppleWebKit/528.5+ (KHTML, like Gecko) Version/3.1.2" - + " Safari/525.20.1"; + "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_7; en-us)" + + " AppleWebKit/530.17 (KHTML, like Gecko) Version/4.0" + + " Safari/530.17"; private static final String IPHONE_USERAGENT = - "Mozilla/5.0 (iPhone; U; CPU iPhone 2_1 like Mac OS X; en)" - + " AppleWebKit/528.5+ (KHTML, like Gecko) Version/3.1.2" - + " Mobile/5F136 Safari/525.20.1"; + "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us)" + + " AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0" + + " Mobile/7A341 Safari/528.16"; private static Locale sLocale; private static Object sLockForLocaleSettings; @@ -421,6 +428,22 @@ public class WebSettings { } /** + * Set whether the WebView loads a page with overview mode. + * @hide Pending API council approval + */ + public void setLoadWithOverviewMode(boolean overview) { + mLoadWithOverviewMode = overview; + } + + /** + * Returns true if this WebView loads page with overview mode + * @hide Pending API council approval + */ + public boolean getLoadWithOverviewMode() { + return mLoadWithOverviewMode; + } + + /** * Store whether the WebView is saving form data. */ public void setSaveFormData(boolean save) { @@ -511,24 +534,21 @@ public class WebSettings { } /** - * Tell the WebView to use the double tree rendering algorithm. - * @param use True if the WebView is to use double tree rendering, false - * otherwise. + * @deprecated This setting controlled a rendering optimization + * that is no longer present. Setting it now has no effect. */ + @Deprecated public synchronized void setUseDoubleTree(boolean use) { - if (mUseDoubleTree != use) { - mUseDoubleTree = use; - postSync(); - } + return; } /** - * Return true if the WebView is using the double tree rendering algorithm. - * @return True if the WebView is using the double tree rendering - * algorithm. + * @deprecated This setting controlled a rendering optimization + * that is no longer present. Setting it now has no effect. */ + @Deprecated public synchronized boolean getUseDoubleTree() { - return mUseDoubleTree; + return false; } /** @@ -633,7 +653,7 @@ public class WebSettings { } /** - * Return the current layout algorithm. + * Return the current layout algorithm. The default is NARROW_COLUMNS. * @return LayoutAlgorithm enum value describing the layout algorithm * being used. * @see WebSettings.LayoutAlgorithm @@ -654,7 +674,7 @@ public class WebSettings { } /** - * Get the standard font family name. + * Get the standard font family name. The default is "sans-serif". * @return The standard font family name as a string. */ public synchronized String getStandardFontFamily() { @@ -673,7 +693,7 @@ public class WebSettings { } /** - * Get the fixed font family name. + * Get the fixed font family name. The default is "monospace". * @return The fixed font family name as a string. */ public synchronized String getFixedFontFamily() { @@ -700,7 +720,7 @@ public class WebSettings { } /** - * Set the serif font family name. + * Set the serif font family name. The default is "sans-serif". * @param font A font family name. */ public synchronized void setSerifFontFamily(String font) { @@ -711,7 +731,7 @@ public class WebSettings { } /** - * Get the serif font family name. + * Get the serif font family name. The default is "serif". * @return The serif font family name as a string. */ public synchronized String getSerifFontFamily() { @@ -730,7 +750,7 @@ public class WebSettings { } /** - * Get the cursive font family name. + * Get the cursive font family name. The default is "cursive". * @return The cursive font family name as a string. */ public synchronized String getCursiveFontFamily() { @@ -749,7 +769,7 @@ public class WebSettings { } /** - * Get the fantasy font family name. + * Get the fantasy font family name. The default is "fantasy". * @return The fantasy font family name as a string. */ public synchronized String getFantasyFontFamily() { @@ -770,7 +790,7 @@ public class WebSettings { } /** - * Get the minimum font size. + * Get the minimum font size. The default is 8. * @return A non-negative integer between 1 and 72. */ public synchronized int getMinimumFontSize() { @@ -791,7 +811,7 @@ public class WebSettings { } /** - * Get the minimum logical font size. + * Get the minimum logical font size. The default is 8. * @return A non-negative integer between 1 and 72. */ public synchronized int getMinimumLogicalFontSize() { @@ -812,7 +832,7 @@ public class WebSettings { } /** - * Get the default font size. + * Get the default font size. The default is 16. * @return A non-negative integer between 1 and 72. */ public synchronized int getDefaultFontSize() { @@ -833,7 +853,7 @@ public class WebSettings { } /** - * Get the default fixed font size. + * Get the default fixed font size. The default is 16. * @return A non-negative integer between 1 and 72. */ public synchronized int getDefaultFixedFontSize() { @@ -853,6 +873,7 @@ public class WebSettings { /** * Return true if the WebView will load image resources automatically. + * The default is true. * @return True if the WebView loads images automatically. */ public synchronized boolean getLoadsImagesAutomatically() { @@ -872,16 +893,16 @@ public class WebSettings { } /** - * Return true if the WebView will block network image. + * Return true if the WebView will block network image. The default is false. * @return True if the WebView blocks network image. */ public synchronized boolean getBlockNetworkImage() { return mBlockNetworkImage; } - + /** * @hide - * Tell the WebView to block all network load requests. + * Tell the WebView to block all network load requests. * @param flag True if the WebView should block all network loads */ public synchronized void setBlockNetworkLoads(boolean flag) { @@ -894,13 +915,14 @@ public class WebSettings { /** * @hide * Return true if the WebView will block all network loads. + * The default is false. * @return True if the WebView blocks all network loads. */ public synchronized boolean getBlockNetworkLoads() { return mBlockNetworkLoads; } - - + + private void verifyNetworkAccess() { if (!mBlockNetworkLoads) { if (mContext.checkPermission("android.permission.INTERNET", @@ -936,19 +958,131 @@ public class WebSettings { } /** - * Set a custom path to plugins used by the WebView. The client - * must ensure it exists before this call. - * @param pluginsPath String path to the directory containing plugins. + * TODO: need to add @Deprecated */ public synchronized void setPluginsPath(String pluginsPath) { - if (pluginsPath != null && !pluginsPath.equals(mPluginsPath)) { - mPluginsPath = pluginsPath; + } + + /** + * Set the path to where database storage API databases should be saved. + * This will update WebCore when the Sync runs in the C++ side. + * @param databasePath String path to the directory where databases should + * be saved. May be the empty string but should never be null. + */ + public synchronized void setDatabasePath(String databasePath) { + if (databasePath != null && !databasePath.equals(mDatabasePath)) { + mDatabasePath = databasePath; + postSync(); + } + } + + /** + * Tell the WebView to enable Application Caches API. + * @param flag True if the WebView should enable Application Caches. + * @hide pending api council approval + */ + public synchronized void setAppCacheEnabled(boolean flag) { + if (mAppCacheEnabled != flag) { + mAppCacheEnabled = flag; + postSync(); + } + } + + /** + * Set a custom path to the Application Caches files. The client + * must ensure it exists before this call. + * @param appCachePath String path to the directory containing Application + * Caches files. The appCache path can be the empty string but should not + * be null. Passing null for this parameter will result in a no-op. + * @hide pending api council approval + */ + public synchronized void setAppCachePath(String appCachePath) { + if (appCachePath != null && !appCachePath.equals(mAppCachePath)) { + mAppCachePath = appCachePath; + postSync(); + } + } + + /** + * Set the maximum size for the Application Caches content. + * @param appCacheMaxSize the maximum size in bytes. + * + * @hide pending api council approval + */ + public synchronized void setAppCacheMaxSize(long appCacheMaxSize) { + if (appCacheMaxSize != mAppCacheMaxSize) { + mAppCacheMaxSize = appCacheMaxSize; + postSync(); + } + } + + /** + * Set whether the database storage API is enabled. + * @param flag boolean True if the WebView should use the database storage + * API. + */ + public synchronized void setDatabaseEnabled(boolean flag) { + if (mDatabaseEnabled != flag) { + mDatabaseEnabled = flag; + postSync(); + } + } + + /** + * Set whether the DOM storage API is enabled. + * @param flag boolean True if the WebView should use the DOM storage + * API. + * @hide pending API council. + */ + public synchronized void setDomStorageEnabled(boolean flag) { + if (mDomStorageEnabled != flag) { + mDomStorageEnabled = flag; + postSync(); + } + } + + /** + * Returns true if the DOM Storage API's are enabled. + * @return True if the DOM Storage API's are enabled. + * @hide pending API council. + */ + public synchronized boolean getDomStorageEnabled() { + return mDomStorageEnabled; + } + + /** + * Return the path to where database storage API databases are saved for + * the current WebView. + * @return the String path to the database storage API databases. + */ + public synchronized String getDatabasePath() { + return mDatabasePath; + } + + /** + * Returns true if database storage API is enabled. + * @return True if the database storage API is enabled. + */ + public synchronized boolean getDatabaseEnabled() { + return mDatabaseEnabled; + } + + /** + * Tell the WebView to enable WebWorkers API. + * @param flag True if the WebView should enable WebWorkers. + * Note that this flag only affects V8. JSC does not have + * an equivalent setting. + * @hide pending api council approval + */ + public synchronized void setWorkersEnabled(boolean flag) { + if (mWorkersEnabled != flag) { + mWorkersEnabled = flag; postSync(); } } /** - * Return true if javascript is enabled. + * Return true if javascript is enabled. <b>Note: The default is false.</b> * @return True if javascript is enabled. */ public synchronized boolean getJavaScriptEnabled() { @@ -964,11 +1098,10 @@ public class WebSettings { } /** - * Return the current path used for plugins in the WebView. - * @return The string path to the WebView plugins. + * TODO: need to add @Deprecated */ public synchronized String getPluginsPath() { - return mPluginsPath; + return ""; } /** @@ -985,7 +1118,8 @@ public class WebSettings { } /** - * Return true if javascript can open windows automatically. + * Return true if javascript can open windows automatically. The default + * is false. * @return True if javascript can open windows automatically during * window.open(). */ @@ -1005,7 +1139,7 @@ public class WebSettings { } /** - * Get the default text encoding name. + * Get the default text encoding name. The default is "Latin-1". * @return The default text encoding name as a string. */ public synchronized String getDefaultTextEncodingName() { @@ -1094,8 +1228,8 @@ public class WebSettings { /** * Set the priority of the Render thread. Unlike the other settings, this - * one only needs to be called once per process. - * + * one only needs to be called once per process. The default is NORMAL. + * * @param priority RenderPriority, can be normal, high or low. */ public synchronized void setRenderPriority(RenderPriority priority) { @@ -1149,10 +1283,9 @@ public class WebSettings { /*package*/ synchronized void syncSettingsAndCreateHandler(BrowserFrame frame) { mBrowserFrame = frame; - if (WebView.DEBUG) { + if (DebugFlags.WEB_SETTINGS) { junit.framework.Assert.assertTrue(frame.mNativeFrame != 0); } - checkGearsPermissions(); nativeSync(frame.mNativeFrame); mSyncPending = false; mEventHandler.createHandler(); @@ -1168,23 +1301,6 @@ public class WebSettings { return size; } - private void checkGearsPermissions() { - // Did we already check the permissions at startup? - if (sGearsPermissionsManager != null) { - return; - } - // Is the pluginsPath sane? - String pluginsPath = getPluginsPath(); - if (pluginsPath == null || pluginsPath.length() == 0) { - // We don't yet have a meaningful plugin path, so - // we can't do anything about the Gears permissions. - return; - } - sGearsPermissionsManager = - new GearsPermissionsManager(mContext, pluginsPath); - sGearsPermissionsManager.doCheckAndStartObserver(); - } - /* Post a SYNC message to handle syncing the native settings. */ private synchronized void postSync() { // Only post if a sync is not pending diff --git a/core/java/android/webkit/WebStorage.java b/core/java/android/webkit/WebStorage.java new file mode 100644 index 0000000..ae560fb --- /dev/null +++ b/core/java/android/webkit/WebStorage.java @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2009 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.os.Handler; +import android.os.Message; +import android.util.Log; + +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + +/** + * Functionality for manipulating the webstorage databases. + */ +public final class WebStorage { + + /** + * Encapsulates a callback function to be executed when a new quota is made + * available. We primarily want this to allow us to call back the sleeping + * WebCore thread from outside the WebViewCore class (as the native call + * is private). It is imperative that this the setDatabaseQuota method is + * executed once a decision to either allow or deny new quota is made, + * otherwise the WebCore thread will remain asleep. + */ + public interface QuotaUpdater { + public void updateQuota(long newQuota); + }; + + // Log tag + private static final String TAG = "webstorage"; + + // Global instance of a WebStorage + private static WebStorage sWebStorage; + + // We keep the origins, quotas and usages as member values + // that we protect via a lock and update in syncValues(). + // This is needed to transfer this data across threads. + private static Lock mLock = new ReentrantLock(); + private static Condition mUpdateCondition = mLock.newCondition(); + private static boolean mUpdateAvailable; + + // Message ids + static final int UPDATE = 0; + static final int SET_QUOTA_ORIGIN = 1; + static final int DELETE_ORIGIN = 2; + static final int DELETE_ALL = 3; + + private Set <String> mOrigins; + private HashMap <String, Long> mQuotas = new HashMap<String, Long>(); + private HashMap <String, Long> mUsages = new HashMap<String, Long>(); + + private Handler mHandler = null; + + private static class Origin { + String mOrigin = null; + long mQuota = 0; + + public Origin(String origin, long quota) { + mOrigin = origin; + mQuota = quota; + } + + public Origin(String origin) { + mOrigin = origin; + } + + public String getOrigin() { + return mOrigin; + } + + public long getQuota() { + return mQuota; + } + } + + /** + * @hide + * Message handler + */ + public void createHandler() { + if (mHandler == null) { + mHandler = new Handler() { + @Override + public void handleMessage(Message msg) { + switch (msg.what) { + case SET_QUOTA_ORIGIN: { + Origin website = (Origin) msg.obj; + nativeSetQuotaForOrigin(website.getOrigin(), + website.getQuota()); + } break; + + case DELETE_ORIGIN: { + Origin website = (Origin) msg.obj; + nativeDeleteOrigin(website.getOrigin()); + } break; + + case DELETE_ALL: + nativeDeleteAllData(); + break; + + case UPDATE: + syncValues(); + break; + } + } + }; + } + } + + /** + * @hide + * Returns a list of origins having a database + */ + public Set getOrigins() { + Set ret = null; + mLock.lock(); + try { + mUpdateAvailable = false; + update(); + while (!mUpdateAvailable) { + mUpdateCondition.await(); + } + ret = mOrigins; + } catch (InterruptedException e) { + Log.e(TAG, "Exception while waiting on the updated origins", e); + } finally { + mLock.unlock(); + } + return ret; + } + + /** + * @hide + * Returns the use for a given origin + */ + public long getUsageForOrigin(String origin) { + long ret = 0; + if (origin == null) { + return ret; + } + mLock.lock(); + try { + mUpdateAvailable = false; + update(); + while (!mUpdateAvailable) { + mUpdateCondition.await(); + } + Long usage = mUsages.get(origin); + if (usage != null) { + ret = usage.longValue(); + } + } catch (InterruptedException e) { + Log.e(TAG, "Exception while waiting on the updated origins", e); + } finally { + mLock.unlock(); + } + return ret; + } + + /** + * @hide + * Returns the quota for a given origin + */ + public long getQuotaForOrigin(String origin) { + long ret = 0; + if (origin == null) { + return ret; + } + mLock.lock(); + try { + mUpdateAvailable = false; + update(); + while (!mUpdateAvailable) { + mUpdateCondition.await(); + } + Long quota = mQuotas.get(origin); + if (quota != null) { + ret = quota.longValue(); + } + } catch (InterruptedException e) { + Log.e(TAG, "Exception while waiting on the updated origins", e); + } finally { + mLock.unlock(); + } + return ret; + } + + /** + * @hide + * Set the quota for a given origin + */ + public void setQuotaForOrigin(String origin, long quota) { + if (origin != null) { + if (WebViewCore.THREAD_NAME.equals(Thread.currentThread().getName())) { + nativeSetQuotaForOrigin(origin, quota); + } else { + postMessage(Message.obtain(null, SET_QUOTA_ORIGIN, + new Origin(origin, quota))); + } + } + } + + /** + * @hide + * Delete a given origin + */ + public void deleteOrigin(String origin) { + if (origin != null) { + if (WebViewCore.THREAD_NAME.equals(Thread.currentThread().getName())) { + nativeDeleteOrigin(origin); + } else { + postMessage(Message.obtain(null, DELETE_ORIGIN, + new Origin(origin))); + } + } + } + + /** + * @hide + * Delete all databases + */ + public void deleteAllData() { + if (WebViewCore.THREAD_NAME.equals(Thread.currentThread().getName())) { + nativeDeleteAllData(); + } else { + postMessage(Message.obtain(null, DELETE_ALL)); + } + } + + /** + * Utility function to send a message to our handler + */ + private void postMessage(Message msg) { + if (mHandler != null) { + mHandler.sendMessage(msg); + } + } + + /** + * @hide + * Get the global instance of WebStorage. + * @return A single instance of WebStorage. + */ + public static WebStorage getInstance() { + if (sWebStorage == null) { + sWebStorage = new WebStorage(); + } + return sWebStorage; + } + + /** + * @hide + * Post a Sync request + */ + public void update() { + if (WebViewCore.THREAD_NAME.equals(Thread.currentThread().getName())) { + syncValues(); + } else { + postMessage(Message.obtain(null, UPDATE)); + } + } + + /** + * Run on the webcore thread + * set the local values with the current ones + */ + private void syncValues() { + mLock.lock(); + Set tmp = nativeGetOrigins(); + mOrigins = new HashSet<String>(); + mQuotas.clear(); + mUsages.clear(); + Iterator<String> iter = tmp.iterator(); + while (iter.hasNext()) { + String origin = iter.next(); + mOrigins.add(origin); + mQuotas.put(origin, new Long(nativeGetQuotaForOrigin(origin))); + mUsages.put(origin, new Long(nativeGetUsageForOrigin(origin))); + } + mUpdateAvailable = true; + mUpdateCondition.signal(); + mLock.unlock(); + } + + // Native functions + private static native Set nativeGetOrigins(); + private static native long nativeGetUsageForOrigin(String origin); + private static native long nativeGetQuotaForOrigin(String origin); + private static native void nativeSetQuotaForOrigin(String origin, long quota); + private static native void nativeDeleteOrigin(String origin); + private static native void nativeDeleteAllData(); +} diff --git a/core/java/android/webkit/WebSyncManager.java b/core/java/android/webkit/WebSyncManager.java index ded17ed..d3ec603 100644 --- a/core/java/android/webkit/WebSyncManager.java +++ b/core/java/android/webkit/WebSyncManager.java @@ -47,7 +47,7 @@ abstract class WebSyncManager implements Runnable { @Override public void handleMessage(Message msg) { if (msg.what == SYNC_MESSAGE) { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.WEB_SYNC_MANAGER) { Log.v(LOGTAG, "*** WebSyncManager sync ***"); } syncFromRamToFlash(); @@ -94,7 +94,7 @@ abstract class WebSyncManager implements Runnable { * sync() forces sync manager to sync now */ public void sync() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.WEB_SYNC_MANAGER) { Log.v(LOGTAG, "*** WebSyncManager sync ***"); } if (mHandler == null) { @@ -109,7 +109,7 @@ abstract class WebSyncManager implements Runnable { * resetSync() resets sync manager's timer */ public void resetSync() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.WEB_SYNC_MANAGER) { Log.v(LOGTAG, "*** WebSyncManager resetSync ***"); } if (mHandler == null) { @@ -124,7 +124,7 @@ abstract class WebSyncManager implements Runnable { * startSync() requests sync manager to start sync */ public void startSync() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.WEB_SYNC_MANAGER) { Log.v(LOGTAG, "*** WebSyncManager startSync ***, Ref count:" + mStartSyncRefCount); } @@ -142,7 +142,7 @@ abstract class WebSyncManager implements Runnable { * the queue to break the sync loop */ public void stopSync() { - if (WebView.LOGV_ENABLED) { + if (DebugFlags.WEB_SYNC_MANAGER) { Log.v(LOGTAG, "*** WebSyncManager stopSync ***, Ref count:" + mStartSyncRefCount); } diff --git a/core/java/android/webkit/TextDialog.java b/core/java/android/webkit/WebTextView.java index 99de56d..a1f2223 100644 --- a/core/java/android/webkit/TextDialog.java +++ b/core/java/android/webkit/WebTextView.java @@ -17,14 +17,13 @@ package android.webkit; import android.content.Context; +import android.graphics.Canvas; import android.graphics.Color; +import android.graphics.ColorFilter; import android.graphics.Paint; +import android.graphics.PixelFormat; import android.graphics.Rect; -import android.graphics.drawable.ColorDrawable; import android.graphics.drawable.Drawable; -import android.graphics.drawable.LayerDrawable; -import android.graphics.drawable.ShapeDrawable; -import android.graphics.drawable.shapes.RectShape; import android.text.Editable; import android.text.InputFilter; import android.text.Selection; @@ -32,13 +31,17 @@ import android.text.Spannable; import android.text.TextPaint; import android.text.TextUtils; import android.text.method.MovementMethod; -import android.view.inputmethod.EditorInfo; -import android.view.inputmethod.InputMethodManager; +import android.text.method.Touch; +import android.util.Log; +import android.view.Gravity; import android.view.KeyCharacterMap; import android.view.KeyEvent; import android.view.MotionEvent; import android.view.View; import android.view.ViewGroup; +import android.view.inputmethod.EditorInfo; +import android.view.inputmethod.InputMethodManager; +import android.view.inputmethod.InputConnection; import android.widget.AbsoluteLayout.LayoutParams; import android.widget.ArrayAdapter; import android.widget.AutoCompleteTextView; @@ -47,11 +50,13 @@ import android.widget.TextView; import java.util.ArrayList; /** - * TextDialog is a specialized version of EditText used by WebView + * WebTextView is a specialized version of EditText used by WebView * to overlay html textfields (and textareas) to use our standard * text editing. */ -/* package */ class TextDialog extends AutoCompleteTextView { +/* package */ class WebTextView extends AutoCompleteTextView { + + static final String LOGTAG = "webtextview"; private WebView mWebView; private boolean mSingle; @@ -62,13 +67,28 @@ import java.util.ArrayList; // on the enter key. The method for blocking unmatched key ups prevents // the shift key from working properly. private boolean mGotEnterDown; - // mScrollToAccommodateCursor being set to false prevents us from scrolling - // the cursor on screen when using the trackball to select a textfield. - private boolean mScrollToAccommodateCursor; private int mMaxLength; // Keep track of the text before the change so we know whether we actually // need to send down the DOM events. private String mPreChange; + private Drawable mBackground; + // Variables for keeping track of the touch down, to send to the WebView + // when a drag starts + private float mDragStartX; + private float mDragStartY; + private long mDragStartTime; + private boolean mDragSent; + // True if the most recent drag event has caused either the TextView to + // scroll or the web page to scroll. Gets reset after a touch down. + private boolean mScrolled; + // Gets set to true when the the IME jumps to the next textfield. When this + // happens, the next time the user hits a key it is okay for the focus + // pointer to not match the WebTextView's node pointer + private boolean mOkayForFocusNotToMatch; + // Whether or not a selection change was generated from webkit. If it was, + // we do not need to pass the selection back to webkit. + private boolean mFromWebKit; + private boolean mGotTouchDown; // Array to store the final character added in onTextChanged, so that its // KeyEvents may be determined. private char[] mCharacter = new char[1]; @@ -79,39 +99,14 @@ import java.util.ArrayList; private static final InputFilter[] NO_FILTERS = new InputFilter[0]; /** - * Create a new TextDialog. - * @param context The Context for this TextDialog. + * Create a new WebTextView. + * @param context The Context for this WebTextView. * @param webView The WebView that created this. */ - /* package */ TextDialog(Context context, WebView webView) { + /* package */ WebTextView(Context context, WebView webView) { super(context); mWebView = webView; - ShapeDrawable background = new ShapeDrawable(new RectShape()); - Paint shapePaint = background.getPaint(); - shapePaint.setStyle(Paint.Style.STROKE); - ColorDrawable color = new ColorDrawable(Color.WHITE); - Drawable[] array = new Drawable[2]; - array[0] = color; - array[1] = background; - LayerDrawable layers = new LayerDrawable(array); - // Hide WebCore's text behind this and allow the WebView - // to draw its own focusring. - setBackgroundDrawable(layers); - // Align the text better with the text behind it, so moving - // off of the textfield will not appear to move the text. - setPadding(3, 2, 0, 0); mMaxLength = -1; - // Turn on subpixel text, and turn off kerning, so it better matches - // the text in webkit. - TextPaint paint = getPaint(); - int flags = paint.getFlags() | Paint.SUBPIXEL_TEXT_FLAG | - Paint.ANTI_ALIAS_FLAG & ~Paint.DEV_KERN_TEXT_FLAG; - paint.setFlags(flags); - // Set the text color to black, regardless of the theme. This ensures - // that other applications that use embedded WebViews will properly - // display the text in textfields. - setTextColor(Color.BLACK); - setImeOptions(EditorInfo.IME_ACTION_NONE); } @Override @@ -122,10 +117,39 @@ import java.util.ArrayList; // Treat ACTION_DOWN and ACTION MULTIPLE the same boolean down = event.getAction() != KeyEvent.ACTION_UP; int keyCode = event.getKeyCode(); + + boolean isArrowKey = false; + switch(keyCode) { + case KeyEvent.KEYCODE_DPAD_LEFT: + case KeyEvent.KEYCODE_DPAD_RIGHT: + case KeyEvent.KEYCODE_DPAD_UP: + case KeyEvent.KEYCODE_DPAD_DOWN: + if (!mWebView.nativeCursorMatchesFocus()) { + return down ? mWebView.onKeyDown(keyCode, event) : mWebView + .onKeyUp(keyCode, event); + + } + isArrowKey = true; + break; + } + if (!isArrowKey && !mOkayForFocusNotToMatch + && mWebView.nativeFocusNodePointer() != mNodePointer) { + mWebView.nativeClearCursor(); + // Do not call remove() here, which hides the soft keyboard. If + // the soft keyboard is being displayed, the user will still want + // it there. + mWebView.removeView(this); + mWebView.requestFocus(); + return mWebView.dispatchKeyEvent(event); + } + // After a jump to next textfield and the first key press, the cursor + // and focus will once again match, so reset this value. + mOkayForFocusNotToMatch = false; + Spannable text = (Spannable) getText(); int oldLength = text.length(); // Normally the delete key's dom events are sent via onTextChanged. - // However, if the length is zero, the text did not change, so we + // However, if the length is zero, the text did not change, so we // go ahead and pass the key down immediately. if (KeyEvent.KEYCODE_DEL == keyCode && 0 == oldLength) { sendDomEvent(event); @@ -151,6 +175,10 @@ import java.util.ArrayList; if (isPopupShowing()) { return super.dispatchKeyEvent(event); } + if (!mWebView.nativeCursorMatchesFocus()) { + return down ? mWebView.onKeyDown(keyCode, event) : mWebView + .onKeyUp(keyCode, event); + } // Center key should be passed to a potential onClick if (!down) { mWebView.shortPressOnTextField(); @@ -177,7 +205,7 @@ import java.util.ArrayList; oldText = ""; } if (super.dispatchKeyEvent(event)) { - // If the TextDialog handled the key it was either an alphanumeric + // If the WebTextView handled the key it was either an alphanumeric // key, a delete, or a movement within the text. All of those are // ok to pass to javascript. @@ -187,27 +215,15 @@ import java.util.ArrayList; // so do not pass down to javascript, and instead // return true. If it is an arrow key or a delete key, we can go // ahead and pass it down. - boolean isArrowKey; - switch(keyCode) { - case KeyEvent.KEYCODE_DPAD_LEFT: - case KeyEvent.KEYCODE_DPAD_RIGHT: - case KeyEvent.KEYCODE_DPAD_UP: - case KeyEvent.KEYCODE_DPAD_DOWN: - isArrowKey = true; - break; - case KeyEvent.KEYCODE_ENTER: - // For multi-line text boxes, newlines will - // trigger onTextChanged for key down (which will send both - // key up and key down) but not key up. - mGotEnterDown = true; - default: - isArrowKey = false; - break; + if (KeyEvent.KEYCODE_ENTER == keyCode) { + // For multi-line text boxes, newlines will + // trigger onTextChanged for key down (which will send both + // key up and key down) but not key up. + mGotEnterDown = true; } if (maxedOut && !isArrowKey && keyCode != KeyEvent.KEYCODE_DEL) { if (oldEnd == oldStart) { // Return true so the key gets dropped. - mScrollToAccommodateCursor = true; return true; } else if (!oldText.equals(getText().toString())) { // FIXME: This makes the text work properly, but it @@ -221,36 +237,33 @@ import java.util.ArrayList; int newEnd = Selection.getSelectionEnd(span); mWebView.replaceTextfieldText(0, oldLength, span.toString(), newStart, newEnd); - mScrollToAccommodateCursor = true; return true; } } + /* FIXME: + * In theory, we would like to send the events for the arrow keys. + * However, the TextView can arbitrarily change the selection (i.e. + * long press followed by using the trackball). Therefore, we keep + * in sync with the TextView via onSelectionChanged. If we also + * send the DOM event, we lose the correct selection. if (isArrowKey) { // Arrow key does not change the text, but we still want to send // the DOM events. sendDomEvent(event); } - mScrollToAccommodateCursor = true; + */ return true; } - // FIXME: TextViews return false for up and down key events even though - // they change the selection. Since we don't want the get out of sync - // with WebCore's notion of the current selection, reset the selection - // to what it was before the key event. - Selection.setSelection(text, oldStart, oldEnd); // Ignore the key up event for newlines. This prevents // multiple newlines in the native textarea. if (mGotEnterDown && !down) { return true; } // if it is a navigation key, pass it to WebView - if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT - || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT - || keyCode == KeyEvent.KEYCODE_DPAD_UP - || keyCode == KeyEvent.KEYCODE_DPAD_DOWN) { + if (isArrowKey) { // WebView check the trackballtime in onKeyDown to avoid calling - // native from both trackball and key handling. As this is called - // from TextDialog, we always want WebView to check with native. + // native from both trackball and key handling. As this is called + // from WebTextView, we always want WebView to check with native. // Reset trackballtime to ensure it. mWebView.resetTrackballTime(); return down ? mWebView.onKeyDown(keyCode, event) : mWebView @@ -260,9 +273,9 @@ import java.util.ArrayList; } /** - * Create a fake touch up event at (x,y) with respect to this TextDialog. + * Create a fake touch up event at (x,y) with respect to this WebTextView. * This is used by WebView to act as though a touch event which happened - * before we placed the TextDialog actually hit it, so that it can place + * before we placed the WebTextView actually hit it, so that it can place * the cursor accordingly. */ /* package */ void fakeTouchEvent(float x, float y) { @@ -279,31 +292,76 @@ import java.util.ArrayList; } /** - * Determine whether this TextDialog currently represents the node + * Determine whether this WebTextView currently represents the node * represented by ptr. * @param ptr Pointer to a node to compare to. - * @return boolean Whether this TextDialog already represents the node + * @return boolean Whether this WebTextView already represents the node * pointed to by ptr. */ /* package */ boolean isSameTextField(int ptr) { return ptr == mNodePointer; } + @Override public InputConnection onCreateInputConnection( + EditorInfo outAttrs) { + InputConnection connection = super.onCreateInputConnection(outAttrs); + if (mWebView != null) { + // Use the name of the textfield + the url. Use backslash as an + // arbitrary separator. + outAttrs.fieldName = mWebView.nativeFocusCandidateName() + "\\" + + mWebView.getUrl(); + } + return connection; + } + @Override - public boolean onPreDraw() { - if (getLayout() == null) { - measure(mWidthSpec, mHeightSpec); + public void onEditorAction(int actionCode) { + switch (actionCode) { + case EditorInfo.IME_ACTION_NEXT: + mWebView.nativeMoveCursorToNextTextInput(); + // Preemptively rebuild the WebTextView, so that the action will + // be set properly. + mWebView.rebuildWebTextView(); + // Since the cursor will no longer be in the same place as the + // focus, set the focus controller back to inactive + mWebView.setFocusControllerInactive(); + mOkayForFocusNotToMatch = true; + break; + case EditorInfo.IME_ACTION_DONE: + super.onEditorAction(actionCode); + break; + case EditorInfo.IME_ACTION_GO: + // Send an enter and hide the soft keyboard + InputMethodManager.getInstance(mContext) + .hideSoftInputFromWindow(getWindowToken(), 0); + sendDomEvent(new KeyEvent(KeyEvent.ACTION_DOWN, + KeyEvent.KEYCODE_ENTER)); + sendDomEvent(new KeyEvent(KeyEvent.ACTION_UP, + KeyEvent.KEYCODE_ENTER)); + + default: + break; } - return super.onPreDraw(); } - + + @Override + protected void onSelectionChanged(int selStart, int selEnd) { + if (!mFromWebKit && mWebView != null) { + if (DebugFlags.WEB_TEXT_VIEW) { + Log.v(LOGTAG, "onSelectionChanged selStart=" + selStart + + " selEnd=" + selEnd); + } + mWebView.setSelection(selStart, selEnd); + } + } + @Override protected void onTextChanged(CharSequence s,int start,int before,int count){ super.onTextChanged(s, start, before, count); String postChange = s.toString(); // Prevent calls to setText from invoking onTextChanged (since this will // mean we are on a different textfield). Also prevent the change when - // going from a textfield with a string of text to one with a smaller + // going from a textfield with a string of text to one with a smaller // limit on text length from registering the onTextChanged event. if (mPreChange == null || mPreChange.equals(postChange) || (mMaxLength > -1 && mPreChange.length() > mMaxLength && @@ -311,8 +369,7 @@ import java.util.ArrayList; return; } mPreChange = postChange; - // This was simply a delete or a cut, so just delete the - // selection. + // This was simply a delete or a cut, so just delete the selection. if (before > 0 && 0 == count) { mWebView.deleteSelection(start, start + before); // For this and all changes to the text, update our cache @@ -337,24 +394,91 @@ import java.util.ArrayList; start + count - charactersFromKeyEvents, start + count - charactersFromKeyEvents); } else { - // This corrects the selection which may have been affected by the + // This corrects the selection which may have been affected by the // trackball or auto-correct. + if (DebugFlags.WEB_TEXT_VIEW) { + Log.v(LOGTAG, "onTextChanged start=" + start + + " start + before=" + (start + before)); + } mWebView.setSelection(start, start + before); } - updateCachedTextfield(); - if (cannotUseKeyEvents) { - return; + if (!cannotUseKeyEvents) { + int length = events.length; + for (int i = 0; i < length; i++) { + // We never send modifier keys to native code so don't send them + // here either. + if (!KeyEvent.isModifierKey(events[i].getKeyCode())) { + sendDomEvent(events[i]); + } + } } - int length = events.length; - for (int i = 0; i < length; i++) { - // We never send modifier keys to native code so don't send them - // here either. - if (!KeyEvent.isModifierKey(events[i].getKeyCode())) { - sendDomEvent(events[i]); + updateCachedTextfield(); + } + + @Override + public boolean onTouchEvent(MotionEvent event) { + switch (event.getAction()) { + case MotionEvent.ACTION_DOWN: + super.onTouchEvent(event); + // This event may be the start of a drag, so store it to pass to the + // WebView if it is. + mDragStartX = event.getX(); + mDragStartY = event.getY(); + mDragStartTime = event.getEventTime(); + mDragSent = false; + mScrolled = false; + mGotTouchDown = true; + break; + case MotionEvent.ACTION_MOVE: + Spannable buffer = getText(); + int initialScrollX = Touch.getInitialScrollX(this, buffer); + int initialScrollY = Touch.getInitialScrollY(this, buffer); + super.onTouchEvent(event); + if (mScrollX != initialScrollX + || mScrollY != initialScrollY) { + if (mWebView != null) { + mWebView.scrollFocusedTextInput(mScrollX, mScrollY); + } + mScrolled = true; + return true; } + if (mWebView != null) { + // Only want to set the initial state once. + if (!mDragSent) { + mWebView.initiateTextFieldDrag(mDragStartX, mDragStartY, + mDragStartTime); + mDragSent = true; + } + boolean scrolled = mWebView.textFieldDrag(event); + if (scrolled) { + mScrolled = true; + cancelLongPress(); + return true; + } + } + return false; + case MotionEvent.ACTION_UP: + case MotionEvent.ACTION_CANCEL: + if (!mScrolled) { + // If the page scrolled, or the TextView scrolled, we do not + // want to change the selection + cancelLongPress(); + if (mGotTouchDown && mWebView != null) { + mWebView.touchUpOnTextField(event); + } + } + // Necessary for the WebView to reset its state + if (mWebView != null && mDragSent) { + mWebView.onTouchEvent(event); + } + mGotTouchDown = false; + break; + default: + break; } + return true; } - + @Override public boolean onTrackballEvent(MotionEvent event) { if (isPopupShowing()) { @@ -363,29 +487,23 @@ import java.util.ArrayList; if (event.getAction() != MotionEvent.ACTION_MOVE) { return false; } + // If the Cursor is not on the text input, webview should handle the + // trackball + if (!mWebView.nativeCursorMatchesFocus()) { + return mWebView.onTrackballEvent(event); + } Spannable text = (Spannable) getText(); MovementMethod move = getMovementMethod(); if (move != null && getLayout() != null && move.onTrackballEvent(this, text, event)) { - // Need to pass down the selection, which has changed. - // FIXME: This should work, but does not, so we set the selection - // in onTextChanged. - //int start = Selection.getSelectionStart(text); - //int end = Selection.getSelectionEnd(text); - //mWebView.setSelection(start, end); + // Selection is changed in onSelectionChanged return true; } - // If the user is in a textfield, and the movement method is not - // handling the trackball events, it means they are at the end of the - // field and continuing to move the trackball. In this case, we should - // not scroll the cursor on screen bc the user may be attempting to - // scroll the page, possibly in the opposite direction of the cursor. - mScrollToAccommodateCursor = false; return false; } /** - * Remove this TextDialog from its host WebView, and return + * Remove this WebTextView from its host WebView, and return * focus to the host. */ /* package */ void remove() { @@ -394,11 +512,6 @@ import java.util.ArrayList; getWindowToken(), 0); mWebView.removeView(this); mWebView.requestFocus(); - mScrollToAccommodateCursor = false; - } - - /* package */ void enableScrollOnScreen(boolean enable) { - mScrollToAccommodateCursor = enable; } /* package */ void bringIntoView() { @@ -407,14 +520,6 @@ import java.util.ArrayList; } } - @Override - public boolean requestRectangleOnScreen(Rect rectangle) { - if (mScrollToAccommodateCursor) { - return super.requestRectangleOnScreen(rectangle); - } - return false; - } - /** * Send the DOM events for the specified event. * @param event KeyEvent to be translated into a DOM event. @@ -425,7 +530,7 @@ import java.util.ArrayList; /** * Always use this instead of setAdapter, as this has features specific to - * the TextDialog. + * the WebTextView. */ public void setAdapterCustom(AutoCompleteAdapter adapter) { if (adapter != null) { @@ -476,7 +581,65 @@ import java.util.ArrayList; if (inPassword) { setInputType(EditorInfo.TYPE_CLASS_TEXT | EditorInfo. TYPE_TEXT_VARIATION_PASSWORD); + createBackground(); + } + // For password fields, draw the WebTextView. For others, just show + // webkit's drawing. + setWillNotDraw(!inPassword); + setBackgroundDrawable(inPassword ? mBackground : null); + // For non-password fields, avoid the invals from TextView's blinking + // cursor + setCursorVisible(inPassword); + } + + /** + * Private class used for the background of a password textfield. + */ + private static class OutlineDrawable extends Drawable { + public void draw(Canvas canvas) { + Rect bounds = getBounds(); + Paint paint = new Paint(); + paint.setAntiAlias(true); + // Draw the background. + paint.setColor(Color.WHITE); + canvas.drawRect(bounds, paint); + // Draw the outline. + paint.setStyle(Paint.Style.STROKE); + paint.setColor(Color.BLACK); + canvas.drawRect(bounds, paint); + } + // Always want it to be opaque. + public int getOpacity() { + return PixelFormat.OPAQUE; + } + // These are needed because they are abstract in Drawable. + public void setAlpha(int alpha) { } + public void setColorFilter(ColorFilter cf) { } + } + + /** + * Create a background for the WebTextView and set up the paint for drawing + * the text. This way, we can see the password transformation of the + * system, which (optionally) shows the actual text before changing to dots. + * The background is necessary to hide the webkit-drawn text beneath. + */ + private void createBackground() { + if (mBackground != null) { + return; } + mBackground = new OutlineDrawable(); + + setGravity(Gravity.CENTER_VERTICAL); + // Turn on subpixel text, and turn off kerning, so it better matches + // the text in webkit. + TextPaint paint = getPaint(); + int flags = paint.getFlags() | Paint.SUBPIXEL_TEXT_FLAG | + Paint.ANTI_ALIAS_FLAG & ~Paint.DEV_KERN_TEXT_FLAG; + paint.setFlags(flags); + // Set the text color to black, regardless of the theme. This ensures + // that other applications that use embedded WebViews will properly + // display the text in password textfields. + setTextColor(Color.BLACK); } /* package */ void setMaxLength(int maxLength) { @@ -491,16 +654,16 @@ import java.util.ArrayList; /** * Set the pointer for this node so it can be determined which node this - * TextDialog represents. + * WebTextView represents. * @param ptr Integer representing the pointer to the node which this - * TextDialog represents. + * WebTextView represents. */ /* package */ void setNodePointer(int ptr) { mNodePointer = ptr; } /** - * Determine the position and size of TextDialog, and add it to the + * Determine the position and size of WebTextView, and add it to the * WebView's view heirarchy. All parameters are presumed to be in * view coordinates. Also requests Focus and sets the cursor to not * request to be in view. @@ -531,6 +694,15 @@ import java.util.ArrayList; } /** + * Set the selection, and disable our onSelectionChanged action. + */ + /* package */ void setSelectionFromWebKit(int start, int end) { + mFromWebKit = true; + Selection.setSelection((Spannable) getText(), start, end); + mFromWebKit = false; + } + + /** * Set whether this is a single-line textfield or a multi-line textarea. * Textfields scroll horizontally, and do not handle the enter key. * Textareas behave oppositely. @@ -540,10 +712,26 @@ import java.util.ArrayList; public void setSingleLine(boolean single) { int inputType = EditorInfo.TYPE_CLASS_TEXT | EditorInfo.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT; - if (!single) { + if (single) { + int action = mWebView.nativeTextFieldAction(); + switch (action) { + // Keep in sync with CachedRoot::ImeAction + case 0: // NEXT + setImeOptions(EditorInfo.IME_ACTION_NEXT); + break; + case 1: // GO + setImeOptions(EditorInfo.IME_ACTION_GO); + break; + case -1: // FAILURE + case 2: // DONE + setImeOptions(EditorInfo.IME_ACTION_DONE); + break; + } + } else { inputType |= EditorInfo.TYPE_TEXT_FLAG_MULTI_LINE | EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES | EditorInfo.TYPE_TEXT_FLAG_AUTO_CORRECT; + setImeOptions(EditorInfo.IME_ACTION_NONE); } mSingle = single; setHorizontallyScrolling(single); @@ -551,8 +739,8 @@ import java.util.ArrayList; } /** - * Set the text for this TextDialog, and set the selection to (start, end) - * @param text Text to go into this TextDialog. + * Set the text for this WebTextView, and set the selection to (start, end) + * @param text Text to go into this WebTextView. * @param start Beginning of the selection. * @param end End of the selection. */ @@ -569,6 +757,10 @@ import java.util.ArrayList; } else if (start > length) { start = length; } + if (DebugFlags.WEB_TEXT_VIEW) { + Log.v(LOGTAG, "setText start=" + start + + " end=" + end); + } Selection.setSelection(span, start, end); } @@ -583,7 +775,7 @@ import java.util.ArrayList; edit.replace(0, edit.length(), text); updateCachedTextfield(); } - + /** * Update the cache to reflect the current text. */ diff --git a/core/java/android/webkit/WebView.java b/core/java/android/webkit/WebView.java index 6936435..f49aab1 100644 --- a/core/java/android/webkit/WebView.java +++ b/core/java/android/webkit/WebView.java @@ -58,7 +58,7 @@ import android.view.ViewParent; import android.view.ViewTreeObserver; import android.view.animation.AlphaAnimation; import android.view.inputmethod.InputMethodManager; -import android.webkit.TextDialog.AutoCompleteAdapter; +import android.webkit.WebTextView.AutoCompleteAdapter; import android.webkit.WebViewCore.EventHub; import android.widget.AbsoluteLayout; import android.widget.Adapter; @@ -80,11 +80,10 @@ import java.io.FileOutputStream; import java.io.IOException; import java.net.URLDecoder; import java.util.ArrayList; -import java.util.HashMap; import java.util.List; /** - * <p>A View that displays web pages. This class is the basis upon which you + * <p>A View that displays web pages. This class is the basis upon which you * can roll your own web browser or simply display some online content within your Activity. * It uses the WebKit rendering engine to display * web pages and includes methods to navigate forward and backward @@ -93,12 +92,109 @@ import java.util.List; * {@link #getSettings() WebSettings}.{@link WebSettings#setBuiltInZoomControls(boolean)} * (introduced in API version 3). * <p>Note that, in order for your Activity to access the Internet and load web pages - * in a WebView, you must add the <var>INTERNET</var> permissions to your + * in a WebView, you must add the <var>INTERNET</var> permissions to your * Android Manifest file:</p> * <pre><uses-permission android:name="android.permission.INTERNET" /></pre> + * * <p>This must be a child of the <code><manifest></code> element.</p> + * + * <h3>Basic usage</h3> + * + * <p>By default, a WebView provides no browser-like widgets, does not + * enable JavaScript and errors will be ignored. If your goal is only + * to display some HTML as a part of your UI, this is probably fine; + * the user won't need to interact with the web page beyond reading + * it, and the web page won't need to interact with the user. If you + * actually want a fully blown web browser, then you probably want to + * invoke the Browser application with your URL rather than show it + * with a WebView. See {@link android.content.Intent} for more information.</p> + * + * <pre class="prettyprint"> + * WebView webview = new WebView(this); + * setContentView(webview); + * + * // Simplest usage: note that an exception will NOT be thrown + * // if there is an error loading this page (see below). + * webview.loadUrl("http://slashdot.org/"); + * + * // Of course you can also load from any string: + * String summary = "<html><body>You scored <b>192</b> points.</body></html>"; + * webview.loadData(summary, "text/html", "utf-8"); + * // ... although note that there are restrictions on what this HTML can do. + * // See the JavaDocs for loadData and loadDataWithBaseUrl for more info. + * </pre> + * + * <p>A WebView has several customization points where you can add your + * own behavior. These are:</p> + * + * <ul> + * <li>Creating and setting a {@link android.webkit.WebChromeClient} subclass. + * This class is called when something that might impact a + * browser UI happens, for instance, progress updates and + * JavaScript alerts are sent here. + * </li> + * <li>Creating and setting a {@link android.webkit.WebViewClient} subclass. + * It will be called when things happen that impact the + * rendering of the content, eg, errors or form submissions. You + * can also intercept URL loading here.</li> + * <li>Via the {@link android.webkit.WebSettings} class, which contains + * miscellaneous configuration. </li> + * <li>With the {@link android.webkit.WebView#addJavascriptInterface} method. + * This lets you bind Java objects into the WebView so they can be + * controlled from the web pages JavaScript.</li> + * </ul> + * + * <p>Here's a more complicated example, showing error handling, + * settings, and progress notification:</p> + * + * <pre class="prettyprint"> + * // Let's display the progress in the activity title bar, like the + * // browser app does. + * getWindow().requestFeature(Window.FEATURE_PROGRESS); + * + * webview.getSettings().setJavaScriptEnabled(true); + * + * final Activity activity = this; + * webview.setWebChromeClient(new WebChromeClient() { + * public void onProgressChanged(WebView view, int progress) { + * // Activities and WebViews measure progress with different scales. + * // The progress meter will automatically disappear when we reach 100% + * activity.setProgress(progress * 1000); + * } + * }); + * webview.setWebViewClient(new WebViewClient() { + * public void onReceivedError(WebView view, int errorCode, String description, String failingUrl) { + * Toast.makeText(activity, "Oh no! " + description, Toast.LENGTH_SHORT).show(); + * } + * }); + * + * webview.loadUrl("http://slashdot.org/"); + * </pre> + * + * <h3>Cookie and window management</h3> + * + * <p>For obvious security reasons, your application has its own + * cache, cookie store etc - it does not share the Browser + * applications data. Cookies are managed on a separate thread, so + * operations like index building don't block the UI + * thread. Follow the instructions in {@link android.webkit.CookieSyncManager} + * if you want to use cookies in your application. + * </p> + * + * <p>By default, requests by the HTML to open new windows are + * ignored. This is true whether they be opened by JavaScript or by + * the target attribute on a link. You can customize your + * WebChromeClient to provide your own behaviour for opening multiple windows, + * and render them in whatever manner you want.</p> + * + * <p>Standard behavior for an Activity is to be destroyed and + * recreated when the devices orientation is changed. This will cause + * the WebView to reload the current page. If you don't want that, you + * can set your Activity to handle the orientation and keyboardHidden + * changes, and then just leave the WebView alone. It'll automatically + * re-orient itself as appropriate.</p> */ -public class WebView extends AbsoluteLayout +public class WebView extends AbsoluteLayout implements ViewTreeObserver.OnGlobalFocusChangeListener, ViewGroup.OnHierarchyChangeListener { @@ -108,62 +204,61 @@ public class WebView extends AbsoluteLayout // true means redraw the screen all-the-time. Only with AUTO_REDRAW_HACK private boolean mAutoRedraw; - // keep debugging parameters near the top of the file static final String LOGTAG = "webview"; - static final boolean DEBUG = false; - static final boolean LOGV_ENABLED = DEBUG; - private class ExtendedZoomControls extends FrameLayout { + private static class ExtendedZoomControls extends FrameLayout { public ExtendedZoomControls(Context context, AttributeSet attrs) { super(context, attrs); LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); inflater.inflate(com.android.internal.R.layout.zoom_magnify, this, true); - mZoomControls = (ZoomControls) findViewById(com.android.internal.R.id.zoomControls); + mPlusMinusZoomControls = (ZoomControls) findViewById( + com.android.internal.R.id.zoomControls); mZoomMagnify = (ImageView) findViewById(com.android.internal.R.id.zoomMagnify); } - + public void show(boolean showZoom, boolean canZoomOut) { - mZoomControls.setVisibility(showZoom ? View.VISIBLE : View.GONE); + mPlusMinusZoomControls.setVisibility( + showZoom ? View.VISIBLE : View.GONE); mZoomMagnify.setVisibility(canZoomOut ? View.VISIBLE : View.GONE); fade(View.VISIBLE, 0.0f, 1.0f); } - + public void hide() { fade(View.GONE, 1.0f, 0.0f); } - + private void fade(int visibility, float startAlpha, float endAlpha) { AlphaAnimation anim = new AlphaAnimation(startAlpha, endAlpha); anim.setDuration(500); startAnimation(anim); setVisibility(visibility); } - + public void setIsZoomMagnifyEnabled(boolean isEnabled) { mZoomMagnify.setEnabled(isEnabled); } - + public boolean hasFocus() { - return mZoomControls.hasFocus() || mZoomMagnify.hasFocus(); + return mPlusMinusZoomControls.hasFocus() || mZoomMagnify.hasFocus(); } - + public void setOnZoomInClickListener(OnClickListener listener) { - mZoomControls.setOnZoomInClickListener(listener); + mPlusMinusZoomControls.setOnZoomInClickListener(listener); } - + public void setOnZoomOutClickListener(OnClickListener listener) { - mZoomControls.setOnZoomOutClickListener(listener); + mPlusMinusZoomControls.setOnZoomOutClickListener(listener); } - + public void setOnZoomMagnifyClickListener(OnClickListener listener) { mZoomMagnify.setOnClickListener(listener); } - ZoomControls mZoomControls; - ImageView mZoomMagnify; + ZoomControls mPlusMinusZoomControls; + ImageView mZoomMagnify; } - + /** * Transportation object for returning WebView across thread boundaries. */ @@ -203,13 +298,13 @@ public class WebView extends AbsoluteLayout private WebViewCore mWebViewCore; // Handler for dispatching UI messages. /* package */ final Handler mPrivateHandler = new PrivateHandler(); - private TextDialog mTextEntry; + private WebTextView mWebTextView; // Used to ignore changes to webkit text that arrives to the UI side after // more key events. private int mTextGeneration; - // The list of loaded plugins. - private static PluginList sPluginList; + // Used by WebViewCore to create child views. + /* package */ final ViewManager mViewManager; /** * Position of the last touch event. @@ -229,9 +324,18 @@ public class WebView extends AbsoluteLayout /** * The minimum elapsed time before sending another ACTION_MOVE event to - * WebViewCore + * WebViewCore. This really should be tuned for each type of the devices. + * For example in Google Map api test case, it takes Dream device at least + * 150ms to do a full cycle in the WebViewCore by processing a touch event, + * triggering the layout and drawing the picture. While the same process + * takes 60+ms on the current high speed device. If we make + * TOUCH_SENT_INTERVAL too small, there will be multiple touch events sent + * to WebViewCore queue and the real layout and draw events will be pushed + * to further, which slows down the refresh rate. Choose 50 to favor the + * current high speed devices. For Dream like devices, 100 is a better + * choice. Maybe make this in the buildspec later. */ - private static final int TOUCH_SENT_INTERVAL = 100; + private static final int TOUCH_SENT_INTERVAL = 50; /** * Helper class to get velocity for fling @@ -239,6 +343,9 @@ public class WebView extends AbsoluteLayout VelocityTracker mVelocityTracker; private int mMaximumFling; + // use this flag to control whether enabling the new double tap zoom + static final boolean ENABLE_DOUBLETAP_ZOOM = true; + /** * Touch mode */ @@ -258,6 +365,7 @@ public class WebView extends AbsoluteLayout private static final int SCROLL_ZOOM_OUT = 11; private static final int LAST_SCROLL_ZOOM = 11; // end of touch mode values specific to scale+scroll + private static final int TOUCH_DOUBLE_TAP_MODE = 12; // Whether to forward the touch events to WebCore private boolean mForwardTouchEvents = false; @@ -267,18 +375,23 @@ public class WebView extends AbsoluteLayout // take control of touch events unless it says no for touch down event. private boolean mPreventDrag; - // If updateTextEntry gets called while we are out of focus, use this - // variable to remember to do it next time we gain focus. - private boolean mNeedsUpdateTextEntry = false; - - // Whether or not to draw the focus ring. - private boolean mDrawFocusRing = true; + // To keep track of whether the current drag was initiated by a WebTextView, + // so that we know not to hide the cursor + boolean mDragFromTextInput; + + // Whether or not to draw the cursor ring. + private boolean mDrawCursorRing = true; + + // true if onPause has been called (and not onResume) + private boolean mIsPaused; /** * Customizable constant */ // pre-computed square of ViewConfiguration.getScaledTouchSlop() private int mTouchSlopSquare; + // pre-computed square of ViewConfiguration.getScaledDoubleTapSlop() + private int mDoubleTapSlopSquare; // pre-computed density adjusted navigation slop private int mNavSlop; // This should be ViewConfiguration.getTapTimeout() @@ -292,7 +405,7 @@ public class WebView extends AbsoluteLayout // needed to avoid flinging after a pause of no movement private static final int MIN_FLING_TIME = 250; // The time that the Zoom Controls are visible before fading away - private static final long ZOOM_CONTROLS_TIMEOUT = + private static final long ZOOM_CONTROLS_TIMEOUT = ViewConfiguration.getZoomControlsTimeout(); // The amount of content to overlap between two screens when going through // pages with the space bar, in pixels. @@ -313,7 +426,7 @@ public class WebView extends AbsoluteLayout private int mContentWidth; // cache of value from WebViewCore private int mContentHeight; // cache of value from WebViewCore - // Need to have the separate control for horizontal and vertical scrollbar + // Need to have the separate control for horizontal and vertical scrollbar // style than the View's single scrollbar style private boolean mOverlayHorizontalScrollbar = true; private boolean mOverlayVerticalScrollbar = false; @@ -328,51 +441,49 @@ public class WebView extends AbsoluteLayout private boolean mWrapContent; - // true if we should call webcore to draw the content, false means we have - // requested something but it isn't ready to draw yet. - private WebViewCore.FocusData mFocusData; /** * Private message ids */ - private static final int REMEMBER_PASSWORD = 1; - private static final int NEVER_REMEMBER_PASSWORD = 2; - private static final int SWITCH_TO_SHORTPRESS = 3; - private static final int SWITCH_TO_LONGPRESS = 4; - private static final int UPDATE_TEXT_ENTRY_ADAPTER = 6; - private static final int SWITCH_TO_ENTER = 7; - private static final int RESUME_WEBCORE_UPDATE = 8; + private static final int REMEMBER_PASSWORD = 1; + private static final int NEVER_REMEMBER_PASSWORD = 2; + private static final int SWITCH_TO_SHORTPRESS = 3; + private static final int SWITCH_TO_LONGPRESS = 4; + private static final int RELEASE_SINGLE_TAP = 5; + private static final int REQUEST_FORM_DATA = 6; + private static final int SWITCH_TO_CLICK = 7; + private static final int RESUME_WEBCORE_UPDATE = 8; //! arg1=x, arg2=y - static final int SCROLL_TO_MSG_ID = 10; - static final int SCROLL_BY_MSG_ID = 11; + static final int SCROLL_TO_MSG_ID = 10; + static final int SCROLL_BY_MSG_ID = 11; //! arg1=x, arg2=y - static final int SPAWN_SCROLL_TO_MSG_ID = 12; + static final int SPAWN_SCROLL_TO_MSG_ID = 12; //! arg1=x, arg2=y - static final int SYNC_SCROLL_TO_MSG_ID = 13; - static final int NEW_PICTURE_MSG_ID = 14; - static final int UPDATE_TEXT_ENTRY_MSG_ID = 15; - static final int WEBCORE_INITIALIZED_MSG_ID = 16; - static final int UPDATE_TEXTFIELD_TEXT_MSG_ID = 17; - static final int DID_FIRST_LAYOUT_MSG_ID = 18; - static final int RECOMPUTE_FOCUS_MSG_ID = 19; - static final int NOTIFY_FOCUS_SET_MSG_ID = 20; - static final int MARK_NODE_INVALID_ID = 21; - static final int UPDATE_CLIPBOARD = 22; - static final int LONG_PRESS_ENTER = 23; - static final int PREVENT_TOUCH_ID = 24; - static final int WEBCORE_NEED_TOUCH_EVENTS = 25; + static final int SYNC_SCROLL_TO_MSG_ID = 13; + static final int NEW_PICTURE_MSG_ID = 14; + static final int UPDATE_TEXT_ENTRY_MSG_ID = 15; + static final int WEBCORE_INITIALIZED_MSG_ID = 16; + static final int UPDATE_TEXTFIELD_TEXT_MSG_ID = 17; + static final int MOVE_OUT_OF_PLUGIN = 19; + static final int CLEAR_TEXT_ENTRY = 20; + static final int UPDATE_TEXT_SELECTION_MSG_ID = 21; + static final int UPDATE_CLIPBOARD = 22; + static final int LONG_PRESS_CENTER = 23; + static final int PREVENT_TOUCH_ID = 24; + static final int WEBCORE_NEED_TOUCH_EVENTS = 25; // obj=Rect in doc coordinates - static final int INVAL_RECT_MSG_ID = 26; - + static final int INVAL_RECT_MSG_ID = 26; + static final int REQUEST_KEYBOARD = 27; + static final String[] HandlerDebugString = { - "REMEMBER_PASSWORD", // = 1; - "NEVER_REMEMBER_PASSWORD", // = 2; - "SWITCH_TO_SHORTPRESS", // = 3; - "SWITCH_TO_LONGPRESS", // = 4; - "5", - "UPDATE_TEXT_ENTRY_ADAPTER", // = 6; - "SWITCH_TO_ENTER", // = 7; - "RESUME_WEBCORE_UPDATE", // = 8; + "REMEMBER_PASSWORD", // = 1; + "NEVER_REMEMBER_PASSWORD", // = 2; + "SWITCH_TO_SHORTPRESS", // = 3; + "SWITCH_TO_LONGPRESS", // = 4; + "RELEASE_SINGLE_TAP", // = 5; + "REQUEST_FORM_DATA", // = 6; + "SWITCH_TO_CLICK", // = 7; + "RESUME_WEBCORE_UPDATE", // = 8; "9", "SCROLL_TO_MSG_ID", // = 10; "SCROLL_BY_MSG_ID", // = 11; @@ -382,31 +493,40 @@ public class WebView extends AbsoluteLayout "UPDATE_TEXT_ENTRY_MSG_ID", // = 15; "WEBCORE_INITIALIZED_MSG_ID", // = 16; "UPDATE_TEXTFIELD_TEXT_MSG_ID", // = 17; - "DID_FIRST_LAYOUT_MSG_ID", // = 18; - "RECOMPUTE_FOCUS_MSG_ID", // = 19; - "NOTIFY_FOCUS_SET_MSG_ID", // = 20; - "MARK_NODE_INVALID_ID", // = 21; + "18", // = 18; + "MOVE_OUT_OF_PLUGIN", // = 19; + "CLEAR_TEXT_ENTRY", // = 20; + "UPDATE_TEXT_SELECTION_MSG_ID", // = 21; "UPDATE_CLIPBOARD", // = 22; - "LONG_PRESS_ENTER", // = 23; + "LONG_PRESS_CENTER", // = 23; "PREVENT_TOUCH_ID", // = 24; "WEBCORE_NEED_TOUCH_EVENTS", // = 25; - "INVAL_RECT_MSG_ID" // = 26; + "INVAL_RECT_MSG_ID", // = 26; + "REQUEST_KEYBOARD" // = 27; }; - // width which view is considered to be fully zoomed out - static final int ZOOM_OUT_WIDTH = 1008; - // default scale limit. Depending on the display density private static float DEFAULT_MAX_ZOOM_SCALE; private static float DEFAULT_MIN_ZOOM_SCALE; // scale limit, which can be set through viewport meta tag in the web page private float mMaxZoomScale; private float mMinZoomScale; - private boolean mMinZoomScaleFixed = false; + private boolean mMinZoomScaleFixed = true; // initial scale in percent. 0 means using default. private int mInitialScale = 0; + // while in the zoom overview mode, the page's width is fully fit to the + // current window. The page is alive, in another words, you can click to + // follow the links. Double tap will toggle between zoom overview mode and + // the last zoom scale. + boolean mInZoomOverview = false; + + // ideally mZoomOverviewWidth should be mContentWidth. But sites like espn, + // engadget always have wider mContentWidth no matter what viewport size is. + int mZoomOverviewWidth = WebViewCore.DEFAULT_VIEWPORT_WIDTH; + float mLastScale; + // default scale. Depending on the display density. static int DEFAULT_SCALE_PERCENT; private float mDefaultScale; @@ -421,6 +541,8 @@ public class WebView extends AbsoluteLayout private float mZoomScale; private float mInvInitialZoomScale; private float mInvFinalZoomScale; + private int mInitialScrollX; + private int mInitialScrollY; private long mZoomStart; private static final int ZOOM_ANIMATION_LENGTH = 500; @@ -433,7 +555,7 @@ public class WebView extends AbsoluteLayout private static final int SNAP_X_LOCK = 4; private static final int SNAP_Y_LOCK = 5; private boolean mSnapPositive; - + // Used to match key downs and key ups private boolean mGotKeyDown; @@ -456,7 +578,7 @@ public class WebView extends AbsoluteLayout * URI scheme for map address */ public static final String SCHEME_GEO = "geo:0,0?q="; - + private int mBackgroundColor = Color.WHITE; // Used to notify listeners of a new picture. @@ -473,7 +595,8 @@ public class WebView extends AbsoluteLayout public void onNewPicture(WebView view, Picture picture); } - public class HitTestResult { + // FIXME: Want to make this public, but need to change the API file. + public /*static*/ class HitTestResult { /** * Default HitTestResult, where the target is unknown */ @@ -543,8 +666,7 @@ public class WebView extends AbsoluteLayout private ExtendedZoomControls mZoomControls; private Runnable mZoomControlRunnable; - private ZoomButtonsController mZoomButtonsController; - private ImageView mZoomOverviewButton; + private ZoomButtonsController mZoomButtonsController; // These keep track of the center point of the zoom. They are used to // determine the point around which we should zoom. @@ -567,11 +689,11 @@ public class WebView extends AbsoluteLayout } else { zoomOut(); } - + updateZoomButtonsEnabled(); } }; - + /** * Construct a new WebView with a Context object. * @param context A Context object used to access application assets. @@ -602,18 +724,10 @@ public class WebView extends AbsoluteLayout mCallbackProxy = new CallbackProxy(context, this); mWebViewCore = new WebViewCore(context, this, mCallbackProxy); mDatabase = WebViewDatabase.getInstance(context); - mFocusData = new WebViewCore.FocusData(); - mFocusData.mFrame = 0; - mFocusData.mNode = 0; - mFocusData.mX = 0; - mFocusData.mY = 0; mScroller = new Scroller(context); - initZoomController(context); - } + mViewManager = new ViewManager(this); - private void initZoomController(Context context) { - // Create the buttons controller mZoomButtonsController = new ZoomButtonsController(this); mZoomButtonsController.setOnZoomListener(mZoomListener); // ZoomButtonsController positions the buttons at the bottom, but in @@ -626,30 +740,11 @@ public class WebView extends AbsoluteLayout params; frameParams.gravity = Gravity.RIGHT; } - - // Create the accessory buttons - LayoutInflater inflater = - (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); - ViewGroup container = mZoomButtonsController.getContainer(); - inflater.inflate(com.android.internal.R.layout.zoom_browser_accessory_buttons, container); - mZoomOverviewButton = - (ImageView) container.findViewById(com.android.internal.R.id.zoom_page_overview); - mZoomOverviewButton.setOnClickListener( - new View.OnClickListener() { - public void onClick(View v) { - mZoomButtonsController.setVisible(false); - zoomScrollOut(); - if (mLogEvent) { - Checkin.updateStats(mContext.getContentResolver(), - Checkin.Stats.Tag.BROWSER_ZOOM_OVERVIEW, 1, 0.0); - } - } - }); } private void updateZoomButtonsEnabled() { boolean canZoomIn = mActualScale < mMaxZoomScale; - boolean canZoomOut = mActualScale > mMinZoomScale; + boolean canZoomOut = mActualScale > mMinZoomScale && !mInZoomOverview; if (!canZoomIn && !canZoomOut) { // Hide the zoom in and out buttons, as well as the fit to page // button, if the page cannot zoom @@ -663,8 +758,6 @@ public class WebView extends AbsoluteLayout mZoomButtonsController.setZoomInEnabled(canZoomIn); mZoomButtonsController.setZoomOutEnabled(canZoomOut); } - mZoomOverviewButton.setVisibility(canZoomScrollOut() ? View.VISIBLE: - View.GONE); } private void init() { @@ -675,9 +768,11 @@ public class WebView extends AbsoluteLayout setLongClickable(true); final ViewConfiguration configuration = ViewConfiguration.get(getContext()); - final int slop = configuration.getScaledTouchSlop(); + int slop = configuration.getScaledTouchSlop(); mTouchSlopSquare = slop * slop; mMinLockSnapReverseDistance = slop; + slop = configuration.getScaledDoubleTapSlop(); + mDoubleTapSlopSquare = slop * slop; final float density = getContext().getResources().getDisplayMetrics().density; // use one line height, 16 based on our current default font, for how // far we allow a touch be away from the edge of a link @@ -899,7 +994,7 @@ public class WebView extends AbsoluteLayout clearTextEntry(); if (mWebViewCore != null) { // Set the handlers to null before destroying WebViewCore so no - // more messages will be posted. + // more messages will be posted. mCallbackProxy.setWebViewClient(null); mCallbackProxy.setWebChromeClient(null); // Tell WebViewCore to destroy itself @@ -930,12 +1025,23 @@ public class WebView extends AbsoluteLayout /** * If platform notifications are enabled, this should be called - * from onPause() or onStop(). + * from the Activity's onPause() or onStop(). */ public static void disablePlatformNotifications() { Network.disablePlatformNotifications(); } - + + /** + * Sets JavaScript engine flags. + * + * @param flags JS engine flags in a String + * + * @hide pending API solidification + */ + public void setJsFlags(String flags) { + mWebViewCore.sendMessage(EventHub.SET_JS_FLAGS, flags); + } + /** * Inform WebView of the network state. This is used to set * the javascript property window.navigator.isOnline and @@ -948,7 +1054,7 @@ public class WebView extends AbsoluteLayout } /** - * Save the state of this WebView used in + * Save the state of this WebView used in * {@link android.app.Activity#onSaveInstanceState}. Please note that this * method no longer stores the display data for this WebView. The previous * behavior could potentially leak files if {@link #restoreState} was never @@ -1026,6 +1132,9 @@ public class WebView extends AbsoluteLayout b.putInt("scrollX", mScrollX); b.putInt("scrollY", mScrollY); b.putFloat("scale", mActualScale); + if (mInZoomOverview) { + b.putFloat("lastScale", mLastScale); + } return true; } return false; @@ -1070,6 +1179,13 @@ public class WebView extends AbsoluteLayout // onSizeChanged() is called, the rest will be set // correctly mActualScale = scale; + float lastScale = b.getFloat("lastScale", -1.0f); + if (lastScale > 0) { + mInZoomOverview = true; + mLastScale = lastScale; + } else { + mInZoomOverview = false; + } invalidate(); return true; } @@ -1079,10 +1195,10 @@ public class WebView extends AbsoluteLayout /** * Restore the state of this WebView from the given map used in - * {@link android.app.Activity#onRestoreInstanceState}. This method should - * be called to restore the state of the WebView before using the object. If - * it is called after the WebView has had a chance to build state (load - * pages, create a back/forward list, etc.) there may be undesirable + * {@link android.app.Activity#onRestoreInstanceState}. This method should + * be called to restore the state of the WebView before using the object. If + * it is called after the WebView has had a chance to build state (load + * pages, create a back/forward list, etc.) there may be undesirable * side-effects. Please note that this method no longer restores the * display data for this WebView. See {@link #savePicture} and {@link * #restorePicture} for saving and restoring the display data. @@ -1143,6 +1259,9 @@ public class WebView extends AbsoluteLayout * @param url The url of the resource to load. */ public void loadUrl(String url) { + if (url == null) { + return; + } switchOutDrawHistory(); mWebViewCore.sendMessage(EventHub.LOAD_URL, url); clearTextEntry(); @@ -1152,18 +1271,16 @@ public class WebView extends AbsoluteLayout * Load the url with postData using "POST" method into the WebView. If url * is not a network url, it will be loaded with {link * {@link #loadUrl(String)} instead. - * + * * @param url The url of the resource to load. * @param postData The data will be passed to "POST" request. - * - * @hide pending API solidification */ public void postUrl(String url, byte[] postData) { if (URLUtil.isNetworkUrl(url)) { switchOutDrawHistory(); - HashMap arg = new HashMap(); - arg.put("url", url); - arg.put("data", postData); + WebViewCore.PostUrlData arg = new WebViewCore.PostUrlData(); + arg.mUrl = url; + arg.mPostData = postData; mWebViewCore.sendMessage(EventHub.POST_URL, arg); clearTextEntry(); } else { @@ -1197,7 +1314,7 @@ public class WebView extends AbsoluteLayout * able to access asset files. If the baseUrl is anything other than * http(s)/ftp(s)/about/javascript as scheme, you can access asset files for * sub resources. - * + * * @param baseUrl Url to resolve relative paths with, if null defaults to * "about:blank" * @param data A String of data in the given encoding. @@ -1208,18 +1325,18 @@ public class WebView extends AbsoluteLayout */ public void loadDataWithBaseURL(String baseUrl, String data, String mimeType, String encoding, String failUrl) { - + if (baseUrl != null && baseUrl.toLowerCase().startsWith("data:")) { loadData(data, mimeType, encoding); return; } switchOutDrawHistory(); - HashMap arg = new HashMap(); - arg.put("baseUrl", baseUrl); - arg.put("data", data); - arg.put("mimeType", mimeType); - arg.put("encoding", encoding); - arg.put("failUrl", failUrl); + WebViewCore.BaseUrlData arg = new WebViewCore.BaseUrlData(); + arg.mBaseUrl = baseUrl; + arg.mData = data; + arg.mMimeType = mimeType; + arg.mEncoding = encoding; + arg.mFailUrl = failUrl; mWebViewCore.sendMessage(EventHub.LOAD_DATA, arg); clearTextEntry(); } @@ -1329,7 +1446,7 @@ public class WebView extends AbsoluteLayout ignoreSnapshot ? 1 : 0); } } - + private boolean extendScroll(int y) { int finalY = mScroller.getFinalY(); int newY = pinLocY(finalY + y); @@ -1338,7 +1455,7 @@ public class WebView extends AbsoluteLayout mScroller.extendDuration(computeDuration(0, y)); return true; } - + /** * Scroll the contents of the view up by half the view size * @param top true to jump to the top of the page @@ -1348,7 +1465,7 @@ public class WebView extends AbsoluteLayout if (mNativeClass == 0) { return false; } - nativeClearFocus(-1, -1); + nativeClearCursor(); // start next trackball movement from page edge if (top) { // go to the top of the document return pinScrollTo(mScrollX, 0, true, 0); @@ -1362,10 +1479,10 @@ public class WebView extends AbsoluteLayout y = -h / 2; } mUserScroll = true; - return mScroller.isFinished() ? pinScrollBy(0, y, true, 0) + return mScroller.isFinished() ? pinScrollBy(0, y, true, 0) : extendScroll(y); } - + /** * Scroll the contents of the view down by half the page size * @param bottom true to jump to bottom of page @@ -1375,7 +1492,7 @@ public class WebView extends AbsoluteLayout if (mNativeClass == 0) { return false; } - nativeClearFocus(-1, -1); + nativeClearCursor(); // start next trackball movement from page edge if (bottom) { return pinScrollTo(mScrollX, mContentHeight, true, 0); } @@ -1388,7 +1505,7 @@ public class WebView extends AbsoluteLayout y = h / 2; } mUserScroll = true; - return mScroller.isFinished() ? pinScrollBy(0, y, true, 0) + return mScroller.isFinished() ? pinScrollBy(0, y, true, 0) : extendScroll(y); } @@ -1401,7 +1518,7 @@ public class WebView extends AbsoluteLayout mContentHeight = 0; mWebViewCore.sendMessage(EventHub.CLEAR_CONTENT); } - + /** * Return a new picture that captures the current display of the webview. * This is a copy of the display, and will be unaffected if the webview @@ -1412,7 +1529,7 @@ public class WebView extends AbsoluteLayout * bounds of the view. */ public Picture capturePicture() { - if (null == mWebViewCore) return null; // check for out of memory tab + if (null == mWebViewCore) return null; // check for out of memory tab return mWebViewCore.copyContentPicture(); } @@ -1420,17 +1537,17 @@ public class WebView extends AbsoluteLayout * Return true if the browser is displaying a TextView for text input. */ private boolean inEditingMode() { - return mTextEntry != null && mTextEntry.getParent() != null - && mTextEntry.hasFocus(); + return mWebTextView != null && mWebTextView.getParent() != null + && mWebTextView.hasFocus(); } private void clearTextEntry() { if (inEditingMode()) { - mTextEntry.remove(); + mWebTextView.remove(); } } - /** + /** * Return the current scale of the WebView * @return The current scale. */ @@ -1471,7 +1588,7 @@ public class WebView extends AbsoluteLayout } /** - * Return a HitTestResult based on the current focus node. If a HTML::a tag + * Return a HitTestResult based on the current cursor node. If a HTML::a tag * is found and the anchor has a non-javascript url, the HitTestResult type * is set to SRC_ANCHOR_TYPE and the url is set in the "extra" field. If the * anchor does not have a url or if it is a javascript url, the type will @@ -1494,26 +1611,26 @@ public class WebView extends AbsoluteLayout } HitTestResult result = new HitTestResult(); - - if (nativeUpdateFocusNode()) { - FocusNode node = mFocusNode; - if (node.mIsTextField || node.mIsTextArea) { + if (nativeHasCursorNode()) { + if (nativeCursorIsTextInput()) { result.setType(HitTestResult.EDIT_TEXT_TYPE); - } else if (node.mText != null) { - String text = node.mText; - if (text.startsWith(SCHEME_TEL)) { - result.setType(HitTestResult.PHONE_TYPE); - result.setExtra(text.substring(SCHEME_TEL.length())); - } else if (text.startsWith(SCHEME_MAILTO)) { - result.setType(HitTestResult.EMAIL_TYPE); - result.setExtra(text.substring(SCHEME_MAILTO.length())); - } else if (text.startsWith(SCHEME_GEO)) { - result.setType(HitTestResult.GEO_TYPE); - result.setExtra(URLDecoder.decode(text - .substring(SCHEME_GEO.length()))); - } else if (node.mIsAnchor) { - result.setType(HitTestResult.SRC_ANCHOR_TYPE); - result.setExtra(text); + } else { + String text = nativeCursorText(); + if (text != null) { + if (text.startsWith(SCHEME_TEL)) { + result.setType(HitTestResult.PHONE_TYPE); + result.setExtra(text.substring(SCHEME_TEL.length())); + } else if (text.startsWith(SCHEME_MAILTO)) { + result.setType(HitTestResult.EMAIL_TYPE); + result.setExtra(text.substring(SCHEME_MAILTO.length())); + } else if (text.startsWith(SCHEME_GEO)) { + result.setType(HitTestResult.GEO_TYPE); + result.setExtra(URLDecoder.decode(text + .substring(SCHEME_GEO.length()))); + } else if (nativeCursorIsAnchor()) { + result.setType(HitTestResult.SRC_ANCHOR_TYPE); + result.setExtra(text); + } } } } @@ -1525,8 +1642,8 @@ public class WebView extends AbsoluteLayout int contentY = viewToContent((int) mLastTouchY + mScrollY); String text = nativeImageURI(contentX, contentY); if (text != null) { - result.setType(type == HitTestResult.UNKNOWN_TYPE ? - HitTestResult.IMAGE_TYPE : + result.setType(type == HitTestResult.UNKNOWN_TYPE ? + HitTestResult.IMAGE_TYPE : HitTestResult.SRC_IMAGE_ANCHOR_TYPE); result.setExtra(text); } @@ -1538,31 +1655,29 @@ public class WebView extends AbsoluteLayout * Request the href of an anchor element due to getFocusNodePath returning * "href." If hrefMsg is null, this method returns immediately and does not * dispatch hrefMsg to its target. - * + * * @param hrefMsg This message will be dispatched with the result of the * request as the data member with "url" as key. The result can * be null. */ + // FIXME: API change required to change the name of this function. We now + // look at the cursor node, and not the focus node. Also, what is + // getFocusNodePath? public void requestFocusNodeHref(Message hrefMsg) { if (hrefMsg == null || mNativeClass == 0) { return; } - if (nativeUpdateFocusNode()) { - FocusNode node = mFocusNode; - if (node.mIsAnchor) { - // NOTE: We may already have the url of the anchor stored in - // node.mText but it may be out of date or the caller may want - // to know about javascript urls. - mWebViewCore.sendMessage(EventHub.REQUEST_FOCUS_HREF, - node.mFramePointer, node.mNodePointer, hrefMsg); - } + if (nativeCursorIsAnchor()) { + mWebViewCore.sendMessage(EventHub.REQUEST_CURSOR_HREF, + nativeCursorFramePointer(), nativeCursorNodePointer(), + hrefMsg); } } - + /** * Request the url of the image last touched by the user. msg will be sent * to its target with a String representing the url as its object. - * + * * @param msg This message will be dispatched with the result of the request * as the data member with "url" as key. The result can be null. */ @@ -1606,7 +1721,7 @@ public class WebView extends AbsoluteLayout return Math.round(x * mInvActualScale); } - private int contentToView(int x) { + /*package*/ int contentToView(int x) { return Math.round(x * mActualScale); } @@ -1637,7 +1752,7 @@ public class WebView extends AbsoluteLayout if ((w | h) == 0) { return; } - + // don't abort a scroll animation if we didn't change anything if (mContentWidth != w || mContentHeight != h) { // record new dimensions @@ -1697,7 +1812,10 @@ public class WebView extends AbsoluteLayout mActualScale = scale; mInvActualScale = 1 / scale; - // as we don't have animation for scaling, don't do animation + // Scale all the child views + mViewManager.scaleAll(); + + // as we don't have animation for scaling, don't do animation // for scrolling, as it causes weird intermediate state // pinScrollTo(Math.round(sx), Math.round(sy)); mScrollX = pinLocX(Math.round(sx)); @@ -1718,18 +1836,21 @@ public class WebView extends AbsoluteLayout private Rect sendOurVisibleRect() { Rect rect = new Rect(); calcOurContentVisibleRect(rect); - if (mFindIsUp) { - rect.bottom -= viewToContent(FIND_HEIGHT); - } // Rect.equals() checks for null input. if (!rect.equals(mLastVisibleRectSent)) { + Point pos = new Point(rect.left, rect.top); mWebViewCore.sendMessage(EventHub.SET_SCROLL_OFFSET, - rect.left, rect.top); + nativeMoveGeneration(), 0, pos); mLastVisibleRectSent = rect; } Rect globalRect = new Rect(); if (getGlobalVisibleRect(globalRect) && !globalRect.equals(mLastGlobalRect)) { + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "sendOurVisibleRect=(" + globalRect.left + "," + + globalRect.top + ",r=" + globalRect.right + ",b=" + + globalRect.bottom); + } // TODO: the global offset is only used by windowRect() // in ChromeClientAndroid ; other clients such as touch // and mouse events could return view + screen relative points. @@ -1744,6 +1865,9 @@ public class WebView extends AbsoluteLayout Point p = new Point(); getGlobalVisibleRect(r, p); r.offset(-p.x, -p.y); + if (mFindIsUp) { + r.bottom -= FIND_HEIGHT; + } } // Sets r to be our visible rectangle in content coordinates @@ -1755,6 +1879,13 @@ public class WebView extends AbsoluteLayout r.bottom = viewToContent(r.bottom); } + static class ViewSizeData { + int mWidth; + int mHeight; + int mTextWrapWidth; + float mScale; + } + /** * Compute unzoomed width and height, and if they differ from the last * values we sent, send them to webkit (to be used has new viewport) @@ -1762,7 +1893,8 @@ public class WebView extends AbsoluteLayout * @return true if new values were sent */ private boolean sendViewSizeZoom() { - int newWidth = Math.round(getViewWidth() * mInvActualScale); + int viewWidth = getViewWidth(); + int newWidth = Math.round(viewWidth * mInvActualScale); int newHeight = Math.round(getViewHeight() * mInvActualScale); /* * Because the native side may have already done a layout before the @@ -1777,8 +1909,16 @@ public class WebView extends AbsoluteLayout } // Avoid sending another message if the dimensions have not changed. if (newWidth != mLastWidthSent || newHeight != mLastHeightSent) { - mWebViewCore.sendMessage(EventHub.VIEW_SIZE_CHANGED, - newWidth, newHeight, new Float(mActualScale)); + ViewSizeData data = new ViewSizeData(); + data.mWidth = newWidth; + data.mHeight = newHeight; + // while in zoom overview mode, the text are wrapped to the screen + // width matching mLastScale. So that we don't trigger re-flow while + // toggling between overview mode and normal mode. + data.mTextWrapWidth = mInZoomOverview ? Math.round(viewWidth + / mLastScale) : newWidth; + data.mScale = mActualScale; + mWebViewCore.sendMessage(EventHub.VIEW_SIZE_CHANGED, data); mLastWidthSent = newWidth; mLastHeightSent = newHeight; return true; @@ -1821,10 +1961,10 @@ public class WebView extends AbsoluteLayout WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem(); return h != null ? h.getUrl() : null; } - + /** - * Get the original url for the current page. This is not always the same - * as the url passed to WebViewClient.onPageStarted because although the + * Get the original url for the current page. This is not always the same + * as the url passed to WebViewClient.onPageStarted because although the * load for that url has begun, the current page may not have changed. * Also, there may have been redirects resulting in a different url to that * originally requested. @@ -1856,13 +1996,22 @@ public class WebView extends AbsoluteLayout } /** + * Get the touch icon url for the apple-touch-icon <link> element. + * @hide + */ + public String getTouchIconUrl() { + WebHistoryItem h = mCallbackProxy.getBackForwardList().getCurrentItem(); + return h != null ? h.getTouchIconUrl() : null; + } + + /** * Get the progress for the current page. * @return The progress for the current page between 0 and 100. */ public int getProgress() { return mCallbackProxy.getProgress(); } - + /** * @return the height of the HTML content. */ @@ -1871,30 +2020,77 @@ public class WebView extends AbsoluteLayout } /** - * Pause all layout, parsing, and javascript timers. This can be useful if - * the WebView is not visible or the application has been paused. + * Pause all layout, parsing, and javascript timers for all webviews. This + * is a global requests, not restricted to just this webview. This can be + * useful if the application has been paused. */ public void pauseTimers() { mWebViewCore.sendMessage(EventHub.PAUSE_TIMERS); } /** - * Resume all layout, parsing, and javascript timers. This will resume - * dispatching all timers. + * Resume all layout, parsing, and javascript timers for all webviews. + * This will resume dispatching all timers. */ public void resumeTimers() { mWebViewCore.sendMessage(EventHub.RESUME_TIMERS); } /** - * Clear the resource cache. This will cause resources to be re-downloaded - * if accessed again. - * <p> - * Note: this really needs to be a static method as it clears cache for all - * WebView. But we need mWebViewCore to send message to WebCore thread, so - * we can't make this static. + * Call this to pause any extra processing associated with this view and + * its associated DOM/plugins/javascript/etc. For example, if the view is + * taken offscreen, this could be called to reduce unnecessary CPU and/or + * network traffic. When the view is again "active", call onResume(). + * + * Note that this differs from pauseTimers(), which affects all views/DOMs + * @hide + */ + public void onPause() { + if (!mIsPaused) { + mIsPaused = true; + mWebViewCore.sendMessage(EventHub.ON_PAUSE); + } + } + + /** + * Call this to balanace a previous call to onPause() + * @hide + */ + public void onResume() { + if (mIsPaused) { + mIsPaused = false; + mWebViewCore.sendMessage(EventHub.ON_RESUME); + } + } + + /** + * Returns true if the view is paused, meaning onPause() was called. Calling + * onResume() sets the paused state back to false. + * @hide + */ + public boolean isPaused() { + return mIsPaused; + } + + /** + * Call this to inform the view that memory is low so that it can + * free any available memory. + * @hide + */ + public void freeMemory() { + mWebViewCore.sendMessage(EventHub.FREE_MEMORY); + } + + /** + * Clear the resource cache. Note that the cache is per-application, so + * this will clear the cache for all WebViews used. + * + * @param includeDiskFiles If false, only the RAM cache is cleared. */ public void clearCache(boolean includeDiskFiles) { + // Note: this really needs to be a static method as it clears cache for all + // WebView. But we need mWebViewCore to send message to WebCore thread, so + // we can't make this static. mWebViewCore.sendMessage(EventHub.CLEAR_CACHE, includeDiskFiles ? 1 : 0, 0); } @@ -1906,7 +2102,7 @@ public class WebView extends AbsoluteLayout public void clearFormData() { if (inEditingMode()) { AutoCompleteAdapter adapter = null; - mTextEntry.setAdapterCustom(adapter); + mWebTextView.setAdapterCustom(adapter); } } @@ -1940,7 +2136,7 @@ public class WebView extends AbsoluteLayout /* * Highlight and scroll to the next occurance of String in findAll. - * Wraps the page infinitely, and scrolls. Must be called after + * Wraps the page infinitely, and scrolls. Must be called after * calling findAll. * * @param forward Direction to search. @@ -1966,11 +2162,8 @@ public class WebView extends AbsoluteLayout // or not we draw the highlights for matches. private boolean mFindIsUp; - private native int nativeFindAll(String findLower, String findUpper); - private native void nativeFindNext(boolean forward); - /** - * Return the first substring consisting of the address of a physical + * Return the first substring consisting of the address of a physical * location. Currently, only addresses in the United States are detected, * and consist of: * - a house number @@ -1983,14 +2176,40 @@ public class WebView extends AbsoluteLayout * All names must be correctly capitalized, and the zip code, if present, * must be valid for the state. The street type must be a standard USPS * spelling or abbreviation. The state or territory must also be spelled - * or abbreviated using USPS standards. The house number may not exceed + * or abbreviated using USPS standards. The house number may not exceed * five digits. * @param addr The string to search for addresses. * * @return the address, or if no address is found, return null. */ public static String findAddress(String addr) { - return WebViewCore.nativeFindAddress(addr); + return findAddress(addr, false); + } + + /** + * @hide + * Return the first substring consisting of the address of a physical + * location. Currently, only addresses in the United States are detected, + * and consist of: + * - a house number + * - a street name + * - a street type (Road, Circle, etc), either spelled out or abbreviated + * - a city name + * - a state or territory, either spelled out or two-letter abbr. + * - an optional 5 digit or 9 digit zip code. + * + * Names are optionally capitalized, and the zip code, if present, + * must be valid for the state. The street type must be a standard USPS + * spelling or abbreviation. The state or territory must also be spelled + * or abbreviated using USPS standards. The house number may not exceed + * five digits. + * @param addr The string to search for addresses. + * @param caseInsensitive addr Set to true to make search ignore case. + * + * @return the address, or if no address is found, return null. + */ + public static String findAddress(String addr, boolean caseInsensitive) { + return WebViewCore.nativeFindAddress(addr, caseInsensitive); } /* @@ -2075,13 +2294,13 @@ public class WebView extends AbsoluteLayout // Scale from content to view coordinates, and pin. // Also called by jni webview.cpp - private void setContentScrollBy(int cx, int cy, boolean animate) { + private boolean setContentScrollBy(int cx, int cy, boolean animate) { if (mDrawHistory) { // disallow WebView to change the scroll position as History Picture // is used in the view system. // TODO: as we switchOutDrawHistory when trackball or navigation // keys are hit, this should be safe. Right? - return; + return false; } cx = contentToView(cx); cy = contentToView(cy); @@ -2098,11 +2317,9 @@ public class WebView extends AbsoluteLayout // FIXME: Why do we only scroll horizontally if there is no // vertical scroll? // Log.d(LOGTAG, "setContentScrollBy cy=" + cy); - if (cy == 0 && cx != 0) { - pinScrollBy(cx, 0, animate, 0); - } + return cy == 0 && cx != 0 && pinScrollBy(cx, 0, animate, 0); } else { - pinScrollBy(cx, cy, animate, 0); + return pinScrollBy(cx, cy, animate, 0); } } @@ -2201,6 +2418,16 @@ public class WebView extends AbsoluteLayout } /** + * Gets the chrome handler. + * @return the current WebChromeClient instance. + * + * @hide API council approval. + */ + public WebChromeClient getWebChromeClient() { + return mCallbackProxy.getWebChromeClient(); + } + + /** * Set the Picture listener. This is an interface used to receive * notifications of a new Picture. * @param listener An implementation of WebView.PictureListener. @@ -2245,10 +2472,9 @@ public class WebView extends AbsoluteLayout * @param interfaceName The name to used to expose the class in Javascript */ public void addJavascriptInterface(Object obj, String interfaceName) { - // Use Hashmap rather than Bundle as Bundles can't cope with Objects - HashMap arg = new HashMap(); - arg.put("object", obj); - arg.put("interfaceName", interfaceName); + WebViewCore.JSInterfaceData arg = new WebViewCore.JSInterfaceData(); + arg.mObject = obj; + arg.mInterfaceName = interfaceName; mWebViewCore.sendMessage(EventHub.ADD_JS_INTERFACE, arg); } @@ -2265,26 +2491,19 @@ public class WebView extends AbsoluteLayout /** * Return the list of currently loaded plugins. * @return The list of currently loaded plugins. + * + * @deprecated This was used for Gears, which has been deprecated. */ + @Deprecated public static synchronized PluginList getPluginList() { - if (sPluginList == null) { - sPluginList = new PluginList(); - } - return sPluginList; + return null; } /** - * Signal the WebCore thread to refresh its list of plugins. Use - * this if the directory contents of one of the plugin directories - * has been modified and needs its changes reflecting. May cause - * plugin load and/or unload. - * @param reloadOpenPages Set to true to reload all open pages. + * @deprecated This was used for Gears, which has been deprecated. */ - public void refreshPlugins(boolean reloadOpenPages) { - if (mWebViewCore != null) { - mWebViewCore.sendMessage(EventHub.REFRESH_PLUGINS, reloadOpenPages); - } - } + @Deprecated + public void refreshPlugins(boolean reloadOpenPages) { } //------------------------------------------------------------------------- // Override View methods @@ -2292,9 +2511,13 @@ public class WebView extends AbsoluteLayout @Override protected void finalize() throws Throwable { - destroy(); + try { + destroy(); + } finally { + super.finalize(); + } } - + @Override protected void onDraw(Canvas canvas) { // if mNativeClass is 0, the WebView has been destroyed. Do nothing. @@ -2303,7 +2526,7 @@ public class WebView extends AbsoluteLayout } if (mWebViewCore.mEndScaleZoom) { mWebViewCore.mEndScaleZoom = false; - if (mTouchMode >= FIRST_SCROLL_ZOOM + if (mTouchMode >= FIRST_SCROLL_ZOOM && mTouchMode <= LAST_SCROLL_ZOOM) { setHorizontalScrollBarEnabled(true); setVerticalScrollBarEnabled(true); @@ -2314,22 +2537,21 @@ public class WebView extends AbsoluteLayout if (mTouchMode >= FIRST_SCROLL_ZOOM && mTouchMode <= LAST_SCROLL_ZOOM) { scrollZoomDraw(canvas); } else { - nativeRecomputeFocus(); // Update the buttons in the picture, so when we draw the picture // to the screen, they are in the correct state. // Tell the native side if user is a) touching the screen, // b) pressing the trackball down, or c) pressing the enter key - // If the focus is a button, we need to draw it in the pressed + // If the cursor is on a button, we need to draw it in the pressed // state. // If mNativeClass is 0, we should not reach here, so we do not // need to check it again. nativeRecordButtons(hasFocus() && hasWindowFocus(), mTouchMode == TOUCH_SHORTPRESS_START_MODE - || mTrackballDown || mGotEnterDown, false); - drawCoreAndFocusRing(canvas, mBackgroundColor, mDrawFocusRing); + || mTrackballDown || mGotCenterDown, false); + drawCoreAndCursorRing(canvas, mBackgroundColor, mDrawCursorRing); } canvas.restoreToCount(sc); - + if (AUTO_REDRAW_HACK && mAutoRedraw) { invalidate(); } @@ -2345,15 +2567,23 @@ public class WebView extends AbsoluteLayout @Override public boolean performLongClick() { + if (mNativeClass != 0 && nativeCursorIsTextInput()) { + // Send the click so that the textfield is in focus + // FIXME: When we start respecting changes to the native textfield's + // selection, need to make sure that this does not change it. + mWebViewCore.sendMessage(EventHub.CLICK, nativeCursorFramePointer(), + nativeCursorNodePointer()); + rebuildWebTextView(); + } if (inEditingMode()) { - return mTextEntry.performLongClick(); + return mWebTextView.performLongClick(); } else { return super.performLongClick(); } } - private void drawCoreAndFocusRing(Canvas canvas, int color, - boolean drawFocus) { + private void drawCoreAndCursorRing(Canvas canvas, int color, + boolean drawCursorRing) { if (mDrawHistory) { canvas.scale(mActualScale, mActualScale); canvas.drawPicture(mHistoryPicture); @@ -2361,14 +2591,14 @@ public class WebView extends AbsoluteLayout } boolean animateZoom = mZoomScale != 0; - boolean animateScroll = !mScroller.isFinished() + boolean animateScroll = !mScroller.isFinished() || mVelocityTracker != null; if (animateZoom) { float zoomScale; int interval = (int) (SystemClock.uptimeMillis() - mZoomStart); if (interval < ZOOM_ANIMATION_LENGTH) { float ratio = (float) interval / ZOOM_ANIMATION_LENGTH; - zoomScale = 1.0f / (mInvInitialZoomScale + zoomScale = 1.0f / (mInvInitialZoomScale + (mInvFinalZoomScale - mInvInitialZoomScale) * ratio); invalidate(); } else { @@ -2376,24 +2606,15 @@ public class WebView extends AbsoluteLayout // set mZoomScale to be 0 as we have done animation mZoomScale = 0; } - float scale = (mActualScale - zoomScale) * mInvActualScale; - float tx = scale * (mZoomCenterX + mScrollX); - float ty = scale * (mZoomCenterY + mScrollY); - - // this block pins the translate to "legal" bounds. This makes the - // animation a bit non-obvious, but it means we won't pop when the - // "real" zoom takes effect - if (true) { - // canvas.translate(mScrollX, mScrollY); - tx -= mScrollX; - ty -= mScrollY; - tx = -pinLoc(-Math.round(tx), getViewWidth(), Math - .round(mContentWidth * zoomScale)); - ty = -pinLoc(-Math.round(ty), getViewHeight(), Math - .round(mContentHeight * zoomScale)); - tx += mScrollX; - ty += mScrollY; - } + float scale = zoomScale * mInvInitialZoomScale; + int tx = Math.round(scale * (mInitialScrollX + mZoomCenterX) + - mZoomCenterX); + tx = -pinLoc(tx, getViewWidth(), Math.round(mContentWidth + * zoomScale)) + mScrollX; + int ty = Math.round(scale * (mInitialScrollY + mZoomCenterY) + - mZoomCenterY); + ty = -pinLoc(ty, getViewHeight(), Math.round(mContentHeight + * zoomScale)) + mScrollY; canvas.translate(tx, ty); canvas.scale(zoomScale, zoomScale); } else { @@ -2408,10 +2629,10 @@ public class WebView extends AbsoluteLayout if (mTouchSelection) { nativeDrawSelectionRegion(canvas); } else { - nativeDrawSelection(canvas, mSelectX, mSelectY, + nativeDrawSelection(canvas, mSelectX, mSelectY, mExtendSelection); } - } else if (drawFocus) { + } else if (drawCursorRing) { if (mTouchMode == TOUCH_SHORTPRESS_START_MODE) { mTouchMode = TOUCH_SHORTPRESS_MODE; HitTestResult hitTest = getHitTestResult(); @@ -2422,7 +2643,7 @@ public class WebView extends AbsoluteLayout LONG_PRESS_TIMEOUT); } } - nativeDrawFocusRing(canvas); + nativeDrawCursorRing(canvas); } // When the FindDialog is up, only draw the matches if we are not in // the process of scrolling them into view. @@ -2431,14 +2652,12 @@ public class WebView extends AbsoluteLayout } } - private native void nativeDrawMatches(Canvas canvas); - private float scrollZoomGridScale(float invScale) { - float griddedInvScale = (int) (invScale * SCROLL_ZOOM_GRID) + float griddedInvScale = (int) (invScale * SCROLL_ZOOM_GRID) / (float) SCROLL_ZOOM_GRID; return 1.0f / griddedInvScale; } - + private float scrollZoomX(float scale) { int width = getViewWidth(); float maxScrollZoomX = mContentWidth * scale - width; @@ -2454,7 +2673,7 @@ public class WebView extends AbsoluteLayout return -(maxScrollZoomY > 0 ? mZoomScrollY * maxScrollZoomY / maxY : maxScrollZoomY / 2); } - + private void drawMagnifyFrame(Canvas canvas, Rect frame, Paint paint) { final float ADORNMENT_LEN = 16.0f; float width = frame.width(); @@ -2475,13 +2694,13 @@ public class WebView extends AbsoluteLayout path.offset(frame.left, frame.top); canvas.drawPath(path, paint); } - - // Returns frame surrounding magified portion of screen while + + // Returns frame surrounding magified portion of screen while // scroll-zoom is enabled. The frame is also used to center the // zoom-in zoom-out points at the start and end of the animation. private Rect scrollZoomFrame(int width, int height, float halfScale) { Rect scrollFrame = new Rect(); - scrollFrame.set(mZoomScrollX, mZoomScrollY, + scrollFrame.set(mZoomScrollX, mZoomScrollY, mZoomScrollX + width, mZoomScrollY + height); if (mContentWidth * mZoomScrollLimit < width) { float scale = zoomFrameScaleX(width, halfScale, 1.0f); @@ -2497,37 +2716,37 @@ public class WebView extends AbsoluteLayout } return scrollFrame; } - + private float zoomFrameScaleX(int width, float halfScale, float noScale) { // mContentWidth > width > mContentWidth * mZoomScrollLimit if (mContentWidth <= width) { return halfScale; } - float part = (width - mContentWidth * mZoomScrollLimit) + float part = (width - mContentWidth * mZoomScrollLimit) / (width * (1 - mZoomScrollLimit)); return halfScale * part + noScale * (1.0f - part); } - + private float zoomFrameScaleY(int height, float halfScale, float noScale) { if (mContentHeight <= height) { return halfScale; } - float part = (height - mContentHeight * mZoomScrollLimit) + float part = (height - mContentHeight * mZoomScrollLimit) / (height * (1 - mZoomScrollLimit)); return halfScale * part + noScale * (1.0f - part); } - + private float scrollZoomMagScale(float invScale) { return (invScale * 2 + mInvActualScale) / 3; } - + private void scrollZoomDraw(Canvas canvas) { - float invScale = mZoomScrollInvLimit; + float invScale = mZoomScrollInvLimit; int elapsed = 0; if (mTouchMode != SCROLL_ZOOM_OUT) { - elapsed = (int) Math.min(System.currentTimeMillis() + elapsed = (int) Math.min(System.currentTimeMillis() - mZoomScrollStart, SCROLL_ZOOM_DURATION); - float transitionScale = (mZoomScrollInvLimit - mInvActualScale) + float transitionScale = (mZoomScrollInvLimit - mInvActualScale) * elapsed / SCROLL_ZOOM_DURATION; if (mTouchMode == SCROLL_ZOOM_ANIMATION_OUT) { invScale = mInvActualScale + transitionScale; @@ -2545,21 +2764,23 @@ public class WebView extends AbsoluteLayout if (mTouchMode == SCROLL_ZOOM_ANIMATION_IN) { setHorizontalScrollBarEnabled(true); setVerticalScrollBarEnabled(true); - updateTextEntry(); - scrollTo((int) (scrollFrame.centerX() * mActualScale) - - (width >> 1), (int) (scrollFrame.centerY() + rebuildWebTextView(); + scrollTo((int) (scrollFrame.centerX() * mActualScale) + - (width >> 1), (int) (scrollFrame.centerY() * mActualScale) - (height >> 1)); mTouchMode = TOUCH_DONE_MODE; + // Show all the child views once we are done. + mViewManager.showAll(); } else { mTouchMode = SCROLL_ZOOM_OUT; } } float newX = scrollZoomX(scale); float newY = scrollZoomY(scale); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "scrollZoomDraw scale=" + scale + " + (" + newX + ", " + newY + ") mZoomScroll=(" + mZoomScrollX + ", " - + mZoomScrollY + ")" + " invScale=" + invScale + " scale=" + + mZoomScrollY + ")" + " invScale=" + invScale + " scale=" + scale); } canvas.translate(newX, newY); @@ -2603,8 +2824,8 @@ public class WebView extends AbsoluteLayout } canvas.scale(halfScale, halfScale, mZoomScrollX + width * halfX , mZoomScrollY + height * halfY); - if (LOGV_ENABLED) { - Log.v(LOGTAG, "scrollZoomDraw halfScale=" + halfScale + " w/h=(" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "scrollZoomDraw halfScale=" + halfScale + " w/h=(" + width + ", " + height + ") half=(" + halfX + ", " + halfY + ")"); } @@ -2632,14 +2853,17 @@ public class WebView extends AbsoluteLayout , Math.max(0, (int) ((x - left) / scale))); mZoomScrollY = Math.min(mContentHeight - height , Math.max(0, (int) ((y - top) / scale))); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "zoomScrollTap scale=" + scale + " + (" + left + ", " + top + ") mZoomScroll=(" + mZoomScrollX + ", " + mZoomScrollY + ")" + " x=" + x + " y=" + y); } } - private boolean canZoomScrollOut() { + /** + * @hide + */ + public boolean canZoomScrollOut() { if (mContentWidth == 0 || mContentHeight == 0) { return false; } @@ -2649,7 +2873,7 @@ public class WebView extends AbsoluteLayout float y = (float) height / (float) mContentHeight; mZoomScrollLimit = Math.max(DEFAULT_MIN_ZOOM_SCALE, Math.min(x, y)); mZoomScrollInvLimit = 1.0f / mZoomScrollLimit; - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "canZoomScrollOut" + " mInvActualScale=" + mInvActualScale + " mZoomScrollLimit=" + mZoomScrollLimit @@ -2664,7 +2888,7 @@ public class WebView extends AbsoluteLayout return mContentWidth >= width * limit || mContentHeight >= height * limit; } - + private void startZoomScrollOut() { setHorizontalScrollBarEnabled(false); setVerticalScrollBarEnabled(false); @@ -2690,30 +2914,35 @@ public class WebView extends AbsoluteLayout mZoomScrollStart = System.currentTimeMillis(); Rect zoomFrame = scrollZoomFrame(width, height , scrollZoomMagScale(mZoomScrollInvLimit)); - mZoomScrollX = Math.max(0, (int) ((mScrollX + halfW) * mInvActualScale) + mZoomScrollX = Math.max(0, (int) ((mScrollX + halfW) * mInvActualScale) - (zoomFrame.width() >> 1)); - mZoomScrollY = Math.max(0, (int) ((mScrollY + halfH) * mInvActualScale) + mZoomScrollY = Math.max(0, (int) ((mScrollY + halfH) * mInvActualScale) - (zoomFrame.height() >> 1)); scrollTo(0, 0); // triggers inval, starts animation clearTextEntry(); - if (LOGV_ENABLED) { - Log.v(LOGTAG, "startZoomScrollOut mZoomScroll=(" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "startZoomScrollOut mZoomScroll=(" + mZoomScrollX + ", " + mZoomScrollY +")"); } } - - private void zoomScrollOut() { + + /** + * @hide + */ + public void zoomScrollOut() { if (canZoomScrollOut() == false) { mTouchMode = TOUCH_DONE_MODE; return; } + // Hide the child views while in this mode. + mViewManager.hideAll(); startZoomScrollOut(); mTouchMode = SCROLL_ZOOM_ANIMATION_OUT; invalidate(); } private void moveZoomScrollWindow(float x, float y) { - if (Math.abs(x - mLastZoomScrollRawX) < 1.5f + if (Math.abs(x - mLastZoomScrollRawX) < 1.5f && Math.abs(y - mLastZoomScrollRawY) < 1.5f) { return; } @@ -2725,12 +2954,12 @@ public class WebView extends AbsoluteLayout int height = getViewHeight(); int maxZoomX = mContentWidth - width; if (maxZoomX > 0) { - int maxScreenX = width - (int) Math.ceil(width + int maxScreenX = width - (int) Math.ceil(width * mZoomScrollLimit) - SCROLL_ZOOM_FINGER_BUFFER; - if (LOGV_ENABLED) { - Log.v(LOGTAG, "moveZoomScrollWindow-X" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "moveZoomScrollWindow-X" + " maxScreenX=" + maxScreenX + " width=" + width - + " mZoomScrollLimit=" + mZoomScrollLimit + " x=" + x); + + " mZoomScrollLimit=" + mZoomScrollLimit + " x=" + x); } x += maxScreenX * mLastScrollX / maxZoomX - mLastTouchX; x *= Math.max(maxZoomX / maxScreenX, mZoomScrollInvLimit); @@ -2738,12 +2967,12 @@ public class WebView extends AbsoluteLayout } int maxZoomY = mContentHeight - height; if (maxZoomY > 0) { - int maxScreenY = height - (int) Math.ceil(height + int maxScreenY = height - (int) Math.ceil(height * mZoomScrollLimit) - SCROLL_ZOOM_FINGER_BUFFER; - if (LOGV_ENABLED) { - Log.v(LOGTAG, "moveZoomScrollWindow-Y" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "moveZoomScrollWindow-Y" + " maxScreenY=" + maxScreenY + " height=" + height - + " mZoomScrollLimit=" + mZoomScrollLimit + " y=" + y); + + " mZoomScrollLimit=" + mZoomScrollLimit + " y=" + y); } y += maxScreenY * mLastScrollY / maxZoomY - mLastTouchY; y *= Math.max(maxZoomY / maxScreenY, mZoomScrollInvLimit); @@ -2752,12 +2981,12 @@ public class WebView extends AbsoluteLayout if (oldX != mZoomScrollX || oldY != mZoomScrollY) { invalidate(); } - if (LOGV_ENABLED) { - Log.v(LOGTAG, "moveZoomScrollWindow" - + " scrollTo=(" + mZoomScrollX + ", " + mZoomScrollY + ")" - + " mLastTouch=(" + mLastTouchX + ", " + mLastTouchY + ")" - + " maxZoom=(" + maxZoomX + ", " + maxZoomY + ")" - + " last=("+mLastScrollX+", "+mLastScrollY+")" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "moveZoomScrollWindow" + + " scrollTo=(" + mZoomScrollX + ", " + mZoomScrollY + ")" + + " mLastTouch=(" + mLastTouchX + ", " + mLastTouchY + ")" + + " maxZoom=(" + maxZoomX + ", " + maxZoomY + ")" + + " last=("+mLastScrollX+", "+mLastScrollY+")" + " x=" + x + " y=" + y); } } @@ -2802,7 +3031,7 @@ public class WebView extends AbsoluteLayout // Should only be called in UI thread void switchOutDrawHistory() { if (null == mWebViewCore) return; // CallbackProxy may trigger this - if (mDrawHistory) { + if (mDrawHistory && mWebViewCore.pictureReady()) { mDrawHistory = false; invalidate(); int oldScrollX = mScrollX; @@ -2818,72 +3047,29 @@ public class WebView extends AbsoluteLayout } } - /** - * Class representing the node which is focused. - */ - private class FocusNode { - public FocusNode() { - mBounds = new Rect(); - } - // Only to be called by JNI - private void setAll(boolean isTextField, boolean isTextArea, boolean - isPassword, boolean isAnchor, boolean isRtlText, int maxLength, - int textSize, int boundsX, int boundsY, int boundsRight, int - boundsBottom, int nodePointer, int framePointer, String text, - String name, int rootTextGeneration) { - mIsTextField = isTextField; - mIsTextArea = isTextArea; - mIsPassword = isPassword; - mIsAnchor = isAnchor; - mIsRtlText = isRtlText; - - mMaxLength = maxLength; - mTextSize = textSize; - - mBounds.set(boundsX, boundsY, boundsRight, boundsBottom); - - - mNodePointer = nodePointer; - mFramePointer = framePointer; - mText = text; - mName = name; - mRootTextGeneration = rootTextGeneration; - } - public boolean mIsTextField; - public boolean mIsTextArea; - public boolean mIsPassword; - public boolean mIsAnchor; - public boolean mIsRtlText; - - public int mSelectionStart; - public int mSelectionEnd; - public int mMaxLength; - public int mTextSize; - - public Rect mBounds; - - public int mNodePointer; - public int mFramePointer; - public String mText; - public String mName; - public int mRootTextGeneration; - } - - // Warning: ONLY use mFocusNode AFTER calling nativeUpdateFocusNode(), - // and ONLY if it returns true; - private FocusNode mFocusNode = new FocusNode(); - + WebViewCore.CursorData cursorData() { + WebViewCore.CursorData result = new WebViewCore.CursorData(); + result.mMoveGeneration = nativeMoveGeneration(); + result.mFrame = nativeCursorFramePointer(); + Point position = nativeCursorPosition(); + result.mX = position.x; + result.mY = position.y; + return result; + } + /** * Delete text from start to end in the focused textfield. If there is no - * focus, or if start == end, silently fail. If start and end are out of + * focus, or if start == end, silently fail. If start and end are out of * order, swap them. * @param start Beginning of selection to delete. * @param end End of selection to delete. */ /* package */ void deleteSelection(int start, int end) { mTextGeneration++; - mWebViewCore.sendMessage(EventHub.DELETE_SELECTION, start, end, - new WebViewCore.FocusData(mFocusData)); + WebViewCore.TextSelectionData data + = new WebViewCore.TextSelectionData(start, end); + mWebViewCore.sendMessage(EventHub.DELETE_SELECTION, mTextGeneration, 0, + data); } /** @@ -2893,119 +3079,138 @@ public class WebView extends AbsoluteLayout * @param end End of selection. */ /* package */ void setSelection(int start, int end) { - mWebViewCore.sendMessage(EventHub.SET_SELECTION, start, end, - new WebViewCore.FocusData(mFocusData)); + mWebViewCore.sendMessage(EventHub.SET_SELECTION, start, end); } // Called by JNI when a touch event puts a textfield into focus. - private void displaySoftKeyboard() { + private void displaySoftKeyboard(boolean isTextView) { InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE); - imm.showSoftInput(mTextEntry, 0); - mTextEntry.enableScrollOnScreen(true); - // Now we need to fake a touch event to place the cursor where the - // user touched. - AbsoluteLayout.LayoutParams lp = (AbsoluteLayout.LayoutParams) - mTextEntry.getLayoutParams(); - if (lp != null) { - // Take the last touch and adjust for the location of the - // TextDialog. - float x = mLastTouchX + (float) (mScrollX - lp.x); - float y = mLastTouchY + (float) (mScrollY - lp.y); - mTextEntry.fakeTouchEvent(x, y); - } - } - - private void updateTextEntry() { - if (mTextEntry == null) { - mTextEntry = new TextDialog(mContext, WebView.this); - // Initialize our generation number. - mTextGeneration = 0; + + if (isTextView) { + imm.showSoftInput(mWebTextView, 0); + // Now we need to fake a touch event to place the cursor where the + // user touched. + AbsoluteLayout.LayoutParams lp = (AbsoluteLayout.LayoutParams) + mWebTextView.getLayoutParams(); + if (lp != null) { + // Take the last touch and adjust for the location of the + // WebTextView. + float x = mLastTouchX + (float) (mScrollX - lp.x); + float y = mLastTouchY + (float) (mScrollY - lp.y); + mWebTextView.fakeTouchEvent(x, y); + } + if (mInZoomOverview) { + // if in zoom overview mode, call doDoubleTap() to bring it back + // to normal mode so that user can enter text. + doDoubleTap(); + } + } + else { // used by plugins + imm.showSoftInput(this, 0); } - // If we do not have focus, do nothing until we gain focus. - if (!hasFocus() && !mTextEntry.hasFocus() - || (mTouchMode >= FIRST_SCROLL_ZOOM + } + + // Called by WebKit to instruct the UI to hide the keyboard + private void hideSoftKeyboard() { + InputMethodManager imm = (InputMethodManager) + getContext().getSystemService(Context.INPUT_METHOD_SERVICE); + + imm.hideSoftInputFromWindow(this.getWindowToken(), 0); + } + + /* + * This method checks the current focus and cursor and potentially rebuilds + * mWebTextView to have the appropriate properties, such as password, + * multiline, and what text it contains. It also removes it if necessary. + */ + /* package */ void rebuildWebTextView() { + // If the WebView does not have focus, do nothing until it gains focus. + if (!hasFocus() && (null == mWebTextView || !mWebTextView.hasFocus()) + || (mTouchMode >= FIRST_SCROLL_ZOOM && mTouchMode <= LAST_SCROLL_ZOOM)) { - mNeedsUpdateTextEntry = true; return; } boolean alreadyThere = inEditingMode(); - if (0 == mNativeClass || !nativeUpdateFocusNode()) { + // inEditingMode can only return true if mWebTextView is non-null, + // so we can safely call remove() if (alreadyThere) + if (0 == mNativeClass || !nativeFocusCandidateIsTextInput()) { if (alreadyThere) { - mTextEntry.remove(); + mWebTextView.remove(); } return; } - FocusNode node = mFocusNode; - if (!node.mIsTextField && !node.mIsTextArea) { - if (alreadyThere) { - mTextEntry.remove(); - } - return; + // At this point, we know we have found an input field, so go ahead + // and create the WebTextView if necessary. + if (mWebTextView == null) { + mWebTextView = new WebTextView(mContext, WebView.this); + // Initialize our generation number. + mTextGeneration = 0; } - mTextEntry.setTextSize(contentToView(node.mTextSize)); - Rect visibleRect = sendOurVisibleRect(); + mWebTextView.setTextSize(contentToView(nativeFocusCandidateTextSize())); + Rect visibleRect = new Rect(); + calcOurContentVisibleRect(visibleRect); // Note that sendOurVisibleRect calls viewToContent, so the coordinates // should be in content coordinates. - if (!Rect.intersects(node.mBounds, visibleRect)) { - // Node is not on screen, so do not bother. - return; + Rect bounds = nativeFocusCandidateNodeBounds(); + if (!Rect.intersects(bounds, visibleRect)) { + mWebTextView.bringIntoView(); } - int x = node.mBounds.left; - int y = node.mBounds.top; - int width = node.mBounds.width(); - int height = node.mBounds.height(); - if (alreadyThere && mTextEntry.isSameTextField(node.mNodePointer)) { + String text = nativeFocusCandidateText(); + int nodePointer = nativeFocusCandidatePointer(); + if (alreadyThere && mWebTextView.isSameTextField(nodePointer)) { // It is possible that we have the same textfield, but it has moved, // i.e. In the case of opening/closing the screen. // In that case, we need to set the dimensions, but not the other // aspects. // We also need to restore the selection, which gets wrecked by // calling setTextEntryRect. - Spannable spannable = (Spannable) mTextEntry.getText(); + Spannable spannable = (Spannable) mWebTextView.getText(); int start = Selection.getSelectionStart(spannable); int end = Selection.getSelectionEnd(spannable); - setTextEntryRect(x, y, width, height); // If the text has been changed by webkit, update it. However, if // there has been more UI text input, ignore it. We will receive // another update when that text is recognized. - if (node.mText != null && !node.mText.equals(spannable.toString()) - && node.mRootTextGeneration == mTextGeneration) { - mTextEntry.setTextAndKeepSelection(node.mText); + if (text != null && !text.equals(spannable.toString()) + && nativeTextGeneration() == mTextGeneration) { + mWebTextView.setTextAndKeepSelection(text); } else { Selection.setSelection(spannable, start, end); } } else { - String text = node.mText; - setTextEntryRect(x, y, width, height); - mTextEntry.setGravity(node.mIsRtlText ? Gravity.RIGHT : - Gravity.NO_GRAVITY); + Rect vBox = contentToView(bounds); + mWebTextView.setRect(vBox.left, vBox.top, vBox.width(), + vBox.height()); + mWebTextView.setGravity(nativeFocusCandidateIsRtlText() ? + Gravity.RIGHT : Gravity.NO_GRAVITY); // this needs to be called before update adapter thread starts to - // ensure the mTextEntry has the same node pointer - mTextEntry.setNodePointer(node.mNodePointer); + // ensure the mWebTextView has the same node pointer + mWebTextView.setNodePointer(nodePointer); int maxLength = -1; - if (node.mIsTextField) { - maxLength = node.mMaxLength; + boolean isTextField = nativeFocusCandidateIsTextField(); + if (isTextField) { + maxLength = nativeFocusCandidateMaxLength(); + String name = nativeFocusCandidateName(); if (mWebViewCore.getSettings().getSaveFormData() - && node.mName != null) { - HashMap data = new HashMap(); - data.put("text", node.mText); + && name != null) { Message update = mPrivateHandler.obtainMessage( - UPDATE_TEXT_ENTRY_ADAPTER, node.mNodePointer, 0, - data); - UpdateTextEntryAdapter updater = new UpdateTextEntryAdapter( - node.mName, getUrl(), update); + REQUEST_FORM_DATA, nodePointer); + RequestFormData updater = new RequestFormData(name, + getUrl(), update); Thread t = new Thread(updater); t.start(); } } - mTextEntry.setMaxLength(maxLength); + mWebTextView.setMaxLength(maxLength); AutoCompleteAdapter adapter = null; - mTextEntry.setAdapterCustom(adapter); - mTextEntry.setSingleLine(node.mIsTextField); - mTextEntry.setInPassword(node.mIsPassword); + mWebTextView.setAdapterCustom(adapter); + mWebTextView.setSingleLine(isTextField); + mWebTextView.setInPassword(nativeFocusCandidateIsPassword()); if (null == text) { - mTextEntry.setText("", 0, 0); + mWebTextView.setText("", 0, 0); + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "rebuildWebTextView null == text"); + } } else { // Change to true to enable the old style behavior, where // entering a textfield/textarea always set the selection to the @@ -3016,24 +3221,35 @@ public class WebView extends AbsoluteLayout // textarea. Testing out a new behavior, where textfields set // selection at the end, and textareas at the beginning. if (false) { - mTextEntry.setText(text, 0, text.length()); - } else if (node.mIsTextField) { + mWebTextView.setText(text, 0, text.length()); + } else if (isTextField) { int length = text.length(); - mTextEntry.setText(text, length, length); + mWebTextView.setText(text, length, length); + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "rebuildWebTextView length=" + length); + } } else { - mTextEntry.setText(text, 0, 0); + mWebTextView.setText(text, 0, 0); + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "rebuildWebTextView !isTextField"); + } } } - mTextEntry.requestFocus(); + mWebTextView.requestFocus(); } } - private class UpdateTextEntryAdapter implements Runnable { + /* + * This class requests an Adapter for the WebTextView which shows past + * entries stored in the database. It is a Runnable so that it can be done + * in its own thread, without slowing down the UI. + */ + private class RequestFormData implements Runnable { private String mName; private String mUrl; private Message mUpdateMessage; - public UpdateTextEntryAdapter(String name, String url, Message msg) { + public RequestFormData(String name, String url, Message msg) { mName = name; mUrl = url; mUpdateMessage = msg; @@ -3044,29 +3260,21 @@ public class WebView extends AbsoluteLayout if (pastEntries.size() > 0) { AutoCompleteAdapter adapter = new AutoCompleteAdapter(mContext, pastEntries); - ((HashMap) mUpdateMessage.obj).put("adapter", adapter); + mUpdateMessage.obj = adapter; mUpdateMessage.sendToTarget(); } } } - private void setTextEntryRect(int x, int y, int width, int height) { - x = contentToView(x); - y = contentToView(y); - width = contentToView(width); - height = contentToView(height); - mTextEntry.setRect(x, y, width, height); - } - - // This is used to determine long press with the enter key, or - // a center key. Does not affect long press with the trackball/touch. - private boolean mGotEnterDown = false; + // This is used to determine long press with the center key. Does not + // affect long press with the trackball/touch. + private boolean mGotCenterDown = false; @Override public boolean onKeyDown(int keyCode, KeyEvent event) { - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "keyDown at " + System.currentTimeMillis() - + ", " + event); + + ", " + event + ", unicode=" + event.getUnicodeChar()); } if (mNativeClass == 0) { @@ -3092,29 +3300,27 @@ public class WebView extends AbsoluteLayout return false; } - if (mShiftIsPressed == false && nativeFocusNodeWantsKeyEvents() == false - && (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT + if (mShiftIsPressed == false && nativeCursorWantsKeyEvents() == false + && (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT || keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT)) { mExtendSelection = false; mShiftIsPressed = true; - if (nativeUpdateFocusNode()) { - FocusNode node = mFocusNode; - mSelectX = contentToView(node.mBounds.left); - mSelectY = contentToView(node.mBounds.top); + if (nativeHasCursorNode()) { + Rect rect = nativeCursorNodeBounds(); + mSelectX = contentToView(rect.left); + mSelectY = contentToView(rect.top); } else { mSelectX = mScrollX + (int) mLastTouchX; mSelectY = mScrollY + (int) mLastTouchY; } - int contentX = viewToContent((int) mLastTouchX + mScrollX); - int contentY = viewToContent((int) mLastTouchY + mScrollY); - nativeClearFocus(contentX, contentY); + nativeHideCursor(); } if (keyCode >= KeyEvent.KEYCODE_DPAD_UP && keyCode <= KeyEvent.KEYCODE_DPAD_RIGHT) { // always handle the navigation keys in the UI thread switchOutDrawHistory(); - if (navHandledKey(keyCode, 1, false, event.getEventTime())) { + if (navHandledKey(keyCode, 1, false, event.getEventTime(), false)) { playSoundEffect(keyCodeToSoundsEffect(keyCode)); return true; } @@ -3122,13 +3328,12 @@ public class WebView extends AbsoluteLayout return false; } - if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER - || keyCode == KeyEvent.KEYCODE_ENTER) { + if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) { switchOutDrawHistory(); if (event.getRepeatCount() == 0) { - mGotEnterDown = true; + mGotCenterDown = true; mPrivateHandler.sendMessageDelayed(mPrivateHandler - .obtainMessage(LONG_PRESS_ENTER), LONG_PRESS_TIMEOUT); + .obtainMessage(LONG_PRESS_CENTER), LONG_PRESS_TIMEOUT); // Already checked mNativeClass, so we do not need to check it // again. nativeRecordButtons(hasFocus() && hasWindowFocus(), true, true); @@ -3138,6 +3343,15 @@ public class WebView extends AbsoluteLayout return false; } + if (keyCode != KeyEvent.KEYCODE_SHIFT_LEFT + && keyCode != KeyEvent.KEYCODE_SHIFT_RIGHT) { + // turn off copy select if a shift-key combo is pressed + mExtendSelection = mShiftIsPressed = false; + if (mTouchMode == TOUCH_SELECT_MODE) { + mTouchMode = TOUCH_INIT_MODE; + } + } + if (getSettings().getNavDump()) { switch (keyCode) { case KeyEvent.KEYCODE_4: @@ -3166,8 +3380,30 @@ public class WebView extends AbsoluteLayout } } + if (nativeCursorIsPlugin()) { + nativeUpdatePluginReceivesEvents(); + invalidate(); + } else if (nativeCursorIsTextInput()) { + // This message will put the node in focus, for the DOM's notion + // of focus, and make the focuscontroller active + mWebViewCore.sendMessage(EventHub.CLICK, nativeCursorFramePointer(), + nativeCursorNodePointer()); + // This will bring up the WebTextView and put it in focus, for + // our view system's notion of focus + rebuildWebTextView(); + // Now we need to pass the event to it + return mWebTextView.onKeyDown(keyCode, event); + } else if (nativeHasFocusNode()) { + // In this case, the cursor is not on a text input, but the focus + // might be. Check it, and if so, hand over to the WebTextView. + rebuildWebTextView(); + if (inEditingMode()) { + return mWebTextView.onKeyDown(keyCode, event); + } + } + // TODO: should we pass all the keys to DOM or check the meta tag - if (nativeFocusNodeWantsKeyEvents() || true) { + if (nativeCursorWantsKeyEvents() || true) { // pass the key to DOM mWebViewCore.sendMessage(EventHub.KEY_DOWN, event); // return true as DOM handles the key @@ -3180,20 +3416,19 @@ public class WebView extends AbsoluteLayout @Override public boolean onKeyUp(int keyCode, KeyEvent event) { - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "keyUp at " + System.currentTimeMillis() - + ", " + event); + + ", " + event + ", unicode=" + event.getUnicodeChar()); } if (mNativeClass == 0) { return false; } - // special CALL handling when focus node's href is "tel:XXX" - if (keyCode == KeyEvent.KEYCODE_CALL && nativeUpdateFocusNode()) { - FocusNode node = mFocusNode; - String text = node.mText; - if (!node.mIsTextField && !node.mIsTextArea && text != null + // special CALL handling when cursor node's href is "tel:XXX" + if (keyCode == KeyEvent.KEYCODE_CALL && nativeHasCursorNode()) { + String text = nativeCursorText(); + if (!nativeCursorIsTextInput() && text != null && text.startsWith(SCHEME_TEL)) { Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse(text)); getContext().startActivity(intent); @@ -3220,7 +3455,7 @@ public class WebView extends AbsoluteLayout return false; } - if (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT + if (keyCode == KeyEvent.KEYCODE_SHIFT_LEFT || keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT) { if (commitCopy()) { return true; @@ -3234,55 +3469,30 @@ public class WebView extends AbsoluteLayout return false; } - if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER - || keyCode == KeyEvent.KEYCODE_ENTER) { + if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) { // remove the long press message first - mPrivateHandler.removeMessages(LONG_PRESS_ENTER); - mGotEnterDown = false; + mPrivateHandler.removeMessages(LONG_PRESS_CENTER); + mGotCenterDown = false; - if (KeyEvent.KEYCODE_DPAD_CENTER == keyCode) { - if (mShiftIsPressed) { - return false; - } - if (getSettings().supportZoom()) { - if (mTouchMode == TOUCH_DOUBLECLICK_MODE) { - zoomScrollOut(); - } else { - if (LOGV_ENABLED) { - Log.v(LOGTAG, "TOUCH_DOUBLECLICK_MODE"); - } - mPrivateHandler.sendMessageDelayed(mPrivateHandler - .obtainMessage(SWITCH_TO_ENTER), TAP_TIMEOUT); - mTouchMode = TOUCH_DOUBLECLICK_MODE; - } - return true; - } + if (mShiftIsPressed) { + return false; } - - Rect visibleRect = sendOurVisibleRect(); - // Note that sendOurVisibleRect calls viewToContent, so the - // coordinates should be in content coordinates. - if (nativeUpdateFocusNode()) { - if (Rect.intersects(mFocusNode.mBounds, visibleRect)) { - nativeSetFollowedLink(true); - mWebViewCore.sendMessage(EventHub.SET_FINAL_FOCUS, - EventHub.BLOCK_FOCUS_CHANGE_UNTIL_KEY_UP, 0, - new WebViewCore.FocusData(mFocusData)); - playSoundEffect(SoundEffectConstants.CLICK); - if (!mCallbackProxy.uiOverrideUrlLoading(mFocusNode.mText)) { - // use CLICK instead of KEY_DOWN/KEY_UP so that we can - // trigger mouse click events - mWebViewCore.sendMessage(EventHub.CLICK); - } + if (getSettings().supportZoom() + && mTouchMode == TOUCH_DOUBLECLICK_MODE) { + zoomScrollOut(); + } else { + mPrivateHandler.sendMessageDelayed(mPrivateHandler + .obtainMessage(SWITCH_TO_CLICK), TAP_TIMEOUT); + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "TOUCH_DOUBLECLICK_MODE"); } - return true; + mTouchMode = TOUCH_DOUBLECLICK_MODE; } - // Bubble up the key event as WebView doesn't handle it - return false; + return true; } // TODO: should we pass all the keys to DOM or check the meta tag - if (nativeFocusNodeWantsKeyEvents() || true) { + if (nativeCursorWantsKeyEvents() || true) { // pass the key to DOM mWebViewCore.sendMessage(EventHub.KEY_UP, event); // return true as DOM handles the key @@ -3292,16 +3502,14 @@ public class WebView extends AbsoluteLayout // Bubble up the key event as WebView doesn't handle it return false; } - + /** * @hide */ public void emulateShiftHeld() { mExtendSelection = false; mShiftIsPressed = true; - int contentX = viewToContent((int) mLastTouchX + mScrollX); - int contentY = viewToContent((int) mLastTouchY + mScrollY); - nativeClearFocus(contentX, contentY); + nativeHideCursor(); } private boolean commitCopy() { @@ -3349,16 +3557,13 @@ public class WebView extends AbsoluteLayout // Clean up the zoom controller mZoomButtonsController.setVisible(false); } - + // Implementation for OnHierarchyChangeListener public void onChildViewAdded(View parent, View child) {} - + public void onChildViewRemoved(View p, View child) { if (child == this) { - if (inEditingMode()) { - clearTextEntry(); - mNeedsUpdateTextEntry = true; - } + clearTextEntry(); } } @@ -3371,26 +3576,25 @@ public class WebView extends AbsoluteLayout public void onGlobalFocusChanged(View oldFocus, View newFocus) { } - // To avoid drawing the focus ring, and remove the TextView when our window + // To avoid drawing the cursor ring, and remove the TextView when our window // loses focus. @Override public void onWindowFocusChanged(boolean hasWindowFocus) { if (hasWindowFocus) { if (hasFocus()) { // If our window regained focus, and we have focus, then begin - // drawing the focus ring, and restore the TextView if - // necessary. - mDrawFocusRing = true; - if (mNeedsUpdateTextEntry) { - updateTextEntry(); - } + // drawing the cursor ring + mDrawCursorRing = true; if (mNativeClass != 0) { nativeRecordButtons(true, false, true); + if (inEditingMode()) { + mWebViewCore.sendMessage(EventHub.SET_ACTIVE, 1, 0); + } } } else { // If our window gained focus, but we do not have it, do not - // draw the focus ring. - mDrawFocusRing = false; + // draw the cursor ring. + mDrawCursorRing = false; // We do not call nativeRecordButtons here because we assume // that when we lost focus, or window focus, it got called with // false for the first parameter @@ -3399,39 +3603,49 @@ public class WebView extends AbsoluteLayout if (getSettings().getBuiltInZoomControls() && !mZoomButtonsController.isVisible()) { /* * The zoom controls come in their own window, so our window - * loses focus. Our policy is to not draw the focus ring if + * loses focus. Our policy is to not draw the cursor ring if * our window is not focused, but this is an exception since * the user can still navigate the web page with the zoom * controls showing. */ - // If our window has lost focus, stop drawing the focus ring - mDrawFocusRing = false; + // If our window has lost focus, stop drawing the cursor ring + mDrawCursorRing = false; } mGotKeyDown = false; mShiftIsPressed = false; if (mNativeClass != 0) { nativeRecordButtons(false, false, true); } + setFocusControllerInactive(); } invalidate(); super.onWindowFocusChanged(hasWindowFocus); } + /* + * Pass a message to WebCore Thread, telling the WebCore::Page's + * FocusController to be "inactive" so that it will + * not draw the blinking cursor. It gets set to "active" to draw the cursor + * in WebViewCore.cpp, when the WebCore thread receives key events/clicks. + */ + /* package */ void setFocusControllerInactive() { + // Do not need to also check whether mWebViewCore is null, because + // mNativeClass is only set if mWebViewCore is non null + if (mNativeClass == 0) return; + mWebViewCore.sendMessage(EventHub.SET_ACTIVE, 0, 0); + } + @Override protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) { - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "MT focusChanged " + focused + ", " + direction); } if (focused) { // When we regain focus, if we have window focus, resume drawing - // the focus ring, and add the TextView if necessary. + // the cursor ring if (hasWindowFocus()) { - mDrawFocusRing = true; - if (mNeedsUpdateTextEntry) { - updateTextEntry(); - mNeedsUpdateTextEntry = false; - } + mDrawCursorRing = true; if (mNativeClass != 0) { nativeRecordButtons(true, false, true); } @@ -3442,12 +3656,13 @@ public class WebView extends AbsoluteLayout } } else { // When we lost focus, unless focus went to the TextView (which is - // true if we are in editing mode), stop drawing the focus ring. + // true if we are in editing mode), stop drawing the cursor ring. if (!inEditingMode()) { - mDrawFocusRing = false; + mDrawCursorRing = false; if (mNativeClass != 0) { nativeRecordButtons(false, false, true); } + setFocusControllerInactive(); } mGotKeyDown = false; } @@ -3465,7 +3680,8 @@ public class WebView extends AbsoluteLayout // update mMinZoomScale if the minimum zoom scale is not fixed if (!mMinZoomScaleFixed) { mMinZoomScale = (float) getViewWidth() - / Math.max(ZOOM_OUT_WIDTH, mContentWidth); + / (mDrawHistory ? mHistoryPicture.getWidth() + : mZoomOverviewWidth); } // we always force, in case our height changed, in which case we still @@ -3476,10 +3692,11 @@ public class WebView extends AbsoluteLayout @Override protected void onScrollChanged(int l, int t, int oldl, int oldt) { super.onScrollChanged(l, t, oldl, oldt); + sendOurVisibleRect(); } - - + + @Override public boolean dispatchKeyEvent(KeyEvent event) { boolean dispatch = true; @@ -3523,7 +3740,7 @@ public class WebView extends AbsoluteLayout return false; } - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, ev + " at " + ev.getEventTime() + " mTouchMode=" + mTouchMode); } @@ -3548,7 +3765,7 @@ public class WebView extends AbsoluteLayout if (mForwardTouchEvents && mTouchMode != SCROLL_ZOOM_OUT && mTouchMode != SCROLL_ZOOM_ANIMATION_IN && mTouchMode != SCROLL_ZOOM_ANIMATION_OUT - && (action != MotionEvent.ACTION_MOVE || + && (action != MotionEvent.ACTION_MOVE || eventTime - mLastSentTouchTime > TOUCH_SENT_INTERVAL)) { WebViewCore.TouchEventData ted = new WebViewCore.TouchEventData(); ted.mAction = action; @@ -3579,22 +3796,34 @@ public class WebView extends AbsoluteLayout mSelectX = mScrollX + (int) x; mSelectY = mScrollY + (int) y; mTouchMode = TOUCH_SELECT_MODE; - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "select=" + mSelectX + "," + mSelectY); } nativeMoveSelection(viewToContent(mSelectX) , viewToContent(mSelectY), false); mTouchSelection = mExtendSelection = true; + } else if (mPrivateHandler.hasMessages(RELEASE_SINGLE_TAP)) { + mPrivateHandler.removeMessages(RELEASE_SINGLE_TAP); + if (deltaX * deltaX + deltaY * deltaY < mDoubleTapSlopSquare) { + mTouchMode = TOUCH_DOUBLE_TAP_MODE; + } else { + // commit the short press action for the previous tap + doShortPress(); + // continue, mTouchMode should be still TOUCH_INIT_MODE + } } else { mTouchMode = TOUCH_INIT_MODE; mPreventDrag = mForwardTouchEvents; + mWebViewCore.sendMessage( + EventHub.UPDATE_FRAME_CACHE_IF_LOADING); if (mLogEvent && eventTime - mLastTouchUpTime < 1000) { EventLog.writeEvent(EVENT_LOG_DOUBLE_TAP_DURATION, (eventTime - mLastTouchUpTime), eventTime); } } // Trigger the link - if (mTouchMode == TOUCH_INIT_MODE) { + if (mTouchMode == TOUCH_INIT_MODE + || mTouchMode == TOUCH_DOUBLE_TAP_MODE) { mPrivateHandler.sendMessageDelayed(mPrivateHandler .obtainMessage(SWITCH_TO_SHORTPRESS), TAP_TIMEOUT); } @@ -3607,7 +3836,7 @@ public class WebView extends AbsoluteLayout break; } case MotionEvent.ACTION_MOVE: { - if (mTouchMode == TOUCH_DONE_MODE + if (mTouchMode == TOUCH_DONE_MODE || mTouchMode == SCROLL_ZOOM_ANIMATION_IN || mTouchMode == SCROLL_ZOOM_ANIMATION_OUT) { // no dragging during scroll zoom animation @@ -3624,7 +3853,7 @@ public class WebView extends AbsoluteLayout if (mTouchMode == TOUCH_SELECT_MODE) { mSelectX = mScrollX + (int) x; mSelectY = mScrollY + (int) y; - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "xtend=" + mSelectX + "," + mSelectY); } nativeMoveSelection(viewToContent(mSelectX) @@ -3640,7 +3869,8 @@ public class WebView extends AbsoluteLayout if (mTouchMode == TOUCH_SHORTPRESS_MODE || mTouchMode == TOUCH_SHORTPRESS_START_MODE) { mPrivateHandler.removeMessages(SWITCH_TO_LONGPRESS); - } else if (mTouchMode == TOUCH_INIT_MODE) { + } else if (mTouchMode == TOUCH_INIT_MODE + || mTouchMode == TOUCH_DOUBLE_TAP_MODE) { mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS); } @@ -3657,22 +3887,14 @@ public class WebView extends AbsoluteLayout mTouchMode = TOUCH_DRAG_MODE; WebViewCore.pauseUpdate(mWebViewCore); - int contentX = viewToContent((int) x + mScrollX); - int contentY = viewToContent((int) y + mScrollY); - if (inEditingMode()) { - mTextEntry.updateCachedTextfield(); - } - nativeClearFocus(contentX, contentY); - // remove the zoom anchor if there is any - if (mZoomScale != 0) { - mWebViewCore - .sendMessage(EventHub.SET_SNAP_ANCHOR, 0, 0); + if (!mDragFromTextInput) { + nativeHideCursor(); } WebSettings settings = getSettings(); if (settings.supportZoom() && settings.getBuiltInZoomControls() && !mZoomButtonsController.isVisible() - && (canZoomScrollOut() || + && (canZoomScrollOut() || mMinZoomScale < mMaxZoomScale)) { mZoomButtonsController.setVisible(true); } @@ -3698,7 +3920,7 @@ public class WebView extends AbsoluteLayout } // reverse direction means lock in the snap mode if ((ax > MAX_SLOPE_FOR_DIAG * ay) && - ((mSnapPositive && + ((mSnapPositive && deltaX < -mMinLockSnapReverseDistance) || (!mSnapPositive && deltaX > mMinLockSnapReverseDistance))) { @@ -3712,9 +3934,9 @@ public class WebView extends AbsoluteLayout } // reverse direction means lock in the snap mode if ((ay > MAX_SLOPE_FOR_DIAG * ax) && - ((mSnapPositive && + ((mSnapPositive && deltaY < -mMinLockSnapReverseDistance) - || (!mSnapPositive && + || (!mSnapPositive && deltaY > mMinLockSnapReverseDistance))) { mSnapScrollMode = SNAP_Y_LOCK; } @@ -3762,7 +3984,23 @@ public class WebView extends AbsoluteLayout case MotionEvent.ACTION_UP: { mLastTouchUpTime = eventTime; switch (mTouchMode) { + case TOUCH_DOUBLE_TAP_MODE: // double tap + mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS); + mTouchMode = TOUCH_DONE_MODE; + doDoubleTap(); + break; case TOUCH_INIT_MODE: // tap + if (ENABLE_DOUBLETAP_ZOOM) { + mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS); + if (!mPreventDrag) { + mPrivateHandler.sendMessageDelayed( + mPrivateHandler.obtainMessage( + RELEASE_SINGLE_TAP), + ViewConfiguration.getDoubleTapTimeout()); + } + break; + } + // fall through case TOUCH_SHORTPRESS_START_MODE: case TOUCH_SHORTPRESS_MODE: mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS); @@ -3779,7 +4017,7 @@ public class WebView extends AbsoluteLayout // no action during scroll animation break; case SCROLL_ZOOM_OUT: - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "ACTION_UP SCROLL_ZOOM_OUT" + " eventTime - mLastTouchTime=" + (eventTime - mLastTouchTime)); @@ -3837,18 +4075,13 @@ public class WebView extends AbsoluteLayout mPrivateHandler.removeMessages(SWITCH_TO_SHORTPRESS); mPrivateHandler.removeMessages(SWITCH_TO_LONGPRESS); mTouchMode = TOUCH_DONE_MODE; - int contentX = viewToContent((int) mLastTouchX + mScrollX); - int contentY = viewToContent((int) mLastTouchY + mScrollY); - if (inEditingMode()) { - mTextEntry.updateCachedTextfield(); - } - nativeClearFocus(contentX, contentY); + nativeHideCursor(); break; } } return true; } - + private long mTrackballFirstTime = 0; private long mTrackballLastTime = 0; private float mTrackballRemainsX = 0.0f; @@ -3870,14 +4103,14 @@ public class WebView extends AbsoluteLayout private boolean mShiftIsPressed = false; private boolean mTrackballDown = false; private long mTrackballUpTime = 0; - private long mLastFocusTime = 0; - private Rect mLastFocusBounds; + private long mLastCursorTime = 0; + private Rect mLastCursorBounds; // Set by default; BrowserActivity clears to interpret trackball data - // directly for movement. Currently, the framework only passes + // directly for movement. Currently, the framework only passes // arrow key events, not trackball events, from one child to the next private boolean mMapTrackballToArrowKeys = true; - + public void setMapTrackballToArrowKeys(boolean setMap) { mMapTrackballToArrowKeys = setMap; } @@ -3895,26 +4128,27 @@ public class WebView extends AbsoluteLayout return true; } if (ev.getAction() == MotionEvent.ACTION_DOWN) { - mPrivateHandler.removeMessages(SWITCH_TO_ENTER); + mPrivateHandler.removeMessages(SWITCH_TO_CLICK); mTrackballDown = true; - if (mNativeClass != 0) { - nativeRecordButtons(hasFocus() && hasWindowFocus(), true, true); + if (mNativeClass == 0) { + return false; } - if (time - mLastFocusTime <= TRACKBALL_TIMEOUT - && !mLastFocusBounds.equals(nativeGetFocusRingBounds())) { - nativeSelectBestAt(mLastFocusBounds); + nativeRecordButtons(hasFocus() && hasWindowFocus(), true, true); + if (time - mLastCursorTime <= TRACKBALL_TIMEOUT + && !mLastCursorBounds.equals(nativeGetCursorRingBounds())) { + nativeSelectBestAt(mLastCursorBounds); } - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "onTrackballEvent down ev=" + ev - + " time=" + time - + " mLastFocusTime=" + mLastFocusTime); + + " time=" + time + + " mLastCursorTime=" + mLastCursorTime); } if (isInTouchMode()) requestFocusFromTouch(); return false; // let common code in onKeyDown at it - } + } if (ev.getAction() == MotionEvent.ACTION_UP) { - // LONG_PRESS_ENTER is set in common onKeyDown - mPrivateHandler.removeMessages(LONG_PRESS_ENTER); + // LONG_PRESS_CENTER is set in common onKeyDown + mPrivateHandler.removeMessages(LONG_PRESS_CENTER); mTrackballDown = false; mTrackballUpTime = time; if (mShiftIsPressed) { @@ -3924,42 +4158,42 @@ public class WebView extends AbsoluteLayout mExtendSelection = true; } } - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "onTrackballEvent up ev=" + ev - + " time=" + time + + " time=" + time ); } return false; // let common code in onKeyUp at it } if (mMapTrackballToArrowKeys && mShiftIsPressed == false) { - if (LOGV_ENABLED) Log.v(LOGTAG, "onTrackballEvent gmail quit"); + if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent gmail quit"); return false; } - // no move if we're still waiting on SWITCH_TO_ENTER timeout + // no move if we're still waiting on SWITCH_TO_CLICK timeout if (mTouchMode == TOUCH_DOUBLECLICK_MODE) { - if (LOGV_ENABLED) Log.v(LOGTAG, "onTrackballEvent 2 click quit"); + if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent 2 click quit"); return true; } if (mTrackballDown) { - if (LOGV_ENABLED) Log.v(LOGTAG, "onTrackballEvent down quit"); + if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent down quit"); return true; // discard move if trackball is down } if (time - mTrackballUpTime < TRACKBALL_TIMEOUT) { - if (LOGV_ENABLED) Log.v(LOGTAG, "onTrackballEvent up timeout quit"); + if (DebugFlags.WEB_VIEW) Log.v(LOGTAG, "onTrackballEvent up timeout quit"); return true; } // TODO: alternatively we can do panning as touch does switchOutDrawHistory(); if (time - mTrackballLastTime > TRACKBALL_TIMEOUT) { - if (LOGV_ENABLED) { - Log.v(LOGTAG, "onTrackballEvent time=" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "onTrackballEvent time=" + time + " last=" + mTrackballLastTime); } mTrackballFirstTime = time; mTrackballXMove = mTrackballYMove = 0; } mTrackballLastTime = time; - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "onTrackballEvent ev=" + ev + " time=" + time); } mTrackballRemainsX += ev.getX(); @@ -3967,7 +4201,7 @@ public class WebView extends AbsoluteLayout doTrackball(time); return true; } - + void moveSelection(float xRate, float yRate) { if (mNativeClass == 0) return; @@ -3981,8 +4215,8 @@ public class WebView extends AbsoluteLayout , mSelectX)); mSelectY = Math.min(maxY, Math.max(mScrollY - SELECT_CURSOR_OFFSET , mSelectY)); - if (LOGV_ENABLED) { - Log.v(LOGTAG, "moveSelection" + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "moveSelection" + " mSelectX=" + mSelectX + " mSelectY=" + mSelectY + " mScrollX=" + mScrollX @@ -3994,10 +4228,10 @@ public class WebView extends AbsoluteLayout nativeMoveSelection(viewToContent(mSelectX) , viewToContent(mSelectY), mExtendSelection); int scrollX = mSelectX < mScrollX ? -SELECT_CURSOR_OFFSET - : mSelectX > maxX - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET + : mSelectX > maxX - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET : 0; int scrollY = mSelectY < mScrollY ? -SELECT_CURSOR_OFFSET - : mSelectY > maxY - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET + : mSelectY > maxY - SELECT_CURSOR_OFFSET ? SELECT_CURSOR_OFFSET : 0; pinScrollBy(scrollX, scrollY, true, 0); Rect select = new Rect(mSelectX, mSelectY, mSelectX + 1, mSelectY + 1); @@ -4054,7 +4288,7 @@ public class WebView extends AbsoluteLayout if (elapsed == 0) { elapsed = TRACKBALL_TIMEOUT; } - float xRate = mTrackballRemainsX * 1000 / elapsed; + float xRate = mTrackballRemainsX * 1000 / elapsed; float yRate = mTrackballRemainsY * 1000 / elapsed; if (mShiftIsPressed) { moveSelection(xRate, yRate); @@ -4064,7 +4298,7 @@ public class WebView extends AbsoluteLayout float ax = Math.abs(xRate); float ay = Math.abs(yRate); float maxA = Math.max(ax, ay); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "doTrackball elapsed=" + elapsed + " xRate=" + xRate + " yRate=" + yRate @@ -4081,9 +4315,9 @@ public class WebView extends AbsoluteLayout int maxWH = Math.max(width, height); mZoomScrollX += scaleTrackballX(xRate, maxWH); mZoomScrollY += scaleTrackballY(yRate, maxWH); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "doTrackball SCROLL_ZOOM_OUT" - + " mZoomScrollX=" + mZoomScrollX + + " mZoomScrollX=" + mZoomScrollX + " mZoomScrollY=" + mZoomScrollY); } mZoomScrollX = Math.min(width, Math.max(0, mZoomScrollX)); @@ -4101,18 +4335,18 @@ public class WebView extends AbsoluteLayout int oldScrollX = mScrollX; int oldScrollY = mScrollY; if (count > 0) { - int selectKeyCode = ax < ay ? mTrackballRemainsY < 0 ? - KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN : + int selectKeyCode = ax < ay ? mTrackballRemainsY < 0 ? + KeyEvent.KEYCODE_DPAD_UP : KeyEvent.KEYCODE_DPAD_DOWN : mTrackballRemainsX < 0 ? KeyEvent.KEYCODE_DPAD_LEFT : KeyEvent.KEYCODE_DPAD_RIGHT; count = Math.min(count, TRACKBALL_MOVE_COUNT); - if (LOGV_ENABLED) { - Log.v(LOGTAG, "doTrackball keyCode=" + selectKeyCode + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "doTrackball keyCode=" + selectKeyCode + " count=" + count + " mTrackballRemainsX=" + mTrackballRemainsX + " mTrackballRemainsY=" + mTrackballRemainsY); } - if (navHandledKey(selectKeyCode, count, false, time)) { + if (navHandledKey(selectKeyCode, count, false, time, false)) { playSoundEffect(keyCodeToSoundsEffect(selectKeyCode)); } mTrackballRemainsX = mTrackballRemainsY = 0; @@ -4120,12 +4354,12 @@ public class WebView extends AbsoluteLayout if (count >= TRACKBALL_SCROLL_COUNT) { int xMove = scaleTrackballX(xRate, width); int yMove = scaleTrackballY(yRate, height); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "doTrackball pinScrollBy" + " count=" + count + " xMove=" + xMove + " yMove=" + yMove - + " mScrollX-oldScrollX=" + (mScrollX-oldScrollX) - + " mScrollY-oldScrollY=" + (mScrollY-oldScrollY) + + " mScrollX-oldScrollX=" + (mScrollX-oldScrollX) + + " mScrollY-oldScrollY=" + (mScrollY-oldScrollY) ); } if (Math.abs(mScrollX - oldScrollX) > Math.abs(xMove)) { @@ -4138,18 +4372,17 @@ public class WebView extends AbsoluteLayout pinScrollBy(xMove, yMove, true, 0); } mUserScroll = true; - } - mWebViewCore.sendMessage(EventHub.UNBLOCK_FOCUS); + } } public void flingScroll(int vx, int vy) { int maxX = Math.max(computeHorizontalScrollRange() - getViewWidth(), 0); int maxY = Math.max(computeVerticalScrollRange() - getViewHeight(), 0); - + mScroller.fling(mScrollX, mScrollY, vx, vy, 0, maxX, 0, maxY); invalidate(); } - + private void doFling() { if (mVelocityTracker == null) { return; @@ -4168,7 +4401,7 @@ public class WebView extends AbsoluteLayout vx = 0; } } - + if (true /* EMG release: make our fling more like Maps' */) { // maps cuts their velocity in half vx = vx * 3 / 4; @@ -4187,6 +4420,8 @@ public class WebView extends AbsoluteLayout private boolean zoomWithPreview(float scale) { float oldScale = mActualScale; + mInitialScrollX = mScrollX; + mInitialScrollY = mScrollY; // snap to DEFAULT_SCALE if it is close if (scale > (mDefaultScale - 0.05) && scale < (mDefaultScale + 0.05)) { @@ -4201,6 +4436,9 @@ public class WebView extends AbsoluteLayout mInvInitialZoomScale = 1.0f / oldScale; mInvFinalZoomScale = 1.0f / mActualScale; mZoomScale = mActualScale; + if (!mInZoomOverview) { + mLastScale = scale; + } invalidate(); return true; } else { @@ -4229,7 +4467,7 @@ public class WebView extends AbsoluteLayout } if (mZoomControls == null) { mZoomControls = createZoomControls(); - + /* * need to be set to VISIBLE first so that getMeasuredHeight() in * {@link #onSizeChanged()} can return the measured value for proper @@ -4238,7 +4476,7 @@ public class WebView extends AbsoluteLayout mZoomControls.setVisibility(View.VISIBLE); mZoomControlRunnable = new Runnable() { public void run() { - + /* Don't dismiss the controls if the user has * focus on them. Wait and check again later. */ @@ -4290,7 +4528,7 @@ public class WebView extends AbsoluteLayout /** * Gets the {@link ZoomButtonsController} which can be used to add * additional buttons to the zoom controls window. - * + * * @return The instance of {@link ZoomButtonsController} used by this class, * or null if it is unavailable. * @hide @@ -4306,7 +4544,18 @@ public class WebView extends AbsoluteLayout public boolean zoomIn() { // TODO: alternatively we can disallow this during draw history mode switchOutDrawHistory(); - return zoomWithPreview(mActualScale * 1.25f); + // Center zooming to the center of the screen. + if (mInZoomOverview) { + // if in overview mode, bring it back to normal mode + mLastTouchX = getViewWidth() * .5f; + mLastTouchY = getViewHeight() * .5f; + doDoubleTap(); + return true; + } else { + mZoomCenterX = getViewWidth() * .5f; + mZoomCenterY = getViewHeight() * .5f; + return zoomWithPreview(mActualScale * 1.25f); + } } /** @@ -4316,7 +4565,18 @@ public class WebView extends AbsoluteLayout public boolean zoomOut() { // TODO: alternatively we can disallow this during draw history mode switchOutDrawHistory(); - return zoomWithPreview(mActualScale * 0.8f); + float scale = mActualScale * 0.8f; + if (scale < (mMinZoomScale + 0.1f) && WebView.ENABLE_DOUBLETAP_ZOOM + && mWebViewCore.getSettings().getUseWideViewPort()) { + // when zoom out to min scale, switch to overview mode + doDoubleTap(); + return true; + } else { + // Center zooming to the center of the screen. + mZoomCenterX = getViewWidth() * .5f; + mZoomCenterY = getViewHeight() * .5f; + return zoomWithPreview(scale); + } } private void updateSelection() { @@ -4328,19 +4588,77 @@ public class WebView extends AbsoluteLayout int contentY = viewToContent((int) mLastTouchY + mScrollY); Rect rect = new Rect(contentX - mNavSlop, contentY - mNavSlop, contentX + mNavSlop, contentY + mNavSlop); - // If we were already focused on a textfield, update its cache. - if (inEditingMode()) { - mTextEntry.updateCachedTextfield(); - } nativeSelectBestAt(rect); } + /** + * Scroll the focused text field/area to match the WebTextView + * @param x New x position of the WebTextView in view coordinates + * @param y New y position of the WebTextView in view coordinates + */ + /*package*/ void scrollFocusedTextInput(int x, int y) { + if (!inEditingMode() || mWebViewCore == null) { + return; + } + mWebViewCore.sendMessage(EventHub.SCROLL_TEXT_INPUT, viewToContent(x), + viewToContent(y)); + } + + /** + * Set our starting point and time for a drag from the WebTextView. + */ + /*package*/ void initiateTextFieldDrag(float x, float y, long eventTime) { + if (!inEditingMode()) { + return; + } + mLastTouchX = x + (float) (mWebTextView.getLeft() - mScrollX); + mLastTouchY = y + (float) (mWebTextView.getTop() - mScrollY); + mLastTouchTime = eventTime; + if (!mScroller.isFinished()) { + mScroller.abortAnimation(); + mPrivateHandler.removeMessages(RESUME_WEBCORE_UPDATE); + } + mSnapScrollMode = SNAP_NONE; + mVelocityTracker = VelocityTracker.obtain(); + mTouchMode = TOUCH_DRAG_START_MODE; + } + + /** + * Given a motion event from the WebTextView, set its location to our + * coordinates, and handle the event. + */ + /*package*/ boolean textFieldDrag(MotionEvent event) { + if (!inEditingMode()) { + return false; + } + mDragFromTextInput = true; + event.offsetLocation((float) (mWebTextView.getLeft() - mScrollX), + (float) (mWebTextView.getTop() - mScrollY)); + boolean result = onTouchEvent(event); + mDragFromTextInput = false; + return result; + } + + /** + * Do a touch up from a WebTextView. This will be handled by webkit to + * change the selection. + * @param event MotionEvent in the WebTextView's coordinates. + */ + /*package*/ void touchUpOnTextField(MotionEvent event) { + if (!inEditingMode()) { + return; + } + int x = viewToContent((int) event.getX() + mWebTextView.getLeft()); + int y = viewToContent((int) event.getY() + mWebTextView.getTop()); + nativeTextInputMotionUp(x, y); + } + /*package*/ void shortPressOnTextField() { if (inEditingMode()) { - View v = mTextEntry; + View v = mWebTextView; int x = viewToContent((v.getLeft() + v.getRight()) >> 1); int y = viewToContent((v.getTop() + v.getBottom()) >> 1); - nativeMotionUp(x, y, mNavSlop, true); + nativeTextInputMotionUp(x, y); } } @@ -4352,29 +4670,76 @@ public class WebView extends AbsoluteLayout // mLastTouchX and mLastTouchY are the point in the current viewport int contentX = viewToContent((int) mLastTouchX + mScrollX); int contentY = viewToContent((int) mLastTouchY + mScrollY); - if (nativeMotionUp(contentX, contentY, mNavSlop, true)) { + if (nativeMotionUp(contentX, contentY, mNavSlop)) { if (mLogEvent) { Checkin.updateStats(mContext.getContentResolver(), Checkin.Stats.Tag.BROWSER_SNAP_CENTER, 1, 0.0); } } - if (nativeUpdateFocusNode() && !mFocusNode.mIsTextField - && !mFocusNode.mIsTextArea) { + if (nativeHasCursorNode() && !nativeCursorIsTextInput()) { playSoundEffect(SoundEffectConstants.CLICK); } } + private void doDoubleTap() { + if (mWebViewCore.getSettings().getUseWideViewPort() == false) { + return; + } + mZoomCenterX = mLastTouchX; + mZoomCenterY = mLastTouchY; + mInZoomOverview = !mInZoomOverview; + mCallbackProxy.uiOnChangeViewingMode(mInZoomOverview); + // remove the zoom control after double tap + if (getSettings().getBuiltInZoomControls()) { + if (mZoomButtonsController.isVisible()) { + mZoomButtonsController.setVisible(false); + } + } else { + if (mZoomControlRunnable != null) { + mPrivateHandler.removeCallbacks(mZoomControlRunnable); + } + if (mZoomControls != null) { + mZoomControls.hide(); + } + } + if (mInZoomOverview) { + zoomWithPreview((float) getViewWidth() / mZoomOverviewWidth); + } else { + // mLastTouchX and mLastTouchY are the point in the current viewport + int contentX = viewToContent((int) mLastTouchX + mScrollX); + int contentY = viewToContent((int) mLastTouchY + mScrollY); + int left = nativeGetBlockLeftEdge(contentX, contentY, mActualScale); + if (left != NO_LEFTEDGE) { + // add a 5pt padding to the left edge. Re-calculate the zoom + // center so that the new scroll x will be on the left edge. + mZoomCenterX = left < 5 ? 0 : (left - 5) * mLastScale + * mActualScale / (mLastScale - mActualScale); + } + zoomWithPreview(mLastScale); + } + } + // Called by JNI to handle a touch on a node representing an email address, // address, or phone number private void overrideLoading(String url) { mCallbackProxy.uiOverrideUrlLoading(url); } + // called by JNI + private void sendPluginState(int state) { + WebViewCore.PluginStateData psd = new WebViewCore.PluginStateData(); + psd.mFrame = nativeCursorFramePointer(); + psd.mNode = nativeCursorNodePointer(); + psd.mState = state; + mWebViewCore.sendMessage(EventHub.PLUGIN_STATE, psd); + } + @Override public boolean requestFocus(int direction, Rect previouslyFocusedRect) { boolean result = false; if (inEditingMode()) { - result = mTextEntry.requestFocus(direction, previouslyFocusedRect); + result = mWebTextView.requestFocus(direction, + previouslyFocusedRect); } else { result = super.requestFocus(direction, previouslyFocusedRect); if (mWebViewCore.getSettings().getNeedInitialFocus()) { @@ -4398,8 +4763,8 @@ public class WebView extends AbsoluteLayout default: return result; } - if (mNativeClass != 0 && !nativeUpdateFocusNode()) { - navHandledKey(fakeKeyDirection, 1, true, 0); + if (mNativeClass != 0 && !nativeHasCursorNode()) { + navHandledKey(fakeKeyDirection, 1, true, 0, true); } } } @@ -4467,14 +4832,19 @@ public class WebView extends AbsoluteLayout int scrollYDelta = 0; - if (rect.bottom > screenBottom && rect.top > screenTop) { - if (rect.height() > height) { - scrollYDelta += (rect.top - screenTop); + if (rect.bottom > screenBottom) { + int oneThirdOfScreenHeight = height / 3; + if (rect.height() > 2 * oneThirdOfScreenHeight) { + // If the rectangle is too tall to fit in the bottom two thirds + // of the screen, place it at the top. + scrollYDelta = rect.top - screenTop; } else { - scrollYDelta += (rect.bottom - screenBottom); + // If the rectangle will still fit on screen, we want its + // top to be in the top third of the screen. + scrollYDelta = rect.top - (screenTop + oneThirdOfScreenHeight); } } else if (rect.top < screenTop) { - scrollYDelta -= (screenTop - rect.top); + scrollYDelta = rect.top - screenTop; } int width = getWidth() - getVerticalScrollbarWidth(); @@ -4499,33 +4869,35 @@ public class WebView extends AbsoluteLayout return false; } - + /* package */ void replaceTextfieldText(int oldStart, int oldEnd, String replace, int newStart, int newEnd) { - HashMap arg = new HashMap(); - arg.put("focusData", new WebViewCore.FocusData(mFocusData)); - arg.put("replace", replace); - arg.put("start", new Integer(newStart)); - arg.put("end", new Integer(newEnd)); + WebViewCore.ReplaceTextData arg = new WebViewCore.ReplaceTextData(); + arg.mReplace = replace; + arg.mNewStart = newStart; + arg.mNewEnd = newEnd; mTextGeneration++; + arg.mTextGeneration = mTextGeneration; mWebViewCore.sendMessage(EventHub.REPLACE_TEXT, oldStart, oldEnd, arg); } /* package */ void passToJavaScript(String currentText, KeyEvent event) { - HashMap arg = new HashMap(); - arg.put("focusData", new WebViewCore.FocusData(mFocusData)); - arg.put("event", event); - arg.put("currentText", currentText); + if (nativeCursorWantsKeyEvents() && !nativeCursorMatchesFocus()) { + mWebViewCore.sendMessage(EventHub.CLICK); + } + WebViewCore.JSKeyData arg = new WebViewCore.JSKeyData(); + arg.mEvent = event; + arg.mCurrentText = currentText; // Increase our text generation number, and pass it to webcore thread mTextGeneration++; mWebViewCore.sendMessage(EventHub.PASS_TO_JS, mTextGeneration, 0, arg); // WebKit's document state is not saved until about to leave the page. - // To make sure the host application, like Browser, has the up to date - // document state when it goes to background, we force to save the + // To make sure the host application, like Browser, has the up to date + // document state when it goes to background, we force to save the // document state. mWebViewCore.removeMessages(EventHub.SAVE_DOCUMENT_STATE); mWebViewCore.sendMessageDelayed(EventHub.SAVE_DOCUMENT_STATE, - new WebViewCore.FocusData(mFocusData), 1000); + cursorData(), 1000); } /* package */ WebViewCore getWebViewCore() { @@ -4543,9 +4915,9 @@ public class WebView extends AbsoluteLayout class PrivateHandler extends Handler { @Override public void handleMessage(Message msg) { - if (LOGV_ENABLED) { - Log.v(LOGTAG, msg.what < REMEMBER_PASSWORD || msg.what - > INVAL_RECT_MSG_ID ? Integer.toString(msg.what) + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, msg.what < REMEMBER_PASSWORD || msg.what + > INVAL_RECT_MSG_ID ? Integer.toString(msg.what) : HandlerDebugString[msg.what - REMEMBER_PASSWORD]); } switch (msg.what) { @@ -4567,6 +4939,8 @@ public class WebView extends AbsoluteLayout if (mTouchMode == TOUCH_INIT_MODE) { mTouchMode = TOUCH_SHORTPRESS_START_MODE; updateSelection(); + } else if (mTouchMode == TOUCH_DOUBLE_TAP_MODE) { + mTouchMode = TOUCH_DONE_MODE; } break; } @@ -4574,23 +4948,49 @@ public class WebView extends AbsoluteLayout if (!mPreventDrag) { mTouchMode = TOUCH_DONE_MODE; performLongClick(); - updateTextEntry(); + rebuildWebTextView(); + } + break; + } + case RELEASE_SINGLE_TAP: { + if (!mPreventDrag) { + mTouchMode = TOUCH_DONE_MODE; + doShortPress(); } break; } - case SWITCH_TO_ENTER: - if (LOGV_ENABLED) Log.v(LOGTAG, "SWITCH_TO_ENTER"); + case SWITCH_TO_CLICK: + // The user clicked with the trackball, and did not click a + // second time, so perform the action of a trackball single + // click mTouchMode = TOUCH_DONE_MODE; - onKeyUp(KeyEvent.KEYCODE_ENTER - , new KeyEvent(KeyEvent.ACTION_UP - , KeyEvent.KEYCODE_ENTER)); + Rect visibleRect = sendOurVisibleRect(); + // Note that sendOurVisibleRect calls viewToContent, so the + // coordinates should be in content coordinates. + if (!nativeCursorIntersects(visibleRect)) { + break; + } + nativeSetFollowedLink(true); + nativeUpdatePluginReceivesEvents(); + WebViewCore.CursorData data = cursorData(); + mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE, data); + playSoundEffect(SoundEffectConstants.CLICK); + boolean isTextInput = nativeCursorIsTextInput(); + if (isTextInput || !mCallbackProxy.uiOverrideUrlLoading( + nativeCursorText())) { + mWebViewCore.sendMessage(EventHub.CLICK, data.mFrame, + nativeCursorNodePointer()); + } + if (isTextInput) { + rebuildWebTextView(); + } break; case SCROLL_BY_MSG_ID: setContentScrollBy(msg.arg1, msg.arg2, (Boolean) msg.obj); break; case SYNC_SCROLL_TO_MSG_ID: if (mUserScroll) { - // if user has scrolled explicitly, don't sync the + // if user has scrolled explicitly, don't sync the // scroll position any more mUserScroll = false; break; @@ -4599,7 +4999,7 @@ public class WebView extends AbsoluteLayout case SCROLL_TO_MSG_ID: if (setContentScrollTo(msg.arg1, msg.arg2)) { // if we can't scroll to the exact position due to pin, - // send a message to WebCore to re-scroll when we get a + // send a message to WebCore to re-scroll when we get a // new picture mUserScroll = false; mWebViewCore.sendMessage(EventHub.SYNC_SCROLL, @@ -4609,24 +5009,50 @@ public class WebView extends AbsoluteLayout case SPAWN_SCROLL_TO_MSG_ID: spawnContentScrollTo(msg.arg1, msg.arg2); break; - case NEW_PICTURE_MSG_ID: + case NEW_PICTURE_MSG_ID: { + WebSettings settings = mWebViewCore.getSettings(); // called for new content - final WebViewCore.DrawData draw = + final int viewWidth = getViewWidth(); + final WebViewCore.DrawData draw = (WebViewCore.DrawData) msg.obj; final Point viewSize = draw.mViewPoint; - if (mZoomScale > 0) { - // use the same logic in sendViewSizeZoom() to make sure - // the mZoomScale has matched the viewSize so that we - // can clear mZoomScale - if (Math.round(getViewWidth() / mZoomScale) == viewSize.x) { - mZoomScale = 0; - mWebViewCore.sendMessage(EventHub.SET_SNAP_ANCHOR, - 0, 0); + boolean useWideViewport = settings.getUseWideViewPort(); + WebViewCore.RestoreState restoreState = draw.mRestoreState; + if (restoreState != null) { + mInZoomOverview = false; + mLastScale = restoreState.mTextWrapScale; + if (restoreState.mMinScale == 0) { + mMinZoomScale = DEFAULT_MIN_ZOOM_SCALE; + mMinZoomScaleFixed = false; + } else { + mMinZoomScale = restoreState.mMinScale; + mMinZoomScaleFixed = true; } - } - if (!mMinZoomScaleFixed) { - mMinZoomScale = (float) getViewWidth() - / Math.max(ZOOM_OUT_WIDTH, draw.mWidthHeight.x); + if (restoreState.mMaxScale == 0) { + mMaxZoomScale = DEFAULT_MAX_ZOOM_SCALE; + } else { + mMaxZoomScale = restoreState.mMaxScale; + } + if (useWideViewport && restoreState.mViewScale == 0) { + mInZoomOverview = ENABLE_DOUBLETAP_ZOOM + && settings.getLoadWithOverviewMode(); + } + mCallbackProxy.uiOnChangeViewingMode(true); + if (!mInZoomOverview) { + // We are going to start zoomed in. However, we + // truly want to show the title bar, and then hide + // it once the page has loaded + mCallbackProxy.uiChangeViewingModeOnFinishedLoad( + false, getOriginalUrl()); + } + setNewZoomScale(mLastScale, false); + setContentScrollTo(restoreState.mScrollX, + restoreState.mScrollY); + // As we are on a new page, remove the WebTextView. This + // is necessary for page loads driven by webkit, and in + // particular when the user was on a password field, so + // the WebTextView was visible. + clearTextEntry(); } // We update the layout (i.e. request a layout from the // view system) if the last view size that we sent to @@ -4634,9 +5060,9 @@ public class WebView extends AbsoluteLayout // received in the fixed dimension. final boolean updateLayout = viewSize.x == mLastWidthSent && viewSize.y == mLastHeightSent; - recordNewContentSize(draw.mWidthHeight.x, + recordNewContentSize(draw.mWidthHeight.x, draw.mWidthHeight.y, updateLayout); - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Rect b = draw.mInvalRegion.getBounds(); Log.v(LOGTAG, "NEW_PICTURE_MSG_ID {" + b.left+","+b.top+","+b.right+","+b.bottom+"}"); @@ -4645,114 +5071,76 @@ public class WebView extends AbsoluteLayout if (mPictureListener != null) { mPictureListener.onNewPicture(WebView.this, capturePicture()); } + if (useWideViewport) { + mZoomOverviewWidth = Math.max(draw.mMinPrefWidth, + draw.mViewPoint.x); + } + if (!mMinZoomScaleFixed) { + mMinZoomScale = (float) viewWidth / mZoomOverviewWidth; + } + if (!mDrawHistory && mInZoomOverview) { + // fit the content width to the current view. Ignore + // the rounding error case. + if (Math.abs((viewWidth * mInvActualScale) + - mZoomOverviewWidth) > 1) { + setNewZoomScale((float) viewWidth + / mZoomOverviewWidth, false); + } + } break; + } case WEBCORE_INITIALIZED_MSG_ID: // nativeCreate sets mNativeClass to a non-zero value nativeCreate(msg.arg1); break; case UPDATE_TEXTFIELD_TEXT_MSG_ID: // Make sure that the textfield is currently focused - // and representing the same node as the pointer. - if (inEditingMode() && - mTextEntry.isSameTextField(msg.arg1)) { + // and representing the same node as the pointer. + if (inEditingMode() && + mWebTextView.isSameTextField(msg.arg1)) { if (msg.getData().getBoolean("password")) { - Spannable text = (Spannable) mTextEntry.getText(); + Spannable text = (Spannable) mWebTextView.getText(); int start = Selection.getSelectionStart(text); int end = Selection.getSelectionEnd(text); - mTextEntry.setInPassword(true); + mWebTextView.setInPassword(true); // Restore the selection, which may have been // ruined by setInPassword. - Spannable pword = (Spannable) mTextEntry.getText(); + Spannable pword = + (Spannable) mWebTextView.getText(); Selection.setSelection(pword, start, end); // If the text entry has created more events, ignore // this one. } else if (msg.arg2 == mTextGeneration) { - mTextEntry.setTextAndKeepSelection( + mWebTextView.setTextAndKeepSelection( (String) msg.obj); } } break; - case DID_FIRST_LAYOUT_MSG_ID: - if (mNativeClass == 0) { - break; - } -// Do not reset the focus or clear the text; the user may have already -// navigated or entered text at this point. The focus should have gotten -// reset, if need be, when the focus cache was built. Similarly, the text -// view should already be torn down and rebuilt if needed. -// nativeResetFocus(); -// clearTextEntry(); - HashMap scaleLimit = (HashMap) msg.obj; - int minScale = (Integer) scaleLimit.get("minScale"); - if (minScale == 0) { - mMinZoomScale = DEFAULT_MIN_ZOOM_SCALE; - mMinZoomScaleFixed = false; - } else { - mMinZoomScale = (float) (minScale / 100.0); - mMinZoomScaleFixed = true; - } - int maxScale = (Integer) scaleLimit.get("maxScale"); - if (maxScale == 0) { - mMaxZoomScale = DEFAULT_MAX_ZOOM_SCALE; - } else { - mMaxZoomScale = (float) (maxScale / 100.0); + case UPDATE_TEXT_SELECTION_MSG_ID: + if (inEditingMode() + && mWebTextView.isSameTextField(msg.arg1) + && msg.arg2 == mTextGeneration) { + WebViewCore.TextSelectionData tData + = (WebViewCore.TextSelectionData) msg.obj; + mWebTextView.setSelectionFromWebKit(tData.mStart, + tData.mEnd); } - // If history Picture is drawn, don't update zoomWidth - if (mDrawHistory) { - break; - } - int width = getViewWidth(); - if (width == 0) { - break; - } - int initialScale = msg.arg1; - int viewportWidth = msg.arg2; - // start a new page with DEFAULT_SCALE zoom scale. - float scale = mDefaultScale; - if (mInitialScale > 0) { - scale = mInitialScale / 100.0f; - } else { - if (mWebViewCore.getSettings().getUseWideViewPort()) { - // force viewSizeChanged by setting mLastWidthSent - // to 0 - mLastWidthSent = 0; - } - if (initialScale == 0) { - // if viewportWidth is defined and it is smaller - // than the view width, zoom in to fill the view - if (viewportWidth > 0 && viewportWidth < width) { - scale = (float) width / viewportWidth; - } - } else { - scale = initialScale / 100.0f; - } - } - setNewZoomScale(scale, false); break; - case MARK_NODE_INVALID_ID: - nativeMarkNodeInvalid(msg.arg1); - break; - case NOTIFY_FOCUS_SET_MSG_ID: - if (mNativeClass != 0) { - nativeNotifyFocusSet(inEditingMode()); + case MOVE_OUT_OF_PLUGIN: + if (nativePluginEatsNavKey()) { + navHandledKey(msg.arg1, 1, false, 0, true); } break; case UPDATE_TEXT_ENTRY_MSG_ID: - // this is sent after finishing resize in WebViewCore. Make + // this is sent after finishing resize in WebViewCore. Make // sure the text edit box is still on the screen. - boolean alreadyThere = inEditingMode(); - if (alreadyThere && nativeUpdateFocusNode()) { - FocusNode node = mFocusNode; - if (node.mIsTextField || node.mIsTextArea) { - mTextEntry.bringIntoView(); - } + if (inEditingMode() && nativeCursorIsTextInput()) { + mWebTextView.bringIntoView(); + rebuildWebTextView(); } - updateTextEntry(); break; - case RECOMPUTE_FOCUS_MSG_ID: - if (mNativeClass != 0) { - nativeRecomputeFocus(); - } + case CLEAR_TEXT_ENTRY: + clearTextEntry(); break; case INVAL_RECT_MSG_ID: { Rect r = (Rect)msg.obj; @@ -4765,17 +5153,15 @@ public class WebView extends AbsoluteLayout } break; } - case UPDATE_TEXT_ENTRY_ADAPTER: - HashMap data = (HashMap) msg.obj; - if (mTextEntry.isSameTextField(msg.arg1)) { - AutoCompleteAdapter adapter = - (AutoCompleteAdapter) data.get("adapter"); - mTextEntry.setAdapterCustom(adapter); + case REQUEST_FORM_DATA: + AutoCompleteAdapter adapter = (AutoCompleteAdapter) msg.obj; + if (mWebTextView.isSameTextField(msg.arg1)) { + mWebTextView.setAdapterCustom(adapter); } break; case UPDATE_CLIPBOARD: String str = (String) msg.obj; - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW) { Log.v(LOGTAG, "UPDATE_CLIPBOARD " + str); } try { @@ -4790,12 +5176,12 @@ public class WebView extends AbsoluteLayout WebViewCore.resumeUpdate(mWebViewCore); break; - case LONG_PRESS_ENTER: + case LONG_PRESS_CENTER: // as this is shared by keydown and trackballdown, reset all // the states - mGotEnterDown = false; + mGotCenterDown = false; mTrackballDown = false; - // LONG_PRESS_ENTER is sent as a delayed message. If we + // LONG_PRESS_CENTER is sent as a delayed message. If we // switch to windows overview, the WebView will be // temporarily removed from the view system. In that case, // do nothing. @@ -4817,6 +5203,14 @@ public class WebView extends AbsoluteLayout } break; + case REQUEST_KEYBOARD: + if (msg.arg1 == 0) { + hideSoftKeyboard(); + } else { + displaySoftKeyboard(false); + } + break; + default: super.handleMessage(msg); break; @@ -4826,16 +5220,12 @@ public class WebView extends AbsoluteLayout // Class used to use a dropdown for a <select> element private class InvokeListBox implements Runnable { - // Strings for the labels in the listbox. - private String[] mArray; - // Array representing whether each item is enabled. - private boolean[] mEnableArray; // Whether the listbox allows multiple selection. private boolean mMultiple; // Passed in to a list with multiple selection to tell // which items are selected. private int[] mSelectedArray; - // Passed in to a list with single selection to tell + // Passed in to a list with single selection to tell // where the initial selection is. private int mSelection; @@ -4854,14 +5244,14 @@ public class WebView extends AbsoluteLayout } /** - * Subclass ArrayAdapter so we can disable OptionGroupLabels, + * Subclass ArrayAdapter so we can disable OptionGroupLabels, * and allow filtering. */ private class MyArrayListAdapter extends ArrayAdapter<Container> { public MyArrayListAdapter(Context context, Container[] objects, boolean multiple) { - super(context, + super(context, multiple ? com.android.internal.R.layout.select_dialog_multichoice : - com.android.internal.R.layout.select_dialog_singlechoice, + com.android.internal.R.layout.select_dialog_singlechoice, objects); } @@ -4919,7 +5309,7 @@ public class WebView extends AbsoluteLayout } } - private InvokeListBox(String[] array, boolean[] enabled, int + private InvokeListBox(String[] array, boolean[] enabled, int selection) { mSelection = selection; mMultiple = false; @@ -4982,31 +5372,36 @@ public class WebView extends AbsoluteLayout public void run() { final ListView listView = (ListView) LayoutInflater.from(mContext) .inflate(com.android.internal.R.layout.select_dialog, null); - final MyArrayListAdapter adapter = new + final MyArrayListAdapter adapter = new MyArrayListAdapter(mContext, mContainers, mMultiple); AlertDialog.Builder b = new AlertDialog.Builder(mContext) .setView(listView).setCancelable(true) .setInverseBackgroundForced(true); - + if (mMultiple) { b.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) { mWebViewCore.sendMessage( - EventHub.LISTBOX_CHOICES, + EventHub.LISTBOX_CHOICES, adapter.getCount(), 0, listView.getCheckedItemPositions()); }}); - b.setNegativeButton(android.R.string.cancel, null); + b.setNegativeButton(android.R.string.cancel, + new DialogInterface.OnClickListener() { + public void onClick(DialogInterface dialog, int which) { + mWebViewCore.sendMessage( + EventHub.SINGLE_LISTBOX_CHOICE, -2, 0); + }}); } final AlertDialog dialog = b.create(); listView.setAdapter(adapter); listView.setFocusableInTouchMode(true); // There is a bug (1250103) where the checks in a ListView with // multiple items selected are associated with the positions, not - // the ids, so the items do not properly retain their checks when + // the ids, so the items do not properly retain their checks when // filtered. Do not allow filtering on multiple lists until // that bug is fixed. - + listView.setTextFilterEnabled(!mMultiple); if (mMultiple) { listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE); @@ -5069,48 +5464,39 @@ public class WebView extends AbsoluteLayout } // called by JNI - private void sendFinalFocus(int frame, int node, int x, int y) { - WebViewCore.FocusData focusData = new WebViewCore.FocusData(); - focusData.mFrame = frame; - focusData.mNode = node; - focusData.mX = x; - focusData.mY = y; - mWebViewCore.sendMessage(EventHub.SET_FINAL_FOCUS, - EventHub.NO_FOCUS_CHANGE_BLOCK, 0, focusData); + private void sendMoveMouse(int frame, int node, int x, int y) { + mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE, + new WebViewCore.CursorData(frame, node, x, y)); } - // called by JNI - private void setFocusData(int moveGeneration, int buildGeneration, - int frame, int node, int x, int y, boolean ignoreNullFocus) { - mFocusData.mMoveGeneration = moveGeneration; - mFocusData.mBuildGeneration = buildGeneration; - mFocusData.mFrame = frame; - mFocusData.mNode = node; - mFocusData.mX = x; - mFocusData.mY = y; - mFocusData.mIgnoreNullFocus = ignoreNullFocus; - } - - // called by JNI - private void sendKitFocus() { - WebViewCore.FocusData focusData = new WebViewCore.FocusData(mFocusData); - mWebViewCore.sendMessage(EventHub.SET_KIT_FOCUS, focusData); + /* + * Send a mouse move event to the webcore thread. + * + * @param removeFocus Pass true if the "mouse" cursor is now over a node + * which wants key events, but it is not the focus. This + * will make the visual appear as though nothing is in + * focus. Remove the WebTextView, if present, and stop + * drawing the blinking caret. + * called by JNI + */ + private void sendMoveMouseIfLatest(boolean removeFocus) { + if (removeFocus) { + clearTextEntry(); + setFocusControllerInactive(); + } + mWebViewCore.sendMessage(EventHub.SET_MOVE_MOUSE_IF_LATEST, + cursorData()); } // called by JNI - private void sendMotionUp(int touchGeneration, int buildGeneration, - int frame, int node, int x, int y, int size, boolean isClick, - boolean retry) { + private void sendMotionUp(int touchGeneration, + int frame, int node, int x, int y) { WebViewCore.TouchUpData touchUpData = new WebViewCore.TouchUpData(); touchUpData.mMoveGeneration = touchGeneration; - touchUpData.mBuildGeneration = buildGeneration; - touchUpData.mSize = size; - touchUpData.mIsClick = isClick; - touchUpData.mRetry = retry; - mFocusData.mFrame = touchUpData.mFrame = frame; - mFocusData.mNode = touchUpData.mNode = node; - mFocusData.mX = touchUpData.mX = x; - mFocusData.mY = touchUpData.mY = y; + touchUpData.mFrame = frame; + touchUpData.mNode = node; + touchUpData.mX = x; + touchUpData.mY = y; mWebViewCore.sendMessage(EventHub.TOUCH_UP, touchUpData); } @@ -5149,56 +5535,72 @@ public class WebView extends AbsoluteLayout private void viewInvalidate() { invalidate(); } - + // return true if the key was handled - private boolean navHandledKey(int keyCode, int count, boolean noScroll - , long time) { + private boolean navHandledKey(int keyCode, int count, boolean noScroll, + long time, boolean ignorePlugin) { if (mNativeClass == 0) { return false; } - mLastFocusTime = time; - mLastFocusBounds = nativeGetFocusRingBounds(); - boolean keyHandled = nativeMoveFocus(keyCode, count, noScroll) == false; - if (LOGV_ENABLED) { - Log.v(LOGTAG, "navHandledKey mLastFocusBounds=" + mLastFocusBounds - + " mLastFocusTime=" + mLastFocusTime + if (ignorePlugin == false && nativePluginEatsNavKey()) { + KeyEvent event = new KeyEvent(time, time, KeyEvent.ACTION_DOWN + , keyCode, count, (mShiftIsPressed ? KeyEvent.META_SHIFT_ON : 0) + | (false ? KeyEvent.META_ALT_ON : 0) // FIXME + | (false ? KeyEvent.META_SYM_ON : 0) // FIXME + , 0, 0, 0); + mWebViewCore.sendMessage(EventHub.KEY_DOWN, event); + mWebViewCore.sendMessage(EventHub.KEY_UP, event); + return true; + } + mLastCursorTime = time; + mLastCursorBounds = nativeGetCursorRingBounds(); + boolean keyHandled + = nativeMoveCursor(keyCode, count, noScroll) == false; + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "navHandledKey mLastCursorBounds=" + mLastCursorBounds + + " mLastCursorTime=" + mLastCursorTime + " handled=" + keyHandled); } if (keyHandled == false || mHeightCanMeasure == false) { return keyHandled; } - Rect contentFocus = nativeGetFocusRingBounds(); - if (contentFocus.isEmpty()) return keyHandled; - Rect viewFocus = contentToView(contentFocus); + Rect contentCursorRingBounds = nativeGetCursorRingBounds(); + if (contentCursorRingBounds.isEmpty()) return keyHandled; + Rect viewCursorRingBounds = contentToView(contentCursorRingBounds); Rect visRect = new Rect(); calcOurVisibleRect(visRect); Rect outset = new Rect(visRect); int maxXScroll = visRect.width() / 2; int maxYScroll = visRect.height() / 2; outset.inset(-maxXScroll, -maxYScroll); - if (Rect.intersects(outset, viewFocus) == false) { + if (Rect.intersects(outset, viewCursorRingBounds) == false) { return keyHandled; } // FIXME: Necessary because ScrollView/ListView do not scroll left/right - int maxH = Math.min(viewFocus.right - visRect.right, maxXScroll); + int maxH = Math.min(viewCursorRingBounds.right - visRect.right, + maxXScroll); if (maxH > 0) { pinScrollBy(maxH, 0, true, 0); } else { - maxH = Math.max(viewFocus.left - visRect.left, -maxXScroll); + maxH = Math.max(viewCursorRingBounds.left - visRect.left, + -maxXScroll); if (maxH < 0) { pinScrollBy(maxH, 0, true, 0); } } - if (mLastFocusBounds.isEmpty()) return keyHandled; - if (mLastFocusBounds.equals(contentFocus)) return keyHandled; - if (LOGV_ENABLED) { - Log.v(LOGTAG, "navHandledKey contentFocus=" + contentFocus); + if (mLastCursorBounds.isEmpty()) return keyHandled; + if (mLastCursorBounds.equals(contentCursorRingBounds)) { + return keyHandled; } - requestRectangleOnScreen(viewFocus); + if (DebugFlags.WEB_VIEW) { + Log.v(LOGTAG, "navHandledKey contentCursorRingBounds=" + + contentCursorRingBounds); + } + requestRectangleOnScreen(viewCursorRingBounds); mUserScroll = true; return keyHandled; } - + /** * Set the background color. It's white by default. Pass * zero to make the view transparent. @@ -5213,7 +5615,7 @@ public class WebView extends AbsoluteLayout nativeDebugDump(); mWebViewCore.sendMessage(EventHub.DUMP_NAVTREE); } - + /** * Update our cache with updatedText. * @param updatedText The new text to put in our cache. @@ -5223,52 +5625,85 @@ public class WebView extends AbsoluteLayout // we recognize that it is up to date. nativeUpdateCachedTextfield(updatedText, mTextGeneration); } - - // Never call this version except by updateCachedTextfield(String) - - // we always want to pass in our generation number. - private native void nativeUpdateCachedTextfield(String updatedText, - int generation); - private native void nativeClearFocus(int x, int y); + + /* package */ native void nativeClearCursor(); private native void nativeCreate(int ptr); + private native int nativeCursorFramePointer(); + private native Rect nativeCursorNodeBounds(); + /* package */ native int nativeCursorNodePointer(); + /* package */ native boolean nativeCursorMatchesFocus(); + private native boolean nativeCursorIntersects(Rect visibleRect); + private native boolean nativeCursorIsAnchor(); + private native boolean nativeCursorIsPlugin(); + private native boolean nativeCursorIsTextInput(); + private native Point nativeCursorPosition(); + private native String nativeCursorText(); + /** + * Returns true if the native cursor node says it wants to handle key events + * (ala plugins). This can only be called if mNativeClass is non-zero! + */ + private native boolean nativeCursorWantsKeyEvents(); private native void nativeDebugDump(); private native void nativeDestroy(); - private native void nativeDrawFocusRing(Canvas content); + private native void nativeDrawCursorRing(Canvas content); + private native void nativeDrawMatches(Canvas canvas); private native void nativeDrawSelection(Canvas content , int x, int y, boolean extendSelection); private native void nativeDrawSelectionRegion(Canvas content); - private native boolean nativeUpdateFocusNode(); - private native Rect nativeGetFocusRingBounds(); - private native Rect nativeGetNavBounds(); + private native void nativeDumpDisplayTree(String urlOrNull); + private native int nativeFindAll(String findLower, String findUpper); + private native void nativeFindNext(boolean forward); + private native boolean nativeFocusCandidateIsPassword(); + private native boolean nativeFocusCandidateIsRtlText(); + private native boolean nativeFocusCandidateIsTextField(); + private native boolean nativeFocusCandidateIsTextInput(); + private native int nativeFocusCandidateMaxLength(); + /* package */ native String nativeFocusCandidateName(); + private native Rect nativeFocusCandidateNodeBounds(); + /* package */ native int nativeFocusCandidatePointer(); + private native String nativeFocusCandidateText(); + private native int nativeFocusCandidateTextSize(); + /* package */ native int nativeFocusNodePointer(); + private native Rect nativeGetCursorRingBounds(); + private native Region nativeGetSelection(); + private native boolean nativeHasCursorNode(); + private native boolean nativeHasFocusNode(); + private native void nativeHideCursor(); + private native String nativeImageURI(int x, int y); private native void nativeInstrumentReport(); - private native void nativeMarkNodeInvalid(int node); + /* package */ native void nativeMoveCursorToNextTextInput(); // return true if the page has been scrolled - private native boolean nativeMotionUp(int x, int y, int slop, boolean isClick); + private native boolean nativeMotionUp(int x, int y, int slop); // returns false if it handled the key - private native boolean nativeMoveFocus(int keyCode, int count, + private native boolean nativeMoveCursor(int keyCode, int count, boolean noScroll); - private native void nativeNotifyFocusSet(boolean inEditingMode); - private native void nativeRecomputeFocus(); + private native int nativeMoveGeneration(); + private native void nativeMoveSelection(int x, int y, + boolean extendSelection); + private native boolean nativePluginEatsNavKey(); // Like many other of our native methods, you must make sure that // mNativeClass is not null before calling this method. private native void nativeRecordButtons(boolean focused, boolean pressed, boolean invalidate); - private native void nativeResetFocus(); - private native void nativeResetNavClipBounds(); private native void nativeSelectBestAt(Rect rect); private native void nativeSetFindIsDown(); private native void nativeSetFollowedLink(boolean followed); private native void nativeSetHeightCanMeasure(boolean measure); - private native void nativeSetNavBounds(Rect rect); - private native void nativeSetNavClipBounds(Rect rect); - private native String nativeImageURI(int x, int y); + // Returns a value corresponding to CachedFrame::ImeAction + /* package */ native int nativeTextFieldAction(); /** - * Returns true if the native focus nodes says it wants to handle key events - * (ala plugins). This can only be called if mNativeClass is non-zero! + * Perform a click on a currently focused text input. Since it is already + * focused, there is no need to go through the nativeMotionUp code, which + * may change the Cursor. */ - private native boolean nativeFocusNodeWantsKeyEvents(); - private native void nativeMoveSelection(int x, int y - , boolean extendSelection); - private native Region nativeGetSelection(); - - private native void nativeDumpDisplayTree(String urlOrNull); + private native void nativeTextInputMotionUp(int x, int y); + private native int nativeTextGeneration(); + // Never call this version except by updateCachedTextfield(String) - + // we always want to pass in our generation number. + private native void nativeUpdateCachedTextfield(String updatedText, + int generation); + private native void nativeUpdatePluginReceivesEvents(); + // return NO_LEFTEDGE means failure. + private static final int NO_LEFTEDGE = -1; + private native int nativeGetBlockLeftEdge(int x, int y, float scale); } diff --git a/core/java/android/webkit/WebViewCore.java b/core/java/android/webkit/WebViewCore.java index a5fa41e..dee62b4 100644 --- a/core/java/android/webkit/WebViewCore.java +++ b/core/java/android/webkit/WebViewCore.java @@ -32,17 +32,17 @@ import android.os.Process; import android.util.Log; import android.util.SparseBooleanArray; import android.view.KeyEvent; +import android.view.SurfaceHolder; +import android.view.SurfaceView; import java.util.ArrayList; -import java.util.HashMap; +import java.util.Set; import junit.framework.Assert; final class WebViewCore { private static final String LOGTAG = "webcore"; - static final boolean DEBUG = false; - static final boolean LOGV_ENABLED = DEBUG; static { // Load libwebcore during static initialization. This happens in the @@ -96,14 +96,19 @@ final class WebViewCore { private int mViewportMaximumScale = 0; private boolean mViewportUserScalable = true; - - private int mRestoredScale = WebView.DEFAULT_SCALE_PERCENT; + + private int mRestoredScale = 0; + private int mRestoredScreenWidthScale = 0; private int mRestoredX = 0; private int mRestoredY = 0; private int mWebkitScrollX = 0; private int mWebkitScrollY = 0; + // If the site doesn't use viewport meta tag to specify the viewport, use + // DEFAULT_VIEWPORT_WIDTH as default viewport width + static final int DEFAULT_VIEWPORT_WIDTH = 800; + // The thread name used to identify the WebCore thread and for use in // debugging other classes that require operation within the WebCore thread. /* package */ static final String THREAD_NAME = "WebViewCoreThread"; @@ -143,6 +148,8 @@ final class WebViewCore { // The WebIconDatabase needs to be initialized within the UI thread so // just request the instance here. WebIconDatabase.getInstance(); + // Create the WebStorage singleton + WebStorage.getInstance(); // Send a message to initialize the WebViewCore. Message init = sWebCoreHandler.obtainMessage( WebCoreThread.INITIALIZE, this); @@ -162,6 +169,10 @@ final class WebViewCore { mSettings.syncSettingsAndCreateHandler(mBrowserFrame); // Create the handler and transfer messages for the IconDatabase WebIconDatabase.getInstance().createHandler(); + // Create the handler for WebStorage + WebStorage.getInstance().createHandler(); + // Create the handler for GeolocationPermissions. + GeolocationPermissions.getInstance().createHandler(); // The transferMessages call will transfer all pending messages to the // WebCore thread handler. mEventHub.transferMessages(); @@ -225,6 +236,16 @@ final class WebViewCore { } /** + * Add an error message to the client's console. + * @param message The message to add + * @param lineNumber the line on which the error occurred + * @param sourceID the filename of the source that caused the error. + */ + protected void addMessageToConsole(String message, int lineNumber, String sourceID) { + mCallbackProxy.addMessageToConsole(message, lineNumber, sourceID); + } + + /** * Invoke a javascript alert. * @param message The message displayed in the alert. */ @@ -233,6 +254,68 @@ final class WebViewCore { } /** + * Notify the browser that the origin has exceeded it's database quota. + * @param url The URL that caused the overflow. + * @param databaseIdentifier The identifier of the database. + * @param currentQuota The current quota for the origin. + */ + protected void exceededDatabaseQuota(String url, + String databaseIdentifier, + long currentQuota) { + // Inform the callback proxy of the quota overflow. Send an object + // that encapsulates a call to the nativeSetDatabaseQuota method to + // awaken the sleeping webcore thread when a decision from the + // client to allow or deny quota is available. + mCallbackProxy.onExceededDatabaseQuota(url, databaseIdentifier, + currentQuota, getUsedQuota(), new WebStorage.QuotaUpdater() { + public void updateQuota(long quota) { + nativeSetNewStorageLimit(quota); + } + }); + } + + /** + * Notify the browser that the appcache has exceeded its max size. + * @param spaceNeeded is the amount of disk space that would be needed + * in order for the last appcache operation to succeed. + */ + protected void reachedMaxAppCacheSize(long spaceNeeded) { + mCallbackProxy.onReachedMaxAppCacheSize(spaceNeeded, getUsedQuota(), + new WebStorage.QuotaUpdater() { + public void updateQuota(long quota) { + nativeSetNewStorageLimit(quota); + } + }); + } + + /** + * Shows a prompt to ask the user to set the Geolocation permission state + * for the given origin. + * @param origin The origin for which Geolocation permissions are + * requested. + */ + protected void geolocationPermissionsShowPrompt(String origin) { + mCallbackProxy.onGeolocationPermissionsShowPrompt(origin, + new GeolocationPermissions.Callback() { + public void invoke(String origin, boolean allow, boolean remember) { + GeolocationPermissionsData data = new GeolocationPermissionsData(); + data.mOrigin = origin; + data.mAllow = allow; + data.mRemember = remember; + // Marshall to WebCore thread. + sendMessage(EventHub.GEOLOCATION_PERMISSIONS_PROVIDE, data); + } + }); + } + + /** + * Hides the Geolocation permissions prompt. + */ + protected void geolocationPermissionsHidePrompt() { + mCallbackProxy.onGeolocationPermissionsHidePrompt(); + } + + /** * Invoke a javascript confirm dialog. * @param message The message displayed in the dialog. * @return True if the user confirmed or false if the user cancelled. @@ -277,31 +360,36 @@ final class WebViewCore { // JNI methods //------------------------------------------------------------------------- - static native String nativeFindAddress(String addr); + static native String nativeFindAddress(String addr, boolean caseInsensitive); /** * Empty the picture set. */ private native void nativeClearContent(); - + /** * Create a flat picture from the set of pictures. */ private native void nativeCopyContentToPicture(Picture picture); - + /** * Draw the picture set with a background color. Returns true - * if some individual picture took too long to draw and can be + * if some individual picture took too long to draw and can be * split into parts. Called from the UI thread. */ private native boolean nativeDrawContent(Canvas canvas, int color); - + + /** + * check to see if picture is blank and in progress + */ + private native boolean nativePictureReady(); + /** * Redraw a portion of the picture set. The Point wh returns the * width and height of the overall picture. */ private native boolean nativeRecordContent(Region invalRegion, Point wh); - + /** * Splits slow parts of the picture set. Called from the webkit * thread after nativeDrawContent returns true. @@ -309,9 +397,10 @@ final class WebViewCore { private native void nativeSplitContent(); private native boolean nativeKey(int keyCode, int unichar, - int repeatCount, boolean isShift, boolean isAlt, boolean isDown); + int repeatCount, boolean isShift, boolean isAlt, boolean isSym, + boolean isDown); - private native boolean nativeClick(); + private native void nativeClick(int framePtr, int nodePtr); private native void nativeSendListBoxChoices(boolean[] choices, int size); @@ -329,60 +418,54 @@ final class WebViewCore { float scale, int realScreenWidth, int screenHeight); private native int nativeGetContentMinPrefWidth(); - + // Start: functions that deal with text editing - private native void nativeReplaceTextfieldText(int frame, int node, int x, - int y, int oldStart, int oldEnd, String replace, int newStart, - int newEnd); + private native void nativeReplaceTextfieldText( + int oldStart, int oldEnd, String replace, int newStart, int newEnd, + int textGeneration); - private native void passToJs(int frame, int node, int x, int y, int gen, + private native void passToJs(int gen, String currentText, int keyCode, int keyValue, boolean down, boolean cap, boolean fn, boolean sym); + private native void nativeSetFocusControllerActive(boolean active); + private native void nativeSaveDocumentState(int frame); - private native void nativeSetFinalFocus(int framePtr, int nodePtr, int x, - int y, boolean block); + private native void nativeMoveMouse(int framePtr, int x, int y); - private native void nativeSetKitFocus(int moveGeneration, - int buildGeneration, int framePtr, int nodePtr, int x, int y, - boolean ignoreNullFocus); + private native void nativeMoveMouseIfLatest(int moveGeneration, + int framePtr, int x, int y); private native String nativeRetrieveHref(int framePtr, int nodePtr); - - private native void nativeTouchUp(int touchGeneration, - int buildGeneration, int framePtr, int nodePtr, int x, int y, - int size, boolean isClick, boolean retry); + + private native void nativeTouchUp(int touchGeneration, + int framePtr, int nodePtr, int x, int y); private native boolean nativeHandleTouchEvent(int action, int x, int y); - private native void nativeUnblockFocus(); - private native void nativeUpdateFrameCache(); - - private native void nativeSetSnapAnchor(int x, int y); - - private native void nativeSnapToAnchor(); - + private native void nativeSetBackgroundColor(int color); - + private native void nativeDumpDomTree(boolean useFile); private native void nativeDumpRenderTree(boolean useFile); private native void nativeDumpNavTree(); - private native void nativeRefreshPlugins(boolean reloadOpenPages); - + private native void nativeSetJsFlags(String flags); + /** * Delete text from start to end in the focused textfield. If there is no - * focus, or if start == end, silently fail. If start and end are out of + * focus, or if start == end, silently fail. If start and end are out of * order, swap them. * @param start Beginning of selection to delete. * @param end End of selection to delete. + * @param textGeneration Text generation number when delete was pressed. */ - private native void nativeDeleteSelection(int frame, int node, int x, int y, - int start, int end); + private native void nativeDeleteSelection(int start, int end, + int textGeneration); /** * Set the selection to (start, end) in the focused textfield. If start and @@ -390,15 +473,34 @@ final class WebViewCore { * @param start Beginning of selection. * @param end End of selection. */ - private native void nativeSetSelection(int frame, int node, int x, int y, - int start, int end); + private native void nativeSetSelection(int start, int end); private native String nativeGetSelection(Region sel); - + // Register a scheme to be treated as local scheme so that it can access // local asset files for resources private native void nativeRegisterURLSchemeAsLocal(String scheme); + /* + * Inform webcore that the user has decided whether to allow or deny new + * quota for the current origin or more space for the app cache, and that + * the main thread should wake up now. + * @param limit Is the new quota for an origin or new app cache max size. + */ + private native void nativeSetNewStorageLimit(long limit); + + private native void nativeUpdatePluginState(int framePtr, int nodePtr, int state); + + /** + * Provide WebCore with a Geolocation permission state for the specified + * origin. + * @param origin The origin for which Geolocation permissions are provided. + * @param allow Whether Geolocation permissions are allowed. + * @param remember Whether this decision should be remembered beyond the + * life of the current page. + */ + private native void nativeGeolocationPermissionsProvide(String origin, boolean allow, boolean remember); + // EventHub for processing messages private final EventHub mEventHub; // WebCore thread handler @@ -447,7 +549,7 @@ final class WebViewCore { CacheManager.endCacheTransaction(); CacheManager.startCacheTransaction(); sendMessageDelayed( - obtainMessage(CACHE_TICKER), + obtainMessage(CACHE_TICKER), CACHE_TICKER_INTERVAL); } break; @@ -472,36 +574,64 @@ final class WebViewCore { } } - static class FocusData { - FocusData() {} - FocusData(FocusData d) { - mMoveGeneration = d.mMoveGeneration; - mBuildGeneration = d.mBuildGeneration; - mFrame = d.mFrame; - mNode = d.mNode; - mX = d.mX; - mY = d.mY; - mIgnoreNullFocus = d.mIgnoreNullFocus; + static class BaseUrlData { + String mBaseUrl; + String mData; + String mMimeType; + String mEncoding; + String mFailUrl; + } + + static class CursorData { + CursorData() {} + CursorData(int frame, int node, int x, int y) { + mFrame = frame; + mX = x; + mY = y; } int mMoveGeneration; - int mBuildGeneration; int mFrame; - int mNode; int mX; int mY; - boolean mIgnoreNullFocus; + } + + static class JSInterfaceData { + Object mObject; + String mInterfaceName; + } + + static class JSKeyData { + String mCurrentText; + KeyEvent mEvent; + } + + static class PostUrlData { + String mUrl; + byte[] mPostData; + } + + static class ReplaceTextData { + String mReplace; + int mNewStart; + int mNewEnd; + int mTextGeneration; + } + + static class TextSelectionData { + public TextSelectionData(int start, int end) { + mStart = start; + mEnd = end; + } + int mStart; + int mEnd; } static class TouchUpData { int mMoveGeneration; - int mBuildGeneration; int mFrame; int mNode; int mX; int mY; - int mSize; - boolean mIsClick; - boolean mRetry; } static class TouchEventData { @@ -510,7 +640,21 @@ final class WebViewCore { int mY; } + static class PluginStateData { + int mFrame; + int mNode; + int mState; + } + + static class GeolocationPermissionsData { + String mOrigin; + boolean mAllow; + boolean mRemember; + } + static final String[] HandlerDebugString = { + "UPDATE_FRAME_CACHE_IF_LOADING", // = 98 + "SCROLL_TEXT_INPUT", // = 99 "LOAD_URL", // = 100; "STOP_LOADING", // = 101; "RELOAD", // = 102; @@ -532,33 +676,37 @@ final class WebViewCore { "CLICK", // = 118; "SET_NETWORK_STATE", // = 119; "DOC_HAS_IMAGES", // = 120; - "SET_SNAP_ANCHOR", // = 121; + "121", // = 121; "DELETE_SELECTION", // = 122; "LISTBOX_CHOICES", // = 123; "SINGLE_LISTBOX_CHOICE", // = 124; - "125", + "MESSAGE_RELAY", // = 125; "SET_BACKGROUND_COLOR", // = 126; - "UNBLOCK_FOCUS", // = 127; + "PLUGIN_STATE", // = 127; "SAVE_DOCUMENT_STATE", // = 128; "GET_SELECTION", // = 129; "WEBKIT_DRAW", // = 130; "SYNC_SCROLL", // = 131; - "REFRESH_PLUGINS", // = 132; - // this will replace REFRESH_PLUGINS in the next release - "POST_URL", // = 142; + "POST_URL", // = 132; "SPLIT_PICTURE_SET", // = 133; "CLEAR_CONTENT", // = 134; - "SET_FINAL_FOCUS", // = 135; - "SET_KIT_FOCUS", // = 136; - "REQUEST_FOCUS_HREF", // = 137; + "SET_MOVE_MOUSE", // = 135; + "SET_MOVE_MOUSE_IF_LATEST", // = 136; + "REQUEST_CURSOR_HREF", // = 137; "ADD_JS_INTERFACE", // = 138; "LOAD_DATA", // = 139; "TOUCH_UP", // = 140; "TOUCH_EVENT", // = 141; + "SET_ACTIVE", // = 142; + "ON_PAUSE", // = 143 + "ON_RESUME", // = 144 + "FREE_MEMORY", // = 145 }; class EventHub { // Message Ids + static final int UPDATE_FRAME_CACHE_IF_LOADING = 98; + static final int SCROLL_TEXT_INPUT = 99; static final int LOAD_URL = 100; static final int STOP_LOADING = 101; static final int RELOAD = 102; @@ -580,26 +728,24 @@ final class WebViewCore { static final int CLICK = 118; static final int SET_NETWORK_STATE = 119; static final int DOC_HAS_IMAGES = 120; - static final int SET_SNAP_ANCHOR = 121; static final int DELETE_SELECTION = 122; static final int LISTBOX_CHOICES = 123; static final int SINGLE_LISTBOX_CHOICE = 124; + static final int MESSAGE_RELAY = 125; static final int SET_BACKGROUND_COLOR = 126; - static final int UNBLOCK_FOCUS = 127; + static final int PLUGIN_STATE = 127; // plugin notifications static final int SAVE_DOCUMENT_STATE = 128; static final int GET_SELECTION = 129; static final int WEBKIT_DRAW = 130; static final int SYNC_SCROLL = 131; - static final int REFRESH_PLUGINS = 132; - // this will replace REFRESH_PLUGINS in the next release - static final int POST_URL = 142; + static final int POST_URL = 132; static final int SPLIT_PICTURE_SET = 133; static final int CLEAR_CONTENT = 134; - + // UI nav messages - static final int SET_FINAL_FOCUS = 135; - static final int SET_KIT_FOCUS = 136; - static final int REQUEST_FOCUS_HREF = 137; + static final int SET_MOVE_MOUSE = 135; + static final int SET_MOVE_MOUSE_IF_LATEST = 136; + static final int REQUEST_CURSOR_HREF = 137; static final int ADD_JS_INTERFACE = 138; static final int LOAD_DATA = 139; @@ -608,6 +754,17 @@ final class WebViewCore { // message used to pass UI touch events to WebCore static final int TOUCH_EVENT = 141; + // Used to tell the focus controller not to draw the blinking cursor, + // based on whether the WebView has focus and whether the WebView's + // cursor matches the webpage's focus. + static final int SET_ACTIVE = 142; + + // lifecycle activities for just this DOM (unlike pauseTimers, which + // is global) + static final int ON_PAUSE = 143; + static final int ON_RESUME = 144; + static final int FREE_MEMORY = 145; + // Network-based messaging static final int CLEAR_SSL_PREF_TABLE = 150; @@ -620,12 +777,12 @@ final class WebViewCore { static final int DUMP_RENDERTREE = 171; static final int DUMP_NAVTREE = 172; + static final int SET_JS_FLAGS = 173; + // Geolocation + static final int GEOLOCATION_PERMISSIONS_PROVIDE = 180; + // private message ids private static final int DESTROY = 200; - - // flag values passed to message SET_FINAL_FOCUS - static final int NO_FOCUS_CHANGE_BLOCK = 0; - static final int BLOCK_FOCUS_CHANGE_UNTIL_KEY_UP = 1; // Private handler for WebCore messages. private Handler mHandler; @@ -654,10 +811,14 @@ final class WebViewCore { mHandler = new Handler() { @Override public void handleMessage(Message msg) { - if (LOGV_ENABLED) { - Log.v(LOGTAG, msg.what < LOAD_URL || msg.what - > TOUCH_EVENT ? Integer.toString(msg.what) - : HandlerDebugString[msg.what - LOAD_URL]); + if (DebugFlags.WEB_VIEW_CORE) { + Log.v(LOGTAG, (msg.what < UPDATE_FRAME_CACHE_IF_LOADING + || msg.what + > FREE_MEMORY ? Integer.toString(msg.what) + : HandlerDebugString[msg.what + - UPDATE_FRAME_CACHE_IF_LOADING]) + + " arg1=" + msg.arg1 + " arg2=" + msg.arg2 + + " obj=" + msg.obj); } switch (msg.what) { case WEBKIT_DRAW: @@ -672,20 +833,26 @@ final class WebViewCore { mNativeClass = 0; break; + case UPDATE_FRAME_CACHE_IF_LOADING: + nativeUpdateFrameCacheIfLoading(); + break; + + case SCROLL_TEXT_INPUT: + nativeScrollFocusedTextInput(msg.arg1, msg.arg2); + break; + case LOAD_URL: loadUrl((String) msg.obj); break; case POST_URL: { - HashMap param = (HashMap) msg.obj; - String url = (String) param.get("url"); - byte[] data = (byte[]) param.get("data"); - mBrowserFrame.postUrl(url, data); + PostUrlData param = (PostUrlData) msg.obj; + mBrowserFrame.postUrl(param.mUrl, param.mPostData); break; } case LOAD_DATA: - HashMap loadParams = (HashMap) msg.obj; - String baseUrl = (String) loadParams.get("baseUrl"); + BaseUrlData loadParams = (BaseUrlData) msg.obj; + String baseUrl = loadParams.mBaseUrl; if (baseUrl != null) { int i = baseUrl.indexOf(':'); if (i > 0) { @@ -698,7 +865,7 @@ final class WebViewCore { * we automatically add the scheme of the * baseUrl for local access as long as it is * not http(s)/ftp(s)/about/javascript - */ + */ String scheme = baseUrl.substring(0, i); if (!scheme.startsWith("http") && !scheme.startsWith("ftp") && @@ -709,16 +876,16 @@ final class WebViewCore { } } mBrowserFrame.loadData(baseUrl, - (String) loadParams.get("data"), - (String) loadParams.get("mimeType"), - (String) loadParams.get("encoding"), - (String) loadParams.get("failUrl")); + loadParams.mData, + loadParams.mMimeType, + loadParams.mEncoding, + loadParams.mFailUrl); break; case STOP_LOADING: - // If the WebCore has committed the load, but not - // finished the first layout yet, we need to set - // first layout done to trigger the interpreted side sync + // If the WebCore has committed the load, but not + // finished the first layout yet, we need to set + // first layout done to trigger the interpreted side sync // up with native side if (mBrowserFrame.committed() && !mBrowserFrame.firstLayoutDone()) { @@ -741,20 +908,23 @@ final class WebViewCore { break; case CLICK: - nativeClick(); + nativeClick(msg.arg1, msg.arg2); break; - case VIEW_SIZE_CHANGED: - viewSizeChanged(msg.arg1, msg.arg2, - ((Float) msg.obj).floatValue()); + case VIEW_SIZE_CHANGED: { + WebView.ViewSizeData data = + (WebView.ViewSizeData) msg.obj; + viewSizeChanged(data.mWidth, data.mHeight, + data.mTextWrapWidth, data.mScale); break; - + } case SET_SCROLL_OFFSET: // note: these are in document coordinates // (inv-zoom) - nativeSetScrollOffset(msg.arg1, msg.arg2); + Point pt = (Point) msg.obj; + nativeSetScrollOffset(msg.arg1, pt.x, pt.y); break; - + case SET_GLOBAL_BOUNDS: Rect r = (Rect) msg.obj; nativeSetGlobalBounds(r.left, r.top, r.width(), @@ -765,7 +935,7 @@ final class WebViewCore { // If it is a standard load and the load is not // committed yet, we interpret BACK as RELOAD if (!mBrowserFrame.committed() && msg.arg1 == -1 && - (mBrowserFrame.loadType() == + (mBrowserFrame.loadType() == BrowserFrame.FRAME_LOADTYPE_STANDARD)) { mBrowserFrame.reload(true); } else { @@ -802,6 +972,24 @@ final class WebViewCore { } break; + case ON_PAUSE: + nativePause(); + break; + + case ON_RESUME: + nativeResume(); + break; + + case FREE_MEMORY: + clearCache(false); + nativeFreeMemory(); + break; + + case PLUGIN_STATE: + PluginStateData psd = (PluginStateData) msg.obj; + nativeUpdatePluginState(psd.mFrame, psd.mNode, psd.mState); + break; + case SET_NETWORK_STATE: if (BrowserFrame.sJavaBridge == null) { throw new IllegalStateException("No WebView " + @@ -812,10 +1000,7 @@ final class WebViewCore { break; case CLEAR_CACHE: - mBrowserFrame.clearCache(); - if (msg.arg1 == 1) { - CacheManager.removeAllCacheFiles(); - } + clearCache(msg.arg1 == 1); break; case CLEAR_HISTORY: @@ -823,29 +1008,21 @@ final class WebViewCore { close(mBrowserFrame.mNativeFrame); break; - case REPLACE_TEXT: - HashMap jMap = (HashMap) msg.obj; - FocusData fData = (FocusData) jMap.get("focusData"); - String replace = (String) jMap.get("replace"); - int newStart = - ((Integer) jMap.get("start")).intValue(); - int newEnd = - ((Integer) jMap.get("end")).intValue(); - nativeReplaceTextfieldText(fData.mFrame, - fData.mNode, fData.mX, fData.mY, msg.arg1, - msg.arg2, replace, newStart, newEnd); + case REPLACE_TEXT: + ReplaceTextData rep = (ReplaceTextData) msg.obj; + nativeReplaceTextfieldText(msg.arg1, msg.arg2, + rep.mReplace, rep.mNewStart, rep.mNewEnd, + rep.mTextGeneration); break; case PASS_TO_JS: { - HashMap jsMap = (HashMap) msg.obj; - FocusData fDat = (FocusData) jsMap.get("focusData"); - KeyEvent evt = (KeyEvent) jsMap.get("event"); + JSKeyData jsData = (JSKeyData) msg.obj; + KeyEvent evt = jsData.mEvent; int keyCode = evt.getKeyCode(); int keyValue = evt.getUnicodeChar(); int generation = msg.arg1; - passToJs(fDat.mFrame, fDat.mNode, fDat.mX, fDat.mY, - generation, - (String) jsMap.get("currentText"), + passToJs(generation, + jsData.mCurrentText, keyCode, keyValue, evt.isDown(), @@ -855,8 +1032,8 @@ final class WebViewCore { } case SAVE_DOCUMENT_STATE: { - FocusData fDat = (FocusData) msg.obj; - nativeSaveDocumentState(fDat.mFrame); + CursorData cDat = (CursorData) msg.obj; + nativeSaveDocumentState(cDat.mFrame); break; } @@ -868,11 +1045,8 @@ final class WebViewCore { case TOUCH_UP: TouchUpData touchUpData = (TouchUpData) msg.obj; nativeTouchUp(touchUpData.mMoveGeneration, - touchUpData.mBuildGeneration, touchUpData.mFrame, touchUpData.mNode, - touchUpData.mX, touchUpData.mY, - touchUpData.mSize, touchUpData.mIsClick, - touchUpData.mRetry); + touchUpData.mX, touchUpData.mY); break; case TOUCH_EVENT: { @@ -885,13 +1059,14 @@ final class WebViewCore { break; } + case SET_ACTIVE: + nativeSetFocusControllerActive(msg.arg1 == 1); + break; + case ADD_JS_INTERFACE: - HashMap map = (HashMap) msg.obj; - Object obj = map.get("object"); - String interfaceName = (String) - map.get("interfaceName"); - mBrowserFrame.addJavascriptInterface(obj, - interfaceName); + JSInterfaceData jsData = (JSInterfaceData) msg.obj; + mBrowserFrame.addJavascriptInterface(jsData.mObject, + jsData.mInterfaceName); break; case REQUEST_EXT_REPRESENTATION: @@ -903,35 +1078,27 @@ final class WebViewCore { mBrowserFrame.documentAsText((Message) msg.obj); break; - case SET_FINAL_FOCUS: - FocusData finalData = (FocusData) msg.obj; - nativeSetFinalFocus(finalData.mFrame, - finalData.mNode, finalData.mX, - finalData.mY, msg.arg1 - != EventHub.NO_FOCUS_CHANGE_BLOCK); - break; - - case UNBLOCK_FOCUS: - nativeUnblockFocus(); + case SET_MOVE_MOUSE: + CursorData cursorData = (CursorData) msg.obj; + nativeMoveMouse(cursorData.mFrame, + cursorData.mX, cursorData.mY); break; - case SET_KIT_FOCUS: - FocusData focusData = (FocusData) msg.obj; - nativeSetKitFocus(focusData.mMoveGeneration, - focusData.mBuildGeneration, - focusData.mFrame, focusData.mNode, - focusData.mX, focusData.mY, - focusData.mIgnoreNullFocus); + case SET_MOVE_MOUSE_IF_LATEST: + CursorData cData = (CursorData) msg.obj; + nativeMoveMouseIfLatest(cData.mMoveGeneration, + cData.mFrame, + cData.mX, cData.mY); break; - case REQUEST_FOCUS_HREF: { + case REQUEST_CURSOR_HREF: { Message hrefMsg = (Message) msg.obj; String res = nativeRetrieveHref(msg.arg1, msg.arg2); hrefMsg.getData().putString("url", res); hrefMsg.sendToTarget(); break; } - + case UPDATE_CACHE_AND_TEXT_ENTRY: nativeUpdateFrameCache(); // FIXME: this should provide a minimal rectangle @@ -948,24 +1115,17 @@ final class WebViewCore { imageResult.sendToTarget(); break; - case SET_SNAP_ANCHOR: - nativeSetSnapAnchor(msg.arg1, msg.arg2); - break; - case DELETE_SELECTION: - FocusData delData = (FocusData) msg.obj; - nativeDeleteSelection(delData.mFrame, - delData.mNode, delData.mX, - delData.mY, msg.arg1, msg.arg2); + TextSelectionData deleteSelectionData + = (TextSelectionData) msg.obj; + nativeDeleteSelection(deleteSelectionData.mStart, + deleteSelectionData.mEnd, msg.arg1); break; case SET_SELECTION: - FocusData selData = (FocusData) msg.obj; - nativeSetSelection(selData.mFrame, - selData.mNode, selData.mX, - selData.mY, msg.arg1, msg.arg2); + nativeSetSelection(msg.arg1, msg.arg2); break; - + case LISTBOX_CHOICES: SparseBooleanArray choices = (SparseBooleanArray) msg.obj; @@ -974,18 +1134,18 @@ final class WebViewCore { for (int c = 0; c < choicesSize; c++) { choicesArray[c] = choices.get(c); } - nativeSendListBoxChoices(choicesArray, + nativeSendListBoxChoices(choicesArray, choicesSize); break; case SINGLE_LISTBOX_CHOICE: nativeSendListBoxChoice(msg.arg1); break; - + case SET_BACKGROUND_COLOR: nativeSetBackgroundColor(msg.arg1); break; - + case GET_SELECTION: String str = nativeGetSelection((Region) msg.obj); Message.obtain(mWebView.mPrivateHandler @@ -1005,26 +1165,39 @@ final class WebViewCore { nativeDumpNavTree(); break; + case SET_JS_FLAGS: + nativeSetJsFlags((String)msg.obj); + break; + + case GEOLOCATION_PERMISSIONS_PROVIDE: + GeolocationPermissionsData data = + (GeolocationPermissionsData) msg.obj; + nativeGeolocationPermissionsProvide(data.mOrigin, + data.mAllow, data.mRemember); + break; + case SYNC_SCROLL: mWebkitScrollX = msg.arg1; mWebkitScrollY = msg.arg2; break; - case REFRESH_PLUGINS: - nativeRefreshPlugins(msg.arg1 != 0); - break; - case SPLIT_PICTURE_SET: nativeSplitContent(); mSplitPictureIsScheduled = false; break; - + case CLEAR_CONTENT: // Clear the view so that onDraw() will draw nothing // but white background // (See public method WebView.clearView) nativeClearContent(); break; + + case MESSAGE_RELAY: + if (msg.obj instanceof Message) { + ((Message) msg.obj).sendToTarget(); + } + break; } } }; @@ -1114,7 +1287,7 @@ final class WebViewCore { //------------------------------------------------------------------------- void stopLoading() { - if (LOGV_ENABLED) Log.v(LOGTAG, "CORE stopLoading"); + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "CORE stopLoading"); if (mBrowserFrame != null) { mBrowserFrame.stopLoading(); } @@ -1189,20 +1362,42 @@ final class WebViewCore { // WebViewCore private methods //------------------------------------------------------------------------- + private void clearCache(boolean includeDiskFiles) { + mBrowserFrame.clearCache(); + if (includeDiskFiles) { + CacheManager.removeAllCacheFiles(); + } + } + private void loadUrl(String url) { - if (LOGV_ENABLED) Log.v(LOGTAG, " CORE loadUrl " + url); + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, " CORE loadUrl " + url); mBrowserFrame.loadUrl(url); } private void key(KeyEvent evt, boolean isDown) { - if (LOGV_ENABLED) { + if (DebugFlags.WEB_VIEW_CORE) { Log.v(LOGTAG, "CORE key at " + System.currentTimeMillis() + ", " + evt); } - if (!nativeKey(evt.getKeyCode(), evt.getUnicodeChar(), + int keyCode = evt.getKeyCode(); + if (!nativeKey(keyCode, evt.getUnicodeChar(), evt.getRepeatCount(), evt.isShiftPressed(), evt.isAltPressed(), - isDown)) { + evt.isSymPressed(), + isDown) && keyCode != KeyEvent.KEYCODE_ENTER) { + if (keyCode >= KeyEvent.KEYCODE_DPAD_UP + && keyCode <= KeyEvent.KEYCODE_DPAD_RIGHT) { + if (DebugFlags.WEB_VIEW_CORE) { + Log.v(LOGTAG, "key: arrow unused by plugin: " + keyCode); + } + if (mWebView != null && evt.isDown()) { + Message.obtain(mWebView.mPrivateHandler, + WebView.MOVE_OUT_OF_PLUGIN, keyCode).sendToTarget(); + } + return; + } // bubble up the event handling + // but do not bubble up the ENTER key, which would open the search + // bar without any text. mCallbackProxy.onUnhandledKeyEvent(evt); } } @@ -1210,21 +1405,24 @@ final class WebViewCore { // These values are used to avoid requesting a layout based on old values private int mCurrentViewWidth = 0; private int mCurrentViewHeight = 0; + private float mCurrentViewScale = 1.0f; // notify webkit that our virtual view size changed size (after inv-zoom) - private void viewSizeChanged(int w, int h, float scale) { - if (LOGV_ENABLED) Log.v(LOGTAG, "CORE onSizeChanged"); + private void viewSizeChanged(int w, int h, int textwrapWidth, float scale) { + if (DebugFlags.WEB_VIEW_CORE) { + Log.v(LOGTAG, "viewSizeChanged w=" + w + "; h=" + h + + "; textwrapWidth=" + textwrapWidth + "; scale=" + scale); + } if (w == 0) { Log.w(LOGTAG, "skip viewSizeChanged as w is 0"); return; } - if (mSettings.getUseWideViewPort() - && (w < mViewportWidth || mViewportWidth == -1)) { - int width = mViewportWidth; + int width = w; + if (mSettings.getUseWideViewPort()) { if (mViewportWidth == -1) { - if (mSettings.getLayoutAlgorithm() == + if (mSettings.getLayoutAlgorithm() == WebSettings.LayoutAlgorithm.NORMAL) { - width = WebView.ZOOM_OUT_WIDTH; + width = DEFAULT_VIEWPORT_WIDTH; } else { /* * if a page's minimum preferred width is wider than the @@ -1238,22 +1436,24 @@ final class WebViewCore { * In the worse case, the native width will be adjusted when * next zoom or screen orientation change happens. */ - width = Math.max(w, nativeGetContentMinPrefWidth()); + width = Math.max(w, Math.max(DEFAULT_VIEWPORT_WIDTH, + nativeGetContentMinPrefWidth())); } + } else { + width = Math.max(w, mViewportWidth); } - nativeSetSize(width, Math.round((float) width * h / w), w, scale, - w, h); - } else { - nativeSetSize(w, h, w, scale, w, h); } + nativeSetSize(width, width == w ? h : Math.round((float) width * h / w), + textwrapWidth, scale, w, h); // Remember the current width and height boolean needInvalidate = (mCurrentViewWidth == 0); mCurrentViewWidth = w; mCurrentViewHeight = h; + mCurrentViewScale = scale; if (needInvalidate) { // ensure {@link #webkitDraw} is called as we were blocking in // {@link #contentDraw} when mCurrentViewWidth is 0 - if (LOGV_ENABLED) Log.v(LOGTAG, "viewSizeChanged"); + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "viewSizeChanged"); contentDraw(); } mEventHub.sendMessage(Message.obtain(null, @@ -1267,9 +1467,24 @@ final class WebViewCore { } } + // Utility method for exceededDatabaseQuota and reachedMaxAppCacheSize + // callbacks. Computes the sum of database quota for all origins. + private long getUsedQuota() { + WebStorage webStorage = WebStorage.getInstance(); + Set<String> origins = webStorage.getOrigins(); + if (origins == null) { + return 0; + } + long usedQuota = 0; + for (String origin : origins) { + usedQuota += webStorage.getQuotaForOrigin(origin); + } + return usedQuota; + } + // Used to avoid posting more than one draw message. private boolean mDrawIsScheduled; - + // Used to avoid posting more than one split picture message. private boolean mSplitPictureIsScheduled; @@ -1278,31 +1493,55 @@ final class WebViewCore { // Used to end scale+scroll mode, accessed by both threads boolean mEndScaleZoom = false; - - public class DrawData { - public DrawData() { + + // mRestoreState is set in didFirstLayout(), and reset in the next + // webkitDraw after passing it to the UI thread. + private RestoreState mRestoreState = null; + + static class RestoreState { + float mMinScale; + float mMaxScale; + float mViewScale; + float mTextWrapScale; + int mScrollX; + int mScrollY; + } + + static class DrawData { + DrawData() { mInvalRegion = new Region(); mWidthHeight = new Point(); } - public Region mInvalRegion; - public Point mViewPoint; - public Point mWidthHeight; + Region mInvalRegion; + Point mViewPoint; + Point mWidthHeight; + int mMinPrefWidth; + RestoreState mRestoreState; // only non-null if it is for the first + // picture set after the first layout } - + private void webkitDraw() { mDrawIsScheduled = false; DrawData draw = new DrawData(); - if (LOGV_ENABLED) Log.v(LOGTAG, "webkitDraw start"); - if (nativeRecordContent(draw.mInvalRegion, draw.mWidthHeight) + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "webkitDraw start"); + if (nativeRecordContent(draw.mInvalRegion, draw.mWidthHeight) == false) { - if (LOGV_ENABLED) Log.v(LOGTAG, "webkitDraw abort"); + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "webkitDraw abort"); return; } if (mWebView != null) { // Send the native view size that was used during the most recent // layout. draw.mViewPoint = new Point(mCurrentViewWidth, mCurrentViewHeight); - if (LOGV_ENABLED) Log.v(LOGTAG, "webkitDraw NEW_PICTURE_MSG_ID"); + if (WebView.ENABLE_DOUBLETAP_ZOOM && mSettings.getUseWideViewPort()) { + draw.mMinPrefWidth = Math.max(DEFAULT_VIEWPORT_WIDTH, + nativeGetContentMinPrefWidth()); + } + if (mRestoreState != null) { + draw.mRestoreState = mRestoreState; + mRestoreState = null; + } + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "webkitDraw NEW_PICTURE_MSG_ID"); Message.obtain(mWebView.mPrivateHandler, WebView.NEW_PICTURE_MSG_ID, draw).sendToTarget(); if (mWebkitScrollX != 0 || mWebkitScrollY != 0) { @@ -1312,9 +1551,6 @@ final class WebViewCore { mWebkitScrollY).sendToTarget(); mWebkitScrollX = mWebkitScrollY = 0; } - // nativeSnapToAnchor() needs to be called after NEW_PICTURE_MSG_ID - // is sent, so that scroll will be based on the new content size. - nativeSnapToAnchor(); } } @@ -1350,6 +1586,10 @@ final class WebViewCore { } } + /* package */ boolean pictureReady() { + return nativePictureReady(); + } + /*package*/ Picture copyContentPicture() { Picture result = new Picture(); nativeCopyContentToPicture(result); @@ -1363,9 +1603,9 @@ final class WebViewCore { sWebCoreHandler.sendMessageAtFrontOfQueue(sWebCoreHandler .obtainMessage(WebCoreThread.REDUCE_PRIORITY)); // Note: there is one possible failure mode. If pauseUpdate() is called - // from UI thread while in webcore thread WEBKIT_DRAW is just pulled out - // of the queue and about to be executed. mDrawIsScheduled may be set to - // false in webkitDraw(). So update won't be blocked. But at least the + // from UI thread while in webcore thread WEBKIT_DRAW is just pulled out + // of the queue and about to be executed. mDrawIsScheduled may be set to + // false in webkitDraw(). So update won't be blocked. But at least the // webcore thread priority is still lowered. if (core != null) { synchronized (core) { @@ -1385,7 +1625,7 @@ final class WebViewCore { synchronized (core) { core.mDrawIsScheduled = false; core.mDrawIsPaused = false; - if (LOGV_ENABLED) Log.v(LOGTAG, "resumeUpdate"); + if (DebugFlags.WEB_VIEW_CORE) Log.v(LOGTAG, "resumeUpdate"); core.contentDraw(); } } @@ -1434,7 +1674,7 @@ final class WebViewCore { mEventHub.sendMessage(Message.obtain(null, EventHub.WEBKIT_DRAW)); } } - + // called by JNI private void contentScrollBy(int dx, int dy, boolean animate) { if (!mBrowserFrame.firstLayoutDone()) { @@ -1442,9 +1682,14 @@ final class WebViewCore { return; } if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.SCROLL_BY_MSG_ID, dx, dy, - new Boolean(animate)).sendToTarget(); + Message msg = Message.obtain(mWebView.mPrivateHandler, + WebView.SCROLL_BY_MSG_ID, dx, dy, new Boolean(animate)); + if (mDrawIsScheduled) { + mEventHub.sendMessage(Message.obtain(null, + EventHub.MESSAGE_RELAY, msg)); + } else { + msg.sendToTarget(); + } } } @@ -1461,8 +1706,14 @@ final class WebViewCore { return; } if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.SCROLL_TO_MSG_ID, x, y).sendToTarget(); + Message msg = Message.obtain(mWebView.mPrivateHandler, + WebView.SCROLL_TO_MSG_ID, x, y); + if (mDrawIsScheduled) { + mEventHub.sendMessage(Message.obtain(null, + EventHub.MESSAGE_RELAY, msg)); + } else { + msg.sendToTarget(); + } } } @@ -1479,24 +1730,14 @@ final class WebViewCore { return; } if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.SPAWN_SCROLL_TO_MSG_ID, x, y).sendToTarget(); - } - } - - // called by JNI - private void sendMarkNodeInvalid(int node) { - if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.MARK_NODE_INVALID_ID, node, 0).sendToTarget(); - } - } - - // called by JNI - private void sendNotifyFocusSet() { - if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.NOTIFY_FOCUS_SET_MSG_ID).sendToTarget(); + Message msg = Message.obtain(mWebView.mPrivateHandler, + WebView.SPAWN_SCROLL_TO_MSG_ID, x, y); + if (mDrawIsScheduled) { + mEventHub.sendMessage(Message.obtain(null, + EventHub.MESSAGE_RELAY, msg)); + } else { + msg.sendToTarget(); + } } } @@ -1511,14 +1752,6 @@ final class WebViewCore { contentDraw(); } - // called by JNI - private void sendRecomputeFocus() { - if (mWebView != null) { - Message.obtain(mWebView.mPrivateHandler, - WebView.RECOMPUTE_FOCUS_MSG_ID).sendToTarget(); - } - } - /* Called by JNI. The coordinates are in doc coordinates, so they need to be scaled before they can be used by the view system, which happens in WebView since it (and its thread) know the current scale factor. @@ -1536,27 +1769,36 @@ final class WebViewCore { } private native void setViewportSettingsFromNative(); - + // called by JNI - private void didFirstLayout() { - // Trick to ensure that the Picture has the exact height for the content - // by forcing to layout with 0 height after the page is ready, which is - // indicated by didFirstLayout. This is essential to get rid of the - // white space in the GMail which uses WebView for message view. - if (mWebView != null && mWebView.mHeightCanMeasure) { - mWebView.mLastHeightSent = 0; - // Send a negative scale to indicate that WebCore should reuse the - // current scale - mEventHub.sendMessage(Message.obtain(null, - EventHub.VIEW_SIZE_CHANGED, mWebView.mLastWidthSent, - mWebView.mLastHeightSent, -1.0f)); + private void didFirstLayout(boolean standardLoad) { + if (DebugFlags.WEB_VIEW_CORE) { + Log.v(LOGTAG, "didFirstLayout standardLoad =" + standardLoad); } mBrowserFrame.didFirstLayout(); - // reset the scroll position as it is a new page now - mWebkitScrollX = mWebkitScrollY = 0; + if (mWebView == null) return; + + setupViewport(standardLoad || mRestoredScale > 0); + // reset the scroll position, the restored offset and scales + mWebkitScrollX = mWebkitScrollY = mRestoredX = mRestoredY + = mRestoredScale = mRestoredScreenWidthScale = 0; + } + + // called by JNI + private void updateViewport() { + // if updateViewport is called before first layout, wait until first + // layout to update the viewport. In the rare case, this is called after + // first layout, force an update as we have just parsed the viewport + // meta tag. + if (mBrowserFrame.firstLayoutDone()) { + setupViewport(true); + } + } + + private void setupViewport(boolean updateRestoreState) { // set the viewport settings from WebKit setViewportSettingsFromNative(); @@ -1607,38 +1849,80 @@ final class WebViewCore { mViewportWidth = 0; } - // now notify webview - if (mWebView != null) { - HashMap scaleLimit = new HashMap(); - scaleLimit.put("minScale", mViewportMinimumScale); - scaleLimit.put("maxScale", mViewportMaximumScale); + // if mViewportWidth is 0, it means device-width, always update. + if (mViewportWidth != 0 && !updateRestoreState) return; - if (mRestoredScale > 0) { - Message.obtain(mWebView.mPrivateHandler, - WebView.DID_FIRST_LAYOUT_MSG_ID, mRestoredScale, 0, - scaleLimit).sendToTarget(); - mRestoredScale = 0; + // now notify webview + int webViewWidth = Math.round(mCurrentViewWidth * mCurrentViewScale); + mRestoreState = new RestoreState(); + mRestoreState.mMinScale = mViewportMinimumScale / 100.0f; + mRestoreState.mMaxScale = mViewportMaximumScale / 100.0f; + mRestoreState.mScrollX = mRestoredX; + mRestoreState.mScrollY = mRestoredY; + if (mRestoredScale > 0) { + if (mRestoredScreenWidthScale > 0) { + mRestoreState.mTextWrapScale = + mRestoredScreenWidthScale / 100.0f; + // 0 will trigger WebView to turn on zoom overview mode + mRestoreState.mViewScale = 0; } else { - Message.obtain(mWebView.mPrivateHandler, - WebView.DID_FIRST_LAYOUT_MSG_ID, mViewportInitialScale, - mViewportWidth, scaleLimit).sendToTarget(); + mRestoreState.mViewScale = mRestoreState.mTextWrapScale = + mRestoredScale / 100.0f; } + } else { + if (mViewportInitialScale > 0) { + mRestoreState.mViewScale = mRestoreState.mTextWrapScale = + mViewportInitialScale / 100.0f; + } else if (mViewportWidth > 0 && mViewportWidth < webViewWidth) { + mRestoreState.mViewScale = mRestoreState.mTextWrapScale = + (float) webViewWidth / mViewportWidth; + } else { + mRestoreState.mTextWrapScale = + WebView.DEFAULT_SCALE_PERCENT / 100.0f; + // 0 will trigger WebView to turn on zoom overview mode + mRestoreState.mViewScale = 0; + } + } - // if no restored offset, move the new page to (0, 0) - Message.obtain(mWebView.mPrivateHandler, WebView.SCROLL_TO_MSG_ID, - mRestoredX, mRestoredY).sendToTarget(); - mRestoredX = mRestoredY = 0; - - // force an early draw for quick feedback after the first layout - if (mCurrentViewWidth != 0) { - synchronized (this) { - if (mDrawIsScheduled) { - mEventHub.removeMessages(EventHub.WEBKIT_DRAW); - } - mDrawIsScheduled = true; - mEventHub.sendMessageAtFrontOfQueue(Message.obtain(null, - EventHub.WEBKIT_DRAW)); - } + if (mWebView.mHeightCanMeasure) { + // Trick to ensure that the Picture has the exact height for the + // content by forcing to layout with 0 height after the page is + // ready, which is indicated by didFirstLayout. This is essential to + // get rid of the white space in the GMail which uses WebView for + // message view. + mWebView.mLastHeightSent = 0; + // Send a negative scale to indicate that WebCore should reuse + // the current scale + WebView.ViewSizeData data = new WebView.ViewSizeData(); + data.mWidth = mWebView.mLastWidthSent; + data.mHeight = 0; + // if mHeightCanMeasure is true, getUseWideViewPort() can't be + // true. It is safe to use mWidth for mTextWrapWidth. + data.mTextWrapWidth = data.mWidth; + data.mScale = -1.0f; + mEventHub.sendMessageAtFrontOfQueue(Message.obtain(null, + EventHub.VIEW_SIZE_CHANGED, data)); + } else if (mSettings.getUseWideViewPort()) { + if (mCurrentViewWidth == 0) { + // Trick to ensure VIEW_SIZE_CHANGED will be sent from WebView + // to WebViewCore + mWebView.mLastWidthSent = 0; + } else { + WebView.ViewSizeData data = new WebView.ViewSizeData(); + // mViewScale as 0 means it is in zoom overview mode. So we don't + // know the exact scale. If mRestoredScale is non-zero, use it; + // otherwise just use mTextWrapScale as the initial scale. + data.mScale = mRestoreState.mViewScale == 0 + ? (mRestoredScale > 0 ? mRestoredScale + : mRestoreState.mTextWrapScale) + : mRestoreState.mViewScale; + data.mWidth = Math.round(webViewWidth / data.mScale); + data.mHeight = mCurrentViewHeight * data.mWidth + / mCurrentViewWidth; + data.mTextWrapWidth = Math.round(webViewWidth + / mRestoreState.mTextWrapScale); + mEventHub.sendMessageAtFrontOfQueue(Message.obtain(null, + EventHub.VIEW_SIZE_CHANGED, data)); } } } @@ -1651,6 +1935,17 @@ final class WebViewCore { } // called by JNI + private void restoreScreenWidthScale(int scale) { + if (!WebView.ENABLE_DOUBLETAP_ZOOM || !mSettings.getUseWideViewPort()) { + return; + } + + if (mBrowserFrame.firstLayoutDone() == false) { + mRestoredScreenWidthScale = scale; + } + } + + // called by JNI private void needTouchEvents(boolean need) { if (mWebView != null) { Message.obtain(mWebView.mPrivateHandler, @@ -1664,15 +1959,39 @@ final class WebViewCore { String text, int textGeneration) { if (mWebView != null) { Message msg = Message.obtain(mWebView.mPrivateHandler, - WebView.UPDATE_TEXTFIELD_TEXT_MSG_ID, ptr, + WebView.UPDATE_TEXTFIELD_TEXT_MSG_ID, ptr, textGeneration, text); msg.getData().putBoolean("password", changeToPassword); msg.sendToTarget(); } } + // called by JNI + private void updateTextSelection(int pointer, int start, int end, + int textGeneration) { + if (mWebView != null) { + Message.obtain(mWebView.mPrivateHandler, + WebView.UPDATE_TEXT_SELECTION_MSG_ID, pointer, textGeneration, + new TextSelectionData(start, end)).sendToTarget(); + } + } + + // called by JNI + private void clearTextEntry() { + if (mWebView == null) return; + Message.obtain(mWebView.mPrivateHandler, + WebView.CLEAR_TEXT_ENTRY).sendToTarget(); + } + + private native void nativeUpdateFrameCacheIfLoading(); + + /** + * Scroll the focused textfield to (x, y) in document space + */ + private native void nativeScrollFocusedTextInput(int x, int y); + // these must be in document space (i.e. not scaled/zoomed). - private native void nativeSetScrollOffset(int dx, int dy); + private native void nativeSetScrollOffset(int gen, int dx, int dy); private native void nativeSetGlobalBounds(int x, int y, int w, int h); @@ -1690,6 +2009,97 @@ final class WebViewCore { if (mWebView != null) { mWebView.requestListBox(array, enabledArray, selection); } - + + } + + // called by JNI + private void requestKeyboard(boolean showKeyboard) { + if (mWebView != null) { + Message.obtain(mWebView.mPrivateHandler, + WebView.REQUEST_KEYBOARD, showKeyboard ? 1 : 0, 0) + .sendToTarget(); + } } + + // This class looks like a SurfaceView to native code. In java, we can + // assume the passed in SurfaceView is this class so we can talk to the + // ViewManager through the ChildView. + private class SurfaceViewProxy extends SurfaceView + implements SurfaceHolder.Callback { + private final ViewManager.ChildView mChildView; + private int mPointer; + private final boolean mIsFixedSize; + SurfaceViewProxy(Context context, ViewManager.ChildView childView, + int pointer, int pixelFormat, boolean isFixedSize) { + super(context); + setWillNotDraw(false); // this prevents the black box artifact + getHolder().addCallback(this); + getHolder().setFormat(pixelFormat); + mChildView = childView; + mChildView.mView = this; + mPointer = pointer; + mIsFixedSize = isFixedSize; + } + void destroy() { + mPointer = 0; + mChildView.removeView(); + } + void attach(int x, int y, int width, int height) { + mChildView.attachView(x, y, width, height); + + if (mIsFixedSize) { + getHolder().setFixedSize(width, height); + } + } + + // SurfaceHolder.Callback methods + public void surfaceCreated(SurfaceHolder holder) { + if (mPointer != 0) { + nativeSurfaceChanged(mPointer, 0, 0, 0, 0); + } + } + public void surfaceChanged(SurfaceHolder holder, int format, int width, + int height) { + if (mPointer != 0) { + nativeSurfaceChanged(mPointer, 1, format, width, height); + } + } + public void surfaceDestroyed(SurfaceHolder holder) { + if (mPointer != 0) { + nativeSurfaceChanged(mPointer, 2, 0, 0, 0); + } + } + } + + // PluginWidget functions for mainting SurfaceViews for the Surface drawing + // model. + private SurfaceView createSurface(int nativePointer, int pixelFormat, + boolean isFixedSize) { + if (mWebView == null) { + return null; + } + return new SurfaceViewProxy(mContext, mWebView.mViewManager.createView(), + nativePointer, pixelFormat, isFixedSize); + } + + private void destroySurface(SurfaceView surface) { + SurfaceViewProxy proxy = (SurfaceViewProxy) surface; + proxy.destroy(); + } + + private void attachSurface(SurfaceView surface, int x, int y, + int width, int height) { + SurfaceViewProxy proxy = (SurfaceViewProxy) surface; + proxy.attach(x, y, width, height); + } + + // Callback for the SurfaceHolder.Callback. Called for all the surface + // callbacks. The state parameter is one of Created(0), Changed(1), + // Destroyed(2). + private native void nativeSurfaceChanged(int pointer, int state, int format, + int width, int height); + + private native void nativePause(); + private native void nativeResume(); + private native void nativeFreeMemory(); } diff --git a/core/java/android/webkit/WebViewDatabase.java b/core/java/android/webkit/WebViewDatabase.java index 1004e30..4e76254 100644 --- a/core/java/android/webkit/WebViewDatabase.java +++ b/core/java/android/webkit/WebViewDatabase.java @@ -48,7 +48,9 @@ public class WebViewDatabase { // 6 -> 7 Change cache localPath from int to String // 7 -> 8 Move cache to its own db // 8 -> 9 Store both scheme and host when storing passwords - private static final int CACHE_DATABASE_VERSION = 1; + private static final int CACHE_DATABASE_VERSION = 3; + // 1 -> 2 Add expires String + // 2 -> 3 Add content-disposition private static WebViewDatabase mInstance = null; @@ -107,6 +109,8 @@ public class WebViewDatabase { private static final String CACHE_EXPIRES_COL = "expires"; + private static final String CACHE_EXPIRES_STRING_COL = "expiresstring"; + private static final String CACHE_MIMETYPE_COL = "mimetype"; private static final String CACHE_ENCODING_COL = "encoding"; @@ -117,6 +121,8 @@ public class WebViewDatabase { private static final String CACHE_CONTENTLENGTH_COL = "contentlength"; + private static final String CACHE_CONTENTDISPOSITION_COL = "contentdisposition"; + // column id strings for "password" table private static final String PASSWORD_HOST_COL = "host"; @@ -150,11 +156,13 @@ public class WebViewDatabase { private static int mCacheLastModifyColIndex; private static int mCacheETagColIndex; private static int mCacheExpiresColIndex; + private static int mCacheExpiresStringColIndex; private static int mCacheMimeTypeColIndex; private static int mCacheEncodingColIndex; private static int mCacheHttpStatusColIndex; private static int mCacheLocationColIndex; private static int mCacheContentLengthColIndex; + private static int mCacheContentDispositionColIndex; private static int mCacheTransactionRefcount; @@ -220,6 +228,8 @@ public class WebViewDatabase { .getColumnIndex(CACHE_ETAG_COL); mCacheExpiresColIndex = mCacheInserter .getColumnIndex(CACHE_EXPIRES_COL); + mCacheExpiresStringColIndex = mCacheInserter + .getColumnIndex(CACHE_EXPIRES_STRING_COL); mCacheMimeTypeColIndex = mCacheInserter .getColumnIndex(CACHE_MIMETYPE_COL); mCacheEncodingColIndex = mCacheInserter @@ -230,6 +240,8 @@ public class WebViewDatabase { .getColumnIndex(CACHE_LOCATION_COL); mCacheContentLengthColIndex = mCacheInserter .getColumnIndex(CACHE_CONTENTLENGTH_COL); + mCacheContentDispositionColIndex = mCacheInserter + .getColumnIndex(CACHE_CONTENTDISPOSITION_COL); } } @@ -320,11 +332,12 @@ public class WebViewDatabase { + " TEXT, " + CACHE_FILE_PATH_COL + " TEXT, " + CACHE_LAST_MODIFY_COL + " TEXT, " + CACHE_ETAG_COL + " TEXT, " + CACHE_EXPIRES_COL + " INTEGER, " + + CACHE_EXPIRES_STRING_COL + " TEXT, " + CACHE_MIMETYPE_COL + " TEXT, " + CACHE_ENCODING_COL + " TEXT," + CACHE_HTTP_STATUS_COL + " INTEGER, " + CACHE_LOCATION_COL + " TEXT, " + CACHE_CONTENTLENGTH_COL - + " INTEGER, " + " UNIQUE (" + CACHE_URL_COL - + ") ON CONFLICT REPLACE);"); + + " INTEGER, " + CACHE_CONTENTDISPOSITION_COL + " TEXT, " + + " UNIQUE (" + CACHE_URL_COL + ") ON CONFLICT REPLACE);"); mCacheDatabase.execSQL("CREATE INDEX cacheUrlIndex ON cache (" + CACHE_URL_COL + ")"); } @@ -537,8 +550,8 @@ public class WebViewDatabase { } Cursor cursor = mCacheDatabase.rawQuery("SELECT filepath, lastmodify, etag, expires, " - + "mimetype, encoding, httpstatus, location, contentlength " - + "FROM cache WHERE url = ?", + + "expiresstring, mimetype, encoding, httpstatus, location, contentlength, " + + "contentdisposition FROM cache WHERE url = ?", new String[] { url }); try { @@ -548,11 +561,13 @@ public class WebViewDatabase { ret.lastModified = cursor.getString(1); ret.etag = cursor.getString(2); ret.expires = cursor.getLong(3); - ret.mimeType = cursor.getString(4); - ret.encoding = cursor.getString(5); - ret.httpStatusCode = cursor.getInt(6); - ret.location = cursor.getString(7); - ret.contentLength = cursor.getLong(8); + ret.expiresString = cursor.getString(4); + ret.mimeType = cursor.getString(5); + ret.encoding = cursor.getString(6); + ret.httpStatusCode = cursor.getInt(7); + ret.location = cursor.getString(8); + ret.contentLength = cursor.getLong(9); + ret.contentdisposition = cursor.getString(10); return ret; } } finally { @@ -591,11 +606,14 @@ public class WebViewDatabase { mCacheInserter.bind(mCacheLastModifyColIndex, c.lastModified); mCacheInserter.bind(mCacheETagColIndex, c.etag); mCacheInserter.bind(mCacheExpiresColIndex, c.expires); + mCacheInserter.bind(mCacheExpiresStringColIndex, c.expiresString); mCacheInserter.bind(mCacheMimeTypeColIndex, c.mimeType); mCacheInserter.bind(mCacheEncodingColIndex, c.encoding); mCacheInserter.bind(mCacheHttpStatusColIndex, c.httpStatusCode); mCacheInserter.bind(mCacheLocationColIndex, c.location); mCacheInserter.bind(mCacheContentLengthColIndex, c.contentLength); + mCacheInserter.bind(mCacheContentDispositionColIndex, + c.contentdisposition); mCacheInserter.execute(); } diff --git a/core/java/android/webkit/gears/AndroidGpsLocationProvider.java b/core/java/android/webkit/gears/AndroidGpsLocationProvider.java deleted file mode 100644 index 3646042..0000000 --- a/core/java/android/webkit/gears/AndroidGpsLocationProvider.java +++ /dev/null @@ -1,156 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.Context; -import android.location.Location; -import android.location.LocationListener; -import android.location.LocationManager; -import android.location.LocationProvider; -import android.os.Bundle; -import android.util.Log; -import android.webkit.WebView; - -/** - * GPS provider implementation for Android. - */ -public final class AndroidGpsLocationProvider implements LocationListener { - /** - * Logging tag - */ - private static final String TAG = "Gears-J-GpsProvider"; - /** - * Our location manager instance. - */ - private LocationManager locationManager; - /** - * The native object ID. - */ - private long nativeObject; - - public AndroidGpsLocationProvider(WebView webview, long object) { - nativeObject = object; - locationManager = (LocationManager) webview.getContext().getSystemService( - Context.LOCATION_SERVICE); - if (locationManager == null) { - Log.e(TAG, - "AndroidGpsLocationProvider: could not get location manager."); - throw new NullPointerException( - "AndroidGpsLocationProvider: locationManager is null."); - } - // Register for location updates. - try { - locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, - this); - } catch (IllegalArgumentException ex) { - Log.e(TAG, - "AndroidLocationGpsProvider: could not register for updates: " + ex); - throw ex; - } catch (SecurityException ex) { - Log.e(TAG, - "AndroidGpsLocationProvider: not allowed to register for update: " - + ex); - throw ex; - } - } - - /** - * Called when the provider is no longer needed. - */ - public void shutdown() { - locationManager.removeUpdates(this); - Log.i(TAG, "GPS provider closed."); - } - - /** - * Called when the location has changed. - * @param location The new location, as a Location object. - */ - public void onLocationChanged(Location location) { - Log.i(TAG, "Location changed: " + location); - nativeLocationChanged(location, nativeObject); - } - - /** - * Called when the provider status changes. - * - * @param provider the name of the location provider associated with this - * update. - * @param status {@link LocationProvider#OUT_OF_SERVICE} if the - * provider is out of service, and this is not expected to change in the - * near future; {@link LocationProvider#TEMPORARILY_UNAVAILABLE} if - * the provider is temporarily unavailable but is expected to be available - * shortly; and {@link LocationProvider#AVAILABLE} if the - * provider is currently available. - * @param extras an optional Bundle which will contain provider specific - * status variables (such as number of satellites). - */ - public void onStatusChanged(String provider, int status, Bundle extras) { - Log.i(TAG, "Provider " + provider + " status changed to " + status); - if (status == LocationProvider.OUT_OF_SERVICE || - status == LocationProvider.TEMPORARILY_UNAVAILABLE) { - nativeProviderError(false, nativeObject); - } - } - - /** - * Called when the provider is enabled. - * - * @param provider the name of the location provider that is now enabled. - */ - public void onProviderEnabled(String provider) { - Log.i(TAG, "Provider " + provider + " enabled."); - // No need to notify the native side. It's enough to start sending - // valid position fixes again. - } - - /** - * Called when the provider is disabled. - * - * @param provider the name of the location provider that is now disabled. - */ - public void onProviderDisabled(String provider) { - Log.i(TAG, "Provider " + provider + " disabled."); - nativeProviderError(true, nativeObject); - } - - /** - * The native method called when a new location is available. - * @param location is the new Location instance to pass to the native side. - * @param nativeObject is a pointer to the corresponding - * AndroidGpsLocationProvider C++ instance. - */ - private native void nativeLocationChanged(Location location, long object); - - /** - * The native method called when there is a GPS provder error. - * @param isDisabled is true when the error signifies the fact that the GPS - * HW is disabled. For other errors, this param is always false. - * @param nativeObject is a pointer to the corresponding - * AndroidGpsLocationProvider C++ instance. - */ - private native void nativeProviderError(boolean isDisabled, long object); -} diff --git a/core/java/android/webkit/gears/AndroidRadioDataProvider.java b/core/java/android/webkit/gears/AndroidRadioDataProvider.java deleted file mode 100644 index 1384042..0000000 --- a/core/java/android/webkit/gears/AndroidRadioDataProvider.java +++ /dev/null @@ -1,260 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.Context; -import android.telephony.CellLocation; -import android.telephony.ServiceState; -import android.telephony.SignalStrength; -import android.telephony.gsm.GsmCellLocation; -import android.telephony.PhoneStateListener; -import android.telephony.TelephonyManager; -import android.util.Log; -import android.webkit.WebView; - -/** - * Radio data provider implementation for Android. - */ -public final class AndroidRadioDataProvider extends PhoneStateListener { - - /** Logging tag */ - private static final String TAG = "Gears-J-RadioProvider"; - - /** Network types */ - private static final int RADIO_TYPE_UNKNOWN = 0; - private static final int RADIO_TYPE_GSM = 1; - private static final int RADIO_TYPE_WCDMA = 2; - private static final int RADIO_TYPE_CDMA = 3; - private static final int RADIO_TYPE_EVDO = 4; - private static final int RADIO_TYPE_1xRTT = 5; - - /** Simple container for radio data */ - public static final class RadioData { - public int cellId = -1; - public int locationAreaCode = -1; - // TODO: use new SignalStrength instead of asu - public int signalStrength = -1; - public int mobileCountryCode = -1; - public int mobileNetworkCode = -1; - public int homeMobileCountryCode = -1; - public int homeMobileNetworkCode = -1; - public int radioType = RADIO_TYPE_UNKNOWN; - public String carrierName; - - /** - * Constructs radioData object from the given telephony data. - * @param telephonyManager contains the TelephonyManager instance. - * @param cellLocation contains information about the current GSM cell. - * @param signalStrength is the strength of the network signal. - * @param serviceState contains information about the network service. - * @return a new RadioData object populated with the currently - * available network information or null if there isn't - * enough information. - */ - public static RadioData getInstance(TelephonyManager telephonyManager, - CellLocation cellLocation, int signalStrength, - ServiceState serviceState) { - - if (!(cellLocation instanceof GsmCellLocation)) { - // This also covers the case when cellLocation is null. - // When that happens, we do not bother creating a - // RadioData instance. - return null; - } - - RadioData radioData = new RadioData(); - GsmCellLocation gsmCellLocation = (GsmCellLocation) cellLocation; - - // Extract the cell id, LAC, and signal strength. - radioData.cellId = gsmCellLocation.getCid(); - radioData.locationAreaCode = gsmCellLocation.getLac(); - radioData.signalStrength = signalStrength; - - // Extract the home MCC and home MNC. - String operator = telephonyManager.getSimOperator(); - radioData.setMobileCodes(operator, true); - - if (serviceState != null) { - // Extract the carrier name. - radioData.carrierName = serviceState.getOperatorAlphaLong(); - - // Extract the MCC and MNC. - operator = serviceState.getOperatorNumeric(); - radioData.setMobileCodes(operator, false); - } - - // Finally get the radio type. - //TODO We have to edit the parameter for getNetworkType regarding CDMA - int type = telephonyManager.getNetworkType(); - if (type == TelephonyManager.NETWORK_TYPE_UMTS) { - radioData.radioType = RADIO_TYPE_WCDMA; - } else if (type == TelephonyManager.NETWORK_TYPE_GPRS - || type == TelephonyManager.NETWORK_TYPE_EDGE) { - radioData.radioType = RADIO_TYPE_GSM; - } else if (type == TelephonyManager.NETWORK_TYPE_CDMA) { - radioData.radioType = RADIO_TYPE_CDMA; - } else if (type == TelephonyManager.NETWORK_TYPE_EVDO_0) { - radioData.radioType = RADIO_TYPE_EVDO; - } else if (type == TelephonyManager.NETWORK_TYPE_EVDO_A) { - radioData.radioType = RADIO_TYPE_EVDO; - } else if (type == TelephonyManager.NETWORK_TYPE_1xRTT) { - radioData.radioType = RADIO_TYPE_1xRTT; - } - - // Print out what we got. - Log.i(TAG, "Got the following data:"); - Log.i(TAG, "CellId: " + radioData.cellId); - Log.i(TAG, "LAC: " + radioData.locationAreaCode); - Log.i(TAG, "MNC: " + radioData.mobileNetworkCode); - Log.i(TAG, "MCC: " + radioData.mobileCountryCode); - Log.i(TAG, "home MNC: " + radioData.homeMobileNetworkCode); - Log.i(TAG, "home MCC: " + radioData.homeMobileCountryCode); - Log.i(TAG, "Signal strength: " + radioData.signalStrength); - Log.i(TAG, "Carrier: " + radioData.carrierName); - Log.i(TAG, "Network type: " + radioData.radioType); - - return radioData; - } - - private RadioData() {} - - /** - * Parses a string containing a mobile country code and a mobile - * network code and sets the corresponding member variables. - * @param codes is the string to parse. - * @param homeValues flags whether the codes are for the home operator. - */ - private void setMobileCodes(String codes, boolean homeValues) { - if (codes != null) { - try { - // The operator numeric format is 3 digit country code plus 2 or - // 3 digit network code. - int mcc = Integer.parseInt(codes.substring(0, 3)); - int mnc = Integer.parseInt(codes.substring(3)); - if (homeValues) { - homeMobileCountryCode = mcc; - homeMobileNetworkCode = mnc; - } else { - mobileCountryCode = mcc; - mobileNetworkCode = mnc; - } - } catch (IndexOutOfBoundsException ex) { - Log.e( - TAG, - "AndroidRadioDataProvider: Invalid operator numeric data: " + ex); - } catch (NumberFormatException ex) { - Log.e( - TAG, - "AndroidRadioDataProvider: Operator numeric format error: " + ex); - } - } - } - }; - - /** The native object ID */ - private long nativeObject; - - /** The last known cellLocation */ - private CellLocation cellLocation = null; - - /** The last known signal strength */ - // TODO: use new SignalStrength instead of asu - private int signalStrength = -1; - - /** The last known serviceState */ - private ServiceState serviceState = null; - - /** - * Our TelephonyManager instance. - */ - private TelephonyManager telephonyManager; - - /** - * Public constructor. Uses the webview to get the Context object. - */ - public AndroidRadioDataProvider(WebView webview, long object) { - super(); - nativeObject = object; - telephonyManager = (TelephonyManager) webview.getContext().getSystemService( - Context.TELEPHONY_SERVICE); - if (telephonyManager == null) { - Log.e(TAG, - "AndroidRadioDataProvider: could not get tepephony manager."); - throw new NullPointerException( - "AndroidRadioDataProvider: telephonyManager is null."); - } - - // Register for cell id, signal strength and service state changed - // notifications. - telephonyManager.listen(this, PhoneStateListener.LISTEN_CELL_LOCATION - | PhoneStateListener.LISTEN_SIGNAL_STRENGTHS - | PhoneStateListener.LISTEN_SERVICE_STATE); - } - - /** - * Should be called when the provider is no longer needed. - */ - public void shutdown() { - telephonyManager.listen(this, PhoneStateListener.LISTEN_NONE); - Log.i(TAG, "AndroidRadioDataProvider shutdown."); - } - - @Override - public void onServiceStateChanged(ServiceState state) { - serviceState = state; - notifyListeners(); - } - - @Override - public void onSignalStrengthsChanged(SignalStrength ss) { - int gsmSignalStrength = ss.getGsmSignalStrength(); - signalStrength = (gsmSignalStrength == 99 ? -1 : gsmSignalStrength); - notifyListeners(); - } - - @Override - public void onCellLocationChanged(CellLocation location) { - cellLocation = location; - notifyListeners(); - } - - private void notifyListeners() { - RadioData radioData = RadioData.getInstance(telephonyManager, cellLocation, - signalStrength, serviceState); - if (radioData != null) { - onUpdateAvailable(radioData, nativeObject); - } - } - - /** - * The native method called when new radio data is available. - * @param radioData is the RadioData instance to pass to the native side. - * @param nativeObject is a pointer to the corresponding - * AndroidRadioDataProvider C++ instance. - */ - private static native void onUpdateAvailable( - RadioData radioData, long nativeObject); -} diff --git a/core/java/android/webkit/gears/AndroidWifiDataProvider.java b/core/java/android/webkit/gears/AndroidWifiDataProvider.java deleted file mode 100644 index d2850b0..0000000 --- a/core/java/android/webkit/gears/AndroidWifiDataProvider.java +++ /dev/null @@ -1,140 +0,0 @@ -// Copyright 2008, Google Inc. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.BroadcastReceiver; -import android.content.Context; -import android.content.Intent; -import android.content.IntentFilter; -import android.net.wifi.ScanResult; -import android.net.wifi.WifiManager; -import android.os.Handler; -import android.os.Looper; -import android.util.Log; -import android.webkit.WebView; -import java.util.List; - -/** - * WiFi data provider implementation for Android. - * {@hide} - */ -public final class AndroidWifiDataProvider extends BroadcastReceiver { - /** - * Logging tag - */ - private static final String TAG = "Gears-J-WifiProvider"; - /** - * Flag for guarding Log.v() calls. - * Set to true to enable extra debug logging. - */ - private static final boolean LOGV_ENABLED = false; - /** - * Our Wifi manager instance. - */ - private WifiManager mWifiManager; - /** - * The native object ID. - */ - private long mNativeObject; - /** - * The Context instance. - */ - private Context mContext; - - /** - * Constructs a instance of this class and registers for wifi scan - * updates. Note that this constructor must be called on a Looper - * thread. Suitable threads can be created on the native side using - * the AndroidLooperThread C++ class. - */ - public AndroidWifiDataProvider(WebView webview, long object) { - mNativeObject = object; - mContext = webview.getContext(); - mWifiManager = - (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE); - if (mWifiManager == null) { - Log.e(TAG, - "AndroidWifiDataProvider: could not get location manager."); - throw new NullPointerException( - "AndroidWifiDataProvider: locationManager is null."); - } - - // Create a Handler that identifies the message loop associated - // with the current thread. Note that it is not necessary to - // override handleMessage() at all since the Intent - // ReceiverDispatcher (see the ActivityThread class) only uses - // this handler to post a Runnable to this thread's loop. - Handler handler = new Handler(Looper.myLooper()); - - IntentFilter filter = new IntentFilter(); - filter.addAction(mWifiManager.SCAN_RESULTS_AVAILABLE_ACTION); - mContext.registerReceiver(this, filter, null, handler); - - // Get the last scan results and pass them to the native side. - // We can't just invoke the callback here, so we queue a message - // to this thread's loop. - handler.post(new Runnable() { - public void run() { - onUpdateAvailable(mWifiManager.getScanResults(), mNativeObject); - } - }); - } - - /** - * Called when the provider is no longer needed. - */ - public void shutdown() { - mContext.unregisterReceiver(this); - if (LOGV_ENABLED) { - Log.v(TAG, "Wifi provider closed."); - } - } - - /** - * This method is called when the AndroidWifiDataProvider is receiving an - * Intent broadcast. - * @param context The Context in which the receiver is running. - * @param intent The Intent being received. - */ - public void onReceive(Context context, Intent intent) { - if (intent.getAction().equals( - mWifiManager.SCAN_RESULTS_AVAILABLE_ACTION)) { - if (LOGV_ENABLED) { - Log.v(TAG, "Wifi scan resulst available"); - } - onUpdateAvailable(mWifiManager.getScanResults(), mNativeObject); - } - } - - /** - * The native method called when new wifi data is available. - * @param scanResults is a list of ScanResults to pass to the native side. - * @param nativeObject is a pointer to the corresponding - * AndroidWifiDataProvider C++ instance. - */ - private static native void onUpdateAvailable( - List<ScanResult> scanResults, long nativeObject); -} diff --git a/core/java/android/webkit/gears/ApacheHttpRequestAndroid.java b/core/java/android/webkit/gears/ApacheHttpRequestAndroid.java deleted file mode 100644 index 74d27ed..0000000 --- a/core/java/android/webkit/gears/ApacheHttpRequestAndroid.java +++ /dev/null @@ -1,1134 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.net.http.Headers; -import android.os.Handler; -import android.os.Looper; -import android.os.Message; -import android.util.Log; -import android.webkit.CacheManager; -import android.webkit.CacheManager.CacheResult; -import android.webkit.CookieManager; - -import java.io.InputStream; -import java.io.OutputStream; -import java.io.IOException; -import java.lang.StringBuilder; -import java.util.Date; -import java.util.Map; -import java.util.HashMap; -import java.util.Iterator; - -import org.apache.http.Header; -import org.apache.http.HttpEntity; -import org.apache.http.client.params.HttpClientParams; -import org.apache.http.params.HttpParams; -import org.apache.http.params.HttpConnectionParams; -import org.apache.http.params.HttpProtocolParams; -import org.apache.http.HttpResponse; -import org.apache.http.entity.AbstractHttpEntity; -import org.apache.http.client.*; -import org.apache.http.client.methods.*; -import org.apache.http.impl.client.AbstractHttpClient; -import org.apache.http.impl.client.DefaultHttpClient; -import org.apache.http.impl.client.DefaultHttpRequestRetryHandler; -import org.apache.http.conn.ssl.StrictHostnameVerifier; -import org.apache.http.impl.cookie.DateUtils; -import org.apache.http.util.CharArrayBuffer; - -import java.util.concurrent.locks.Condition; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; - -/** - * Performs the underlying HTTP/HTTPS GET, POST, HEAD, PUT, DELETE requests. - * <p> These are performed synchronously (blocking). The caller should - * ensure that it is in a background thread if asynchronous behavior - * is required. All data is pushed, so there is no need for JNI native - * callbacks. - * <p> This uses Apache's HttpClient framework to perform most - * of the underlying network activity. The Android brower's cache, - * android.webkit.CacheManager, is also used when caching is enabled, - * and updated with new data. The android.webkit.CookieManager is also - * queried and updated as necessary. - * <p> The public interface is designed to be called by native code - * through JNI, and to simplify coding none of the public methods will - * surface a checked exception. Unchecked exceptions may still be - * raised but only if the system is in an ill state, such as out of - * memory. - * <p> TODO: This isn't plumbed into LocalServer yet. Mutually - * dependent on LocalServer - will attach the two together once both - * are submitted. - */ -public final class ApacheHttpRequestAndroid { - /** Debug logging tag. */ - private static final String LOG_TAG = "Gears-J"; - /** Flag for guarding Log.v() calls. */ - private static final boolean LOGV_ENABLED = false; - /** HTTP response header line endings are CR-LF style. */ - private static final String HTTP_LINE_ENDING = "\r\n"; - /** Safe MIME type to use whenever it isn't specified. */ - private static final String DEFAULT_MIME_TYPE = "text/plain"; - /** Case-sensitive header keys */ - public static final String KEY_CONTENT_LENGTH = "Content-Length"; - public static final String KEY_EXPIRES = "Expires"; - public static final String KEY_LAST_MODIFIED = "Last-Modified"; - public static final String KEY_ETAG = "ETag"; - public static final String KEY_LOCATION = "Location"; - public static final String KEY_CONTENT_TYPE = "Content-Type"; - /** Number of bytes to send and receive on the HTTP connection in - * one go. */ - private static final int BUFFER_SIZE = 4096; - - /** The first element of the String[] value in a headers map is the - * unmodified (case-sensitive) key. */ - public static final int HEADERS_MAP_INDEX_KEY = 0; - /** The second element of the String[] value in a headers map is the - * associated value. */ - public static final int HEADERS_MAP_INDEX_VALUE = 1; - - /** Request headers, as key -> value map. */ - // TODO: replace this design by a simpler one (the C++ side has to - // be modified too), where we do not store both the original header - // and the lowercase one. - private Map<String, String[]> mRequestHeaders = - new HashMap<String, String[]>(); - /** Response headers, as a lowercase key -> value map. */ - private Map<String, String[]> mResponseHeaders = - new HashMap<String, String[]>(); - /** The URL used for createCacheResult() */ - private String mCacheResultUrl; - /** CacheResult being saved into, if inserting a new cache entry. */ - private CacheResult mCacheResult; - /** Initialized by initChildThread(). Used to target abort(). */ - private Thread mBridgeThread; - - /** Our HttpClient */ - private AbstractHttpClient mClient; - /** The HttpMethod associated with this request */ - private HttpRequestBase mMethod; - /** The complete response line e.g "HTTP/1.0 200 OK" */ - private String mResponseLine; - /** HTTP body stream, setup after connection. */ - private InputStream mBodyInputStream; - - /** HTTP Response Entity */ - private HttpResponse mResponse; - - /** Post Entity, used to stream the request to the server */ - private StreamEntity mPostEntity = null; - /** Content lenght, mandatory when using POST */ - private long mContentLength; - - /** The request executes in a parallel thread */ - private Thread mHttpThread = null; - /** protect mHttpThread, if interrupt() is called concurrently */ - private Lock mHttpThreadLock = new ReentrantLock(); - /** Flag set to true when the request thread is joined */ - private boolean mConnectionFinished = false; - /** Flag set to true by interrupt() and/or connection errors */ - private boolean mConnectionFailed = false; - /** Lock protecting the access to mConnectionFailed */ - private Lock mConnectionFailedLock = new ReentrantLock(); - - /** Lock on the loop in StreamEntity */ - private Lock mStreamingReadyLock = new ReentrantLock(); - /** Condition variable used to signal the loop is ready... */ - private Condition mStreamingReady = mStreamingReadyLock.newCondition(); - - /** Used to pass around the block of data POSTed */ - private Buffer mBuffer = new Buffer(); - /** Used to signal that the block of data has been written */ - private SignalConsumed mSignal = new SignalConsumed(); - - // inner classes - - /** - * Implements the http request - */ - class Connection implements Runnable { - public void run() { - boolean problem = false; - try { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "REQUEST : " + mMethod.getRequestLine()); - } - mResponse = mClient.execute(mMethod); - if (mResponse != null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "response (status line): " - + mResponse.getStatusLine()); - } - mResponseLine = "" + mResponse.getStatusLine(); - } else { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "problem, response == null"); - } - problem = true; - } - } catch (IOException e) { - Log.e(LOG_TAG, "Connection IO exception ", e); - problem = true; - } catch (RuntimeException e) { - Log.e(LOG_TAG, "Connection runtime exception ", e); - problem = true; - } - - if (!problem) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Request complete (" - + mMethod.getRequestLine() + ")"); - } - } else { - mConnectionFailedLock.lock(); - mConnectionFailed = true; - mConnectionFailedLock.unlock(); - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Request FAILED (" - + mMethod.getRequestLine() + ")"); - } - // We abort the execution in order to shutdown and release - // the underlying connection - mMethod.abort(); - if (mPostEntity != null) { - // If there is a post entity, we need to wake it up from - // a potential deadlock - mPostEntity.signalOutputStream(); - } - } - } - } - - /** - * simple buffer class implementing a producer/consumer model - */ - class Buffer { - private DataPacket mPacket; - private boolean mEmpty = true; - public synchronized void put(DataPacket packet) { - while (!mEmpty) { - try { - wait(); - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "InterruptedException while putting " + - "a DataPacket in the Buffer: " + e); - } - } - } - mPacket = packet; - mEmpty = false; - notify(); - } - public synchronized DataPacket get() { - while (mEmpty) { - try { - wait(); - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "InterruptedException while getting " + - "a DataPacket in the Buffer: " + e); - } - } - } - mEmpty = true; - notify(); - return mPacket; - } - } - - /** - * utility class used to block until the packet is signaled as being - * consumed - */ - class SignalConsumed { - private boolean mConsumed = false; - public synchronized void waitUntilPacketConsumed() { - while (!mConsumed) { - try { - wait(); - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "InterruptedException while waiting " + - "until a DataPacket is consumed: " + e); - } - } - } - mConsumed = false; - notify(); - } - public synchronized void packetConsumed() { - while (mConsumed) { - try { - wait(); - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "InterruptedException while indicating " - + "that the DataPacket has been consumed: " + e); - } - } - } - mConsumed = true; - notify(); - } - } - - /** - * Utility class encapsulating a packet of data - */ - class DataPacket { - private byte[] mContent; - private int mLength; - public DataPacket(byte[] content, int length) { - mContent = content; - mLength = length; - } - public byte[] getBytes() { - return mContent; - } - public int getLength() { - return mLength; - } - } - - /** - * HttpEntity class to write the bytes received by the C++ thread - * on the connection outputstream, in a streaming way. - * This entity is executed in the request thread. - * The writeTo() method is automatically called by the - * HttpPost execution; upon reception, we loop while receiving - * the data packets from the main thread, until completion - * or error. When done, we flush the outputstream. - * The main thread (sendPostData()) also blocks until the - * outputstream is made available (or an error happens) - */ - class StreamEntity implements HttpEntity { - private OutputStream mOutputStream; - - // HttpEntity interface methods - - public boolean isRepeatable() { - return false; - } - - public boolean isChunked() { - return false; - } - - public long getContentLength() { - return mContentLength; - } - - public Header getContentType() { - return null; - } - - public Header getContentEncoding() { - return null; - } - - public InputStream getContent() throws IOException { - return null; - } - - public void writeTo(final OutputStream out) throws IOException { - // We signal that the outputstream is available - mStreamingReadyLock.lock(); - mOutputStream = out; - mStreamingReady.signal(); - mStreamingReadyLock.unlock(); - - // We then loop waiting on messages to process. - boolean finished = false; - while (!finished) { - DataPacket packet = mBuffer.get(); - if (packet == null) { - finished = true; - } else { - write(packet); - } - mSignal.packetConsumed(); - mConnectionFailedLock.lock(); - if (mConnectionFailed) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "stopping loop on error"); - } - finished = true; - } - mConnectionFailedLock.unlock(); - } - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "flushing the outputstream..."); - } - mOutputStream.flush(); - } - - public boolean isStreaming() { - return true; - } - - public void consumeContent() throws IOException { - // Nothing to release - } - - // local methods - - private void write(DataPacket packet) { - try { - if (mOutputStream == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "NO OUTPUT STREAM !!!"); - } - return; - } - mOutputStream.write(packet.getBytes(), 0, packet.getLength()); - mOutputStream.flush(); - } catch (IOException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "exc: " + e); - } - mConnectionFailedLock.lock(); - mConnectionFailed = true; - mConnectionFailedLock.unlock(); - } - } - - public boolean isReady() { - mStreamingReadyLock.lock(); - try { - if (mOutputStream == null) { - mStreamingReady.await(); - } - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "InterruptedException in " - + "StreamEntity::isReady() : ", e); - } - } finally { - mStreamingReadyLock.unlock(); - } - if (mOutputStream == null) { - return false; - } - return true; - } - - public void signalOutputStream() { - mStreamingReadyLock.lock(); - mStreamingReady.signal(); - mStreamingReadyLock.unlock(); - } - } - - /** - * Initialize mBridgeThread using the TLS value of - * Thread.currentThread(). Called on start up of the native child - * thread. - */ - public synchronized void initChildThread() { - mBridgeThread = Thread.currentThread(); - } - - public void setContentLength(long length) { - mContentLength = length; - } - - /** - * Analagous to the native-side HttpRequest::open() function. This - * initializes an underlying HttpClient method, but does - * not go to the wire. On success, this enables a call to send() to - * initiate the transaction. - * - * @param method The HTTP method, e.g GET or POST. - * @param url The URL to open. - * @return True on success with a complete HTTP response. - * False on failure. - */ - public synchronized boolean open(String method, String url) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "open " + method + " " + url); - } - // Create the client - if (mConnectionFailed) { - // interrupt() could have been called even before open() - return false; - } - mClient = new DefaultHttpClient(); - mClient.setHttpRequestRetryHandler( - new DefaultHttpRequestRetryHandler(0, false)); - mBodyInputStream = null; - mResponseLine = null; - mResponseHeaders = null; - mPostEntity = null; - mHttpThread = null; - mConnectionFailed = false; - mConnectionFinished = false; - - // Create the method. We support everything that - // Apache HttpClient supports, apart from TRACE. - if ("GET".equalsIgnoreCase(method)) { - mMethod = new HttpGet(url); - } else if ("POST".equalsIgnoreCase(method)) { - mMethod = new HttpPost(url); - mPostEntity = new StreamEntity(); - ((HttpPost)mMethod).setEntity(mPostEntity); - } else if ("HEAD".equalsIgnoreCase(method)) { - mMethod = new HttpHead(url); - } else if ("PUT".equalsIgnoreCase(method)) { - mMethod = new HttpPut(url); - } else if ("DELETE".equalsIgnoreCase(method)) { - mMethod = new HttpDelete(url); - } else { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Method " + method + " not supported"); - } - return false; - } - HttpParams params = mClient.getParams(); - // We handle the redirections C++-side - HttpClientParams.setRedirecting(params, false); - HttpProtocolParams.setUseExpectContinue(params, false); - return true; - } - - /** - * We use this to start the connection thread (doing the method execute). - * We usually always return true here, as the connection will run its - * course in the thread. - * We only return false if interrupted beforehand -- if a connection - * problem happens, we will thus fail in either sendPostData() or - * parseHeaders(). - */ - public synchronized boolean connectToRemote() { - boolean ret = false; - applyRequestHeaders(); - mConnectionFailedLock.lock(); - if (!mConnectionFailed) { - mHttpThread = new Thread(new Connection()); - mHttpThread.start(); - } - ret = mConnectionFailed; - mConnectionFailedLock.unlock(); - return !ret; - } - - /** - * Get the complete response line of the HTTP request. Only valid on - * completion of the transaction. - * @return The complete HTTP response line, e.g "HTTP/1.0 200 OK". - */ - public synchronized String getResponseLine() { - return mResponseLine; - } - - /** - * Wait for the request thread completion - * (unless already finished) - */ - private void waitUntilConnectionFinished() { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "waitUntilConnectionFinished(" - + mConnectionFinished + ")"); - } - if (!mConnectionFinished) { - if (mHttpThread != null) { - try { - mHttpThread.join(); - mConnectionFinished = true; - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "http thread joined"); - } - } catch (InterruptedException e) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "interrupted: " + e); - } - } - } else { - Log.e(LOG_TAG, ">>> Trying to join on mHttpThread " + - "when it does not exist!"); - } - } - } - - // Headers handling - - /** - * Receive all headers from the server and populate - * mResponseHeaders. - * @return True if headers are successfully received, False on - * connection error. - */ - public synchronized boolean parseHeaders() { - mConnectionFailedLock.lock(); - if (mConnectionFailed) { - mConnectionFailedLock.unlock(); - return false; - } - mConnectionFailedLock.unlock(); - waitUntilConnectionFinished(); - mResponseHeaders = new HashMap<String, String[]>(); - if (mResponse == null) - return false; - - Header[] headers = mResponse.getAllHeaders(); - for (int i = 0; i < headers.length; i++) { - Header header = headers[i]; - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "header " + header.getName() - + " -> " + header.getValue()); - } - setResponseHeader(header.getName(), header.getValue()); - } - - return true; - } - - /** - * Set a header to send with the HTTP request. Will not take effect - * on a transaction already in progress. The key is associated - * case-insensitive, but stored case-sensitive. - * @param name The name of the header, e.g "Set-Cookie". - * @param value The value for this header, e.g "text/html". - */ - public synchronized void setRequestHeader(String name, String value) { - String[] mapValue = { name, value }; - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "setRequestHeader: " + name + " => " + value); - } - if (name.equalsIgnoreCase(KEY_CONTENT_LENGTH)) { - setContentLength(Long.parseLong(value)); - } else { - mRequestHeaders.put(name.toLowerCase(), mapValue); - } - } - - /** - * Returns the value associated with the given request header. - * @param name The name of the request header, non-null, case-insensitive. - * @return The value associated with the request header, or null if - * not set, or error. - */ - public synchronized String getRequestHeader(String name) { - String[] value = mRequestHeaders.get(name.toLowerCase()); - if (value != null) { - return value[HEADERS_MAP_INDEX_VALUE]; - } else { - return null; - } - } - - private void applyRequestHeaders() { - if (mMethod == null) - return; - Iterator<String[]> it = mRequestHeaders.values().iterator(); - while (it.hasNext()) { - // Set the key case-sensitive. - String[] entry = it.next(); - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "apply header " + entry[HEADERS_MAP_INDEX_KEY] + - " => " + entry[HEADERS_MAP_INDEX_VALUE]); - } - mMethod.setHeader(entry[HEADERS_MAP_INDEX_KEY], - entry[HEADERS_MAP_INDEX_VALUE]); - } - } - - /** - * Returns the value associated with the given response header. - * @param name The name of the response header, non-null, case-insensitive. - * @return The value associated with the response header, or null if - * not set or error. - */ - public synchronized String getResponseHeader(String name) { - if (mResponseHeaders != null) { - String[] value = mResponseHeaders.get(name.toLowerCase()); - if (value != null) { - return value[HEADERS_MAP_INDEX_VALUE]; - } else { - return null; - } - } else { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "getResponseHeader() called but " - + "response not received"); - } - return null; - } - } - - /** - * Return all response headers, separated by CR-LF line endings, and - * ending with a trailing blank line. This mimics the format of the - * raw response header up to but not including the body. - * @return A string containing the entire response header. - */ - public synchronized String getAllResponseHeaders() { - if (mResponseHeaders == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "getAllResponseHeaders() called but " - + "response not received"); - } - return null; - } - StringBuilder result = new StringBuilder(); - Iterator<String[]> it = mResponseHeaders.values().iterator(); - while (it.hasNext()) { - String[] entry = it.next(); - // Output the "key: value" lines. - result.append(entry[HEADERS_MAP_INDEX_KEY]); - result.append(": "); - result.append(entry[HEADERS_MAP_INDEX_VALUE]); - result.append(HTTP_LINE_ENDING); - } - result.append(HTTP_LINE_ENDING); - return result.toString(); - } - - - /** - * Set a response header and associated value. The key is associated - * case-insensitively, but stored case-sensitively. - * @param name Case sensitive request header key. - * @param value The associated value. - */ - private void setResponseHeader(String name, String value) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Set response header " + name + ": " + value); - } - String mapValue[] = { name, value }; - mResponseHeaders.put(name.toLowerCase(), mapValue); - } - - // Cookie handling - - /** - * Get the cookie for the given URL. - * @param url The fully qualified URL. - * @return A string containing the cookie for the URL if it exists, - * or null if not. - */ - public static String getCookieForUrl(String url) { - // Get the cookie for this URL, set as a header - return CookieManager.getInstance().getCookie(url); - } - - /** - * Set the cookie for the given URL. - * @param url The fully qualified URL. - * @param cookie The new cookie value. - * @return A string containing the cookie for the URL if it exists, - * or null if not. - */ - public static void setCookieForUrl(String url, String cookie) { - // Get the cookie for this URL, set as a header - CookieManager.getInstance().setCookie(url, cookie); - } - - // Cache handling - - /** - * Perform a request using LocalServer if possible. Initializes - * class members so that receive() will obtain data from the stream - * provided by the response. - * @param url The fully qualified URL to try in LocalServer. - * @return True if the url was found and is now setup to receive. - * False if not found, with no side-effect. - */ - public synchronized boolean useLocalServerResult(String url) { - UrlInterceptHandlerGears handler = - UrlInterceptHandlerGears.getInstance(); - if (handler == null) { - return false; - } - UrlInterceptHandlerGears.ServiceResponse serviceResponse = - handler.getServiceResponse(url, mRequestHeaders); - if (serviceResponse == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "No response in LocalServer"); - } - return false; - } - // LocalServer will handle this URL. Initialize stream and - // response. - mBodyInputStream = serviceResponse.getInputStream(); - mResponseLine = serviceResponse.getStatusLine(); - mResponseHeaders = serviceResponse.getResponseHeaders(); - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Got response from LocalServer: " + mResponseLine); - } - return true; - } - - /** - * Perform a request using the cache result if present. Initializes - * class members so that receive() will obtain data from the cache. - * @param url The fully qualified URL to try in the cache. - * @return True is the url was found and is now setup to receive - * from cache. False if not found, with no side-effect. - */ - public synchronized boolean useCacheResult(String url) { - // Try the browser's cache. CacheManager wants a Map<String, String>. - Map<String, String> cacheRequestHeaders = new HashMap<String, String>(); - Iterator<Map.Entry<String, String[]>> it = - mRequestHeaders.entrySet().iterator(); - while (it.hasNext()) { - Map.Entry<String, String[]> entry = it.next(); - cacheRequestHeaders.put( - entry.getKey(), - entry.getValue()[HEADERS_MAP_INDEX_VALUE]); - } - CacheResult mCacheResult = - CacheManager.getCacheFile(url, cacheRequestHeaders); - if (mCacheResult == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "No CacheResult for " + url); - } - return false; - } - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Got CacheResult from browser cache"); - } - // Check for expiry. -1 is "never", otherwise milliseconds since 1970. - // Can be compared to System.currentTimeMillis(). - long expires = mCacheResult.getExpires(); - if (expires >= 0 && System.currentTimeMillis() >= expires) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "CacheResult expired " - + (System.currentTimeMillis() - expires) - + " milliseconds ago"); - } - // Cache hit has expired. Do not return it. - return false; - } - // Setup the mBodyInputStream to come from the cache. - mBodyInputStream = mCacheResult.getInputStream(); - if (mBodyInputStream == null) { - // Cache result may have gone away. - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "No mBodyInputStream for CacheResult " + url); - } - return false; - } - // Cache hit. Parse headers. - synthesizeHeadersFromCacheResult(mCacheResult); - return true; - } - - /** - * Take the limited set of headers in a CacheResult and synthesize - * response headers. - * @param cacheResult A CacheResult to populate mResponseHeaders with. - */ - private void synthesizeHeadersFromCacheResult(CacheResult cacheResult) { - int statusCode = cacheResult.getHttpStatusCode(); - // The status message is informal, so we can greatly simplify it. - String statusMessage; - if (statusCode >= 200 && statusCode < 300) { - statusMessage = "OK"; - } else if (statusCode >= 300 && statusCode < 400) { - statusMessage = "MOVED"; - } else { - statusMessage = "UNAVAILABLE"; - } - // Synthesize the response line. - mResponseLine = "HTTP/1.1 " + statusCode + " " + statusMessage; - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Synthesized " + mResponseLine); - } - // Synthesize the returned headers from cache. - mResponseHeaders = new HashMap<String, String[]>(); - String contentLength = Long.toString(cacheResult.getContentLength()); - setResponseHeader(KEY_CONTENT_LENGTH, contentLength); - long expires = cacheResult.getExpires(); - if (expires >= 0) { - // "Expires" header is valid and finite. Milliseconds since 1970 - // epoch, formatted as RFC-1123. - String expiresString = DateUtils.formatDate(new Date(expires)); - setResponseHeader(KEY_EXPIRES, expiresString); - } - String lastModified = cacheResult.getLastModified(); - if (lastModified != null) { - // Last modification time of the page. Passed end-to-end, but - // not used by us. - setResponseHeader(KEY_LAST_MODIFIED, lastModified); - } - String eTag = cacheResult.getETag(); - if (eTag != null) { - // Entity tag. A kind of GUID to identify identical resources. - setResponseHeader(KEY_ETAG, eTag); - } - String location = cacheResult.getLocation(); - if (location != null) { - // If valid, refers to the location of a redirect. - setResponseHeader(KEY_LOCATION, location); - } - String mimeType = cacheResult.getMimeType(); - if (mimeType == null) { - // Use a safe default MIME type when none is - // specified. "text/plain" is safe to render in the browser - // window (even if large) and won't be intepreted as anything - // that would cause execution. - mimeType = DEFAULT_MIME_TYPE; - } - String encoding = cacheResult.getEncoding(); - // Encoding may not be specified. No default. - String contentType = mimeType; - if (encoding != null) { - if (encoding.length() > 0) { - contentType += "; charset=" + encoding; - } - } - setResponseHeader(KEY_CONTENT_TYPE, contentType); - } - - /** - * Create a CacheResult for this URL. This enables the repsonse body - * to be sent in calls to appendCacheResult(). - * @param url The fully qualified URL to add to the cache. - * @param responseCode The response code returned for the request, e.g 200. - * @param mimeType The MIME type of the body, e.g "text/plain". - * @param encoding The encoding, e.g "utf-8". Use "" for unknown. - */ - public synchronized boolean createCacheResult( - String url, int responseCode, String mimeType, String encoding) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Making cache entry for " + url); - } - // Take the headers and parse them into a format needed by - // CacheManager. - Headers cacheHeaders = new Headers(); - Iterator<Map.Entry<String, String[]>> it = - mResponseHeaders.entrySet().iterator(); - while (it.hasNext()) { - Map.Entry<String, String[]> entry = it.next(); - // Headers.parseHeader() expects lowercase keys. - String keyValue = entry.getKey() + ": " - + entry.getValue()[HEADERS_MAP_INDEX_VALUE]; - CharArrayBuffer buffer = new CharArrayBuffer(keyValue.length()); - buffer.append(keyValue); - // Parse it into the header container. - cacheHeaders.parseHeader(buffer); - } - mCacheResult = CacheManager.createCacheFile( - url, responseCode, cacheHeaders, mimeType, true); - if (mCacheResult != null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Saving into cache"); - } - mCacheResult.setEncoding(encoding); - mCacheResultUrl = url; - return true; - } else { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Couldn't create mCacheResult"); - } - return false; - } - } - - /** - * Add data from the response body to the CacheResult created with - * createCacheResult(). - * @param data A byte array of the next sequential bytes in the - * response body. - * @param bytes The number of bytes to write from the start of - * the array. - * @return True if all bytes successfully written, false on failure. - */ - public synchronized boolean appendCacheResult(byte[] data, int bytes) { - if (mCacheResult == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "appendCacheResult() called without a " - + "CacheResult initialized"); - } - return false; - } - try { - mCacheResult.getOutputStream().write(data, 0, bytes); - } catch (IOException ex) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Got IOException writing cache data: " + ex); - } - return false; - } - return true; - } - - /** - * Save the completed CacheResult into the CacheManager. This must - * have been created first with createCacheResult(). - * @return Returns true if the entry has been successfully saved. - */ - public synchronized boolean saveCacheResult() { - if (mCacheResult == null || mCacheResultUrl == null) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Tried to save cache result but " - + "createCacheResult not called"); - } - return false; - } - - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Saving cache result"); - } - CacheManager.saveCacheFile(mCacheResultUrl, mCacheResult); - mCacheResult = null; - mCacheResultUrl = null; - return true; - } - - /** - * Called by the main thread to interrupt the child thread. - * We do not set mConnectionFailed here as we still need the - * ability to receive a null packet for sendPostData(). - */ - public synchronized void abort() { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "ABORT CALLED"); - } - if (mMethod != null) { - mMethod.abort(); - } - } - - /** - * Interrupt a blocking IO operation and wait for the - * thread to complete. - */ - public synchronized void interrupt() { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "INTERRUPT CALLED"); - } - mConnectionFailedLock.lock(); - mConnectionFailed = true; - mConnectionFailedLock.unlock(); - if (mMethod != null) { - mMethod.abort(); - } - if (mHttpThread != null) { - waitUntilConnectionFinished(); - } - } - - /** - * Receive the next sequential bytes of the response body after - * successful connection. This will receive up to the size of the - * provided byte array. If there is no body, this will return 0 - * bytes on the first call after connection. - * @param buf A pre-allocated byte array to receive data into. - * @return The number of bytes from the start of the array which - * have been filled, 0 on EOF, or negative on error. - */ - public synchronized int receive(byte[] buf) { - if (mBodyInputStream == null) { - // If this is the first call, setup the InputStream. This may - // fail if there were headers, but no body returned by the - // server. - try { - if (mResponse != null) { - HttpEntity entity = mResponse.getEntity(); - mBodyInputStream = entity.getContent(); - } - } catch (IOException inputException) { - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Failed to connect InputStream: " - + inputException); - } - // Not unexpected. For example, 404 response return headers, - // and sometimes a body with a detailed error. - } - if (mBodyInputStream == null) { - // No error stream either. Treat as a 0 byte response. - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "No InputStream"); - } - return 0; // EOF. - } - } - int ret; - try { - int got = mBodyInputStream.read(buf); - if (got > 0) { - // Got some bytes, not EOF. - ret = got; - } else { - // EOF. - mBodyInputStream.close(); - ret = 0; - } - } catch (IOException e) { - // An abort() interrupts us by calling close() on our stream. - if (LOGV_ENABLED) { - Log.i(LOG_TAG, "Got IOException in mBodyInputStream.read(): ", e); - } - ret = -1; - } - return ret; - } - - /** - * For POST method requests, send a stream of data provided by the - * native side in repeated callbacks. - * We put the data in mBuffer, and wait until it is consumed - * by the StreamEntity in the request thread. - * @param data A byte array containing the data to sent, or null - * if indicating EOF. - * @param bytes The number of bytes from the start of the array to - * send, or 0 if indicating EOF. - * @return True if all bytes were successfully sent, false on error. - */ - public boolean sendPostData(byte[] data, int bytes) { - mConnectionFailedLock.lock(); - if (mConnectionFailed) { - mConnectionFailedLock.unlock(); - return false; - } - mConnectionFailedLock.unlock(); - if (mPostEntity == null) return false; - - // We block until the outputstream is available - // (or in case of connection error) - if (!mPostEntity.isReady()) return false; - - if (data == null && bytes == 0) { - mBuffer.put(null); - } else { - mBuffer.put(new DataPacket(data, bytes)); - } - mSignal.waitUntilPacketConsumed(); - - mConnectionFailedLock.lock(); - if (mConnectionFailed) { - Log.e(LOG_TAG, "failure"); - mConnectionFailedLock.unlock(); - return false; - } - mConnectionFailedLock.unlock(); - return true; - } - -} diff --git a/core/java/android/webkit/gears/DesktopAndroid.java b/core/java/android/webkit/gears/DesktopAndroid.java deleted file mode 100644 index a7a144b..0000000 --- a/core/java/android/webkit/gears/DesktopAndroid.java +++ /dev/null @@ -1,113 +0,0 @@ -// Copyright 2008 The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.Context; -import android.content.ComponentName; -import android.content.Intent; -import android.graphics.Bitmap; -import android.graphics.BitmapFactory; -import android.net.Uri; -import android.provider.Browser; -import android.util.Log; -import android.webkit.WebView; - -/** - * Utility class to create a shortcut on Android - */ -public class DesktopAndroid { - - private static final String TAG = "Gears-J-Desktop"; - private static final String EXTRA_SHORTCUT_DUPLICATE = "duplicate"; - private static final String ACTION_INSTALL_SHORTCUT = - "com.android.launcher.action.INSTALL_SHORTCUT"; - - // Android now enforces a 64x64 limit for the icon - private static int MAX_WIDTH = 64; - private static int MAX_HEIGHT = 64; - - /** - * Small utility function returning a Bitmap object. - * - * @param path the icon path - */ - private static Bitmap getBitmap(String path) { - return BitmapFactory.decodeFile(path); - } - - /** - * Create a shortcut for a webpage. - * - * <p>To set a shortcut on Android, we use the ACTION_INSTALL_SHORTCUT - * from the default Home application. We only have to create an Intent - * containing extra parameters specifying the shortcut. - * <p>Note: the shortcut mechanism is not system wide and depends on the - * Home application; if phone carriers decide to rewrite a Home application - * that does not accept this Intent, no shortcut will be added. - * - * @param webview the webview we are called from - * @param title the shortcut's title - * @param url the shortcut's url - * @param imagePath the local path of the shortcut's icon - */ - public static void setShortcut(WebView webview, String title, - String url, String imagePath) { - Context context = webview.getContext(); - - Intent viewWebPage = new Intent(Intent.ACTION_VIEW); - viewWebPage.setData(Uri.parse(url)); - long urlHash = url.hashCode(); - long uniqueId = (urlHash << 32) | viewWebPage.hashCode(); - viewWebPage.putExtra(Browser.EXTRA_APPLICATION_ID, - Long.toString(uniqueId)); - - Intent intent = new Intent(ACTION_INSTALL_SHORTCUT); - intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, viewWebPage); - intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, title); - - // We disallow the creation of duplicate shortcuts (i.e. same - // url, same title, but different screen position). - intent.putExtra(EXTRA_SHORTCUT_DUPLICATE, false); - - Bitmap bmp = getBitmap(imagePath); - if (bmp != null) { - if ((bmp.getWidth() > MAX_WIDTH) || - (bmp.getHeight() > MAX_HEIGHT)) { - Bitmap scaledBitmap = Bitmap.createScaledBitmap(bmp, - MAX_WIDTH, MAX_HEIGHT, true); - intent.putExtra(Intent.EXTRA_SHORTCUT_ICON, scaledBitmap); - } else { - intent.putExtra(Intent.EXTRA_SHORTCUT_ICON, bmp); - } - } else { - // This should not happen as we just downloaded the icon - Log.e(TAG, "icon file <" + imagePath + "> not found"); - } - - context.sendBroadcast(intent); - } - -} diff --git a/core/java/android/webkit/gears/NativeDialog.java b/core/java/android/webkit/gears/NativeDialog.java deleted file mode 100644 index 9e2b375..0000000 --- a/core/java/android/webkit/gears/NativeDialog.java +++ /dev/null @@ -1,142 +0,0 @@ -// Copyright 2008 The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.ActivityNotFoundException; -import android.content.Context; -import android.content.Intent; -import android.util.Log; - -import java.io.File; -import java.lang.InterruptedException; -import java.util.concurrent.locks.Condition; -import java.util.concurrent.locks.Lock; -import java.util.concurrent.locks.ReentrantLock; - -/** - * Utility class to call a modal native dialog on Android - * The dialog itself is an Activity defined in the Browser. - * @hide - */ -public class NativeDialog { - - private static final String TAG = "Gears-J-NativeDialog"; - - private final String DIALOG_PACKAGE = "com.android.browser"; - private final String DIALOG_CLASS = DIALOG_PACKAGE + ".GearsNativeDialog"; - - private static Lock mLock = new ReentrantLock(); - private static Condition mDialogFinished = mLock.newCondition(); - private static String mResults = null; - - private static boolean mAsynchronousDialog; - - /** - * Utility function to build the intent calling the - * dialog activity - */ - private Intent createIntent(String type, String arguments) { - Intent intent = new Intent(); - intent.setClassName(DIALOG_PACKAGE, DIALOG_CLASS); - intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); - intent.putExtra("dialogArguments", arguments); - intent.putExtra("dialogType", type); - return intent; - } - - /** - * Opens a native dialog synchronously and waits for its completion. - * - * The dialog is an activity (GearsNativeDialog) provided by the Browser - * that we call via startActivity(). Contrary to a normal activity though, - * we need to block until it returns. To do so, we define a static lock - * object in this class, which GearsNativeDialog can unlock once done - */ - public String showDialog(Context context, String file, - String arguments) { - - try { - mAsynchronousDialog = false; - mLock.lock(); - File path = new File(file); - String fileName = path.getName(); - String type = fileName.substring(0, fileName.indexOf(".html")); - Intent intent = createIntent(type, arguments); - - mResults = null; - context.startActivity(intent); - mDialogFinished.await(); - } catch (InterruptedException e) { - Log.e(TAG, "exception e: " + e); - } catch (ActivityNotFoundException e) { - Log.e(TAG, "exception e: " + e); - } finally { - mLock.unlock(); - } - - return mResults; - } - - /** - * Opens a native dialog asynchronously - * - * The dialog is an activity (GearsNativeDialog) provided by the - * Browser. - */ - public void showAsyncDialog(Context context, String type, - String arguments) { - mAsynchronousDialog = true; - Intent intent = createIntent(type, arguments); - context.startActivity(intent); - } - - /** - * Static method that GearsNativeDialog calls to unlock us - */ - public static void signalFinishedDialog() { - if (!mAsynchronousDialog) { - mLock.lock(); - mDialogFinished.signal(); - mLock.unlock(); - } else { - // we call the native callback - closeAsynchronousDialog(mResults); - } - } - - /** - * Static method that GearsNativeDialog calls to set the - * dialog's result - */ - public static void closeDialog(String res) { - mResults = res; - } - - /** - * Native callback method - */ - private native static void closeAsynchronousDialog(String res); -} diff --git a/core/java/android/webkit/gears/PluginSettings.java b/core/java/android/webkit/gears/PluginSettings.java deleted file mode 100644 index 2d0cc13..0000000 --- a/core/java/android/webkit/gears/PluginSettings.java +++ /dev/null @@ -1,79 +0,0 @@ -// Copyright 2008 The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.content.Context; -import android.util.Log; -import android.webkit.Plugin; -import android.webkit.Plugin.PreferencesClickHandler; - -/** - * Simple bridge class intercepting the click in the - * browser plugin list and calling the Gears settings - * dialog. - */ -public class PluginSettings { - - private static final String TAG = "Gears-J-PluginSettings"; - private Context mContext; - - public PluginSettings(Plugin plugin) { - plugin.setClickHandler(new ClickHandler()); - } - - /** - * We do not call the dialog synchronously here as the main - * message loop would be blocked, so we call it via a secondary thread. - */ - private class ClickHandler implements PreferencesClickHandler { - public void handleClickEvent(Context context) { - mContext = context.getApplicationContext(); - Thread startDialog = new Thread(new StartDialog(context)); - startDialog.start(); - } - } - - /** - * Simple wrapper class to call the gears native method in - * a separate thread (the native code will then instanciate a NativeDialog - * object which will start the GearsNativeDialog activity defined in - * the Browser). - */ - private class StartDialog implements Runnable { - Context mContext; - - public StartDialog(Context context) { - mContext = context; - } - - public void run() { - runSettingsDialog(mContext); - } - } - - private static native void runSettingsDialog(Context c); - -} diff --git a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java b/core/java/android/webkit/gears/UrlInterceptHandlerGears.java deleted file mode 100644 index 43104bf..0000000 --- a/core/java/android/webkit/gears/UrlInterceptHandlerGears.java +++ /dev/null @@ -1,417 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.util.Log; -import android.webkit.CacheManager.CacheResult; -import android.webkit.Plugin; -import android.webkit.PluginData; -import android.webkit.UrlInterceptRegistry; -import android.webkit.UrlInterceptHandler; -import android.webkit.WebView; - -import org.apache.http.util.CharArrayBuffer; - -import java.io.*; -import java.util.*; - -/** - * Services requests to handle URLs coming from the browser or - * HttpRequestAndroid. This registers itself with the - * UrlInterceptRegister in Android so we get a chance to service all - * URLs passing through the browser before anything else. - */ -public class UrlInterceptHandlerGears implements UrlInterceptHandler { - /** Singleton instance. */ - private static UrlInterceptHandlerGears instance; - /** Debug logging tag. */ - private static final String LOG_TAG = "Gears-J"; - /** Buffer size for reading/writing streams. */ - private static final int BUFFER_SIZE = 4096; - /** Enable/disable all logging in this class. */ - private static boolean logEnabled = false; - /** The unmodified (case-sensitive) key in the headers map is the - * same index as used by HttpRequestAndroid. */ - public static final int HEADERS_MAP_INDEX_KEY = - ApacheHttpRequestAndroid.HEADERS_MAP_INDEX_KEY; - /** The associated value in the headers map is the same index as - * used by HttpRequestAndroid. */ - public static final int HEADERS_MAP_INDEX_VALUE = - ApacheHttpRequestAndroid.HEADERS_MAP_INDEX_VALUE; - - /** - * Object passed to the native side, containing information about - * the URL to service. - */ - public static class ServiceRequest { - // The URL being requested. - private String url; - // Request headers. Map of lowercase key to [ unmodified key, value ]. - private Map<String, String[]> requestHeaders; - - /** - * Initialize members on construction. - * @param url The URL being requested. - * @param requestHeaders Headers associated with the request, - * or null if none. - * Map of lowercase key to [ unmodified key, value ]. - */ - public ServiceRequest(String url, Map<String, String[]> requestHeaders) { - this.url = url; - this.requestHeaders = requestHeaders; - } - - /** - * Returns the URL being requested. - * @return The URL being requested. - */ - public String getUrl() { - return url; - } - - /** - * Get the value associated with a request header key, if any. - * @param header The key to find, case insensitive. - * @return The value associated with this header, or null if not found. - */ - public String getRequestHeader(String header) { - if (requestHeaders != null) { - String[] value = requestHeaders.get(header.toLowerCase()); - if (value != null) { - return value[HEADERS_MAP_INDEX_VALUE]; - } else { - return null; - } - } else { - return null; - } - } - } - - /** - * Object returned by the native side, containing information needed - * to pass the entire response back to the browser or - * HttpRequestAndroid. Works from either an in-memory array or a - * file on disk. - */ - public class ServiceResponse { - // The response status code, e.g 200. - private int statusCode; - // The full status line, e.g "HTTP/1.1 200 OK". - private String statusLine; - // All headers associated with the response. Map of lowercase key - // to [ unmodified key, value ]. - private Map<String, String[]> responseHeaders = - new HashMap<String, String[]>(); - // The MIME type, e.g "text/html". - private String mimeType; - // The encoding, e.g "utf-8", or null if none. - private String encoding; - // The stream which contains the body when read(). - private InputStream inputStream; - // The length of the content body. - private long contentLength; - - /** - * Initialize members using an in-memory array to return the body. - * @param statusCode The response status code, e.g 200. - * @param statusLine The full status line, e.g "HTTP/1.1 200 OK". - * @param mimeType The MIME type, e.g "text/html". - * @param encoding Encoding, e.g "utf-8" or null if none. - * @param body The response body as a byte array, non-empty. - */ - void setResultArray( - int statusCode, - String statusLine, - String mimeType, - String encoding, - byte[] body) { - this.statusCode = statusCode; - this.statusLine = statusLine; - this.mimeType = mimeType; - this.encoding = encoding; - // Setup a stream to read out of the byte array. - this.contentLength = body.length; - this.inputStream = new ByteArrayInputStream(body); - } - - /** - * Initialize members using a file on disk to return the body. - * @param statusCode The response status code, e.g 200. - * @param statusLine The full status line, e.g "HTTP/1.1 200 OK". - * @param mimeType The MIME type, e.g "text/html". - * @param encoding Encoding, e.g "utf-8" or null if none. - * @param path Full path to the file containing the body. - * @return True if the file is successfully setup to stream, - * false on error such as file not found. - */ - boolean setResultFile( - int statusCode, - String statusLine, - String mimeType, - String encoding, - String path) { - this.statusCode = statusCode; - this.statusLine = statusLine; - this.mimeType = mimeType; - this.encoding = encoding; - try { - // Setup a stream to read out of a file on disk. - File file = new File(path); - this.contentLength = file.length(); - this.inputStream = new FileInputStream(file); - return true; - } catch (java.io.FileNotFoundException ex) { - log("File not found: " + path); - return false; - } - } - - /** - * Set a response header, adding its settings to the header members. - * @param key The case sensitive key for the response header, - * e.g "Set-Cookie". - * @param value The value associated with this key, e.g "cookie1234". - */ - public void setResponseHeader(String key, String value) { - // The map value contains the unmodified key (not lowercase). - String[] mapValue = { key, value }; - responseHeaders.put(key.toLowerCase(), mapValue); - } - - /** - * Return the "Content-Type" header possibly supplied by a - * previous setResponseHeader(). - * @return The "Content-Type" value, or null if not present. - */ - public String getContentType() { - // The map keys are lowercase. - String[] value = responseHeaders.get("content-type"); - if (value != null) { - return value[HEADERS_MAP_INDEX_VALUE]; - } else { - return null; - } - } - - /** - * Returns the HTTP status code for the response, supplied in - * setResultArray() or setResultFile(). - * @return The HTTP statue code, e.g 200. - */ - public int getStatusCode() { - return statusCode; - } - - /** - * Returns the full HTTP status line for the response, supplied in - * setResultArray() or setResultFile(). - * @return The HTTP statue line, e.g "HTTP/1.1 200 OK". - */ - public String getStatusLine() { - return statusLine; - } - - /** - * Get all response headers supplied in calls in - * setResponseHeader(). - * @return A Map<String, String[]> containing all headers. - */ - public Map<String, String[]> getResponseHeaders() { - return responseHeaders; - } - - /** - * Returns the MIME type for the response, supplied in - * setResultArray() or setResultFile(). - * @return The MIME type, e.g "text/html". - */ - public String getMimeType() { - return mimeType; - } - - /** - * Returns the encoding for the response, supplied in - * setResultArray() or setResultFile(), or null if none. - * @return The encoding, e.g "utf-8", or null if none. - */ - public String getEncoding() { - return encoding; - } - - /** - * Returns the InputStream setup by setResultArray() or - * setResultFile() to allow reading data either from memory or - * disk. - * @return The InputStream containing the response body. - */ - public InputStream getInputStream() { - return inputStream; - } - - /** - * @return The length of the response body. - */ - public long getContentLength() { - return contentLength; - } - } - - /** - * Construct and initialize the singleton instance. - */ - public UrlInterceptHandlerGears() { - if (instance != null) { - Log.e(LOG_TAG, "UrlInterceptHandlerGears singleton already constructed"); - throw new RuntimeException(); - } - instance = this; - } - - /** - * Turn on/off logging in this class. - * @param on Logging enable state. - */ - public static void enableLogging(boolean on) { - logEnabled = on; - } - - /** - * Get the singleton instance. - * @return The singleton instance. - */ - public static UrlInterceptHandlerGears getInstance() { - return instance; - } - - /** - * Register the singleton instance with the browser's interception - * mechanism. - */ - public synchronized void register() { - UrlInterceptRegistry.registerHandler(this); - } - - /** - * Unregister the singleton instance from the browser's interception - * mechanism. - */ - public synchronized void unregister() { - UrlInterceptRegistry.unregisterHandler(this); - } - - /** - * Given an URL, returns the CacheResult which contains the - * surrogate response for the request, or null if the handler is - * not interested. - * - * @param url URL string. - * @param headers The headers associated with the request. May be null. - * @return The CacheResult containing the surrogate response. - * @Deprecated Use PluginData getPluginData(String url, - * Map<String, String> headers); instead - */ - @Deprecated - public CacheResult service(String url, Map<String, String> headers) { - throw new UnsupportedOperationException("unimplemented"); - } - - /** - * Given an URL, returns a PluginData instance which contains the - * response for the request. This implements the UrlInterceptHandler - * interface. - * - * @param url The fully qualified URL being requested. - * @param requestHeaders The request headers for this URL. - * @return a PluginData object. - */ - public PluginData getPluginData(String url, Map<String, String> requestHeaders) { - // Thankfully the browser does call us with case-sensitive - // headers. We just need to map it case-insensitive. - Map<String, String[]> lowercaseRequestHeaders = - new HashMap<String, String[]>(); - Iterator<Map.Entry<String, String>> requestHeadersIt = - requestHeaders.entrySet().iterator(); - while (requestHeadersIt.hasNext()) { - Map.Entry<String, String> entry = requestHeadersIt.next(); - String key = entry.getKey(); - String mapValue[] = { key, entry.getValue() }; - lowercaseRequestHeaders.put(key.toLowerCase(), mapValue); - } - ServiceResponse response = getServiceResponse(url, lowercaseRequestHeaders); - if (response == null) { - // No result for this URL. - return null; - } - return new PluginData(response.getInputStream(), - response.getContentLength(), - response.getResponseHeaders(), - response.getStatusCode()); - } - - /** - * Given an URL, returns a CacheResult and headers which contain the - * response for the request. - * - * @param url The fully qualified URL being requested. - * @param requestHeaders The request headers for this URL. - * @return If a response can be crafted, a ServiceResponse is - * created which contains all response headers and an InputStream - * attached to the body. If there is no response, null is returned. - */ - public ServiceResponse getServiceResponse(String url, - Map<String, String[]> requestHeaders) { - if (!url.startsWith("http://") && !url.startsWith("https://")) { - // Don't know how to service non-HTTP URLs - return null; - } - // Call the native handler to craft a response for this URL. - return nativeService(new ServiceRequest(url, requestHeaders)); - } - - /** - * Convenience debug function. Calls the Android logging - * mechanism. logEnabled is not a constant, so if the string - * evaluation is potentially expensive, the caller also needs to - * check it. - * @param str String to log to the Android console. - */ - private void log(String str) { - if (logEnabled) { - Log.i(LOG_TAG, str); - } - } - - /** - * Native method which handles the bulk of the request in LocalServer. - * @param request A ServiceRequest object containing information about - * the request. - * @return If serviced, a ServiceResponse object containing all the - * information to provide a response for the URL, or null - * if no response available for this URL. - */ - private native static ServiceResponse nativeService(ServiceRequest request); -} diff --git a/core/java/android/webkit/gears/VersionExtractor.java b/core/java/android/webkit/gears/VersionExtractor.java deleted file mode 100644 index 172dacb..0000000 --- a/core/java/android/webkit/gears/VersionExtractor.java +++ /dev/null @@ -1,147 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.util.Log; -import java.io.IOException; -import java.io.StringReader; -import javax.xml.parsers.DocumentBuilderFactory; -import javax.xml.parsers.DocumentBuilder; -import javax.xml.parsers.FactoryConfigurationError; -import javax.xml.parsers.ParserConfigurationException; -import org.xml.sax.InputSource; -import org.xml.sax.SAXException; -import org.w3c.dom.Document; -import org.w3c.dom.DOMException; -import org.w3c.dom.Node; -import org.w3c.dom.NodeList; - -/** - * A class that can extract the Gears version and upgrade URL from an - * xml document. - */ -public final class VersionExtractor { - - /** - * Logging tag - */ - private static final String TAG = "Gears-J-VersionExtractor"; - /** - * XML element names. - */ - private static final String VERSION = "em:version"; - private static final String URL = "em:updateLink"; - - /** - * Parses the input xml string and invokes the native - * setVersionAndUrl method. - * @param xml is the XML string to parse. - * @return true if the extraction is successful and false otherwise. - */ - public static boolean extract(String xml, long nativeObject) { - try { - // Build the builders. - DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); - factory.setNamespaceAware(false); - DocumentBuilder builder = factory.newDocumentBuilder(); - - // Create the document. - Document doc = builder.parse(new InputSource(new StringReader(xml))); - - // Look for the version and url elements and get their text - // contents. - String version = extractText(doc, VERSION); - String url = extractText(doc, URL); - - // If we have both, let the native side know. - if (version != null && url != null) { - setVersionAndUrl(version, url, nativeObject); - return true; - } - - return false; - - } catch (FactoryConfigurationError ex) { - Log.e(TAG, "Could not create the DocumentBuilderFactory " + ex); - } catch (ParserConfigurationException ex) { - Log.e(TAG, "Could not create the DocumentBuilder " + ex); - } catch (SAXException ex) { - Log.e(TAG, "Could not parse the xml " + ex); - } catch (IOException ex) { - Log.e(TAG, "Could not read the xml " + ex); - } - - return false; - } - - /** - * Extracts the text content of the first element with the given name. - * @param doc is the Document where the element is searched for. - * @param elementName is name of the element to searched for. - * @return the text content of the element or null if no such - * element is found. - */ - private static String extractText(Document doc, String elementName) { - String text = null; - NodeList node_list = doc.getElementsByTagName(elementName); - - if (node_list.getLength() > 0) { - // We are only interested in the first node. Normally there - // should not be more than one anyway. - Node node = node_list.item(0); - - // Iterate through the text children. - NodeList child_list = node.getChildNodes(); - - try { - for (int i = 0; i < child_list.getLength(); ++i) { - Node child = child_list.item(i); - if (child.getNodeType() == Node.TEXT_NODE) { - if (text == null) { - text = new String(); - } - text += child.getNodeValue(); - } - } - } catch (DOMException ex) { - Log.e(TAG, "getNodeValue() failed " + ex); - } - } - - if (text != null) { - text = text.trim(); - } - - return text; - } - - /** - * Native method used to send the version and url back to the C++ - * side. - */ - private static native void setVersionAndUrl( - String version, String url, long nativeObject); -} diff --git a/core/java/android/webkit/gears/ZipInflater.java b/core/java/android/webkit/gears/ZipInflater.java deleted file mode 100644 index f6b6be5..0000000 --- a/core/java/android/webkit/gears/ZipInflater.java +++ /dev/null @@ -1,200 +0,0 @@ -// Copyright 2008, The Android Open Source Project -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, -// this list of conditions and the following disclaimer. -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// 3. Neither the name of Google Inc. nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED -// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF -// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; -// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, -// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR -// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF -// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -package android.webkit.gears; - -import android.os.StatFs; -import android.util.Log; -import java.io.BufferedInputStream; -import java.io.BufferedOutputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.FileOutputStream; -import java.io.IOException; -import java.util.Enumeration; -import java.util.zip.CRC32; -import java.util.zip.ZipEntry; -import java.util.zip.ZipFile; -import java.util.zip.ZipInputStream; - - -/** - * A class that can inflate a zip archive. - */ -public final class ZipInflater { - /** - * Logging tag - */ - private static final String TAG = "Gears-J-ZipInflater"; - - /** - * The size of the buffer used to read from the archive. - */ - private static final int BUFFER_SIZE_BYTES = 32 * 1024; // 32 KB. - /** - * The path navigation component (i.e. "../"). - */ - private static final String PATH_NAVIGATION_COMPONENT = ".." + File.separator; - /** - * The root of the data partition. - */ - private static final String DATA_PARTITION_ROOT = "/data"; - - /** - * We need two be able to store two versions of gears in parallel: - * - the zipped version - * - the unzipped version, which will be loaded next time the browser is started. - * We are conservative and do not attempt to unpack unless there enough free - * space on the device to store 4 times the new Gears size. - */ - private static final long SIZE_MULTIPLIER = 4; - - /** - * Unzips the archive with the given name. - * @param filename is the name of the zip to inflate. - * @param path is the path where the zip should be unpacked. It must contain - * a trailing separator, or the extraction will fail. - * @return true if the extraction is successful and false otherwise. - */ - public static boolean inflate(String filename, String path) { - Log.i(TAG, "Extracting " + filename + " to " + path); - - // Check that the path ends with a separator. - if (!path.endsWith(File.separator)) { - Log.e(TAG, "Path missing trailing separator: " + path); - return false; - } - - boolean result = false; - - // Use a ZipFile to get an enumeration of the entries and - // calculate the overall uncompressed size of the archive. Also - // check for existing files or directories that have the same - // name as the entries in the archive. Also check for invalid - // entry names (e.g names that attempt to navigate to the - // parent directory). - ZipInputStream zipStream = null; - long uncompressedSize = 0; - try { - ZipFile zipFile = new ZipFile(filename); - try { - Enumeration entries = zipFile.entries(); - while (entries.hasMoreElements()) { - ZipEntry entry = (ZipEntry) entries.nextElement(); - uncompressedSize += entry.getSize(); - // Check against entry names that may attempt to navigate - // out of the destination directory. - if (entry.getName().indexOf(PATH_NAVIGATION_COMPONENT) >= 0) { - throw new IOException("Illegal entry name: " + entry.getName()); - } - - // Check against entries with the same name as pre-existing files or - // directories. - File file = new File(path + entry.getName()); - if (file.exists()) { - // A file or directory with the same name already exist. - // This must not happen, so we treat this as an error. - throw new IOException( - "A file or directory with the same name already exists."); - } - } - } finally { - zipFile.close(); - } - - Log.i(TAG, "Determined uncompressed size: " + uncompressedSize); - // Check we have enough space to unpack this archive. - if (freeSpace() <= uncompressedSize * SIZE_MULTIPLIER) { - throw new IOException("Not enough space to unpack this archive."); - } - - zipStream = new ZipInputStream( - new BufferedInputStream(new FileInputStream(filename))); - ZipEntry entry; - int counter; - byte buffer[] = new byte[BUFFER_SIZE_BYTES]; - - // Iterate through the entries and write each of them to a file. - while ((entry = zipStream.getNextEntry()) != null) { - File file = new File(path + entry.getName()); - if (entry.isDirectory()) { - // If the entry denotes a directory, we need to create a - // directory with the same name. - file.mkdirs(); - } else { - CRC32 checksum = new CRC32(); - BufferedOutputStream output = new BufferedOutputStream( - new FileOutputStream(file), - BUFFER_SIZE_BYTES); - try { - // Read the entry and write it to the file. - while ((counter = zipStream.read(buffer, 0, BUFFER_SIZE_BYTES)) != - -1) { - output.write(buffer, 0, counter); - checksum.update(buffer, 0, counter); - } - output.flush(); - } finally { - output.close(); - } - - if (checksum.getValue() != entry.getCrc()) { - throw new IOException( - "Integrity check failed for: " + entry.getName()); - } - } - zipStream.closeEntry(); - } - - result = true; - - } catch (FileNotFoundException ex) { - Log.e(TAG, "The zip file could not be found. " + ex); - } catch (IOException ex) { - Log.e(TAG, "Could not read or write an entry. " + ex); - } catch(IllegalArgumentException ex) { - Log.e(TAG, "Could not create the BufferedOutputStream. " + ex); - } finally { - if (zipStream != null) { - try { - zipStream.close(); - } catch (IOException ex) { - // Ignored. - } - } - // Discard any exceptions and return the result to the native side. - return result; - } - } - - private static final long freeSpace() { - StatFs data_partition = new StatFs(DATA_PARTITION_ROOT); - long freeSpace = data_partition.getAvailableBlocks() * - data_partition.getBlockSize(); - Log.i(TAG, "Free space on the data partition: " + freeSpace); - return freeSpace; - } -} diff --git a/core/java/android/webkit/gears/package.html b/core/java/android/webkit/gears/package.html deleted file mode 100644 index db6f78b..0000000 --- a/core/java/android/webkit/gears/package.html +++ /dev/null @@ -1,3 +0,0 @@ -<body> -{@hide} -</body>
\ No newline at end of file diff --git a/core/java/android/widget/AbsListView.java b/core/java/android/widget/AbsListView.java index eea97dc..67721c9 100644 --- a/core/java/android/widget/AbsListView.java +++ b/core/java/android/widget/AbsListView.java @@ -546,6 +546,7 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te private void initAbsListView() { // Setting focusable in touch mode will set the focusable property to true + setClickable(true); setFocusableInTouchMode(true); setWillNotDraw(false); setAlwaysDrawnWithCacheEnabled(false); @@ -1433,6 +1434,10 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te * this is a long press. */ void keyPressed() { + if (!isEnabled() || !isClickable()) { + return; + } + Drawable selector = mSelector; Rect selectorRect = mSelectorRect; if (selector != null && (isFocused() || touchModeDrawsInPressedState()) @@ -1450,8 +1455,8 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te Drawable d = selector.getCurrent(); if (d != null && d instanceof TransitionDrawable) { if (longClickable) { - ((TransitionDrawable) d).startTransition(ViewConfiguration - .getLongPressTimeout()); + ((TransitionDrawable) d).startTransition( + ViewConfiguration.getLongPressTimeout()); } else { ((TransitionDrawable) d).resetTransition(); } @@ -1732,18 +1737,29 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te } @Override + public boolean onKeyDown(int keyCode, KeyEvent event) { + return false; + } + + @Override public boolean onKeyUp(int keyCode, KeyEvent event) { switch (keyCode) { case KeyEvent.KEYCODE_DPAD_CENTER: case KeyEvent.KEYCODE_ENTER: - if (isPressed() && mSelectedPosition >= 0 && mAdapter != null && + if (!isEnabled()) { + return true; + } + if (isClickable() && isPressed() && + mSelectedPosition >= 0 && mAdapter != null && mSelectedPosition < mAdapter.getCount()) { + final View view = getChildAt(mSelectedPosition - mFirstPosition); performItemClick(view, mSelectedPosition, mSelectedRowId); setPressed(false); if (view != null) view.setPressed(false); return true; } + break; } return super.onKeyUp(keyCode, event); } @@ -1892,6 +1908,12 @@ public abstract class AbsListView extends AdapterView<ListAdapter> implements Te @Override public boolean onTouchEvent(MotionEvent ev) { + if (!isEnabled()) { + // A disabled view that is clickable still consumes the touch + // events, it just doesn't respond to them. + return isClickable() || isLongClickable(); + } + if (mFastScroller != null) { boolean intercepted = mFastScroller.onTouchEvent(ev); if (intercepted) { diff --git a/core/java/android/widget/AbsSeekBar.java b/core/java/android/widget/AbsSeekBar.java index 04cb8a0..2a0e5e5 100644 --- a/core/java/android/widget/AbsSeekBar.java +++ b/core/java/android/widget/AbsSeekBar.java @@ -64,10 +64,10 @@ public abstract class AbsSeekBar extends ProgressBar { TypedArray a = context.obtainStyledAttributes(attrs, com.android.internal.R.styleable.SeekBar, defStyle, 0); Drawable thumb = a.getDrawable(com.android.internal.R.styleable.SeekBar_thumb); - setThumb(thumb); + setThumb(thumb); // will guess mThumbOffset if thumb != null... + // ...but allow layout to override this int thumbOffset = - a.getDimensionPixelOffset(com.android.internal.R.styleable.SeekBar_thumbOffset, 0); - setThumbOffset(thumbOffset); + a.getDimensionPixelOffset(com.android.internal.R.styleable.SeekBar_thumbOffset, getThumbOffset()); a.recycle(); a = context.obtainStyledAttributes(attrs, @@ -77,13 +77,21 @@ public abstract class AbsSeekBar extends ProgressBar { } /** - * Sets the thumb that will be drawn at the end of the progress meter within the SeekBar + * Sets the thumb that will be drawn at the end of the progress meter within the SeekBar. + * <p> + * If the thumb is a valid drawable (i.e. not null), half its width will be + * used as the new thumb offset (@see #setThumbOffset(int)). * * @param thumb Drawable representing the thumb */ public void setThumb(Drawable thumb) { if (thumb != null) { thumb.setCallback(this); + + // Assuming the thumb drawable is symmetric, set the thumb offset + // such that the thumb will hang halfway off either edge of the + // progress bar. + mThumbOffset = (int)thumb.getIntrinsicWidth() / 2; } mThumb = thumb; invalidate(); @@ -320,11 +328,6 @@ public abstract class AbsSeekBar extends ProgressBar { final int max = getMax(); progress += scale * max; - if (progress < 0) { - progress = 0; - } else if (progress > max) { - progress = max; - } setProgress((int) progress, true); } diff --git a/core/java/android/widget/AdapterView.java b/core/java/android/widget/AdapterView.java index 7d2fcbc..fe6d91a 100644 --- a/core/java/android/widget/AdapterView.java +++ b/core/java/android/widget/AdapterView.java @@ -163,7 +163,7 @@ public abstract class AdapterView<T extends Adapter> extends ViewGroup { /** * View to show if there are no items to show. */ - View mEmptyView; + private View mEmptyView; /** * The number of items in the current adapter. diff --git a/core/java/android/widget/AlphabetIndexer.java b/core/java/android/widget/AlphabetIndexer.java index f50676a..59b2c2a 100644 --- a/core/java/android/widget/AlphabetIndexer.java +++ b/core/java/android/widget/AlphabetIndexer.java @@ -28,7 +28,7 @@ import android.util.SparseIntArray; * invalidates the cache if changes occur in the cursor. * <p/> * Your adapter is responsible for updating the cursor by calling {@link #setCursor} if the - * cursor changes. {@link #getPositionForSection} method does the binary search for the starting + * cursor changes. {@link #getPositionForSection} method does the binary search for the starting * index of a given section (alphabet). */ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { @@ -37,33 +37,33 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { * Cursor that is used by the adapter of the list view. */ protected Cursor mDataCursor; - + /** * The index of the cursor column that this list is sorted on. */ protected int mColumnIndex; - + /** * The string of characters that make up the indexing sections. */ protected CharSequence mAlphabet; - + /** * Cached length of the alphabet array. */ private int mAlphabetLength; - + /** * This contains a cache of the computed indices so far. It will get reset whenever * the dataset changes or the cursor changes. */ private SparseIntArray mAlphaMap; - + /** * Use a collator to compare strings in a localized manner. */ private java.text.Collator mCollator; - + /** * The section array converted from the alphabet string. */ @@ -72,9 +72,9 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { /** * Constructs the indexer. * @param cursor the cursor containing the data set - * @param sortedColumnIndex the column number in the cursor that is sorted + * @param sortedColumnIndex the column number in the cursor that is sorted * alphabetically - * @param alphabet string containing the alphabet, with space as the first character. + * @param alphabet string containing the alphabet, with space as the first character. * For example, use the string " ABCDEFGHIJKLMNOPQRSTUVWXYZ" for English indexing. * The characters must be uppercase and be sorted in ascii/unicode order. Basically * characters in the alphabet will show up as preview letters. @@ -104,7 +104,7 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { public Object[] getSections() { return mAlphabetArray; } - + /** * Sets a new cursor as the data set and resets the cache of indices. * @param cursor the new cursor to use as the data set @@ -124,9 +124,16 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { * Default implementation compares the first character of word with letter. */ protected int compare(String word, String letter) { - return mCollator.compare(word.substring(0, 1), letter); + final String firstLetter; + if (word.length() == 0) { + firstLetter = " "; + } else { + firstLetter = word.substring(0, 1); + } + + return mCollator.compare(firstLetter, letter); } - + /** * Performs a binary search or cache lookup to find the first row that * matches a given section's starting letter. @@ -143,7 +150,7 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { if (cursor == null || mAlphabet == null) { return 0; } - + // Check bounds if (sectionIndex <= 0) { return 0; @@ -164,7 +171,7 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { int key = letter; // Check map if (Integer.MIN_VALUE != (pos = alphaMap.get(key, Integer.MIN_VALUE))) { - // Is it approximate? Using negative value to indicate that it's + // Is it approximate? Using negative value to indicate that it's // an approximation and positive value when it is the accurate // position. if (pos < 0) { @@ -204,7 +211,7 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { } int diff = compare(curName, targetLetter); if (diff != 0) { - // Commenting out approximation code because it doesn't work for certain + // TODO: Commenting out approximation code because it doesn't work for certain // lists with custom comparators // Enter approximation in hash if a better solution doesn't exist // String startingLetter = Character.toString(getFirstLetter(curName)); @@ -259,9 +266,9 @@ public class AlphabetIndexer extends DataSetObserver implements SectionIndexer { return i; } } - return 0; // Don't recognize the letter - falls under zero'th section + return 0; // Don't recognize the letter - falls under zero'th section } - + /* * @hide */ diff --git a/core/java/android/widget/AutoCompleteTextView.java b/core/java/android/widget/AutoCompleteTextView.java index 02d77d1..d821a7d 100644 --- a/core/java/android/widget/AutoCompleteTextView.java +++ b/core/java/android/widget/AutoCompleteTextView.java @@ -194,7 +194,7 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe setFocusable(true); addTextChangedListener(new MyWatcher()); - + mPassThroughClickListener = new PassThroughClickListener(); super.setOnClickListener(mPassThroughClickListener); } @@ -321,8 +321,6 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * @return the background drawable * * @attr ref android.R.styleable#PopupWindow_popupBackground - * - * @hide Pending API council approval */ public Drawable getDropDownBackground() { return mPopup.getBackground(); @@ -334,8 +332,6 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * @param d the drawable to set as the background * * @attr ref android.R.styleable#PopupWindow_popupBackground - * - * @hide Pending API council approval */ public void setDropDownBackgroundDrawable(Drawable d) { mPopup.setBackgroundDrawable(d); @@ -347,47 +343,15 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * @param id the id of the drawable to set as the background * * @attr ref android.R.styleable#PopupWindow_popupBackground - * - * @hide Pending API council approval */ public void setDropDownBackgroundResource(int id) { mPopup.setBackgroundDrawable(getResources().getDrawable(id)); } - - /** - * <p>Sets the animation style of the auto-complete drop-down list.</p> - * - * <p>If the drop-down is showing, calling this method will take effect only - * the next time the drop-down is shown.</p> - * - * @param animationStyle animation style to use when the drop-down appears - * and disappears. Set to -1 for the default animation, 0 for no - * animation, or a resource identifier for an explicit animation. - * - * @hide Pending API council approval - */ - public void setDropDownAnimationStyle(int animationStyle) { - mPopup.setAnimationStyle(animationStyle); - } - - /** - * <p>Returns the animation style that is used when the drop-down list appears and disappears - * </p> - * - * @return the animation style that is used when the drop-down list appears and disappears - * - * @hide Pending API council approval - */ - public int getDropDownAnimationStyle() { - return mPopup.getAnimationStyle(); - } /** * <p>Sets the vertical offset used for the auto-complete drop-down list.</p> * * @param offset the vertical offset - * - * @hide Pending API council approval */ public void setDropDownVerticalOffset(int offset) { mDropDownVerticalOffset = offset; @@ -397,8 +361,6 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * <p>Gets the vertical offset used for the auto-complete drop-down list.</p> * * @return the vertical offset - * - * @hide Pending API council approval */ public int getDropDownVerticalOffset() { return mDropDownVerticalOffset; @@ -408,8 +370,6 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * <p>Sets the horizontal offset used for the auto-complete drop-down list.</p> * * @param offset the horizontal offset - * - * @hide Pending API council approval */ public void setDropDownHorizontalOffset(int offset) { mDropDownHorizontalOffset = offset; @@ -419,13 +379,39 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe * <p>Gets the horizontal offset used for the auto-complete drop-down list.</p> * * @return the horizontal offset - * - * @hide Pending API council approval */ public int getDropDownHorizontalOffset() { return mDropDownHorizontalOffset; } + /** + * <p>Sets the animation style of the auto-complete drop-down list.</p> + * + * <p>If the drop-down is showing, calling this method will take effect only + * the next time the drop-down is shown.</p> + * + * @param animationStyle animation style to use when the drop-down appears + * and disappears. Set to -1 for the default animation, 0 for no + * animation, or a resource identifier for an explicit animation. + * + * @hide Pending API council approval + */ + public void setDropDownAnimationStyle(int animationStyle) { + mPopup.setAnimationStyle(animationStyle); + } + + /** + * <p>Returns the animation style that is used when the drop-down list appears and disappears + * </p> + * + * @return the animation style that is used when the drop-down list appears and disappears + * + * @hide Pending API council approval + */ + public int getDropDownAnimationStyle() { + return mPopup.getAnimationStyle(); + } + /** * @return Whether the drop-down is visible as long as there is {@link #enoughToFilter()} * @@ -1595,7 +1581,7 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe */ CharSequence fixText(CharSequence invalidText); } - + /** * Allows us a private hook into the on click event without preventing users from setting * their own click listener. @@ -1611,5 +1597,5 @@ public class AutoCompleteTextView extends EditText implements Filter.FilterListe if (mWrapped != null) mWrapped.onClick(v); } } - + } diff --git a/core/java/android/widget/ExpandableListView.java b/core/java/android/widget/ExpandableListView.java index 5360621..6abb2ae 100644 --- a/core/java/android/widget/ExpandableListView.java +++ b/core/java/android/widget/ExpandableListView.java @@ -33,6 +33,7 @@ import android.view.ContextMenu; import android.view.SoundEffectConstants; import android.view.View; import android.view.ContextMenu.ContextMenuInfo; +import android.widget.AdapterView.AdapterContextMenuInfo; import android.widget.ExpandableListConnector.PositionMetadata; /** @@ -916,7 +917,14 @@ public class ExpandableListView extends ListView { @Override ContextMenuInfo createContextMenuInfo(View view, int flatListPosition, long id) { - PositionMetadata pm = mConnector.getUnflattenedPos(flatListPosition); + // Adjust for and handle for header views + final int adjustedPosition = flatListPosition - getHeaderViewsCount(); + if (adjustedPosition < 0) { + // Return normal info for header view context menus + return new AdapterContextMenuInfo(view, flatListPosition, id); + } + + PositionMetadata pm = mConnector.getUnflattenedPos(adjustedPosition); ExpandableListPosition pos = pm.position; pm.recycle(); diff --git a/core/java/android/widget/FastScroller.java b/core/java/android/widget/FastScroller.java index 2da777a..67c0def 100644 --- a/core/java/android/widget/FastScroller.java +++ b/core/java/android/widget/FastScroller.java @@ -55,7 +55,7 @@ class FastScroller { private int mThumbY; private RectF mOverlayPos; - private int mOverlaySize = 104; + private int mOverlaySize; private AbsListView mList; private boolean mScrollCompleted; @@ -119,10 +119,10 @@ class FastScroller { private void useThumbDrawable(Context context, Drawable drawable) { mThumbDrawable = drawable; - mThumbW = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, - 64, context.getResources().getDisplayMetrics()); - mThumbH = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, - 52, context.getResources().getDisplayMetrics()); + mThumbW = context.getResources().getDimensionPixelSize( + com.android.internal.R.dimen.fastscroll_thumb_width); + mThumbH = context.getResources().getDimensionPixelSize( + com.android.internal.R.dimen.fastscroll_thumb_height); mChangedBounds = true; } @@ -138,7 +138,9 @@ class FastScroller { mScrollCompleted = true; getSectionsFromIndexer(); - + + mOverlaySize = context.getResources().getDimensionPixelSize( + com.android.internal.R.dimen.fastscroll_overlay_size); mOverlayPos = new RectF(); mScrollFade = new ScrollFade(); mPaint = new Paint(); diff --git a/core/java/android/widget/LinearLayout.java b/core/java/android/widget/LinearLayout.java index a9822f8..6cc794b 100644 --- a/core/java/android/widget/LinearLayout.java +++ b/core/java/android/widget/LinearLayout.java @@ -59,7 +59,7 @@ public class LinearLayout extends ViewGroup { * Note: this is orthogonal to {@link #mBaselineAligned}, which is concerned * with whether the children of this layout are baseline aligned. */ - private int mBaselineAlignedChildIndex = 0; + private int mBaselineAlignedChildIndex = -1; /** * The additional offset to the child's baseline. diff --git a/core/java/android/widget/ListView.java b/core/java/android/widget/ListView.java index f8a6f89..993b7cb 100644 --- a/core/java/android/widget/ListView.java +++ b/core/java/android/widget/ListView.java @@ -1428,7 +1428,8 @@ public class ListView extends AbsListView { throw new IllegalStateException("The content of the adapter has changed but " + "ListView did not receive a notification. Make sure the content of " + "your adapter is not modified from a background thread, but only " - + "from the UI thread."); + + "from the UI thread. [in ListView(" + getId() + ", " + getClass() + + ") with Adapter(" + mAdapter.getClass() + ")]"); } setSelectedPositionInt(mNextSelectedPosition); @@ -3264,12 +3265,13 @@ public class ListView extends AbsListView { if (mChoiceMode == CHOICE_MODE_MULTIPLE) { mCheckStates.put(position, value); } else { - // Clear the old value: if something was selected and value == false - // then it is unselected - mCheckStates.clear(); - // If value == true, select the appropriate position + // Clear all values if we're checking something, or unchecking the currently + // selected item + if (value || isItemChecked(position)) { + mCheckStates.clear(); + } // this may end up selecting the value we just cleared but this way - // we don't have to first to a get(position) + // we ensure length of mCheckStates is 1, a fact getCheckedItemPosition relies on if (value) { mCheckStates.put(position, true); } @@ -3285,11 +3287,12 @@ public class ListView extends AbsListView { /** * Returns the checked state of the specified position. The result is only - * valid if the choice mode has not been set to {@link #CHOICE_MODE_SINGLE} + * valid if the choice mode has been set to {@link #CHOICE_MODE_SINGLE} * or {@link #CHOICE_MODE_MULTIPLE}. * * @param position The item whose checked state to return - * @return The item's checked state + * @return The item's checked state or <code>false</code> if choice mode + * is invalid * * @see #setChoiceMode(int) */ @@ -3303,7 +3306,7 @@ public class ListView extends AbsListView { /** * Returns the currently checked item. The result is only valid if the choice - * mode has not been set to {@link #CHOICE_MODE_SINGLE}. + * mode has been set to {@link #CHOICE_MODE_SINGLE}. * * @return The position of the currently checked item or * {@link #INVALID_POSITION} if nothing is selected @@ -3320,10 +3323,12 @@ public class ListView extends AbsListView { /** * Returns the set of checked items in the list. The result is only valid if - * the choice mode has not been set to {@link #CHOICE_MODE_SINGLE}. + * the choice mode has not been set to {@link #CHOICE_MODE_NONE}. * * @return A SparseBooleanArray which will return true for each call to - * get(int position) where position is a position in the list. + * get(int position) where position is a position in the list, + * or <code>null</code> if the choice mode is set to + * {@link #CHOICE_MODE_NONE}. */ public SparseBooleanArray getCheckedItemPositions() { if (mChoiceMode != CHOICE_MODE_NONE) { diff --git a/core/java/android/widget/MediaController.java b/core/java/android/widget/MediaController.java index 0c9d980..446a992 100644 --- a/core/java/android/widget/MediaController.java +++ b/core/java/android/widget/MediaController.java @@ -250,6 +250,29 @@ public class MediaController extends FrameLayout { } /** + * Disable pause or seek buttons if the stream cannot be paused or seeked. + * This requires the control interface to be a MediaPlayerControlExt + */ + private void disableUnsupportedButtons() { + try { + if (mPauseButton != null && !mPlayer.canPause()) { + mPauseButton.setEnabled(false); + } + if (mRewButton != null && !mPlayer.canSeekBackward()) { + mRewButton.setEnabled(false); + } + if (mFfwdButton != null && !mPlayer.canSeekForward()) { + mFfwdButton.setEnabled(false); + } + } catch (IncompatibleClassChangeError ex) { + // We were given an old version of the interface, that doesn't have + // the canPause/canSeekXYZ methods. This is OK, it just means we + // assume the media can be paused and seeked, and so we don't disable + // the buttons. + } + } + + /** * Show the controller on screen. It will go away * automatically after 'timeout' milliseconds of inactivity. * @param timeout The timeout in milliseconds. Use 0 to show @@ -259,6 +282,10 @@ public class MediaController extends FrameLayout { if (!mShowing && mAnchor != null) { setProgress(); + if (mPauseButton != null) { + mPauseButton.requestFocus(); + } + disableUnsupportedButtons(); int [] anchorpos = new int[2]; mAnchor.getLocationOnScreen(anchorpos); @@ -392,6 +419,9 @@ public class MediaController extends FrameLayout { keyCode == KeyEvent.KEYCODE_SPACE)) { doPauseResume(); show(sDefaultTimeout); + if (mPauseButton != null) { + mPauseButton.requestFocus(); + } return true; } else if (keyCode == KeyEvent.KEYCODE_MEDIA_STOP) { if (mPlayer.isPlaying()) { @@ -421,17 +451,13 @@ public class MediaController extends FrameLayout { }; private void updatePausePlay() { - if (mRoot == null) - return; - - ImageButton button = (ImageButton) mRoot.findViewById(com.android.internal.R.id.pause); - if (button == null) + if (mRoot == null || mPauseButton == null) return; if (mPlayer.isPlaying()) { - button.setImageResource(com.android.internal.R.drawable.ic_media_pause); + mPauseButton.setImageResource(com.android.internal.R.drawable.ic_media_pause); } else { - button.setImageResource(com.android.internal.R.drawable.ic_media_play); + mPauseButton.setImageResource(com.android.internal.R.drawable.ic_media_play); } } @@ -516,7 +542,7 @@ public class MediaController extends FrameLayout { if (mProgress != null) { mProgress.setEnabled(enabled); } - + disableUnsupportedButtons(); super.setEnabled(enabled); } @@ -579,5 +605,8 @@ public class MediaController extends FrameLayout { void seekTo(int pos); boolean isPlaying(); int getBufferPercentage(); - }; + boolean canPause(); + boolean canSeekBackward(); + boolean canSeekForward(); + } } diff --git a/core/java/android/widget/PopupWindow.java b/core/java/android/widget/PopupWindow.java index 90fbb77..548dee9 100644 --- a/core/java/android/widget/PopupWindow.java +++ b/core/java/android/widget/PopupWindow.java @@ -817,6 +817,7 @@ public class PopupWindow { * @param p the layout parameters of the popup's content view */ private void invokePopup(WindowManager.LayoutParams p) { + p.packageName = mContext.getPackageName(); mWindowManager.addView(mPopupView, p); } diff --git a/core/java/android/widget/Scroller.java b/core/java/android/widget/Scroller.java index c9ace0a..381641f 100644 --- a/core/java/android/widget/Scroller.java +++ b/core/java/android/widget/Scroller.java @@ -17,6 +17,7 @@ package android.widget; import android.content.Context; +import android.hardware.SensorManager; import android.view.ViewConfiguration; import android.view.animation.AnimationUtils; import android.view.animation.Interpolator; @@ -79,9 +80,9 @@ public class Scroller { mFinished = true; mInterpolator = interpolator; float ppi = context.getResources().getDisplayMetrics().density * 160.0f; - mDeceleration = 9.8f // g (m/s^2) - * 39.37f // inch/meter - * ppi // pixels per inch + mDeceleration = SensorManager.GRAVITY_EARTH // g (m/s^2) + * 39.37f // inch/meter + * ppi // pixels per inch * ViewConfiguration.getScrollFriction(); } @@ -347,7 +348,11 @@ public class Scroller { } /** - * + * Stops the animation. Contrary to {@link #forceFinished(boolean)}, + * aborting the animating cause the scroller to move to the final x and y + * position + * + * @see #forceFinished(boolean) */ public void abortAnimation() { mCurrX = mFinalX; @@ -356,10 +361,12 @@ public class Scroller { } /** - * Extend the scroll animation. This allows a running animation to - * scroll further and longer, when used with setFinalX() or setFinalY(). + * Extend the scroll animation. This allows a running animation to scroll + * further and longer, when used with {@link #setFinalX(int)} or {@link #setFinalY(int)}. * * @param extend Additional time to scroll in milliseconds. + * @see #setFinalX(int) + * @see #setFinalY(int) */ public void extendDuration(int extend) { int passed = timePassed(); @@ -367,18 +374,37 @@ public class Scroller { mDurationReciprocal = 1.0f / (float)mDuration; mFinished = false; } - + + /** + * Returns the time elapsed since the beginning of the scrolling. + * + * @return The elapsed time in milliseconds. + */ public int timePassed() { return (int)(AnimationUtils.currentAnimationTimeMillis() - mStartTime); } - + + /** + * Sets the final position (X) for this scroller. + * + * @param newX The new X offset as an absolute distance from the origin. + * @see #extendDuration(int) + * @see #setFinalY(int) + */ public void setFinalX(int newX) { mFinalX = newX; mDeltaX = mFinalX - mStartX; mFinished = false; } - public void setFinalY(int newY) { + /** + * Sets the final position (Y) for this scroller. + * + * @param newY The new Y offset as an absolute distance from the origin. + * @see #extendDuration(int) + * @see #setFinalX(int) + */ + public void setFinalY(int newY) { mFinalY = newY; mDeltaY = mFinalY - mStartY; mFinished = false; diff --git a/core/java/android/widget/SimpleCursorTreeAdapter.java b/core/java/android/widget/SimpleCursorTreeAdapter.java index c456f56..a1c65f0 100644 --- a/core/java/android/widget/SimpleCursorTreeAdapter.java +++ b/core/java/android/widget/SimpleCursorTreeAdapter.java @@ -26,9 +26,16 @@ import android.view.View; * defined in an XML file. You can specify which columns you want, which views * you want to display the columns, and the XML file that defines the appearance * of these views. Separate XML files for child and groups are possible. - * TextViews bind the values to their text property (see - * {@link TextView#setText(CharSequence)}). ImageViews bind the values to their - * image's Uri property (see {@link ImageView#setImageURI(android.net.Uri)}). + * + * Binding occurs in two phases. First, if a + * {@link android.widget.SimpleCursorTreeAdapter.ViewBinder} is available, + * {@link ViewBinder#setViewValue(android.view.View, android.database.Cursor, int)} + * is invoked. If the returned value is true, binding has occurred. If the + * returned value is false and the view to bind is a TextView, + * {@link #setViewText(TextView, String)} is invoked. If the returned value + * is false and the view to bind is an ImageView, + * {@link #setViewImage(ImageView, String)} is invoked. If no appropriate + * binding can be found, an {@link IllegalStateException} is thrown. */ public abstract class SimpleCursorTreeAdapter extends ResourceCursorTreeAdapter { /** The indices of columns that contain data to display for a group. */ @@ -48,6 +55,11 @@ public abstract class SimpleCursorTreeAdapter extends ResourceCursorTreeAdapter private int[] mChildTo; /** + * View binder, if supplied + */ + private ViewBinder mViewBinder; + + /** * Constructor. * * @param context The context where the {@link ExpandableListView} @@ -193,21 +205,53 @@ public abstract class SimpleCursorTreeAdapter extends ResourceCursorTreeAdapter initFromColumns(childCursor, childFromNames, mChildFrom); } + /** + * Returns the {@link ViewBinder} used to bind data to views. + * + * @return a ViewBinder or null if the binder does not exist + * + * @see #setViewBinder(android.widget.SimpleCursorTreeAdapter.ViewBinder) + */ + public ViewBinder getViewBinder() { + return mViewBinder; + } + + /** + * Sets the binder used to bind data to views. + * + * @param viewBinder the binder used to bind data to views, can be null to + * remove the existing binder + * + * @see #getViewBinder() + */ + public void setViewBinder(ViewBinder viewBinder) { + mViewBinder = viewBinder; + } + private void bindView(View view, Context context, Cursor cursor, int[] from, int[] to) { + final ViewBinder binder = mViewBinder; + for (int i = 0; i < to.length; i++) { View v = view.findViewById(to[i]); if (v != null) { - String text = cursor.getString(from[i]); - if (text == null) { - text = ""; + boolean bound = false; + if (binder != null) { + bound = binder.setViewValue(v, cursor, from[i]); } - if (v instanceof TextView) { - ((TextView) v).setText(text); - } else if (v instanceof ImageView) { - setViewImage((ImageView) v, text); - } else { - throw new IllegalStateException("SimpleCursorAdapter can bind values only to" + - " TextView and ImageView!"); + + if (!bound) { + String text = cursor.getString(from[i]); + if (text == null) { + text = ""; + } + if (v instanceof TextView) { + setViewText((TextView) v, text); + } else if (v instanceof ImageView) { + setViewImage((ImageView) v, text); + } else { + throw new IllegalStateException("SimpleCursorTreeAdapter can bind values" + + " only to TextView and ImageView!"); + } } } } @@ -238,4 +282,48 @@ public abstract class SimpleCursorTreeAdapter extends ResourceCursorTreeAdapter v.setImageURI(Uri.parse(value)); } } + + /** + * Called by bindView() to set the text for a TextView but only if + * there is no existing ViewBinder or if the existing ViewBinder cannot + * handle binding to an TextView. + * + * Intended to be overridden by Adapters that need to filter strings + * retrieved from the database. + * + * @param v TextView to receive text + * @param text the text to be set for the TextView + */ + public void setViewText(TextView v, String text) { + v.setText(text); + } + + /** + * This class can be used by external clients of SimpleCursorTreeAdapter + * to bind values from the Cursor to views. + * + * You should use this class to bind values from the Cursor to views + * that are not directly supported by SimpleCursorTreeAdapter or to + * change the way binding occurs for views supported by + * SimpleCursorTreeAdapter. + * + * @see SimpleCursorTreeAdapter#setViewImage(ImageView, String) + * @see SimpleCursorTreeAdapter#setViewText(TextView, String) + */ + public static interface ViewBinder { + /** + * Binds the Cursor column defined by the specified index to the specified view. + * + * When binding is handled by this ViewBinder, this method must return true. + * If this method returns false, SimpleCursorTreeAdapter will attempts to handle + * the binding on its own. + * + * @param view the view to bind the data to + * @param cursor the cursor to get the data from + * @param columnIndex the column at which the data can be found in the cursor + * + * @return true if the data was bound to the view, false otherwise + */ + boolean setViewValue(View view, Cursor cursor, int columnIndex); + } } diff --git a/core/java/android/widget/TabHost.java b/core/java/android/widget/TabHost.java index 103d44d..1bee9db 100644 --- a/core/java/android/widget/TabHost.java +++ b/core/java/android/widget/TabHost.java @@ -68,7 +68,7 @@ public class TabHost extends FrameLayout implements ViewTreeObserver.OnTouchMode initTabHost(); } - private final void initTabHost() { + private void initTabHost() { setFocusableInTouchMode(true); setDescendantFocusability(FOCUS_AFTER_DESCENDANTS); @@ -134,7 +134,8 @@ mTabHost.addTab(TAB_TAG_1, "Hello, world!", "Tab 1"); mTabContent = (FrameLayout) findViewById(com.android.internal.R.id.tabcontent); if (mTabContent == null) { throw new RuntimeException( - "Your TabHost must have a FrameLayout whose id attribute is 'android.R.id.tabcontent'"); + "Your TabHost must have a FrameLayout whose id attribute is " + + "'android.R.id.tabcontent'"); } } @@ -176,7 +177,7 @@ mTabHost.addTab(TAB_TAG_1, "Hello, world!", "Tab 1"); if (!isInTouchMode) { // leaving touch mode.. if nothing has focus, let's give it to // the indicator of the current tab - if (!mCurrentView.hasFocus() || mCurrentView.isFocused()) { + if (mCurrentView != null && (!mCurrentView.hasFocus() || mCurrentView.isFocused())) { mTabWidget.getChildTabViewAt(mCurrentTab).requestFocus(); } } diff --git a/core/java/android/widget/TextView.java b/core/java/android/widget/TextView.java index 260799e..a611d5a 100644 --- a/core/java/android/widget/TextView.java +++ b/core/java/android/widget/TextView.java @@ -327,6 +327,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener mText = ""; mTextPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG); + mTextPaint.density = getResources().getDisplayMetrics().density; // If we get the paint from the skin, we should set it to left, since // the layout always wants it to be left. // mTextPaint.setTextAlign(Paint.Align.LEFT); @@ -5769,7 +5770,7 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener * Causes words in the text that are longer than the view is wide * to be ellipsized instead of broken in the middle. You may also * want to {@link #setSingleLine} or {@link #setHorizontallyScrolling} - * to constrain the text toa single line. Use <code>null</code> + * to constrain the text to a single line. Use <code>null</code> * to turn off ellipsizing. * * @attr ref android.R.styleable#TextView_ellipsize @@ -6916,6 +6917,17 @@ public class TextView extends View implements ViewTreeObserver.OnPreDrawListener } } + boolean hasLetter = false; + for (int i = start; i < end; i++) { + if (Character.isLetter(mTransformed.charAt(i))) { + hasLetter = true; + break; + } + } + if (!hasLetter) { + return null; + } + if (start == end) { return null; } diff --git a/core/java/android/widget/VideoView.java b/core/java/android/widget/VideoView.java index 20dd8a6..549f984 100644 --- a/core/java/android/widget/VideoView.java +++ b/core/java/android/widget/VideoView.java @@ -23,6 +23,7 @@ import android.content.Intent; import android.content.res.Resources; import android.media.AudioManager; import android.media.MediaPlayer; +import android.media.Metadata; import android.media.MediaPlayer.OnCompletionListener; import android.media.MediaPlayer.OnErrorListener; import android.net.Uri; @@ -34,7 +35,7 @@ import android.view.MotionEvent; import android.view.SurfaceHolder; import android.view.SurfaceView; import android.view.View; -import android.widget.MediaController.MediaPlayerControl; +import android.widget.MediaController.*; import java.io.IOException; @@ -51,11 +52,26 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { private Uri mUri; private int mDuration; + // all possible internal states + private static final int STATE_ERROR = -1; + private static final int STATE_IDLE = 0; + private static final int STATE_PREPARING = 1; + private static final int STATE_PREPARED = 2; + private static final int STATE_PLAYING = 3; + private static final int STATE_PAUSED = 4; + private static final int STATE_PLAYBACK_COMPLETED = 5; + + // mCurrentState is a VideoView object's current state. + // mTargetState is the state that a method caller intends to reach. + // For instance, regardless the VideoView object's current state, + // calling pause() intends to bring the object to a target state + // of STATE_PAUSED. + private int mCurrentState = STATE_IDLE; + private int mTargetState = STATE_IDLE; + // All the stuff we need for playing and showing a video private SurfaceHolder mSurfaceHolder = null; private MediaPlayer mMediaPlayer = null; - private boolean mIsPrepared; - private boolean mIsPlaybackCompleted; private int mVideoWidth; private int mVideoHeight; private int mSurfaceWidth; @@ -65,8 +81,10 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { private MediaPlayer.OnPreparedListener mOnPreparedListener; private int mCurrentBufferPercentage; private OnErrorListener mOnErrorListener; - private boolean mStartWhenPrepared; - private int mSeekWhenPrepared; + private int mSeekWhenPrepared; // recording the seek position while preparing + private boolean mCanPause; + private boolean mCanSeekBack; + private boolean mCanSeekForward; public VideoView(Context context) { super(context); @@ -80,7 +98,6 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { public VideoView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); - initVideoView(); } @@ -143,6 +160,8 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { setFocusable(true); setFocusableInTouchMode(true); requestFocus(); + mCurrentState = STATE_IDLE; + mTargetState = STATE_IDLE; } public void setVideoPath(String path) { @@ -151,7 +170,6 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { public void setVideoURI(Uri uri) { mUri = uri; - mStartWhenPrepared = false; mSeekWhenPrepared = 0; openVideo(); requestLayout(); @@ -163,6 +181,8 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { mMediaPlayer.stop(); mMediaPlayer.release(); mMediaPlayer = null; + mCurrentState = STATE_IDLE; + mTargetState = STATE_IDLE; } } @@ -176,18 +196,14 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { Intent i = new Intent("com.android.music.musicservicecommand"); i.putExtra("command", "pause"); mContext.sendBroadcast(i); - - if (mMediaPlayer != null) { - mMediaPlayer.reset(); - mMediaPlayer.release(); - mMediaPlayer = null; - } + + // we shouldn't clear the target state, because somebody might have + // called start() previously + release(false); try { mMediaPlayer = new MediaPlayer(); mMediaPlayer.setOnPreparedListener(mPreparedListener); mMediaPlayer.setOnVideoSizeChangedListener(mSizeChangedListener); - mIsPrepared = false; - Log.v(TAG, "reset duration to -1 in openVideo"); mDuration = -1; mMediaPlayer.setOnCompletionListener(mCompletionListener); mMediaPlayer.setOnErrorListener(mErrorListener); @@ -198,12 +214,19 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC); mMediaPlayer.setScreenOnWhilePlaying(true); mMediaPlayer.prepareAsync(); + // we don't set the target state here either, but preserve the + // target state that was there before. + mCurrentState = STATE_PREPARING; attachMediaController(); } catch (IOException ex) { Log.w(TAG, "Unable to open content: " + mUri, ex); + mCurrentState = STATE_ERROR; + mTargetState = STATE_ERROR; return; } catch (IllegalArgumentException ex) { Log.w(TAG, "Unable to open content: " + mUri, ex); + mCurrentState = STATE_ERROR; + mTargetState = STATE_ERROR; return; } } @@ -222,7 +245,7 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { View anchorView = this.getParent() instanceof View ? (View)this.getParent() : this; mMediaController.setAnchorView(anchorView); - mMediaController.setEnabled(mIsPrepared); + mMediaController.setEnabled(isInPlaybackState()); } } @@ -239,8 +262,23 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() { public void onPrepared(MediaPlayer mp) { - // briefly show the mediacontroller - mIsPrepared = true; + mCurrentState = STATE_PREPARED; + + // Get the capabilities of the player for this stream + Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL, + MediaPlayer.BYPASS_METADATA_FILTER); + + if (data != null) { + mCanPause = !data.has(Metadata.PAUSE_AVAILABLE) + || data.getBoolean(Metadata.PAUSE_AVAILABLE); + mCanSeekBack = !data.has(Metadata.SEEK_BACKWARD_AVAILABLE) + || data.getBoolean(Metadata.SEEK_BACKWARD_AVAILABLE); + mCanSeekForward = !data.has(Metadata.SEEK_FORWARD_AVAILABLE) + || data.getBoolean(Metadata.SEEK_FORWARD_AVAILABLE); + } else { + mCanPause = mCanSeekForward = mCanSeekForward = true; + } + if (mOnPreparedListener != null) { mOnPreparedListener.onPrepared(mMediaPlayer); } @@ -249,6 +287,11 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { } mVideoWidth = mp.getVideoWidth(); mVideoHeight = mp.getVideoHeight(); + + int seekToPosition = mSeekWhenPrepared; // mSeekWhenPrepared may be changed after seekTo() call + if (seekToPosition != 0) { + seekTo(seekToPosition); + } if (mVideoWidth != 0 && mVideoHeight != 0) { //Log.i("@@@@", "video size: " + mVideoWidth +"/"+ mVideoHeight); getHolder().setFixedSize(mVideoWidth, mVideoHeight); @@ -256,18 +299,13 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { // We didn't actually change the size (it was already at the size // we need), so we won't get a "surface changed" callback, so // start the video here instead of in the callback. - if (mSeekWhenPrepared != 0) { - mMediaPlayer.seekTo(mSeekWhenPrepared); - mSeekWhenPrepared = 0; - } - if (mStartWhenPrepared) { + if (mTargetState == STATE_PLAYING) { start(); - mStartWhenPrepared = false; if (mMediaController != null) { mMediaController.show(); } } else if (!isPlaying() && - (mSeekWhenPrepared != 0 || getCurrentPosition() > 0)) { + (seekToPosition != 0 || getCurrentPosition() > 0)) { if (mMediaController != null) { // Show the media controls when we're paused into a video and make 'em stick. mMediaController.show(0); @@ -277,13 +315,8 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { } else { // We don't know the video size yet, but should start anyway. // The video size might be reported to us later. - if (mSeekWhenPrepared != 0) { - mMediaPlayer.seekTo(mSeekWhenPrepared); - mSeekWhenPrepared = 0; - } - if (mStartWhenPrepared) { + if (mTargetState == STATE_PLAYING) { start(); - mStartWhenPrepared = false; } } } @@ -292,7 +325,8 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { private MediaPlayer.OnCompletionListener mCompletionListener = new MediaPlayer.OnCompletionListener() { public void onCompletion(MediaPlayer mp) { - mIsPlaybackCompleted = true; + mCurrentState = STATE_PLAYBACK_COMPLETED; + mTargetState = STATE_PLAYBACK_COMPLETED; if (mMediaController != null) { mMediaController.hide(); } @@ -306,6 +340,8 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { new MediaPlayer.OnErrorListener() { public boolean onError(MediaPlayer mp, int framework_err, int impl_err) { Log.d(TAG, "Error: " + framework_err + "," + impl_err); + mCurrentState = STATE_ERROR; + mTargetState = STATE_ERROR; if (mMediaController != null) { mMediaController.hide(); } @@ -402,14 +438,13 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { { mSurfaceWidth = w; mSurfaceHeight = h; - if (mMediaPlayer != null && mIsPrepared && mVideoWidth == w && mVideoHeight == h) { + boolean isValidState = (mTargetState == STATE_PLAYING); + boolean hasValidSize = (mVideoWidth == w && mVideoHeight == h); + if (mMediaPlayer != null && isValidState && hasValidSize) { if (mSeekWhenPrepared != 0) { - mMediaPlayer.seekTo(mSeekWhenPrepared); - mSeekWhenPrepared = 0; + seekTo(mSeekWhenPrepared); } - if (!mIsPlaybackCompleted) { - start(); - } + start(); if (mMediaController != null) { mMediaController.show(); } @@ -427,17 +462,28 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { // after we return from this we can't use the surface any more mSurfaceHolder = null; if (mMediaController != null) mMediaController.hide(); - if (mMediaPlayer != null) { - mMediaPlayer.reset(); - mMediaPlayer.release(); - mMediaPlayer = null; - } + release(true); } }; + /* + * release the media player in any state + */ + private void release(boolean cleartargetstate) { + if (mMediaPlayer != null) { + mMediaPlayer.reset(); + mMediaPlayer.release(); + mMediaPlayer = null; + mCurrentState = STATE_IDLE; + if (cleartargetstate) { + mTargetState = STATE_IDLE; + } + } + } + @Override public boolean onTouchEvent(MotionEvent ev) { - if (mIsPrepared && mMediaPlayer != null && mMediaController != null) { + if (isInPlaybackState() && mMediaController != null) { toggleMediaControlsVisiblity(); } return false; @@ -445,7 +491,7 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { @Override public boolean onTrackballEvent(MotionEvent ev) { - if (mIsPrepared && mMediaPlayer != null && mMediaController != null) { + if (isInPlaybackState() && mMediaController != null) { toggleMediaControlsVisiblity(); } return false; @@ -454,15 +500,13 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { @Override public boolean onKeyDown(int keyCode, KeyEvent event) { - if (mIsPrepared && - keyCode != KeyEvent.KEYCODE_BACK && - keyCode != KeyEvent.KEYCODE_VOLUME_UP && - keyCode != KeyEvent.KEYCODE_VOLUME_DOWN && - keyCode != KeyEvent.KEYCODE_MENU && - keyCode != KeyEvent.KEYCODE_CALL && - keyCode != KeyEvent.KEYCODE_ENDCALL && - mMediaPlayer != null && - mMediaController != null) { + boolean isKeyCodeSupported = keyCode != KeyEvent.KEYCODE_BACK && + keyCode != KeyEvent.KEYCODE_VOLUME_UP && + keyCode != KeyEvent.KEYCODE_VOLUME_DOWN && + keyCode != KeyEvent.KEYCODE_MENU && + keyCode != KeyEvent.KEYCODE_CALL && + keyCode != KeyEvent.KEYCODE_ENDCALL; + if (isInPlaybackState() && isKeyCodeSupported && mMediaController != null) { if (keyCode == KeyEvent.KEYCODE_HEADSETHOOK || keyCode == KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE) { if (mMediaPlayer.isPlaying()) { @@ -494,26 +538,26 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { } public void start() { - mIsPlaybackCompleted = false; - if (mMediaPlayer != null && mIsPrepared) { - mMediaPlayer.start(); - mStartWhenPrepared = false; - } else { - mStartWhenPrepared = true; + if (isInPlaybackState()) { + mMediaPlayer.start(); + mCurrentState = STATE_PLAYING; } + mTargetState = STATE_PLAYING; } public void pause() { - if (mMediaPlayer != null && mIsPrepared) { + if (isInPlaybackState()) { if (mMediaPlayer.isPlaying()) { mMediaPlayer.pause(); + mCurrentState = STATE_PAUSED; } } - mStartWhenPrepared = false; + mTargetState = STATE_PAUSED; } + // cache duration as mDuration for faster access public int getDuration() { - if (mMediaPlayer != null && mIsPrepared) { + if (isInPlaybackState()) { if (mDuration > 0) { return mDuration; } @@ -525,25 +569,23 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { } public int getCurrentPosition() { - if (mMediaPlayer != null && mIsPrepared) { + if (isInPlaybackState()) { return mMediaPlayer.getCurrentPosition(); } return 0; } public void seekTo(int msec) { - if (mMediaPlayer != null && mIsPrepared) { + if (isInPlaybackState()) { mMediaPlayer.seekTo(msec); + mSeekWhenPrepared = 0; } else { mSeekWhenPrepared = msec; } } public boolean isPlaying() { - if (mMediaPlayer != null && mIsPrepared) { - return mMediaPlayer.isPlaying(); - } - return false; + return isInPlaybackState() && mMediaPlayer.isPlaying(); } public int getBufferPercentage() { @@ -552,4 +594,23 @@ public class VideoView extends SurfaceView implements MediaPlayerControl { } return 0; } + + private boolean isInPlaybackState() { + return (mMediaPlayer != null && + mCurrentState != STATE_ERROR && + mCurrentState != STATE_IDLE && + mCurrentState != STATE_PREPARING); + } + + public boolean canPause() { + return mCanPause; + } + + public boolean canSeekBackward() { + return mCanSeekBack; + } + + public boolean canSeekForward() { + return mCanSeekForward; + } } diff --git a/core/java/com/android/internal/app/ShutdownThread.java b/core/java/com/android/internal/app/ShutdownThread.java index 77d6e20..4c9451e 100644 --- a/core/java/com/android/internal/app/ShutdownThread.java +++ b/core/java/com/android/internal/app/ShutdownThread.java @@ -21,8 +21,8 @@ import android.app.ActivityManagerNative; import android.app.IActivityManager; import android.app.ProgressDialog; import android.app.AlertDialog; -import android.bluetooth.BluetoothDevice; -import android.bluetooth.IBluetoothDevice; +import android.bluetooth.BluetoothAdapter; +import android.bluetooth.IBluetooth; import android.content.BroadcastReceiver; import android.content.Context; import android.content.DialogInterface; @@ -179,13 +179,13 @@ public final class ShutdownThread extends Thread { final ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone")); - final IBluetoothDevice bluetooth = - IBluetoothDevice.Stub.asInterface(ServiceManager.checkService( + final IBluetooth bluetooth = + IBluetooth.Stub.asInterface(ServiceManager.checkService( Context.BLUETOOTH_SERVICE)); try { bluetoothOff = bluetooth == null || - bluetooth.getBluetoothState() == BluetoothDevice.BLUETOOTH_STATE_OFF; + bluetooth.getBluetoothState() == BluetoothAdapter.BLUETOOTH_STATE_OFF; if (!bluetoothOff) { Log.w(TAG, "Disabling Bluetooth..."); bluetooth.disable(false); // disable but don't persist new state @@ -213,7 +213,7 @@ public final class ShutdownThread extends Thread { if (!bluetoothOff) { try { bluetoothOff = - bluetooth.getBluetoothState() == BluetoothDevice.BLUETOOTH_STATE_OFF; + bluetooth.getBluetoothState() == BluetoothAdapter.BLUETOOTH_STATE_OFF; } catch (RemoteException ex) { Log.e(TAG, "RemoteException during bluetooth shutdown", ex); bluetoothOff = true; diff --git a/core/java/com/android/internal/content/SyncStateContentProviderHelper.java b/core/java/com/android/internal/content/SyncStateContentProviderHelper.java new file mode 100644 index 0000000..d2931a4 --- /dev/null +++ b/core/java/com/android/internal/content/SyncStateContentProviderHelper.java @@ -0,0 +1,115 @@ +/* + * 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 com.android.internal.content; + +import com.android.internal.util.ArrayUtils; + +import android.database.Cursor; +import android.database.DatabaseUtils; +import android.database.sqlite.SQLiteDatabase; +import android.accounts.Account; +import android.content.ContentValues; +import android.provider.SyncStateContract; + +/** + * Extends the schema of a ContentProvider to include the _sync_state table + * and implements query/insert/update/delete to access that table using the + * authority "syncstate". This can be used to store the sync state for a + * set of accounts. + * + * @hide + */ +public class SyncStateContentProviderHelper { + private static final String SELECT_BY_ACCOUNT = + SyncStateContract.Columns.ACCOUNT_NAME + "=? AND " + + SyncStateContract.Columns.ACCOUNT_TYPE + "=?"; + + private static final String SYNC_STATE_TABLE = "_sync_state"; + private static final String SYNC_STATE_META_TABLE = "_sync_state_metadata"; + private static final String SYNC_STATE_META_VERSION_COLUMN = "version"; + + private static long DB_VERSION = 1; + + private static final String[] ACCOUNT_PROJECTION = + new String[]{SyncStateContract.Columns.ACCOUNT_NAME, + SyncStateContract.Columns.ACCOUNT_TYPE}; + + public static final String PATH = "syncstate"; + + public void createDatabase(SQLiteDatabase db) { + db.execSQL("DROP TABLE IF EXISTS " + SYNC_STATE_TABLE); + db.execSQL("CREATE TABLE " + SYNC_STATE_TABLE + " (" + + SyncStateContract.Columns._ID + " INTEGER PRIMARY KEY," + + SyncStateContract.Columns.ACCOUNT_NAME + " TEXT NOT NULL," + + SyncStateContract.Columns.ACCOUNT_TYPE + " TEXT NOT NULL," + + SyncStateContract.Columns.DATA + " TEXT," + + "UNIQUE(" + SyncStateContract.Columns.ACCOUNT_NAME + ", " + + SyncStateContract.Columns.ACCOUNT_TYPE + "));"); + + db.execSQL("DROP TABLE IF EXISTS " + SYNC_STATE_META_TABLE); + db.execSQL("CREATE TABLE " + SYNC_STATE_META_TABLE + " (" + + SYNC_STATE_META_VERSION_COLUMN + " INTEGER);"); + ContentValues values = new ContentValues(); + values.put(SYNC_STATE_META_VERSION_COLUMN, DB_VERSION); + db.insert(SYNC_STATE_META_TABLE, SYNC_STATE_META_VERSION_COLUMN, values); + } + + public void onDatabaseOpened(SQLiteDatabase db) { + long version = DatabaseUtils.longForQuery(db, + "SELECT " + SYNC_STATE_META_VERSION_COLUMN + " FROM " + SYNC_STATE_META_TABLE, + null); + if (version != DB_VERSION) { + createDatabase(db); + } + } + + public Cursor query(SQLiteDatabase db, String[] projection, + String selection, String[] selectionArgs, String sortOrder) { + return db.query(SYNC_STATE_TABLE, projection, selection, selectionArgs, + null, null, sortOrder); + } + + public long insert(SQLiteDatabase db, ContentValues values) { + return db.replace(SYNC_STATE_TABLE, SyncStateContract.Columns.ACCOUNT_NAME, values); + } + + public int delete(SQLiteDatabase db, String userWhere, String[] whereArgs) { + return db.delete(SYNC_STATE_TABLE, userWhere, whereArgs); + } + + public int update(SQLiteDatabase db, ContentValues values, + String selection, String[] selectionArgs) { + return db.update(SYNC_STATE_TABLE, values, selection, selectionArgs); + } + + public void onAccountsChanged(SQLiteDatabase db, Account[] accounts) { + Cursor c = db.query(SYNC_STATE_TABLE, ACCOUNT_PROJECTION, null, null, null, null, null); + try { + while (c.moveToNext()) { + final String accountName = c.getString(0); + final String accountType = c.getString(1); + Account account = new Account(accountName, accountType); + if (!ArrayUtils.contains(accounts, account)) { + db.delete(SYNC_STATE_TABLE, SELECT_BY_ACCOUNT, + new String[]{accountName, accountType}); + } + } + } finally { + c.close(); + } + } +}
\ No newline at end of file diff --git a/core/java/com/android/internal/os/BatteryStatsImpl.java b/core/java/com/android/internal/os/BatteryStatsImpl.java index a449e5f..2da72df 100644 --- a/core/java/com/android/internal/os/BatteryStatsImpl.java +++ b/core/java/com/android/internal/os/BatteryStatsImpl.java @@ -978,10 +978,13 @@ public final class BatteryStatsImpl extends BatteryStats { } else if (mBtHeadset != null) { return getCurrentBluetoothPingCount() - mBluetoothPingStart; } - return -1; + return 0; } public void setBtHeadset(BluetoothHeadset headset) { + if (headset != null && mBtHeadset == null && isOnBattery() && mBluetoothPingStart == -1) { + mBluetoothPingStart = getCurrentBluetoothPingCount(); + } mBtHeadset = headset; } diff --git a/core/java/com/android/internal/os/HandlerCaller.java b/core/java/com/android/internal/os/HandlerCaller.java index 932555d..5825024 100644 --- a/core/java/com/android/internal/os/HandlerCaller.java +++ b/core/java/com/android/internal/os/HandlerCaller.java @@ -93,6 +93,18 @@ public class HandlerCaller { mH.sendMessage(msg); } + public boolean hasMessages(int what) { + return mH.hasMessages(what); + } + + public void removeMessages(int what) { + mH.removeMessages(what); + } + + public void removeMessages(int what, Object obj) { + mH.removeMessages(what, obj); + } + public void sendMessage(Message msg) { mH.sendMessage(msg); } @@ -132,6 +144,14 @@ public class HandlerCaller { return mH.obtainMessage(what, arg1, arg2, arg3); } + public Message obtainMessageIIOO(int what, int arg1, int arg2, + Object arg3, Object arg4) { + SomeArgs args = obtainArgs(); + args.arg1 = arg3; + args.arg2 = arg4; + return mH.obtainMessage(what, arg1, arg2, args); + } + public Message obtainMessageIOO(int what, int arg1, Object arg2, Object arg3) { SomeArgs args = obtainArgs(); args.arg1 = arg2; diff --git a/core/java/com/android/internal/os/ZygoteInit.java b/core/java/com/android/internal/os/ZygoteInit.java index 94149e1..a2d3cd8 100644 --- a/core/java/com/android/internal/os/ZygoteInit.java +++ b/core/java/com/android/internal/os/ZygoteInit.java @@ -93,7 +93,26 @@ public class ZygoteInit { /** Controls whether we should preload resources during zygote init. */ private static final boolean PRELOAD_RESOURCES = true; - + + /** + * List of methods we "warm up" in the register map cache. These were + * chosen because they appeared on the stack in GCs in multiple + * applications. + * + * This is in a VM-ready format, to minimize string processing. If a + * class is not already loaded, or a method is not found, the entry + * will be skipped. + * + * This doesn't really merit a separately-generated input file at this + * time. The list is fairly short, and the consequences of failure + * are minor. + */ + private static final String[] REGISTER_MAP_METHODS = { + // (currently not doing any) + //"Landroid/app/Activity;.setContentView:(I)V", + }; + + /** * Invokes a static "main(argv[]) method on class "className". * Converts various failing exceptions into RuntimeExceptions, with @@ -328,6 +347,45 @@ public class ZygoteInit { } /** + * Pre-caches register maps for methods that are commonly used. + */ + private static void cacheRegisterMaps() { + String failed = null; + int failure; + long startTime = System.nanoTime(); + + failure = 0; + + for (int i = 0; i < REGISTER_MAP_METHODS.length; i++) { + String str = REGISTER_MAP_METHODS[i]; + + if (!Debug.cacheRegisterMap(str)) { + if (failed == null) + failed = str; + failure++; + } + } + + long delta = System.nanoTime() - startTime; + + if (failure == REGISTER_MAP_METHODS.length) { + if (REGISTER_MAP_METHODS.length > 0) { + Log.i(TAG, + "Register map caching failed (precise GC not enabled?)"); + } + return; + } + + Log.i(TAG, "Register map cache: found " + + (REGISTER_MAP_METHODS.length - failure) + " of " + + REGISTER_MAP_METHODS.length + " methods in " + + (delta / 1000000L) + "ms"); + if (failure > 0) { + Log.i(TAG, " First failure: " + failed); + } + } + + /** * Load in commonly used resources, so they can be shared across * processes. * @@ -519,6 +577,7 @@ public class ZygoteInit { EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START, SystemClock.uptimeMillis()); preloadClasses(); + //cacheRegisterMaps(); preloadResources(); EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END, SystemClock.uptimeMillis()); diff --git a/core/java/com/android/internal/service/wallpaper/ImageWallpaper.java b/core/java/com/android/internal/service/wallpaper/ImageWallpaper.java new file mode 100644 index 0000000..c4eb31f --- /dev/null +++ b/core/java/com/android/internal/service/wallpaper/ImageWallpaper.java @@ -0,0 +1,150 @@ +/* + * Copyright (C) 2009 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 com.android.internal.service.wallpaper; + +import android.app.WallpaperManager; +import android.graphics.Canvas; +import android.graphics.Rect; +import android.graphics.drawable.Drawable; +import android.service.wallpaper.WallpaperService; +import android.view.MotionEvent; +import android.view.SurfaceHolder; +import android.content.Context; +import android.content.IntentFilter; +import android.content.Intent; +import android.content.BroadcastReceiver; + +/** + * Default built-in wallpaper that simply shows a static image. + */ +public class ImageWallpaper extends WallpaperService { + WallpaperManager mWallpaperManager; + ImageWallpaper.DrawableEngine mEngine; + private WallpaperObserver mReceiver; + + @Override + public void onCreate() { + super.onCreate(); + mWallpaperManager = (WallpaperManager) getSystemService(WALLPAPER_SERVICE); + IntentFilter filter = new IntentFilter(Intent.ACTION_WALLPAPER_CHANGED); + mReceiver = new WallpaperObserver(); + registerReceiver(mReceiver, filter); + } + + @Override + public void onDestroy() { + super.onDestroy(); + unregisterReceiver(mReceiver); + } + + public Engine onCreateEngine() { + mEngine = new DrawableEngine(); + return mEngine; + } + + class WallpaperObserver extends BroadcastReceiver { + public void onReceive(Context context, Intent intent) { + mEngine.updateWallpaper(); + mEngine.drawFrame(); + } + } + + class DrawableEngine extends Engine { + private final Object mLock = new Object(); + private final Rect mBounds = new Rect(); + Drawable mBackground; + float mXOffset; + float mYOffset; + + @Override + public void onCreate(SurfaceHolder surfaceHolder) { + super.onCreate(surfaceHolder); + updateWallpaper(); + surfaceHolder.setSizeFromLayout(); + //setTouchEventsEnabled(true); + } + + @Override + public void onVisibilityChanged(boolean visible) { + drawFrame(); + } + + @Override + public void onTouchEvent(MotionEvent event) { + super.onTouchEvent(event); + } + + @Override + public void onOffsetsChanged(float xOffset, float yOffset, + int xPixels, int yPixels) { + mXOffset = xOffset; + mYOffset = yOffset; + drawFrame(); + } + + @Override + public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) { + super.onSurfaceChanged(holder, format, width, height); + drawFrame(); + } + + @Override + public void onSurfaceCreated(SurfaceHolder holder) { + super.onSurfaceCreated(holder); + } + + @Override + public void onSurfaceDestroyed(SurfaceHolder holder) { + super.onSurfaceDestroyed(holder); + } + + void drawFrame() { + SurfaceHolder sh = getSurfaceHolder(); + Canvas c = sh.lockCanvas(); + if (c != null) { + final Rect frame = sh.getSurfaceFrame(); + synchronized (mLock) { + final Drawable background = mBackground; + final int dw = frame.width(); + final int dh = frame.height(); + final int bw = mBackground.getIntrinsicWidth(); + final int bh = mBackground.getIntrinsicHeight(); + final int availw = bw-dw; + final int availh = bh-dh; + int xPixels = availw > 0 + ? -(int)(availw*mXOffset+.5f) : -(availw/2); + int yPixels = availh > 0 + ? -(int)(availh*mYOffset+.5f) : -(availh/2); + c.translate(xPixels, yPixels); + c.drawColor(0xff000000); + background.draw(c); + } + sh.unlockCanvasAndPost(c); + } + } + + void updateWallpaper() { + synchronized (mLock) { + mBackground = mWallpaperManager.getDrawable(); + mBounds.left = mBounds.top = 0; + mBounds.right = mBackground.getIntrinsicWidth(); + mBounds.bottom = mBackground.getIntrinsicHeight(); + mBackground.setBounds(mBounds); + } + } + } +} diff --git a/core/java/com/android/internal/view/BaseIWindow.java b/core/java/com/android/internal/view/BaseIWindow.java new file mode 100644 index 0000000..f4f6297 --- /dev/null +++ b/core/java/com/android/internal/view/BaseIWindow.java @@ -0,0 +1,95 @@ +package com.android.internal.view; + +import android.graphics.Rect; +import android.os.ParcelFileDescriptor; +import android.os.RemoteException; +import android.view.IWindow; +import android.view.IWindowSession; +import android.view.KeyEvent; +import android.view.MotionEvent; + +public class BaseIWindow extends IWindow.Stub { + private IWindowSession mSession; + + public void setSession(IWindowSession session) { + mSession = session; + } + + public void resized(int w, int h, Rect coveredInsets, + Rect visibleInsets, boolean reportDraw) { + if (reportDraw) { + try { + mSession.finishDrawing(this); + } catch (RemoteException e) { + } + } + } + + public void dispatchKey(KeyEvent event) { + try { + mSession.finishKey(this); + } catch (RemoteException ex) { + } + } + + public boolean onDispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { + event.recycle(); + return false; + } + + public void dispatchPointer(MotionEvent event, long eventTime, + boolean callWhenDone) { + try { + if (event == null) { + event = mSession.getPendingPointerMove(this); + onDispatchPointer(event, eventTime, false); + } else if (callWhenDone) { + if (!onDispatchPointer(event, eventTime, true)) { + mSession.finishKey(this); + } + } else { + onDispatchPointer(event, eventTime, false); + } + } catch (RemoteException ex) { + } + } + + public boolean onDispatchTrackball(MotionEvent event, long eventTime, + boolean callWhenDone) { + event.recycle(); + return false; + } + + public void dispatchTrackball(MotionEvent event, long eventTime, + boolean callWhenDone) { + try { + if (event == null) { + event = mSession.getPendingTrackballMove(this); + onDispatchTrackball(event, eventTime, false); + } else if (callWhenDone) { + if (!onDispatchTrackball(event, eventTime, true)) { + mSession.finishKey(this); + } + } else { + onDispatchTrackball(event, eventTime, false); + } + } catch (RemoteException ex) { + } + } + + public void dispatchAppVisibility(boolean visible) { + } + + public void dispatchGetNewSurface() { + } + + public void windowFocusChanged(boolean hasFocus, boolean touchEnabled) { + } + + public void executeCommand(String command, String parameters, ParcelFileDescriptor out) { + } + + public void dispatchWallpaperOffsets(float x, float y) { + } +} diff --git a/core/java/com/android/internal/view/BaseSurfaceHolder.java b/core/java/com/android/internal/view/BaseSurfaceHolder.java new file mode 100644 index 0000000..2823689 --- /dev/null +++ b/core/java/com/android/internal/view/BaseSurfaceHolder.java @@ -0,0 +1,174 @@ +package com.android.internal.view; + +import android.graphics.Canvas; +import android.graphics.PixelFormat; +import android.graphics.Rect; +import android.os.SystemClock; +import android.util.Log; +import android.view.Surface; +import android.view.SurfaceHolder; + +import java.util.ArrayList; +import java.util.concurrent.locks.ReentrantLock; + +public abstract class BaseSurfaceHolder implements SurfaceHolder { + private static final String TAG = "BaseSurfaceHolder"; + static final boolean DEBUG = false; + + public final ArrayList<SurfaceHolder.Callback> mCallbacks + = new ArrayList<SurfaceHolder.Callback>(); + + public final ReentrantLock mSurfaceLock = new ReentrantLock(); + public final Surface mSurface = new Surface(); + + int mRequestedWidth = -1; + int mRequestedHeight = -1; + int mRequestedFormat = PixelFormat.OPAQUE; + int mRequestedType = -1; + + long mLastLockTime = 0; + + int mType = -1; + final Rect mSurfaceFrame = new Rect(); + + public abstract void onUpdateSurface(); + public abstract void onRelayoutContainer(); + public abstract boolean onAllowLockCanvas(); + + public int getRequestedWidth() { + return mRequestedWidth; + } + + public int getRequestedHeight() { + return mRequestedHeight; + } + + public int getRequestedFormat() { + return mRequestedFormat; + } + + public int getRequestedType() { + return mRequestedType; + } + + public void addCallback(Callback callback) { + synchronized (mCallbacks) { + // This is a linear search, but in practice we'll + // have only a couple callbacks, so it doesn't matter. + if (mCallbacks.contains(callback) == false) { + mCallbacks.add(callback); + } + } + } + + public void removeCallback(Callback callback) { + synchronized (mCallbacks) { + mCallbacks.remove(callback); + } + } + + public void setFixedSize(int width, int height) { + if (mRequestedWidth != width || mRequestedHeight != height) { + mRequestedWidth = width; + mRequestedHeight = height; + onRelayoutContainer(); + } + } + + public void setSizeFromLayout() { + if (mRequestedWidth != -1 || mRequestedHeight != -1) { + mRequestedWidth = mRequestedHeight = -1; + onRelayoutContainer(); + } + } + + public void setFormat(int format) { + if (mRequestedFormat != format) { + mRequestedFormat = format; + onUpdateSurface(); + } + } + + public void setType(int type) { + switch (type) { + case SURFACE_TYPE_HARDWARE: + case SURFACE_TYPE_GPU: + // these are deprecated, treat as "NORMAL" + type = SURFACE_TYPE_NORMAL; + break; + } + switch (type) { + case SURFACE_TYPE_NORMAL: + case SURFACE_TYPE_PUSH_BUFFERS: + if (mRequestedType != type) { + mRequestedType = type; + onUpdateSurface(); + } + break; + } + } + + public Canvas lockCanvas() { + return internalLockCanvas(null); + } + + public Canvas lockCanvas(Rect dirty) { + return internalLockCanvas(dirty); + } + + private final Canvas internalLockCanvas(Rect dirty) { + if (mType == SURFACE_TYPE_PUSH_BUFFERS) { + throw new BadSurfaceTypeException( + "Surface type is SURFACE_TYPE_PUSH_BUFFERS"); + } + mSurfaceLock.lock(); + + if (DEBUG) Log.i(TAG, "Locking canvas..,"); + + Canvas c = null; + if (onAllowLockCanvas()) { + Rect frame = dirty != null ? dirty : mSurfaceFrame; + try { + c = mSurface.lockCanvas(frame); + } catch (Exception e) { + Log.e(TAG, "Exception locking surface", e); + } + } + + if (DEBUG) Log.i(TAG, "Returned canvas: " + c); + if (c != null) { + mLastLockTime = SystemClock.uptimeMillis(); + return c; + } + + // If the Surface is not ready to be drawn, then return null, + // but throttle calls to this function so it isn't called more + // than every 100ms. + long now = SystemClock.uptimeMillis(); + long nextTime = mLastLockTime + 100; + if (nextTime > now) { + try { + Thread.sleep(nextTime-now); + } catch (InterruptedException e) { + } + now = SystemClock.uptimeMillis(); + } + mLastLockTime = now; + mSurfaceLock.unlock(); + + return null; + } + + public void unlockCanvasAndPost(Canvas canvas) { + mSurface.unlockCanvasAndPost(canvas); + mSurfaceLock.unlock(); + } + + public Surface getSurface() { + return mSurface; + } + + public Rect getSurfaceFrame() { + return mSurfaceFrame; + } +}; diff --git a/core/java/com/android/internal/widget/ContactHeaderWidget.java b/core/java/com/android/internal/widget/ContactHeaderWidget.java new file mode 100644 index 0000000..70f2779 --- /dev/null +++ b/core/java/com/android/internal/widget/ContactHeaderWidget.java @@ -0,0 +1,480 @@ +/* + * Copyright (C) 2009 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 com.android.internal.widget; + +import android.Manifest; +import android.content.AsyncQueryHandler; +import android.content.ContentResolver; +import android.content.ContentUris; +import android.content.ContentValues; +import android.content.Context; +import android.content.Intent; +import android.database.Cursor; +import android.graphics.Bitmap; +import android.graphics.BitmapFactory; +import android.graphics.Rect; +import android.graphics.drawable.Drawable; +import android.net.Uri; +import android.os.Handler; +import android.os.Message; +import android.os.SystemClock; +import android.provider.SocialContract; +import android.provider.ContactsContract.Contacts; +import android.provider.ContactsContract.Data; +import android.provider.ContactsContract.Intents; +import android.provider.ContactsContract.PhoneLookup; +import android.provider.ContactsContract.Presence; +import android.provider.ContactsContract.RawContacts; +import android.provider.ContactsContract.CommonDataKinds.Photo; +import android.provider.SocialContract.Activities; +import android.util.AttributeSet; +import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.widget.CheckBox; +import android.widget.FrameLayout; +import android.widget.ImageView; +import android.widget.RelativeLayout; +import android.widget.TextView; + +import com.android.internal.R; + +/** + * Header used across system for displaying a title bar with contact info. You + * can bind specific values on the header, or use helper methods like + * {@link #bindFromContactId(long)} to populate asynchronously. + * <p> + * The parent must request the {@link Manifest.permission#READ_CONTACTS} + * permission to access contact data. + */ +public class ContactHeaderWidget extends FrameLayout implements View.OnClickListener, + View.OnLongClickListener { + + private static final String TAG = "ContactHeaderWidget"; + + private TextView mDisplayNameView; + private TextView mPhoneticNameView; + private CheckBox mStarredView; + private ImageView mPhotoView; + private ImageView mPresenceView; + private TextView mStatusView; + private int mNoPhotoResource; + private QueryHandler mQueryHandler; + + protected long mContactId; + protected Uri mContactSummaryUri; + protected Uri mContactUri; + protected Uri mStatusUri; + + protected ContentResolver mContentResolver; + + /** + * Interface for callbacks invoked when the user interacts with a header. + */ + public interface ContactHeaderListener { + public void onPhotoLongClick(View view); + public void onDisplayNameLongClick(View view); + } + + private ContactHeaderListener mListener; + + //Projection used for the summary info in the header. + protected static final String[] HEADER_PROJECTION = new String[] { + Contacts.DISPLAY_NAME, + Contacts.STARRED, + Contacts.PHOTO_ID, + Contacts.PRESENCE_STATUS, + }; + protected static final int HEADER_DISPLAY_NAME_COLUMN_INDEX = 0; + //TODO: We need to figure out how we're going to get the phonetic name. + //static final int HEADER_PHONETIC_NAME_COLUMN_INDEX + protected static final int HEADER_STARRED_COLUMN_INDEX = 1; + protected static final int HEADER_PHOTO_ID_COLUMN_INDEX = 2; + protected static final int HEADER_PRESENCE_STATUS_COLUMN_INDEX = 3; + + //Projection used for finding the most recent social status. + protected static final String[] SOCIAL_PROJECTION = new String[] { + Activities.TITLE, + Activities.PUBLISHED, + }; + protected static final int SOCIAL_TITLE_COLUMN_INDEX = 0; + protected static final int SOCIAL_PUBLISHED_COLUMN_INDEX = 1; + + //Projection used for looking up contact id from phone number + protected static final String[] PHONE_LOOKUP_PROJECTION = new String[] { + PhoneLookup._ID, + }; + protected static final int PHONE_LOOKUP_CONTACT_ID_COLUMN_INDEX = 0; + + //Projection used for looking up contact id from email address + protected static final String[] EMAIL_LOOKUP_PROJECTION = new String[] { + RawContacts.CONTACT_ID, + }; + protected static final int EMAIL_LOOKUP_CONTACT_ID_COLUMN_INDEX = 0; + + + private static final int TOKEN_CONTACT_INFO = 0; + private static final int TOKEN_SOCIAL = 1; + + public ContactHeaderWidget(Context context) { + this(context, null); + } + + public ContactHeaderWidget(Context context, AttributeSet attrs) { + this(context, attrs, 0); + } + + public ContactHeaderWidget(Context context, AttributeSet attrs, int defStyle) { + super(context, attrs, defStyle); + + mContentResolver = mContext.getContentResolver(); + + LayoutInflater inflater = + (LayoutInflater) mContext.getSystemService(Context.LAYOUT_INFLATER_SERVICE); + inflater.inflate(R.layout.contact_header, this); + + mDisplayNameView = (TextView) findViewById(R.id.name); + mDisplayNameView.setOnLongClickListener(this); + + mPhoneticNameView = (TextView) findViewById(R.id.phonetic_name); + + mStarredView = (CheckBox)findViewById(R.id.star); + mStarredView.setOnClickListener(this); + + mPhotoView = (ImageView)findViewById(R.id.photo); + mPhotoView.setOnClickListener(this); + mPhotoView.setOnLongClickListener(this); + + mPresenceView = (ImageView) findViewById(R.id.presence); + + mStatusView = (TextView)findViewById(R.id.status); + + // Set the photo with a random "no contact" image + long now = SystemClock.elapsedRealtime(); + int num = (int) now & 0xf; + if (num < 9) { + // Leaning in from right, common + mNoPhotoResource = R.drawable.ic_contact_picture; + } else if (num < 14) { + // Leaning in from left uncommon + mNoPhotoResource = R.drawable.ic_contact_picture_2; + } else { + // Coming in from the top, rare + mNoPhotoResource = R.drawable.ic_contact_picture_3; + } + + mQueryHandler = new QueryHandler(mContentResolver); + } + + /** + * Set the given {@link ContactHeaderListener} to handle header events. + */ + public void setContactHeaderListener(ContactHeaderListener listener) { + mListener = listener; + } + + /** {@inheritDoc} */ + public boolean onLongClick(View v) { + switch (v.getId()) { + case R.id.photo: + performPhotoLongClick(); + return true; + case R.id.name: + performDisplayNameLongClick(); + return true; + } + return false; + } + + private void performPhotoLongClick() { + if (mListener != null) { + mListener.onPhotoLongClick(mPhotoView); + } + } + + private void performDisplayNameLongClick() { + if (mListener != null) { + mListener.onDisplayNameLongClick(mDisplayNameView); + } + } + + private class QueryHandler extends AsyncQueryHandler { + + public QueryHandler(ContentResolver cr) { + super(cr); + } + + @Override + protected void onQueryComplete(int token, Object cookie, Cursor cursor) { + try{ + if (token == TOKEN_CONTACT_INFO) { + bindContactInfo(cursor); + invalidate(); + } else if (token == TOKEN_SOCIAL) { + bindSocial(cursor); + invalidate(); + } + } finally { + if (cursor != null) { + cursor.close(); + } + } + } + } + + /** + * Turn on/off showing of the star element. + */ + public void showStar(boolean showStar) { + mStarredView.setVisibility(showStar ? View.VISIBLE : View.GONE); + } + + /** + * Manually set the starred state of this header widget. This doesn't change + * the underlying {@link Contacts} value, only the UI state. + */ + public void setStared(boolean starred) { + mStarredView.setChecked(starred); + } + + /** + * Manually set the presence. + */ + public void setPresence(int presence) { + mPresenceView.setImageResource(Presence.getPresenceIconResourceId(presence)); + } + + /** + * Manually set the contact uri + */ + public void setContactUri(Uri uri) { + mContactUri = uri; + } + + /** + * Manually set the photo to display in the header. This doesn't change the + * underlying {@link Contacts}, only the UI state. + */ + public void setPhoto(Bitmap bitmap) { + mPhotoView.setImageBitmap(bitmap); + } + + /** + * Manually set the display name and phonetic name to show in the header. + * This doesn't change the underlying {@link Contacts}, only the UI state. + */ + public void setDisplayName(CharSequence displayName, CharSequence phoneticName) { + mDisplayNameView.setText(displayName); + if (mPhoneticNameView != null) { + mPhoneticNameView.setText(phoneticName); + } + } + + /** + * Manually set the social snippet text to display in the header. + */ + public void setSocialSnippet(CharSequence snippet) { + mStatusView.setText(snippet); + } + + /** + * Convenience method for binding all available data from an existing + * contact. + * + * @param contactId the contact id of the contact whose info should be displayed. + */ + public void bindFromContactId(long contactId) { + mContactId = contactId; + mContactUri = ContentUris.withAppendedId(Contacts.CONTENT_URI, mContactId); + + bindSummaryUri(ContentUris.withAppendedId(Contacts.CONTENT_SUMMARY_URI, mContactId)); + bindSocialUri(ContentUris.withAppendedId(Activities.CONTENT_CONTACT_STATUS_URI, mContactId)); + } + + /** + * Convenience method for binding {@link Contacts} header details from a + * {@link Contacts#CONTENT_SUMMARY_URI} reference. + */ + public void bindSummaryUri(Uri contactSummary) { + mContactSummaryUri = contactSummary; + mQueryHandler.startQuery(TOKEN_CONTACT_INFO, null, mContactSummaryUri, HEADER_PROJECTION, + null, null, null); + } + + /** + * Convenience method for binding {@link Activities} header details from a + * {@link Activities#CONTENT_CONTACT_STATUS_URI}. + */ + public void bindSocialUri(Uri contactSocial) { + mStatusUri = contactSocial; + mQueryHandler.startQuery(TOKEN_SOCIAL, null, mStatusUri, SOCIAL_PROJECTION, null, null, + null); + } + + /** + * Convenience method for binding all available data from an existing + * contact. + * + * @param emailAddress The email address used to do a reverse lookup in + * the contacts database. If more than one contact contains this email + * address, one of them will be chosen to bind to. + */ + public void bindFromEmail(String emailAddress) { + Cursor c = null; + try { + c = mContentResolver.query(Uri.withAppendedPath( + RawContacts.CONTENT_FILTER_EMAIL_URI, Uri.encode(emailAddress)), + EMAIL_LOOKUP_PROJECTION, null, null, null); + if (c != null && c.moveToFirst()) { + long contactId = c.getLong(EMAIL_LOOKUP_CONTACT_ID_COLUMN_INDEX); + bindFromContactId(contactId); + } else { + setDisplayName(emailAddress, null); + } + } finally { + if (c != null) { + c.close(); + } + } + } + + /** + * Convenience method for binding all available data from an existing + * contact. + * + * @param number The phone number used to do a reverse lookup in + * the contacts database. If more than one contact contains this phone + * number, one of them will be chosen to bind to. + */ + public void bindFromPhoneNumber(String number) { + Cursor c = null; + try { + c = mContentResolver.query(Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, number), + PHONE_LOOKUP_PROJECTION, null, null, null); + if (c != null && c.moveToFirst()) { + long contactId = c.getLong(PHONE_LOOKUP_CONTACT_ID_COLUMN_INDEX); + bindFromContactId(contactId); + } else { + setDisplayName(number, null); + } + } finally { + if (c != null) { + c.close(); + } + } + } + + /** + * Bind the contact details provided by the given {@link Cursor}. + */ + protected void bindContactInfo(Cursor c) { + if (c == null || !c.moveToFirst()) return; + + // TODO: Bring back phonetic name + final String displayName = c.getString(HEADER_DISPLAY_NAME_COLUMN_INDEX); + final String phoneticName = null; + this.setDisplayName(displayName, null); + + final boolean starred = c.getInt(HEADER_STARRED_COLUMN_INDEX) != 0; + mStarredView.setChecked(starred); + + //Set the photo + Bitmap photoBitmap = loadContactPhoto(c.getLong(HEADER_PHOTO_ID_COLUMN_INDEX), null); + if (photoBitmap == null) { + photoBitmap = loadPlaceholderPhoto(null); + } + mPhotoView.setImageBitmap(photoBitmap); + + //Set the presence status + int presence = c.getInt(HEADER_PRESENCE_STATUS_COLUMN_INDEX); + mPresenceView.setImageResource(Presence.getPresenceIconResourceId(presence)); + } + + /** + * Bind the social data provided by the given {@link Cursor}. + */ + protected void bindSocial(Cursor c) { + if (c == null || !c.moveToFirst()) return; + final String status = c.getString(SOCIAL_TITLE_COLUMN_INDEX); + this.setSocialSnippet(status); + } + + public void onClick(View view) { + switch (view.getId()) { + case R.id.star: { + // Toggle "starred" state + final ContentValues values = new ContentValues(1); + values.put(Contacts.STARRED, mStarredView.isChecked()); + mContentResolver.update(mContactUri, values, null, null); + break; + } + case R.id.photo: { + // Photo launches contact detail action + final Intent intent = new Intent(Intents.SHOW_OR_CREATE_CONTACT, mContactUri); + final Rect target = getTargetRect(view); + intent.putExtra(Intents.EXTRA_TARGET_RECT, target); + intent.putExtra(Intents.EXTRA_MODE, Intents.MODE_SMALL); + mContext.startActivity(intent); + break; + } + } + } + + private Rect getTargetRect(View anchor) { + final int[] location = new int[2]; + anchor.getLocationOnScreen(location); + + final Rect rect = new Rect(); + rect.left = location[0]; + rect.top = location[1]; + rect.right = rect.left + anchor.getWidth(); + rect.bottom = rect.top + anchor.getHeight(); + return rect; + } + + private Bitmap loadContactPhoto(long photoId, BitmapFactory.Options options) { + Cursor photoCursor = null; + Bitmap photoBm = null; + + try { + photoCursor = mContentResolver.query( + ContentUris.withAppendedId(Data.CONTENT_URI, photoId), + new String[] { Photo.PHOTO }, + null, null, null); + + if (photoCursor != null && photoCursor.moveToFirst() && !photoCursor.isNull(0)) { + byte[] photoData = photoCursor.getBlob(0); + photoBm = BitmapFactory.decodeByteArray(photoData, 0, + photoData.length, options); + } + } finally { + if (photoCursor != null) { + photoCursor.close(); + } + } + + return photoBm; + } + + private Bitmap loadPlaceholderPhoto(BitmapFactory.Options options) { + if (mNoPhotoResource == 0) { + return null; + } + return BitmapFactory.decodeResource(mContext.getResources(), + mNoPhotoResource, options); + } +} diff --git a/core/java/com/google/android/gdata/client/QueryParamsImpl.java b/core/java/com/google/android/gdata/client/QueryParamsImpl.java index e27b36f..fbe0d22 100644 --- a/core/java/com/google/android/gdata/client/QueryParamsImpl.java +++ b/core/java/com/google/android/gdata/client/QueryParamsImpl.java @@ -60,6 +60,8 @@ public class QueryParamsImpl extends QueryParams { sb.append('?'); } for (String param : params) { + String value = mParams.get(param); + if (value == null) continue; if (first) { first = false; } else { @@ -67,7 +69,7 @@ public class QueryParamsImpl extends QueryParams { } sb.append(param); sb.append('='); - String value = mParams.get(param); + String encodedValue = null; try { diff --git a/core/java/com/google/android/gdata2/client/AndroidGDataClient.java b/core/java/com/google/android/gdata2/client/AndroidGDataClient.java new file mode 100644 index 0000000..6ba791d --- /dev/null +++ b/core/java/com/google/android/gdata2/client/AndroidGDataClient.java @@ -0,0 +1,590 @@ +// Copyright 2007 The Android Open Source Project + +package com.google.android.gdata2.client; + +import com.google.android.net.GoogleHttpClient; +import com.google.wireless.gdata2.client.GDataClient; +import com.google.wireless.gdata2.client.HttpException; +import com.google.wireless.gdata2.client.QueryParams; +import com.google.wireless.gdata2.data.StringUtils; +import com.google.wireless.gdata2.parser.ParseException; +import com.google.wireless.gdata2.serializer.GDataSerializer; +import com.google.android.gdata2.client.QueryParamsImpl; + +import org.apache.http.Header; +import org.apache.http.HttpEntity; +import org.apache.http.HttpResponse; +import org.apache.http.StatusLine; +import org.apache.http.params.HttpParams; +import org.apache.http.params.BasicHttpParams; +import org.apache.http.client.methods.HttpGet; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.entity.InputStreamEntity; +import org.apache.http.entity.AbstractHttpEntity; + +import android.content.ContentResolver; +import android.content.Context; +import android.net.http.AndroidHttpClient; +import android.text.TextUtils; +import android.util.Config; +import android.util.Log; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.UnsupportedEncodingException; +import java.io.BufferedInputStream; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URLEncoder; + +/** + * Implementation of a GDataClient using GoogleHttpClient to make HTTP + * requests. Always issues GETs and POSTs, using the X-HTTP-Method-Override + * header when a PUT or DELETE is desired, to avoid issues with firewalls, etc., + * that do not allow methods other than GET or POST. + */ +public class AndroidGDataClient implements GDataClient { + + private static final String TAG = "GDataClient"; + private static final boolean DEBUG = false; + private static final boolean LOCAL_LOGV = DEBUG ? Config.LOGD : Config.LOGV; + + private static final String X_HTTP_METHOD_OVERRIDE = + "X-HTTP-Method-Override"; + + private static final String DEFAULT_USER_AGENT_APP_VERSION = "Android-GData/1.2"; + + private static final int MAX_REDIRECTS = 10; + private static String DEFAULT_GDATA_VERSION = "2.0"; + + + private String mGDataVersion; + private final GoogleHttpClient mHttpClient; + private ContentResolver mResolver; + + /** + * Interface for creating HTTP requests. Used by + * {@link AndroidGDataClient#createAndExecuteMethod}, since HttpUriRequest does not allow for + * changing the URI after creation, e.g., when you want to follow a redirect. + */ + private interface HttpRequestCreator { + HttpUriRequest createRequest(URI uri); + } + + private static class GetRequestCreator implements HttpRequestCreator { + public GetRequestCreator() { + } + + public HttpUriRequest createRequest(URI uri) { + HttpGet get = new HttpGet(uri); + return get; + } + } + + private static class PostRequestCreator implements HttpRequestCreator { + private final String mMethodOverride; + private final HttpEntity mEntity; + public PostRequestCreator(String methodOverride, HttpEntity entity) { + mMethodOverride = methodOverride; + mEntity = entity; + } + + public HttpUriRequest createRequest(URI uri) { + HttpPost post = new HttpPost(uri); + if (mMethodOverride != null) { + post.addHeader(X_HTTP_METHOD_OVERRIDE, mMethodOverride); + } + post.setEntity(mEntity); + return post; + } + } + + // MAJOR TODO: make this work across redirects (if we can reset the InputStream). + // OR, read the bits into a local buffer (yuck, the media could be large). + private static class MediaPutRequestCreator implements HttpRequestCreator { + private final InputStream mMediaInputStream; + private final String mContentType; + public MediaPutRequestCreator(InputStream mediaInputStream, String contentType) { + mMediaInputStream = mediaInputStream; + mContentType = contentType; + } + + public HttpUriRequest createRequest(URI uri) { + HttpPost post = new HttpPost(uri); + post.addHeader(X_HTTP_METHOD_OVERRIDE, "PUT"); + // mMediaInputStream.reset(); + InputStreamEntity entity = new InputStreamEntity(mMediaInputStream, + -1 /* read until EOF */); + entity.setContentType(mContentType); + post.setEntity(entity); + return post; + } + } + + + /** + * Creates a new AndroidGDataClient. + * + * @param context The ContentResolver to get URL rewriting rules from + * through the Android proxy server, using null to indicate not using proxy. + * The context will also be used by GoogleHttpClient for configuration of + * SSL session persistence. + */ + public AndroidGDataClient(Context context) { + this(context, DEFAULT_USER_AGENT_APP_VERSION); + } + + /** + * Creates a new AndroidGDataClient. + * + * @param context The ContentResolver to get URL rewriting rules from + * through the Android proxy server, using null to indicate not using proxy. + * The context will also be used by GoogleHttpClient for configuration of + * SSL session persistence. + * @param appAndVersion The application name and version to be used as the basis of the + * User-Agent. e.g., Android-GData/1.5.0. + */ + public AndroidGDataClient(Context context, String appAndVersion) { + this(context, appAndVersion, DEFAULT_GDATA_VERSION); + } + + /** + * Creates a new AndroidGDataClient. + * + * @param context The ContentResolver to get URL rewriting rules from + * through the Android proxy server, using null to indicate not using proxy. + * The context will also be used by GoogleHttpClient for configuration of + * SSL session persistence. + * @param appAndVersion The application name and version to be used as the basis of the + * User-Agent. e.g., Android-GData/1.5.0. + * @param gdataVersion The gdata service version that should be + * used, e.g. "2.0" + * + */ + public AndroidGDataClient(Context context, String appAndVersion, String gdataVersion) { + mHttpClient = new GoogleHttpClient(context, appAndVersion, + true /* gzip capable */); + mHttpClient.enableCurlLogging(TAG, Log.VERBOSE); + mResolver = context.getContentResolver(); + mGDataVersion = gdataVersion; + } + + + public void close() { + mHttpClient.close(); + } + + /* + * (non-Javadoc) + * @see GDataClient#encodeUri(java.lang.String) + */ + public String encodeUri(String uri) { + String encodedUri; + try { + encodedUri = URLEncoder.encode(uri, "UTF-8"); + } catch (UnsupportedEncodingException uee) { + // should not happen. + Log.e("JakartaGDataClient", + "UTF-8 not supported -- should not happen. " + + "Using default encoding.", uee); + encodedUri = URLEncoder.encode(uri); + } + return encodedUri; + } + + /* + * (non-Javadoc) + * @see com.google.wireless.gdata.client.GDataClient#createQueryParams() + */ + public QueryParams createQueryParams() { + return new QueryParamsImpl(); + } + + // follows redirects + private InputStream createAndExecuteMethod(HttpRequestCreator creator, + String uriString, + String authToken, + String eTag, + String protocolVersion) + throws HttpException, IOException { + + HttpResponse response = null; + int status = 500; + int redirectsLeft = MAX_REDIRECTS; + + URI uri; + try { + uri = new URI(uriString); + } catch (URISyntaxException use) { + Log.w(TAG, "Unable to parse " + uriString + " as URI.", use); + throw new IOException("Unable to parse " + uriString + " as URI: " + + use.getMessage()); + } + + // we follow redirects ourselves, since we want to follow redirects even on POSTs, which + // the HTTP library does not do. following redirects ourselves also allows us to log + // the redirects using our own logging. + while (redirectsLeft > 0) { + + HttpUriRequest request = creator.createRequest(uri); + + AndroidHttpClient.modifyRequestToAcceptGzipResponse(request); + // only add the auth token if not null (to allow for GData feeds that do not require + // authentication.) + if (!TextUtils.isEmpty(authToken)) { + request.addHeader("Authorization", "GoogleLogin auth=" + authToken); + } + + // while by default we have a 2.0 in this variable, it is possible to construct + // a client that has an empty version field, to work with 1.0 services. + if (!TextUtils.isEmpty(mGDataVersion)) { + request.addHeader("GDataVersion", mGDataVersion); + } + + // if we have a passed down eTag value, we need to add several headers + if (!TextUtils.isEmpty(eTag)) { + String method = request.getMethod(); + Header overrideMethodHeader = request.getFirstHeader(X_HTTP_METHOD_OVERRIDE); + if (overrideMethodHeader != null) { + method = overrideMethodHeader.getValue(); + } + if ("GET".equals(method)) { + // add the none match header, if the resource is not changed + // this request will result in a 304 now. + request.addHeader("If-None-Match", eTag); + } else if ("DELETE".equals(method) + || "PUT".equals(method)) { + // now we send an if-match, but only if the passed in eTag is a strong eTag + // as this only makes sense for a strong eTag + if (!eTag.startsWith("W/")) { + request.addHeader("If-Match", eTag); + } + } + } + + if (LOCAL_LOGV) { + for (Header h : request.getAllHeaders()) { + Log.v(TAG, h.getName() + ": " + h.getValue()); + } + } + + if (Log.isLoggable(TAG, Log.DEBUG)) { + Log.d(TAG, "Executing " + request.getRequestLine().toString()); + } + + response = null; + + try { + response = mHttpClient.execute(request); + } catch (IOException ioe) { + Log.w(TAG, "Unable to execute HTTP request." + ioe); + throw ioe; + } + + StatusLine statusLine = response.getStatusLine(); + if (statusLine == null) { + Log.w(TAG, "StatusLine is null."); + throw new NullPointerException("StatusLine is null -- should not happen."); + } + + if (Log.isLoggable(TAG, Log.DEBUG)) { + Log.d(TAG, response.getStatusLine().toString()); + for (Header h : response.getAllHeaders()) { + Log.d(TAG, h.getName() + ": " + h.getValue()); + } + } + status = statusLine.getStatusCode(); + + HttpEntity entity = response.getEntity(); + + if ((status >= 200) && (status < 300) && entity != null) { + InputStream in = AndroidHttpClient.getUngzippedContent(entity); + if (Log.isLoggable(TAG, Log.DEBUG)) { + in = logInputStreamContents(in); + } + return in; + } + + // TODO: handle 301, 307? + // TODO: let the http client handle the redirects, if we can be sure we'll never get a + // redirect on POST. + if (status == 302) { + // consume the content, so the connection can be closed. + entity.consumeContent(); + Header location = response.getFirstHeader("Location"); + if (location == null) { + if (Log.isLoggable(TAG, Log.DEBUG)) { + Log.d(TAG, "Redirect requested but no Location " + + "specified."); + } + break; + } + if (Log.isLoggable(TAG, Log.DEBUG)) { + Log.d(TAG, "Following redirect to " + location.getValue()); + } + try { + uri = new URI(location.getValue()); + } catch (URISyntaxException use) { + if (Log.isLoggable(TAG, Log.DEBUG)) { + Log.d(TAG, "Unable to parse " + location.getValue() + " as URI.", use); + throw new IOException("Unable to parse " + location.getValue() + + " as URI."); + } + break; + } + --redirectsLeft; + } else { + break; + } + } + + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, "Received " + status + " status code."); + } + String errorMessage = null; + HttpEntity entity = response.getEntity(); + try { + if (response != null && entity != null) { + InputStream in = AndroidHttpClient.getUngzippedContent(entity); + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + byte[] buf = new byte[8192]; + int bytesRead = -1; + while ((bytesRead = in.read(buf)) != -1) { + baos.write(buf, 0, bytesRead); + } + // TODO: use appropriate encoding, picked up from Content-Type. + errorMessage = new String(baos.toByteArray()); + if (Log.isLoggable(TAG, Log.VERBOSE)) { + Log.v(TAG, errorMessage); + } + } + } finally { + if (entity != null) { + entity.consumeContent(); + } + } + String exceptionMessage = "Received " + status + " status code"; + if (errorMessage != null) { + exceptionMessage += (": " + errorMessage); + } + throw new HttpException(exceptionMessage, status, null /* InputStream */); + } + + /* + * (non-Javadoc) + * @see GDataClient#getFeedAsStream(java.lang.String, java.lang.String) + */ + public InputStream getFeedAsStream(String feedUrl, + String authToken, + String eTag, + String protocolVersion) + throws HttpException, IOException { + + InputStream in = createAndExecuteMethod(new GetRequestCreator(), feedUrl, authToken, eTag, protocolVersion); + if (in != null) { + return in; + } + throw new IOException("Unable to access feed."); + } + + /** + * Log the contents of the input stream. + * The original input stream is consumed, so the caller must use the + * BufferedInputStream that is returned. + * @param in InputStream + * @return replacement input stream for caller to use + * @throws IOException + */ + private InputStream logInputStreamContents(InputStream in) throws IOException { + if (in == null) { + return in; + } + // bufferSize is the (arbitrary) maximum amount to log. + // The original InputStream is wrapped in a + // BufferedInputStream with a 16K buffer. This lets + // us read up to 16K, write it to the log, and then + // reset the stream so the the original client can + // then read the data. The BufferedInputStream + // provides the mark and reset support, even when + // the original InputStream does not. + final int bufferSize = 16384; + BufferedInputStream bin = new BufferedInputStream(in, bufferSize); + bin.mark(bufferSize); + int wanted = bufferSize; + int totalReceived = 0; + byte buf[] = new byte[wanted]; + while (wanted > 0) { + int got = bin.read(buf, totalReceived, wanted); + if (got <= 0) break; // EOF + wanted -= got; + totalReceived += got; + } + Log.d(TAG, new String(buf, 0, totalReceived, "UTF-8")); + bin.reset(); + return bin; + } + + public InputStream getMediaEntryAsStream(String mediaEntryUrl, String authToken, String eTag, String protocolVersion) + throws HttpException, IOException { + + InputStream in = createAndExecuteMethod(new GetRequestCreator(), mediaEntryUrl, authToken, eTag, protocolVersion); + + if (in != null) { + return in; + } + throw new IOException("Unable to access media entry."); + } + + /* (non-Javadoc) + * @see GDataClient#createEntry + */ + public InputStream createEntry(String feedUrl, + String authToken, + String protocolVersion, + GDataSerializer entry) + throws HttpException, IOException { + + HttpEntity entity = createEntityForEntry(entry, GDataSerializer.FORMAT_CREATE); + InputStream in = createAndExecuteMethod( + new PostRequestCreator(null /* override */, entity), + feedUrl, + authToken, + null, + protocolVersion); + if (in != null) { + return in; + } + throw new IOException("Unable to create entry."); + } + + /* (non-Javadoc) + * @see GDataClient#updateEntry + */ + public InputStream updateEntry(String editUri, + String authToken, + String eTag, + String protocolVersion, + GDataSerializer entry) + throws HttpException, IOException { + HttpEntity entity = createEntityForEntry(entry, GDataSerializer.FORMAT_UPDATE); + final String method = entry.getSupportsPartial() ? "PATCH" : "PUT"; + InputStream in = createAndExecuteMethod( + new PostRequestCreator(method, entity), + editUri, + authToken, + eTag, + protocolVersion); + if (in != null) { + return in; + } + throw new IOException("Unable to update entry."); + } + + /* (non-Javadoc) + * @see GDataClient#deleteEntry + */ + public void deleteEntry(String editUri, String authToken, String eTag) + throws HttpException, IOException { + if (StringUtils.isEmpty(editUri)) { + throw new IllegalArgumentException( + "you must specify an non-empty edit url"); + } + InputStream in = + createAndExecuteMethod( + new PostRequestCreator("DELETE", null /* entity */), + editUri, + authToken, + eTag, + null /* protocolVersion, not required for a delete */); + if (in == null) { + throw new IOException("Unable to delete entry."); + } + try { + in.close(); + } catch (IOException ioe) { + // ignore + } + } + + public InputStream updateMediaEntry(String editUri, String authToken, String eTag, + String protocolVersion, InputStream mediaEntryInputStream, String contentType) + throws HttpException, IOException { + InputStream in = createAndExecuteMethod( + new MediaPutRequestCreator(mediaEntryInputStream, contentType), + editUri, + authToken, + eTag, + protocolVersion); + if (in != null) { + return in; + } + throw new IOException("Unable to write media entry."); + } + + private HttpEntity createEntityForEntry(GDataSerializer entry, int format) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + try { + entry.serialize(baos, format); + } catch (IOException ioe) { + Log.e(TAG, "Unable to serialize entry.", ioe); + throw ioe; + } catch (ParseException pe) { + Log.e(TAG, "Unable to serialize entry.", pe); + throw new IOException("Unable to serialize entry: " + pe.getMessage()); + } + + byte[] entryBytes = baos.toByteArray(); + + if (entryBytes != null && Log.isLoggable(TAG, Log.DEBUG)) { + try { + Log.d(TAG, "Serialized entry: " + new String(entryBytes, "UTF-8")); + } catch (UnsupportedEncodingException uee) { + // should not happen + throw new IllegalStateException("UTF-8 should be supported!", + uee); + } + } + + AbstractHttpEntity entity = AndroidHttpClient.getCompressedEntity(entryBytes, mResolver); + entity.setContentType(entry.getContentType()); + return entity; + } + + /** + * Connects to a GData server (specified by the batchUrl) and submits a + * batch for processing. The response from the server is returned as an + * {@link InputStream}. The caller is responsible for calling + * {@link InputStream#close()} on the returned {@link InputStream}. + * + * @param batchUrl The batch url to which the batch is submitted. + * @param authToken the authentication token that should be used when + * submitting the batch. + * @param protocolVersion The version of the protocol that + * should be used for this request. + * @param batch The batch of entries to submit. + * @throws IOException Thrown if an io error occurs while communicating with + * the service. + * @throws HttpException if the service returns an error response. + */ + public InputStream submitBatch(String batchUrl, + String authToken, + String protocolVersion, + GDataSerializer batch) + throws HttpException, IOException + { + HttpEntity entity = createEntityForEntry(batch, GDataSerializer.FORMAT_BATCH); + InputStream in = createAndExecuteMethod( + new PostRequestCreator("POST", entity), + batchUrl, + authToken, + null, + protocolVersion); + if (in != null) { + return in; + } + throw new IOException("Unable to process batch request."); + } +} + diff --git a/core/java/com/google/android/gdata2/client/AndroidXmlParserFactory.java b/core/java/com/google/android/gdata2/client/AndroidXmlParserFactory.java new file mode 100644 index 0000000..f097706 --- /dev/null +++ b/core/java/com/google/android/gdata2/client/AndroidXmlParserFactory.java @@ -0,0 +1,31 @@ +package com.google.android.gdata2.client; + +import com.google.wireless.gdata2.parser.xml.XmlParserFactory; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; +import org.xmlpull.v1.XmlSerializer; + +import android.util.Xml; + +/** + * XmlParserFactory for the Android platform. + */ +public class AndroidXmlParserFactory implements XmlParserFactory { + + /* + * (non-javadoc) + * @see XmlParserFactory#createParser + */ + public XmlPullParser createParser() throws XmlPullParserException { + return Xml.newPullParser(); + } + + /* + * (non-javadoc) + * @see XmlParserFactory#createSerializer + */ + public XmlSerializer createSerializer() throws XmlPullParserException { + return Xml.newSerializer(); + } +} diff --git a/core/java/com/google/android/gdata2/client/QueryParamsImpl.java b/core/java/com/google/android/gdata2/client/QueryParamsImpl.java new file mode 100644 index 0000000..a26f4ce --- /dev/null +++ b/core/java/com/google/android/gdata2/client/QueryParamsImpl.java @@ -0,0 +1,99 @@ +package com.google.android.gdata2.client; +import com.google.wireless.gdata2.client.QueryParams; + +import android.text.TextUtils; +import android.util.Log; + +import java.io.UnsupportedEncodingException; +import java.net.URLEncoder; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +/** + * Simple implementation of the QueryParams interface. + */ +// TODO: deal with categories +public class QueryParamsImpl extends QueryParams { + + private final Map<String,String> mParams = new HashMap<String,String>(); + + /** + * Creates a new empty QueryParamsImpl. + */ + public QueryParamsImpl() { + } + + @Override + public void clear() { + setEntryId(null); + mParams.clear(); + } + + @Override + public String generateQueryUrl(String feedUrl) { + + if (TextUtils.isEmpty(getEntryId()) && + mParams.isEmpty()) { + // nothing to do + return feedUrl; + } + + // handle entry IDs + if (!TextUtils.isEmpty(getEntryId())) { + if (!mParams.isEmpty()) { + throw new IllegalStateException("Cannot set both an entry ID " + + "and other query paramters."); + } + return feedUrl + '/' + getEntryId(); + } + + // otherwise, append the querystring params. + StringBuilder sb = new StringBuilder(); + sb.append(feedUrl); + Set<String> params = mParams.keySet(); + boolean first = true; + if (feedUrl.contains("?")) { + first = false; + } else { + sb.append('?'); + } + for (String param : params) { + if (first) { + first = false; + } else { + sb.append('&'); + } + sb.append(param); + sb.append('='); + String value = mParams.get(param); + String encodedValue = null; + + try { + encodedValue = URLEncoder.encode(value, "UTF-8"); + } catch (UnsupportedEncodingException uee) { + // should not happen. + Log.w("QueryParamsImpl", + "UTF-8 not supported -- should not happen. " + + "Using default encoding.", uee); + encodedValue = URLEncoder.encode(value); + } + sb.append(encodedValue); + } + return sb.toString(); + } + + @Override + public String getParamValue(String param) { + if (!(mParams.containsKey(param))) { + return null; + } + return mParams.get(param); + } + + @Override + public void setParamValue(String param, String value) { + mParams.put(param, value); + } + +} diff --git a/core/java/com/google/android/mms/pdu/EncodedStringValue.java b/core/java/com/google/android/mms/pdu/EncodedStringValue.java index 7696c5e..a27962d 100644 --- a/core/java/com/google/android/mms/pdu/EncodedStringValue.java +++ b/core/java/com/google/android/mms/pdu/EncodedStringValue.java @@ -269,4 +269,16 @@ public class EncodedStringValue implements Cloneable { return new EncodedStringValue(value.mCharacterSet, value.mData); } + + public static EncodedStringValue[] encodeStrings(String[] array) { + int count = array.length; + if (count > 0) { + EncodedStringValue[] encodedArray = new EncodedStringValue[count]; + for (int i = 0; i < count; i++) { + encodedArray[i] = new EncodedStringValue(array[i]); + } + return encodedArray; + } + return null; + } } diff --git a/core/java/com/google/android/mms/pdu/PduPersister.java b/core/java/com/google/android/mms/pdu/PduPersister.java index d2a41f1..df91ea6 100644 --- a/core/java/com/google/android/mms/pdu/PduPersister.java +++ b/core/java/com/google/android/mms/pdu/PduPersister.java @@ -31,6 +31,7 @@ import android.content.Context; import android.database.Cursor; import android.database.DatabaseUtils; import android.net.Uri; +import android.provider.Telephony; import android.provider.Telephony.Mms; import android.provider.Telephony.MmsSms; import android.provider.Telephony.Threads; @@ -54,6 +55,8 @@ import java.util.Map; import java.util.Set; import java.util.Map.Entry; +import com.google.android.mms.pdu.EncodedStringValue; + /** * This class is the high-level manager of PDU storage. */ @@ -159,6 +162,7 @@ public class PduPersister { Part.CONTENT_TYPE, Part.FILENAME, Part.NAME, + Part.TEXT }; private static final int PART_COLUMN_ID = 0; @@ -169,6 +173,7 @@ public class PduPersister { private static final int PART_COLUMN_CONTENT_TYPE = 5; private static final int PART_COLUMN_FILENAME = 6; private static final int PART_COLUMN_NAME = 7; + private static final int PART_COLUMN_TEXT = 8; private static final HashMap<Uri, Integer> MESSAGE_BOX_MAP; // These map are used for convenience in persist() and load(). @@ -414,26 +419,36 @@ public class PduPersister { ByteArrayOutputStream baos = new ByteArrayOutputStream(); InputStream is = null; - try { - is = mContentResolver.openInputStream(partURI); - - byte[] buffer = new byte[256]; - int len = is.read(buffer); - while (len >= 0) { - baos.write(buffer, 0, len); - len = is.read(buffer); - } - } catch (IOException e) { - Log.e(TAG, "Failed to load part data", e); - c.close(); - throw new MmsException(e); - } finally { - if (is != null) { - try { - is.close(); - } catch (IOException e) { - Log.e(TAG, "Failed to close stream", e); - } // Ignore + // Store simple string values directly in the database instead of an + // external file. This makes the text searchable and retrieval slightly + // faster. + if ("text/plain".equals(type) || "application/smil".equals(type)) { + String text = c.getString(PART_COLUMN_TEXT); + byte [] blob = new EncodedStringValue(text).getTextString(); + baos.write(blob, 0, blob.length); + } else { + + try { + is = mContentResolver.openInputStream(partURI); + + byte[] buffer = new byte[256]; + int len = is.read(buffer); + while (len >= 0) { + baos.write(buffer, 0, len); + len = is.read(buffer); + } + } catch (IOException e) { + Log.e(TAG, "Failed to load part data", e); + c.close(); + throw new MmsException(e); + } finally { + if (is != null) { + try { + is.close(); + } catch (IOException e) { + Log.e(TAG, "Failed to close stream", e); + } // Ignore + } } } part.setData(baos.toByteArray()); @@ -719,29 +734,37 @@ public class PduPersister { InputStream is = null; try { - os = mContentResolver.openOutputStream(uri); byte[] data = part.getData(); - if (data == null) { - Uri dataUri = part.getDataUri(); - if ((dataUri == null) || (dataUri == uri)) { - Log.w(TAG, "Can't find data for this part."); - return; - } - is = mContentResolver.openInputStream(dataUri); - - if (LOCAL_LOGV) { - Log.v(TAG, "Saving data to: " + uri); - } - - byte[] buffer = new byte[256]; - for (int len = 0; (len = is.read(buffer)) != -1; ) { - os.write(buffer, 0, len); + if ("text/plain".equals(contentType) || "application/smil".equals(contentType)) { + ContentValues cv = new ContentValues(); + cv.put(Telephony.Mms.Part.TEXT, new EncodedStringValue(data).getString()); + if (mContentResolver.update(uri, cv, null, null) != 1) { + throw new MmsException("unable to update " + uri.toString()); } } else { - if (LOCAL_LOGV) { - Log.v(TAG, "Saving data to: " + uri); + os = mContentResolver.openOutputStream(uri); + if (data == null) { + Uri dataUri = part.getDataUri(); + if ((dataUri == null) || (dataUri == uri)) { + Log.w(TAG, "Can't find data for this part."); + return; + } + is = mContentResolver.openInputStream(dataUri); + + if (LOCAL_LOGV) { + Log.v(TAG, "Saving data to: " + uri); + } + + byte[] buffer = new byte[256]; + for (int len = 0; (len = is.read(buffer)) != -1; ) { + os.write(buffer, 0, len); + } + } else { + if (LOCAL_LOGV) { + Log.v(TAG, "Saving data to: " + uri); + } + os.write(data); } - os.write(data); } } catch (FileNotFoundException e) { Log.e(TAG, "Failed to open Input/Output stream.", e); @@ -998,6 +1021,7 @@ public class PduPersister { + "content://mms/drafts, content://mms/outbox, " + "content://mms/temp."); } + PDU_CACHE_INSTANCE.purge(uri); PduHeaders header = pdu.getPduHeaders(); PduBody body = null; diff --git a/core/java/com/google/android/net/GoogleHttpClient.java b/core/java/com/google/android/net/GoogleHttpClient.java index 922f5be..8a1298f 100644 --- a/core/java/com/google/android/net/GoogleHttpClient.java +++ b/core/java/com/google/android/net/GoogleHttpClient.java @@ -58,8 +58,8 @@ import java.net.URISyntaxException; * and otherwise tweak HTTP requests. */ public class GoogleHttpClient implements HttpClient { - private static final String TAG = "GoogleHttpClient"; + private static final boolean LOCAL_LOGV = Config.LOGV || false; /** Exception thrown when a request is blocked by the URL rules. */ public static class BlockedRequestException extends IOException { @@ -289,9 +289,7 @@ public class GoogleHttpClient implements HttpClient { wrapper.setURI(uri); request = wrapper; - if (Config.LOGV) { - Log.v(TAG, "Rule " + rule.mName + ": " + original + " -> " + rewritten); - } + if (LOCAL_LOGV) Log.v(TAG, "Rule " + rule.mName + ": " + original + " -> " + rewritten); return executeWithoutRewriting(request, context); } diff --git a/core/java/com/google/android/net/UrlRules.java b/core/java/com/google/android/net/UrlRules.java index c269d1b..54d139d 100644 --- a/core/java/com/google/android/net/UrlRules.java +++ b/core/java/com/google/android/net/UrlRules.java @@ -20,6 +20,7 @@ import android.content.ContentResolver; import android.database.Cursor; import android.provider.Checkin; import android.provider.Settings; +import android.util.Config; import android.util.Log; import java.util.ArrayList; @@ -53,6 +54,9 @@ import java.util.regex.Pattern; * </pre> */ public class UrlRules { + public static final String TAG = "UrlRules"; + public static final boolean LOCAL_LOGV = Config.LOGV || false; + /** Thrown when the rewrite rules can't be parsed. */ public static class RuleFormatException extends Exception { public RuleFormatException(String msg) { super(msg); } @@ -192,10 +196,11 @@ public class UrlRules { Settings.Gservices.PROVISIONING_DIGEST); if (sCachedDigest != null && sCachedDigest.equals(digest)) { // The digest is the same, so the rules are the same. + if (LOCAL_LOGV) Log.v(TAG, "Using cached rules for digest: " + digest); return sCachedRules; } - // Get all the Gservices settings with names starting with "url:". + if (LOCAL_LOGV) Log.v(TAG, "Scanning for Gservices \"url:*\" rules"); Cursor cursor = resolver.query(Settings.Gservices.CONTENT_URI, new String[] { Settings.Gservices.NAME, @@ -210,16 +215,18 @@ public class UrlRules { String name = cursor.getString(0).substring(4); // "url:X" String value = cursor.getString(1); if (value == null || value.length() == 0) continue; + if (LOCAL_LOGV) Log.v(TAG, " Rule " + name + ": " + value); rules.add(new Rule(name, value)); } catch (RuleFormatException e) { // Oops, Gservices has an invalid rule! Skip it. - Log.e("UrlRules", "Invalid rule from Gservices", e); + Log.e(TAG, "Invalid rule from Gservices", e); Checkin.logEvent(resolver, Checkin.Events.Tag.GSERVICES_ERROR, e.toString()); } } sCachedRules = new UrlRules(rules.toArray(new Rule[rules.size()])); sCachedDigest = digest; + if (LOCAL_LOGV) Log.v(TAG, "New rules stored for digest: " + digest); } finally { cursor.close(); } |