/* Copyright (C) 2010 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.exchange.provider;
import com.android.email.Email;
import com.android.email.EmailAddressAdapter;
import com.android.email.R;
import com.android.email.provider.EmailContent.Account;
import com.android.email.provider.EmailContent.HostAuth;
import android.app.Activity;
import android.content.Context;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.database.MergeCursor;
import android.net.Uri;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ListView;
import android.widget.TextView;
/**
* Email Address adapter that performs asynchronous GAL lookups.
*/
public class GalEmailAddressAdapter extends EmailAddressAdapter {
// DO NOT CHECK IN SET TO TRUE
private static final boolean DEBUG_GAL_LOG = false;
// Don't run GAL query until there are 3 characters typed
private static final int MINIMUM_GAL_CONSTRAINT_LENGTH = 3;
private Activity mActivity;
private Account mAccount;
private boolean mAccountHasGal;
private String mAccountEmailDomain;
private LayoutInflater mInflater;
// Local variables to track status of the search
private int mSeparatorDisplayCount;
private int mSeparatorTotalCount;
public GalEmailAddressAdapter(Activity activity) {
super(activity);
mActivity = activity;
mAccount = null;
mAccountHasGal = false;
mInflater = (LayoutInflater) activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
/**
* Set the account ID when known. Not used for generic contacts lookup; Use when
* linking lookup to specific account.
*/
@Override
public void setAccount(Account account) {
mAccount = account;
mAccountHasGal = false;
int finalSplit = mAccount.mEmailAddress.lastIndexOf('@');
mAccountEmailDomain = mAccount.mEmailAddress.substring(finalSplit + 1);
}
/**
* Sniff the provided account and if it's EAS, record "mAccounthHasGal". If not,
* clear mAccount so we just ignore it.
*/
private void checkGalAccount(Account account) {
HostAuth ha = HostAuth.restoreHostAuthWithId(mActivity, account.mHostAuthKeyRecv);
if (ha != null) {
if ("eas".equalsIgnoreCase(ha.mProtocol)) {
mAccountHasGal = true;
return;
}
}
// for any reason, we could not identify a GAL account, so clear mAccount
// and we'll never check this again
mAccount = null;
mAccountHasGal = false;
}
@Override
public Cursor runQueryOnBackgroundThread(final CharSequence constraint) {
// One time (and not in the UI thread) - check the account and see if it support GAL
// If not, clear it so we never bother again
if (mAccount != null && mAccountHasGal == false) {
checkGalAccount(mAccount);
}
// Get the cursor from ContactsProvider, and set up to exit immediately, returning it
Cursor contactsCursor = super.runQueryOnBackgroundThread(constraint);
// If we don't have a GAL account or we don't have a constraint that's long enough,
// just return the raw contactsCursor
if (!mAccountHasGal || constraint == null) {
return contactsCursor;
}
final String constraintString = constraint.toString().trim();
if (constraintString.length() < MINIMUM_GAL_CONSTRAINT_LENGTH) {
return contactsCursor;
}
// Strategy for handling dynamic GAL lookup.
// 1. Create cursor that we can use now (and update later)
// 2. Return it immediately
// 3. Spawn a thread that will update the cursor when results arrive or search fails
final MatrixCursor matrixCursor = new MatrixCursor(ExchangeProvider.GAL_PROJECTION);
final MyMergeCursor mergedResultCursor =
new MyMergeCursor(new Cursor[] {contactsCursor, matrixCursor});
mergedResultCursor.setSeparatorPosition(contactsCursor.getCount());
mSeparatorDisplayCount = -1;
mSeparatorTotalCount = -1;
new Thread(new Runnable() {
public void run() {
// Uri format is account/constraint
Uri galUri =
ExchangeProvider.GAL_URI.buildUpon()
.appendPath(Long.toString(mAccount.mId))
.appendPath(constraintString).build();
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Query: " + galUri);
}
// Use ExchangeProvider to get the results of the GAL query
final Cursor galCursor =
mContentResolver.query(galUri, ExchangeProvider.GAL_PROJECTION,
null, null, null);
// There are three result cases to handle here.
// 1. matrixCursor is closed - this means the UI no longer cares about us
// 2. gal cursor is null or empty - remove separator and exit
// 3. gal cursor has results - update separator and add results to matrix cursor
// Case 1: The merged cursor has already been dropped, (e.g. results superceded)
if (mergedResultCursor.isClosed()) {
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Drop result (cursor closed, bg thread)");
}
return;
}
// Cases 2 & 3 have UI aspects, so do them in the UI thread
mActivity.runOnUiThread(new Runnable() {
public void run() {
// Case 1: (final re-check): Merged cursor already dropped
if (mergedResultCursor.isClosed()) {
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Drop result (cursor closed, ui thread)");
}
return;
}
// Case 2: Gal cursor is null or empty
if (galCursor == null || galCursor.getCount() == 0) {
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Drop empty result");
}
mergedResultCursor.setSeparatorPosition(ListView.INVALID_POSITION);
GalEmailAddressAdapter.this.notifyDataSetChanged();
return;
}
// Case 3: Real results
galCursor.moveToPosition(-1);
while (galCursor.moveToNext()) {
MatrixCursor.RowBuilder rb = matrixCursor.newRow();
rb.add(galCursor.getLong(ExchangeProvider.GAL_COLUMN_ID));
rb.add(galCursor.getString(ExchangeProvider.GAL_COLUMN_DISPLAYNAME));
rb.add(galCursor.getString(ExchangeProvider.GAL_COLUMN_DATA));
}
// Replace the separator text with "totals"
mSeparatorDisplayCount = galCursor.getCount();
mSeparatorTotalCount =
galCursor.getExtras().getInt(ExchangeProvider.EXTRAS_TOTAL_RESULTS);
// Notify UI that the cursor changed
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Notify result, added=" + mSeparatorDisplayCount);
}
GalEmailAddressAdapter.this.notifyDataSetChanged();
}});
}}).start();
return mergedResultCursor;
}
/*
* The following series of overrides insert the separator between contacts & GAL contacts
* TODO: extract most of this into a CursorAdapter superclass, and share with AccountFolderList
*/
/**
* Get the separator position, which is tucked into the cursor to deal with threading.
* Result is invalid for any other cursor types (e.g. the raw contacts cursor)
*/
private int getSeparatorPosition() {
Cursor c = this.getCursor();
if (c instanceof MyMergeCursor) {
return ((MyMergeCursor)c).getSeparatorPosition();
} else {
return ListView.INVALID_POSITION;
}
}
/**
* Prevents the separator view from recycling into the other views
*/
@Override
public int getItemViewType(int position) {
if (position == getSeparatorPosition()) {
return IGNORE_ITEM_VIEW_TYPE;
}
return super.getItemViewType(position);
}
/**
* Injects the separator view when required
*/
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// The base class's getView() checks for mDataValid at the beginning, but we don't have
// to do that, because if the cursor is invalid getCount() returns 0, in which case this
// method wouldn't get called.
// Handle the separator here - create & bind
if (position == getSeparatorPosition()) {
View separator;
separator = mInflater.inflate(R.layout.recipient_dropdown_separator, parent, false);
TextView text1 = (TextView) separator.findViewById(R.id.text1);
View progress = separator.findViewById(R.id.progress);
String bannerText;
if (mSeparatorDisplayCount == -1) {
// Display "Searching <account>..."
bannerText = mContext.getString(R.string.gal_searching_fmt, mAccountEmailDomain);
progress.setVisibility(View.VISIBLE);
} else {
if (mSeparatorDisplayCount == mSeparatorTotalCount) {
// Display "x results from <account>"
bannerText = mContext.getResources().getQuantityString(
R.plurals.gal_completed_fmt, mSeparatorDisplayCount,
mSeparatorDisplayCount, mAccountEmailDomain);
} else {
// Display "First x results from <account>"
bannerText = mContext.getString(R.string.gal_completed_limited_fmt,
mSeparatorDisplayCount, mAccountEmailDomain);
}
progress.setVisibility(View.GONE);
}
text1.setText(bannerText);
return separator;
}
return super.getView(getRealPosition(position), convertView, parent);
}
/**
* Forces navigation to skip over the separator
*/
@Override
public boolean areAllItemsEnabled() {
return false;
}
/**
* Forces navigation to skip over the separator
*/
@Override
public boolean isEnabled(int position) {
return position != getSeparatorPosition();
}
/**
* Adjusts list count to include separator
*/
@Override
public int getCount() {
int count = super.getCount();
if (getSeparatorPosition() != ListView.INVALID_POSITION) {
// Increment for separator, if we have anything to show.
count += 1;
}
return count;
}
/**
* Converts list position to cursor position
*/
private int getRealPosition(int pos) {
int separatorPosition = getSeparatorPosition();
if (separatorPosition == ListView.INVALID_POSITION) {
// No separator, identity map
return pos;
} else if (pos <= separatorPosition) {
// Before or at the separator, identity map
return pos;
} else {
// After the separator, remove 1 from the pos to get the real underlying pos
return pos - 1;
}
}
/**
* Returns the item using external position numbering (no separator)
*/
@Override
public Object getItem(int pos) {
return super.getItem(getRealPosition(pos));
}
/**
* Returns the item id using external position numbering (no separator)
*/
@Override
public long getItemId(int pos) {
if (pos == getSeparatorPosition()) {
return View.NO_ID;
}
return super.getItemId(getRealPosition(pos));
}
/**
* Lightweight override of MergeCursor. Synchronizes "mClosed" / "isClosed()" so we
* can safely check if it has been closed, in the threading jumble of our adapter.
* Also holds the separator position, so it can be tracked with the cursor itself and avoid
* errors when multiple cursors are in flight.
*/
private static class MyMergeCursor extends MergeCursor {
private int mSeparatorPosition;
public MyMergeCursor(Cursor[] cursors) {
super(cursors);
mClosed = false;
mSeparatorPosition = ListView.INVALID_POSITION;
}
@Override
public synchronized void close() {
super.close();
if (DEBUG_GAL_LOG) {
Log.d(Email.LOG_TAG, "Closing MyMergeCursor");
}
}
@Override
public synchronized boolean isClosed() {
return super.isClosed();
}
void setSeparatorPosition(int newPos) {
mSeparatorPosition = newPos;
}
int getSeparatorPosition() {
return mSeparatorPosition;
}
}
}