src/com/android/dialer/calllog/CallLogGroupBuilder.java - platform/packages/apps/Dialer - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.dialer.calllog;

 import com.google.common.annotations.VisibleForTesting;

 import android.database.Cursor;
 import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 import android.text.format.Time;

 import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.common.util.DateUtils;
 import com.android.contacts.common.util.PhoneNumberHelper;
 import com.android.dialer.util.AppCompatConstants;

 /**
  * Groups together calls in the call log.  The primary grouping attempts to group together calls
  * to and from the same number into a single row on the call log.
  * A secondary grouping assigns calls, grouped via the primary grouping, to "day groups".  The day
  * groups provide a means of identifying the calls which occurred "Today", "Yesterday", "Last week",
  * or "Other".
  * <p>
  * This class is meant to be used in conjunction with {@link GroupingListAdapter}.
  */
 public class CallLogGroupBuilder {
     public interface GroupCreator {

         /**
          * Defines the interface for adding a group to the call log.
          * The primary group for a call log groups the calls together based on the number which was
          * dialed.
          * @param cursorPosition The starting position of the group in the cursor.
          * @param size The size of the group.
          */
         public void addGroup(int cursorPosition, int size);

         /**
          * Defines the interface for tracking the day group each call belongs to.  Calls in a call
          * group are assigned the same day group as the first call in the group.  The day group
          * assigns calls to the buckets: Today, Yesterday, Last week, and Other
          *
          * @param rowId The row Id of the current call.
          * @param dayGroup The day group the call belongs in.
          */
         public void setDayGroup(long rowId, int dayGroup);

         /**
          * Defines the interface for clearing the day groupings information on rebind/regroup.
          */
         public void clearDayGroups();
     }

     /**
      * Day grouping for call log entries used to represent no associated day group.  Used primarily
      * when retrieving the previous day group, but there is no previous day group (i.e. we are at
      * the start of the list).
      */
     public static final int DAY_GROUP_NONE = -1;

     /** Day grouping for calls which occurred today. */
     public static final int DAY_GROUP_TODAY = 0;

     /** Day grouping for calls which occurred yesterday. */
     public static final int DAY_GROUP_YESTERDAY = 1;

     /** Day grouping for calls which occurred before last week. */
     public static final int DAY_GROUP_OTHER = 2;

     /** Instance of the time object used for time calculations. */
     private static final Time TIME = new Time();

     /** The object on which the groups are created. */
     private final GroupCreator mGroupCreator;

     public CallLogGroupBuilder(GroupCreator groupCreator) {
         mGroupCreator = groupCreator;
     }

     /**
      * Finds all groups of adjacent entries in the call log which should be grouped together and
      * calls {@link GroupCreator#addGroup(int, int)} on {@link #mGroupCreator} for each of
      * them.
      * <p>
      * For entries that are not grouped with others, we do not need to create a group of size one.
      * <p>
      * It assumes that the cursor will not change during its execution.
      *
      * @see GroupingListAdapter#addGroups(Cursor)
      */
     public void addGroups(Cursor cursor) {
         final int count = cursor.getCount();
         if (count == 0) {
             return;
         }

         // Clear any previous day grouping information.
         mGroupCreator.clearDayGroups();

         // Get current system time, used for calculating which day group calls belong to.
         long currentTime = System.currentTimeMillis();
         cursor.moveToFirst();

         // Determine the day group for the first call in the cursor.
         final long firstDate = cursor.getLong(CallLogQuery.DATE);
         final long firstRowId = cursor.getLong(CallLogQuery.ID);
         int groupDayGroup = getDayGroup(firstDate, currentTime);
         mGroupCreator.setDayGroup(firstRowId, groupDayGroup);

         // Instantiate the group values to those of the first call in the cursor.
         String groupNumber = cursor.getString(CallLogQuery.NUMBER);
         String groupPostDialDigits = CompatUtils.isNCompatible()
                 ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : "";
         String groupViaNumbers = CompatUtils.isNCompatible()
                 ? cursor.getString(CallLogQuery.VIA_NUMBER) : "";
         int groupCallType = cursor.getInt(CallLogQuery.CALL_TYPE);
         String groupAccountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME);
         String groupAccountId = cursor.getString(CallLogQuery.ACCOUNT_ID);
         int groupSize = 1;

         String number;
         String numberPostDialDigits;
         String numberViaNumbers;
         int callType;
         String accountComponentName;
         String accountId;

         while (cursor.moveToNext()) {
             // Obtain the values for the current call to group.
             number = cursor.getString(CallLogQuery.NUMBER);
             numberPostDialDigits = CompatUtils.isNCompatible()
                     ? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : "";
             numberViaNumbers = CompatUtils.isNCompatible()
                     ? cursor.getString(CallLogQuery.VIA_NUMBER) : "";
             callType = cursor.getInt(CallLogQuery.CALL_TYPE);
             accountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME);
             accountId = cursor.getString(CallLogQuery.ACCOUNT_ID);

             final boolean isSameNumber = equalNumbers(groupNumber, number);
             final boolean isSamePostDialDigits = groupPostDialDigits.equals(numberPostDialDigits);
             final boolean isSameViaNumbers = groupViaNumbers.equals(numberViaNumbers);
             final boolean isSameAccount = isSameAccount(
                     groupAccountComponentName, accountComponentName, groupAccountId, accountId);

             // Group with the same number and account. Never group voicemails. Only group blocked
             // calls with other blocked calls.
             if (isSameNumber && isSameAccount && isSamePostDialDigits && isSameViaNumbers
                     && areBothNotVoicemail(callType, groupCallType)
                     && (areBothNotBlocked(callType, groupCallType)
                             || areBothBlocked(callType, groupCallType))) {
                 // Increment the size of the group to include the current call, but do not create
                 // the group until finding a call that does not match.
                 groupSize++;
             } else {
                 // The call group has changed. Determine the day group for the new call group.
                 final long date = cursor.getLong(CallLogQuery.DATE);
                 groupDayGroup = getDayGroup(date, currentTime);

                 // Create a group for the previous group of calls, which does not include the
                 // current call.
                 mGroupCreator.addGroup(cursor.getPosition() - groupSize, groupSize);

                 // Start a new group; it will include at least the current call.
                 groupSize = 1;

                 // Update the group values to those of the current call.
                 groupNumber = number;
                 groupPostDialDigits = numberPostDialDigits;
                 groupViaNumbers = numberViaNumbers;
                 groupCallType = callType;
                 groupAccountComponentName = accountComponentName;
                 groupAccountId = accountId;
             }

             // Save the day group associated with the current call.
             final long currentCallId = cursor.getLong(CallLogQuery.ID);
             mGroupCreator.setDayGroup(currentCallId, groupDayGroup);
         }

         // Create a group for the last set of calls.
         mGroupCreator.addGroup(count - groupSize, groupSize);
     }

     /**
      * Group cursor entries by date, with only one entry per group. This is used for listing
      * voicemails in the archive tab.
      */
     public void addVoicemailGroups(Cursor cursor) {
         if (cursor.getCount() == 0) {
             return;
         }

         // Clear any previous day grouping information.
         mGroupCreator.clearDayGroups();

         // Get current system time, used for calculating which day group calls belong to.
         long currentTime = System.currentTimeMillis();

         // Reset cursor to start before the first row
         cursor.moveToPosition(-1);

         // Create an individual group for each voicemail
         while (cursor.moveToNext()) {
             mGroupCreator.addGroup(cursor.getPosition(), 1);
             mGroupCreator.setDayGroup(cursor.getLong(CallLogQuery.ID),
                     getDayGroup(cursor.getLong(CallLogQuery.DATE), currentTime));

         }
     }

     @VisibleForTesting
     boolean equalNumbers(String number1, String number2) {
         if (PhoneNumberHelper.isUriNumber(number1) || PhoneNumberHelper.isUriNumber(number2)) {
             return compareSipAddresses(number1, number2);
         } else {
             return PhoneNumberUtils.compare(number1, number2);
         }
     }

     private boolean isSameAccount(String name1, String name2, String id1, String id2) {
         return TextUtils.equals(name1, name2) && TextUtils.equals(id1, id2);
     }

     @VisibleForTesting
     boolean compareSipAddresses(String number1, String number2) {
         if (number1 == null || number2 == null) return number1 == number2;

         int index1 = number1.indexOf('@');
         final String userinfo1;
         final String rest1;
         if (index1 != -1) {
             userinfo1 = number1.substring(0, index1);
             rest1 = number1.substring(index1);
         } else {
             userinfo1 = number1;
             rest1 = "";
         }

         int index2 = number2.indexOf('@');
         final String userinfo2;
         final String rest2;
         if (index2 != -1) {
             userinfo2 = number2.substring(0, index2);
             rest2 = number2.substring(index2);
         } else {
             userinfo2 = number2;
             rest2 = "";
         }

         return userinfo1.equals(userinfo2) && rest1.equalsIgnoreCase(rest2);
     }

     /**
      * Given a call date and the current date, determine which date group the call belongs in.
      *
      * @param date The call date.
      * @param now The current date.
      * @return The date group the call belongs in.
      */
     private int getDayGroup(long date, long now) {
         int days = DateUtils.getDayDifference(TIME, date, now);

         if (days == 0) {
             return DAY_GROUP_TODAY;
         } else if (days == 1) {
             return DAY_GROUP_YESTERDAY;
         } else {
             return DAY_GROUP_OTHER;
         }
     }

     private boolean areBothNotVoicemail(int callType, int groupCallType) {
         return callType != AppCompatConstants.CALLS_VOICEMAIL_TYPE
                 && groupCallType != AppCompatConstants.CALLS_VOICEMAIL_TYPE;
     }

     private boolean areBothNotBlocked(int callType, int groupCallType) {
         return callType != AppCompatConstants.CALLS_BLOCKED_TYPE
                 && groupCallType != AppCompatConstants.CALLS_BLOCKED_TYPE;
     }

     private boolean areBothBlocked(int callType, int groupCallType) {
         return callType == AppCompatConstants.CALLS_BLOCKED_TYPE
                 && groupCallType == AppCompatConstants.CALLS_BLOCKED_TYPE;
     }
 }
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.dialer.calllog;

	import com.google.common.annotations.VisibleForTesting;

	import android.database.Cursor;
	import android.telephony.PhoneNumberUtils;
	import android.text.TextUtils;
	import android.text.format.Time;

	import com.android.contacts.common.compat.CompatUtils;
	import com.android.contacts.common.util.DateUtils;
	import com.android.contacts.common.util.PhoneNumberHelper;
	import com.android.dialer.util.AppCompatConstants;

	/**
	* Groups together calls in the call log. The primary grouping attempts to group together calls
	* to and from the same number into a single row on the call log.
	* A secondary grouping assigns calls, grouped via the primary grouping, to "day groups". The day
	* groups provide a means of identifying the calls which occurred "Today", "Yesterday", "Last week",
	* or "Other".
	* <p>
	* This class is meant to be used in conjunction with {@link GroupingListAdapter}.
	*/
	public class CallLogGroupBuilder {
	public interface GroupCreator {

	/**
	* Defines the interface for adding a group to the call log.
	* The primary group for a call log groups the calls together based on the number which was
	* dialed.
	* @param cursorPosition The starting position of the group in the cursor.
	* @param size The size of the group.
	*/
	public void addGroup(int cursorPosition, int size);

	/**
	* Defines the interface for tracking the day group each call belongs to. Calls in a call
	* group are assigned the same day group as the first call in the group. The day group
	* assigns calls to the buckets: Today, Yesterday, Last week, and Other
	*
	* @param rowId The row Id of the current call.
	* @param dayGroup The day group the call belongs in.
	*/
	public void setDayGroup(long rowId, int dayGroup);

	/**
	* Defines the interface for clearing the day groupings information on rebind/regroup.
	*/
	public void clearDayGroups();
	}

	/**
	* Day grouping for call log entries used to represent no associated day group. Used primarily
	* when retrieving the previous day group, but there is no previous day group (i.e. we are at
	* the start of the list).
	*/
	public static final int DAY_GROUP_NONE = -1;

	/** Day grouping for calls which occurred today. */
	public static final int DAY_GROUP_TODAY = 0;

	/** Day grouping for calls which occurred yesterday. */
	public static final int DAY_GROUP_YESTERDAY = 1;

	/** Day grouping for calls which occurred before last week. */
	public static final int DAY_GROUP_OTHER = 2;

	/** Instance of the time object used for time calculations. */
	private static final Time TIME = new Time();

	/** The object on which the groups are created. */
	private final GroupCreator mGroupCreator;

	public CallLogGroupBuilder(GroupCreator groupCreator) {
	mGroupCreator = groupCreator;
	}

	/**
	* Finds all groups of adjacent entries in the call log which should be grouped together and
	* calls {@link GroupCreator#addGroup(int, int)} on {@link #mGroupCreator} for each of
	* them.
	* <p>
	* For entries that are not grouped with others, we do not need to create a group of size one.
	* <p>
	* It assumes that the cursor will not change during its execution.
	*
	* @see GroupingListAdapter#addGroups(Cursor)
	*/
	public void addGroups(Cursor cursor) {
	final int count = cursor.getCount();
	if (count == 0) {
	return;
	}

	// Clear any previous day grouping information.
	mGroupCreator.clearDayGroups();

	// Get current system time, used for calculating which day group calls belong to.
	long currentTime = System.currentTimeMillis();
	cursor.moveToFirst();

	// Determine the day group for the first call in the cursor.
	final long firstDate = cursor.getLong(CallLogQuery.DATE);
	final long firstRowId = cursor.getLong(CallLogQuery.ID);
	int groupDayGroup = getDayGroup(firstDate, currentTime);
	mGroupCreator.setDayGroup(firstRowId, groupDayGroup);

	// Instantiate the group values to those of the first call in the cursor.
	String groupNumber = cursor.getString(CallLogQuery.NUMBER);
	String groupPostDialDigits = CompatUtils.isNCompatible()
	? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : "";
	String groupViaNumbers = CompatUtils.isNCompatible()
	? cursor.getString(CallLogQuery.VIA_NUMBER) : "";
	int groupCallType = cursor.getInt(CallLogQuery.CALL_TYPE);
	String groupAccountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME);
	String groupAccountId = cursor.getString(CallLogQuery.ACCOUNT_ID);
	int groupSize = 1;

	String number;
	String numberPostDialDigits;
	String numberViaNumbers;
	int callType;
	String accountComponentName;
	String accountId;

	while (cursor.moveToNext()) {
	// Obtain the values for the current call to group.
	number = cursor.getString(CallLogQuery.NUMBER);
	numberPostDialDigits = CompatUtils.isNCompatible()
	? cursor.getString(CallLogQuery.POST_DIAL_DIGITS) : "";
	numberViaNumbers = CompatUtils.isNCompatible()
	? cursor.getString(CallLogQuery.VIA_NUMBER) : "";
	callType = cursor.getInt(CallLogQuery.CALL_TYPE);
	accountComponentName = cursor.getString(CallLogQuery.ACCOUNT_COMPONENT_NAME);
	accountId = cursor.getString(CallLogQuery.ACCOUNT_ID);

	final boolean isSameNumber = equalNumbers(groupNumber, number);
	final boolean isSamePostDialDigits = groupPostDialDigits.equals(numberPostDialDigits);
	final boolean isSameViaNumbers = groupViaNumbers.equals(numberViaNumbers);
	final boolean isSameAccount = isSameAccount(
	groupAccountComponentName, accountComponentName, groupAccountId, accountId);

	// Group with the same number and account. Never group voicemails. Only group blocked
	// calls with other blocked calls.
	if (isSameNumber && isSameAccount && isSamePostDialDigits && isSameViaNumbers
	&& areBothNotVoicemail(callType, groupCallType)
	&& (areBothNotBlocked(callType, groupCallType)
	\|\| areBothBlocked(callType, groupCallType))) {
	// Increment the size of the group to include the current call, but do not create
	// the group until finding a call that does not match.
	groupSize++;
	} else {
	// The call group has changed. Determine the day group for the new call group.
	final long date = cursor.getLong(CallLogQuery.DATE);
	groupDayGroup = getDayGroup(date, currentTime);

	// Create a group for the previous group of calls, which does not include the
	// current call.
	mGroupCreator.addGroup(cursor.getPosition() - groupSize, groupSize);

	// Start a new group; it will include at least the current call.
	groupSize = 1;

	// Update the group values to those of the current call.
	groupNumber = number;
	groupPostDialDigits = numberPostDialDigits;
	groupViaNumbers = numberViaNumbers;
	groupCallType = callType;
	groupAccountComponentName = accountComponentName;
	groupAccountId = accountId;
	}

	// Save the day group associated with the current call.
	final long currentCallId = cursor.getLong(CallLogQuery.ID);
	mGroupCreator.setDayGroup(currentCallId, groupDayGroup);
	}

	// Create a group for the last set of calls.
	mGroupCreator.addGroup(count - groupSize, groupSize);
	}

	/**
	* Group cursor entries by date, with only one entry per group. This is used for listing
	* voicemails in the archive tab.
	*/
	public void addVoicemailGroups(Cursor cursor) {
	if (cursor.getCount() == 0) {
	return;
	}

	// Clear any previous day grouping information.
	mGroupCreator.clearDayGroups();

	// Get current system time, used for calculating which day group calls belong to.
	long currentTime = System.currentTimeMillis();

	// Reset cursor to start before the first row
	cursor.moveToPosition(-1);

	// Create an individual group for each voicemail
	while (cursor.moveToNext()) {
	mGroupCreator.addGroup(cursor.getPosition(), 1);
	mGroupCreator.setDayGroup(cursor.getLong(CallLogQuery.ID),
	getDayGroup(cursor.getLong(CallLogQuery.DATE), currentTime));

	}
	}

	@VisibleForTesting
	boolean equalNumbers(String number1, String number2) {
	if (PhoneNumberHelper.isUriNumber(number1) \|\| PhoneNumberHelper.isUriNumber(number2)) {
	return compareSipAddresses(number1, number2);
	} else {
	return PhoneNumberUtils.compare(number1, number2);
	}
	}

	private boolean isSameAccount(String name1, String name2, String id1, String id2) {
	return TextUtils.equals(name1, name2) && TextUtils.equals(id1, id2);
	}

	@VisibleForTesting
	boolean compareSipAddresses(String number1, String number2) {
	if (number1 == null \|\| number2 == null) return number1 == number2;

	int index1 = number1.indexOf('@');
	final String userinfo1;
	final String rest1;
	if (index1 != -1) {
	userinfo1 = number1.substring(0, index1);
	rest1 = number1.substring(index1);
	} else {
	userinfo1 = number1;
	rest1 = "";
	}

	int index2 = number2.indexOf('@');
	final String userinfo2;
	final String rest2;
	if (index2 != -1) {
	userinfo2 = number2.substring(0, index2);
	rest2 = number2.substring(index2);
	} else {
	userinfo2 = number2;
	rest2 = "";
	}

	return userinfo1.equals(userinfo2) && rest1.equalsIgnoreCase(rest2);
	}

	/**
	* Given a call date and the current date, determine which date group the call belongs in.
	*
	* @param date The call date.
	* @param now The current date.
	* @return The date group the call belongs in.
	*/
	private int getDayGroup(long date, long now) {
	int days = DateUtils.getDayDifference(TIME, date, now);

	if (days == 0) {
	return DAY_GROUP_TODAY;
	} else if (days == 1) {
	return DAY_GROUP_YESTERDAY;
	} else {
	return DAY_GROUP_OTHER;
	}
	}

	private boolean areBothNotVoicemail(int callType, int groupCallType) {
	return callType != AppCompatConstants.CALLS_VOICEMAIL_TYPE
	&& groupCallType != AppCompatConstants.CALLS_VOICEMAIL_TYPE;
	}

	private boolean areBothNotBlocked(int callType, int groupCallType) {
	return callType != AppCompatConstants.CALLS_BLOCKED_TYPE
	&& groupCallType != AppCompatConstants.CALLS_BLOCKED_TYPE;
	}

	private boolean areBothBlocked(int callType, int groupCallType) {
	return callType == AppCompatConstants.CALLS_BLOCKED_TYPE
	&& groupCallType == AppCompatConstants.CALLS_BLOCKED_TYPE;
	}
	}