1/* 2 * Copyright (C) 2011 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 17package com.android.dialer.app.calllog; 18 19import android.database.Cursor; 20import android.os.Build.VERSION; 21import android.os.Build.VERSION_CODES; 22import android.support.annotation.Nullable; 23import android.support.annotation.VisibleForTesting; 24import android.telephony.PhoneNumberUtils; 25import android.text.TextUtils; 26import android.text.format.Time; 27import com.android.contacts.common.util.DateUtils; 28import com.android.dialer.calllogutils.CallbackActionHelper; 29import com.android.dialer.calllogutils.CallbackActionHelper.CallbackAction; 30import com.android.dialer.compat.AppCompatConstants; 31import com.android.dialer.compat.telephony.TelephonyManagerCompat; 32import com.android.dialer.phonenumbercache.CallLogQuery; 33import com.android.dialer.phonenumberutil.PhoneNumberHelper; 34import java.util.Objects; 35 36/** 37 * Groups together calls in the call log. The primary grouping attempts to group together calls to 38 * and from the same number into a single row on the call log. A secondary grouping assigns calls, 39 * grouped via the primary grouping, to "day groups". The day groups provide a means of identifying 40 * the calls which occurred "Today", "Yesterday", "Last week", or "Other". 41 * 42 * <p>This class is meant to be used in conjunction with {@link GroupingListAdapter}. 43 */ 44public class CallLogGroupBuilder { 45 46 /** 47 * Day grouping for call log entries used to represent no associated day group. Used primarily 48 * when retrieving the previous day group, but there is no previous day group (i.e. we are at the 49 * start of the list). 50 */ 51 public static final int DAY_GROUP_NONE = -1; 52 /** Day grouping for calls which occurred today. */ 53 public static final int DAY_GROUP_TODAY = 0; 54 /** Day grouping for calls which occurred yesterday. */ 55 public static final int DAY_GROUP_YESTERDAY = 1; 56 /** Day grouping for calls which occurred before last week. */ 57 public static final int DAY_GROUP_OTHER = 2; 58 /** Instance of the time object used for time calculations. */ 59 private static final Time TIME = new Time(); 60 /** The object on which the groups are created. */ 61 private final GroupCreator groupCreator; 62 63 public CallLogGroupBuilder(GroupCreator groupCreator) { 64 this.groupCreator = groupCreator; 65 } 66 67 /** 68 * Finds all groups of adjacent entries in the call log which should be grouped together and calls 69 * {@link GroupCreator#addGroup(int, int)} on {@link #groupCreator} for each of them. 70 * 71 * <p>For entries that are not grouped with others, we do not need to create a group of size one. 72 * 73 * <p>It assumes that the cursor will not change during its execution. 74 * 75 * @see GroupingListAdapter#addGroups(Cursor) 76 */ 77 public void addGroups(Cursor cursor) { 78 final int count = cursor.getCount(); 79 if (count == 0) { 80 return; 81 } 82 83 // Clear any previous day grouping information. 84 groupCreator.clearDayGroups(); 85 86 // Get current system time, used for calculating which day group calls belong to. 87 long currentTime = System.currentTimeMillis(); 88 cursor.moveToFirst(); 89 90 // Determine the day group for the first call in the cursor. 91 final long firstDate = cursor.getLong(CallLogQuery.DATE); 92 final long firstRowId = cursor.getLong(CallLogQuery.ID); 93 int groupDayGroup = getDayGroup(firstDate, currentTime); 94 groupCreator.setDayGroup(firstRowId, groupDayGroup); 95 96 // Determine the callback action for the first call in the cursor. 97 String groupNumber = cursor.getString(CallLogQuery.NUMBER); 98 String groupAccountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME); 99 int groupFeatures = cursor.getInt(CallLogQuery.FEATURES); 100 int groupCallbackAction = 101 CallbackActionHelper.getCallbackAction( 102 groupNumber, groupFeatures, groupAccountComponentName); 103 groupCreator.setCallbackAction(firstRowId, groupCallbackAction); 104 105 // Instantiate other group values to those of the first call in the cursor. 106 String groupAccountId = cursor.getString(CallLogQuery.ACCOUNT_ID); 107 String groupPostDialDigits = 108 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : ""; 109 String groupViaNumbers = 110 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.VIA_NUMBER) : ""; 111 int groupCallType = cursor.getInt(CallLogQuery.CALL_TYPE); 112 int groupSize = 1; 113 114 String number; 115 String numberPostDialDigits; 116 String numberViaNumbers; 117 int callType; 118 int callFeatures; 119 String accountComponentName; 120 String accountId; 121 int callbackAction; 122 123 while (cursor.moveToNext()) { 124 // Obtain the values for the current call to group. 125 number = cursor.getString(CallLogQuery.NUMBER); 126 numberPostDialDigits = 127 (VERSION.SDK_INT >= VERSION_CODES.N) 128 ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) 129 : ""; 130 numberViaNumbers = 131 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.VIA_NUMBER) : ""; 132 callType = cursor.getInt(CallLogQuery.CALL_TYPE); 133 callFeatures = cursor.getInt(CallLogQuery.FEATURES); 134 accountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME); 135 accountId = cursor.getString(CallLogQuery.ACCOUNT_ID); 136 callbackAction = 137 CallbackActionHelper.getCallbackAction(number, callFeatures, accountComponentName); 138 139 final boolean isSameNumber = equalNumbers(groupNumber, number); 140 final boolean isSamePostDialDigits = groupPostDialDigits.equals(numberPostDialDigits); 141 final boolean isSameViaNumbers = groupViaNumbers.equals(numberViaNumbers); 142 final boolean isSameAccount = 143 isSameAccount(groupAccountComponentName, accountComponentName, groupAccountId, accountId); 144 final boolean isSameCallbackAction = (groupCallbackAction == callbackAction); 145 146 // Group calls with the following criteria: 147 // (1) Calls with the same number, account, and callback action should be in the same group; 148 // (2) Never group voice mails; and 149 // (3) Only group blocked calls with other blocked calls. 150 // (4) Only group calls that were assisted dialed with other calls that were assisted dialed. 151 if (isSameNumber 152 && isSameAccount 153 && isSamePostDialDigits 154 && isSameViaNumbers 155 && isSameCallbackAction 156 && areBothNotVoicemail(callType, groupCallType) 157 && (areBothNotBlocked(callType, groupCallType) || areBothBlocked(callType, groupCallType)) 158 && meetsAssistedDialingGroupingCriteria(groupFeatures, callFeatures)) { 159 // Increment the size of the group to include the current call, but do not create 160 // the group until finding a call that does not match. 161 groupSize++; 162 } else { 163 // The call group has changed. Determine the day group for the new call group. 164 final long date = cursor.getLong(CallLogQuery.DATE); 165 groupDayGroup = getDayGroup(date, currentTime); 166 167 // Create a group for the previous group of calls, which does not include the 168 // current call. 169 groupCreator.addGroup(cursor.getPosition() - groupSize, groupSize); 170 171 // Start a new group; it will include at least the current call. 172 groupSize = 1; 173 174 // Update the group values to those of the current call. 175 groupNumber = number; 176 groupPostDialDigits = numberPostDialDigits; 177 groupViaNumbers = numberViaNumbers; 178 groupCallType = callType; 179 groupAccountComponentName = accountComponentName; 180 groupAccountId = accountId; 181 groupCallbackAction = callbackAction; 182 groupFeatures = callFeatures; 183 } 184 185 // Save the callback action and the day group associated with the current call. 186 final long currentCallId = cursor.getLong(CallLogQuery.ID); 187 groupCreator.setCallbackAction(currentCallId, groupCallbackAction); 188 groupCreator.setDayGroup(currentCallId, groupDayGroup); 189 } 190 191 // Create a group for the last set of calls. 192 groupCreator.addGroup(count - groupSize, groupSize); 193 } 194 195 /** 196 * Returns true when the two input numbers can be considered identical enough for caller ID 197 * purposes and put in a call log group. 198 */ 199 @VisibleForTesting 200 boolean equalNumbers(@Nullable String number1, @Nullable String number2) { 201 if (PhoneNumberHelper.isUriNumber(number1) || PhoneNumberHelper.isUriNumber(number2)) { 202 return compareSipAddresses(number1, number2); 203 } 204 205 // PhoneNumberUtils.compare(String, String) ignores special characters such as '#'. For example, 206 // it thinks "123" and "#123" are identical enough for caller ID purposes. 207 // When either input number contains special characters, we put the two in the same group iff 208 // their raw numbers are exactly the same. 209 if (PhoneNumberHelper.numberHasSpecialChars(number1) 210 || PhoneNumberHelper.numberHasSpecialChars(number2)) { 211 return PhoneNumberHelper.sameRawNumbers(number1, number2); 212 } 213 214 return PhoneNumberUtils.compare(number1, number2); 215 } 216 217 private boolean isSameAccount(String name1, String name2, String id1, String id2) { 218 return TextUtils.equals(name1, name2) && TextUtils.equals(id1, id2); 219 } 220 221 @VisibleForTesting 222 boolean compareSipAddresses(@Nullable String number1, @Nullable String number2) { 223 if (number1 == null || number2 == null) { 224 return Objects.equals(number1, number2); 225 } 226 227 int index1 = number1.indexOf('@'); 228 final String userinfo1; 229 final String rest1; 230 if (index1 != -1) { 231 userinfo1 = number1.substring(0, index1); 232 rest1 = number1.substring(index1); 233 } else { 234 userinfo1 = number1; 235 rest1 = ""; 236 } 237 238 int index2 = number2.indexOf('@'); 239 final String userinfo2; 240 final String rest2; 241 if (index2 != -1) { 242 userinfo2 = number2.substring(0, index2); 243 rest2 = number2.substring(index2); 244 } else { 245 userinfo2 = number2; 246 rest2 = ""; 247 } 248 249 return userinfo1.equals(userinfo2) && rest1.equalsIgnoreCase(rest2); 250 } 251 252 /** 253 * Given a call date and the current date, determine which date group the call belongs in. 254 * 255 * @param date The call date. 256 * @param now The current date. 257 * @return The date group the call belongs in. 258 */ 259 private int getDayGroup(long date, long now) { 260 int days = DateUtils.getDayDifference(TIME, date, now); 261 262 if (days == 0) { 263 return DAY_GROUP_TODAY; 264 } else if (days == 1) { 265 return DAY_GROUP_YESTERDAY; 266 } else { 267 return DAY_GROUP_OTHER; 268 } 269 } 270 271 private boolean areBothNotVoicemail(int callType, int groupCallType) { 272 return callType != AppCompatConstants.CALLS_VOICEMAIL_TYPE 273 && groupCallType != AppCompatConstants.CALLS_VOICEMAIL_TYPE; 274 } 275 276 private boolean areBothNotBlocked(int callType, int groupCallType) { 277 return callType != AppCompatConstants.CALLS_BLOCKED_TYPE 278 && groupCallType != AppCompatConstants.CALLS_BLOCKED_TYPE; 279 } 280 281 private boolean areBothBlocked(int callType, int groupCallType) { 282 return callType == AppCompatConstants.CALLS_BLOCKED_TYPE 283 && groupCallType == AppCompatConstants.CALLS_BLOCKED_TYPE; 284 } 285 286 private boolean meetsAssistedDialingGroupingCriteria(int groupFeatures, int callFeatures) { 287 int groupAssisted = (groupFeatures & TelephonyManagerCompat.FEATURES_ASSISTED_DIALING); 288 int callAssisted = (callFeatures & TelephonyManagerCompat.FEATURES_ASSISTED_DIALING); 289 290 return groupAssisted == callAssisted; 291 } 292 293 public interface GroupCreator { 294 295 /** 296 * Defines the interface for adding a group to the call log. The primary group for a call log 297 * groups the calls together based on the number which was dialed. 298 * 299 * @param cursorPosition The starting position of the group in the cursor. 300 * @param size The size of the group. 301 */ 302 void addGroup(int cursorPosition, int size); 303 304 /** 305 * Defines the interface for tracking each call's callback action. Calls in a call group are 306 * associated with the same callback action as the first call in the group. The value of a 307 * callback action should be one of the categories in {@link CallbackAction}. 308 * 309 * @param rowId The row ID of the current call. 310 * @param callbackAction The current call's callback action. 311 */ 312 void setCallbackAction(long rowId, @CallbackAction int callbackAction); 313 314 /** 315 * Defines the interface for tracking the day group each call belongs to. Calls in a call group 316 * are assigned the same day group as the first call in the group. The day group assigns calls 317 * to the buckets: Today, Yesterday, Last week, and Other 318 * 319 * @param rowId The row ID of the current call. 320 * @param dayGroup The day group the call belongs to. 321 */ 322 void setDayGroup(long rowId, int dayGroup); 323 324 /** Defines the interface for clearing the day groupings information on rebind/regroup. */ 325 void clearDayGroups(); 326 } 327} 328