@SuppressLint("CheckResult")
private static @NonNull List<RecipientId> refreshDirectory(@NonNull Context context, @NonNull SignalServiceAccountManager accountManager) throws IOException {
  if (TextUtils.isEmpty(TextSecurePreferences.getLocalNumber(context))) {
    return Collections.emptyList();
  }

  if (!Permissions.hasAll(context, Manifest.permission.WRITE_CONTACTS)) {
    return Collections.emptyList();
  }

  RecipientDatabase recipientDatabase                       = DatabaseFactory.getRecipientDatabase(context);
  Set<String>       allRecipientNumbers                     = recipientDatabase.getAllPhoneNumbers();
  Stream<String>    eligibleRecipientDatabaseContactNumbers = Stream.of(allRecipientNumbers);
  Stream<String>    eligibleSystemDatabaseContactNumbers    = Stream.of(ContactAccessor.getInstance().getAllContactsWithNumbers(context));
  Set<String>       eligibleContactNumbers                  = Stream.concat(eligibleRecipientDatabaseContactNumbers, eligibleSystemDatabaseContactNumbers).collect(Collectors.toSet());
  Set<String>       storedNumbers                           = Stream.of(allRecipientNumbers).collect(Collectors.toSet());
  DirectoryResult   directoryResult                         = getDirectoryResult(context, accountManager, recipientDatabase, storedNumbers, eligibleContactNumbers);

  return directoryResult.getNewlyActiveRecipients();
}
 

public static @NonNull SignalServiceAccountManager createAuthenticated(@NonNull Context context,
                                                                       @NonNull UUID uuid,
                                                                       @NonNull String number,
                                                                       @NonNull String password)
{
  if (new SignalServiceNetworkAccess(context).isCensored(number)) {
    SignalExecutors.BOUNDED.execute(() -> {
      try {
        ProviderInstaller.installIfNeeded(context);
      } catch (Throwable t) {
        Log.w(TAG, t);
      }
    });
  }

  return new SignalServiceAccountManager(new SignalServiceNetworkAccess(context).getConfiguration(number),
                                         uuid, number, password, BuildConfig.SIGNAL_AGENT);
}
 

/**
 * Should only be used during registration when you haven't yet been assigned a UUID.
 */
public static @NonNull SignalServiceAccountManager createUnauthenticated(@NonNull Context context,
                                                                         @NonNull String number,
                                                                         @NonNull String password)
{
  if (new SignalServiceNetworkAccess(context).isCensored(number)) {
    SignalExecutors.BOUNDED.execute(() -> {
      try {
        ProviderInstaller.installIfNeeded(context);
      } catch (Throwable t) {
        Log.w(TAG, t);
      }
    });
  }

  return new SignalServiceAccountManager(new SignalServiceNetworkAccess(context).getConfiguration(number),
                                         null, number, password, BuildConfig.SIGNAL_AGENT);
}
 

@Override
protected Integer doInBackground(Void... params) {
  try {
    Context                     context        = getActivity();
    SignalServiceAccountManager accountManager = ApplicationDependencies.getSignalServiceAccountManager();

    try {
      accountManager.setGcmId(Optional.<String>absent());
    } catch (AuthorizationFailedException e) {
      Log.w(TAG, e);
    }

    if (!TextSecurePreferences.isFcmDisabled(context)) {
      FirebaseInstanceId.getInstance().deleteInstanceId();
    }

    return SUCCESS;
  } catch (IOException ioe) {
    Log.w(TAG, ioe);
    return NETWORK_ERROR;
  }
}
 

@Override
public void onRun() throws IOException {
  if (TextSecurePreferences.isSignedPreKeyRegistered(context)) {
    Log.w(TAG, "Signed prekey already registered...");
    return;
  }

  if (!TextSecurePreferences.isPushRegistered(context)) {
    Log.w(TAG, "Not yet registered...");
    return;
  }

  SignalServiceAccountManager accountManager     = ApplicationDependencies.getSignalServiceAccountManager();
  IdentityKeyPair             identityKeyPair    = IdentityKeyUtil.getIdentityKeyPair(context);
  SignedPreKeyRecord          signedPreKeyRecord = PreKeyUtil.generateSignedPreKey(context, identityKeyPair, true);

  accountManager.setSignedPreKey(signedPreKeyRecord);
  TextSecurePreferences.setSignedPreKeyRegistered(context, true);
}
 

@Override
public void onRun() throws Exception {
  SignalServiceAccountManager accountManager    = ApplicationDependencies.getSignalServiceAccountManager();
  RecipientDatabase           recipientDatabase = DatabaseFactory.getRecipientDatabase(context);
  ProfileKey                  profileKey        = ProfileKeyUtil.createNew();
  Recipient                   self              = Recipient.self();

  recipientDatabase.setProfileKey(self.getId(), profileKey);

   try (StreamDetails avatarStream = AvatarHelper.getSelfProfileAvatarStream(context)) {
    if (FeatureFlags.versionedProfiles()) {
      accountManager.setVersionedProfile(self.getUuid().get(),
                                         profileKey,
                                         Recipient.self().getProfileName().serialize(),
                                         avatarStream);
    } else {
      accountManager.setProfileName(profileKey, Recipient.self().getProfileName().serialize());
      accountManager.setProfileAvatar(profileKey, avatarStream);
    }
  }

  ApplicationDependencies.getJobManager().add(new RefreshAttributesJob());

  updateProfileKeyOnAllV2Groups();
}
 

@Override
public void onRun() throws Exception {
  Log.i(TAG, "Rotating signed prekey...");

  SignalServiceAccountManager accountManager     = ApplicationDependencies.getSignalServiceAccountManager();
  IdentityKeyPair             identityKey        = IdentityKeyUtil.getIdentityKeyPair(context);
  SignedPreKeyRecord          signedPreKeyRecord = PreKeyUtil.generateSignedPreKey(context, identityKey, false);

  accountManager.setSignedPreKey(signedPreKeyRecord);

  PreKeyUtil.setActiveSignedPreKeyId(context, signedPreKeyRecord.getId());
  TextSecurePreferences.setSignedPreKeyRegistered(context, true);
  TextSecurePreferences.setSignedPreKeyFailureCount(context, 0);

  ApplicationDependencies.getJobManager().add(new CleanPreKeysJob());
}
 

@Test
public void getPushChallengeBlocking_completes_fast_if_posted_to_event_bus() throws IOException {
  SignalServiceAccountManager signal = mock(SignalServiceAccountManager.class);
  doAnswer(invocation -> {
    AsyncTask.execute(() -> PushChallengeRequest.postChallengeResponse("CHALLENGE"));
    return null;
  }).when(signal).requestPushChallenge("token", "+123456");

  long startTime = System.currentTimeMillis();
  Optional<String> challenge = PushChallengeRequest.getPushChallengeBlocking(signal, Optional.of("token"), "+123456", 500L);
  long duration = System.currentTimeMillis() - startTime;

  assertThat(duration, lessThan(500L));
  verify(signal).requestPushChallenge("token", "+123456");
  verifyNoMoreInteractions(signal);

  assertTrue(challenge.isPresent());
  assertEquals("CHALLENGE", challenge.get());
}
 

public void finishDeviceLink(String deviceName) throws IOException, InvalidKeyException, TimeoutException, UserAlreadyExists {
    accountData.signalingKey = Util.getSecret(52);
    SignalServiceAccountManager.NewDeviceRegistrationReturn ret = accountManager.finishNewDeviceRegistration(accountData.axolotlStore.identityKeyStore.getIdentityKeyPair(), accountData.signalingKey, false, true, accountData.axolotlStore.identityKeyStore.getLocalRegistrationId(), deviceName);
    accountData.deviceId = ret.getDeviceId();
    accountData.username = ret.getNumber();
    // TODO do this check before actually registering
    if (userExists()) {
        throw new UserAlreadyExists(accountData.username, getFileName());
    }
    accountData.axolotlStore = new SignalProtocolStore(ret.getIdentity(), accountData.axolotlStore.identityKeyStore.getLocalRegistrationId());

    accountData.registered = true;
    refreshPreKeys();

    accountData.init();

    requestSyncGroups();
    requestSyncContacts();

    accountData.save();
    managers.put(accountData.username, this);
    logger.info("Successfully finished linked to " + Util.redact(accountData.username) + " as device #" + accountData.deviceId);
}
 

/**
 * Requests a push challenge and waits for the response.
 * <p>
 * Blocks the current thread for up to {@param timeoutMs} milliseconds.
 *
 * @param accountManager Account manager to request the push from.
 * @param fcmToken       Optional FCM token. If not present will return absent.
 * @param e164number     Local number.
 * @param timeoutMs      Timeout in milliseconds
 * @return Either returns a challenge, or absent.
 */
@WorkerThread
public static Optional<String> getPushChallengeBlocking(@NonNull SignalServiceAccountManager accountManager,
                                                        @NonNull Optional<String> fcmToken,
                                                        @NonNull String e164number,
                                                        long timeoutMs)
{
  if (!fcmToken.isPresent()) {
    Log.w(TAG, "Push challenge not requested, as no FCM token was present");
    return Optional.absent();
  }

  long startTime = System.currentTimeMillis();
  Log.i(TAG, "Requesting a push challenge");

  Request request = new Request(accountManager, fcmToken.get(), e164number, timeoutMs);

  Optional<String> challenge = request.requestAndReceiveChallengeBlocking();

  long duration = System.currentTimeMillis() - startTime;

  if (challenge.isPresent()) {
    Log.i(TAG, String.format(Locale.US, "Received a push challenge \"%s\" in %d ms", challenge.get(), duration));
  } else {
    Log.w(TAG, String.format(Locale.US, "Did not received a push challenge in %d ms", duration));
  }
  return challenge;
}
 

private Request(@NonNull SignalServiceAccountManager accountManager,
                @NonNull String fcmToken,
                @NonNull String e164number,
                long timeoutMs)
{
  this.latch          = new CountDownLatch(1);
  this.challenge      = new AtomicReference<>();
  this.accountManager = accountManager;
  this.fcmToken       = fcmToken;
  this.e164number     = e164number;
  this.timeoutMs      = timeoutMs;
}
 

@Override
public void onRun() throws IOException {
  if (!TextSecurePreferences.isPushRegistered(context) || TextSecurePreferences.getLocalNumber(context) == null) {
    Log.w(TAG, "Not yet registered. Skipping.");
    return;
  }

  int       registrationId              = TextSecurePreferences.getLocalRegistrationId(context);
  boolean   fetchesMessages             = TextSecurePreferences.isFcmDisabled(context);
  byte[]    unidentifiedAccessKey       = UnidentifiedAccess.deriveAccessKeyFrom(ProfileKeyUtil.getSelfProfileKey());
  boolean   universalUnidentifiedAccess = TextSecurePreferences.isUniversalUnidentifiedAccess(context);
  String    registrationLockV1          = null;
  String    registrationLockV2          = null;
  KbsValues kbsValues                   = SignalStore.kbsValues();

  if (kbsValues.isV2RegistrationLockEnabled()) {
    registrationLockV2 = kbsValues.getRegistrationLockToken();
  } else if (TextSecurePreferences.isV1RegistrationLockEnabled(context)) {
    //noinspection deprecation Ok to read here as they have not migrated
    registrationLockV1 = TextSecurePreferences.getDeprecatedV1RegistrationLockPin(context);
  }

  Log.i(TAG, "Calling setAccountAttributes() reglockV1? " + !TextUtils.isEmpty(registrationLockV1) + ", reglockV2? " + !TextUtils.isEmpty(registrationLockV2) + ", pin? " + kbsValues.hasPin());

  SignalServiceAccountManager signalAccountManager = ApplicationDependencies.getSignalServiceAccountManager();
  signalAccountManager.setAccountAttributes(null, registrationId, fetchesMessages,
                                            registrationLockV1, registrationLockV2,
                                            unidentifiedAccessKey, universalUnidentifiedAccess,
                                            AppCapabilities.getCapabilities(kbsValues.hasPin()));
}
 

@Override
public void onRun() throws IOException {
  if (!TextSecurePreferences.isPushRegistered(context)) {
    Log.w(TAG, "Not registered. Skipping.");
    return;
  }

  SignalServiceAccountManager accountManager = ApplicationDependencies.getSignalServiceAccountManager();

  int availableKeys = accountManager.getPreKeysCount();

  Log.i(TAG, "Available keys: " + availableKeys);

  if (availableKeys >= PREKEY_MINIMUM && TextSecurePreferences.isSignedPreKeyRegistered(context)) {
    Log.i(TAG, "Available keys sufficient.");
    SignalStore.setLastPrekeyRefreshTime(System.currentTimeMillis());
    return;
  }

  List<PreKeyRecord> preKeyRecords       = PreKeyUtil.generatePreKeys(context);
  IdentityKeyPair    identityKey         = IdentityKeyUtil.getIdentityKeyPair(context);
  SignedPreKeyRecord signedPreKeyRecord  = PreKeyUtil.generateSignedPreKey(context, identityKey, false);

  Log.i(TAG, "Registering new prekeys...");

  accountManager.setPreKeys(identityKey.getPublicKey(), signedPreKeyRecord, preKeyRecords);

  PreKeyUtil.setActiveSignedPreKeyId(context, signedPreKeyRecord.getId());
  TextSecurePreferences.setSignedPreKeyRegistered(context, true);

  ApplicationDependencies.getJobManager().add(new CleanPreKeysJob());
  SignalStore.setLastPrekeyRefreshTime(System.currentTimeMillis());
  Log.i(TAG, "Successfully refreshed prekeys.");
}
 

@Override
public void onRun() throws IOException {
  if (!TextSecurePreferences.isPushRegistered(context)) {
    Log.w(TAG, "Not yet registered. Ignoring.");
    return;
  }

  synchronized (RotateCertificateJob.class) {
    SignalServiceAccountManager accountManager = ApplicationDependencies.getSignalServiceAccountManager();
    byte[]                      certificate    = accountManager.getSenderCertificate();

    TextSecurePreferences.setUnidentifiedAccessCertificate(context, certificate);
  }
}
 

public static synchronized @NonNull SignalServiceAccountManager getSignalServiceAccountManager() {
  assertInitialization();

  if (accountManager == null) {
    accountManager = provider.provideSignalServiceAccountManager();
  }

  return accountManager;
}
 

@Override
public @NonNull SignalServiceAccountManager provideSignalServiceAccountManager() {
  return new SignalServiceAccountManager(networkAccess.getConfiguration(context),
                                         new DynamicCredentialsProvider(context),
                                         BuildConfig.SIGNAL_AGENT,
                                         provideGroupsV2Operations());
}
 

@Test
public void getPushChallengeBlocking_returns_absent_if_times_out() {
  SignalServiceAccountManager signal = mock(SignalServiceAccountManager.class);

  Optional<String> challenge = PushChallengeRequest.getPushChallengeBlocking(signal, Optional.of("token"), "+123456", 50L);

  assertFalse(challenge.isPresent());
}
 

@Test
public void getPushChallengeBlocking_waits_for_specified_period() {
  SignalServiceAccountManager signal = mock(SignalServiceAccountManager.class);

  long startTime = System.currentTimeMillis();
  PushChallengeRequest.getPushChallengeBlocking(signal, Optional.of("token"), "+123456", 250L);
  long duration = System.currentTimeMillis() - startTime;

  assertThat(duration, greaterThanOrEqualTo(250L));
}
 

@Test
public void getPushChallengeBlocking_returns_fast_if_no_fcm_token_supplied() {
  SignalServiceAccountManager signal = mock(SignalServiceAccountManager.class);

  long startTime = System.currentTimeMillis();
  PushChallengeRequest.getPushChallengeBlocking(signal, Optional.absent(), "+123456", 500L);
  long duration = System.currentTimeMillis() - startTime;

  assertThat(duration, lessThan(500L));
}
 

@Test
public void getPushChallengeBlocking_returns_absent_if_no_fcm_token_supplied() {
  SignalServiceAccountManager signal = mock(SignalServiceAccountManager.class);

  Optional<String> challenge = PushChallengeRequest.getPushChallengeBlocking(signal, Optional.absent(), "+123456", 500L);

  verifyZeroInteractions(signal);
  assertFalse(challenge.isPresent());
}
 

public void register(String username) throws IOException, BackingStoreException {
    logger.info("Sending verification SMS to " + username + ".");
    prefs.clear();
    String password = Base64.encodeBytes(Util.getSecretBytes(18));
    prefs.put("LOCAL_USERNAME", username);
    prefs.put("LOCAL_PASSWORD", password);
    accountManager = new SignalServiceAccountManager(config, username, password, USER_AGENT);
    accountManager.requestSmsVerificationCode(false);
}
 

public void verify(String verificationCode) throws IOException {
    String username = prefs.get("LOCAL_USERNAME", null);
    String password = prefs.get("LOCAL_PASSWORD", null);
    logger.info("Verifying user " + username + " with code " + verificationCode + "...");
    String code = verificationCode.replace("-", "");
    int registrationId = KeyHelper.generateRegistrationId(false);
    prefs.putInt("REGISTRATION_ID", registrationId);
    byte[] profileKey = Util.getSecretBytes(32);
    byte[] unidentifiedAccessKey = UnidentifiedAccess.deriveAccessKeyFrom(profileKey);
    accountManager = new SignalServiceAccountManager(config, username, password, USER_AGENT);
    accountManager.verifyAccountWithCode(code, null, registrationId, true, null, unidentifiedAccessKey, false);
}
 

public void listen() throws IOException, InvalidKeyException {
    String username = prefs.get("LOCAL_USERNAME", null);
    String password = prefs.get("LOCAL_PASSWORD", null);
    logger.info("Generating keys for " + username + "...");
    IdentityKeyPair identityKeyPair = KeyHelper.generateIdentityKeyPair();
    int registrationId = prefs.getInt("REGISTRATION_ID", -1);
    this.protocolStore = new InMemorySignalProtocolStore(identityKeyPair, registrationId);
    accountManager = new SignalServiceAccountManager(config, username, password, USER_AGENT);
    refreshPreKeys(identityKeyPair);
    logger.info("Starting message listener...");
    messageRetrieverThread.start();
    // TODO refresh keys job
}
 

public void init() throws IOException {
    accountData = AccountData.load(new File(getFileName()));
    accountManager = new SignalServiceAccountManager(serviceConfiguration, accountData.username, accountData.password, accountData.deviceId, USER_AGENT, sleepTimer);
    try {
        if (accountData.registered && accountManager.getPreKeysCount() < PREKEY_MINIMUM_COUNT) {
            refreshPreKeys();
            accountData.save();
        }
    } catch (AuthorizationFailedException e) {
        logger.warn("Authorization failed, was the number registered elsewhere?");
        accountData.registered = false;
    }
}
 

public void register(boolean voiceVerification, Optional<String> captcha) throws IOException {
    accountData.password = Util.getSecret(18);

    accountManager = new SignalServiceAccountManager(serviceConfiguration, accountData.username, accountData.password, USER_AGENT, sleepTimer);

    if (voiceVerification) {
        accountManager.requestVoiceVerificationCode(Locale.getDefault(), captcha, Optional.absent());  // TODO: Allow requester to set the locale
    } else {
        accountManager.requestSmsVerificationCode(true, captcha, Optional.absent()); //  TODO: Allow requester to set challenge
    }

    accountData.registered = false;
    accountData.init();
    accountData.save();
}
 

public URI getDeviceLinkUri() throws TimeoutException, IOException {
    accountData.password = Util.getSecret(18);

    accountManager = new SignalServiceAccountManager(serviceConfiguration, accountData.username, accountData.password, USER_AGENT, sleepTimer);
    String uuid = accountManager.getNewDeviceUuid();

    accountData.registered = false;
    try {
        return new URI("tsdevice:/?uuid=" + URLEncoder.encode(uuid, "utf-8") + "&pub_key=" + URLEncoder.encode(Base64.encodeBytesWithoutPadding(accountData.axolotlStore.identityKeyStore.getIdentityKeyPair().getPublicKey().serialize()), "utf-8"));
    } catch (URISyntaxException e) {
        // Shouldn't happen
        return null;
    }
}
 

public ProvisioningManager(String settingsPath, SignalServiceConfiguration serviceConfiguration, String userAgent) {
    this.pathConfig = PathConfig.createDefault(settingsPath);
    this.serviceConfiguration = serviceConfiguration;
    this.userAgent = userAgent;

    identityKey = KeyHelper.generateIdentityKeyPair();
    registrationId = KeyHelper.generateRegistrationId(false);
    password = KeyUtils.createPassword();
    final SleepTimer timer = new UptimeSleepTimer();
    accountManager = new SignalServiceAccountManager(serviceConfiguration, null, null, password, SignalServiceAddress.DEFAULT_DEVICE_ID, userAgent, timer);
}
 

private static DirectoryResult getDirectoryResult(@NonNull Context context,
                                                  @NonNull SignalServiceAccountManager accountManager,
                                                  @NonNull RecipientDatabase recipientDatabase,
                                                  @NonNull Set<String> locallyStoredNumbers,
                                                  @NonNull Set<String> eligibleContactNumbers)
    throws IOException
{
  FuzzyPhoneNumberHelper.InputResult  inputResult   = FuzzyPhoneNumberHelper.generateInput(eligibleContactNumbers, locallyStoredNumbers);
  List<ContactTokenDetails>           activeTokens  = accountManager.getContacts(inputResult.getNumbers());
  Set<String>                         activeNumbers = Stream.of(activeTokens).map(ContactTokenDetails::getNumber).collect(Collectors.toSet());
  FuzzyPhoneNumberHelper.OutputResult outputResult  = FuzzyPhoneNumberHelper.generateOutput(activeNumbers, inputResult);

  if (inputResult.getFuzzies().size() > 0) {
    Log.i(TAG, "[getDirectoryResult] Got a fuzzy number result.");
  }

  if (outputResult.getRewrites().size() > 0) {
    Log.i(TAG, "[getDirectoryResult] Need to rewrite some numbers.");
  }

  recipientDatabase.updatePhoneNumbers(outputResult.getRewrites());

  List<RecipientId> activeIds   = new LinkedList<>();
  List<RecipientId> inactiveIds = new LinkedList<>();

  Set<String> inactiveContactNumbers = new HashSet<>(inputResult.getNumbers());
  inactiveContactNumbers.removeAll(outputResult.getRewrites().keySet());

  for (String number : outputResult.getNumbers()) {
    activeIds.add(recipientDatabase.getOrInsertFromE164(number));
    inactiveContactNumbers.remove(number);
  }

  for (String inactiveContactNumber : inactiveContactNumbers) {
    inactiveIds.add(recipientDatabase.getOrInsertFromE164(inactiveContactNumber));
  }

  Set<RecipientId>  currentActiveIds = new HashSet<>(recipientDatabase.getRegistered());
  Set<RecipientId>  contactIds       = new HashSet<>(recipientDatabase.getSystemContacts());
  List<RecipientId> newlyActiveIds   = Stream.of(activeIds)
                                             .filter(id -> !currentActiveIds.contains(id))
                                             .filter(contactIds::contains)
                                             .toList();

  recipientDatabase.setRegistered(activeIds, inactiveIds);
  updateContactsDatabase(context, activeIds, true, outputResult.getRewrites());

  Set<String> activeContactNumbers = Stream.of(activeIds).map(Recipient::resolved).filter(Recipient::hasSmsAddress).map(Recipient::requireSmsAddress).collect(Collectors.toSet());

  if (TextSecurePreferences.hasSuccessfullyRetrievedDirectory(context)) {
    return new DirectoryResult(activeContactNumbers, newlyActiveIds);
  } else {
    TextSecurePreferences.setHasSuccessfullyRetrievedDirectory(context, true);
    return new DirectoryResult(activeContactNumbers);
  }
}
 

private static RegisteredState getRegisteredState(@NonNull Context                     context,
                                                  @NonNull SignalServiceAccountManager accountManager,
                                                  @NonNull RecipientDatabase           recipientDatabase,
                                                  @NonNull Recipient                   recipient)
    throws IOException
{
  boolean                       activeUser    = recipient.resolve().getRegistered() == RegisteredState.REGISTERED;
  boolean                       systemContact = recipient.isSystemContact();
  Optional<ContactTokenDetails> details       = Optional.absent();
  Map<String, String>           rewrites      = new HashMap<>();

  if (recipient.hasE164()) {
    FuzzyPhoneNumberHelper.InputResult inputResult = FuzzyPhoneNumberHelper.generateInput(Collections.singletonList(recipient.requireE164()), recipientDatabase.getAllPhoneNumbers());

    if (inputResult.getNumbers().size() > 1) {
      Log.i(TAG, "[getRegisteredState] Got a fuzzy number result.");

      List<ContactTokenDetails>           detailList   = accountManager.getContacts(inputResult.getNumbers());
      Collection<String>                  registered   = Stream.of(detailList).map(ContactTokenDetails::getNumber).collect(Collectors.toSet());
      FuzzyPhoneNumberHelper.OutputResult outputResult = FuzzyPhoneNumberHelper.generateOutput(registered, inputResult);
      String                              finalNumber  = recipient.requireE164();
      ContactTokenDetails                 detail       = new ContactTokenDetails();

      if (outputResult.getRewrites().size() > 0 && outputResult.getRewrites().containsKey(finalNumber)) {
        Log.i(TAG, "[getRegisteredState] Need to rewrite a number.");
        finalNumber = outputResult.getRewrites().get(finalNumber);
        rewrites    = outputResult.getRewrites();
      }

      detail.setNumber(finalNumber);
      details = Optional.of(detail);

      recipientDatabase.updatePhoneNumbers(outputResult.getRewrites());
    } else {
      details = accountManager.getContact(recipient.requireE164());
    }
  }

  if (details.isPresent()) {
    recipientDatabase.setRegistered(recipient.getId(), RegisteredState.REGISTERED);

    if (Permissions.hasAll(context, Manifest.permission.WRITE_CONTACTS)) {
      updateContactsDatabase(context, Util.asList(recipient.getId()), false, rewrites);
    }

    if (!activeUser && TextSecurePreferences.isMultiDevice(context)) {
      ApplicationDependencies.getJobManager().add(new MultiDeviceContactUpdateJob());
    }

    if (!activeUser && systemContact) {
      notifyNewUsers(context, Collections.singletonList(recipient.getId()));
    }

    return RegisteredState.REGISTERED;
  } else {
    recipientDatabase.setRegistered(recipient.getId(), RegisteredState.NOT_REGISTERED);
    return RegisteredState.NOT_REGISTERED;
  }
}
 

public DeviceListLoader(Context context, SignalServiceAccountManager accountManager) {
  super(context);
  this.accountManager = accountManager;
}