/*
* 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.contacts.quickcontact;
import com.android.contacts.Collapser;
import com.android.contacts.ContactPhotoManager;
import com.android.contacts.R;
import com.android.contacts.model.AccountTypeManager;
import com.android.contacts.model.DataKind;
import com.android.contacts.util.DataStatus;
import com.android.contacts.util.NotifyingAsyncQueryHandler;
import com.android.contacts.util.NotifyingAsyncQueryHandler.AsyncQueryListener;
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentManager;
import android.content.ActivityNotFoundException;
import android.content.ContentUris;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.AssetFileDescriptor;
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.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.provider.ContactsContract.CommonDataKinds.Email;
import android.provider.ContactsContract.CommonDataKinds.Im;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.CommonDataKinds.Photo;
import android.provider.ContactsContract.CommonDataKinds.SipAddress;
import android.provider.ContactsContract.CommonDataKinds.StructuredPostal;
import android.provider.ContactsContract.CommonDataKinds.Website;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.DisplayPhoto;
import android.provider.ContactsContract.QuickContact;
import android.provider.ContactsContract.RawContacts;
import android.support.v13.app.FragmentPagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v4.view.ViewPager.SimpleOnPageChangeListener;
import android.text.TextUtils;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.HorizontalScrollView;
import android.widget.ImageButton;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
// TODO: Save selected tab index during rotation
/**
* Mostly translucent {@link Activity} that shows QuickContact dialog. It loads
* data asynchronously, and then shows a popup with details centered around
* {@link Intent#getSourceBounds()}.
*/
public class QuickContactActivity extends Activity {
private static final String TAG = "QuickContact";
private static final boolean TRACE_LAUNCH = false;
private static final String TRACE_TAG = "quickcontact";
@SuppressWarnings("deprecation")
private static final String LEGACY_AUTHORITY = android.provider.Contacts.AUTHORITY;
private NotifyingAsyncQueryHandler mHandler;
private Uri mLookupUri;
private String[] mExcludeMimes;
private List<String> mSortedActionMimeTypes = Lists.newArrayList();
private boolean mHasFinishedAnimatingIn = false;
private boolean mHasStartedAnimatingOut = false;
private FloatingChildLayout mFloatingLayout;
private View mPhotoContainer;
private ViewGroup mTrack;
private HorizontalScrollView mTrackScroller;
private View mSelectedTabRectangle;
private View mLineAfterTrack;
private ImageButton mOpenDetailsButton;
private ImageButton mOpenDetailsPushLayerButton;
private ViewPager mListPager;
/**
* Keeps the default action per mimetype. Empty if no default actions are set
*/
private HashMap<String, Action> mDefaultsMap = new HashMap<String, Action>();
/**
* Set of {@link Action} that are associated with the aggregate currently
* displayed by this dialog, represented as a map from {@link String}
* MIME-type to a list of {@link Action}.
*/
private ActionMultiMap mActions = new ActionMultiMap();
/**
* {@link #LEADING_MIMETYPES} and {@link #TRAILING_MIMETYPES} are used to sort MIME-types.
*
* <p>The MIME-types in {@link #LEADING_MIMETYPES} appear in the front of the dialog,
* in the order specified here.</p>
*
* <p>The ones in {@link #TRAILING_MIMETYPES} appear in the end of the dialog, in the order
* specified here.</p>
*
* <p>The rest go between them, in the order in the array.</p>
*/
private static final List<String> LEADING_MIMETYPES = Lists.newArrayList(
Phone.CONTENT_ITEM_TYPE, SipAddress.CONTENT_ITEM_TYPE, Email.CONTENT_ITEM_TYPE);
/** See {@link #LEADING_MIMETYPES}. */
private static final List<String> TRAILING_MIMETYPES = Lists.newArrayList(
StructuredPostal.CONTENT_ITEM_TYPE, Website.CONTENT_ITEM_TYPE);
/** Id for the background handler that loads the data */
private static final int HANDLER_ID_DATA = 1;
@Override
protected void onCreate(Bundle icicle) {
super.onCreate(icicle);
// Show QuickContact in front of soft input
getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
setContentView(R.layout.quickcontact_activity);
mFloatingLayout = (FloatingChildLayout) findViewById(R.id.floating_layout);
mTrack = (ViewGroup) findViewById(R.id.track);
mTrackScroller = (HorizontalScrollView) findViewById(R.id.track_scroller);
mOpenDetailsButton = (ImageButton) findViewById(R.id.open_details_button);
mOpenDetailsPushLayerButton = (ImageButton) findViewById(R.id.open_details_push_layer);
mListPager = (ViewPager) findViewById(R.id.item_list_pager);
mSelectedTabRectangle = findViewById(R.id.selected_tab_rectangle);
mLineAfterTrack = findViewById(R.id.line_after_track);
mFloatingLayout.setOnOutsideTouchListener(new View.OnTouchListener() {
@Override
public boolean onTouch(View v, MotionEvent event) {
return handleOutsideTouch();
}
});
final OnClickListener openDetailsClickHandler = new OnClickListener() {
@Override
public void onClick(View v) {
final Intent intent = new Intent(Intent.ACTION_VIEW, mLookupUri);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);
hide(false);
}
};
mOpenDetailsButton.setOnClickListener(openDetailsClickHandler);
mOpenDetailsPushLayerButton.setOnClickListener(openDetailsClickHandler);
mListPager.setAdapter(new ViewPagerAdapter(getFragmentManager()));
mListPager.setOnPageChangeListener(new PageChangeListener());
mHandler = new NotifyingAsyncQueryHandler(this, mQueryListener);
show();
}
private void show() {
if (TRACE_LAUNCH) {
android.os.Debug.startMethodTracing(TRACE_TAG);
}
final Intent intent = getIntent();
Uri lookupUri = intent.getData();
// Check to see whether it comes from the old version.
if (LEGACY_AUTHORITY.equals(lookupUri.getAuthority())) {
final long rawContactId = ContentUris.parseId(lookupUri);
lookupUri = RawContacts.getContactLookupUri(getContentResolver(),
ContentUris.withAppendedId(RawContacts.CONTENT_URI, rawContactId));
}
mLookupUri = Preconditions.checkNotNull(lookupUri, "missing lookupUri");
// Read requested parameters for displaying
final Rect targetScreen = intent.getSourceBounds();
Preconditions.checkNotNull(targetScreen, "missing targetScreen");
mFloatingLayout.setChildTargetScreen(targetScreen);
mExcludeMimes = intent.getStringArrayExtra(QuickContact.EXTRA_EXCLUDE_MIMES);
// find and prepare correct header view
mPhotoContainer = findViewById(R.id.photo_container);
setHeaderNameText(R.id.name, R.string.missing_name);
// Start background query for data, but only select photo rows when they
// directly match the super-primary PHOTO_ID.
final Uri dataUri = Uri.withAppendedPath(lookupUri, Contacts.Data.CONTENT_DIRECTORY);
mHandler.cancelOperation(HANDLER_ID_DATA);
// Select all data items of the contact (except for photos, where we only select the display
// photo)
mHandler.startQuery(HANDLER_ID_DATA, lookupUri, dataUri, DataQuery.PROJECTION, Data.MIMETYPE
+ "!=? OR (" + Data.MIMETYPE + "=? AND " + Data._ID + "=" + Contacts.PHOTO_ID
+ ")", new String[] { Photo.CONTENT_ITEM_TYPE, Photo.CONTENT_ITEM_TYPE }, null);
}
private boolean handleOutsideTouch() {
if (!mHasFinishedAnimatingIn) return false;
if (mHasStartedAnimatingOut) return false;
mHasStartedAnimatingOut = true;
hide(true);
return true;
}
private void hide(boolean withAnimation) {
// cancel any pending queries
mHandler.cancelOperation(HANDLER_ID_DATA);
if (withAnimation) {
mFloatingLayout.hideChild(new Runnable() {
@Override
public void run() {
finish();
}
});
} else {
mFloatingLayout.hideChild(null);
finish();
}
}
@Override
public void onBackPressed() {
hide(true);
}
private final AsyncQueryListener mQueryListener = new AsyncQueryListener() {
@Override
public synchronized void onQueryComplete(int token, Object cookie, Cursor cursor) {
try {
if (isFinishing()) {
hide(false);
return;
} else if (cursor == null || cursor.getCount() == 0) {
Toast.makeText(QuickContactActivity.this, R.string.invalidContactMessage,
Toast.LENGTH_LONG).show();
hide(false);
return;
}
bindData(cursor);
if (TRACE_LAUNCH) {
android.os.Debug.stopMethodTracing();
}
// Data bound and ready, pull curtain to show. Put this on the Handler to ensure
// that the layout passes are completed
mHandler.post(new Runnable() {
@Override
public void run() {
mFloatingLayout.showChild(new Runnable() {
@Override
public void run() {
mHasFinishedAnimatingIn = true;
}
});
}
});
} finally {
if (cursor != null) {
cursor.close();
}
}
}
};
/** Assign this string to the view if it is not empty. */
private void setHeaderNameText(int id, int resId) {
setHeaderNameText(id, getText(resId));
}
/** Assign this string to the view if it is not empty. */
private void setHeaderNameText(int id, CharSequence value) {
final View view = mPhotoContainer.findViewById(id);
if (view instanceof TextView) {
if (!TextUtils.isEmpty(value)) {
((TextView)view).setText(value);
}
}
}
/**
* Assign this string to the view (if found in {@link #mPhotoContainer}), or hiding this view
* if there is no string.
*/
private void setHeaderText(int id, int resId) {
setHeaderText(id, getText(resId));
}
/**
* Assign this string to the view (if found in {@link #mPhotoContainer}), or hiding this view
* if there is no string.
*/
private void setHeaderText(int id, CharSequence value) {
final View view = mPhotoContainer.findViewById(id);
if (view instanceof TextView) {
((TextView)view).setText(value);
view.setVisibility(TextUtils.isEmpty(value) ? View.GONE : View.VISIBLE);
}
}
/** Assign this image to the view, if found in {@link #mPhotoContainer}. */
private void setHeaderImage(int id, Drawable drawable) {
final View view = mPhotoContainer.findViewById(id);
if (view instanceof ImageView) {
((ImageView)view).setImageDrawable(drawable);
view.setVisibility(drawable == null ? View.GONE : View.VISIBLE);
}
}
/**
* Check if the given MIME-type appears in the list of excluded MIME-types
* that the most-recent caller requested.
*/
private boolean isMimeExcluded(String mimeType) {
if (mExcludeMimes == null) return false;
for (String excludedMime : mExcludeMimes) {
if (TextUtils.equals(excludedMime, mimeType)) {
return true;
}
}
return false;
}
/**
* Handle the result from the {@link #TOKEN_DATA} query.
*/
private void bindData(Cursor cursor) {
final ResolveCache cache = ResolveCache.getInstance(this);
final Context context = this;
mOpenDetailsButton.setVisibility(isMimeExcluded(Contacts.CONTENT_ITEM_TYPE) ? View.GONE
: View.VISIBLE);
mDefaultsMap.clear();
final DataStatus status = new DataStatus();
final AccountTypeManager accountTypes = AccountTypeManager.getInstance(
context.getApplicationContext());
final ImageView photoView = (ImageView) mPhotoContainer.findViewById(R.id.photo);
Bitmap photoBitmap = null;
while (cursor.moveToNext()) {
// Handle any social status updates from this row
status.possibleUpdate(cursor);
final String mimeType = cursor.getString(DataQuery.MIMETYPE);
// Skip this data item if MIME-type excluded
if (isMimeExcluded(mimeType)) continue;
final long dataId = cursor.getLong(DataQuery._ID);
final String accountType = cursor.getString(DataQuery.ACCOUNT_TYPE);
final String dataSet = cursor.getString(DataQuery.DATA_SET);
final boolean isPrimary = cursor.getInt(DataQuery.IS_PRIMARY) != 0;
final boolean isSuperPrimary = cursor.getInt(DataQuery.IS_SUPER_PRIMARY) != 0;
// Handle photos included as data row
if (Photo.CONTENT_ITEM_TYPE.equals(mimeType)) {
final int displayPhotoColumnIndex = cursor.getColumnIndex(Photo.PHOTO_FILE_ID);
final boolean hasDisplayPhoto = !cursor.isNull(displayPhotoColumnIndex);
if (hasDisplayPhoto) {
final long displayPhotoId = cursor.getLong(displayPhotoColumnIndex);
final Uri displayPhotoUri = ContentUris.withAppendedId(
DisplayPhoto.CONTENT_URI, displayPhotoId);
// Fetch and JPEG uncompress on the background thread
new AsyncTask<Void, Void, Bitmap>() {
@Override
protected Bitmap doInBackground(Void... params) {
try {
AssetFileDescriptor fd = getContentResolver()
.openAssetFileDescriptor(displayPhotoUri, "r");
return BitmapFactory.decodeStream(fd.createInputStream());
} catch (IOException e) {
Log.e(TAG, "Error getting display photo. Ignoring, as we already " +
"have the thumbnail", e);
return null;
}
}
@Override
protected void onPostExecute(Bitmap result) {
if (result == null) return;
photoView.setImageBitmap(result);
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
}
final int photoColumnIndex = cursor.getColumnIndex(Photo.PHOTO);
final byte[] photoBlob = cursor.getBlob(photoColumnIndex);
if (photoBlob != null) {
photoBitmap = BitmapFactory.decodeByteArray(photoBlob, 0, photoBlob.length);
}
continue;
}
final DataKind kind = accountTypes.getKindOrFallback(accountType, dataSet, mimeType);
if (kind != null) {
// Build an action for this data entry, find a mapping to a UI
// element, build its summary from the cursor, and collect it
// along with all others of this MIME-type.
final Action action = new DataAction(context, mimeType, kind, dataId, cursor);
final boolean wasAdded = considerAdd(action, cache);
if (wasAdded) {
// Remember the default
if (isSuperPrimary || (isPrimary && (mDefaultsMap.get(mimeType) == null))) {
mDefaultsMap.put(mimeType, action);
}
}
}
// Handle Email rows with presence data as Im entry
final boolean hasPresence = !cursor.isNull(DataQuery.PRESENCE);
if (hasPresence && Email.CONTENT_ITEM_TYPE.equals(mimeType)) {
final DataKind imKind = accountTypes.getKindOrFallback(accountType, dataSet,
Im.CONTENT_ITEM_TYPE);
if (imKind != null) {
final DataAction action = new DataAction(context, Im.CONTENT_ITEM_TYPE, imKind,
dataId, cursor);
considerAdd(action, cache);
}
}
}
// Collapse Action Lists (remove e.g. duplicate e-mail addresses from different sources)
for (List<Action> actionChildren : mActions.values()) {
Collapser.collapseList(actionChildren);
}
if (cursor.moveToLast()) {
// Read contact name from last data row
final String name = cursor.getString(DataQuery.DISPLAY_NAME);
setHeaderNameText(R.id.name, name);
}
if (photoView != null) {
// Place photo when discovered in data, otherwise show generic avatar
if (photoBitmap != null) {
photoView.setImageBitmap(photoBitmap);
} else {
photoView.setImageResource(ContactPhotoManager.getDefaultAvatarResId(true, false));
}
}
// All the mime-types to add.
final Set<String> containedTypes = new HashSet<String>(mActions.keySet());
mSortedActionMimeTypes.clear();
// First, add LEADING_MIMETYPES, which are most common.
for (String mimeType : LEADING_MIMETYPES) {
if (containedTypes.contains(mimeType)) {
mSortedActionMimeTypes.add(mimeType);
containedTypes.remove(mimeType);
}
}
// Add all the remaining ones that are not TRAILING
for (String mimeType : containedTypes.toArray(new String[containedTypes.size()])) {
if (!TRAILING_MIMETYPES.contains(mimeType)) {
mSortedActionMimeTypes.add(mimeType);
containedTypes.remove(mimeType);
}
}
// Then, add TRAILING_MIMETYPES, which are least common.
for (String mimeType : TRAILING_MIMETYPES) {
if (containedTypes.contains(mimeType)) {
containedTypes.remove(mimeType);
mSortedActionMimeTypes.add(mimeType);
}
}
// Add buttons for each mimetype
for (String mimeType : mSortedActionMimeTypes) {
final View actionView = inflateAction(mimeType, cache, mTrack);
mTrack.addView(actionView);
}
final boolean hasData = !mSortedActionMimeTypes.isEmpty();
mTrackScroller.setVisibility(hasData ? View.VISIBLE : View.GONE);
mSelectedTabRectangle.setVisibility(hasData ? View.VISIBLE : View.GONE);
mLineAfterTrack.setVisibility(hasData ? View.VISIBLE : View.GONE);
mListPager.setVisibility(hasData ? View.VISIBLE : View.GONE);
}
/**
* Consider adding the given {@link Action}, which will only happen if
* {@link PackageManager} finds an application to handle
* {@link Action#getIntent()}.
* @return true if action has been added
*/
private boolean considerAdd(Action action, ResolveCache resolveCache) {
if (resolveCache.hasResolve(action)) {
mActions.put(action.getMimeType(), action);
return true;
}
return false;
}
/**
* Inflate the in-track view for the action of the given MIME-type, collapsing duplicate values.
* Will use the icon provided by the {@link DataKind}.
*/
private View inflateAction(String mimeType, ResolveCache resolveCache, ViewGroup root) {
final CheckableImageView typeView = (CheckableImageView) getLayoutInflater().inflate(
R.layout.quickcontact_track_button, root, false);
List<Action> children = mActions.get(mimeType);
typeView.setTag(mimeType);
final Action firstInfo = children.get(0);
// Set icon and listen for clicks
final CharSequence descrip = resolveCache.getDescription(firstInfo);
final Drawable icon = resolveCache.getIcon(firstInfo);
typeView.setChecked(false);
typeView.setContentDescription(descrip);
typeView.setImageDrawable(icon);
typeView.setOnClickListener(mTypeViewClickListener);
return typeView;
}
private CheckableImageView getActionViewAt(int position) {
return (CheckableImageView) mTrack.getChildAt(position);
}
@Override
public void onAttachFragment(Fragment fragment) {
final QuickContactListFragment listFragment = (QuickContactListFragment) fragment;
listFragment.setListener(mListFragmentListener);
}
/** A type (e.g. Call/Addresses was clicked) */
private final OnClickListener mTypeViewClickListener = new OnClickListener() {
@Override
public void onClick(View view) {
final CheckableImageView actionView = (CheckableImageView)view;
final String mimeType = (String) actionView.getTag();
int index = mSortedActionMimeTypes.indexOf(mimeType);
mListPager.setCurrentItem(index, true);
}
};
private class ViewPagerAdapter extends FragmentPagerAdapter {
public ViewPagerAdapter(FragmentManager fragmentManager) {
super(fragmentManager);
}
@Override
public Fragment getItem(int position) {
QuickContactListFragment fragment = new QuickContactListFragment();
final String mimeType = mSortedActionMimeTypes.get(position);
final List<Action> actions = mActions.get(mimeType);
fragment.setActions(actions);
return fragment;
}
@Override
public int getCount() {
return mSortedActionMimeTypes.size();
}
}
private class PageChangeListener extends SimpleOnPageChangeListener {
@Override
public void onPageSelected(int position) {
final CheckableImageView actionView = getActionViewAt(position);
mTrackScroller.requestChildRectangleOnScreen(actionView,
new Rect(0, 0, actionView.getWidth(), actionView.getHeight()), false);
}
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
final RelativeLayout.LayoutParams layoutParams =
(RelativeLayout.LayoutParams) mSelectedTabRectangle.getLayoutParams();
final int width = mSelectedTabRectangle.getWidth();
layoutParams.leftMargin = (int) ((position + positionOffset) * width);
mSelectedTabRectangle.setLayoutParams(layoutParams);
}
}
private final QuickContactListFragment.Listener mListFragmentListener =
new QuickContactListFragment.Listener() {
@Override
public void onOutsideClick() {
// If there is no background, we want to dismiss, because to the user it seems
// like he had touched outside. If the ViewPager is solid however, those taps
// must be ignored
final boolean isTransparent = mListPager.getBackground() == null;
if (isTransparent) handleOutsideTouch();
}
@Override
public void onItemClicked(final Action action, final boolean alternate) {
final Runnable startAppRunnable = new Runnable() {
@Override
public void run() {
try {
startActivity(alternate ? action.getAlternateIntent() : action.getIntent());
} catch (ActivityNotFoundException e) {
Toast.makeText(QuickContactActivity.this, R.string.quickcontact_missing_app,
Toast.LENGTH_SHORT).show();
}
hide(false);
}
};
// Defer the action to make the window properly repaint
new Handler().post(startAppRunnable);
}
};
private interface DataQuery {
final String[] PROJECTION = new String[] {
Data._ID,
RawContacts.ACCOUNT_TYPE,
RawContacts.DATA_SET,
Contacts.STARRED,
Contacts.DISPLAY_NAME,
Data.STATUS,
Data.STATUS_RES_PACKAGE,
Data.STATUS_ICON,
Data.STATUS_LABEL,
Data.STATUS_TIMESTAMP,
Data.PRESENCE,
Data.CHAT_CAPABILITY,
Data.RES_PACKAGE,
Data.MIMETYPE,
Data.IS_PRIMARY,
Data.IS_SUPER_PRIMARY,
Data.RAW_CONTACT_ID,
Data.DATA1, Data.DATA2, Data.DATA3, Data.DATA4, Data.DATA5,
Data.DATA6, Data.DATA7, Data.DATA8, Data.DATA9, Data.DATA10, Data.DATA11,
Data.DATA12, Data.DATA13, Data.DATA14, Data.DATA15,
};
final int _ID = 0;
final int ACCOUNT_TYPE = 1;
final int DATA_SET = 2;
final int STARRED = 3;
final int DISPLAY_NAME = 4;
final int STATUS = 5;
final int STATUS_RES_PACKAGE = 6;
final int STATUS_ICON = 7;
final int STATUS_LABEL = 8;
final int STATUS_TIMESTAMP = 9;
final int PRESENCE = 10;
final int CHAT_CAPABILITY = 11;
final int RES_PACKAGE = 12;
final int MIMETYPE = 13;
final int IS_PRIMARY = 14;
final int IS_SUPER_PRIMARY = 15;
}
}