session-android/src/org/thoughtcrime/securesms/database/Address.java
nielsandriesse ed2ab2d78a Refactor
2020-05-11 16:19:26 +10:00

271 lines
7.9 KiB
Java

package org.thoughtcrime.securesms.database;
import android.content.Context;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.annotation.VisibleForTesting;
import android.text.TextUtils;
import android.util.Pair;
import org.thoughtcrime.securesms.util.DelimiterUtil;
import org.thoughtcrime.securesms.util.GroupUtil;
import org.thoughtcrime.securesms.util.NumberUtil;
import org.thoughtcrime.securesms.util.TextSecurePreferences;
import org.thoughtcrime.securesms.util.Util;
import org.whispersystems.libsignal.util.guava.Optional;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Address implements Parcelable, Comparable<Address> {
public static final Parcelable.Creator<Address> CREATOR = new Parcelable.Creator<Address>() {
public Address createFromParcel(Parcel in) {
return new Address(in);
}
public Address[] newArray(int size) {
return new Address[size];
}
};
public static final Address UNKNOWN = new Address("Unknown");
private static final String TAG = Address.class.getSimpleName();
private static final AtomicReference<Pair<String, ExternalAddressFormatter>> cachedFormatter = new AtomicReference<>();
private final String address;
private Address(@NonNull String address) {
if (address == null) throw new AssertionError(address);
this.address = address.toLowerCase();
}
public Address(Parcel in) {
this(in.readString());
}
public static @NonNull Address fromSerialized(@NonNull String serialized) {
return new Address(serialized);
}
public static Address fromExternal(@NonNull Context context, @Nullable String external) {
return Address.fromSerialized(external);
}
public static @NonNull List<Address> fromSerializedList(@NonNull String serialized, char delimiter) {
String[] escapedAddresses = DelimiterUtil.split(serialized, delimiter);
List<Address> addresses = new LinkedList<>();
for (String escapedAddress : escapedAddresses) {
addresses.add(Address.fromSerialized(DelimiterUtil.unescape(escapedAddress, delimiter)));
}
return addresses;
}
public static @NonNull String toSerializedList(@NonNull List<Address> addresses, char delimiter) {
Collections.sort(addresses);
List<String> escapedAddresses = new LinkedList<>();
for (Address address : addresses) {
escapedAddresses.add(DelimiterUtil.escape(address.serialize(), delimiter));
}
return Util.join(escapedAddresses, delimiter + "");
}
private static @NonNull ExternalAddressFormatter getExternalAddressFormatter(Context context) {
String localNumber = TextSecurePreferences.getLocalNumber(context);
if (!TextUtils.isEmpty(localNumber)) {
Pair<String, ExternalAddressFormatter> cached = cachedFormatter.get();
if (cached != null && cached.first.equals(localNumber)) return cached.second;
ExternalAddressFormatter formatter = new ExternalAddressFormatter(localNumber);
cachedFormatter.set(new Pair<>(localNumber, formatter));
return formatter;
} else {
return new ExternalAddressFormatter(Util.getSimCountryIso(context).or("US"), true);
}
}
public boolean isGroup() { return GroupUtil.isEncodedGroup(address); }
public boolean isClosedGroup() { return GroupUtil.isClosedGroup(address); }
public boolean isOpenGroup() { return GroupUtil.isOpenGroup(address); }
public boolean isRSSFeed() { return GroupUtil.isRSSFeed(address); }
public boolean isMmsGroup() { return GroupUtil.isMmsGroup(address); }
public boolean isEmail() {
return NumberUtil.isValidEmail(address);
}
public boolean isPhone() {
return !isGroup() && !isEmail();
}
public @NonNull String toGroupString() {
if (!isGroup()) throw new AssertionError("Not group");
return address;
}
public @NonNull String toPhoneString() {
if (!isPhone() && !isOpenGroup()) {
if (isEmail()) throw new AssertionError("Not e164, is email");
if (isGroup()) throw new AssertionError("Not e164, is group");
throw new AssertionError("Not e164, unknown");
}
return address;
}
public @NonNull String toEmailString() {
if (!isEmail()) throw new AssertionError("Not email");
return address;
}
@Override
public @NonNull String toString() {
return address;
}
public String serialize() {
return address;
}
@Override
public boolean equals(Object other) {
if (this == other) return true;
if (other == null || !(other instanceof Address)) return false;
return address.equals(((Address) other).address);
}
@Override
public int hashCode() {
return address.hashCode();
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(address);
}
@Override
public int compareTo(@NonNull Address other) {
return address.compareTo(other.address);
}
@VisibleForTesting
public static class ExternalAddressFormatter {
private static final String TAG = ExternalAddressFormatter.class.getSimpleName();
private static final Set<String> SHORT_COUNTRIES = new HashSet<String>() {{
add("NU");
add("TK");
add("NC");
add("AC");
}};
private static final Pattern US_NO_AREACODE = Pattern.compile("^(\\d{7})$");
private static final Pattern BR_NO_AREACODE = Pattern.compile("^(9?\\d{8})$");
private final Optional<PhoneNumber> localNumber;
private final String localCountryCode;
private final Pattern ALPHA_PATTERN = Pattern.compile("[a-zA-Z]");
ExternalAddressFormatter(@NonNull String localNumberString) {
throw new AssertionError("Not Implemented");
}
ExternalAddressFormatter(@NonNull String localCountryCode, boolean countryCode) {
this.localNumber = Optional.absent();
this.localCountryCode = localCountryCode;
}
public String format(@Nullable String number) {
if (number == null) return "Unknown";
return number;
}
private @Nullable String parseAreaCode(@NonNull String e164Number, int countryCode) {
switch (countryCode) {
case 1:
return e164Number.substring(2, 5);
case 55:
return e164Number.substring(3, 5);
}
return null;
}
private @NonNull String applyAreaCodeRules(@NonNull Optional<PhoneNumber> localNumber, @NonNull String testNumber) {
if (!localNumber.isPresent() || !localNumber.get().getAreaCode().isPresent()) {
return testNumber;
}
Matcher matcher;
switch (localNumber.get().getCountryCode()) {
case 1:
matcher = US_NO_AREACODE.matcher(testNumber);
if (matcher.matches()) {
return localNumber.get().getAreaCode() + matcher.group();
}
break;
case 55:
matcher = BR_NO_AREACODE.matcher(testNumber);
if (matcher.matches()) {
return localNumber.get().getAreaCode() + matcher.group();
}
}
return testNumber;
}
private static class PhoneNumber {
private final String e164Number;
private final int countryCode;
private final Optional<String> areaCode;
PhoneNumber(String e164Number, int countryCode, @Nullable String areaCode) {
this.e164Number = e164Number;
this.countryCode = countryCode;
this.areaCode = Optional.fromNullable(areaCode);
}
String getE164Number() {
return e164Number;
}
int getCountryCode() {
return countryCode;
}
Optional<String> getAreaCode() {
return areaCode;
}
}
}
}