Java tutorial
/* * Copyright (C) 2006 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.contacts.activities; import android.app.Activity; import android.content.ActivityNotFoundException; import android.content.ContentResolver; import android.content.ContentValues; import android.content.Intent; import android.content.Loader; import android.content.Loader.OnLoadCompleteListener; import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.database.Cursor; import android.graphics.Bitmap; import android.net.Uri; import android.os.Bundle; import android.provider.ContactsContract.CommonDataKinds.Photo; import android.provider.ContactsContract.Contacts; import android.provider.ContactsContract.DisplayPhoto; import android.provider.ContactsContract.Intents; import android.provider.ContactsContract.RawContacts; import android.util.Log; import android.widget.Toast; import com.android.contacts.ContactSaveService; import com.android.contacts.ContactsActivity; import com.android.contacts.ContactsUtils; import com.android.contacts.R; import com.android.contacts.editor.ContactEditorUtils; import com.android.contacts.model.AccountTypeManager; import com.android.contacts.model.Contact; import com.android.contacts.model.ContactLoader; import com.android.contacts.model.RawContactDelta; import com.android.contacts.model.RawContactDeltaList; import com.android.contacts.model.RawContactModifier; import com.android.contacts.model.ValuesDelta; import com.android.contacts.model.account.AccountInfo; import com.android.contacts.model.account.AccountType; import com.android.contacts.model.account.AccountWithDataSet; import com.android.contacts.util.ContactPhotoUtils; import com.google.common.base.Preconditions; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; import java.io.FileNotFoundException; import java.util.List; /** * Provides an external interface for other applications to attach images * to contacts. It will first present a contact picker and then run the * image that is handed to it through the cropper to make the image the proper * size and give the user a chance to use the face detector. */ public class AttachPhotoActivity extends ContactsActivity { private static final String TAG = AttachPhotoActivity.class.getSimpleName(); private static final int REQUEST_PICK_CONTACT = 1; private static final int REQUEST_CROP_PHOTO = 2; private static final int REQUEST_PICK_DEFAULT_ACCOUNT_FOR_NEW_CONTACT = 3; private static final String KEY_CONTACT_URI = "contact_uri"; private static final String KEY_TEMP_PHOTO_URI = "temp_photo_uri"; private static final String KEY_CROPPED_PHOTO_URI = "cropped_photo_uri"; private Uri mTempPhotoUri; private Uri mCroppedPhotoUri; private ContentResolver mContentResolver; private ListenableFuture<List<AccountInfo>> mAccountsFuture; // Height and width (in pixels) to request for the photo - queried from the provider. private static int mPhotoDim; // Default photo dimension to use if unable to query the provider. private static final int mDefaultPhotoDim = 720; private Uri mContactUri; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); if (RequestPermissionsActivity.startPermissionActivityIfNeeded(this)) { return; } if (icicle != null) { final String uri = icicle.getString(KEY_CONTACT_URI); mContactUri = (uri == null) ? null : Uri.parse(uri); mTempPhotoUri = Uri.parse(icicle.getString(KEY_TEMP_PHOTO_URI)); mCroppedPhotoUri = Uri.parse(icicle.getString(KEY_CROPPED_PHOTO_URI)); } else { mTempPhotoUri = ContactPhotoUtils.generateTempImageUri(this); mCroppedPhotoUri = ContactPhotoUtils.generateTempCroppedImageUri(this); Intent intent = new Intent(Intent.ACTION_PICK); intent.setType(Contacts.CONTENT_TYPE); intent.setPackage(getPackageName()); startActivityForResult(intent, REQUEST_PICK_CONTACT); } mContentResolver = getContentResolver(); // Load the photo dimension to request. mPhotoDim is a static class // member varible so only need to load this if this is the first time // through. if (mPhotoDim == 0) { Cursor c = mContentResolver.query(DisplayPhoto.CONTENT_MAX_DIMENSIONS_URI, new String[] { DisplayPhoto.DISPLAY_MAX_DIM }, null, null, null); if (c != null) { try { if (c.moveToFirst()) { mPhotoDim = c.getInt(0); } } finally { c.close(); } } } // Start loading accounts in case they are needed. mAccountsFuture = AccountTypeManager.getInstance(this) .filterAccountsAsync(AccountTypeManager.writableFilter()); } @Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); if (mContactUri != null) { outState.putString(KEY_CONTACT_URI, mContactUri.toString()); } if (mTempPhotoUri != null) { outState.putString(KEY_TEMP_PHOTO_URI, mTempPhotoUri.toString()); } if (mCroppedPhotoUri != null) { outState.putString(KEY_CROPPED_PHOTO_URI, mCroppedPhotoUri.toString()); } } @Override protected void onActivityResult(int requestCode, int resultCode, Intent result) { if (requestCode == REQUEST_PICK_DEFAULT_ACCOUNT_FOR_NEW_CONTACT) { // Bail if the account selector was not successful. if (resultCode != Activity.RESULT_OK) { Log.w(TAG, "account selector was not successful"); finish(); return; } // If there's an account specified, use it. if (result != null) { AccountWithDataSet account = result.getParcelableExtra(Intents.Insert.EXTRA_ACCOUNT); if (account != null) { createNewRawContact(account); return; } } // If there isn't an account specified, then the user opted to keep the contact local. createNewRawContact(null); } else if (requestCode == REQUEST_PICK_CONTACT) { if (resultCode != RESULT_OK) { finish(); return; } // A contact was picked. Launch the cropper to get face detection, the right size, etc. // TODO: get these values from constants somewhere final Intent myIntent = getIntent(); final Uri inputUri = myIntent.getData(); // Save the URI into a temporary file provider URI so that // we can add the FLAG_GRANT_WRITE_URI_PERMISSION flag to the eventual // crop intent for read-only URI's. // TODO: With b/10837468 fixed should be able to avoid this copy. if (!ContactPhotoUtils.savePhotoFromUriToUri(this, inputUri, mTempPhotoUri, false)) { finish(); return; } final Intent intent = new Intent("com.android.camera.action.CROP", mTempPhotoUri); if (myIntent.getStringExtra("mimeType") != null) { intent.setDataAndType(mTempPhotoUri, myIntent.getStringExtra("mimeType")); } ContactPhotoUtils.addPhotoPickerExtras(intent, mCroppedPhotoUri); ContactPhotoUtils.addCropExtras(intent, mPhotoDim != 0 ? mPhotoDim : mDefaultPhotoDim); if (!hasIntentHandler(intent)) { // No activity supports the crop action. So skip cropping and set the photo // without performing any cropping. mCroppedPhotoUri = mTempPhotoUri; mContactUri = result.getData(); loadContact(mContactUri, new Listener() { @Override public void onContactLoaded(Contact contact) { saveContact(contact); } }); return; } try { startActivityForResult(intent, REQUEST_CROP_PHOTO); } catch (ActivityNotFoundException ex) { Toast.makeText(this, R.string.missing_app, Toast.LENGTH_SHORT).show(); return; } mContactUri = result.getData(); } else if (requestCode == REQUEST_CROP_PHOTO) { // Delete the temporary photo from cache now that we have a cropped version. // We should do this even if the crop failed and we eventually bail getContentResolver().delete(mTempPhotoUri, null, null); if (resultCode != RESULT_OK) { finish(); return; } loadContact(mContactUri, new Listener() { @Override public void onContactLoaded(Contact contact) { saveContact(contact); } }); } } private boolean hasIntentHandler(Intent intent) { final List<ResolveInfo> resolveInfo = getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY); return resolveInfo != null && resolveInfo.size() > 0; } // TODO: consider moving this to ContactLoader, especially if we keep adding similar // code elsewhere (ViewNotificationService is another case). The only concern is that, // although this is convenient, it isn't quite as robust as using LoaderManager... for // instance, the loader doesn't persist across Activity restarts. private void loadContact(Uri contactUri, final Listener listener) { final ContactLoader loader = new ContactLoader(this, contactUri, true); loader.registerListener(0, new OnLoadCompleteListener<Contact>() { @Override public void onLoadComplete(Loader<Contact> loader, Contact contact) { try { loader.reset(); } catch (RuntimeException e) { Log.e(TAG, "Error resetting loader", e); } listener.onContactLoaded(contact); } }); loader.startLoading(); } private interface Listener { public void onContactLoaded(Contact contact); } /** * If prerequisites have been met, attach the photo to a raw-contact and save. * The prerequisites are: * - photo has been cropped * - contact has been loaded */ private void saveContact(Contact contact) { if (contact.getRawContacts() == null) { Log.w(TAG, "No raw contacts found for contact"); finish(); return; } // Obtain the raw-contact that we will save to. RawContactDeltaList deltaList = contact.createRawContactDeltaList(); RawContactDelta raw = deltaList.getFirstWritableRawContact(this); if (raw == null) { // We can't directly insert this photo since no raw contacts exist in the contact. selectAccountAndCreateContact(); return; } saveToContact(contact, deltaList, raw); } private void saveToContact(Contact contact, RawContactDeltaList deltaList, RawContactDelta raw) { // Create a scaled, compressed bitmap to add to the entity-delta list. final int size = ContactsUtils.getThumbnailSize(this); Bitmap bitmap; try { bitmap = ContactPhotoUtils.getBitmapFromUri(this, mCroppedPhotoUri); } catch (FileNotFoundException e) { Log.w(TAG, "Could not find bitmap"); finish(); return; } if (bitmap == null) { Log.w(TAG, "Could not decode bitmap"); finish(); return; } final Bitmap scaled = Bitmap.createScaledBitmap(bitmap, size, size, false); final byte[] compressed = ContactPhotoUtils.compressBitmap(scaled); if (compressed == null) { Log.w(TAG, "could not create scaled and compressed Bitmap"); finish(); return; } // Add compressed bitmap to entity-delta... this allows us to save to // a new contact; otherwise the entity-delta-list would be empty, and // the ContactSaveService would not create the new contact, and the // full-res photo would fail to be saved to the non-existent contact. AccountType account = raw.getRawContactAccountType(this); ValuesDelta values = RawContactModifier.ensureKindExists(raw, account, Photo.CONTENT_ITEM_TYPE); if (values == null) { Log.w(TAG, "cannot attach photo to this account type"); finish(); return; } values.setPhoto(compressed); // Finally, invoke the ContactSaveService. if (Log.isLoggable(TAG, Log.VERBOSE)) { Log.v(TAG, "all prerequisites met, about to save photo to contact"); } Intent intent = ContactSaveService.createSaveContactIntent(this, deltaList, "", 0, contact.isUserProfile(), null, null, raw.getRawContactId() != null ? raw.getRawContactId() : -1, mCroppedPhotoUri); ContactSaveService.startService(this, intent); finish(); } private void selectAccountAndCreateContact() { Preconditions.checkNotNull(mAccountsFuture, "Accounts future must be initialized first"); // If there is no default account or the accounts have changed such that we need to // prompt the user again, then launch the account prompt. final ContactEditorUtils editorUtils = ContactEditorUtils.create(this); // Technically this could block but in reality this method won't be called until the user // presses the save button which should allow plenty of time for the accounts to // finish loading. Note also that this could be stale if the accounts have changed since // we requested them but that's OK since ContactEditorAccountsChangedActivity will reload // the accounts final List<AccountInfo> accountInfos = Futures.getUnchecked(mAccountsFuture); final List<AccountWithDataSet> accounts = AccountInfo.extractAccounts(accountInfos); if (editorUtils.shouldShowAccountChangedNotification(accounts)) { Intent intent = new Intent(this, ContactEditorAccountsChangedActivity.class) .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP); startActivityForResult(intent, REQUEST_PICK_DEFAULT_ACCOUNT_FOR_NEW_CONTACT); } else { // Otherwise, there should be a default account. Then either create a null contact // (if default account is null) or create a contact with the specified account. final AccountWithDataSet targetAccount = editorUtils.getOnlyOrDefaultAccount(accounts); createNewRawContact(targetAccount); } } /** * Create a new writeable raw contact to store mCroppedPhotoUri. */ private void createNewRawContact(final AccountWithDataSet account) { // Reload the contact from URI instead of trying to pull the contact from a member variable, // since this function can be called after the activity stops and resumes. loadContact(mContactUri, new Listener() { @Override public void onContactLoaded(Contact contactToSave) { final RawContactDeltaList deltaList = contactToSave.createRawContactDeltaList(); final ContentValues after = new ContentValues(); after.put(RawContacts.ACCOUNT_TYPE, account != null ? account.type : null); after.put(RawContacts.ACCOUNT_NAME, account != null ? account.name : null); after.put(RawContacts.DATA_SET, account != null ? account.dataSet : null); final RawContactDelta newRawContactDelta = new RawContactDelta(ValuesDelta.fromAfter(after)); deltaList.add(newRawContactDelta); saveToContact(contactToSave, deltaList, newRawContactDelta); } }); } }