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 * <li>{@link #ANSWERED_EXTERNALLY_TYPE}</li> 183 * </ul> 184 * </p> 185 */ 186 public static final String TYPE = "type"; 187 188 /** Call log type for incoming calls. */ 189 public static final int INCOMING_TYPE = 1; 190 /** Call log type for outgoing calls. */ 191 public static final int OUTGOING_TYPE = 2; 192 /** Call log type for missed calls. */ 193 public static final int MISSED_TYPE = 3; 194 /** Call log type for voicemails. */ 195 public static final int VOICEMAIL_TYPE = 4; 196 /** Call log type for calls rejected by direct user action. */ 197 public static final int REJECTED_TYPE = 5; 198 /** Call log type for calls blocked automatically. */ 199 public static final int BLOCKED_TYPE = 6; 200 /** 201 * Call log type for a call which was answered on another device. Used in situations where 202 * a call rings on multiple devices simultaneously and it ended up being answered on a 203 * device other than the current one. 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 /** Call was pulled externally. */ 218 public static final int FEATURES_PULLED_EXTERNALLY = 0x2; 219 220 /** Call was HD. */ 221 public static final int FEATURES_HD_CALL = 0x4; 222 223 /** Call was WIFI call. */ 224 public static final int FEATURES_WIFI = 0x8; 225 226 /** 227 * The phone number as the user entered it. 228 * <P>Type: TEXT</P> 229 */ 230 public static final String NUMBER = "number"; 231 232 /** 233 * The number presenting rules set by the network. 234 * 235 * <p> 236 * Allowed values: 237 * <ul> 238 * <li>{@link #PRESENTATION_ALLOWED}</li> 239 * <li>{@link #PRESENTATION_RESTRICTED}</li> 240 * <li>{@link #PRESENTATION_UNKNOWN}</li> 241 * <li>{@link #PRESENTATION_PAYPHONE}</li> 242 * </ul> 243 * </p> 244 * 245 * <P>Type: INTEGER</P> 246 */ 247 public static final String NUMBER_PRESENTATION = "presentation"; 248 249 /** Number is allowed to display for caller id. */ 250 public static final int PRESENTATION_ALLOWED = 1; 251 /** Number is blocked by user. */ 252 public static final int PRESENTATION_RESTRICTED = 2; 253 /** Number is not specified or unknown by network. */ 254 public static final int PRESENTATION_UNKNOWN = 3; 255 /** Number is a pay phone. */ 256 public static final int PRESENTATION_PAYPHONE = 4; 257 258 /** 259 * The ISO 3166-1 two letters country code of the country where the 260 * user received or made the call. 261 * <P> 262 * Type: TEXT 263 * </P> 264 */ 265 public static final String COUNTRY_ISO = "countryiso"; 266 267 /** 268 * The date the call occured, in milliseconds since the epoch 269 * <P>Type: INTEGER (long)</P> 270 */ 271 public static final String DATE = "date"; 272 273 /** 274 * The duration of the call in seconds 275 * <P>Type: INTEGER (long)</P> 276 */ 277 public static final String DURATION = "duration"; 278 279 /** 280 * The data usage of the call in bytes. 281 * <P>Type: INTEGER (long)</P> 282 */ 283 public static final String DATA_USAGE = "data_usage"; 284 285 /** 286 * Whether or not the call has been acknowledged 287 * <P>Type: INTEGER (boolean)</P> 288 */ 289 public static final String NEW = "new"; 290 291 /** 292 * The cached name associated with the phone number, if it exists. 293 * 294 * <p>This value is typically filled in by the dialer app for the caching purpose, 295 * so it's not guaranteed to be present, and may not be current if the contact 296 * information associated with this number has changed. 297 * <P>Type: TEXT</P> 298 */ 299 public static final String CACHED_NAME = "name"; 300 301 /** 302 * The cached number type (Home, Work, etc) associated with the 303 * phone number, if it exists. 304 * 305 * <p>This value is typically filled in by the dialer app for the caching purpose, 306 * so it's not guaranteed to be present, and may not be current if the contact 307 * information associated with this number has changed. 308 * <P>Type: INTEGER</P> 309 */ 310 public static final String CACHED_NUMBER_TYPE = "numbertype"; 311 312 /** 313 * The cached number label, for a custom number type, associated with the 314 * phone number, if it exists. 315 * 316 * <p>This value is typically filled in by the dialer app for the caching purpose, 317 * so it's not guaranteed to be present, and may not be current if the contact 318 * information associated with this number has changed. 319 * <P>Type: TEXT</P> 320 */ 321 public static final String CACHED_NUMBER_LABEL = "numberlabel"; 322 323 /** 324 * URI of the voicemail entry. Populated only for {@link #VOICEMAIL_TYPE}. 325 * <P>Type: TEXT</P> 326 */ 327 public static final String VOICEMAIL_URI = "voicemail_uri"; 328 329 /** 330 * Transcription of the call or voicemail entry. This will only be populated for call log 331 * entries of type {@link #VOICEMAIL_TYPE} that have valid transcriptions. 332 */ 333 public static final String TRANSCRIPTION = "transcription"; 334 335 /** 336 * State of voicemail transcription entry. This will only be populated for call log 337 * entries of type {@link #VOICEMAIL_TYPE}. 338 * @hide 339 */ 340 public static final String TRANSCRIPTION_STATE = "transcription_state"; 341 342 /** 343 * Whether this item has been read or otherwise consumed by the user. 344 * <p> 345 * Unlike the {@link #NEW} field, which requires the user to have acknowledged the 346 * existence of the entry, this implies the user has interacted with the entry. 347 * <P>Type: INTEGER (boolean)</P> 348 */ 349 public static final String IS_READ = "is_read"; 350 351 /** 352 * A geocoded location for the number associated with this call. 353 * <p> 354 * The string represents a city, state, or country associated with the number. 355 * <P>Type: TEXT</P> 356 */ 357 public static final String GEOCODED_LOCATION = "geocoded_location"; 358 359 /** 360 * The cached URI to look up the contact associated with the phone number, if it exists. 361 * 362 * <p>This value is typically filled in by the dialer app for the caching purpose, 363 * so it's not guaranteed to be present, and may not be current if the contact 364 * information associated with this number has changed. 365 * <P>Type: TEXT</P> 366 */ 367 public static final String CACHED_LOOKUP_URI = "lookup_uri"; 368 369 /** 370 * The cached phone number of the contact which matches this entry, if it exists. 371 * 372 * <p>This value is typically filled in by the dialer app for the caching purpose, 373 * so it's not guaranteed to be present, and may not be current if the contact 374 * information associated with this number has changed. 375 * <P>Type: TEXT</P> 376 */ 377 public static final String CACHED_MATCHED_NUMBER = "matched_number"; 378 379 /** 380 * The cached normalized(E164) version of the phone number, if it exists. 381 * 382 * <p>This value is typically filled in by the dialer app for the caching purpose, 383 * so it's not guaranteed to be present, and may not be current if the contact 384 * information associated with this number has changed. 385 * <P>Type: TEXT</P> 386 */ 387 public static final String CACHED_NORMALIZED_NUMBER = "normalized_number"; 388 389 /** 390 * The cached photo id of the picture associated with the phone number, if it exists. 391 * 392 * <p>This value is typically filled in by the dialer app for the caching purpose, 393 * so it's not guaranteed to be present, and may not be current if the contact 394 * information associated with this number has changed. 395 * <P>Type: INTEGER (long)</P> 396 */ 397 public static final String CACHED_PHOTO_ID = "photo_id"; 398 399 /** 400 * The cached photo URI of the picture associated with the phone number, if it exists. 401 * 402 * <p>This value is typically filled in by the dialer app for the caching purpose, 403 * so it's not guaranteed to be present, and may not be current if the contact 404 * information associated with this number has changed. 405 * <P>Type: TEXT (URI)</P> 406 */ 407 public static final String CACHED_PHOTO_URI = "photo_uri"; 408 409 /** 410 * The cached phone number, formatted with formatting rules based on the country the 411 * user was in when the call was made or received. 412 * 413 * <p>This value is typically filled in by the dialer app for the caching purpose, 414 * so it's not guaranteed to be present, and may not be current if the contact 415 * information associated with this number has changed. 416 * <P>Type: TEXT</P> 417 */ 418 public static final String CACHED_FORMATTED_NUMBER = "formatted_number"; 419 420 // Note: PHONE_ACCOUNT_* constant values are "subscription_*" due to a historic naming 421 // that was encoded into call log databases. 422 423 /** 424 * The component name of the account used to place or receive the call; in string form. 425 * <P>Type: TEXT</P> 426 */ 427 public static final String PHONE_ACCOUNT_COMPONENT_NAME = "subscription_component_name"; 428 429 /** 430 * The identifier for the account used to place or receive the call. 431 * <P>Type: TEXT</P> 432 */ 433 public static final String PHONE_ACCOUNT_ID = "subscription_id"; 434 435 /** 436 * The address associated with the account used to place or receive the call; in string 437 * form. For SIM-based calls, this is the user's own phone number. 438 * <P>Type: TEXT</P> 439 * 440 * @hide 441 */ 442 public static final String PHONE_ACCOUNT_ADDRESS = "phone_account_address"; 443 444 /** 445 * Indicates that the entry will be hidden from all queries until the associated 446 * {@link android.telecom.PhoneAccount} is registered with the system. 447 * <P>Type: INTEGER</P> 448 * 449 * @hide 450 */ 451 public static final String PHONE_ACCOUNT_HIDDEN = "phone_account_hidden"; 452 453 /** 454 * The subscription ID used to place this call. This is no longer used and has been 455 * replaced with PHONE_ACCOUNT_COMPONENT_NAME/PHONE_ACCOUNT_ID. 456 * For ContactsProvider internal use only. 457 * <P>Type: INTEGER</P> 458 * 459 * @Deprecated 460 * @hide 461 */ 462 public static final String SUB_ID = "sub_id"; 463 464 /** 465 * The post-dial portion of a dialed number, including any digits dialed after a 466 * {@link TelecomManager#DTMF_CHARACTER_PAUSE} or a {@link 467 * TelecomManager#DTMF_CHARACTER_WAIT} and these characters themselves. 468 * <P>Type: TEXT</P> 469 */ 470 public static final String POST_DIAL_DIGITS = "post_dial_digits"; 471 472 /** 473 * For an incoming call, the secondary line number the call was received via. 474 * When a SIM card has multiple phone numbers associated with it, the via number indicates 475 * which of the numbers associated with the SIM was called. 476 */ 477 public static final String VIA_NUMBER = "via_number"; 478 479 /** 480 * Indicates that the entry will be copied from primary user to other users. 481 * <P>Type: INTEGER</P> 482 * 483 * @hide 484 */ 485 public static final String ADD_FOR_ALL_USERS = "add_for_all_users"; 486 487 /** 488 * The date the row is last inserted, updated, or marked as deleted, in milliseconds 489 * since the epoch. Read only. 490 * <P>Type: INTEGER (long)</P> 491 */ 492 public static final String LAST_MODIFIED = "last_modified"; 493 494 /** 495 * If a successful call is made that is longer than this duration, update the phone number 496 * in the ContactsProvider with the normalized version of the number, based on the user's 497 * current country code. 498 */ 499 private static final int MIN_DURATION_FOR_NORMALIZED_NUMBER_UPDATE_MS = 1000 * 10; 500 501 /** 502 * Adds a call to the call log. 503 * 504 * @param ci the CallerInfo object to get the target contact from. Can be null 505 * if the contact is unknown. 506 * @param context the context used to get the ContentResolver 507 * @param number the phone number to be added to the calls db 508 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 509 * is set by the network and denotes the number presenting rules for 510 * "allowed", "payphone", "restricted" or "unknown" 511 * @param callType enumerated values for "incoming", "outgoing", or "missed" 512 * @param features features of the call (e.g. Video). 513 * @param accountHandle The accountHandle object identifying the provider of the call 514 * @param start time stamp for the call in milliseconds 515 * @param duration call duration in seconds 516 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 517 * the call. 518 * @result The URI of the call log entry belonging to the user that made or received this 519 * call. 520 * {@hide} 521 */ addCall(CallerInfo ci, Context context, String number, int presentation, int callType, int features, PhoneAccountHandle accountHandle, long start, int duration, Long dataUsage)522 public static Uri addCall(CallerInfo ci, Context context, String number, 523 int presentation, int callType, int features, PhoneAccountHandle accountHandle, 524 long start, int duration, Long dataUsage) { 525 return addCall(ci, context, number, /* postDialDigits =*/ "", /* viaNumber =*/ "", 526 presentation, callType, features, accountHandle, start, duration, 527 dataUsage, /* addForAllUsers =*/ false, /* userToBeInsertedTo =*/ null, 528 /* is_read =*/ false); 529 } 530 531 532 /** 533 * Adds a call to the call log. 534 * 535 * @param ci the CallerInfo object to get the target contact from. Can be null 536 * if the contact is unknown. 537 * @param context the context used to get the ContentResolver 538 * @param number the phone number to be added to the calls db 539 * @param viaNumber the secondary number that the incoming call received with. If the 540 * call was received with the SIM assigned number, then this field must be ''. 541 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 542 * is set by the network and denotes the number presenting rules for 543 * "allowed", "payphone", "restricted" or "unknown" 544 * @param callType enumerated values for "incoming", "outgoing", or "missed" 545 * @param features features of the call (e.g. Video). 546 * @param accountHandle The accountHandle object identifying the provider of the call 547 * @param start time stamp for the call in milliseconds 548 * @param duration call duration in seconds 549 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 550 * the call. 551 * @param addForAllUsers If true, the call is added to the call log of all currently 552 * running users. The caller must have the MANAGE_USERS permission if this is true. 553 * @param userToBeInsertedTo {@link UserHandle} of user that the call is going to be 554 * inserted to. null if it is inserted to the current user. The 555 * value is ignored if @{link addForAllUsers} is true. 556 * @result The URI of the call log entry belonging to the user that made or received this 557 * call. 558 * {@hide} 559 */ 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)560 public static Uri addCall(CallerInfo ci, Context context, String number, 561 String postDialDigits, String viaNumber, int presentation, int callType, 562 int features, PhoneAccountHandle accountHandle, long start, int duration, 563 Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo) { 564 return addCall(ci, context, number, postDialDigits, viaNumber, presentation, callType, 565 features, accountHandle, start, duration, dataUsage, addForAllUsers, 566 userToBeInsertedTo, /* is_read =*/ false); 567 } 568 569 /** 570 * Adds a call to the call log. 571 * 572 * @param ci the CallerInfo object to get the target contact from. Can be null 573 * if the contact is unknown. 574 * @param context the context used to get the ContentResolver 575 * @param number the phone number to be added to the calls db 576 * @param postDialDigits the post-dial digits that were dialed after the number, 577 * if it was outgoing. Otherwise it is ''. 578 * @param viaNumber the secondary number that the incoming call received with. If the 579 * call was received with the SIM assigned number, then this field must be ''. 580 * @param presentation enum value from PhoneConstants.PRESENTATION_xxx, which 581 * is set by the network and denotes the number presenting rules for 582 * "allowed", "payphone", "restricted" or "unknown" 583 * @param callType enumerated values for "incoming", "outgoing", or "missed" 584 * @param features features of the call (e.g. Video). 585 * @param accountHandle The accountHandle object identifying the provider of the call 586 * @param start time stamp for the call in milliseconds 587 * @param duration call duration in seconds 588 * @param dataUsage data usage for the call in bytes, null if data usage was not tracked for 589 * the call. 590 * @param addForAllUsers If true, the call is added to the call log of all currently 591 * running users. The caller must have the MANAGE_USERS permission if this is true. 592 * @param userToBeInsertedTo {@link UserHandle} of user that the call is going to be 593 * inserted to. null if it is inserted to the current user. The 594 * value is ignored if @{link addForAllUsers} is true. 595 * @param is_read Flag to show if the missed call log has been read by the user or not. 596 * Used for call log restore of missed calls. 597 * 598 * @result The URI of the call log entry belonging to the user that made or received this 599 * call. This could be of the shadow provider. Do not return it to non-system apps, 600 * as they don't have permissions. 601 * {@hide} 602 */ 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)603 public static Uri addCall(CallerInfo ci, Context context, String number, 604 String postDialDigits, String viaNumber, int presentation, int callType, 605 int features, PhoneAccountHandle accountHandle, long start, int duration, 606 Long dataUsage, boolean addForAllUsers, UserHandle userToBeInsertedTo, 607 boolean is_read) { 608 if (VERBOSE_LOG) { 609 Log.v(LOG_TAG, String.format("Add call: number=%s, user=%s, for all=%s", 610 number, userToBeInsertedTo, addForAllUsers)); 611 } 612 final ContentResolver resolver = context.getContentResolver(); 613 int numberPresentation = PRESENTATION_ALLOWED; 614 615 TelecomManager tm = null; 616 try { 617 tm = TelecomManager.from(context); 618 } catch (UnsupportedOperationException e) {} 619 620 String accountAddress = null; 621 if (tm != null && accountHandle != null) { 622 PhoneAccount account = tm.getPhoneAccount(accountHandle); 623 if (account != null) { 624 Uri address = account.getSubscriptionAddress(); 625 if (address != null) { 626 accountAddress = address.getSchemeSpecificPart(); 627 } 628 } 629 } 630 631 // Remap network specified number presentation types 632 // PhoneConstants.PRESENTATION_xxx to calllog number presentation types 633 // Calls.PRESENTATION_xxx, in order to insulate the persistent calllog 634 // from any future radio changes. 635 // If the number field is empty set the presentation type to Unknown. 636 if (presentation == PhoneConstants.PRESENTATION_RESTRICTED) { 637 numberPresentation = PRESENTATION_RESTRICTED; 638 } else if (presentation == PhoneConstants.PRESENTATION_PAYPHONE) { 639 numberPresentation = PRESENTATION_PAYPHONE; 640 } else if (TextUtils.isEmpty(number) 641 || presentation == PhoneConstants.PRESENTATION_UNKNOWN) { 642 numberPresentation = PRESENTATION_UNKNOWN; 643 } 644 if (numberPresentation != PRESENTATION_ALLOWED) { 645 number = ""; 646 if (ci != null) { 647 ci.name = ""; 648 } 649 } 650 651 // accountHandle information 652 String accountComponentString = null; 653 String accountId = null; 654 if (accountHandle != null) { 655 accountComponentString = accountHandle.getComponentName().flattenToString(); 656 accountId = accountHandle.getId(); 657 } 658 659 ContentValues values = new ContentValues(6); 660 661 values.put(NUMBER, number); 662 values.put(POST_DIAL_DIGITS, postDialDigits); 663 values.put(VIA_NUMBER, viaNumber); 664 values.put(NUMBER_PRESENTATION, Integer.valueOf(numberPresentation)); 665 values.put(TYPE, Integer.valueOf(callType)); 666 values.put(FEATURES, features); 667 values.put(DATE, Long.valueOf(start)); 668 values.put(DURATION, Long.valueOf(duration)); 669 if (dataUsage != null) { 670 values.put(DATA_USAGE, dataUsage); 671 } 672 values.put(PHONE_ACCOUNT_COMPONENT_NAME, accountComponentString); 673 values.put(PHONE_ACCOUNT_ID, accountId); 674 values.put(PHONE_ACCOUNT_ADDRESS, accountAddress); 675 values.put(NEW, Integer.valueOf(1)); 676 values.put(ADD_FOR_ALL_USERS, addForAllUsers ? 1 : 0); 677 678 if (callType == MISSED_TYPE) { 679 values.put(IS_READ, Integer.valueOf(is_read ? 1 : 0)); 680 } 681 682 if ((ci != null) && (ci.contactIdOrZero > 0)) { 683 // Update usage information for the number associated with the contact ID. 684 // We need to use both the number and the ID for obtaining a data ID since other 685 // contacts may have the same number. 686 687 final Cursor cursor; 688 689 // We should prefer normalized one (probably coming from 690 // Phone.NORMALIZED_NUMBER column) first. If it isn't available try others. 691 if (ci.normalizedNumber != null) { 692 final String normalizedPhoneNumber = ci.normalizedNumber; 693 cursor = resolver.query(Phone.CONTENT_URI, 694 new String[] { Phone._ID }, 695 Phone.CONTACT_ID + " =? AND " + Phone.NORMALIZED_NUMBER + " =?", 696 new String[] { String.valueOf(ci.contactIdOrZero), 697 normalizedPhoneNumber}, 698 null); 699 } else { 700 final String phoneNumber = ci.phoneNumber != null ? ci.phoneNumber : number; 701 cursor = resolver.query( 702 Uri.withAppendedPath(Callable.CONTENT_FILTER_URI, 703 Uri.encode(phoneNumber)), 704 new String[] { Phone._ID }, 705 Phone.CONTACT_ID + " =?", 706 new String[] { String.valueOf(ci.contactIdOrZero) }, 707 null); 708 } 709 710 if (cursor != null) { 711 try { 712 if (cursor.getCount() > 0 && cursor.moveToFirst()) { 713 final String dataId = cursor.getString(0); 714 updateDataUsageStatForData(resolver, dataId); 715 if (duration >= MIN_DURATION_FOR_NORMALIZED_NUMBER_UPDATE_MS 716 && callType == Calls.OUTGOING_TYPE 717 && TextUtils.isEmpty(ci.normalizedNumber)) { 718 updateNormalizedNumber(context, resolver, dataId, number); 719 } 720 } 721 } finally { 722 cursor.close(); 723 } 724 } 725 } 726 727 /* 728 Writing the calllog works in the following way: 729 - All user entries 730 - if user-0 is encrypted, insert to user-0's shadow only. 731 (other users should also be encrypted, so nothing to do for other users.) 732 - if user-0 is decrypted, insert to user-0's real provider, as well as 733 all other users that are running and decrypted and should have calllog. 734 735 - Single user entry. 736 - If the target user is encryted, insert to its shadow. 737 - Otherwise insert to its real provider. 738 739 When the (real) calllog provider starts, it copies entries that it missed from 740 elsewhere. 741 - When user-0's (real) provider starts, it copies from user-0's shadow, and clears 742 the shadow. 743 744 - When other users (real) providers start, unless it shouldn't have calllog entries, 745 - Copy from the user's shadow, and clears the shadow. 746 - Copy from user-0's entries that are FOR_ALL_USERS = 1. (and don't clear it.) 747 */ 748 749 Uri result = null; 750 751 final UserManager userManager = context.getSystemService(UserManager.class); 752 final int currentUserId = userManager.getUserHandle(); 753 754 if (addForAllUsers) { 755 // First, insert to the system user. 756 final Uri uriForSystem = addEntryAndRemoveExpiredEntries( 757 context, userManager, UserHandle.SYSTEM, values); 758 if (uriForSystem == null 759 || SHADOW_AUTHORITY.equals(uriForSystem.getAuthority())) { 760 // This means the system user is still encrypted and the entry has inserted 761 // into the shadow. This means other users are still all encrypted. 762 // Nothing further to do; just return null. 763 return null; 764 } 765 if (UserHandle.USER_SYSTEM == currentUserId) { 766 result = uriForSystem; 767 } 768 769 // Otherwise, insert to all other users that are running and unlocked. 770 771 final List<UserInfo> users = userManager.getUsers(true); 772 773 final int count = users.size(); 774 for (int i = 0; i < count; i++) { 775 final UserInfo userInfo = users.get(i); 776 final UserHandle userHandle = userInfo.getUserHandle(); 777 final int userId = userHandle.getIdentifier(); 778 779 if (userHandle.isSystem()) { 780 // Already written. 781 continue; 782 } 783 784 if (!shouldHaveSharedCallLogEntries(context, userManager, userId)) { 785 // Shouldn't have calllog entries. 786 continue; 787 } 788 789 // For other users, we write only when they're running *and* decrypted. 790 // Other providers will copy from the system user's real provider, when they 791 // start. 792 if (userManager.isUserRunning(userHandle) 793 && userManager.isUserUnlocked(userHandle)) { 794 final Uri uri = addEntryAndRemoveExpiredEntries(context, userManager, 795 userHandle, values); 796 if (userId == currentUserId) { 797 result = uri; 798 } 799 } 800 } 801 } else { 802 // Single-user entry. Just write to that user, assuming it's running. If the 803 // user is encrypted, we write to the shadow calllog. 804 805 final UserHandle targetUserHandle = userToBeInsertedTo != null 806 ? userToBeInsertedTo 807 : UserHandle.of(currentUserId); 808 result = addEntryAndRemoveExpiredEntries(context, userManager, targetUserHandle, 809 values); 810 } 811 return result; 812 } 813 814 /** @hide */ shouldHaveSharedCallLogEntries(Context context, UserManager userManager, int userId)815 public static boolean shouldHaveSharedCallLogEntries(Context context, 816 UserManager userManager, int userId) { 817 if (userManager.hasUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS, 818 UserHandle.of(userId))) { 819 return false; 820 } 821 final UserInfo userInfo = userManager.getUserInfo(userId); 822 return userInfo != null && !userInfo.isManagedProfile(); 823 } 824 825 /** 826 * Query the call log database for the last dialed number. 827 * @param context Used to get the content resolver. 828 * @return The last phone number dialed (outgoing) or an empty 829 * string if none exist yet. 830 */ getLastOutgoingCall(Context context)831 public static String getLastOutgoingCall(Context context) { 832 final ContentResolver resolver = context.getContentResolver(); 833 Cursor c = null; 834 try { 835 c = resolver.query( 836 CONTENT_URI, 837 new String[] {NUMBER}, 838 TYPE + " = " + OUTGOING_TYPE, 839 null, 840 DEFAULT_SORT_ORDER + " LIMIT 1"); 841 if (c == null || !c.moveToFirst()) { 842 return ""; 843 } 844 return c.getString(0); 845 } finally { 846 if (c != null) c.close(); 847 } 848 } 849 addEntryAndRemoveExpiredEntries(Context context, UserManager userManager, UserHandle user, ContentValues values)850 private static Uri addEntryAndRemoveExpiredEntries(Context context, UserManager userManager, 851 UserHandle user, ContentValues values) { 852 final ContentResolver resolver = context.getContentResolver(); 853 854 // Since we're doing this operation on behalf of an app, we only 855 // want to use the actual "unlocked" state. 856 final Uri uri = ContentProvider.maybeAddUserId( 857 userManager.isUserUnlocked(user) ? CONTENT_URI : SHADOW_CONTENT_URI, 858 user.getIdentifier()); 859 860 if (VERBOSE_LOG) { 861 Log.v(LOG_TAG, String.format("Inserting to %s", uri)); 862 } 863 864 try { 865 // When cleaning up the call log, try to delete older call long entries on a per 866 // PhoneAccount basis first. There can be multiple ConnectionServices causing 867 // the addition of entries in the call log. With the introduction of Self-Managed 868 // ConnectionServices, we want to ensure that a misbehaving self-managed CS cannot 869 // spam the call log with its own entries, causing entries from Telephony to be 870 // removed. 871 final Uri result = resolver.insert(uri, values); 872 if (values.containsKey(PHONE_ACCOUNT_ID) 873 && !TextUtils.isEmpty(values.getAsString(PHONE_ACCOUNT_ID)) 874 && values.containsKey(PHONE_ACCOUNT_COMPONENT_NAME) 875 && !TextUtils.isEmpty(values.getAsString(PHONE_ACCOUNT_COMPONENT_NAME))) { 876 // Only purge entries for the same phone account. 877 resolver.delete(uri, "_id IN " + 878 "(SELECT _id FROM calls" 879 + " WHERE " + PHONE_ACCOUNT_COMPONENT_NAME + " = ?" 880 + " AND " + PHONE_ACCOUNT_ID + " = ?" 881 + " ORDER BY " + DEFAULT_SORT_ORDER 882 + " LIMIT -1 OFFSET 500)", new String[] { 883 values.getAsString(PHONE_ACCOUNT_COMPONENT_NAME), 884 values.getAsString(PHONE_ACCOUNT_ID) 885 }); 886 } else { 887 // No valid phone account specified, so default to the old behavior. 888 resolver.delete(uri, "_id IN " + 889 "(SELECT _id FROM calls ORDER BY " + DEFAULT_SORT_ORDER 890 + " LIMIT -1 OFFSET 500)", null); 891 } 892 893 return result; 894 } catch (IllegalArgumentException e) { 895 Log.w(LOG_TAG, "Failed to insert calllog", e); 896 // Even though we make sure the target user is running and decrypted before calling 897 // this method, there's a chance that the user just got shut down, in which case 898 // we'll still get "IllegalArgumentException: Unknown URL content://call_log/calls". 899 return null; 900 } 901 } 902 updateDataUsageStatForData(ContentResolver resolver, String dataId)903 private static void updateDataUsageStatForData(ContentResolver resolver, String dataId) { 904 final Uri feedbackUri = DataUsageFeedback.FEEDBACK_URI.buildUpon() 905 .appendPath(dataId) 906 .appendQueryParameter(DataUsageFeedback.USAGE_TYPE, 907 DataUsageFeedback.USAGE_TYPE_CALL) 908 .build(); 909 resolver.update(feedbackUri, new ContentValues(), null, null); 910 } 911 912 /* 913 * Update the normalized phone number for the given dataId in the ContactsProvider, based 914 * on the user's current country. 915 */ updateNormalizedNumber(Context context, ContentResolver resolver, String dataId, String number)916 private static void updateNormalizedNumber(Context context, ContentResolver resolver, 917 String dataId, String number) { 918 if (TextUtils.isEmpty(number) || TextUtils.isEmpty(dataId)) { 919 return; 920 } 921 final String countryIso = getCurrentCountryIso(context); 922 if (TextUtils.isEmpty(countryIso)) { 923 return; 924 } 925 final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, 926 getCurrentCountryIso(context)); 927 if (TextUtils.isEmpty(normalizedNumber)) { 928 return; 929 } 930 final ContentValues values = new ContentValues(); 931 values.put(Phone.NORMALIZED_NUMBER, normalizedNumber); 932 resolver.update(Data.CONTENT_URI, values, Data._ID + "=?", new String[] {dataId}); 933 } 934 getCurrentCountryIso(Context context)935 private static String getCurrentCountryIso(Context context) { 936 String countryIso = null; 937 final CountryDetector detector = (CountryDetector) context.getSystemService( 938 Context.COUNTRY_DETECTOR); 939 if (detector != null) { 940 final Country country = detector.detectCountry(); 941 if (country != null) { 942 countryIso = country.getCountryIso(); 943 } 944 } 945 return countryIso; 946 } 947 } 948 } 949