1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 18 package android.provider; 19 20 import android.content.ContentProvider; 21 import android.content.ContentResolver; 22 import android.content.ContentValues; 23 import android.content.Context; 24 import android.content.Intent; 25 import android.content.pm.UserInfo; 26 import android.database.Cursor; 27 import android.location.Country; 28 import android.location.CountryDetector; 29 import android.net.Uri; 30 import android.os.UserHandle; 31 import android.os.UserManager; 32 import android.provider.ContactsContract.CommonDataKinds.Callable; 33 import android.provider.ContactsContract.CommonDataKinds.Phone; 34 import android.provider.ContactsContract.Data; 35 import android.provider.ContactsContract.DataUsageFeedback; 36 import android.telecom.PhoneAccount; 37 import android.telecom.PhoneAccountHandle; 38 import android.telecom.TelecomManager; 39 import android.telephony.PhoneNumberUtils; 40 import android.text.TextUtils; 41 import android.util.Log; 42 43 import com.android.internal.telephony.CallerInfo; 44 import com.android.internal.telephony.PhoneConstants; 45 46 import java.util.List; 47 48 /** 49 * The CallLog provider contains information about placed and received calls. 50 */ 51 public class CallLog { 52 private static final String LOG_TAG = "CallLog"; 53 private static final boolean VERBOSE_LOG = false; // DON'T SUBMIT WITH TRUE. 54 55 public static final String AUTHORITY = "call_log"; 56 57 /** 58 * The content:// style URL for this provider 59 */ 60 public static final Uri CONTENT_URI = 61 Uri.parse("content://" + AUTHORITY); 62 63 64 /** 65 * The "shadow" provider stores calllog when the real calllog provider is encrypted. The 66 * real provider will alter copy from it when it starts, and remove the entries in the shadow. 67 * 68 * <p>See the comment in {@link Calls#addCall} for the details. 69 * 70 * @hide 71 */ 72 public static final String SHADOW_AUTHORITY = "call_log_shadow"; 73 74 /** 75 * Contains the recent calls. 76 */ 77 public static class Calls implements BaseColumns { 78 /** 79 * The content:// style URL for this table 80 */ 81 public static final Uri CONTENT_URI = 82 Uri.parse("content://call_log/calls"); 83 84 /** @hide */ 85 public static final Uri SHADOW_CONTENT_URI = 86 Uri.parse("content://call_log_shadow/calls"); 87 88 /** 89 * The content:// style URL for filtering this table on phone numbers 90 */ 91 public static final Uri CONTENT_FILTER_URI = 92 Uri.parse("content://call_log/calls/filter"); 93 94 /** 95 * Query parameter used to limit the number of call logs returned. 96 * <p> 97 * TYPE: integer 98 */ 99 public static final String LIMIT_PARAM_KEY = "limit"; 100 101 /** 102 * Query parameter used to specify the starting record to return. 103 * <p> 104 * TYPE: integer 105 */ 106 public static final String OFFSET_PARAM_KEY = "offset"; 107 108 /** 109 * An optional URI parameter which instructs the provider to allow the operation to be 110 * applied to voicemail records as well. 111 * <p> 112 * TYPE: Boolean 113 * <p> 114 * Using this parameter with a value of {@code true} will result in a security error if the 115 * calling package does not have appropriate permissions to access voicemails. 116 * 117 * @hide 118 */ 119 public static final String ALLOW_VOICEMAILS_PARAM_KEY = "allow_voicemails"; 120 121 /** 122 * An optional extra used with {@link #CONTENT_TYPE Calls.CONTENT_TYPE} and 123 * {@link Intent#ACTION_VIEW} to specify that the presented list of calls should be 124 * filtered for a particular call type. 125 * 126 * Applications implementing a call log UI should check for this extra, and display a 127 * filtered list of calls based on the specified call type. If not applicable within the 128 * application's UI, it should be silently ignored. 129 * 130 * <p> 131 * The following example brings up the call log, showing only missed calls. 132 * <pre> 133 * Intent intent = new Intent(Intent.ACTION_VIEW); 134 * intent.setType(CallLog.Calls.CONTENT_TYPE); 135 * intent.putExtra(CallLog.Calls.EXTRA_CALL_TYPE_FILTER, CallLog.Calls.MISSED_TYPE); 136 * startActivity(intent); 137 * </pre> 138 * </p> 139 */ 140 public static final String EXTRA_CALL_TYPE_FILTER = 141 "android.provider.extra.CALL_TYPE_FILTER"; 142 143 /** 144 * Content uri used to access call log entries, including voicemail records. You must have 145 * the READ_CALL_LOG and WRITE_CALL_LOG permissions to read and write to the call log, as 146 * well as READ_VOICEMAIL and WRITE_VOICEMAIL permissions to read and write voicemails. 147 */ 148 public static final Uri CONTENT_URI_WITH_VOICEMAIL = CONTENT_URI.buildUpon() 149 .appendQueryParameter(ALLOW_VOICEMAILS_PARAM_KEY, "true") 150 .build(); 151 152 /** 153 * The default sort order for this table 154 */ 155 public static final String DEFAULT_SORT_ORDER = "date DESC"; 156 157 /** 158 * The MIME type of {@link #CONTENT_URI} and {@link #CONTENT_FILTER_URI} 159 * providing a directory of calls. 160 */ 161 public static final String CONTENT_TYPE = "vnd.android.cursor.dir/calls"; 162 163 /** 164 * The MIME type of a {@link #CONTENT_URI} sub-directory of a single 165 * call. 166 */ 167 public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/calls"; 168 169 /** 170 * The type of the call (incoming, outgoing or missed). 171 * <P>Type: INTEGER (int)</P> 172 * 173 * <p> 174 * Allowed values: 175 * <ul> 176 * <li>{@link #INCOMING_TYPE}</li> 177 * <li>{@link #OUTGOING_TYPE}</li> 178 * <li>{@link #MISSED_TYPE}</li> 179 * <li>{@link #VOICEMAIL_TYPE}</li> 180 * <li>{@link #REJECTED_TYPE}</li> 181 * <li>{@link #BLOCKED_TYPE}</li> 182 * </ul> 183 * </p> 184 */ 185 public static final String TYPE = "type"; 186 187 /** Call log type for incoming calls. */ 188 public static final int INCOMING_TYPE = 1; 189 /** Call log type for outgoing calls. */ 190 public static final int OUTGOING_TYPE = 2; 191 /** Call log type for missed calls. */ 192 public static final int MISSED_TYPE = 3; 193 /** Call log type for voicemails. */ 194 public static final int VOICEMAIL_TYPE = 4; 195 /** Call log type for calls rejected by direct user action. */ 196 public static final int REJECTED_TYPE = 5; 197 /** Call log type for calls blocked automatically. */ 198 public static final int BLOCKED_TYPE = 6; 199 /** 200 * Call log type for a call which was answered on another device. Used in situations where 201 * a call rings on multiple devices simultaneously and it ended up being answered on a 202 * device other than the current one. 203 * @hide 204 */ 205 public static final int ANSWERED_EXTERNALLY_TYPE = 7; 206 207 /** 208 * Bit-mask describing features of the call (e.g. video). 209 * 210 * <P>Type: INTEGER (int)</P> 211 */ 212 public static final String FEATURES = "features"; 213 214 /** Call had video. */ 215 public static final int FEATURES_VIDEO = 0x1; 216 217 /** 218 * Call was pulled externally. 219 * @hide 220 */ 221 public static final int FEATURES_PULLED_EXTERNALLY = 0x2; 222 223 /** 224 * The phone number as the user entered it. 225 * <P>Type: TEXT</P> 226 */ 227 public static final String NUMBER = "number"; 228 229 /** 230 * The number presenting rules set by the network. 231 * 232 * <p> 233 * Allowed values: 234 * <ul> 235 * <li>{@link #PRESENTATION_ALLOWED}</li> 236 * <li>{@link #PRESENTATION_RESTRICTED}</li> 237 * <li>{@link #PRESENTATION_UNKNOWN}</li> 238 * <li>{@link #PRESENTATION_PAYPHONE}</li> 239 * </ul> 240 * </p> 241 * 242 * <P>Type: INTEGER</P> 243 */ 244 public static final String NUMBER_PRESENTATION = "presentation"; 245 246 /** Number is allowed to display for caller id. */ 247 public static final int PRESENTATION_ALLOWED = 1; 248 /** Number is blocked by user. */ 249 public static final int PRESENTATION_RESTRICTED = 2; 250 /** Number is not specified or unknown by network. */ 251 public static final int PRESENTATION_UNKNOWN = 3; 252 /** Number is a pay phone. */ 253 public static final int PRESENTATION_PAYPHONE = 4; 254 255 /** 256 * The ISO 3166-1 two letters country code of the country where the 257 * user received or made the call. 258 * <P> 259 * Type: TEXT 260 * </P> 261 */ 262 public static final String COUNTRY_ISO = "countryiso"; 263 264 /** 265 * The date the call occured, in milliseconds since the epoch 266 * <P>Type: INTEGER (long)</P> 267 */ 268 public static final String DATE = "date"; 269 270 /** 271 * The duration of the call in seconds 272 * <P>Type: INTEGER (long)</P> 273 */ 274 public static final String DURATION = "duration"; 275 276 /** 277 * The data usage of the call in bytes. 278 * <P>Type: INTEGER (long)</P> 279 */ 280 public static final String DATA_USAGE = "data_usage"; 281 282 /** 283 * Whether or not the call has been acknowledged 284 * <P>Type: INTEGER (boolean)</P> 285 */ 286 public static final String NEW = "new"; 287 288 /** 289 * The cached name associated with the phone number, if it exists. 290 * This value is not guaranteed to be current, if the contact information 291 * associated with this number has changed. 292 * <P>Type: TEXT</P> 293 */ 294 public static final String CACHED_NAME = "name"; 295 296 /** 297 * The cached number type (Home, Work, etc) associated with the 298 * phone number, if it exists. 299 * This value is not guaranteed to be current, if the contact information 300 * associated with this number has changed. 301 * <P>Type: INTEGER</P> 302 */ 303 public static final String CACHED_NUMBER_TYPE = "numbertype"; 304 305 /** 306 * The cached number label, for a custom number type, associated with the 307 * phone number, if it exists. 308 * This value is not guaranteed to be current, if the contact information 309 * associated with this number has changed. 310 * <P>Type: TEXT</P> 311 */ 312 public static final String CACHED_NUMBER_LABEL = "numberlabel"; 313 314 /** 315 * URI of the voicemail entry. Populated only for {@link #VOICEMAIL_TYPE}. 316 * <P>Type: TEXT</P> 317 */ 318 public static final String VOICEMAIL_URI = "voicemail_uri"; 319 320 /** 321 * Transcription of the call or voicemail entry. This will only be populated for call log 322 * entries of type {@link #VOICEMAIL_TYPE} that have valid transcriptions. 323 */ 324 public static final String TRANSCRIPTION = "transcription"; 325 326 /** 327 * Whether this item has been read or otherwise consumed by the user. 328 * <p> 329 * Unlike the {@link #NEW} field, which requires the user to have acknowledged the 330 * existence of the entry, this implies the user has interacted with the entry. 331 * <P>Type: INTEGER (boolean)</P> 332 */ 333 public static final String IS_READ = "is_read"; 334 335 /** 336 * A geocoded location for the number associated with this call. 337 * <p> 338 * The string represents a city, state, or country associated with the number. 339 * <P>Type: TEXT</P> 340 */ 341 public static final String GEOCODED_LOCATION = "geocoded_location"; 342 343 /** 344 * The cached URI to look up the contact associated with the phone number, if it exists. 345 * This value may not be current if the contact information associated with this number 346 * has changed. 347 * <P>Type: TEXT</P> 348 */ 349 public static final String CACHED_LOOKUP_URI = "lookup_uri"; 350 351 /** 352 * The cached phone number of the contact which matches this entry, if it exists. 353 * This value may not be current if the contact information associated with this number 354 * has changed. 355 * <P>Type: TEXT</P> 356 */ 357 public static final String CACHED_MATCHED_NUMBER = "matched_number"; 358 359 /** 360 * The cached normalized(E164) version of the phone number, if it exists. 361 * This value may not be current if the contact information associated with this number 362 * has changed. 363 * <P>Type: TEXT</P> 364 */ 365 public static final String CACHED_NORMALIZED_NUMBER = "normalized_number"; 366 367 /** 368 * The cached photo id of the picture associated with the phone number, if it exists. 369 * This value may not be current if the contact information associated with this number 370 * has changed. 371 * <P>Type: INTEGER (long)</P> 372 */ 373 public static final String CACHED_PHOTO_ID = "photo_id"; 374 375 /** 376 * The cached photo URI of the picture associated with the phone number, if it exists. 377 * This value may not be current if the contact information associated with this number 378 * has changed. 379 * <P>Type: TEXT (URI)</P> 380 */ 381 public static final String CACHED_PHOTO_URI = "photo_uri"; 382 383 /** 384 * The cached phone number, formatted with formatting rules based on the country the 385 * user was in when the call was made or received. 386 * This value is not guaranteed to be present, and may not be current if the contact 387 * information associated with this number 388 * has changed. 389 * <P>Type: TEXT</P> 390 */ 391 public static final String CACHED_FORMATTED_NUMBER = "formatted_number"; 392 393 // Note: PHONE_ACCOUNT_* constant values are "subscription_*" due to a historic naming 394 // that was encoded into call log databases. 395 396 /** 397 * The component name of the account used to place or receive the call; in string form. 398 * <P>Type: TEXT</P> 399 */ 400 public static final String PHONE_ACCOUNT_COMPONENT_NAME = "subscription_component_name"; 401 402 /** 403 * The identifier for the account used to place or receive the call. 404 * <P>Type: TEXT</P> 405 */ 406 public static final String PHONE_ACCOUNT_ID = "subscription_id"; 407 408 /** 409 * The address associated with the account used to place or receive the call; in string 410 * form. For SIM-based calls, this is the user's own phone number. 411 * <P>Type: TEXT</P> 412 * 413 * @hide 414 */ 415 public static final String PHONE_ACCOUNT_ADDRESS = "phone_account_address"; 416 417 /** 418 * Indicates that the entry will be hidden from all queries until the associated 419 * {@link android.telecom.PhoneAccount} is registered with the system. 420 * <P>Type: INTEGER</P> 421 * 422 * @hide 423 */ 424 public static final String PHONE_ACCOUNT_HIDDEN = "phone_account_hidden"; 425 426 /** 427 * The subscription ID used to place this call. This is no longer used and has been 428 * replaced with PHONE_ACCOUNT_COMPONENT_NAME/PHONE_ACCOUNT_ID. 429 * For ContactsProvider internal use only. 430 * <P>Type: INTEGER</P> 431 * 432 * @Deprecated 433 * @hide 434 */ 435 public static final String SUB_ID = "sub_id"; 436 437 /** 438 * The post-dial portion of a dialed number, including any digits dialed after a 439 * {@link TelecomManager#DTMF_CHARACTER_PAUSE} or a {@link 440 * TelecomManager#DTMF_CHARACTER_WAIT} and these characters themselves. 441 * <P>Type: TEXT</P> 442 */ 443 public static final String POST_DIAL_DIGITS = "post_dial_digits"; 444 445 /** 446 * For an incoming call, the secondary line number the call was received via. 447 * When a SIM card has multiple phone numbers associated with it, the via number indicates 448 * which of the numbers associated with the SIM was called. 449 */ 450 public static final String VIA_NUMBER = "via_number"; 451 452 /** 453 * Indicates that the entry will be copied from primary user to other users. 454 * <P>Type: INTEGER</P> 455 * 456 * @hide 457 */ 458 public static final String ADD_FOR_ALL_USERS = "add_for_all_users"; 459 460 /** 461 * The date the row is last inserted, updated, or marked as deleted, in milliseconds 462 * since the epoch. Read only. 463 * <P>Type: INTEGER (long)</P> 464 */ 465 public static final String LAST_MODIFIED = "last_modified"; 466 467 /** 468 * If a successful call is made that is longer than this duration, update the phone number 469 * in the ContactsProvider with the normalized version of the number, based on the user's 470 * current country code. 471 */ 472 private static final int MIN_DURATION_FOR_NORMALIZED_NUMBER_UPDATE_MS = 1000 * 10; 473 474 /** 475 * Adds a call to the call log. 476 * 477 * @param ci the CallerInfo object to get the target contact from. Can be null 478 * if the contact is unknown. 479 * @param context the context used to get the ContentResolver 480 * @param number the phone number to be added to the calls db 481 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 482 * is set by the network and denotes the number presenting rules for 483 * "allowed", "payphone", "restricted" or "unknown" 484 * @param callType enumerated values for "incoming", "outgoing", or "missed" 485 * @param features features of the call (e.g. Video). 486 * @param accountHandle The accountHandle object identifying the provider of the call 487 * @param start time stamp for the call in milliseconds 488 * @param duration call duration in seconds 489 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 490 * the call. 491 * @result The URI of the call log entry belonging to the user that made or received this 492 * call. 493 * {@hide} 494 */ addCall(CallerInfo ci, Context context, String number, int presentation, int callType, int features, PhoneAccountHandle accountHandle, long start, int duration, Long dataUsage)495 public static Uri addCall(CallerInfo ci, Context context, String number, 496 int presentation, int callType, int features, PhoneAccountHandle accountHandle, 497 long start, int duration, Long dataUsage) { 498 return addCall(ci, context, number, /* postDialDigits =*/ "", /* viaNumber =*/ "", 499 presentation, callType, features, accountHandle, start, duration, 500 dataUsage, /* addForAllUsers =*/ false, /* userToBeInsertedTo =*/ null, 501 /* is_read =*/ false); 502 } 503 504 505 /** 506 * Adds a call to the call log. 507 * 508 * @param ci the CallerInfo object to get the target contact from. Can be null 509 * if the contact is unknown. 510 * @param context the context used to get the ContentResolver 511 * @param number the phone number to be added to the calls db 512 * @param viaNumber the secondary number that the incoming call received with. If the 513 * call was received with the SIM assigned number, then this field must be ''. 514 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 515 * is set by the network and denotes the number presenting rules for 516 * "allowed", "payphone", "restricted" or "unknown" 517 * @param callType enumerated values for "incoming", "outgoing", or "missed" 518 * @param features features of the call (e.g. Video). 519 * @param accountHandle The accountHandle object identifying the provider of the call 520 * @param start time stamp for the call in milliseconds 521 * @param duration call duration in seconds 522 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 523 * the call. 524 * @param addForAllUsers If true, the call is added to the call log of all currently 525 * running users. The caller must have the MANAGE_USERS permission if this is true. 526 * @param userToBeInsertedTo {@link UserHandle} of user that the call is going to be 527 * inserted to. null if it is inserted to the current user. The 528 * value is ignored if @{link addForAllUsers} is true. 529 * @result The URI of the call log entry belonging to the user that made or received this 530 * call. 531 * {@hide} 532 */ addCall(CallerInfo ci, Context context, String number, String postDialDigits, String viaNumber, int presentation, int callType, int features, PhoneAccountHandle accountHandle, long start, int duration, Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo)533 public static Uri addCall(CallerInfo ci, Context context, String number, 534 String postDialDigits, String viaNumber, int presentation, int callType, 535 int features, PhoneAccountHandle accountHandle, long start, int duration, 536 Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo) { 537 return addCall(ci, context, number, postDialDigits, viaNumber, presentation, callType, 538 features, accountHandle, start, duration, dataUsage, addForAllUsers, 539 userToBeInsertedTo, /* is_read =*/ false); 540 } 541 542 /** 543 * Adds a call to the call log. 544 * 545 * @param ci the CallerInfo object to get the target contact from. Can be null 546 * if the contact is unknown. 547 * @param context the context used to get the ContentResolver 548 * @param number the phone number to be added to the calls db 549 * @param postDialDigits the post-dial digits that were dialed after the number, 550 * if it was outgoing. Otherwise it is ''. 551 * @param viaNumber the secondary number that the incoming call received with. If the 552 * call was received with the SIM assigned number, then this field must be ''. 553 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 554 * is set by the network and denotes the number presenting rules for 555 * "allowed", "payphone", "restricted" or "unknown" 556 * @param callType enumerated values for "incoming", "outgoing", or "missed" 557 * @param features features of the call (e.g. Video). 558 * @param accountHandle The accountHandle object identifying the provider of the call 559 * @param start time stamp for the call in milliseconds 560 * @param duration call duration in seconds 561 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 562 * the call. 563 * @param addForAllUsers If true, the call is added to the call log of all currently 564 * running users. The caller must have the MANAGE_USERS permission if this is true. 565 * @param userToBeInsertedTo {@link UserHandle} of user that the call is going to be 566 * inserted to. null if it is inserted to the current user. The 567 * value is ignored if @{link addForAllUsers} is true. 568 * @param is_read Flag to show if the missed call log has been read by the user or not. 569 * Used for call log restore of missed calls. 570 * 571 * @result The URI of the call log entry belonging to the user that made or received this 572 * call. This could be of the shadow provider. Do not return it to non-system apps, 573 * as they don't have permissions. 574 * {@hide} 575 */ addCall(CallerInfo ci, Context context, String number, String postDialDigits, String viaNumber, int presentation, int callType, int features, PhoneAccountHandle accountHandle, long start, int duration, Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo, boolean is_read)576 public static Uri addCall(CallerInfo ci, Context context, String number, 577 String postDialDigits, String viaNumber, int presentation, int callType, 578 int features, PhoneAccountHandle accountHandle, long start, int duration, 579 Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo, 580 boolean is_read) { 581 if (VERBOSE_LOG) { 582 Log.v(LOG_TAG, String.format("Add call: number=%s, user=%s, for all=%s", 583 number, userToBeInsertedTo, addForAllUsers)); 584 } 585 final ContentResolver resolver = context.getContentResolver(); 586 int numberPresentation = PRESENTATION_ALLOWED; 587 588 TelecomManager tm = null; 589 try { 590 tm = TelecomManager.from(context); 591 } catch (UnsupportedOperationException e) {} 592 593 String accountAddress = null; 594 if (tm != null && accountHandle != null) { 595 PhoneAccount account = tm.getPhoneAccount(accountHandle); 596 if (account != null) { 597 Uri address = account.getSubscriptionAddress(); 598 if (address != null) { 599 accountAddress = address.getSchemeSpecificPart(); 600 } 601 } 602 } 603 604 // Remap network specified number presentation types 605 // PhoneConstants.PRESENTATION_xxx to calllog number presentation types 606 // Calls.PRESENTATION_xxx, in order to insulate the persistent calllog 607 // from any future radio changes. 608 // If the number field is empty set the presentation type to Unknown. 609 if (presentation == PhoneConstants.PRESENTATION_RESTRICTED) { 610 numberPresentation = PRESENTATION_RESTRICTED; 611 } else if (presentation == PhoneConstants.PRESENTATION_PAYPHONE) { 612 numberPresentation = PRESENTATION_PAYPHONE; 613 } else if (TextUtils.isEmpty(number) 614 || presentation == PhoneConstants.PRESENTATION_UNKNOWN) { 615 numberPresentation = PRESENTATION_UNKNOWN; 616 } 617 if (numberPresentation != PRESENTATION_ALLOWED) { 618 number = ""; 619 if (ci != null) { 620 ci.name = ""; 621 } 622 } 623 624 // accountHandle information 625 String accountComponentString = null; 626 String accountId = null; 627 if (accountHandle != null) { 628 accountComponentString = accountHandle.getComponentName().flattenToString(); 629 accountId = accountHandle.getId(); 630 } 631 632 ContentValues values = new ContentValues(6); 633 634 values.put(NUMBER, number); 635 values.put(POST_DIAL_DIGITS, postDialDigits); 636 values.put(VIA_NUMBER, viaNumber); 637 values.put(NUMBER_PRESENTATION, Integer.valueOf(numberPresentation)); 638 values.put(TYPE, Integer.valueOf(callType)); 639 values.put(FEATURES, features); 640 values.put(DATE, Long.valueOf(start)); 641 values.put(DURATION, Long.valueOf(duration)); 642 if (dataUsage != null) { 643 values.put(DATA_USAGE, dataUsage); 644 } 645 values.put(PHONE_ACCOUNT_COMPONENT_NAME, accountComponentString); 646 values.put(PHONE_ACCOUNT_ID, accountId); 647 values.put(PHONE_ACCOUNT_ADDRESS, accountAddress); 648 values.put(NEW, Integer.valueOf(1)); 649 values.put(ADD_FOR_ALL_USERS, addForAllUsers ? 1 : 0); 650 651 if (callType == MISSED_TYPE) { 652 values.put(IS_READ, Integer.valueOf(is_read ? 1 : 0)); 653 } 654 655 if ((ci != null) && (ci.contactIdOrZero > 0)) { 656 // Update usage information for the number associated with the contact ID. 657 // We need to use both the number and the ID for obtaining a data ID since other 658 // contacts may have the same number. 659 660 final Cursor cursor; 661 662 // We should prefer normalized one (probably coming from 663 // Phone.NORMALIZED_NUMBER column) first. If it isn't available try others. 664 if (ci.normalizedNumber != null) { 665 final String normalizedPhoneNumber = ci.normalizedNumber; 666 cursor = resolver.query(Phone.CONTENT_URI, 667 new String[] { Phone._ID }, 668 Phone.CONTACT_ID + " =? AND " + Phone.NORMALIZED_NUMBER + " =?", 669 new String[] { String.valueOf(ci.contactIdOrZero), 670 normalizedPhoneNumber}, 671 null); 672 } else { 673 final String phoneNumber = ci.phoneNumber != null ? ci.phoneNumber : number; 674 cursor = resolver.query( 675 Uri.withAppendedPath(Callable.CONTENT_FILTER_URI, 676 Uri.encode(phoneNumber)), 677 new String[] { Phone._ID }, 678 Phone.CONTACT_ID + " =?", 679 new String[] { String.valueOf(ci.contactIdOrZero) }, 680 null); 681 } 682 683 if (cursor != null) { 684 try { 685 if (cursor.getCount() > 0 && cursor.moveToFirst()) { 686 final String dataId = cursor.getString(0); 687 updateDataUsageStatForData(resolver, dataId); 688 if (duration >= MIN_DURATION_FOR_NORMALIZED_NUMBER_UPDATE_MS 689 && callType == Calls.OUTGOING_TYPE 690 && TextUtils.isEmpty(ci.normalizedNumber)) { 691 updateNormalizedNumber(context, resolver, dataId, number); 692 } 693 } 694 } finally { 695 cursor.close(); 696 } 697 } 698 } 699 700 /* 701 Writing the calllog works in the following way: 702 - All user entries 703 - if user-0 is encrypted, insert to user-0's shadow only. 704 (other users should also be encrypted, so nothing to do for other users.) 705 - if user-0 is decrypted, insert to user-0's real provider, as well as 706 all other users that are running and decrypted and should have calllog. 707 708 - Single user entry. 709 - If the target user is encryted, insert to its shadow. 710 - Otherwise insert to its real provider. 711 712 When the (real) calllog provider starts, it copies entries that it missed from 713 elsewhere. 714 - When user-0's (real) provider starts, it copies from user-0's shadow, and clears 715 the shadow. 716 717 - When other users (real) providers start, unless it shouldn't have calllog entries, 718 - Copy from the user's shadow, and clears the shadow. 719 - Copy from user-0's entries that are FOR_ALL_USERS = 1. (and don't clear it.) 720 */ 721 722 Uri result = null; 723 724 final UserManager userManager = context.getSystemService(UserManager.class); 725 final int currentUserId = userManager.getUserHandle(); 726 727 if (addForAllUsers) { 728 // First, insert to the system user. 729 final Uri uriForSystem = addEntryAndRemoveExpiredEntries( 730 context, userManager, UserHandle.SYSTEM, values); 731 if (uriForSystem == null 732 || SHADOW_AUTHORITY.equals(uriForSystem.getAuthority())) { 733 // This means the system user is still encrypted and the entry has inserted 734 // into the shadow. This means other users are still all encrypted. 735 // Nothing further to do; just return null. 736 return null; 737 } 738 if (UserHandle.USER_SYSTEM == currentUserId) { 739 result = uriForSystem; 740 } 741 742 // Otherwise, insert to all other users that are running and unlocked. 743 744 final List<UserInfo> users = userManager.getUsers(true); 745 746 final int count = users.size(); 747 for (int i = 0; i < count; i++) { 748 final UserInfo userInfo = users.get(i); 749 final UserHandle userHandle = userInfo.getUserHandle(); 750 final int userId = userHandle.getIdentifier(); 751 752 if (userHandle.isSystem()) { 753 // Already written. 754 continue; 755 } 756 757 if (!shouldHaveSharedCallLogEntries(context, userManager, userId)) { 758 // Shouldn't have calllog entries. 759 continue; 760 } 761 762 // For other users, we write only when they're running *and* decrypted. 763 // Other providers will copy from the system user's real provider, when they 764 // start. 765 if (userManager.isUserRunning(userHandle) 766 && userManager.isUserUnlocked(userHandle)) { 767 final Uri uri = addEntryAndRemoveExpiredEntries(context, userManager, 768 userHandle, values); 769 if (userId == currentUserId) { 770 result = uri; 771 } 772 } 773 } 774 } else { 775 // Single-user entry. Just write to that user, assuming it's running. If the 776 // user is encrypted, we write to the shadow calllog. 777 778 final UserHandle targetUserHandle = userToBeInsertedTo != null 779 ? userToBeInsertedTo 780 : UserHandle.of(currentUserId); 781 result = addEntryAndRemoveExpiredEntries(context, userManager, targetUserHandle, 782 values); 783 } 784 return result; 785 } 786 787 /** @hide */ shouldHaveSharedCallLogEntries(Context context, UserManager userManager, int userId)788 public static boolean shouldHaveSharedCallLogEntries(Context context, 789 UserManager userManager, int userId) { 790 if (userManager.hasUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS, 791 UserHandle.of(userId))) { 792 return false; 793 } 794 final UserInfo userInfo = userManager.getUserInfo(userId); 795 return userInfo != null && !userInfo.isManagedProfile(); 796 } 797 798 /** 799 * Query the call log database for the last dialed number. 800 * @param context Used to get the content resolver. 801 * @return The last phone number dialed (outgoing) or an empty 802 * string if none exist yet. 803 */ getLastOutgoingCall(Context context)804 public static String getLastOutgoingCall(Context context) { 805 final ContentResolver resolver = context.getContentResolver(); 806 Cursor c = null; 807 try { 808 c = resolver.query( 809 CONTENT_URI, 810 new String[] {NUMBER}, 811 TYPE + " = " + OUTGOING_TYPE, 812 null, 813 DEFAULT_SORT_ORDER + " LIMIT 1"); 814 if (c == null || !c.moveToFirst()) { 815 return ""; 816 } 817 return c.getString(0); 818 } finally { 819 if (c != null) c.close(); 820 } 821 } 822 addEntryAndRemoveExpiredEntries(Context context, UserManager userManager, UserHandle user, ContentValues values)823 private static Uri addEntryAndRemoveExpiredEntries(Context context, UserManager userManager, 824 UserHandle user, ContentValues values) { 825 final ContentResolver resolver = context.getContentResolver(); 826 827 // Since we're doing this operation on behalf of an app, we only 828 // want to use the actual "unlocked" state. 829 final Uri uri = ContentProvider.maybeAddUserId( 830 userManager.isUserUnlocked(user) ? CONTENT_URI : SHADOW_CONTENT_URI, 831 user.getIdentifier()); 832 833 if (VERBOSE_LOG) { 834 Log.v(LOG_TAG, String.format("Inserting to %s", uri)); 835 } 836 837 try { 838 final Uri result = resolver.insert(uri, values); 839 resolver.delete(uri, "_id IN " + 840 "(SELECT _id FROM calls ORDER BY " + DEFAULT_SORT_ORDER 841 + " LIMIT -1 OFFSET 500)", null); 842 return result; 843 } catch (IllegalArgumentException e) { 844 Log.w(LOG_TAG, "Failed to insert calllog", e); 845 // Even though we make sure the target user is running and decrypted before calling 846 // this method, there's a chance that the user just got shut down, in which case 847 // we'll still get "IllegalArgumentException: Unknown URL content://call_log/calls". 848 return null; 849 } 850 } 851 updateDataUsageStatForData(ContentResolver resolver, String dataId)852 private static void updateDataUsageStatForData(ContentResolver resolver, String dataId) { 853 final Uri feedbackUri = DataUsageFeedback.FEEDBACK_URI.buildUpon() 854 .appendPath(dataId) 855 .appendQueryParameter(DataUsageFeedback.USAGE_TYPE, 856 DataUsageFeedback.USAGE_TYPE_CALL) 857 .build(); 858 resolver.update(feedbackUri, new ContentValues(), null, null); 859 } 860 861 /* 862 * Update the normalized phone number for the given dataId in the ContactsProvider, based 863 * on the user's current country. 864 */ updateNormalizedNumber(Context context, ContentResolver resolver, String dataId, String number)865 private static void updateNormalizedNumber(Context context, ContentResolver resolver, 866 String dataId, String number) { 867 if (TextUtils.isEmpty(number) || TextUtils.isEmpty(dataId)) { 868 return; 869 } 870 final String countryIso = getCurrentCountryIso(context); 871 if (TextUtils.isEmpty(countryIso)) { 872 return; 873 } 874 final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, 875 getCurrentCountryIso(context)); 876 if (TextUtils.isEmpty(normalizedNumber)) { 877 return; 878 } 879 final ContentValues values = new ContentValues(); 880 values.put(Phone.NORMALIZED_NUMBER, normalizedNumber); 881 resolver.update(Data.CONTENT_URI, values, Data._ID + "=?", new String[] {dataId}); 882 } 883 getCurrentCountryIso(Context context)884 private static String getCurrentCountryIso(Context context) { 885 String countryIso = null; 886 final CountryDetector detector = (CountryDetector) context.getSystemService( 887 Context.COUNTRY_DETECTOR); 888 if (detector != null) { 889 final Country country = detector.detectCountry(); 890 if (country != null) { 891 countryIso = country.getCountryIso(); 892 } 893 } 894 return countryIso; 895 } 896 } 897 } 898