Refactor ApplicationDependencies.

src/org/thoughtcrime/securesms/ApplicationContext.java

@@ -234,7 +234,7 @@ public class ApplicationContext extends MultiDexApplication implements DefaultLi
   }
 
   private void initializeAppDependencies() {
-    ApplicationDependencies.init(new ApplicationDependencyProvider(this, new SignalServiceNetworkAccess(this)));
+    ApplicationDependencies.init(this, new ApplicationDependencyProvider(this, new SignalServiceNetworkAccess(this)));
   }
 
   private void initializeGcmCheck() {

src/org/thoughtcrime/securesms/dependencies/ApplicationDependencies.java

@@ -1,19 +1,22 @@
 package org.thoughtcrime.securesms.dependencies;
 
 import android.app.Application;
+import android.content.Context;
 
 import androidx.annotation.NonNull;
 
 import org.thoughtcrime.securesms.IncomingMessageProcessor;
 import org.thoughtcrime.securesms.gcm.MessageRetriever;
 import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
+import org.thoughtcrime.securesms.service.IncomingMessageObserver;
+import org.thoughtcrime.securesms.util.TextSecurePreferences;
 import org.whispersystems.signalservice.api.SignalServiceAccountManager;
 import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
 import org.whispersystems.signalservice.api.SignalServiceMessageSender;
 
 /**
  * Location for storing and retrieving application-scoped singletons. Users must call
- * {@link #init(Provider)} before using any of the methods, preferably early on in
+ * {@link #init(Application, Provider)} before using any of the methods, preferably early on in
  * {@link Application#onCreate()}.
  *
  * All future application-scoped singletons should be written as normal objects, then placed here
@@ -21,61 +24,95 @@ import org.whispersystems.signalservice.api.SignalServiceMessageSender;
  */
 public class ApplicationDependencies {
 
-  private static ApplicationDependencies instance;
+  private static Application application;
+  private static Provider    provider;
 
-  private final Provider provider;
+  private static SignalServiceAccountManager  accountManager;
+  private static SignalServiceMessageSender   messageSender;
+  private static SignalServiceMessageReceiver messageReceiver;
+  private static IncomingMessageProcessor     incomingMessageProcessor;
+  private static MessageRetriever             messageRetriever;
 
-  private ApplicationDependencies(@NonNull Provider provider) {
-    this.provider = provider;
+  public static synchronized void init(@NonNull Application application, @NonNull Provider provider) {
+    if (ApplicationDependencies.application != null || ApplicationDependencies.provider != null) {
+      throw new IllegalStateException("Already initialized!");
     }
 
-  public static synchronized void init(@NonNull Provider provider) {
-    instance = new ApplicationDependencies(provider);
+    ApplicationDependencies.application = application;
+    ApplicationDependencies.provider    = provider;
   }
 
   public static synchronized @NonNull SignalServiceAccountManager getSignalServiceAccountManager() {
     assertInitialization();
-    return instance.provider.getSignalServiceAccountManager();
+
+    if (accountManager == null) {
+      accountManager = provider.provideSignalServiceAccountManager();
+    }
+
+    return accountManager;
   }
 
   public static synchronized @NonNull SignalServiceMessageSender getSignalServiceMessageSender() {
     assertInitialization();
-    return instance.provider.getSignalServiceMessageSender();
+
+    if (messageSender == null) {
+      messageSender = provider.provideSignalServiceMessageSender();
+    } else {
+      messageSender.setMessagePipe(IncomingMessageObserver.getPipe(), IncomingMessageObserver.getUnidentifiedPipe());
+      messageSender.setIsMultiDevice(TextSecurePreferences.isMultiDevice(application));
+    }
+
+    return messageSender;
   }
 
   public static synchronized @NonNull SignalServiceMessageReceiver getSignalServiceMessageReceiver() {
     assertInitialization();
-    return instance.provider.getSignalServiceMessageReceiver();
+
+    if (messageReceiver == null) {
+      messageReceiver = provider.provideSignalServiceMessageReceiver();
+    }
+
+    return messageReceiver;
   }
 
   public static synchronized @NonNull SignalServiceNetworkAccess getSignalServiceNetworkAccess() {
     assertInitialization();
-    return instance.provider.getSignalServiceNetworkAccess();
+    return provider.provideSignalServiceNetworkAccess();
   }
 
   public static synchronized @NonNull IncomingMessageProcessor getIncomingMessageProcessor() {
     assertInitialization();
-    return instance.provider.getIncomingMessageProcessor();
+
+    if (incomingMessageProcessor == null) {
+      incomingMessageProcessor = provider.provideIncomingMessageProcessor();
+    }
+
+    return incomingMessageProcessor;
   }
 
   public static synchronized @NonNull MessageRetriever getMessageRetriever() {
     assertInitialization();
-    return instance.provider.getMessageRetriever();
+
+    if (messageRetriever == null) {
+      messageRetriever = provider.provideMessageRetriever();
+    }
+
+    return messageRetriever;
   }
 
   private static void assertInitialization() {
-    if (instance == null) {
+    if (application == null || provider == null) {
       throw new UninitializedException();
     }
   }
 
   public interface Provider {
-    @NonNull SignalServiceAccountManager getSignalServiceAccountManager();
-    @NonNull SignalServiceMessageSender getSignalServiceMessageSender();
-    @NonNull SignalServiceMessageReceiver getSignalServiceMessageReceiver();
-    @NonNull SignalServiceNetworkAccess getSignalServiceNetworkAccess();
-    @NonNull IncomingMessageProcessor getIncomingMessageProcessor();
-    @NonNull MessageRetriever getMessageRetriever();
+    @NonNull SignalServiceAccountManager provideSignalServiceAccountManager();
+    @NonNull SignalServiceMessageSender provideSignalServiceMessageSender();
+    @NonNull SignalServiceMessageReceiver provideSignalServiceMessageReceiver();
+    @NonNull SignalServiceNetworkAccess provideSignalServiceNetworkAccess();
+    @NonNull IncomingMessageProcessor provideIncomingMessageProcessor();
+    @NonNull MessageRetriever provideMessageRetriever();
   }
 
   private static class UninitializedException extends IllegalStateException {

src/org/thoughtcrime/securesms/dependencies/ApplicationDependencyProvider.java

@@ -35,32 +35,21 @@ public class ApplicationDependencyProvider implements ApplicationDependencies.Pr
   private final Context                    context;
   private final SignalServiceNetworkAccess networkAccess;
 
-  private SignalServiceAccountManager  accountManager;
-  private SignalServiceMessageSender   messageSender;
-  private SignalServiceMessageReceiver messageReceiver;
-  private IncomingMessageProcessor     incomingMessageProcessor;
-  private MessageRetriever             messageRetriever;
-
   public ApplicationDependencyProvider(@NonNull Context context, @NonNull SignalServiceNetworkAccess networkAccess) {
     this.context       = context.getApplicationContext();
     this.networkAccess = networkAccess;
   }
 
   @Override
-  public @NonNull SignalServiceAccountManager getSignalServiceAccountManager() {
-    if (accountManager == null) {
-      this.accountManager = new SignalServiceAccountManager(networkAccess.getConfiguration(context),
+  public @NonNull SignalServiceAccountManager provideSignalServiceAccountManager() {
+    return new SignalServiceAccountManager(networkAccess.getConfiguration(context),
                                            new DynamicCredentialsProvider(context),
                                            BuildConfig.USER_AGENT);
   }
 
-    return accountManager;
-  }
-
   @Override
-  public @NonNull SignalServiceMessageSender getSignalServiceMessageSender() {
-    if (this.messageSender == null) {
-      this.messageSender = new SignalServiceMessageSender(networkAccess.getConfiguration(context),
+  public @NonNull SignalServiceMessageSender provideSignalServiceMessageSender() {
+      return new SignalServiceMessageSender(networkAccess.getConfiguration(context),
                                             new DynamicCredentialsProvider(context),
                                             new SignalProtocolStoreImpl(context),
                                             BuildConfig.USER_AGENT,
@@ -68,51 +57,32 @@ public class ApplicationDependencyProvider implements ApplicationDependencies.Pr
                                             Optional.fromNullable(IncomingMessageObserver.getPipe()),
                                             Optional.fromNullable(IncomingMessageObserver.getUnidentifiedPipe()),
                                             Optional.of(new SecurityEventListener(context)));
-    }else {
-      this.messageSender.setMessagePipe(IncomingMessageObserver.getPipe(), IncomingMessageObserver.getUnidentifiedPipe());
-      this.messageSender.setIsMultiDevice(TextSecurePreferences.isMultiDevice(context));
-    }
-
-    return this.messageSender;
   }
 
   @Override
-  public @NonNull SignalServiceMessageReceiver getSignalServiceMessageReceiver() {
-    if (this.messageReceiver == null) {
+  public @NonNull SignalServiceMessageReceiver provideSignalServiceMessageReceiver() {
     SleepTimer sleepTimer = TextSecurePreferences.isFcmDisabled(context) ? new RealtimeSleepTimer(context)
                                                                          : new UptimeSleepTimer();
-
-      this.messageReceiver = new SignalServiceMessageReceiver(networkAccess.getConfiguration(context),
+    return new SignalServiceMessageReceiver(networkAccess.getConfiguration(context),
                                             new DynamicCredentialsProvider(context),
                                             BuildConfig.USER_AGENT,
                                             new PipeConnectivityListener(),
                                             sleepTimer);
   }
 
-    return this.messageReceiver;
-  }
-
   @Override
-  public @NonNull SignalServiceNetworkAccess getSignalServiceNetworkAccess() {
+  public @NonNull SignalServiceNetworkAccess provideSignalServiceNetworkAccess() {
     return networkAccess;
   }
 
   @Override
-  public @NonNull IncomingMessageProcessor getIncomingMessageProcessor() {
-    if (incomingMessageProcessor == null) {
-      incomingMessageProcessor = new IncomingMessageProcessor(context);
-    }
-
-    return incomingMessageProcessor;
+  public @NonNull IncomingMessageProcessor provideIncomingMessageProcessor() {
+    return new IncomingMessageProcessor(context);
   }
 
   @Override
-  public @NonNull MessageRetriever getMessageRetriever() {
-    if (messageRetriever == null) {
-      messageRetriever = new MessageRetriever();
-    }
-
-    return messageRetriever;
+  public @NonNull MessageRetriever provideMessageRetriever() {
+    return new MessageRetriever();
   }
 
   private static class DynamicCredentialsProvider implements CredentialsProvider {