/*
* 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.contacts;
import com.android.internal.telephony.CallerInfo;
import com.android.internal.telephony.ITelephony;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ListActivity;
import android.content.ActivityNotFoundException;
import android.content.AsyncQueryHandler;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.DialogInterface.OnClickListener;
import android.database.CharArrayBuffer;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabaseCorruptException;
import android.database.sqlite.SQLiteDiskIOException;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteFullException;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.SystemClock;
import android.provider.CallLog;
import android.provider.CallLog.Calls;
import android.provider.ContactsContract.Intents.Insert;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.PhoneLookup;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.telephony.PhoneNumberUtils;
import android.telephony.TelephonyManager;
import android.text.SpannableStringBuilder;
import android.text.TextUtils;
import android.text.format.DateUtils;
import android.util.Log;
import android.view.ContextMenu;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.view.ViewTreeObserver;
import android.view.ContextMenu.ContextMenuInfo;
import android.widget.AdapterView;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Locale;
/**
* Displays a list of call log entries.
*/
public class RecentCallsListActivity extends ListActivity
implements View.OnCreateContextMenuListener {
private static final String TAG = "RecentCallsList";
/** The projection to use when querying the call log table */
static final String[] CALL_LOG_PROJECTION = new String[] {
Calls._ID,
Calls.NUMBER,
Calls.DATE,
Calls.DURATION,
Calls.TYPE,
Calls.CACHED_NAME,
Calls.CACHED_NUMBER_TYPE,
Calls.CACHED_NUMBER_LABEL
};
static final int ID_COLUMN_INDEX = 0;
static final int NUMBER_COLUMN_INDEX = 1;
static final int DATE_COLUMN_INDEX = 2;
static final int DURATION_COLUMN_INDEX = 3;
static final int CALL_TYPE_COLUMN_INDEX = 4;
static final int CALLER_NAME_COLUMN_INDEX = 5;
static final int CALLER_NUMBERTYPE_COLUMN_INDEX = 6;
static final int CALLER_NUMBERLABEL_COLUMN_INDEX = 7;
/** The projection to use when querying the phones table */
static final String[] PHONES_PROJECTION = new String[] {
PhoneLookup._ID,
PhoneLookup.DISPLAY_NAME,
PhoneLookup.TYPE,
PhoneLookup.LABEL,
PhoneLookup.NUMBER
};
static final int PERSON_ID_COLUMN_INDEX = 0;
static final int NAME_COLUMN_INDEX = 1;
static final int PHONE_TYPE_COLUMN_INDEX = 2;
static final int LABEL_COLUMN_INDEX = 3;
static final int MATCHED_NUMBER_COLUMN_INDEX = 4;
private static final int MENU_ITEM_DELETE = 1;
private static final int MENU_ITEM_DELETE_ALL = 2;
private static final int MENU_ITEM_VIEW_CONTACTS = 3;
private static final int QUERY_TOKEN = 53;
private static final int UPDATE_TOKEN = 54;
private static final int DIALOG_CONFIRM_DELETE_ALL = 1;
RecentCallsAdapter mAdapter;
private QueryHandler mQueryHandler;
String mVoiceMailNumber;
static final class ContactInfo {
public long personId;
public String name;
public int type;
public String label;
public String number;
public String formattedNumber;
public static ContactInfo EMPTY = new ContactInfo();
}
public static final class RecentCallsListItemViews {
TextView line1View;
TextView labelView;
TextView numberView;
TextView dateView;
ImageView iconView;
View callView;
ImageView groupIndicator;
TextView groupSize;
}
static final class CallerInfoQuery {
String number;
int position;
String name;
int numberType;
String numberLabel;
}
/**
* Shared builder used by {@link #formatPhoneNumber(String)} to minimize
* allocations when formatting phone numbers.
*/
private static final SpannableStringBuilder sEditable = new SpannableStringBuilder();
/**
* Invalid formatting type constant for {@link #sFormattingType}.
*/
private static final int FORMATTING_TYPE_INVALID = -1;
/**
* Cached formatting type for current {@link Locale}, as provided by
* {@link PhoneNumberUtils#getFormatTypeForLocale(Locale)}.
*/
private static int sFormattingType = FORMATTING_TYPE_INVALID;
/** Adapter class to fill in data for the Call Log */
final class RecentCallsAdapter extends GroupingListAdapter
implements Runnable, ViewTreeObserver.OnPreDrawListener, View.OnClickListener {
HashMap<String,ContactInfo> mContactInfo;
private final LinkedList<CallerInfoQuery> mRequests;
private volatile boolean mDone;
private boolean mLoading = true;
ViewTreeObserver.OnPreDrawListener mPreDrawListener;
private static final int REDRAW = 1;
private static final int START_THREAD = 2;
private boolean mFirst;
private Thread mCallerIdThread;
private CharSequence[] mLabelArray;
private Drawable mDrawableIncoming;
private Drawable mDrawableOutgoing;
private Drawable mDrawableMissed;
/**
* Reusable char array buffers.
*/
private CharArrayBuffer mBuffer1 = new CharArrayBuffer(128);
private CharArrayBuffer mBuffer2 = new CharArrayBuffer(128);
public void onClick(View view) {
String number = (String) view.getTag();
if (!TextUtils.isEmpty(number)) {
Uri telUri = Uri.fromParts("tel", number, null);
startActivity(new Intent(Intent.ACTION_CALL_PRIVILEGED, telUri));
}
}
public boolean onPreDraw() {
if (mFirst) {
mHandler.sendEmptyMessageDelayed(START_THREAD, 1000);
mFirst = false;
}
return true;
}
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case REDRAW:
notifyDataSetChanged();
break;
case START_THREAD:
startRequestProcessing();
break;
}
}
};
public RecentCallsAdapter() {
super(RecentCallsListActivity.this);
mContactInfo = new HashMap<String,ContactInfo>();
mRequests = new LinkedList<CallerInfoQuery>();
mPreDrawListener = null;
mDrawableIncoming = getResources().getDrawable(
R.drawable.ic_call_log_list_incoming_call);
mDrawableOutgoing = getResources().getDrawable(
R.drawable.ic_call_log_list_outgoing_call);
mDrawableMissed = getResources().getDrawable(
R.drawable.ic_call_log_list_missed_call);
mLabelArray = getResources().getTextArray(com.android.internal.R.array.phoneTypes);
}
/**
* Requery on background thread when {@link Cursor} changes.
*/
@Override
protected void onContentChanged() {
// Start async requery
startQuery();
}
void setLoading(boolean loading) {
mLoading = loading;
}
@Override
public boolean isEmpty() {
if (mLoading) {
// We don't want the empty state to show when loading.
return false;
} else {
return super.isEmpty();
}
}
public ContactInfo getContactInfo(String number) {
return mContactInfo.get(number);
}
public void startRequestProcessing() {
mDone = false;
mCallerIdThread = new Thread(this);
mCallerIdThread.setPriority(Thread.MIN_PRIORITY);
mCallerIdThread.start();
}
public void stopRequestProcessing() {
mDone = true;
if (mCallerIdThread != null) mCallerIdThread.interrupt();
}
public void clearCache() {
synchronized (mContactInfo) {
mContactInfo.clear();
}
}
private void updateCallLog(CallerInfoQuery ciq, ContactInfo ci) {
// Check if they are different. If not, don't update.
if (TextUtils.equals(ciq.name, ci.name)
&& TextUtils.equals(ciq.numberLabel, ci.label)
&& ciq.numberType == ci.type) {
return;
}
ContentValues values = new ContentValues(3);
values.put(Calls.CACHED_NAME, ci.name);
values.put(Calls.CACHED_NUMBER_TYPE, ci.type);
values.put(Calls.CACHED_NUMBER_LABEL, ci.label);
try {
RecentCallsListActivity.this.getContentResolver().update(Calls.CONTENT_URI, values,
Calls.NUMBER + "='" + ciq.number + "'", null);
} catch (SQLiteDiskIOException e) {
Log.w(TAG, "Exception while updating call info", e);
} catch (SQLiteFullException e) {
Log.w(TAG, "Exception while updating call info", e);
} catch (SQLiteDatabaseCorruptException e) {
Log.w(TAG, "Exception while updating call info", e);
}
}
private void enqueueRequest(String number, int position,
String name, int numberType, String numberLabel) {
CallerInfoQuery ciq = new CallerInfoQuery();
ciq.number = number;
ciq.position = position;
ciq.name = name;
ciq.numberType = numberType;
ciq.numberLabel = numberLabel;
synchronized (mRequests) {
mRequests.add(ciq);
mRequests.notifyAll();
}
}
private boolean queryContactInfo(CallerInfoQuery ciq) {
// First check if there was a prior request for the same number
// that was already satisfied
ContactInfo info = mContactInfo.get(ciq.number);
boolean needNotify = false;
if (info != null && info != ContactInfo.EMPTY) {
return true;
} else {
Cursor phonesCursor =
RecentCallsListActivity.this.getContentResolver().query(
Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,
Uri.encode(ciq.number)),
PHONES_PROJECTION, null, null, null);
if (phonesCursor != null) {
if (phonesCursor.moveToFirst()) {
info = new ContactInfo();
info.personId = phonesCursor.getLong(PERSON_ID_COLUMN_INDEX);
info.name = phonesCursor.getString(NAME_COLUMN_INDEX);
info.type = phonesCursor.getInt(PHONE_TYPE_COLUMN_INDEX);
info.label = phonesCursor.getString(LABEL_COLUMN_INDEX);
info.number = phonesCursor.getString(MATCHED_NUMBER_COLUMN_INDEX);
// New incoming phone number invalidates our formatted
// cache. Any cache fills happen only on the GUI thread.
info.formattedNumber = null;
mContactInfo.put(ciq.number, info);
// Inform list to update this item, if in view
needNotify = true;
}
phonesCursor.close();
}
}
if (info != null) {
updateCallLog(ciq, info);
}
return needNotify;
}
/*
* Handles requests for contact name and number type
* @see java.lang.Runnable#run()
*/
public void run() {
boolean needNotify = false;
while (!mDone) {
CallerInfoQuery ciq = null;
synchronized (mRequests) {
if (!mRequests.isEmpty()) {
ciq = mRequests.removeFirst();
} else {
if (needNotify) {
needNotify = false;
mHandler.sendEmptyMessage(REDRAW);
}
try {
mRequests.wait(1000);
} catch (InterruptedException ie) {
// Ignore and continue processing requests
}
}
}
if (ciq != null && queryContactInfo(ciq)) {
needNotify = true;
}
}
}
@Override
protected void addGroups(Cursor cursor) {
int count = cursor.getCount();
if (count == 0) {
return;
}
int groupItemCount = 1;
CharArrayBuffer currentValue = mBuffer1;
CharArrayBuffer value = mBuffer2;
cursor.moveToFirst();
cursor.copyStringToBuffer(NUMBER_COLUMN_INDEX, currentValue);
int currentCallType = cursor.getInt(CALL_TYPE_COLUMN_INDEX);
for (int i = 1; i < count; i++) {
cursor.moveToNext();
cursor.copyStringToBuffer(NUMBER_COLUMN_INDEX, value);
boolean sameNumber = equalPhoneNumbers(value, currentValue);
// Group adjacent calls with the same number. Make an exception
// for the latest item if it was a missed call. We don't want
// a missed call to be hidden inside a group.
if (sameNumber && currentCallType != Calls.MISSED_TYPE) {
groupItemCount++;
} else {
if (groupItemCount > 1) {
addGroup(i - groupItemCount, groupItemCount, false);
}
groupItemCount = 1;
// Swap buffers
CharArrayBuffer temp = currentValue;
currentValue = value;
value = temp;
// If we have just examined a row following a missed call, make
// sure that it is grouped with subsequent calls from the same number
// even if it was also missed.
if (sameNumber && currentCallType == Calls.MISSED_TYPE) {
currentCallType = 0; // "not a missed call"
} else {
currentCallType = cursor.getInt(CALL_TYPE_COLUMN_INDEX);
}
}
}
if (groupItemCount > 1) {
addGroup(count - groupItemCount, groupItemCount, false);
}
}
protected boolean equalPhoneNumbers(CharArrayBuffer buffer1, CharArrayBuffer buffer2) {
// TODO add PhoneNumberUtils.compare(CharSequence, CharSequence) to avoid
// string allocation
return PhoneNumberUtils.compare(new String(buffer1.data, 0, buffer1.sizeCopied),
new String(buffer2.data, 0, buffer2.sizeCopied));
}
@Override
protected View newStandAloneView(Context context, ViewGroup parent) {
LayoutInflater inflater =
(LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.recent_calls_list_item, parent, false);
findAndCacheViews(view);
return view;
}
@Override
protected void bindStandAloneView(View view, Context context, Cursor cursor) {
bindView(context, view, cursor);
}
@Override
protected View newChildView(Context context, ViewGroup parent) {
LayoutInflater inflater =
(LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.recent_calls_list_child_item, parent, false);
findAndCacheViews(view);
return view;
}
@Override
protected void bindChildView(View view, Context context, Cursor cursor) {
bindView(context, view, cursor);
}
@Override
protected View newGroupView(Context context, ViewGroup parent) {
LayoutInflater inflater =
(LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View view = inflater.inflate(R.layout.recent_calls_list_group_item, parent, false);
findAndCacheViews(view);
return view;
}
@Override
protected void bindGroupView(View view, Context context, Cursor cursor, int groupSize,
boolean expanded) {
final RecentCallsListItemViews views = (RecentCallsListItemViews) view.getTag();
int groupIndicator = expanded
? com.android.internal.R.drawable.expander_ic_maximized
: com.android.internal.R.drawable.expander_ic_minimized;
views.groupIndicator.setImageResource(groupIndicator);
views.groupSize.setText("(" + groupSize + ")");
bindView(context, view, cursor);
}
private void findAndCacheViews(View view) {
// Get the views to bind to
RecentCallsListItemViews views = new RecentCallsListItemViews();
views.line1View = (TextView) view.findViewById(R.id.line1);
views.labelView = (TextView) view.findViewById(R.id.label);
views.numberView = (TextView) view.findViewById(R.id.number);
views.dateView = (TextView) view.findViewById(R.id.date);
views.iconView = (ImageView) view.findViewById(R.id.call_type_icon);
views.callView = view.findViewById(R.id.call_icon);
views.callView.setOnClickListener(this);
views.groupIndicator = (ImageView) view.findViewById(R.id.groupIndicator);
views.groupSize = (TextView) view.findViewById(R.id.groupSize);
view.setTag(views);
}
public void bindView(Context context, View view, Cursor c) {
final RecentCallsListItemViews views = (RecentCallsListItemViews) view.getTag();
String number = c.getString(NUMBER_COLUMN_INDEX);
String formattedNumber = null;
String callerName = c.getString(CALLER_NAME_COLUMN_INDEX);
int callerNumberType = c.getInt(CALLER_NUMBERTYPE_COLUMN_INDEX);
String callerNumberLabel = c.getString(CALLER_NUMBERLABEL_COLUMN_INDEX);
// Store away the number so we can call it directly if you click on the call icon
views.callView.setTag(number);
// Lookup contacts with this number
ContactInfo info = mContactInfo.get(number);
if (info == null) {
// Mark it as empty and queue up a request to find the name
// The db request should happen on a non-UI thread
info = ContactInfo.EMPTY;
mContactInfo.put(number, info);
enqueueRequest(number, c.getPosition(),
callerName, callerNumberType, callerNumberLabel);
} else if (info != ContactInfo.EMPTY) { // Has been queried
// Check if any data is different from the data cached in the
// calls db. If so, queue the request so that we can update
// the calls db.
if (!TextUtils.equals(info.name, callerName)
|| info.type != callerNumberType
|| !TextUtils.equals(info.label, callerNumberLabel)) {
// Something is amiss, so sync up.
enqueueRequest(number, c.getPosition(),
callerName, callerNumberType, callerNumberLabel);
}
// Format and cache phone number for found contact
if (info.formattedNumber == null) {
info.formattedNumber = formatPhoneNumber(info.number);
}
formattedNumber = info.formattedNumber;
}
String name = info.name;
int ntype = info.type;
String label = info.label;
// If there's no name cached in our hashmap, but there's one in the
// calls db, use the one in the calls db. Otherwise the name in our
// hashmap is more recent, so it has precedence.
if (TextUtils.isEmpty(name) && !TextUtils.isEmpty(callerName)) {
name = callerName;
ntype = callerNumberType;
label = callerNumberLabel;
// Format the cached call_log phone number
formattedNumber = formatPhoneNumber(number);
}
// Set the text lines and call icon.
// Assumes the call back feature is on most of the
// time. For private and unknown numbers: hide it.
views.callView.setVisibility(View.VISIBLE);
if (!TextUtils.isEmpty(name)) {
views.line1View.setText(name);
views.labelView.setVisibility(View.VISIBLE);
CharSequence numberLabel = Phone.getDisplayLabel(context, ntype, label,
mLabelArray);
views.numberView.setVisibility(View.VISIBLE);
views.numberView.setText(formattedNumber);
if (!TextUtils.isEmpty(numberLabel)) {
views.labelView.setText(numberLabel);
views.labelView.setVisibility(View.VISIBLE);
} else {
views.labelView.setVisibility(View.GONE);
}
} else {
if (number.equals(CallerInfo.UNKNOWN_NUMBER)) {
number = getString(R.string.unknown);
views.callView.setVisibility(View.INVISIBLE);
} else if (number.equals(CallerInfo.PRIVATE_NUMBER)) {
number = getString(R.string.private_num);
views.callView.setVisibility(View.INVISIBLE);
} else if (number.equals(CallerInfo.PAYPHONE_NUMBER)) {
number = getString(R.string.payphone);
} else if (number.equals(mVoiceMailNumber)) {
number = getString(R.string.voicemail);
} else {
// Just a raw number, and no cache, so format it nicely
number = formatPhoneNumber(number);
}
views.line1View.setText(number);
views.numberView.setVisibility(View.GONE);
views.labelView.setVisibility(View.GONE);
}
long date = c.getLong(DATE_COLUMN_INDEX);
// Set the date/time field by mixing relative and absolute times.
int flags = DateUtils.FORMAT_ABBREV_RELATIVE;
views.dateView.setText(DateUtils.getRelativeTimeSpanString(date,
System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS, flags));
if (views.iconView != null) {
int type = c.getInt(CALL_TYPE_COLUMN_INDEX);
// Set the icon
switch (type) {
case Calls.INCOMING_TYPE:
views.iconView.setImageDrawable(mDrawableIncoming);
break;
case Calls.OUTGOING_TYPE:
views.iconView.setImageDrawable(mDrawableOutgoing);
break;
case Calls.MISSED_TYPE:
views.iconView.setImageDrawable(mDrawableMissed);
break;
}
}
// Listen for the first draw
if (mPreDrawListener == null) {
mFirst = true;
mPreDrawListener = this;
view.getViewTreeObserver().addOnPreDrawListener(this);
}
}
}
private static final class QueryHandler extends AsyncQueryHandler {
private final WeakReference<RecentCallsListActivity> mActivity;
/**
* Simple handler that wraps background calls to catch
* {@link SQLiteException}, such as when the disk is full.
*/
protected class CatchingWorkerHandler extends AsyncQueryHandler.WorkerHandler {
public CatchingWorkerHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
try {
// Perform same query while catching any exceptions
super.handleMessage(msg);
} catch (SQLiteDiskIOException e) {
Log.w(TAG, "Exception on background worker thread", e);
} catch (SQLiteFullException e) {
Log.w(TAG, "Exception on background worker thread", e);
} catch (SQLiteDatabaseCorruptException e) {
Log.w(TAG, "Exception on background worker thread", e);
}
}
}
@Override
protected Handler createHandler(Looper looper) {
// Provide our special handler that catches exceptions
return new CatchingWorkerHandler(looper);
}
public QueryHandler(Context context) {
super(context.getContentResolver());
mActivity = new WeakReference<RecentCallsListActivity>(
(RecentCallsListActivity) context);
}
@Override
protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
final RecentCallsListActivity activity = mActivity.get();
if (activity != null && !activity.isFinishing()) {
final RecentCallsListActivity.RecentCallsAdapter callsAdapter = activity.mAdapter;
callsAdapter.setLoading(false);
callsAdapter.changeCursor(cursor);
} else {
cursor.close();
}
}
}
@Override
protected void onCreate(Bundle state) {
super.onCreate(state);
setContentView(R.layout.recent_calls);
// Typing here goes to the dialer
setDefaultKeyMode(DEFAULT_KEYS_DIALER);
mAdapter = new RecentCallsAdapter();
getListView().setOnCreateContextMenuListener(this);
setListAdapter(mAdapter);
mVoiceMailNumber = ((TelephonyManager)getSystemService(Context.TELEPHONY_SERVICE))
.getVoiceMailNumber();
mQueryHandler = new QueryHandler(this);
// Reset locale-based formatting cache
sFormattingType = FORMATTING_TYPE_INVALID;
}
@Override
protected void onResume() {
// The adapter caches looked up numbers, clear it so they will get
// looked up again.
if (mAdapter != null) {
mAdapter.clearCache();
}
startQuery();
resetNewCallsFlag();
super.onResume();
mAdapter.mPreDrawListener = null; // Let it restart the thread after next draw
}
@Override
protected void onPause() {
super.onPause();
// Kill the requests thread
mAdapter.stopRequestProcessing();
}
@Override
protected void onDestroy() {
super.onDestroy();
mAdapter.stopRequestProcessing();
mAdapter.changeCursor(null);
}
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
// Clear notifications only when window gains focus. This activity won't
// immediately receive focus if the keyguard screen is above it.
if (hasFocus) {
try {
ITelephony iTelephony =
ITelephony.Stub.asInterface(ServiceManager.getService("phone"));
if (iTelephony != null) {
iTelephony.cancelMissedCallsNotification();
} else {
Log.w(TAG, "Telephony service is null, can't call " +
"cancelMissedCallsNotification");
}
} catch (RemoteException e) {
Log.e(TAG, "Failed to clear missed calls notification due to remote exception");
}
}
}
/**
* Format the given phone number using
* {@link PhoneNumberUtils#formatNumber(android.text.Editable, int)}. This
* helper method uses {@link #sEditable} and {@link #sFormattingType} to
* prevent allocations between multiple calls.
* <p>
* Because of the shared {@link #sEditable} builder, <b>this method is not
* thread safe</b>, and should only be called from the GUI thread.
* <p>
* If the given String object is null or empty, return an empty String.
*/
private String formatPhoneNumber(String number) {
if (TextUtils.isEmpty(number)) {
return "";
}
// Cache formatting type if not already present
if (sFormattingType == FORMATTING_TYPE_INVALID) {
sFormattingType = PhoneNumberUtils.getFormatTypeForLocale(Locale.getDefault());
}
sEditable.clear();
sEditable.append(number);
PhoneNumberUtils.formatNumber(sEditable, sFormattingType);
return sEditable.toString();
}
private void resetNewCallsFlag() {
// Mark all "new" missed calls as not new anymore
StringBuilder where = new StringBuilder("type=");
where.append(Calls.MISSED_TYPE);
where.append(" AND new=1");
ContentValues values = new ContentValues(1);
values.put(Calls.NEW, "0");
mQueryHandler.startUpdate(UPDATE_TOKEN, null, Calls.CONTENT_URI,
values, where.toString(), null);
}
private void startQuery() {
mAdapter.setLoading(true);
// Cancel any pending queries
mQueryHandler.cancelOperation(QUERY_TOKEN);
mQueryHandler.startQuery(QUERY_TOKEN, null, Calls.CONTENT_URI,
CALL_LOG_PROJECTION, null, null, Calls.DEFAULT_SORT_ORDER);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
menu.add(0, MENU_ITEM_DELETE_ALL, 0, R.string.recentCalls_deleteAll)
.setIcon(android.R.drawable.ic_menu_close_clear_cancel);
return true;
}
@Override
public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfoIn) {
AdapterView.AdapterContextMenuInfo menuInfo;
try {
menuInfo = (AdapterView.AdapterContextMenuInfo) menuInfoIn;
} catch (ClassCastException e) {
Log.e(TAG, "bad menuInfoIn", e);
return;
}
Cursor cursor = (Cursor) mAdapter.getItem(menuInfo.position);
String number = cursor.getString(NUMBER_COLUMN_INDEX);
Uri numberUri = null;
boolean isVoicemail = false;
if (number.equals(CallerInfo.UNKNOWN_NUMBER)) {
number = getString(R.string.unknown);
} else if (number.equals(CallerInfo.PRIVATE_NUMBER)) {
number = getString(R.string.private_num);
} else if (number.equals(CallerInfo.PAYPHONE_NUMBER)) {
number = getString(R.string.payphone);
} else if (number.equals(mVoiceMailNumber)) {
number = getString(R.string.voicemail);
numberUri = Uri.parse("voicemail:x");
isVoicemail = true;
} else {
numberUri = Uri.fromParts("tel", number, null);
}
ContactInfo info = mAdapter.getContactInfo(number);
boolean contactInfoPresent = (info != null && info != ContactInfo.EMPTY);
if (contactInfoPresent) {
menu.setHeaderTitle(info.name);
} else {
menu.setHeaderTitle(number);
}
if (numberUri != null) {
Intent intent = new Intent(Intent.ACTION_CALL_PRIVILEGED, numberUri);
menu.add(0, 0, 0, getResources().getString(R.string.recentCalls_callNumber, number))
.setIntent(intent);
}
if (contactInfoPresent) {
menu.add(0, 0, 0, R.string.menu_viewContact)
.setIntent(new Intent(Intent.ACTION_VIEW,
ContentUris.withAppendedId(Contacts.CONTENT_URI, info.personId)));
}
if (numberUri != null && !isVoicemail) {
menu.add(0, 0, 0, R.string.recentCalls_editNumberBeforeCall)
.setIntent(new Intent(Intent.ACTION_DIAL, numberUri));
menu.add(0, 0, 0, R.string.menu_sendTextMessage)
.setIntent(new Intent(Intent.ACTION_SENDTO,
Uri.fromParts("sms", number, null)));
}
if (!contactInfoPresent && numberUri != null && !isVoicemail) {
Intent intent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
intent.setType(Contacts.CONTENT_ITEM_TYPE);
intent.putExtra(Insert.PHONE, number);
menu.add(0, 0, 0, R.string.recentCalls_addToContact)
.setIntent(intent);
}
menu.add(0, MENU_ITEM_DELETE, 0, R.string.recentCalls_removeFromRecentList);
}
@Override
protected Dialog onCreateDialog(int id, Bundle args) {
switch (id) {
case DIALOG_CONFIRM_DELETE_ALL:
return new AlertDialog.Builder(this)
.setTitle(R.string.clearCallLogConfirmation_title)
.setIcon(android.R.drawable.ic_dialog_alert)
.setMessage(R.string.clearCallLogConfirmation)
.setNegativeButton(android.R.string.cancel, null)
.setPositiveButton(android.R.string.ok, new OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
getContentResolver().delete(Calls.CONTENT_URI, null, null);
// TODO The change notification should do this automatically, but it
// isn't working right now. Remove this when the change notification
// is working properly.
startQuery();
}
})
.setCancelable(false)
.create();
}
return null;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case MENU_ITEM_DELETE_ALL: {
showDialog(DIALOG_CONFIRM_DELETE_ALL);
return true;
}
case MENU_ITEM_VIEW_CONTACTS: {
Intent intent = new Intent(Intent.ACTION_VIEW, Contacts.CONTENT_URI);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
return true;
}
}
return super.onOptionsItemSelected(item);
}
@Override
public boolean onContextItemSelected(MenuItem item) {
// Convert the menu info to the proper type
AdapterView.AdapterContextMenuInfo menuInfo;
try {
menuInfo = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
} catch (ClassCastException e) {
Log.e(TAG, "bad menuInfoIn", e);
return false;
}
switch (item.getItemId()) {
case MENU_ITEM_DELETE: {
Cursor cursor = (Cursor)mAdapter.getItem(menuInfo.position);
int groupSize = 1;
if (mAdapter.isGroupHeader(menuInfo.position)) {
groupSize = mAdapter.getGroupSize(menuInfo.position);
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < groupSize; i++) {
if (i != 0) {
sb.append(",");
cursor.moveToNext();
}
long id = cursor.getLong(ID_COLUMN_INDEX);
sb.append(id);
}
getContentResolver().delete(Calls.CONTENT_URI, Calls._ID + " IN (" + sb + ")",
null);
}
}
return super.onContextItemSelected(item);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_CALL: {
long callPressDiff = SystemClock.uptimeMillis() - event.getDownTime();
if (callPressDiff >= ViewConfiguration.getLongPressTimeout()) {
// Launch voice dialer
Intent intent = new Intent(Intent.ACTION_VOICE_COMMAND);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
try {
startActivity(intent);
} catch (ActivityNotFoundException e) {
}
return true;
}
}
}
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
switch (keyCode) {
case KeyEvent.KEYCODE_CALL:
try {
ITelephony phone = ITelephony.Stub.asInterface(
ServiceManager.checkService("phone"));
if (phone != null && !phone.isIdle()) {
// Let the super class handle it
break;
}
} catch (RemoteException re) {
// Fall through and try to call the contact
}
callEntry(getListView().getSelectedItemPosition());
return true;
}
return super.onKeyUp(keyCode, event);
}
/*
* Get the number from the Contacts, if available, since sometimes
* the number provided by caller id may not be formatted properly
* depending on the carrier (roaming) in use at the time of the
* incoming call.
* Logic : If the caller-id number starts with a "+", use it
* Else if the number in the contacts starts with a "+", use that one
* Else if the number in the contacts is longer, use that one
*/
private String getBetterNumberFromContacts(String number) {
String matchingNumber = null;
// Look in the cache first. If it's not found then query the Phones db
ContactInfo ci = mAdapter.mContactInfo.get(number);
if (ci != null && ci != ContactInfo.EMPTY) {
matchingNumber = ci.number;
} else {
try {
Cursor phonesCursor =
RecentCallsListActivity.this.getContentResolver().query(
Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI,
number),
PHONES_PROJECTION, null, null, null);
if (phonesCursor != null) {
if (phonesCursor.moveToFirst()) {
matchingNumber = phonesCursor.getString(MATCHED_NUMBER_COLUMN_INDEX);
}
phonesCursor.close();
}
} catch (Exception e) {
// Use the number from the call log
}
}
if (!TextUtils.isEmpty(matchingNumber) &&
(matchingNumber.startsWith("+")
|| matchingNumber.length() > number.length())) {
number = matchingNumber;
}
return number;
}
private void callEntry(int position) {
if (position < 0) {
// In touch mode you may often not have something selected, so
// just call the first entry to make sure that [send] [send] calls the
// most recent entry.
position = 0;
}
final Cursor cursor = mAdapter.getCursor();
if (cursor != null && cursor.moveToPosition(position)) {
String number = cursor.getString(NUMBER_COLUMN_INDEX);
if (TextUtils.isEmpty(number)
|| number.equals(CallerInfo.UNKNOWN_NUMBER)
|| number.equals(CallerInfo.PRIVATE_NUMBER)
|| number.equals(CallerInfo.PAYPHONE_NUMBER)) {
// This number can't be called, do nothing
return;
}
int callType = cursor.getInt(CALL_TYPE_COLUMN_INDEX);
if (!number.startsWith("+") &&
(callType == Calls.INCOMING_TYPE
|| callType == Calls.MISSED_TYPE)) {
// If the caller-id matches a contact with a better qualified number, use it
number = getBetterNumberFromContacts(number);
}
Intent intent = new Intent(Intent.ACTION_CALL_PRIVILEGED,
Uri.fromParts("tel", number, null));
intent.setFlags(
Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
startActivity(intent);
}
}
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
if (mAdapter.isGroupHeader(position)) {
mAdapter.toggleGroup(position);
} else {
Intent intent = new Intent(this, CallDetailActivity.class);
intent.setData(ContentUris.withAppendedId(CallLog.Calls.CONTENT_URI, id));
startActivity(intent);
}
}
@Override
public void startSearch(String initialQuery, boolean selectInitialQuery, Bundle appSearchData,
boolean globalSearch) {
if (globalSearch) {
super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch);
} else {
ContactsSearchManager.startSearch(this, initialQuery);
}
}
}