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.compat.AppCompatConstants; 29import com.android.dialer.phonenumbercache.CallLogQuery; 30import com.android.dialer.phonenumberutil.PhoneNumberHelper; 31import java.util.Objects; 32 33/** 34 * Groups together calls in the call log. The primary grouping attempts to group together calls to 35 * and from the same number into a single row on the call log. A secondary grouping assigns calls, 36 * grouped via the primary grouping, to "day groups". The day groups provide a means of identifying 37 * the calls which occurred "Today", "Yesterday", "Last week", or "Other". 38 * 39 * <p>This class is meant to be used in conjunction with {@link GroupingListAdapter}. 40 */ 41public class CallLogGroupBuilder { 42 43 /** 44 * Day grouping for call log entries used to represent no associated day group. Used primarily 45 * when retrieving the previous day group, but there is no previous day group (i.e. we are at the 46 * start of the list). 47 */ 48 public static final int DAY_GROUP_NONE = -1; 49 /** Day grouping for calls which occurred today. */ 50 public static final int DAY_GROUP_TODAY = 0; 51 /** Day grouping for calls which occurred yesterday. */ 52 public static final int DAY_GROUP_YESTERDAY = 1; 53 /** Day grouping for calls which occurred before last week. */ 54 public static final int DAY_GROUP_OTHER = 2; 55 /** Instance of the time object used for time calculations. */ 56 private static final Time TIME = new Time(); 57 /** The object on which the groups are created. */ 58 private final GroupCreator mGroupCreator; 59 60 public CallLogGroupBuilder(GroupCreator groupCreator) { 61 mGroupCreator = groupCreator; 62 } 63 64 /** 65 * Finds all groups of adjacent entries in the call log which should be grouped together and calls 66 * {@link GroupCreator#addGroup(int, int)} on {@link #mGroupCreator} for each of them. 67 * 68 * <p>For entries that are not grouped with others, we do not need to create a group of size one. 69 * 70 * <p>It assumes that the cursor will not change during its execution. 71 * 72 * @see GroupingListAdapter#addGroups(Cursor) 73 */ 74 public void addGroups(Cursor cursor) { 75 final int count = cursor.getCount(); 76 if (count == 0) { 77 return; 78 } 79 80 // Clear any previous day grouping information. 81 mGroupCreator.clearDayGroups(); 82 83 // Get current system time, used for calculating which day group calls belong to. 84 long currentTime = System.currentTimeMillis(); 85 cursor.moveToFirst(); 86 87 // Determine the day group for the first call in the cursor. 88 final long firstDate = cursor.getLong(CallLogQuery.DATE); 89 final long firstRowId = cursor.getLong(CallLogQuery.ID); 90 int groupDayGroup = getDayGroup(firstDate, currentTime); 91 mGroupCreator.setDayGroup(firstRowId, groupDayGroup); 92 93 // Instantiate the group values to those of the first call in the cursor. 94 String groupNumber = cursor.getString(CallLogQuery.NUMBER); 95 String groupPostDialDigits = 96 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : ""; 97 String groupViaNumbers = 98 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.VIA_NUMBER) : ""; 99 int groupCallType = cursor.getInt(CallLogQuery.CALL_TYPE); 100 String groupAccountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME); 101 String groupAccountId = cursor.getString(CallLogQuery.ACCOUNT_ID); 102 int groupSize = 1; 103 104 String number; 105 String numberPostDialDigits; 106 String numberViaNumbers; 107 int callType; 108 String accountComponentName; 109 String accountId; 110 111 while (cursor.moveToNext()) { 112 // Obtain the values for the current call to group. 113 number = cursor.getString(CallLogQuery.NUMBER); 114 numberPostDialDigits = 115 (VERSION.SDK_INT >= VERSION_CODES.N) 116 ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) 117 : ""; 118 numberViaNumbers = 119 (VERSION.SDK_INT >= VERSION_CODES.N) ? cursor.getString(CallLogQuery.VIA_NUMBER) : ""; 120 callType = cursor.getInt(CallLogQuery.CALL_TYPE); 121 accountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME); 122 accountId = cursor.getString(CallLogQuery.ACCOUNT_ID); 123 124 final boolean isSameNumber = equalNumbers(groupNumber, number); 125 final boolean isSamePostDialDigits = groupPostDialDigits.equals(numberPostDialDigits); 126 final boolean isSameViaNumbers = groupViaNumbers.equals(numberViaNumbers); 127 final boolean isSameAccount = 128 isSameAccount(groupAccountComponentName, accountComponentName, groupAccountId, accountId); 129 130 // Group with the same number and account. Never group voicemails. Only group blocked 131 // calls with other blocked calls. 132 if (isSameNumber 133 && isSameAccount 134 && isSamePostDialDigits 135 && isSameViaNumbers 136 && areBothNotVoicemail(callType, groupCallType) 137 && (areBothNotBlocked(callType, groupCallType) 138 || areBothBlocked(callType, groupCallType))) { 139 // Increment the size of the group to include the current call, but do not create 140 // the group until finding a call that does not match. 141 groupSize++; 142 } else { 143 // The call group has changed. Determine the day group for the new call group. 144 final long date = cursor.getLong(CallLogQuery.DATE); 145 groupDayGroup = getDayGroup(date, currentTime); 146 147 // Create a group for the previous group of calls, which does not include the 148 // current call. 149 mGroupCreator.addGroup(cursor.getPosition() - groupSize, groupSize); 150 151 // Start a new group; it will include at least the current call. 152 groupSize = 1; 153 154 // Update the group values to those of the current call. 155 groupNumber = number; 156 groupPostDialDigits = numberPostDialDigits; 157 groupViaNumbers = numberViaNumbers; 158 groupCallType = callType; 159 groupAccountComponentName = accountComponentName; 160 groupAccountId = accountId; 161 } 162 163 // Save the day group associated with the current call. 164 final long currentCallId = cursor.getLong(CallLogQuery.ID); 165 mGroupCreator.setDayGroup(currentCallId, groupDayGroup); 166 } 167 168 // Create a group for the last set of calls. 169 mGroupCreator.addGroup(count - groupSize, groupSize); 170 } 171 172 @VisibleForTesting 173 boolean equalNumbers(@Nullable String number1, @Nullable String number2) { 174 if (PhoneNumberHelper.isUriNumber(number1) || PhoneNumberHelper.isUriNumber(number2)) { 175 return compareSipAddresses(number1, number2); 176 } else { 177 return PhoneNumberUtils.compare(number1, number2); 178 } 179 } 180 181 private boolean isSameAccount(String name1, String name2, String id1, String id2) { 182 return TextUtils.equals(name1, name2) && TextUtils.equals(id1, id2); 183 } 184 185 @VisibleForTesting 186 boolean compareSipAddresses(@Nullable String number1, @Nullable String number2) { 187 if (number1 == null || number2 == null) { 188 return Objects.equals(number1, number2); 189 } 190 191 int index1 = number1.indexOf('@'); 192 final String userinfo1; 193 final String rest1; 194 if (index1 != -1) { 195 userinfo1 = number1.substring(0, index1); 196 rest1 = number1.substring(index1); 197 } else { 198 userinfo1 = number1; 199 rest1 = ""; 200 } 201 202 int index2 = number2.indexOf('@'); 203 final String userinfo2; 204 final String rest2; 205 if (index2 != -1) { 206 userinfo2 = number2.substring(0, index2); 207 rest2 = number2.substring(index2); 208 } else { 209 userinfo2 = number2; 210 rest2 = ""; 211 } 212 213 return userinfo1.equals(userinfo2) && rest1.equalsIgnoreCase(rest2); 214 } 215 216 /** 217 * Given a call date and the current date, determine which date group the call belongs in. 218 * 219 * @param date The call date. 220 * @param now The current date. 221 * @return The date group the call belongs in. 222 */ 223 private int getDayGroup(long date, long now) { 224 int days = DateUtils.getDayDifference(TIME, date, now); 225 226 if (days == 0) { 227 return DAY_GROUP_TODAY; 228 } else if (days == 1) { 229 return DAY_GROUP_YESTERDAY; 230 } else { 231 return DAY_GROUP_OTHER; 232 } 233 } 234 235 private boolean areBothNotVoicemail(int callType, int groupCallType) { 236 return callType != AppCompatConstants.CALLS_VOICEMAIL_TYPE 237 && groupCallType != AppCompatConstants.CALLS_VOICEMAIL_TYPE; 238 } 239 240 private boolean areBothNotBlocked(int callType, int groupCallType) { 241 return callType != AppCompatConstants.CALLS_BLOCKED_TYPE 242 && groupCallType != AppCompatConstants.CALLS_BLOCKED_TYPE; 243 } 244 245 private boolean areBothBlocked(int callType, int groupCallType) { 246 return callType == AppCompatConstants.CALLS_BLOCKED_TYPE 247 && groupCallType == AppCompatConstants.CALLS_BLOCKED_TYPE; 248 } 249 250 public interface GroupCreator { 251 252 /** 253 * Defines the interface for adding a group to the call log. The primary group for a call log 254 * groups the calls together based on the number which was dialed. 255 * 256 * @param cursorPosition The starting position of the group in the cursor. 257 * @param size The size of the group. 258 */ 259 void addGroup(int cursorPosition, int size); 260 261 /** 262 * Defines the interface for tracking the day group each call belongs to. Calls in a call group 263 * are assigned the same day group as the first call in the group. The day group assigns calls 264 * to the buckets: Today, Yesterday, Last week, and Other 265 * 266 * @param rowId The row Id of the current call. 267 * @param dayGroup The day group the call belongs in. 268 */ 269 void setDayGroup(long rowId, int dayGroup); 270 271 /** Defines the interface for clearing the day groupings information on rebind/regroup. */ 272 void clearDayGroups(); 273 } 274} 275