Java tutorial
/* * Copyright (C) 2013 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 es.example.contacts.ui; import android.annotation.SuppressLint; import android.annotation.TargetApi; import android.content.ContentProviderOperation; import android.content.ContentProviderResult; import android.content.ContentResolver; import android.content.Intent; import android.content.pm.PackageManager; import android.content.res.AssetFileDescriptor; import android.database.Cursor; import android.graphics.Bitmap; import android.net.Uri; import android.os.Build; import android.os.Bundle; import android.os.StrictMode; import android.provider.ContactsContract; import android.provider.ContactsContract.CommonDataKinds.StructuredPostal; import android.provider.ContactsContract.Contacts; import android.provider.ContactsContract.Contacts.Photo; import android.provider.ContactsContract.Data; import android.support.v4.app.Fragment; import android.support.v4.app.LoaderManager; import android.support.v4.content.CursorLoader; import android.support.v4.content.Loader; import android.util.DisplayMetrics; import android.util.Log; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; import android.view.MenuItem; import android.view.View; import android.view.ViewGroup; import android.widget.ImageButton; import android.widget.ImageView; import android.widget.LinearLayout; import android.widget.SeekBar; import android.widget.TextView; import android.widget.Toast; import es.example.contacts.BuildConfig; import es.example.contacts.R; import es.example.contacts.util.ImageLoader; import es.example.contacts.util.Utils; import java.io.FileNotFoundException; import java.io.IOException; import java.util.ArrayList; /** * This fragment displays details of a specific contact from the contacts provider. It shows the * contact's display photo, name and all its mailing addresses. You can also modify this fragment * to show other information, such as phone numbers, email addresses and so forth. * * This fragment appears full-screen in an activity on devices with small screen sizes, and as * part of a two-pane layout on devices with larger screens, alongside the * {@link ContactsListFragment}. * * To create an instance of this fragment, use the factory method * {@link ContactDetailFragment#newInstance(android.net.Uri)}, passing as an argument the contact * Uri for the contact you want to display. */ public class ContactDetailFragment extends Fragment implements LoaderManager.LoaderCallbacks<Cursor> { public static final String LEVEL_MIME_TYPE = "vnd.android.cursor.item/level"; public static final String EXTRA_CONTACT_URI = "es.example.contacts.ui.EXTRA_CONTACT_URI"; // Defines a tag for identifying log entries private static final String TAG = "ContactDetailFragment"; // The geo Uri scheme prefix, used with Intent.ACTION_VIEW to form a geographical address // intent that will trigger available apps to handle viewing a location (such as Maps) private static final String GEO_URI_SCHEME_PREFIX = "geo:0,0?q="; // Whether or not this fragment is showing in a two pane layout private boolean mIsTwoPaneLayout; private Uri mContactUri; // Stores the contact Uri for this fragment instance private ImageLoader mImageLoader; // Handles loading the contact image in a background thread // Used to store references to key views, layouts and menu items as these need to be updated // in multiple methods throughout this class. private ImageView mImageView; private LinearLayout mDetailsLayout; private TextView mEmptyView; private TextView mContactName; private MenuItem mEditContactMenuItem; /** * Factory method to generate a new instance of the fragment given a contact Uri. A factory * method is preferable to simply using the constructor as it handles creating the bundle and * setting the bundle as an argument. * * @param contactUri The contact Uri to load * @return A new instance of {@link ContactDetailFragment} */ public static ContactDetailFragment newInstance(Uri contactUri) { // Create new instance of this fragment final ContactDetailFragment fragment = new ContactDetailFragment(); // Create and populate the args bundle final Bundle args = new Bundle(); args.putParcelable(EXTRA_CONTACT_URI, contactUri); // Assign the args bundle to the new fragment fragment.setArguments(args); // Return fragment return fragment; } /** * Fragments require an empty constructor. */ public ContactDetailFragment() { } /** * Sets the contact that this Fragment displays, or clears the display if the contact argument * is null. This will re-initialize all the views and start the queries to the system contacts * provider to populate the contact information. * * @param contactLookupUri The contact lookup Uri to load and display in this fragment. Passing * null is valid and the fragment will display a message that no * contact is currently selected instead. */ public void setContact(Uri contactLookupUri) { // In version 3.0 and later, stores the provided contact lookup Uri in a class field. This // Uri is then used at various points in this class to map to the provided contact. if (Utils.hasHoneycomb()) { mContactUri = contactLookupUri; } else { // For versions earlier than Android 3.0, stores a contact Uri that's constructed from // contactLookupUri. Later on, the resulting Uri is combined with // Contacts.Data.CONTENT_DIRECTORY to map to the provided contact. It's done // differently for these earlier versions because Contacts.Data.CONTENT_DIRECTORY works // differently for Android versions before 3.0. mContactUri = Contacts.lookupContact(getActivity().getContentResolver(), contactLookupUri); } // If the Uri contains data, load the contact's image and load contact details. if (contactLookupUri != null) { // Asynchronously loads the contact image mImageLoader.loadImage(mContactUri, mImageView); // Shows the contact photo ImageView and hides the empty view mImageView.setVisibility(View.VISIBLE); mEmptyView.setVisibility(View.GONE); // Shows the edit contact action/menu item if (mEditContactMenuItem != null) { mEditContactMenuItem.setVisible(true); } // Starts two queries to to retrieve contact information from the Contacts Provider. // restartLoader() is used instead of initLoader() as this method may be called // multiple times. getLoaderManager().restartLoader(ContactDetailQuery.QUERY_ID, null, this); getLoaderManager().restartLoader(ContactAddressQuery.QUERY_ID, null, this); } else { // If contactLookupUri is null, then the method was called when no contact was selected // in the contacts list. This should only happen in a two-pane layout when the user // hasn't yet selected a contact. Don't display an image for the contact, and don't // account for the view's space in the layout. Turn on the TextView that appears when // the layout is empty, and set the contact name to the empty string. Turn off any menu // items that are visible. mImageView.setVisibility(View.GONE); mEmptyView.setVisibility(View.VISIBLE); mDetailsLayout.removeAllViews(); if (mContactName != null) { mContactName.setText(""); } if (mEditContactMenuItem != null) { mEditContactMenuItem.setVisible(false); } } } /** * When the Fragment is first created, this callback is invoked. It initializes some key * class fields. */ @Override public void onCreate(Bundle savedInstanceState) { StrictMode.setThreadPolicy( new StrictMode.ThreadPolicy.Builder().detectDiskReads().detectDiskWrites().detectNetwork() // or .detectAll() for all detectable problems .penaltyLog().build()); StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder().detectLeakedSqlLiteObjects() .detectLeakedClosableObjects().penaltyLog().penaltyDeath().build()); super.onCreate(savedInstanceState); // Check if this fragment is part of a two pane set up or a single pane mIsTwoPaneLayout = getResources().getBoolean(R.bool.has_two_panes); // Let this fragment contribute menu items setHasOptionsMenu(true); /* * The ImageLoader takes care of loading and resizing images asynchronously into the * ImageView. More thorough sample code demonstrating background image loading as well as * details on how it works can be found in the following Android Training class: * http://developer.android.com/training/displaying-bitmaps/ */ mImageLoader = new ImageLoader(getActivity(), getLargestScreenDimension()) { @Override protected Bitmap processBitmap(Object data) { // This gets called in a background thread and passed the data from // ImageLoader.loadImage(). return loadContactPhoto((Uri) data, getImageSize()); } }; // Set a placeholder loading image for the image loader mImageLoader.setLoadingImage(R.drawable.ic_contact_picture_180_holo_light); // Tell the image loader to set the image directly when it's finished loading // rather than fading in mImageLoader.setImageFadeIn(false); } @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { // Inflates the main layout to be used by this fragment final View detailView = inflater.inflate(R.layout.contact_detail_fragment, container, false); // Gets handles to view objects in the layout mImageView = (ImageView) detailView.findViewById(R.id.contact_image); mDetailsLayout = (LinearLayout) detailView.findViewById(R.id.contact_details_layout); mEmptyView = (TextView) detailView.findViewById(android.R.id.empty); if (mIsTwoPaneLayout) { // If this is a two pane view, the following code changes the visibility of the contact // name in details. For a one-pane view, the contact name is displayed as a title. mContactName = (TextView) detailView.findViewById(R.id.contact_name); mContactName.setVisibility(View.VISIBLE); } return detailView; } @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); // If not being created from a previous state if (savedInstanceState == null) { // Sets the argument extra as the currently displayed contact setContact(getArguments() != null ? (Uri) getArguments().getParcelable(EXTRA_CONTACT_URI) : null); } else { // If being recreated from a saved state, sets the contact from the incoming // savedInstanceState Bundle setContact((Uri) savedInstanceState.getParcelable(EXTRA_CONTACT_URI)); } } /** * When the Fragment is being saved in order to change activity state, save the * currently-selected contact. */ @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); // Saves the contact Uri outState.putParcelable(EXTRA_CONTACT_URI, mContactUri); } @Override public boolean onOptionsItemSelected(MenuItem item) { switch (item.getItemId()) { // When "edit" menu option selected case R.id.menu_edit_contact: // Standard system edit contact intent Intent intent = new Intent(Intent.ACTION_EDIT, mContactUri); // Because of an issue in Android 4.0 (API level 14), clicking Done or Back in the // People app doesn't return the user to your app; instead, it displays the People // app's contact list. A workaround, introduced in Android 4.0.3 (API level 15) is // to set a special flag in the extended data for the Intent you send to the People // app. The issue is does not appear in versions prior to Android 4.0. You can use // the flag with any version of the People app; if the workaround isn't needed, // the flag is ignored. intent.putExtra("finishActivityOnSaveCompleted", true); // Start the edit activity startActivity(intent); return true; } return super.onOptionsItemSelected(item); } @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) { super.onCreateOptionsMenu(menu, inflater); // Inflates the options menu for this fragment inflater.inflate(R.menu.contact_detail_menu, menu); // Gets a handle to the "find" menu item mEditContactMenuItem = menu.findItem(R.id.menu_edit_contact); // If contactUri is null the edit menu item should be hidden, otherwise // it is visible. mEditContactMenuItem.setVisible(mContactUri != null); } @Override public Loader<Cursor> onCreateLoader(int id, Bundle args) { switch (id) { // Two main queries to load the required information case ContactDetailQuery.QUERY_ID: // This query loads main contact details, see // ContactDetailQuery for more information. return new CursorLoader(getActivity(), mContactUri, ContactDetailQuery.PROJECTION, null, null, null); case ContactAddressQuery.QUERY_ID: // This query loads contact address details, see // ContactAddressQuery for more information. final Uri uri = Uri.withAppendedPath(mContactUri, Contacts.Data.CONTENT_DIRECTORY); return new CursorLoader(getActivity(), uri, ContactAddressQuery.PROJECTION, ContactAddressQuery.SELECTION, null, null); } return null; } String displayName; String id; @Override public void onLoadFinished(Loader<Cursor> loader, Cursor data) { // If this fragment was cleared while the query was running // eg. from from a call like setContact(uri) then don't do // anything. if (mContactUri == null) { return; } switch (loader.getId()) { case ContactDetailQuery.QUERY_ID: // Moves to the first row in the Cursor if (data.moveToFirst()) { // For the contact details query, fetches the contact display name. // ContactDetailQuery.DISPLAY_NAME maps to the appropriate display // name field based on OS version. final String contactName = data.getString(ContactDetailQuery.DISPLAY_NAME); displayName = contactName; id = data.getString(ContactDetailQuery.ID); if (mIsTwoPaneLayout && mContactName != null) { // In the two pane layout, there is a dedicated TextView // that holds the contact name. mContactName.setText(contactName); } else { // In the single pane layout, sets the activity title // to the contact name. On HC+ this will be set as // the ActionBar title text. getActivity().setTitle(contactName); } } break; case ContactAddressQuery.QUERY_ID: // This query loads the contact address details. More than // one contact address is possible, so move each one to a // LinearLayout in a Scrollview so multiple addresses can // be scrolled by the user. // Each LinearLayout has the same LayoutParams so this can // be created once and used for each address. final LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams( ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT); // Clears out the details layout first in case the details // layout has addresses from a previous data load still // added as children. mDetailsLayout.removeAllViews(); // Loops through all the rows in the Cursor if (data.moveToFirst()) { do { final Uri uri = Uri.withAppendedPath(mContactUri, ContactsContract.RawContacts.Data.CONTENT_DIRECTORY); ContentResolver cr = getActivity().getContentResolver(); Cursor cur = cr.query(uri, ContactPhoneQuery.PROJECTION, ContactPhoneQuery.SELECTION, null, null); try { if (cur.moveToFirst()) { // Builds the address layout final Uri uriData = Uri.parse("content://com.android.contacts/data"); Cursor curData = cr.query(Data.CONTENT_URI, ContactData1Query.PROJECTION, ContactData1Query.SELECTION, null, null); try { if (curData.getCount() == 0) { final LinearLayout layout = buildAddressLayout( data.getInt(ContactAddressQuery.TYPE), data.getString(ContactAddressQuery.LABEL), data.getString(ContactAddressQuery.ADDRESS), cur.getString(ContactPhoneQuery.PHONE), null, data.getString(ContactAddressQuery.CONTACT_ID), displayName); // Adds the new address layout to the details layout mDetailsLayout.addView(layout, layoutParams); } else { if (curData.moveToFirst()) { final LinearLayout layout = buildAddressLayout( curData.getInt(ContactAddressQuery.ID), data.getString(ContactAddressQuery.LABEL), data.getString(ContactAddressQuery.ADDRESS), cur.getString(ContactPhoneQuery.PHONE), curData.getString(ContactData1Query.DATA1), data.getString(ContactAddressQuery.CONTACT_ID), displayName); // Adds the new address layout to the details layout mDetailsLayout.addView(layout, layoutParams); } } } finally { if (curData != null) curData.close(); } } } finally { if (cur != null) cur.close(); } } while (data.moveToNext()); data.close(); } else { // If nothing found, adds an empty address layout mDetailsLayout.addView(buildEmptyAddressLayout(), layoutParams); } break; } } @Override public void onLoaderReset(Loader<Cursor> loader) { // Nothing to do here. The Cursor does not need to be released as it was never directly // bound to anything (like an adapter). } /** * Builds an empty address layout that just shows that no addresses * were found for this contact. * * @return A LinearLayout to add to the contact details layout */ private LinearLayout buildEmptyAddressLayout() { return buildAddressLayout(0, null, null, null, null, null, null); } /** * Builds an address LinearLayout based on address information from the Contacts Provider. * Each address for the contact gets its own LinearLayout object; for example, if the contact * has three postal addresses, then 3 LinearLayouts are generated. * * @param addressType From * {@link android.provider.ContactsContract.CommonDataKinds.StructuredPostal#TYPE} * @param addressTypeLabel From * {@link android.provider.ContactsContract.CommonDataKinds.StructuredPostal#LABEL} * @param address From * {@link android.provider.ContactsContract.CommonDataKinds.StructuredPostal#FORMATTED_ADDRESS} * @param phone From * {@link android.provider.ContactsContract.CommonDataKinds.Phone#NUMBER} * @param data1 From * {@link android.provider.ContactsContract.Data#DATA1} * @param _id From * {@link android.provider.ContactsContract#} * @return A LinearLayout to add to the contact details layout, * populated with the provided address details. */ private LinearLayout buildAddressLayout(int addressType, String addressTypeLabel, final String address, final String phone, final String data1, final String _id, final String _name) { // Inflates the address layout final LinearLayout addressLayout = (LinearLayout) LayoutInflater.from(getActivity()) .inflate(R.layout.contact_detail_item, mDetailsLayout, false); // Gets handles to the view objects in the layout final TextView headerTextView = (TextView) addressLayout.findViewById(R.id.contact_detail_header); final TextView addressTextView = (TextView) addressLayout.findViewById(R.id.contact_detail_item); final ImageButton viewAddressButton = (ImageButton) addressLayout.findViewById(R.id.button_view_address); final TextView phoneTextView = (TextView) addressLayout.findViewById(R.id.contact_phone); final SeekBar levelSeekBar = (SeekBar) addressLayout.findViewById(R.id.contact_level); final ImageButton saveButton = (ImageButton) addressLayout.findViewById(R.id.button_save); Integer prioridad = Integer.parseInt(data1 == null ? "4" : data1); // If there's no addresses for the contact, shows the empty view and message, and hides the // header and button. if (addressTypeLabel == null && addressType == 0 && phone == null) { headerTextView.setVisibility(View.GONE); viewAddressButton.setVisibility(View.GONE); addressTextView.setText(R.string.no_address); } else { // Gets postal address label type CharSequence label = StructuredPostal.getTypeLabel(getResources(), addressType, addressTypeLabel); // Sets TextView objects in the layout headerTextView.setText(label); addressTextView.setText(address); phoneTextView.setText(phone); levelSeekBar.setProgress(prioridad); // Defines an onClickListener object for the address button viewAddressButton.setOnClickListener(new View.OnClickListener() { // Defines what to do when users click the address button @Override public void onClick(View view) { final Intent viewIntent = new Intent(Intent.ACTION_VIEW, constructGeoUri(address)); // A PackageManager instance is needed to verify that there's a default app // that handles ACTION_VIEW and a geo Uri. final PackageManager packageManager = getActivity().getPackageManager(); // Checks for an activity that can handle this intent. Preferred in this // case over Intent.createChooser() as it will still let the user choose // a default (or use a previously set default) for geo Uris. if (packageManager.resolveActivity(viewIntent, PackageManager.MATCH_DEFAULT_ONLY) != null) { startActivity(viewIntent); } else { // If no default is found, displays a message that no activity can handle // the view button. Toast.makeText(getActivity(), R.string.no_intent_found, Toast.LENGTH_SHORT).show(); } } }); // Defines an onClickListener object for the save button saveButton.setOnClickListener(new View.OnClickListener() { // Defines what to do when users click the address button @Override public void onClick(View view) { // Creates a new intent for sending to the device's contacts application // Creates a new array of ContentProviderOperation objects. ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>(); Integer prioridad = levelSeekBar.getProgress(); Log.d("ContactDetalFragment", _id); ContentProviderOperation.Builder op; if (data1 == null) { Uri uri = addCallerIsSyncAdapterParameter(Data.CONTENT_URI, true); ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI) .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, null) .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, null).build()); ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI) .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0) .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE) .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, _name) .build()); op = ContentProviderOperation.newInsert(Data.CONTENT_URI) .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0) .withValue(Data.DATA1, prioridad).withValue(Data.MIMETYPE, LEVEL_MIME_TYPE); } else { String where = Data.MIMETYPE + " = ? "; String[] params = new String[] { LEVEL_MIME_TYPE, }; op = ContentProviderOperation.newUpdate(Data.CONTENT_URI).withSelection(where, params) .withValue(Data.DATA1, prioridad); } ops.add(op.build()); try { ContentProviderResult[] results = view.getContext().getContentResolver() .applyBatch(ContactsContract.AUTHORITY, ops); } catch (Exception e) { CharSequence txt = getString(R.string.contactUpdateFailure); int duration = Toast.LENGTH_SHORT; Toast toast = Toast.makeText(view.getContext(), txt, duration); toast.show(); // Log exception Log.e(TAG, "Exception encountered while inserting contact: " + e); } } }); } return addressLayout; } private static Uri addCallerIsSyncAdapterParameter(Uri uri, boolean isSyncOperation) { if (isSyncOperation) { return uri.buildUpon().appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true").build(); } return uri; } /** * Constructs a geo scheme Uri from a postal address. * * @param postalAddress A postal address. * @return the geo:// Uri for the postal address. */ private Uri constructGeoUri(String postalAddress) { // Concatenates the geo:// prefix to the postal address. The postal address must be // converted to Uri format and encoded for special characters. return Uri.parse(GEO_URI_SCHEME_PREFIX + Uri.encode(postalAddress)); } /** * Fetches the width or height of the screen in pixels, whichever is larger. This is used to * set a maximum size limit on the contact photo that is retrieved from the Contacts Provider. * This limit prevents the app from trying to decode and load an image that is much larger than * the available screen area. * * @return The largest screen dimension in pixels. */ private int getLargestScreenDimension() { // Gets a DisplayMetrics object, which is used to retrieve the display's pixel height and // width final DisplayMetrics displayMetrics = new DisplayMetrics(); // Retrieves a displayMetrics object for the device's default display getActivity().getWindowManager().getDefaultDisplay().getMetrics(displayMetrics); final int height = displayMetrics.heightPixels; final int width = displayMetrics.widthPixels; // Returns the larger of the two values return height > width ? height : width; } /** * Decodes and returns the contact's thumbnail image. * @param contactUri The Uri of the contact containing the image. * @param imageSize The desired target width and height of the output image in pixels. * @return If a thumbnail image exists for the contact, a Bitmap image, otherwise null. */ @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH) private Bitmap loadContactPhoto(Uri contactUri, int imageSize) { // Ensures the Fragment is still added to an activity. As this method is called in a // background thread, there's the possibility the Fragment is no longer attached and // added to an activity. If so, no need to spend resources loading the contact photo. if (!isAdded() || getActivity() == null) { return null; } // Instantiates a ContentResolver for retrieving the Uri of the image final ContentResolver contentResolver = getActivity().getContentResolver(); // Instantiates an AssetFileDescriptor. Given a content Uri pointing to an image file, the // ContentResolver can return an AssetFileDescriptor for the file. AssetFileDescriptor afd = null; if (Utils.hasICS()) { // On platforms running Android 4.0 (API version 14) and later, a high resolution image // is available from Photo.DISPLAY_PHOTO. try { // Constructs the content Uri for the image Uri displayImageUri = Uri.withAppendedPath(contactUri, Photo.DISPLAY_PHOTO); // Retrieves an AssetFileDescriptor from the Contacts Provider, using the // constructed Uri afd = contentResolver.openAssetFileDescriptor(displayImageUri, "r"); // If the file exists if (afd != null) { // Reads and decodes the file to a Bitmap and scales it to the desired size return ImageLoader.decodeSampledBitmapFromDescriptor(afd.getFileDescriptor(), imageSize, imageSize); } } catch (FileNotFoundException e) { // Catches file not found exceptions if (BuildConfig.DEBUG) { // Log debug message, this is not an error message as this exception is thrown // when a contact is legitimately missing a contact photo (which will be quite // frequently in a long contacts list). Log.d(TAG, "Contact photo not found for contact " + contactUri.toString() + ": " + e.toString()); } } finally { // Once the decode is complete, this closes the file. You must do this each time // you access an AssetFileDescriptor; otherwise, every image load you do will open // a new descriptor. if (afd != null) { try { afd.close(); } catch (IOException e) { // Closing a file descriptor might cause an IOException if the file is // already closed. Nothing extra is needed to handle this. } } } } // If the platform version is less than Android 4.0 (API Level 14), use the only available // image URI, which points to a normal-sized image. try { // Constructs the image Uri from the contact Uri and the directory twig from the // Contacts.Photo table Uri imageUri = Uri.withAppendedPath(contactUri, Photo.CONTENT_DIRECTORY); // Retrieves an AssetFileDescriptor from the Contacts Provider, using the constructed // Uri afd = getActivity().getContentResolver().openAssetFileDescriptor(imageUri, "r"); // If the file exists if (afd != null) { // Reads the image from the file, decodes it, and scales it to the available screen // area return ImageLoader.decodeSampledBitmapFromDescriptor(afd.getFileDescriptor(), imageSize, imageSize); } } catch (FileNotFoundException e) { // Catches file not found exceptions if (BuildConfig.DEBUG) { // Log debug message, this is not an error message as this exception is thrown // when a contact is legitimately missing a contact photo (which will be quite // frequently in a long contacts list). Log.d(TAG, "Contact photo not found for contact " + contactUri.toString() + ": " + e.toString()); } } finally { // Once the decode is complete, this closes the file. You must do this each time you // access an AssetFileDescriptor; otherwise, every image load you do will open a new // descriptor. if (afd != null) { try { afd.close(); } catch (IOException e) { // Closing a file descriptor might cause an IOException if the file is // already closed. Ignore this. } } } // If none of the case selectors match, returns null. return null; } /** * This interface defines constants used by contact retrieval queries. */ public interface ContactDetailQuery { // A unique query ID to distinguish queries being run by the // LoaderManager. final static int QUERY_ID = 1; // The query projection (columns to fetch from the provider) @SuppressLint("InlinedApi") final static String[] PROJECTION = { Contacts._ID, Utils.hasHoneycomb() ? Contacts.DISPLAY_NAME_PRIMARY : Contacts.DISPLAY_NAME, }; // The query column numbers which map to each value in the projection final static int ID = 0; final static int DISPLAY_NAME = 1; } /** * This interface defines constants used by address retrieval queries. */ public interface ContactAddressQuery { // A unique query ID to distinguish queries being run by the // LoaderManager. final static int QUERY_ID = 2; // The query projection (columns to fetch from the provider) final static String[] PROJECTION = { StructuredPostal._ID, StructuredPostal.FORMATTED_ADDRESS, StructuredPostal.TYPE, StructuredPostal.LABEL, StructuredPostal.CONTACT_ID, }; // The query selection criteria. In this case matching against the // StructuredPostal content mime type. final static String SELECTION = Data.MIMETYPE + "='" + StructuredPostal.CONTENT_ITEM_TYPE + "'"; // The query column numbers which map to each value in the projection final static int ID = 0; final static int ADDRESS = 1; final static int TYPE = 2; final static int LABEL = 3; final static int CONTACT_ID = 4; } /** * This interface defines constants used by address retrieval queries. */ public interface ContactPhoneQuery { // A unique query ID to distinguish queries being run by the // LoaderManager. final static int QUERY_ID = 3; // The query projection (columns to fetch from the provider) final static String[] PROJECTION = { ContactsContract.CommonDataKinds.Phone._ID, ContactsContract.CommonDataKinds.Phone.NUMBER }; // The query selection criteria. In this case matching against the // StructuredPostal content mime type. final static String SELECTION = Data.MIMETYPE + "='" + ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE + "'"; // The query column numbers which map to each value in the projection final static int ID = 0; final static int PHONE = 1; } /** * This interface defines constants used by address retrieval queries. */ public interface ContactData1Query { // A unique query ID to distinguish queries being run by the // LoaderManager. final static int QUERY_ID = 4; // The query projection (columns to fetch from the provider) final static String[] PROJECTION = { Data._ID, Data.DATA1 }; // The query selection criteria. In this case matching against the // content mime type. final static String SELECTION = Data.MIMETYPE + "='" + LEVEL_MIME_TYPE + "' "; // The query column numbers which map to each value in the projection final static int ID = 0; final static int DATA1 = 1; } }