From a240266106bf99780a48d86883499dbebd20fbda Mon Sep 17 00:00:00 2001 From: zachh Date: Fri, 12 Jan 2018 15:19:00 -0800 Subject: Cleaned up wording around "valid" and "formattable". We don't actually parition by "formattable", we parition by "valid". An invalid number like 456-7890 can be formatted to E164 ("+14567890") but what ParitionedNumbers actually does is parition by valid/invalid (and then converts the valid numbers to E164). Also added a new sharded test suite for phonenumberproto tests which had occasionally been timing out on TAP. Test: existing PiperOrigin-RevId: 181800443 Change-Id: Id64fc32c893025b0115dd350dd87e3277607f21c --- .../phonenumberproto/DialerPhoneNumberUtil.java | 6 +-- .../phonenumberproto/PartitionedNumbers.java | 51 ++++++++++++---------- 2 files changed, 30 insertions(+), 27 deletions(-) (limited to 'java/com/android/dialer/phonenumberproto') diff --git a/java/com/android/dialer/phonenumberproto/DialerPhoneNumberUtil.java b/java/com/android/dialer/phonenumberproto/DialerPhoneNumberUtil.java index 8cb4557cb..8969737d4 100644 --- a/java/com/android/dialer/phonenumberproto/DialerPhoneNumberUtil.java +++ b/java/com/android/dialer/phonenumberproto/DialerPhoneNumberUtil.java @@ -132,13 +132,13 @@ public class DialerPhoneNumberUtil { * Formats the provided number to E164 format or return a normalized version of the raw number if * the number is not valid according to {@link PhoneNumberUtil#isValidNumber(PhoneNumber)}. * - * @see #formatToE164(DialerPhoneNumber) + * @see #formatToValidE164(DialerPhoneNumber) * @see PhoneNumberUtils#normalizeNumber(String) */ @WorkerThread public String normalizeNumber(DialerPhoneNumber number) { Assert.isWorkerThread(); - return formatToE164(number) + return formatToValidE164(number) .or(PhoneNumberUtils.normalizeNumber(number.getRawInput().getNumber())); } @@ -154,7 +154,7 @@ public class DialerPhoneNumberUtil { * @see PhoneNumberUtils#formatNumberToE164(String, String) */ @WorkerThread - public Optional formatToE164(DialerPhoneNumber number) { + public Optional formatToValidE164(DialerPhoneNumber number) { Assert.isWorkerThread(); if (number.hasDialerInternalPhoneNumber()) { PhoneNumber phoneNumber = Converter.protoToPojo(number.getDialerInternalPhoneNumber()); diff --git a/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java b/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java index 372f21ee8..4c8ac2f21 100644 --- a/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java +++ b/java/com/android/dialer/phonenumberproto/PartitionedNumbers.java @@ -30,14 +30,14 @@ import java.util.Map; import java.util.Set; /** - * Divides a set of {@link DialerPhoneNumber DialerPhoneNumbers} by those that can be formatted to - * E164 and those that cannot. + * Divides a set of {@link DialerPhoneNumber DialerPhoneNumbers} according to those that are valid + * according to libphonenumber, and those that are not. */ public final class PartitionedNumbers { private final ImmutableMap> e164NumbersToDialerPhoneNumbers; private final ImmutableMap> - unformattableNumbersToDialerPhoneNumbers; + invalidNumbersToDialerPhoneNumbers; @WorkerThread public PartitionedNumbers(@NonNull ImmutableSet dialerPhoneNumbers) { @@ -45,12 +45,12 @@ public final class PartitionedNumbers { DialerPhoneNumberUtil dialerPhoneNumberUtil = new DialerPhoneNumberUtil(PhoneNumberUtil.getInstance()); Map> e164MapBuilder = new ArrayMap<>(); - Map> unformattableMapBuilder = new ArrayMap<>(); + Map> invalidMapBuilder = new ArrayMap<>(); for (DialerPhoneNumber dialerPhoneNumber : dialerPhoneNumbers) { - Optional e164 = dialerPhoneNumberUtil.formatToE164(dialerPhoneNumber); - if (e164.isPresent()) { - String validE164 = e164.get(); + Optional optValidE164 = dialerPhoneNumberUtil.formatToValidE164(dialerPhoneNumber); + if (optValidE164.isPresent()) { + String validE164 = optValidE164.get(); Set currentNumbers = e164MapBuilder.get(validE164); if (currentNumbers == null) { currentNumbers = new ArraySet<>(); @@ -58,49 +58,52 @@ public final class PartitionedNumbers { } currentNumbers.add(dialerPhoneNumber); } else { - String unformattableNumber = dialerPhoneNumber.getRawInput().getNumber(); - Set currentNumbers = unformattableMapBuilder.get(unformattableNumber); + String invalidNumber = dialerPhoneNumber.getRawInput().getNumber(); + Set currentNumbers = invalidMapBuilder.get(invalidNumber); if (currentNumbers == null) { currentNumbers = new ArraySet<>(); - unformattableMapBuilder.put(unformattableNumber, currentNumbers); + invalidMapBuilder.put(invalidNumber, currentNumbers); } currentNumbers.add(dialerPhoneNumber); } } e164NumbersToDialerPhoneNumbers = makeImmutable(e164MapBuilder); - unformattableNumbersToDialerPhoneNumbers = makeImmutable(unformattableMapBuilder); + invalidNumbersToDialerPhoneNumbers = makeImmutable(invalidMapBuilder); } - /** Returns the set of formatted number from the original DialerPhoneNumbers */ + /** Returns the set of invalid numbers from the original DialerPhoneNumbers */ @NonNull - public ImmutableSet unformattableNumbers() { - return unformattableNumbersToDialerPhoneNumbers.keySet(); + public ImmutableSet invalidNumbers() { + return invalidNumbersToDialerPhoneNumbers.keySet(); } - /** Returns the set of raw number that is unformattable from the original DialerPhoneNumbers */ + /** Returns the set of valid, E164 formatted numbers from the original DialerPhoneNumbers */ @NonNull public ImmutableSet validE164Numbers() { return e164NumbersToDialerPhoneNumbers.keySet(); } /** - * Returns the corresponding set of original DialerPhoneNumber that maps to the e.164 number, or - * an empty set if the number is not found. + * Returns the corresponding set of original DialerPhoneNumbers that map to the valid E164 number + * from {@link #validE164Numbers()}. + * + * @throws NullPointerException if there are no numbers found */ @NonNull - public ImmutableSet dialerPhoneNumbersForE164(String e164) { - return Assert.isNotNull(e164NumbersToDialerPhoneNumbers.get(e164)); + public ImmutableSet dialerPhoneNumbersForValidE164(String validE164) { + return Assert.isNotNull(e164NumbersToDialerPhoneNumbers.get(validE164)); } /** - * Returns the corresponding set of original DialerPhoneNumber that maps to the unformattable - * number returned by {@link #unformattableNumbers()}, or an empty set if the number is not found. + * Returns the corresponding set of original DialerPhoneNumbers that map to the invalid number + * from {@link #invalidNumbers()}. + * + * @throws NullPointerException if there are no numbers found */ @NonNull - public ImmutableSet dialerPhoneNumbersForUnformattable( - String unformattableNumber) { - return Assert.isNotNull(unformattableNumbersToDialerPhoneNumbers.get(unformattableNumber)); + public ImmutableSet dialerPhoneNumbersForInvalid(String invalidNumber) { + return Assert.isNotNull(invalidNumbersToDialerPhoneNumbers.get(invalidNumber)); } private static ImmutableMap> makeImmutable( -- cgit v1.2.3