Move all files to natural position.

This commit is contained in:
Alan Evans
2020-01-06 10:52:48 -05:00
parent 0df36047e7
commit 9ebe920195
3016 changed files with 6 additions and 36 deletions

View File

@@ -0,0 +1,183 @@
package org.thoughtcrime.securesms.dependencies;
import android.app.Application;
import androidx.annotation.NonNull;
import org.thoughtcrime.securesms.BuildConfig;
import org.thoughtcrime.securesms.IncomingMessageProcessor;
import org.thoughtcrime.securesms.gcm.MessageRetriever;
import org.thoughtcrime.securesms.jobmanager.JobManager;
import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
import org.thoughtcrime.securesms.recipients.LiveRecipientCache;
import org.thoughtcrime.securesms.service.IncomingMessageObserver;
import org.thoughtcrime.securesms.util.FeatureFlags;
import org.thoughtcrime.securesms.util.FrameRateTracker;
import org.thoughtcrime.securesms.util.IasKeyStore;
import org.thoughtcrime.securesms.util.TextSecurePreferences;
import org.whispersystems.signalservice.api.KeyBackupService;
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(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
* to manage their singleton-ness.
*/
public class ApplicationDependencies {
private static Application application;
private static Provider provider;
private static SignalServiceAccountManager accountManager;
private static SignalServiceMessageSender messageSender;
private static SignalServiceMessageReceiver messageReceiver;
private static IncomingMessageProcessor incomingMessageProcessor;
private static MessageRetriever messageRetriever;
private static LiveRecipientCache recipientCache;
private static JobManager jobManager;
private static FrameRateTracker frameRateTracker;
public static synchronized void init(@NonNull Application application, @NonNull Provider provider) {
if (ApplicationDependencies.application != null || ApplicationDependencies.provider != null) {
throw new IllegalStateException("Already initialized!");
}
ApplicationDependencies.application = application;
ApplicationDependencies.provider = provider;
}
public static @NonNull Application getApplication() {
assertInitialization();
return application;
}
public static synchronized @NonNull SignalServiceAccountManager getSignalServiceAccountManager() {
assertInitialization();
if (accountManager == null) {
accountManager = provider.provideSignalServiceAccountManager();
}
return accountManager;
}
public static synchronized @NonNull KeyBackupService getKeyBackupService() {
if (!FeatureFlags.KBS) throw new AssertionError();
return getSignalServiceAccountManager().getKeyBackupService(IasKeyStore.getIasKeyStore(application),
BuildConfig.KEY_BACKUP_ENCLAVE_NAME,
BuildConfig.KEY_BACKUP_MRENCLAVE,
10);
}
public static synchronized @NonNull SignalServiceMessageSender getSignalServiceMessageSender() {
assertInitialization();
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();
if (messageReceiver == null) {
messageReceiver = provider.provideSignalServiceMessageReceiver();
}
return messageReceiver;
}
public static synchronized void resetSignalServiceMessageReceiver() {
assertInitialization();
messageReceiver = null;
}
public static synchronized @NonNull SignalServiceNetworkAccess getSignalServiceNetworkAccess() {
assertInitialization();
return provider.provideSignalServiceNetworkAccess();
}
public static synchronized @NonNull IncomingMessageProcessor getIncomingMessageProcessor() {
assertInitialization();
if (incomingMessageProcessor == null) {
incomingMessageProcessor = provider.provideIncomingMessageProcessor();
}
return incomingMessageProcessor;
}
public static synchronized @NonNull MessageRetriever getMessageRetriever() {
assertInitialization();
if (messageRetriever == null) {
messageRetriever = provider.provideMessageRetriever();
}
return messageRetriever;
}
public static synchronized @NonNull LiveRecipientCache getRecipientCache() {
assertInitialization();
if (recipientCache == null) {
recipientCache = provider.provideRecipientCache();
}
return recipientCache;
}
public static synchronized @NonNull JobManager getJobManager() {
assertInitialization();
if (jobManager == null) {
jobManager = provider.provideJobManager();
}
return jobManager;
}
public static synchronized @NonNull FrameRateTracker getFrameRateTracker() {
assertInitialization();
if (frameRateTracker == null) {
frameRateTracker = provider.provideFrameRateTracker();
}
return frameRateTracker;
}
private static void assertInitialization() {
if (application == null || provider == null) {
throw new UninitializedException();
}
}
public interface Provider {
@NonNull SignalServiceAccountManager provideSignalServiceAccountManager();
@NonNull SignalServiceMessageSender provideSignalServiceMessageSender();
@NonNull SignalServiceMessageReceiver provideSignalServiceMessageReceiver();
@NonNull SignalServiceNetworkAccess provideSignalServiceNetworkAccess();
@NonNull IncomingMessageProcessor provideIncomingMessageProcessor();
@NonNull MessageRetriever provideMessageRetriever();
@NonNull LiveRecipientCache provideRecipientCache();
@NonNull JobManager provideJobManager();
@NonNull FrameRateTracker provideFrameRateTracker();
}
private static class UninitializedException extends IllegalStateException {
private UninitializedException() {
super("You must call init() first!");
}
}
}

View File

@@ -0,0 +1,176 @@
package org.thoughtcrime.securesms.dependencies;
import android.app.Application;
import android.content.Context;
import androidx.annotation.NonNull;
import org.greenrobot.eventbus.EventBus;
import org.thoughtcrime.securesms.BuildConfig;
import org.thoughtcrime.securesms.IncomingMessageProcessor;
import org.thoughtcrime.securesms.crypto.storage.SignalProtocolStoreImpl;
import org.thoughtcrime.securesms.database.DatabaseFactory;
import org.thoughtcrime.securesms.events.ReminderUpdateEvent;
import org.thoughtcrime.securesms.gcm.MessageRetriever;
import org.thoughtcrime.securesms.jobmanager.Job;
import org.thoughtcrime.securesms.jobmanager.JobManager;
import org.thoughtcrime.securesms.jobmanager.JobMigrator;
import org.thoughtcrime.securesms.jobmanager.impl.JsonDataSerializer;
import org.thoughtcrime.securesms.jobs.FastJobStorage;
import org.thoughtcrime.securesms.jobs.JobManagerFactories;
import org.thoughtcrime.securesms.logging.Log;
import org.thoughtcrime.securesms.push.SecurityEventListener;
import org.thoughtcrime.securesms.push.SignalServiceNetworkAccess;
import org.thoughtcrime.securesms.recipients.LiveRecipientCache;
import org.thoughtcrime.securesms.service.IncomingMessageObserver;
import org.thoughtcrime.securesms.util.AlarmSleepTimer;
import org.thoughtcrime.securesms.util.FrameRateTracker;
import org.thoughtcrime.securesms.util.TextSecurePreferences;
import org.whispersystems.libsignal.util.guava.Optional;
import org.whispersystems.signalservice.api.SignalServiceAccountManager;
import org.whispersystems.signalservice.api.SignalServiceMessageReceiver;
import org.whispersystems.signalservice.api.SignalServiceMessageSender;
import org.whispersystems.signalservice.api.util.CredentialsProvider;
import org.whispersystems.signalservice.api.util.SleepTimer;
import org.whispersystems.signalservice.api.util.UptimeSleepTimer;
import org.whispersystems.signalservice.api.websocket.ConnectivityListener;
import java.util.UUID;
/**
* Implementation of {@link ApplicationDependencies.Provider} that provides real app dependencies.
*/
public class ApplicationDependencyProvider implements ApplicationDependencies.Provider {
private static final String TAG = Log.tag(ApplicationDependencyProvider.class);
private final Application context;
private final SignalServiceNetworkAccess networkAccess;
public ApplicationDependencyProvider(@NonNull Application context, @NonNull SignalServiceNetworkAccess networkAccess) {
this.context = context;
this.networkAccess = networkAccess;
}
@Override
public @NonNull SignalServiceAccountManager provideSignalServiceAccountManager() {
return new SignalServiceAccountManager(networkAccess.getConfiguration(context),
new DynamicCredentialsProvider(context),
BuildConfig.USER_AGENT);
}
@Override
public @NonNull SignalServiceMessageSender provideSignalServiceMessageSender() {
return new SignalServiceMessageSender(networkAccess.getConfiguration(context),
new DynamicCredentialsProvider(context),
new SignalProtocolStoreImpl(context),
BuildConfig.USER_AGENT,
TextSecurePreferences.isMultiDevice(context),
Optional.fromNullable(IncomingMessageObserver.getPipe()),
Optional.fromNullable(IncomingMessageObserver.getUnidentifiedPipe()),
Optional.of(new SecurityEventListener(context)));
}
@Override
public @NonNull SignalServiceMessageReceiver provideSignalServiceMessageReceiver() {
SleepTimer sleepTimer = TextSecurePreferences.isFcmDisabled(context) ? new AlarmSleepTimer(context)
: new UptimeSleepTimer();
return new SignalServiceMessageReceiver(networkAccess.getConfiguration(context),
new DynamicCredentialsProvider(context),
BuildConfig.USER_AGENT,
new PipeConnectivityListener(),
sleepTimer);
}
@Override
public @NonNull SignalServiceNetworkAccess provideSignalServiceNetworkAccess() {
return networkAccess;
}
@Override
public @NonNull IncomingMessageProcessor provideIncomingMessageProcessor() {
return new IncomingMessageProcessor(context);
}
@Override
public @NonNull MessageRetriever provideMessageRetriever() {
return new MessageRetriever();
}
@Override
public @NonNull LiveRecipientCache provideRecipientCache() {
return new LiveRecipientCache(context);
}
@Override
public @NonNull JobManager provideJobManager() {
return new JobManager(context, new JobManager.Configuration.Builder()
.setDataSerializer(new JsonDataSerializer())
.setJobFactories(JobManagerFactories.getJobFactories(context))
.setConstraintFactories(JobManagerFactories.getConstraintFactories(context))
.setConstraintObservers(JobManagerFactories.getConstraintObservers(context))
.setJobStorage(new FastJobStorage(DatabaseFactory.getJobDatabase(context)))
.setJobMigrator(new JobMigrator(TextSecurePreferences.getJobManagerVersion(context), JobManager.CURRENT_VERSION, JobManagerFactories.getJobMigrations(context)))
.build());
}
@Override
public @NonNull FrameRateTracker provideFrameRateTracker() {
return new FrameRateTracker(context);
}
private static class DynamicCredentialsProvider implements CredentialsProvider {
private final Context context;
private DynamicCredentialsProvider(Context context) {
this.context = context.getApplicationContext();
}
@Override
public UUID getUuid() {
return TextSecurePreferences.getLocalUuid(context);
}
@Override
public String getE164() {
return TextSecurePreferences.getLocalNumber(context);
}
@Override
public String getPassword() {
return TextSecurePreferences.getPushServerPassword(context);
}
@Override
public String getSignalingKey() {
return TextSecurePreferences.getSignalingKey(context);
}
}
private class PipeConnectivityListener implements ConnectivityListener {
@Override
public void onConnected() {
Log.i(TAG, "onConnected()");
TextSecurePreferences.setUnauthorizedReceived(context, false);
}
@Override
public void onConnecting() {
Log.i(TAG, "onConnecting()");
}
@Override
public void onDisconnected() {
Log.w(TAG, "onDisconnected()");
}
@Override
public void onAuthenticationFailure() {
Log.w(TAG, "onAuthenticationFailure()");
TextSecurePreferences.setUnauthorizedReceived(context, true);
EventBus.getDefault().post(new ReminderUpdateEvent());
}
}
}