/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.incallui;
import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.provider.ContactsContract;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import android.provider.ContactsContract.Contacts;
import android.provider.ContactsContract.Data;
import android.provider.ContactsContract.PhoneLookup;
import android.provider.ContactsContract.RawContacts;
import android.telephony.PhoneNumberUtils;
import android.text.TextUtils;
import com.android.contacts.common.ContactsUtils;
import com.android.contacts.common.ContactsUtils.UserType;
import com.android.contacts.common.util.TelephonyManagerUtils;
import com.android.dialer.logging.ContactLookupResult;
import com.android.dialer.phonenumbercache.ContactInfoHelper;
import com.android.dialer.phonenumberutil.PhoneNumberHelper;
/**
* Looks up caller information for the given phone number. This is intermediate data and should NOT
* be used by any UI.
*/
public class CallerInfo {
private static final String TAG = "CallerInfo";
private static final String[] DEFAULT_PHONELOOKUP_PROJECTION =
new String[] {
PhoneLookup.CONTACT_ID,
PhoneLookup.DISPLAY_NAME,
PhoneLookup.LOOKUP_KEY,
PhoneLookup.NUMBER,
PhoneLookup.NORMALIZED_NUMBER,
PhoneLookup.LABEL,
PhoneLookup.TYPE,
PhoneLookup.PHOTO_URI,
PhoneLookup.CUSTOM_RINGTONE,
PhoneLookup.SEND_TO_VOICEMAIL
};
/**
* Please note that, any one of these member variables can be null, and any accesses to them
* should be prepared to handle such a case.
*
* <p>Also, it is implied that phoneNumber is more often populated than name is, (think of calls
* being dialed/received using numbers where names are not known to the device), so phoneNumber
* should serve as a dependable fallback when name is unavailable.
*
* <p>One other detail here is that this CallerInfo object reflects information found on a
* connection, it is an OUTPUT that serves mainly to display information to the user. In no way is
* this object used as input to make a connection, so we can choose to display whatever
* human-readable text makes sense to the user for a connection. This is especially relevant for
* the phone number field, since it is the one field that is most likely exposed to the user.
*
* <p>As an example: 1. User dials "911" 2. Device recognizes that this is an emergency number 3.
* We use the "Emergency Number" string instead of "911" in the phoneNumber field.
*
* <p>What we're really doing here is treating phoneNumber as an essential field here, NOT name.
* We're NOT always guaranteed to have a name for a connection, but the number should be
* displayable.
*/
public String name;
public String nameAlternative;
public String phoneNumber;
public String normalizedNumber;
public String forwardingNumber;
public String geoDescription;
boolean shouldShowGeoDescription;
public String cnapName;
public int numberPresentation;
public int namePresentation;
public boolean contactExists;
public ContactLookupResult.Type contactLookupResultType = ContactLookupResult.Type.NOT_FOUND;
public String phoneLabel;
/* Split up the phoneLabel into number type and label name */
public int numberType;
public String numberLabel;
public int photoResource;
// Contact ID, which will be 0 if a contact comes from the corp CP2.
public long contactIdOrZero;
public String lookupKeyOrNull;
public boolean needUpdate;
public Uri contactRefUri;
public @UserType long userType;
/**
* Contact display photo URI. If a contact has no display photo but a thumbnail, it'll be the
* thumbnail URI instead.
*/
public Uri contactDisplayPhotoUri;
// fields to hold individual contact preference data,
// including the send to voicemail flag and the ringtone
// uri reference.
public Uri contactRingtoneUri;
public boolean shouldSendToVoicemail;
/**
* Drawable representing the caller image. This is essentially a cache for the image data tied
* into the connection / callerinfo object.
*
* <p>This might be a high resolution picture which is more suitable for full-screen image view
* than for smaller icons used in some kinds of notifications.
*
* <p>The {@link #isCachedPhotoCurrent} flag indicates if the image data needs to be reloaded.
*/
public Drawable cachedPhoto;
/**
* Bitmap representing the caller image which has possibly lower resolution than {@link
* #cachedPhoto} and thus more suitable for icons (like notification icons).
*
* <p>In usual cases this is just down-scaled image of {@link #cachedPhoto}. If the down-scaling
* fails, this will just become null.
*
* <p>The {@link #isCachedPhotoCurrent} flag indicates if the image data needs to be reloaded.
*/
public Bitmap cachedPhotoIcon;
/**
* Boolean which indicates if {@link #cachedPhoto} and {@link #cachedPhotoIcon} is fresh enough.
* If it is false, those images aren't pointing to valid objects.
*/
public boolean isCachedPhotoCurrent;
/**
* String which holds the call subject sent as extra from the lower layers for this call. This is
* used to display the no-caller ID reason for restricted/unknown number presentation.
*/
public String callSubject;
public String countryIso;
private boolean isEmergency;
private boolean isVoiceMail;
public CallerInfo() {
// TODO: Move all the basic initialization here?
isEmergency = false;
isVoiceMail = false;
userType = ContactsUtils.USER_TYPE_CURRENT;
}
static String[] getDefaultPhoneLookupProjection() {
return DEFAULT_PHONELOOKUP_PROJECTION;
}
/**
* getCallerInfo given a Cursor.
*
* @param context the context used to retrieve string constants
* @param contactRef the URI to attach to this CallerInfo object
* @param cursor the first object in the cursor is used to build the CallerInfo object.
* @return the CallerInfo which contains the caller id for the given number. The returned
* CallerInfo is null if no number is supplied.
*/
public static CallerInfo getCallerInfo(Context context, Uri contactRef, Cursor cursor) {
CallerInfo info = new CallerInfo();
info.cachedPhoto = null;
info.contactExists = false;
info.contactRefUri = contactRef;
info.isCachedPhotoCurrent = false;
info.name = null;
info.needUpdate = false;
info.numberLabel = null;
info.numberType = 0;
info.phoneLabel = null;
info.photoResource = 0;
info.userType = ContactsUtils.USER_TYPE_CURRENT;
Log.v(TAG, "getCallerInfo() based on cursor...");
if (cursor == null || !cursor.moveToFirst()) {
return info;
}
// TODO: photo_id is always available but not taken
// care of here. Maybe we should store it in the
// CallerInfo object as well.
long contactId = 0L;
int columnIndex;
// Look for the number
columnIndex = cursor.getColumnIndex(PhoneLookup.NUMBER);
if (columnIndex != -1) {
// The Contacts provider ignores special characters in phone numbers when searching for a
// contact. For example, number "123" is considered a match with a contact with number "#123".
// We need to check whether the result contains a number that truly matches the query and move
// the cursor to that position before filling in the fields in CallerInfo.
boolean hasNumberMatch =
PhoneNumberHelper.updateCursorToMatchContactLookupUri(cursor, columnIndex, contactRef);
if (hasNumberMatch) {
info.phoneNumber = cursor.getString(columnIndex);
} else {
return info;
}
}
// Look for the name
columnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
if (columnIndex != -1) {
info.name = normalize(cursor.getString(columnIndex));
}
// Look for the normalized number
columnIndex = cursor.getColumnIndex(PhoneLookup.NORMALIZED_NUMBER);
if (columnIndex != -1) {
info.normalizedNumber = cursor.getString(columnIndex);
}
// Look for the label/type combo
columnIndex = cursor.getColumnIndex(PhoneLookup.LABEL);
if (columnIndex != -1) {
int typeColumnIndex = cursor.getColumnIndex(PhoneLookup.TYPE);
if (typeColumnIndex != -1) {
info.numberType = cursor.getInt(typeColumnIndex);
info.numberLabel = cursor.getString(columnIndex);
info.phoneLabel =
Phone.getTypeLabel(context.getResources(), info.numberType, info.numberLabel)
.toString();
}
}
// cache the lookup key for later use to create lookup URIs
columnIndex = cursor.getColumnIndex(PhoneLookup.LOOKUP_KEY);
if (columnIndex != -1) {
info.lookupKeyOrNull = cursor.getString(columnIndex);
}
// Look for the person_id.
columnIndex = getColumnIndexForPersonId(contactRef, cursor);
if (columnIndex != -1) {
contactId = cursor.getLong(columnIndex);
if (contactId != 0 && !Contacts.isEnterpriseContactId(contactId)) {
info.contactIdOrZero = contactId;
Log.v(TAG, "==> got info.contactIdOrZero: " + info.contactIdOrZero);
}
} else {
// No valid columnIndex, so we can't look up person_id.
Log.v(TAG, "Couldn't find contactId column for " + contactRef);
// Watch out: this means that anything that depends on
// person_id will be broken (like contact photo lookups in
// the in-call UI, for example.)
}
// Display photo URI.
columnIndex = cursor.getColumnIndex(PhoneLookup.PHOTO_URI);
if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
info.contactDisplayPhotoUri = Uri.parse(cursor.getString(columnIndex));
} else {
info.contactDisplayPhotoUri = null;
}
// look for the custom ringtone, create from the string stored
// in the database.
columnIndex = cursor.getColumnIndex(PhoneLookup.CUSTOM_RINGTONE);
if ((columnIndex != -1) && (cursor.getString(columnIndex) != null)) {
if (TextUtils.isEmpty(cursor.getString(columnIndex))) {
// make it consistent with frameworks/base/.../CallerInfo.java
info.contactRingtoneUri = Uri.EMPTY;
} else {
info.contactRingtoneUri = Uri.parse(cursor.getString(columnIndex));
}
} else {
info.contactRingtoneUri = null;
}
// look for the send to voicemail flag, set it to true only
// under certain circumstances.
columnIndex = cursor.getColumnIndex(PhoneLookup.SEND_TO_VOICEMAIL);
info.shouldSendToVoicemail = (columnIndex != -1) && ((cursor.getInt(columnIndex)) == 1);
info.contactExists = true;
info.contactLookupResultType = ContactLookupResult.Type.LOCAL_CONTACT;
// Determine userType by directoryId and contactId
final String directory =
contactRef == null
? null
: contactRef.getQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY);
Long directoryId = null;
if (directory != null) {
try {
directoryId = Long.parseLong(directory);
} catch (NumberFormatException e) {
// do nothing
}
}
info.userType = ContactsUtils.determineUserType(directoryId, contactId);
info.nameAlternative =
ContactInfoHelper.lookUpDisplayNameAlternative(
context, info.lookupKeyOrNull, info.userType, directoryId);
cursor.close();
return info;
}
/**
* getCallerInfo given a URI, look up in the call-log database for the uri unique key.
*
* @param context the context used to get the ContentResolver
* @param contactRef the URI used to lookup caller id
* @return the CallerInfo which contains the caller id for the given number. The returned
* CallerInfo is null if no number is supplied.
*/
private static CallerInfo getCallerInfo(Context context, Uri contactRef) {
return getCallerInfo(
context,
contactRef,
context.getContentResolver().query(contactRef, null, null, null, null));
}
/**
* Performs another lookup if previous lookup fails and it's a SIP call and the peer's username is
* all numeric. Look up the username as it could be a PSTN number in the contact database.
*
* @param context the query context
* @param number the original phone number, could be a SIP URI
* @param previousResult the result of previous lookup
* @return previousResult if it's not the case
*/
static CallerInfo doSecondaryLookupIfNecessary(
Context context, String number, CallerInfo previousResult) {
if (!previousResult.contactExists && PhoneNumberHelper.isUriNumber(number)) {
String username = PhoneNumberHelper.getUsernameFromUriNumber(number);
if (PhoneNumberUtils.isGlobalPhoneNumber(username)) {
previousResult =
getCallerInfo(
context,
Uri.withAppendedPath(
PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, Uri.encode(username)));
}
}
return previousResult;
}
// Accessors
private static String normalize(String s) {
if (s == null || s.length() > 0) {
return s;
} else {
return null;
}
}
/**
* Returns the column index to use to find the "person_id" field in the specified cursor, based on
* the contact URI that was originally queried.
*
* <p>This is a helper function for the getCallerInfo() method that takes a Cursor. Looking up the
* person_id is nontrivial (compared to all the other CallerInfo fields) since the column we need
* to use depends on what query we originally ran.
*
* <p>Watch out: be sure to not do any database access in this method, since it's run from the UI
* thread (see comments below for more info.)
*
* @return the columnIndex to use (with cursor.getLong()) to get the person_id, or -1 if we
* couldn't figure out what colum to use.
* <p>TODO: Add a unittest for this method. (This is a little tricky to test, since we'll need
* a live contacts database to test against, preloaded with at least some phone numbers and
* SIP addresses. And we'll probably have to hardcode the column indexes we expect, so the
* test might break whenever the contacts schema changes. But we can at least make sure we
* handle all the URI patterns we claim to, and that the mime types match what we expect...)
*/
private static int getColumnIndexForPersonId(Uri contactRef, Cursor cursor) {
// TODO: This is pretty ugly now, see bug 2269240 for
// more details. The column to use depends upon the type of URL:
// - content://com.android.contacts/data/phones ==> use the "contact_id" column
// - content://com.android.contacts/phone_lookup ==> use the "_ID" column
// - content://com.android.contacts/data ==> use the "contact_id" column
// If it's none of the above, we leave columnIndex=-1 which means
// that the person_id field will be left unset.
//
// The logic here *used* to be based on the mime type of contactRef
// (for example Phone.CONTENT_ITEM_TYPE would tell us to use the
// RawContacts.CONTACT_ID column). But looking up the mime type requires
// a call to context.getContentResolver().getType(contactRef), which
// isn't safe to do from the UI thread since it can cause an ANR if
// the contacts provider is slow or blocked (like during a sync.)
//
// So instead, figure out the column to use for person_id by just
// looking at the URI itself.
Log.v(TAG, "- getColumnIndexForPersonId: contactRef URI = '" + contactRef + "'...");
// Warning: Do not enable the following logging (due to ANR risk.)
// if (VDBG) Rlog.v(TAG, "- MIME type: "
// + context.getContentResolver().getType(contactRef));
String url = contactRef.toString();
String columnName = null;
if (url.startsWith("content://com.android.contacts/data/phones")) {
// Direct lookup in the Phone table.
// MIME type: Phone.CONTENT_ITEM_TYPE (= "vnd.android.cursor.item/phone_v2")
Log.v(TAG, "'data/phones' URI; using RawContacts.CONTACT_ID");
columnName = RawContacts.CONTACT_ID;
} else if (url.startsWith("content://com.android.contacts/data")) {
// Direct lookup in the Data table.
// MIME type: Data.CONTENT_TYPE (= "vnd.android.cursor.dir/data")
Log.v(TAG, "'data' URI; using Data.CONTACT_ID");
// (Note Data.CONTACT_ID and RawContacts.CONTACT_ID are equivalent.)
columnName = Data.CONTACT_ID;
} else if (url.startsWith("content://com.android.contacts/phone_lookup")) {
// Lookup in the PhoneLookup table, which provides "fuzzy matching"
// for phone numbers.
// MIME type: PhoneLookup.CONTENT_TYPE (= "vnd.android.cursor.dir/phone_lookup")
Log.v(TAG, "'phone_lookup' URI; using PhoneLookup._ID");
columnName = PhoneLookup.CONTACT_ID;
} else {
Log.v(TAG, "Unexpected prefix for contactRef '" + url + "'");
}
int columnIndex = (columnName != null) ? cursor.getColumnIndex(columnName) : -1;
Log.v(
TAG,
"==> Using column '"
+ columnName
+ "' (columnIndex = "
+ columnIndex
+ ") for person_id lookup...");
return columnIndex;
}
/** @return true if the caller info is an emergency number. */
public boolean isEmergencyNumber() {
return isEmergency;
}
/** @return true if the caller info is a voicemail number. */
public boolean isVoiceMailNumber() {
return isVoiceMail;
}
/**
* Mark this CallerInfo as an emergency call.
*
* @param context To lookup the localized 'Emergency Number' string.
* @return this instance.
*/
/* package */ CallerInfo markAsEmergency(Context context) {
name = context.getString(R.string.emergency_number);
phoneNumber = null;
isEmergency = true;
return this;
}
/**
* Mark this CallerInfo as a voicemail call. The voicemail label is obtained from the telephony
* manager. Caller must hold the READ_PHONE_STATE permission otherwise the phoneNumber will be set
* to null.
*
* @return this instance.
*/
/* package */ CallerInfo markAsVoiceMail(Context context) {
isVoiceMail = true;
try {
// For voicemail calls, we display the voice mail tag
// instead of the real phone number in the "number"
// field.
name = TelephonyManagerUtils.getVoiceMailAlphaTag(context);
phoneNumber = null;
} catch (SecurityException se) {
// Should never happen: if this process does not have
// permission to retrieve VM tag, it should not have
// permission to retrieve VM number and would not call
// this method.
// Leave phoneNumber untouched.
Log.e(TAG, "Cannot access VoiceMail.", se);
}
// TODO: There is no voicemail picture?
// photoResource = android.R.drawable.badge_voicemail;
return this;
}
/**
* Updates this CallerInfo's geoDescription field, based on the raw phone number in the
* phoneNumber field.
*
* <p>(Note that the various getCallerInfo() methods do *not* set the geoDescription
* automatically; you need to call this method explicitly to get it.)
*
* @param context the context used to look up the current locale / country
* @param fallbackNumber if this CallerInfo's phoneNumber field is empty, this specifies a
* fallback number to use instead.
*/
public void updateGeoDescription(Context context, String fallbackNumber) {
String number = TextUtils.isEmpty(phoneNumber) ? fallbackNumber : phoneNumber;
geoDescription = PhoneNumberHelper.getGeoDescription(context, number, countryIso);
}
/** @return a string debug representation of this instance. */
@Override
public String toString() {
// Warning: never check in this file with VERBOSE_DEBUG = true
// because that will result in PII in the system log.
final boolean VERBOSE_DEBUG = false;
if (VERBOSE_DEBUG) {
return new StringBuilder(384)
.append(super.toString() + " { ")
.append("\nname: " + name)
.append("\nphoneNumber: " + phoneNumber)
.append("\nnormalizedNumber: " + normalizedNumber)
.append("\forwardingNumber: " + forwardingNumber)
.append("\ngeoDescription: " + geoDescription)
.append("\ncnapName: " + cnapName)
.append("\nnumberPresentation: " + numberPresentation)
.append("\nnamePresentation: " + namePresentation)
.append("\ncontactExists: " + contactExists)
.append("\nphoneLabel: " + phoneLabel)
.append("\nnumberType: " + numberType)
.append("\nnumberLabel: " + numberLabel)
.append("\nphotoResource: " + photoResource)
.append("\ncontactIdOrZero: " + contactIdOrZero)
.append("\nneedUpdate: " + needUpdate)
.append("\ncontactRefUri: " + contactRefUri)
.append("\ncontactRingtoneUri: " + contactRingtoneUri)
.append("\ncontactDisplayPhotoUri: " + contactDisplayPhotoUri)
.append("\nshouldSendToVoicemail: " + shouldSendToVoicemail)
.append("\ncachedPhoto: " + cachedPhoto)
.append("\nisCachedPhotoCurrent: " + isCachedPhotoCurrent)
.append("\nemergency: " + isEmergency)
.append("\nvoicemail: " + isVoiceMail)
.append("\nuserType: " + userType)
.append(" }")
.toString();
} else {
return new StringBuilder(128)
.append(super.toString() + " { ")
.append("name " + ((name == null) ? "null" : "non-null"))
.append(", phoneNumber " + ((phoneNumber == null) ? "null" : "non-null"))
.append(" }")
.toString();
}
}
}