/*
* 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.internal.telephony;
import android.content.Context;
import android.database.Cursor;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.provider.ContactsContract.PhoneLookup;
import android.provider.ContactsContract.CommonDataKinds.Phone;
import static android.provider.ContactsContract.RawContacts;
import android.text.TextUtils;
import android.telephony.TelephonyManager;
import android.telephony.PhoneNumberUtils;
import android.util.Config;
import android.util.Log;
/**
* Looks up caller information for the given phone number.
*
* {@hide}
*/
public class CallerInfo {
private static final String TAG = "CallerInfo";
public static final String UNKNOWN_NUMBER = "-1";
public static final String PRIVATE_NUMBER = "-2";
public static final String PAYPHONE_NUMBER = "-3";
/**
* 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.
*
* 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.
*
* 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.
*
* 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.
*
* 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 phoneNumber;
public String cnapName;
public int numberPresentation;
public int namePresentation;
public boolean contactExists;
public String phoneLabel;
/* Split up the phoneLabel into number type and label name */
public int numberType;
public String numberLabel;
public int photoResource;
public long person_id;
public boolean needUpdate;
public Uri contactRefUri;
// 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. The isCachedPhotoCurrent flag indicates
* if the image data needs to be reloaded.
*/
public Drawable cachedPhoto;
public boolean isCachedPhotoCurrent;
private boolean mIsEmergency;
private boolean mIsVoiceMail;
public CallerInfo() {
// TODO: Move all the basic initialization here?
mIsEmergency = false;
mIsVoiceMail = false;
}
/**
* 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.photoResource = 0;
info.phoneLabel = null;
info.numberType = 0;
info.numberLabel = null;
info.cachedPhoto = null;
info.isCachedPhotoCurrent = false;
info.contactExists = false;
if (Config.LOGV) Log.v(TAG, "construct callerInfo from cursor");
if (cursor != null) {
if (cursor.moveToFirst()) {
// TODO: photo_id is always available but not taken
// care of here. Maybe we should store it in the
// CallerInfo object as well.
int columnIndex;
// Look for the name
columnIndex = cursor.getColumnIndex(PhoneLookup.DISPLAY_NAME);
if (columnIndex != -1) {
info.name = cursor.getString(columnIndex);
}
// Look for the number
columnIndex = cursor.getColumnIndex(PhoneLookup.NUMBER);
if (columnIndex != -1) {
info.phoneNumber = 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.getDisplayLabel(context,
info.numberType, info.numberLabel)
.toString();
}
}
// Look for the person ID.
// TODO: This is pretty ugly now, see bug 2269240 for
// more details. With tel: URI the contact id is in
// col "_id" while when we use a
// content://contacts/data/phones URI, the contact id
// is col "contact_id". As a work around we use the
// type of the contact url to figure out which column
// we should look at to get the contact_id.
final String mimeType = context.getContentResolver().getType(contactRef);
columnIndex = -1;
if (Phone.CONTENT_ITEM_TYPE.equals(mimeType)) {
// content://com.android.contacts/data/phones URL
columnIndex = cursor.getColumnIndex(RawContacts.CONTACT_ID);
} else {
// content://com.android.contacts/phone_lookup URL
// TODO: mime type is null here so we cannot test
// if we have the right url type. phone_lookup URL
// should resolve to a mime type.
columnIndex = cursor.getColumnIndex(PhoneLookup._ID);
}
if (columnIndex != -1) {
info.person_id = cursor.getLong(columnIndex);
} else {
Log.e(TAG, "Column missing for " + contactRef);
}
// 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)) {
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;
}
cursor.close();
}
info.needUpdate = false;
info.name = normalize(info.name);
info.contactRefUri = contactRef;
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.
*/
public static CallerInfo getCallerInfo(Context context, Uri contactRef) {
return getCallerInfo(context, contactRef,
context.getContentResolver().query(contactRef, null, null, null, null));
}
/**
* getCallerInfo given a phone number, look up in the call-log database
* for the matching caller id info.
* @param context the context used to get the ContentResolver
* @param number the phone number 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. If
* a matching number is not found, then a generic caller info is returned,
* with all relevant fields empty or null.
*/
public static CallerInfo getCallerInfo(Context context, String number) {
if (TextUtils.isEmpty(number)) {
return null;
}
// Change the callerInfo number ONLY if it is an emergency number
// or if it is the voicemail number. If it is either, take a
// shortcut and skip the query.
if (PhoneNumberUtils.isEmergencyNumber(number)) {
return new CallerInfo().markAsEmergency(context);
} else if (PhoneNumberUtils.isVoiceMailNumber(number)) {
return new CallerInfo().markAsVoiceMail();
}
Uri contactUri = Uri.withAppendedPath(PhoneLookup.CONTENT_FILTER_URI, Uri.encode(number));
CallerInfo info = getCallerInfo(context, contactUri);
// if no query results were returned with a viable number,
// fill in the original number value we used to query with.
if (TextUtils.isEmpty(info.phoneNumber)) {
info.phoneNumber = number;
}
return info;
}
/**
* getCallerId: a convenience method to get the caller id for a given
* number.
*
* @param context the context used to get the ContentResolver.
* @param number a phone number.
* @return if the number belongs to a contact, the contact's name is
* returned; otherwise, the number itself is returned.
*
* TODO NOTE: This MAY need to refer to the Asynchronous Query API
* [startQuery()], instead of getCallerInfo, but since it looks like
* it is only being used by the provider calls in the messaging app:
* 1. android.provider.Telephony.Mms.getDisplayAddress()
* 2. android.provider.Telephony.Sms.getDisplayAddress()
* We may not need to make the change.
*/
public static String getCallerId(Context context, String number) {
CallerInfo info = getCallerInfo(context, number);
String callerID = null;
if (info != null) {
String name = info.name;
if (!TextUtils.isEmpty(name)) {
callerID = name;
} else {
callerID = number;
}
}
return callerID;
}
// Accessors
/**
* @return true if the caller info is an emergency number.
*/
public boolean isEmergencyNumber() {
return mIsEmergency;
}
/**
* @return true if the caller info is a voicemail number.
*/
public boolean isVoiceMailNumber() {
return mIsVoiceMail;
}
/**
* Mark this CallerInfo as an emergency call.
* @param context To lookup the localized 'Emergency Number' string.
* @return this instance.
*/
// TODO: Note we're setting the phone number here (refer to
// javadoc comments at the top of CallerInfo class) to a localized
// string 'Emergency Number'. This is pretty bad because we are
// making UI work here instead of just packaging the data. We
// should set the phone number to the dialed number and name to
// 'Emergency Number' and let the UI make the decision about what
// should be displayed.
/* package */ CallerInfo markAsEmergency(Context context) {
phoneNumber = context.getString(
com.android.internal.R.string.emergency_call_dialog_number_for_display);
photoResource = com.android.internal.R.drawable.picture_emergency;
mIsEmergency = 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.
*/
// TODO: As in the emergency number handling, we end up writing a
// string in the phone number field.
/* package */ CallerInfo markAsVoiceMail() {
mIsVoiceMail = true;
try {
String voiceMailLabel = TelephonyManager.getDefault().getVoiceMailAlphaTag();
phoneNumber = voiceMailLabel;
} 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?
// FIXME: FIND ANOTHER ICON
// photoResource = android.R.drawable.badge_voicemail;
return this;
}
private static String normalize(String s) {
if (s == null || s.length() > 0) {
return s;
} else {
return null;
}
}
/**
* @return a string debug representation of this instance.
*/
public String toString() {
return new StringBuilder(384)
.append("\nname: " + name)
.append("\nphoneNumber: " + phoneNumber)
.append("\ncnapName: " + cnapName)
.append("\nnumberPresentation: " + numberPresentation)
.append("\nnamePresentation: " + namePresentation)
.append("\ncontactExits: " + contactExists)
.append("\nphoneLabel: " + phoneLabel)
.append("\nnumberType: " + numberType)
.append("\nnumberLabel: " + numberLabel)
.append("\nphotoResource: " + photoResource)
.append("\nperson_id: " + person_id)
.append("\nneedUpdate: " + needUpdate)
.append("\ncontactRefUri: " + contactRefUri)
.append("\ncontactRingtoneUri: " + contactRefUri)
.append("\nshouldSendToVoicemail: " + shouldSendToVoicemail)
.append("\ncachedPhoto: " + cachedPhoto)
.append("\nisCachedPhotoCurrent: " + isCachedPhotoCurrent)
.append("\nemergency: " + mIsEmergency)
.append("\nvoicemail " + mIsVoiceMail)
.toString();
}
}