index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideAppEventProcessorFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.IdManager;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.model.processor.AppEventProcessor;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideAppEventProcessorFactory implements Factory<AppEventProcessor> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<HealthConnectConstantsMapper> mapperProvider;
private final Provider<IdManager> managerProvider;
public AppModule_ProvideAppEventProcessorFactory(AppModule module,
Provider<Context> contextProvider, Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<IdManager> managerProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.mapperProvider = mapperProvider;
this.managerProvider = managerProvider;
}
@Override
public AppEventProcessor get() {
return provideAppEventProcessor(module, contextProvider.get(), mapperProvider.get(), managerProvider.get());
}
public static AppModule_ProvideAppEventProcessorFactory create(AppModule module,
Provider<Context> contextProvider, Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<IdManager> managerProvider) {
return new AppModule_ProvideAppEventProcessorFactory(module, contextProvider, mapperProvider, managerProvider);
}
public static AppEventProcessor provideAppEventProcessor(AppModule instance, Context context,
HealthConnectConstantsMapper mapper, IdManager manager) {
return Preconditions.checkNotNullFromProvides(instance.provideAppEventProcessor(context, mapper, manager));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideAuthRepositoryFactory.java | package sdk.sahha.android.di;
import android.content.SharedPreferences;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.repository.AuthRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideAuthRepositoryFactory implements Factory<AuthRepo> {
private final AppModule module;
private final Provider<SahhaApi> apiProvider;
private final Provider<SharedPreferences> encryptedSharedPreferencesProvider;
public AppModule_ProvideAuthRepositoryFactory(AppModule module, Provider<SahhaApi> apiProvider,
Provider<SharedPreferences> encryptedSharedPreferencesProvider) {
this.module = module;
this.apiProvider = apiProvider;
this.encryptedSharedPreferencesProvider = encryptedSharedPreferencesProvider;
}
@Override
public AuthRepo get() {
return provideAuthRepository(module, apiProvider.get(), encryptedSharedPreferencesProvider.get());
}
public static AppModule_ProvideAuthRepositoryFactory create(AppModule module,
Provider<SahhaApi> apiProvider,
Provider<SharedPreferences> encryptedSharedPreferencesProvider) {
return new AppModule_ProvideAuthRepositoryFactory(module, apiProvider, encryptedSharedPreferencesProvider);
}
public static AuthRepo provideAuthRepository(AppModule instance, SahhaApi api,
SharedPreferences encryptedSharedPreferences) {
return Preconditions.checkNotNullFromProvides(instance.provideAuthRepository(api, encryptedSharedPreferences));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideBatchAggregateLogsFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.use_case.background.BatchAggregateLogs;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideBatchAggregateLogsFactory implements Factory<BatchAggregateLogs> {
private final AppModule module;
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<PermissionActionProvider> providerProvider;
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
public AppModule_ProvideBatchAggregateLogsFactory(AppModule module,
Provider<SahhaTimeManager> timeManagerProvider,
Provider<PermissionActionProvider> providerProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider) {
this.module = module;
this.timeManagerProvider = timeManagerProvider;
this.providerProvider = providerProvider;
this.healthConnectRepoProvider = healthConnectRepoProvider;
}
@Override
public BatchAggregateLogs get() {
return provideBatchAggregateLogs(module, timeManagerProvider.get(), providerProvider.get(), healthConnectRepoProvider.get());
}
public static AppModule_ProvideBatchAggregateLogsFactory create(AppModule module,
Provider<SahhaTimeManager> timeManagerProvider,
Provider<PermissionActionProvider> providerProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider) {
return new AppModule_ProvideBatchAggregateLogsFactory(module, timeManagerProvider, providerProvider, healthConnectRepoProvider);
}
public static BatchAggregateLogs provideBatchAggregateLogs(AppModule instance,
SahhaTimeManager timeManager, PermissionActionProvider provider,
HealthConnectRepo healthConnectRepo) {
return Preconditions.checkNotNullFromProvides(instance.provideBatchAggregateLogs(timeManager, provider, healthConnectRepo));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideBatchMutexFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import kotlinx.coroutines.sync.Mutex;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideBatchMutexFactory implements Factory<Mutex> {
private final AppModule module;
public AppModule_ProvideBatchMutexFactory(AppModule module) {
this.module = module;
}
@Override
public Mutex get() {
return provideBatchMutex(module);
}
public static AppModule_ProvideBatchMutexFactory create(AppModule module) {
return new AppModule_ProvideBatchMutexFactory(module);
}
public static Mutex provideBatchMutex(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideBatchMutex());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideBatchedDataDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.BatchedDataDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideBatchedDataDaoFactory implements Factory<BatchedDataDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideBatchedDataDaoFactory(AppModule module,
Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public BatchedDataDao get() {
return provideBatchedDataDao(module, dbProvider.get());
}
public static AppModule_ProvideBatchedDataDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideBatchedDataDaoFactory(module, dbProvider);
}
public static BatchedDataDao provideBatchedDataDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideBatchedDataDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideBatchedDataRepositoryFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.dao.BatchedDataDao;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideBatchedDataRepositoryFactory implements Factory<BatchedDataRepo> {
private final AppModule module;
private final Provider<BatchedDataDao> batchedDataDaoProvider;
public AppModule_ProvideBatchedDataRepositoryFactory(AppModule module,
Provider<BatchedDataDao> batchedDataDaoProvider) {
this.module = module;
this.batchedDataDaoProvider = batchedDataDaoProvider;
}
@Override
public BatchedDataRepo get() {
return provideBatchedDataRepository(module, batchedDataDaoProvider.get());
}
public static AppModule_ProvideBatchedDataRepositoryFactory create(AppModule module,
Provider<BatchedDataDao> batchedDataDaoProvider) {
return new AppModule_ProvideBatchedDataRepositoryFactory(module, batchedDataDaoProvider);
}
public static BatchedDataRepo provideBatchedDataRepository(AppModule instance,
BatchedDataDao batchedDataDao) {
return Preconditions.checkNotNullFromProvides(instance.provideBatchedDataRepository(batchedDataDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideCalculateBatchLimitFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.use_case.CalculateBatchLimit;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideCalculateBatchLimitFactory implements Factory<CalculateBatchLimit> {
private final AppModule module;
private final Provider<BatchedDataRepo> batchedDataRepoProvider;
public AppModule_ProvideCalculateBatchLimitFactory(AppModule module,
Provider<BatchedDataRepo> batchedDataRepoProvider) {
this.module = module;
this.batchedDataRepoProvider = batchedDataRepoProvider;
}
@Override
public CalculateBatchLimit get() {
return provideCalculateBatchLimit(module, batchedDataRepoProvider.get());
}
public static AppModule_ProvideCalculateBatchLimitFactory create(AppModule module,
Provider<BatchedDataRepo> batchedDataRepoProvider) {
return new AppModule_ProvideCalculateBatchLimitFactory(module, batchedDataRepoProvider);
}
public static CalculateBatchLimit provideCalculateBatchLimit(AppModule instance,
BatchedDataRepo batchedDataRepo) {
return Preconditions.checkNotNullFromProvides(instance.provideCalculateBatchLimit(batchedDataRepo));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideConfigDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.ConfigurationDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideConfigDaoFactory implements Factory<ConfigurationDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideConfigDaoFactory(AppModule module, Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public ConfigurationDao get() {
return provideConfigDao(module, dbProvider.get());
}
public static AppModule_ProvideConfigDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideConfigDaoFactory(module, dbProvider);
}
public static ConfigurationDao provideConfigDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideConfigDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideConnectionStateManagerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.ConnectionStateManager;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideConnectionStateManagerFactory implements Factory<ConnectionStateManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideConnectionStateManagerFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public ConnectionStateManager get() {
return provideConnectionStateManager(module, contextProvider.get());
}
public static AppModule_ProvideConnectionStateManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideConnectionStateManagerFactory(module, contextProvider);
}
public static ConnectionStateManager provideConnectionStateManager(AppModule instance,
Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideConnectionStateManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDatBatcherRunnableFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.interaction.SensorInteractionManager;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.framework.runnable.DataBatcherRunnable;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDatBatcherRunnableFactory implements Factory<DataBatcherRunnable> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<PermissionManager> permissionManagerProvider;
private final Provider<SensorInteractionManager> sensorManagerProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
public AppModule_ProvideDatBatcherRunnableFactory(AppModule module,
Provider<Context> contextProvider, Provider<PermissionManager> permissionManagerProvider,
Provider<SensorInteractionManager> sensorManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.permissionManagerProvider = permissionManagerProvider;
this.sensorManagerProvider = sensorManagerProvider;
this.configRepoProvider = configRepoProvider;
}
@Override
public DataBatcherRunnable get() {
return provideDatBatcherRunnable(module, contextProvider.get(), permissionManagerProvider.get(), sensorManagerProvider.get(), configRepoProvider.get());
}
public static AppModule_ProvideDatBatcherRunnableFactory create(AppModule module,
Provider<Context> contextProvider, Provider<PermissionManager> permissionManagerProvider,
Provider<SensorInteractionManager> sensorManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider) {
return new AppModule_ProvideDatBatcherRunnableFactory(module, contextProvider, permissionManagerProvider, sensorManagerProvider, configRepoProvider);
}
public static DataBatcherRunnable provideDatBatcherRunnable(AppModule instance, Context context,
PermissionManager permissionManager, SensorInteractionManager sensorManager,
SahhaConfigRepo configRepo) {
return Preconditions.checkNotNullFromProvides(instance.provideDatBatcherRunnable(context, permissionManager, sensorManager, configRepo));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDataLogTransformerFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.mapper.AggregationDataTypeMapper;
import sdk.sahha.android.domain.transformer.AggregateDataLogTransformer;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDataLogTransformerFactory implements Factory<AggregateDataLogTransformer> {
private final AppModule module;
private final Provider<AggregationDataTypeMapper> mapperProvider;
public AppModule_ProvideDataLogTransformerFactory(AppModule module,
Provider<AggregationDataTypeMapper> mapperProvider) {
this.module = module;
this.mapperProvider = mapperProvider;
}
@Override
public AggregateDataLogTransformer get() {
return provideDataLogTransformer(module, mapperProvider.get());
}
public static AppModule_ProvideDataLogTransformerFactory create(AppModule module,
Provider<AggregationDataTypeMapper> mapperProvider) {
return new AppModule_ProvideDataLogTransformerFactory(module, mapperProvider);
}
public static AggregateDataLogTransformer provideDataLogTransformer(AppModule instance,
AggregationDataTypeMapper mapper) {
return Preconditions.checkNotNullFromProvides(instance.provideDataLogTransformer(mapper));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDatabaseFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDatabaseFactory implements Factory<SahhaDatabase> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideDatabaseFactory(AppModule module, Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public SahhaDatabase get() {
return provideDatabase(module, contextProvider.get());
}
public static AppModule_ProvideDatabaseFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideDatabaseFactory(module, contextProvider);
}
public static SahhaDatabase provideDatabase(AppModule instance, Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideDatabase(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDecryptorFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.security.Decryptor;
import sdk.sahha.android.data.local.dao.SecurityDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDecryptorFactory implements Factory<Decryptor> {
private final AppModule module;
private final Provider<SecurityDao> securityDaoProvider;
public AppModule_ProvideDecryptorFactory(AppModule module,
Provider<SecurityDao> securityDaoProvider) {
this.module = module;
this.securityDaoProvider = securityDaoProvider;
}
@Override
public Decryptor get() {
return provideDecryptor(module, securityDaoProvider.get());
}
public static AppModule_ProvideDecryptorFactory create(AppModule module,
Provider<SecurityDao> securityDaoProvider) {
return new AppModule_ProvideDecryptorFactory(module, securityDaoProvider);
}
public static Decryptor provideDecryptor(AppModule instance, SecurityDao securityDao) {
return Preconditions.checkNotNullFromProvides(instance.provideDecryptor(securityDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDefaultScopeFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import kotlinx.coroutines.CoroutineScope;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.DefaultScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDefaultScopeFactory implements Factory<CoroutineScope> {
private final AppModule module;
public AppModule_ProvideDefaultScopeFactory(AppModule module) {
this.module = module;
}
@Override
public CoroutineScope get() {
return provideDefaultScope(module);
}
public static AppModule_ProvideDefaultScopeFactory create(AppModule module) {
return new AppModule_ProvideDefaultScopeFactory(module);
}
public static CoroutineScope provideDefaultScope(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideDefaultScope());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDeviceInfoRepoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.local.dao.ConfigurationDao;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.manager.IdManager;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDeviceInfoRepoFactory implements Factory<DeviceInfoRepo> {
private final AppModule module;
private final Provider<ConfigurationDao> configDaoProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<IdManager> idManagerProvider;
public AppModule_ProvideDeviceInfoRepoFactory(AppModule module,
Provider<ConfigurationDao> configDaoProvider, Provider<SahhaApi> apiProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider, Provider<IdManager> idManagerProvider) {
this.module = module;
this.configDaoProvider = configDaoProvider;
this.apiProvider = apiProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.idManagerProvider = idManagerProvider;
}
@Override
public DeviceInfoRepo get() {
return provideDeviceInfoRepo(module, configDaoProvider.get(), apiProvider.get(), sahhaErrorLoggerProvider.get(), idManagerProvider.get());
}
public static AppModule_ProvideDeviceInfoRepoFactory create(AppModule module,
Provider<ConfigurationDao> configDaoProvider, Provider<SahhaApi> apiProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider, Provider<IdManager> idManagerProvider) {
return new AppModule_ProvideDeviceInfoRepoFactory(module, configDaoProvider, apiProvider, sahhaErrorLoggerProvider, idManagerProvider);
}
public static DeviceInfoRepo provideDeviceInfoRepo(AppModule instance, ConfigurationDao configDao,
SahhaApi api, SahhaErrorLogger sahhaErrorLogger, IdManager idManager) {
return Preconditions.checkNotNullFromProvides(instance.provideDeviceInfoRepo(configDao, api, sahhaErrorLogger, idManager));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDeviceUsageDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.DeviceUsageDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDeviceUsageDaoFactory implements Factory<DeviceUsageDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideDeviceUsageDaoFactory(AppModule module,
Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public DeviceUsageDao get() {
return provideDeviceUsageDao(module, dbProvider.get());
}
public static AppModule_ProvideDeviceUsageDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideDeviceUsageDaoFactory(module, dbProvider);
}
public static DeviceUsageDao provideDeviceUsageDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideDeviceUsageDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideDeviceUsageRepositoryFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.dao.DeviceUsageDao;
import sdk.sahha.android.domain.repository.DeviceUsageRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideDeviceUsageRepositoryFactory implements Factory<DeviceUsageRepo> {
private final AppModule module;
private final Provider<DeviceUsageDao> deviceUsageDaoProvider;
public AppModule_ProvideDeviceUsageRepositoryFactory(AppModule module,
Provider<DeviceUsageDao> deviceUsageDaoProvider) {
this.module = module;
this.deviceUsageDaoProvider = deviceUsageDaoProvider;
}
@Override
public DeviceUsageRepo get() {
return provideDeviceUsageRepository(module, deviceUsageDaoProvider.get());
}
public static AppModule_ProvideDeviceUsageRepositoryFactory create(AppModule module,
Provider<DeviceUsageDao> deviceUsageDaoProvider) {
return new AppModule_ProvideDeviceUsageRepositoryFactory(module, deviceUsageDaoProvider);
}
public static DeviceUsageRepo provideDeviceUsageRepository(AppModule instance,
DeviceUsageDao deviceUsageDao) {
return Preconditions.checkNotNullFromProvides(instance.provideDeviceUsageRepository(deviceUsageDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideEncryptedSharedPreferencesFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import android.content.SharedPreferences;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideEncryptedSharedPreferencesFactory implements Factory<SharedPreferences> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideEncryptedSharedPreferencesFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public SharedPreferences get() {
return provideEncryptedSharedPreferences(module, contextProvider.get());
}
public static AppModule_ProvideEncryptedSharedPreferencesFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideEncryptedSharedPreferencesFactory(module, contextProvider);
}
public static SharedPreferences provideEncryptedSharedPreferences(AppModule instance,
Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideEncryptedSharedPreferences(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideEncryptorFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.security.Encryptor;
import sdk.sahha.android.data.local.dao.SecurityDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideEncryptorFactory implements Factory<Encryptor> {
private final AppModule module;
private final Provider<SecurityDao> securityDaoProvider;
public AppModule_ProvideEncryptorFactory(AppModule module,
Provider<SecurityDao> securityDaoProvider) {
this.module = module;
this.securityDaoProvider = securityDaoProvider;
}
@Override
public Encryptor get() {
return provideEncryptor(module, securityDaoProvider.get());
}
public static AppModule_ProvideEncryptorFactory create(AppModule module,
Provider<SecurityDao> securityDaoProvider) {
return new AppModule_ProvideEncryptorFactory(module, securityDaoProvider);
}
public static Encryptor provideEncryptor(AppModule instance, SecurityDao securityDao) {
return Preconditions.checkNotNullFromProvides(instance.provideEncryptor(securityDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideGsonConverterFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import retrofit2.converter.gson.GsonConverterFactory;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideGsonConverterFactory implements Factory<GsonConverterFactory> {
private final AppModule module;
public AppModule_ProvideGsonConverterFactory(AppModule module) {
this.module = module;
}
@Override
public GsonConverterFactory get() {
return provideGsonConverter(module);
}
public static AppModule_ProvideGsonConverterFactory create(AppModule module) {
return new AppModule_ProvideGsonConverterFactory(module);
}
public static GsonConverterFactory provideGsonConverter(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideGsonConverter());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHealthConfigDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.HealthConnectConfigDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHealthConfigDaoFactory implements Factory<HealthConnectConfigDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideHealthConfigDaoFactory(AppModule module,
Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public HealthConnectConfigDao get() {
return provideHealthConfigDao(module, dbProvider.get());
}
public static AppModule_ProvideHealthConfigDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideHealthConfigDaoFactory(module, dbProvider);
}
public static HealthConnectConfigDao provideHealthConfigDao(AppModule instance,
SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideHealthConfigDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHealthConnectClientFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import androidx.health.connect.client.HealthConnectClient;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import org.jetbrains.annotations.Nullable;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHealthConnectClientFactory implements Factory<HealthConnectClient> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideHealthConnectClientFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
@Nullable
public HealthConnectClient get() {
return provideHealthConnectClient(module, contextProvider.get());
}
public static AppModule_ProvideHealthConnectClientFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideHealthConnectClientFactory(module, contextProvider);
}
@Nullable
public static HealthConnectClient provideHealthConnectClient(AppModule instance,
Context context) {
return instance.provideHealthConnectClient(context);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHealthConnectConstantsMapperFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHealthConnectConstantsMapperFactory implements Factory<HealthConnectConstantsMapper> {
private final AppModule module;
public AppModule_ProvideHealthConnectConstantsMapperFactory(AppModule module) {
this.module = module;
}
@Override
public HealthConnectConstantsMapper get() {
return provideHealthConnectConstantsMapper(module);
}
public static AppModule_ProvideHealthConnectConstantsMapperFactory create(AppModule module) {
return new AppModule_ProvideHealthConnectConstantsMapperFactory(module);
}
public static HealthConnectConstantsMapper provideHealthConnectConstantsMapper(
AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideHealthConnectConstantsMapper());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHealthConnectMapperDefaultsFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.data.mapper.HealthConnectMapperDefaults;
import sdk.sahha.android.domain.manager.IdManager;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHealthConnectMapperDefaultsFactory implements Factory<HealthConnectMapperDefaults> {
private final AppModule module;
private final Provider<HealthConnectConstantsMapper> mapperProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<IdManager> idManagerProvider;
public AppModule_ProvideHealthConnectMapperDefaultsFactory(AppModule module,
Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<SahhaTimeManager> timeManagerProvider, Provider<IdManager> idManagerProvider) {
this.module = module;
this.mapperProvider = mapperProvider;
this.timeManagerProvider = timeManagerProvider;
this.idManagerProvider = idManagerProvider;
}
@Override
public HealthConnectMapperDefaults get() {
return provideHealthConnectMapperDefaults(module, mapperProvider.get(), timeManagerProvider.get(), idManagerProvider.get());
}
public static AppModule_ProvideHealthConnectMapperDefaultsFactory create(AppModule module,
Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<SahhaTimeManager> timeManagerProvider, Provider<IdManager> idManagerProvider) {
return new AppModule_ProvideHealthConnectMapperDefaultsFactory(module, mapperProvider, timeManagerProvider, idManagerProvider);
}
public static HealthConnectMapperDefaults provideHealthConnectMapperDefaults(AppModule instance,
HealthConnectConstantsMapper mapper, SahhaTimeManager timeManager, IdManager idManager) {
return Preconditions.checkNotNullFromProvides(instance.provideHealthConnectMapperDefaults(mapper, timeManager, idManager));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHealthConnectRepoFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import androidx.health.connect.client.HealthConnectClient;
import androidx.work.WorkManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.data.local.dao.HealthConnectConfigDao;
import sdk.sahha.android.data.local.dao.MovementDao;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.manager.IdManager;
import sdk.sahha.android.domain.manager.PostChunkManager;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata({
"sdk.sahha.android.di.DefaultScope",
"sdk.sahha.android.di.IoScope"
})
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHealthConnectRepoFactory implements Factory<HealthConnectRepo> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<PostChunkManager> chunkManagerProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<WorkManager> workManagerProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<HealthConnectClient> clientProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<SahhaTimeManager> sahhaTimeManagerProvider;
private final Provider<HealthConnectConfigDao> healthConnectConfigDaoProvider;
private final Provider<MovementDao> movementDaoProvider;
private final Provider<HealthConnectConstantsMapper> constantsMapperProvider;
private final Provider<IdManager> idManagerProvider;
public AppModule_ProvideHealthConnectRepoFactory(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<PostChunkManager> chunkManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<AuthRepo> authRepoProvider,
Provider<SensorRepo> sensorRepoProvider, Provider<WorkManager> workManagerProvider,
Provider<SahhaApi> apiProvider, Provider<HealthConnectClient> clientProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaTimeManager> sahhaTimeManagerProvider,
Provider<HealthConnectConfigDao> healthConnectConfigDaoProvider,
Provider<MovementDao> movementDaoProvider,
Provider<HealthConnectConstantsMapper> constantsMapperProvider,
Provider<IdManager> idManagerProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.ioScopeProvider = ioScopeProvider;
this.chunkManagerProvider = chunkManagerProvider;
this.configRepoProvider = configRepoProvider;
this.authRepoProvider = authRepoProvider;
this.sensorRepoProvider = sensorRepoProvider;
this.workManagerProvider = workManagerProvider;
this.apiProvider = apiProvider;
this.clientProvider = clientProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.sahhaTimeManagerProvider = sahhaTimeManagerProvider;
this.healthConnectConfigDaoProvider = healthConnectConfigDaoProvider;
this.movementDaoProvider = movementDaoProvider;
this.constantsMapperProvider = constantsMapperProvider;
this.idManagerProvider = idManagerProvider;
}
@Override
public HealthConnectRepo get() {
return provideHealthConnectRepo(module, contextProvider.get(), defaultScopeProvider.get(), ioScopeProvider.get(), chunkManagerProvider.get(), configRepoProvider.get(), authRepoProvider.get(), sensorRepoProvider.get(), workManagerProvider.get(), apiProvider.get(), clientProvider.get(), sahhaErrorLoggerProvider.get(), sahhaTimeManagerProvider.get(), healthConnectConfigDaoProvider.get(), movementDaoProvider.get(), constantsMapperProvider.get(), idManagerProvider.get());
}
public static AppModule_ProvideHealthConnectRepoFactory create(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<PostChunkManager> chunkManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<AuthRepo> authRepoProvider,
Provider<SensorRepo> sensorRepoProvider, Provider<WorkManager> workManagerProvider,
Provider<SahhaApi> apiProvider, Provider<HealthConnectClient> clientProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaTimeManager> sahhaTimeManagerProvider,
Provider<HealthConnectConfigDao> healthConnectConfigDaoProvider,
Provider<MovementDao> movementDaoProvider,
Provider<HealthConnectConstantsMapper> constantsMapperProvider,
Provider<IdManager> idManagerProvider) {
return new AppModule_ProvideHealthConnectRepoFactory(module, contextProvider, defaultScopeProvider, ioScopeProvider, chunkManagerProvider, configRepoProvider, authRepoProvider, sensorRepoProvider, workManagerProvider, apiProvider, clientProvider, sahhaErrorLoggerProvider, sahhaTimeManagerProvider, healthConnectConfigDaoProvider, movementDaoProvider, constantsMapperProvider, idManagerProvider);
}
public static HealthConnectRepo provideHealthConnectRepo(AppModule instance, Context context,
CoroutineScope defaultScope, CoroutineScope ioScope, PostChunkManager chunkManager,
SahhaConfigRepo configRepo, AuthRepo authRepo, SensorRepo sensorRepo, WorkManager workManager,
SahhaApi api, HealthConnectClient client, SahhaErrorLogger sahhaErrorLogger,
SahhaTimeManager sahhaTimeManager, HealthConnectConfigDao healthConnectConfigDao,
MovementDao movementDao, HealthConnectConstantsMapper constantsMapper, IdManager idManager) {
return Preconditions.checkNotNullFromProvides(instance.provideHealthConnectRepo(context, defaultScope, ioScope, chunkManager, configRepo, authRepo, sensorRepo, workManager, api, client, sahhaErrorLogger, sahhaTimeManager, healthConnectConfigDao, movementDao, constantsMapper, idManager));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideHostAppLifecycleObserverFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.domain.interaction.PermissionInteractionManager;
import sdk.sahha.android.domain.model.processor.AppEventProcessor;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.framework.observer.HostAppLifecycleObserver;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideHostAppLifecycleObserverFactory implements Factory<HostAppLifecycleObserver> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<AppEventProcessor> processorProvider;
private final Provider<BatchedDataRepo> repositoryProvider;
private final Provider<PermissionInteractionManager> permissionInteractionManagerProvider;
private final Provider<CoroutineScope> ioScopeProvider;
public AppModule_ProvideHostAppLifecycleObserverFactory(AppModule module,
Provider<Context> contextProvider, Provider<AppEventProcessor> processorProvider,
Provider<BatchedDataRepo> repositoryProvider,
Provider<PermissionInteractionManager> permissionInteractionManagerProvider,
Provider<CoroutineScope> ioScopeProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.processorProvider = processorProvider;
this.repositoryProvider = repositoryProvider;
this.permissionInteractionManagerProvider = permissionInteractionManagerProvider;
this.ioScopeProvider = ioScopeProvider;
}
@Override
public HostAppLifecycleObserver get() {
return provideHostAppLifecycleObserver(module, contextProvider.get(), processorProvider.get(), repositoryProvider.get(), permissionInteractionManagerProvider.get(), ioScopeProvider.get());
}
public static AppModule_ProvideHostAppLifecycleObserverFactory create(AppModule module,
Provider<Context> contextProvider, Provider<AppEventProcessor> processorProvider,
Provider<BatchedDataRepo> repositoryProvider,
Provider<PermissionInteractionManager> permissionInteractionManagerProvider,
Provider<CoroutineScope> ioScopeProvider) {
return new AppModule_ProvideHostAppLifecycleObserverFactory(module, contextProvider, processorProvider, repositoryProvider, permissionInteractionManagerProvider, ioScopeProvider);
}
public static HostAppLifecycleObserver provideHostAppLifecycleObserver(AppModule instance,
Context context, AppEventProcessor processor, BatchedDataRepo repository,
PermissionInteractionManager permissionInteractionManager, CoroutineScope ioScope) {
return Preconditions.checkNotNullFromProvides(instance.provideHostAppLifecycleObserver(context, processor, repository, permissionInteractionManager, ioScope));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideIdManagerFactory.java | package sdk.sahha.android.di;
import android.content.SharedPreferences;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.IdManager;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideIdManagerFactory implements Factory<IdManager> {
private final AppModule module;
private final Provider<SharedPreferences> sharedPreferencesProvider;
public AppModule_ProvideIdManagerFactory(AppModule module,
Provider<SharedPreferences> sharedPreferencesProvider) {
this.module = module;
this.sharedPreferencesProvider = sharedPreferencesProvider;
}
@Override
public IdManager get() {
return provideIdManager(module, sharedPreferencesProvider.get());
}
public static AppModule_ProvideIdManagerFactory create(AppModule module,
Provider<SharedPreferences> sharedPreferencesProvider) {
return new AppModule_ProvideIdManagerFactory(module, sharedPreferencesProvider);
}
public static IdManager provideIdManager(AppModule instance,
SharedPreferences sharedPreferences) {
return Preconditions.checkNotNullFromProvides(instance.provideIdManager(sharedPreferences));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideInsightsRepositoryFactory.java | package sdk.sahha.android.di;
import androidx.health.connect.client.HealthConnectClient;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.repository.InsightsRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideInsightsRepositoryFactory implements Factory<InsightsRepo> {
private final AppModule module;
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<HealthConnectClient> clientProvider;
private final Provider<CoroutineScope> ioScopeProvider;
public AppModule_ProvideInsightsRepositoryFactory(AppModule module,
Provider<SahhaTimeManager> timeManagerProvider, Provider<SahhaApi> apiProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<HealthConnectClient> clientProvider, Provider<CoroutineScope> ioScopeProvider) {
this.module = module;
this.timeManagerProvider = timeManagerProvider;
this.apiProvider = apiProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.clientProvider = clientProvider;
this.ioScopeProvider = ioScopeProvider;
}
@Override
public InsightsRepo get() {
return provideInsightsRepository(module, timeManagerProvider.get(), apiProvider.get(), sahhaErrorLoggerProvider.get(), clientProvider.get(), ioScopeProvider.get());
}
public static AppModule_ProvideInsightsRepositoryFactory create(AppModule module,
Provider<SahhaTimeManager> timeManagerProvider, Provider<SahhaApi> apiProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<HealthConnectClient> clientProvider, Provider<CoroutineScope> ioScopeProvider) {
return new AppModule_ProvideInsightsRepositoryFactory(module, timeManagerProvider, apiProvider, sahhaErrorLoggerProvider, clientProvider, ioScopeProvider);
}
public static InsightsRepo provideInsightsRepository(AppModule instance,
SahhaTimeManager timeManager, SahhaApi api, SahhaErrorLogger sahhaErrorLogger,
HealthConnectClient client, CoroutineScope ioScope) {
return Preconditions.checkNotNullFromProvides(instance.provideInsightsRepository(timeManager, api, sahhaErrorLogger, client, ioScope));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideIoScopeFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import kotlinx.coroutines.CoroutineScope;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideIoScopeFactory implements Factory<CoroutineScope> {
private final AppModule module;
public AppModule_ProvideIoScopeFactory(AppModule module) {
this.module = module;
}
@Override
public CoroutineScope get() {
return provideIoScope(module);
}
public static AppModule_ProvideIoScopeFactory create(AppModule module) {
return new AppModule_ProvideIoScopeFactory(module);
}
public static CoroutineScope provideIoScope(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideIoScope());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideKeyguardManagerFactory.java | package sdk.sahha.android.di;
import android.app.KeyguardManager;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideKeyguardManagerFactory implements Factory<KeyguardManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideKeyguardManagerFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public KeyguardManager get() {
return provideKeyguardManager(module, contextProvider.get());
}
public static AppModule_ProvideKeyguardManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideKeyguardManagerFactory(module, contextProvider);
}
public static KeyguardManager provideKeyguardManager(AppModule instance, Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideKeyguardManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideMainScopeFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import kotlinx.coroutines.CoroutineScope;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.MainScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideMainScopeFactory implements Factory<CoroutineScope> {
private final AppModule module;
public AppModule_ProvideMainScopeFactory(AppModule module) {
this.module = module;
}
@Override
public CoroutineScope get() {
return provideMainScope(module);
}
public static AppModule_ProvideMainScopeFactory create(AppModule module) {
return new AppModule_ProvideMainScopeFactory(module);
}
public static CoroutineScope provideMainScope(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideMainScope());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideManualPermissionsDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.ManualPermissionsDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideManualPermissionsDaoFactory implements Factory<ManualPermissionsDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideManualPermissionsDaoFactory(AppModule module,
Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public ManualPermissionsDao get() {
return provideManualPermissionsDao(module, dbProvider.get());
}
public static AppModule_ProvideManualPermissionsDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideManualPermissionsDaoFactory(module, dbProvider);
}
public static ManualPermissionsDao provideManualPermissionsDao(AppModule instance,
SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideManualPermissionsDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideMovementDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.MovementDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideMovementDaoFactory implements Factory<MovementDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideMovementDaoFactory(AppModule module, Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public MovementDao get() {
return provideMovementDao(module, dbProvider.get());
}
public static AppModule_ProvideMovementDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideMovementDaoFactory(module, dbProvider);
}
public static MovementDao provideMovementDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideMovementDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideMutexFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import kotlinx.coroutines.sync.Mutex;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideMutexFactory implements Factory<Mutex> {
private final AppModule module;
public AppModule_ProvideMutexFactory(AppModule module) {
this.module = module;
}
@Override
public Mutex get() {
return provideMutex(module);
}
public static AppModule_ProvideMutexFactory create(AppModule module) {
return new AppModule_ProvideMutexFactory(module);
}
public static Mutex provideMutex(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideMutex());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideNotificationManagerFactory.java | package sdk.sahha.android.di;
import android.app.NotificationManager;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideNotificationManagerFactory implements Factory<NotificationManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideNotificationManagerFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public NotificationManager get() {
return provideNotificationManager(module, contextProvider.get());
}
public static AppModule_ProvideNotificationManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideNotificationManagerFactory(module, contextProvider);
}
public static NotificationManager provideNotificationManager(AppModule instance,
Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideNotificationManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideOkHttpClientFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import okhttp3.OkHttpClient;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideOkHttpClientFactory implements Factory<OkHttpClient> {
private final AppModule module;
public AppModule_ProvideOkHttpClientFactory(AppModule module) {
this.module = module;
}
@Override
public OkHttpClient get() {
return provideOkHttpClient(module);
}
public static AppModule_ProvideOkHttpClientFactory create(AppModule module) {
return new AppModule_ProvideOkHttpClientFactory(module);
}
public static OkHttpClient provideOkHttpClient(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideOkHttpClient());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvidePermissionActionProviderFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvidePermissionActionProviderFactory implements Factory<PermissionActionProvider> {
private final AppModule module;
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
public AppModule_ProvidePermissionActionProviderFactory(AppModule module,
Provider<HealthConnectRepo> healthConnectRepoProvider) {
this.module = module;
this.healthConnectRepoProvider = healthConnectRepoProvider;
}
@Override
public PermissionActionProvider get() {
return providePermissionActionProvider(module, healthConnectRepoProvider.get());
}
public static AppModule_ProvidePermissionActionProviderFactory create(AppModule module,
Provider<HealthConnectRepo> healthConnectRepoProvider) {
return new AppModule_ProvidePermissionActionProviderFactory(module, healthConnectRepoProvider);
}
public static PermissionActionProvider providePermissionActionProvider(AppModule instance,
HealthConnectRepo healthConnectRepo) {
return Preconditions.checkNotNullFromProvides(instance.providePermissionActionProvider(healthConnectRepo));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvidePermissionHandlerFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.model.callbacks.ActivityCallback;
import sdk.sahha.android.domain.model.categories.PermissionHandler;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvidePermissionHandlerFactory implements Factory<PermissionHandler> {
private final AppModule module;
private final Provider<ActivityCallback> activityCallbackProvider;
public AppModule_ProvidePermissionHandlerFactory(AppModule module,
Provider<ActivityCallback> activityCallbackProvider) {
this.module = module;
this.activityCallbackProvider = activityCallbackProvider;
}
@Override
public PermissionHandler get() {
return providePermissionHandler(module, activityCallbackProvider.get());
}
public static AppModule_ProvidePermissionHandlerFactory create(AppModule module,
Provider<ActivityCallback> activityCallbackProvider) {
return new AppModule_ProvidePermissionHandlerFactory(module, activityCallbackProvider);
}
public static PermissionHandler providePermissionHandler(AppModule instance,
ActivityCallback activityCallback) {
return Preconditions.checkNotNullFromProvides(instance.providePermissionHandler(activityCallback));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvidePermissionManagerFactory.java | package sdk.sahha.android.di;
import android.content.SharedPreferences;
import androidx.health.connect.client.HealthConnectClient;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.local.dao.ManualPermissionsDao;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.model.categories.PermissionHandler;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.MainScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvidePermissionManagerFactory implements Factory<PermissionManager> {
private final AppModule module;
private final Provider<PermissionHandler> permissionHandlerProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<ManualPermissionsDao> manualPermissionsDaoProvider;
private final Provider<HealthConnectClient> healthConnectClientProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<SharedPreferences> sharedPrefsProvider;
private final Provider<CoroutineScope> mainScopeProvider;
public AppModule_ProvidePermissionManagerFactory(AppModule module,
Provider<PermissionHandler> permissionHandlerProvider,
Provider<SahhaConfigRepo> configRepoProvider,
Provider<ManualPermissionsDao> manualPermissionsDaoProvider,
Provider<HealthConnectClient> healthConnectClientProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SharedPreferences> sharedPrefsProvider, Provider<CoroutineScope> mainScopeProvider) {
this.module = module;
this.permissionHandlerProvider = permissionHandlerProvider;
this.configRepoProvider = configRepoProvider;
this.manualPermissionsDaoProvider = manualPermissionsDaoProvider;
this.healthConnectClientProvider = healthConnectClientProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.sharedPrefsProvider = sharedPrefsProvider;
this.mainScopeProvider = mainScopeProvider;
}
@Override
public PermissionManager get() {
return providePermissionManager(module, permissionHandlerProvider.get(), configRepoProvider.get(), manualPermissionsDaoProvider.get(), healthConnectClientProvider.get(), sahhaErrorLoggerProvider.get(), sharedPrefsProvider.get(), mainScopeProvider.get());
}
public static AppModule_ProvidePermissionManagerFactory create(AppModule module,
Provider<PermissionHandler> permissionHandlerProvider,
Provider<SahhaConfigRepo> configRepoProvider,
Provider<ManualPermissionsDao> manualPermissionsDaoProvider,
Provider<HealthConnectClient> healthConnectClientProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SharedPreferences> sharedPrefsProvider, Provider<CoroutineScope> mainScopeProvider) {
return new AppModule_ProvidePermissionManagerFactory(module, permissionHandlerProvider, configRepoProvider, manualPermissionsDaoProvider, healthConnectClientProvider, sahhaErrorLoggerProvider, sharedPrefsProvider, mainScopeProvider);
}
public static PermissionManager providePermissionManager(AppModule instance,
PermissionHandler permissionHandler, SahhaConfigRepo configRepo,
ManualPermissionsDao manualPermissionsDao, HealthConnectClient healthConnectClient,
SahhaErrorLogger sahhaErrorLogger, SharedPreferences sharedPrefs, CoroutineScope mainScope) {
return Preconditions.checkNotNullFromProvides(instance.providePermissionManager(permissionHandler, configRepo, manualPermissionsDao, healthConnectClient, sahhaErrorLogger, sharedPrefs, mainScope));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvidePostChunkManagerFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.sync.Mutex;
import sdk.sahha.android.domain.manager.PostChunkManager;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvidePostChunkManagerFactory implements Factory<PostChunkManager> {
private final AppModule module;
private final Provider<Mutex> mutexProvider;
public AppModule_ProvidePostChunkManagerFactory(AppModule module, Provider<Mutex> mutexProvider) {
this.module = module;
this.mutexProvider = mutexProvider;
}
@Override
public PostChunkManager get() {
return providePostChunkManager(module, mutexProvider.get());
}
public static AppModule_ProvidePostChunkManagerFactory create(AppModule module,
Provider<Mutex> mutexProvider) {
return new AppModule_ProvidePostChunkManagerFactory(module, mutexProvider);
}
public static PostChunkManager providePostChunkManager(AppModule instance, Mutex mutex) {
return Preconditions.checkNotNullFromProvides(instance.providePostChunkManager(mutex));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvidePowerManagerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import android.os.PowerManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvidePowerManagerFactory implements Factory<PowerManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvidePowerManagerFactory(AppModule module, Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public PowerManager get() {
return providePowerManager(module, contextProvider.get());
}
public static AppModule_ProvidePowerManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvidePowerManagerFactory(module, contextProvider);
}
public static PowerManager providePowerManager(AppModule instance, Context context) {
return Preconditions.checkNotNullFromProvides(instance.providePowerManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideReceiverManagerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.domain.manager.ReceiverManager;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.MainScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideReceiverManagerFactory implements Factory<ReceiverManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<CoroutineScope> mainScopeProvider;
public AppModule_ProvideReceiverManagerFactory(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> mainScopeProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.mainScopeProvider = mainScopeProvider;
}
@Override
public ReceiverManager get() {
return provideReceiverManager(module, contextProvider.get(), mainScopeProvider.get());
}
public static AppModule_ProvideReceiverManagerFactory create(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> mainScopeProvider) {
return new AppModule_ProvideReceiverManagerFactory(module, contextProvider, mainScopeProvider);
}
public static ReceiverManager provideReceiverManager(AppModule instance, Context context,
CoroutineScope mainScope) {
return Preconditions.checkNotNullFromProvides(instance.provideReceiverManager(context, mainScope));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaApiFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import okhttp3.OkHttpClient;
import retrofit2.converter.gson.GsonConverterFactory;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.source.SahhaEnvironment;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaApiFactory implements Factory<SahhaApi> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<Enum<SahhaEnvironment>> environmentProvider;
private final Provider<GsonConverterFactory> gsonProvider;
private final Provider<OkHttpClient> okHttpClientProvider;
public AppModule_ProvideSahhaApiFactory(AppModule module, Provider<Context> contextProvider,
Provider<Enum<SahhaEnvironment>> environmentProvider,
Provider<GsonConverterFactory> gsonProvider, Provider<OkHttpClient> okHttpClientProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.environmentProvider = environmentProvider;
this.gsonProvider = gsonProvider;
this.okHttpClientProvider = okHttpClientProvider;
}
@Override
public SahhaApi get() {
return provideSahhaApi(module, contextProvider.get(), environmentProvider.get(), gsonProvider.get(), okHttpClientProvider.get());
}
public static AppModule_ProvideSahhaApiFactory create(AppModule module,
Provider<Context> contextProvider, Provider<Enum<SahhaEnvironment>> environmentProvider,
Provider<GsonConverterFactory> gsonProvider, Provider<OkHttpClient> okHttpClientProvider) {
return new AppModule_ProvideSahhaApiFactory(module, contextProvider, environmentProvider, gsonProvider, okHttpClientProvider);
}
public static SahhaApi provideSahhaApi(AppModule instance, Context context,
Enum<SahhaEnvironment> environment, GsonConverterFactory gson, OkHttpClient okHttpClient) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaApi(context, environment, gson, okHttpClient));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaConfigRepoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.dao.ConfigurationDao;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaConfigRepoFactory implements Factory<SahhaConfigRepo> {
private final AppModule module;
private final Provider<ConfigurationDao> configDaoProvider;
public AppModule_ProvideSahhaConfigRepoFactory(AppModule module,
Provider<ConfigurationDao> configDaoProvider) {
this.module = module;
this.configDaoProvider = configDaoProvider;
}
@Override
public SahhaConfigRepo get() {
return provideSahhaConfigRepo(module, configDaoProvider.get());
}
public static AppModule_ProvideSahhaConfigRepoFactory create(AppModule module,
Provider<ConfigurationDao> configDaoProvider) {
return new AppModule_ProvideSahhaConfigRepoFactory(module, configDaoProvider);
}
public static SahhaConfigRepo provideSahhaConfigRepo(AppModule instance,
ConfigurationDao configDao) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaConfigRepo(configDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaEnvironmentFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import sdk.sahha.android.source.SahhaEnvironment;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaEnvironmentFactory implements Factory<Enum<SahhaEnvironment>> {
private final AppModule module;
public AppModule_ProvideSahhaEnvironmentFactory(AppModule module) {
this.module = module;
}
@Override
public Enum<SahhaEnvironment> get() {
return provideSahhaEnvironment(module);
}
public static AppModule_ProvideSahhaEnvironmentFactory create(AppModule module) {
return new AppModule_ProvideSahhaEnvironmentFactory(module);
}
public static Enum<SahhaEnvironment> provideSahhaEnvironment(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaEnvironment());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaErrorApiFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import okhttp3.OkHttpClient;
import retrofit2.converter.gson.GsonConverterFactory;
import sdk.sahha.android.data.remote.SahhaErrorApi;
import sdk.sahha.android.source.SahhaEnvironment;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaErrorApiFactory implements Factory<SahhaErrorApi> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<Enum<SahhaEnvironment>> environmentProvider;
private final Provider<GsonConverterFactory> gsonProvider;
private final Provider<OkHttpClient> okHttpClientProvider;
public AppModule_ProvideSahhaErrorApiFactory(AppModule module, Provider<Context> contextProvider,
Provider<Enum<SahhaEnvironment>> environmentProvider,
Provider<GsonConverterFactory> gsonProvider, Provider<OkHttpClient> okHttpClientProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.environmentProvider = environmentProvider;
this.gsonProvider = gsonProvider;
this.okHttpClientProvider = okHttpClientProvider;
}
@Override
public SahhaErrorApi get() {
return provideSahhaErrorApi(module, contextProvider.get(), environmentProvider.get(), gsonProvider.get(), okHttpClientProvider.get());
}
public static AppModule_ProvideSahhaErrorApiFactory create(AppModule module,
Provider<Context> contextProvider, Provider<Enum<SahhaEnvironment>> environmentProvider,
Provider<GsonConverterFactory> gsonProvider, Provider<OkHttpClient> okHttpClientProvider) {
return new AppModule_ProvideSahhaErrorApiFactory(module, contextProvider, environmentProvider, gsonProvider, okHttpClientProvider);
}
public static SahhaErrorApi provideSahhaErrorApi(AppModule instance, Context context,
Enum<SahhaEnvironment> environment, GsonConverterFactory gson, OkHttpClient okHttpClient) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaErrorApi(context, environment, gson, okHttpClient));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaErrorLoggerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.remote.SahhaErrorApi;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.DefaultScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaErrorLoggerFactory implements Factory<SahhaErrorLogger> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<SahhaConfigRepo> sahhaConfigRepoProvider;
private final Provider<SahhaErrorApi> sahhaErrorApiProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<AuthRepo> authRepoProvider;
public AppModule_ProvideSahhaErrorLoggerFactory(AppModule module,
Provider<Context> contextProvider, Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<SahhaErrorApi> sahhaErrorApiProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<AuthRepo> authRepoProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.sahhaConfigRepoProvider = sahhaConfigRepoProvider;
this.sahhaErrorApiProvider = sahhaErrorApiProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.authRepoProvider = authRepoProvider;
}
@Override
public SahhaErrorLogger get() {
return provideSahhaErrorLogger(module, contextProvider.get(), sahhaConfigRepoProvider.get(), sahhaErrorApiProvider.get(), defaultScopeProvider.get(), authRepoProvider.get());
}
public static AppModule_ProvideSahhaErrorLoggerFactory create(AppModule module,
Provider<Context> contextProvider, Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<SahhaErrorApi> sahhaErrorApiProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<AuthRepo> authRepoProvider) {
return new AppModule_ProvideSahhaErrorLoggerFactory(module, contextProvider, sahhaConfigRepoProvider, sahhaErrorApiProvider, defaultScopeProvider, authRepoProvider);
}
public static SahhaErrorLogger provideSahhaErrorLogger(AppModule instance, Context context,
SahhaConfigRepo sahhaConfigRepo, SahhaErrorApi sahhaErrorApi, CoroutineScope defaultScope,
AuthRepo authRepo) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaErrorLogger(context, sahhaConfigRepo, sahhaErrorApi, defaultScope, authRepo));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSahhaNotificationManagerFactory.java | package sdk.sahha.android.di;
import android.app.NotificationManager;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.domain.manager.SahhaNotificationManager;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.DefaultScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSahhaNotificationManagerFactory implements Factory<SahhaNotificationManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<NotificationManager> notificationManagerProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
public AppModule_ProvideSahhaNotificationManagerFactory(AppModule module,
Provider<Context> contextProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<NotificationManager> notificationManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<CoroutineScope> defaultScopeProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.notificationManagerProvider = notificationManagerProvider;
this.configRepoProvider = configRepoProvider;
this.defaultScopeProvider = defaultScopeProvider;
}
@Override
public SahhaNotificationManager get() {
return provideSahhaNotificationManager(module, contextProvider.get(), sahhaErrorLoggerProvider.get(), notificationManagerProvider.get(), configRepoProvider.get(), defaultScopeProvider.get());
}
public static AppModule_ProvideSahhaNotificationManagerFactory create(AppModule module,
Provider<Context> contextProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<NotificationManager> notificationManagerProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<CoroutineScope> defaultScopeProvider) {
return new AppModule_ProvideSahhaNotificationManagerFactory(module, contextProvider, sahhaErrorLoggerProvider, notificationManagerProvider, configRepoProvider, defaultScopeProvider);
}
public static SahhaNotificationManager provideSahhaNotificationManager(AppModule instance,
Context context, SahhaErrorLogger sahhaErrorLogger, NotificationManager notificationManager,
SahhaConfigRepo configRepo, CoroutineScope defaultScope) {
return Preconditions.checkNotNullFromProvides(instance.provideSahhaNotificationManager(context, sahhaErrorLogger, notificationManager, configRepo, defaultScope));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSecurityDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.SecurityDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSecurityDaoFactory implements Factory<SecurityDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideSecurityDaoFactory(AppModule module, Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public SecurityDao get() {
return provideSecurityDao(module, dbProvider.get());
}
public static AppModule_ProvideSecurityDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideSecurityDaoFactory(module, dbProvider);
}
public static SecurityDao provideSecurityDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideSecurityDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSensorManagerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import android.hardware.SensorManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSensorManagerFactory implements Factory<SensorManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideSensorManagerFactory(AppModule module,
Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public SensorManager get() {
return provideSensorManager(module, contextProvider.get());
}
public static AppModule_ProvideSensorManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideSensorManagerFactory(module, contextProvider);
}
public static SensorManager provideSensorManager(AppModule instance, Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideSensorManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSensorRepositoryFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import kotlinx.coroutines.sync.Mutex;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.data.local.dao.MovementDao;
import sdk.sahha.android.data.local.dao.SleepDao;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.manager.PostChunkManager;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.DeviceUsageRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata({
"sdk.sahha.android.di.DefaultScope",
"sdk.sahha.android.di.IoScope"
})
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSensorRepositoryFactory implements Factory<SensorRepo> {
private final AppModule module;
private final Provider<Context> contextProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<SahhaConfigRepo> sahhaConfigRepoProvider;
private final Provider<DeviceUsageRepo> deviceUsageRepoProvider;
private final Provider<SleepDao> sleepDaoProvider;
private final Provider<MovementDao> movementDaoProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<Mutex> mutexProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<PostChunkManager> chunkManagerProvider;
private final Provider<PermissionManager> permissionManagerProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
public AppModule_ProvideSensorRepositoryFactory(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<DeviceUsageRepo> deviceUsageRepoProvider, Provider<SleepDao> sleepDaoProvider,
Provider<MovementDao> movementDaoProvider, Provider<AuthRepo> authRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider, Provider<Mutex> mutexProvider,
Provider<SahhaApi> apiProvider, Provider<PostChunkManager> chunkManagerProvider,
Provider<PermissionManager> permissionManagerProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
this.module = module;
this.contextProvider = contextProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.ioScopeProvider = ioScopeProvider;
this.sahhaConfigRepoProvider = sahhaConfigRepoProvider;
this.deviceUsageRepoProvider = deviceUsageRepoProvider;
this.sleepDaoProvider = sleepDaoProvider;
this.movementDaoProvider = movementDaoProvider;
this.authRepoProvider = authRepoProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.mutexProvider = mutexProvider;
this.apiProvider = apiProvider;
this.chunkManagerProvider = chunkManagerProvider;
this.permissionManagerProvider = permissionManagerProvider;
this.timeManagerProvider = timeManagerProvider;
}
@Override
public SensorRepo get() {
return provideSensorRepository(module, contextProvider.get(), defaultScopeProvider.get(), ioScopeProvider.get(), sahhaConfigRepoProvider.get(), deviceUsageRepoProvider.get(), sleepDaoProvider.get(), movementDaoProvider.get(), authRepoProvider.get(), sahhaErrorLoggerProvider.get(), mutexProvider.get(), apiProvider.get(), chunkManagerProvider.get(), permissionManagerProvider.get(), timeManagerProvider.get());
}
public static AppModule_ProvideSensorRepositoryFactory create(AppModule module,
Provider<Context> contextProvider, Provider<CoroutineScope> defaultScopeProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<DeviceUsageRepo> deviceUsageRepoProvider, Provider<SleepDao> sleepDaoProvider,
Provider<MovementDao> movementDaoProvider, Provider<AuthRepo> authRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider, Provider<Mutex> mutexProvider,
Provider<SahhaApi> apiProvider, Provider<PostChunkManager> chunkManagerProvider,
Provider<PermissionManager> permissionManagerProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
return new AppModule_ProvideSensorRepositoryFactory(module, contextProvider, defaultScopeProvider, ioScopeProvider, sahhaConfigRepoProvider, deviceUsageRepoProvider, sleepDaoProvider, movementDaoProvider, authRepoProvider, sahhaErrorLoggerProvider, mutexProvider, apiProvider, chunkManagerProvider, permissionManagerProvider, timeManagerProvider);
}
public static SensorRepo provideSensorRepository(AppModule instance, Context context,
CoroutineScope defaultScope, CoroutineScope ioScope, SahhaConfigRepo sahhaConfigRepo,
DeviceUsageRepo deviceUsageRepo, SleepDao sleepDao, MovementDao movementDao,
AuthRepo authRepo, SahhaErrorLogger sahhaErrorLogger, Mutex mutex, SahhaApi api,
PostChunkManager chunkManager, PermissionManager permissionManager,
SahhaTimeManager timeManager) {
return Preconditions.checkNotNullFromProvides(instance.provideSensorRepository(context, defaultScope, ioScope, sahhaConfigRepo, deviceUsageRepo, sleepDao, movementDao, authRepo, sahhaErrorLogger, mutex, api, chunkManager, permissionManager, timeManager));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSensorToHealthConnectMetricMapperFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import sdk.sahha.android.framework.mapper.SensorToHealthConnectMetricMapper;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSensorToHealthConnectMetricMapperFactory implements Factory<SensorToHealthConnectMetricMapper> {
private final AppModule module;
public AppModule_ProvideSensorToHealthConnectMetricMapperFactory(AppModule module) {
this.module = module;
}
@Override
public SensorToHealthConnectMetricMapper get() {
return provideSensorToHealthConnectMetricMapper(module);
}
public static AppModule_ProvideSensorToHealthConnectMetricMapperFactory create(AppModule module) {
return new AppModule_ProvideSensorToHealthConnectMetricMapperFactory(module);
}
public static SensorToHealthConnectMetricMapper provideSensorToHealthConnectMetricMapper(
AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideSensorToHealthConnectMetricMapper());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSleepDaoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.SleepDao;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSleepDaoFactory implements Factory<SleepDao> {
private final AppModule module;
private final Provider<SahhaDatabase> dbProvider;
public AppModule_ProvideSleepDaoFactory(AppModule module, Provider<SahhaDatabase> dbProvider) {
this.module = module;
this.dbProvider = dbProvider;
}
@Override
public SleepDao get() {
return provideSleepDao(module, dbProvider.get());
}
public static AppModule_ProvideSleepDaoFactory create(AppModule module,
Provider<SahhaDatabase> dbProvider) {
return new AppModule_ProvideSleepDaoFactory(module, dbProvider);
}
public static SleepDao provideSleepDao(AppModule instance, SahhaDatabase db) {
return Preconditions.checkNotNullFromProvides(instance.provideSleepDao(db));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideSleepRepositoryFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.data.local.dao.SleepDao;
import sdk.sahha.android.domain.repository.SleepRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideSleepRepositoryFactory implements Factory<SleepRepo> {
private final AppModule module;
private final Provider<SleepDao> sleepDaoProvider;
public AppModule_ProvideSleepRepositoryFactory(AppModule module,
Provider<SleepDao> sleepDaoProvider) {
this.module = module;
this.sleepDaoProvider = sleepDaoProvider;
}
@Override
public SleepRepo get() {
return provideSleepRepository(module, sleepDaoProvider.get());
}
public static AppModule_ProvideSleepRepositoryFactory create(AppModule module,
Provider<SleepDao> sleepDaoProvider) {
return new AppModule_ProvideSleepRepositoryFactory(module, sleepDaoProvider);
}
public static SleepRepo provideSleepRepository(AppModule instance, SleepDao sleepDao) {
return Preconditions.checkNotNullFromProvides(instance.provideSleepRepository(sleepDao));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideTimeManagerFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import sdk.sahha.android.common.SahhaTimeManager;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideTimeManagerFactory implements Factory<SahhaTimeManager> {
private final AppModule module;
public AppModule_ProvideTimeManagerFactory(AppModule module) {
this.module = module;
}
@Override
public SahhaTimeManager get() {
return provideTimeManager(module);
}
public static AppModule_ProvideTimeManagerFactory create(AppModule module) {
return new AppModule_ProvideTimeManagerFactory(module);
}
public static SahhaTimeManager provideTimeManager(AppModule instance) {
return Preconditions.checkNotNullFromProvides(instance.provideTimeManager());
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideUserDataRepoFactory.java | package sdk.sahha.android.di;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.UserDataRepo;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideUserDataRepoFactory implements Factory<UserDataRepo> {
private final AppModule module;
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
public AppModule_ProvideUserDataRepoFactory(AppModule module,
Provider<CoroutineScope> ioScopeProvider, Provider<AuthRepo> authRepoProvider,
Provider<SahhaApi> apiProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
this.module = module;
this.ioScopeProvider = ioScopeProvider;
this.authRepoProvider = authRepoProvider;
this.apiProvider = apiProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
}
@Override
public UserDataRepo get() {
return provideUserDataRepo(module, ioScopeProvider.get(), authRepoProvider.get(), apiProvider.get(), sahhaErrorLoggerProvider.get());
}
public static AppModule_ProvideUserDataRepoFactory create(AppModule module,
Provider<CoroutineScope> ioScopeProvider, Provider<AuthRepo> authRepoProvider,
Provider<SahhaApi> apiProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
return new AppModule_ProvideUserDataRepoFactory(module, ioScopeProvider, authRepoProvider, apiProvider, sahhaErrorLoggerProvider);
}
public static UserDataRepo provideUserDataRepo(AppModule instance, CoroutineScope ioScope,
AuthRepo authRepo, SahhaApi api, SahhaErrorLogger sahhaErrorLogger) {
return Preconditions.checkNotNullFromProvides(instance.provideUserDataRepo(ioScope, authRepo, api, sahhaErrorLogger));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/AppModule_ProvideWorkManagerFactory.java | package sdk.sahha.android.di;
import android.content.Context;
import androidx.work.WorkManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.Preconditions;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AppModule_ProvideWorkManagerFactory implements Factory<WorkManager> {
private final AppModule module;
private final Provider<Context> contextProvider;
public AppModule_ProvideWorkManagerFactory(AppModule module, Provider<Context> contextProvider) {
this.module = module;
this.contextProvider = contextProvider;
}
@Override
public WorkManager get() {
return provideWorkManager(module, contextProvider.get());
}
public static AppModule_ProvideWorkManagerFactory create(AppModule module,
Provider<Context> contextProvider) {
return new AppModule_ProvideWorkManagerFactory(module, contextProvider);
}
public static WorkManager provideWorkManager(AppModule instance, Context context) {
return Preconditions.checkNotNullFromProvides(instance.provideWorkManager(context));
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/di/DaggerAppComponent.java | package sdk.sahha.android.di;
import android.app.ActivityManager;
import android.app.KeyguardManager;
import android.app.NotificationManager;
import android.content.Context;
import android.content.SharedPreferences;
import android.hardware.SensorManager;
import android.os.PowerManager;
import androidx.health.connect.client.HealthConnectClient;
import androidx.work.WorkManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.DoubleCheck;
import dagger.internal.InstanceFactory;
import dagger.internal.Preconditions;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import kotlinx.coroutines.sync.Mutex;
import okhttp3.OkHttpClient;
import retrofit2.converter.gson.GsonConverterFactory;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.common.security.Decryptor;
import sdk.sahha.android.common.security.Encryptor;
import sdk.sahha.android.data.local.SahhaDatabase;
import sdk.sahha.android.data.local.dao.BatchedDataDao;
import sdk.sahha.android.data.local.dao.ConfigurationDao;
import sdk.sahha.android.data.local.dao.DeviceUsageDao;
import sdk.sahha.android.data.local.dao.HealthConnectConfigDao;
import sdk.sahha.android.data.local.dao.ManualPermissionsDao;
import sdk.sahha.android.data.local.dao.MovementDao;
import sdk.sahha.android.data.local.dao.SecurityDao;
import sdk.sahha.android.data.local.dao.SleepDao;
import sdk.sahha.android.data.mapper.HealthConnectMapperDefaults;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.data.remote.SahhaErrorApi;
import sdk.sahha.android.domain.interaction.AuthInteractionManager;
import sdk.sahha.android.domain.interaction.AuthInteractionManager_Factory;
import sdk.sahha.android.domain.interaction.InsightsInteractionManager;
import sdk.sahha.android.domain.interaction.PermissionInteractionManager;
import sdk.sahha.android.domain.interaction.PermissionInteractionManager_Factory;
import sdk.sahha.android.domain.interaction.SahhaInteractionManager;
import sdk.sahha.android.domain.interaction.SensorInteractionManager;
import sdk.sahha.android.domain.interaction.SensorInteractionManager_Factory;
import sdk.sahha.android.domain.interaction.UserDataInteractionManager;
import sdk.sahha.android.domain.interaction.UserDataInteractionManager_Factory;
import sdk.sahha.android.domain.manager.ConnectionStateManager;
import sdk.sahha.android.domain.manager.IdManager;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.manager.PostChunkManager;
import sdk.sahha.android.domain.manager.ReceiverManager;
import sdk.sahha.android.domain.manager.SahhaNotificationManager;
import sdk.sahha.android.domain.mapper.AggregationDataTypeMapper;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.model.callbacks.ActivityCallback;
import sdk.sahha.android.domain.model.categories.PermissionHandler;
import sdk.sahha.android.domain.model.processor.AppEventProcessor;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
import sdk.sahha.android.domain.repository.AppCrashRepo;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
import sdk.sahha.android.domain.repository.DeviceUsageRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.repository.InsightsRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.repository.SleepRepo;
import sdk.sahha.android.domain.repository.UserDataRepo;
import sdk.sahha.android.domain.transformer.AggregateDataLogTransformer;
import sdk.sahha.android.domain.use_case.CalculateBatchLimit;
import sdk.sahha.android.domain.use_case.GetBiomarkersUseCase;
import sdk.sahha.android.domain.use_case.GetDemographicUseCase;
import sdk.sahha.android.domain.use_case.GetDemographicUseCase_Factory;
import sdk.sahha.android.domain.use_case.GetSamplesUseCase;
import sdk.sahha.android.domain.use_case.GetScoresUseCase;
import sdk.sahha.android.domain.use_case.GetScoresUseCase_Factory;
import sdk.sahha.android.domain.use_case.GetSensorDataUseCase;
import sdk.sahha.android.domain.use_case.GetSensorDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.GetStatsUseCase;
import sdk.sahha.android.domain.use_case.SaveTokensUseCase;
import sdk.sahha.android.domain.use_case.SaveTokensUseCase_Factory;
import sdk.sahha.android.domain.use_case.UploadLatestCrashLog;
import sdk.sahha.android.domain.use_case.background.BatchAggregateLogs;
import sdk.sahha.android.domain.use_case.background.BatchDataLogs;
import sdk.sahha.android.domain.use_case.background.BatchDataLogs_Factory;
import sdk.sahha.android.domain.use_case.background.FilterActivityOverlaps;
import sdk.sahha.android.domain.use_case.background.FilterActivityOverlaps_Factory;
import sdk.sahha.android.domain.use_case.background.KillMainService;
import sdk.sahha.android.domain.use_case.background.KillMainService_Factory;
import sdk.sahha.android.domain.use_case.background.LogAppAliveState;
import sdk.sahha.android.domain.use_case.background.LogAppEvent;
import sdk.sahha.android.domain.use_case.background.RestartWorkers;
import sdk.sahha.android.domain.use_case.background.RestartWorkers_Factory;
import sdk.sahha.android.domain.use_case.background.StartCollectingPhoneScreenLockDataUseCase;
import sdk.sahha.android.domain.use_case.background.StartCollectingPhoneScreenLockDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.background.StartCollectingStepDetectorData;
import sdk.sahha.android.domain.use_case.background.StartCollectingStepDetectorData_Factory;
import sdk.sahha.android.domain.use_case.background.StartDataCollectionServiceUseCase;
import sdk.sahha.android.domain.use_case.background.StartDataCollectionServiceUseCase_Factory;
import sdk.sahha.android.domain.use_case.metadata.AddMetadata;
import sdk.sahha.android.domain.use_case.metadata.AddMetadata_Factory;
import sdk.sahha.android.domain.use_case.permissions.OpenAppSettingsUseCase;
import sdk.sahha.android.domain.use_case.permissions.OpenAppSettingsUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.PostAllSensorDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostAllSensorDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.PostBatchData;
import sdk.sahha.android.domain.use_case.post.PostBatchData_Factory;
import sdk.sahha.android.domain.use_case.post.PostDemographicUseCase;
import sdk.sahha.android.domain.use_case.post.PostDemographicUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.PostDeviceDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostDeviceDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.PostHealthConnectDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostSleepDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostSleepDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.PostStepDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostStepDataUseCase_Factory;
import sdk.sahha.android.domain.use_case.post.StartPostWorkersUseCase;
import sdk.sahha.android.domain.use_case.post.StartPostWorkersUseCase_Factory;
import sdk.sahha.android.framework.observer.HostAppLifecycleObserver;
import sdk.sahha.android.framework.runnable.DataBatcherRunnable;
import sdk.sahha.android.source.SahhaEnvironment;
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class DaggerAppComponent {
private DaggerAppComponent() {
}
public static AppComponent.Builder builder() {
return new Builder();
}
private static final class Builder implements AppComponent.Builder {
private AppModule appModule;
private Context context;
@Override
public Builder appModule(AppModule appModule) {
this.appModule = Preconditions.checkNotNull(appModule);
return this;
}
@Override
public Builder context(Context context) {
this.context = Preconditions.checkNotNull(context);
return this;
}
@Override
public AppComponent build() {
Preconditions.checkBuilderRequirement(appModule, AppModule.class);
Preconditions.checkBuilderRequirement(context, Context.class);
return new AppComponentImpl(appModule, context);
}
}
private static final class AppComponentImpl implements AppComponent {
private final AppModule appModule;
private final Context context;
private final AppComponentImpl appComponentImpl = this;
private Provider<Enum<SahhaEnvironment>> provideSahhaEnvironmentProvider;
private Provider<Context> contextProvider;
private Provider<SahhaDatabase> provideDatabaseProvider;
private Provider<GsonConverterFactory> provideGsonConverterProvider;
private Provider<OkHttpClient> provideOkHttpClientProvider;
private Provider<SahhaApi> provideSahhaApiProvider;
private Provider<SharedPreferences> provideEncryptedSharedPreferencesProvider;
private Provider<AuthRepo> provideAuthRepositoryProvider;
private Provider<SecurityDao> provideSecurityDaoProvider;
private Provider<Decryptor> provideDecryptorProvider;
private Provider<CoroutineScope> provideDefaultScopeProvider;
private Provider<CoroutineScope> provideIoScopeProvider;
private Provider<Mutex> provideBatchMutexProvider;
private Provider<PostChunkManager> providePostChunkManagerProvider;
private Provider<ConfigurationDao> provideConfigDaoProvider;
private Provider<SahhaConfigRepo> provideSahhaConfigRepoProvider;
private Provider<DeviceUsageDao> provideDeviceUsageDaoProvider;
private Provider<DeviceUsageRepo> provideDeviceUsageRepositoryProvider;
private Provider<SleepDao> provideSleepDaoProvider;
private Provider<MovementDao> provideMovementDaoProvider;
private Provider<SahhaErrorApi> provideSahhaErrorApiProvider;
private Provider<SahhaErrorLogger> provideSahhaErrorLoggerProvider;
private Provider<Mutex> provideMutexProvider;
private Provider<ActivityCallback> provideActivityCallbackProvider;
private Provider<PermissionHandler> providePermissionHandlerProvider;
private Provider<ManualPermissionsDao> provideManualPermissionsDaoProvider;
private Provider<HealthConnectClient> provideHealthConnectClientProvider;
private Provider<CoroutineScope> provideMainScopeProvider;
private Provider<PermissionManager> providePermissionManagerProvider;
private Provider<SahhaTimeManager> provideTimeManagerProvider;
private Provider<SensorRepo> provideSensorRepositoryProvider;
private Provider<WorkManager> provideWorkManagerProvider;
private Provider<HealthConnectConfigDao> provideHealthConfigDaoProvider;
private Provider<HealthConnectConstantsMapper> provideHealthConnectConstantsMapperProvider;
private Provider<IdManager> provideIdManagerProvider;
private Provider<HealthConnectRepo> provideHealthConnectRepoProvider;
private Provider<BatchedDataDao> provideBatchedDataDaoProvider;
private Provider<BatchedDataRepo> provideBatchedDataRepositoryProvider;
private Provider<DeviceInfoRepo> provideDeviceInfoRepoProvider;
private Provider<UserDataRepo> provideUserDataRepoProvider;
private Provider<NotificationManager> provideNotificationManagerProvider;
private Provider<SahhaNotificationManager> provideSahhaNotificationManagerProvider;
private Provider<SensorManager> provideSensorManagerProvider;
private Provider<ConnectionStateManager> provideConnectionStateManagerProvider;
private Provider<CalculateBatchLimit> provideCalculateBatchLimitProvider;
private Provider<PermissionActionProvider> providePermissionActionProvider;
private Provider<BatchAggregateLogs> provideBatchAggregateLogsProvider;
private Provider<SleepRepo> provideSleepRepositoryProvider;
private Provider<ReceiverManager> provideReceiverManagerProvider;
private Provider<InsightsRepo> provideInsightsRepositoryProvider;
private Provider<ActivityManager> provideActivityManagerProvider;
private Provider<AppCrashRepo> provideAppCrashRepoProvider;
private Provider<PowerManager> providePowerManagerProvider;
private Provider<KeyguardManager> provideKeyguardManagerProvider;
private Provider<AppEventProcessor> provideAppEventProcessorProvider;
private Provider<OpenAppSettingsUseCase> openAppSettingsUseCaseProvider;
private Provider<PermissionInteractionManager> permissionInteractionManagerProvider;
private Provider<HostAppLifecycleObserver> provideHostAppLifecycleObserverProvider;
private Provider<StartPostWorkersUseCase> startPostWorkersUseCaseProvider;
private Provider<StartDataCollectionServiceUseCase> startDataCollectionServiceUseCaseProvider;
private Provider<GetScoresUseCase> getScoresUseCaseProvider;
private Provider<GetDemographicUseCase> getDemographicUseCaseProvider;
private Provider<PostDemographicUseCase> postDemographicUseCaseProvider;
private Provider<UserDataInteractionManager> userDataInteractionManagerProvider;
private Provider<SaveTokensUseCase> saveTokensUseCaseProvider;
private Provider<RestartWorkers> restartWorkersProvider;
private Provider<KillMainService> killMainServiceProvider;
private Provider<AuthInteractionManager> authInteractionManagerProvider;
private Provider<PostAllSensorDataUseCase> postAllSensorDataUseCaseProvider;
private Provider<GetSensorDataUseCase> getSensorDataUseCaseProvider;
private Provider<BatchDataLogs> batchDataLogsProvider;
private Provider<FilterActivityOverlaps> filterActivityOverlapsProvider;
private Provider<AddMetadata> addMetadataProvider;
private Provider<AggregationDataTypeMapper> provideAggregationDataTypeMapperProvider;
private Provider<AggregateDataLogTransformer> provideDataLogTransformerProvider;
private Provider<PostBatchData> postBatchDataProvider;
private Provider<PostSleepDataUseCase> postSleepDataUseCaseProvider;
private Provider<PostDeviceDataUseCase> postDeviceDataUseCaseProvider;
private Provider<PostStepDataUseCase> postStepDataUseCaseProvider;
private Provider<StartCollectingStepDetectorData> startCollectingStepDetectorDataProvider;
private Provider<StartCollectingPhoneScreenLockDataUseCase> startCollectingPhoneScreenLockDataUseCaseProvider;
private Provider<SensorInteractionManager> sensorInteractionManagerProvider;
private Provider<DataBatcherRunnable> provideDatBatcherRunnableProvider;
private Provider<HealthConnectMapperDefaults> provideHealthConnectMapperDefaultsProvider;
private Provider<Encryptor> provideEncryptorProvider;
private AppComponentImpl(AppModule appModuleParam, Context contextParam) {
this.appModule = appModuleParam;
this.context = contextParam;
initialize(appModuleParam, contextParam);
}
private GetScoresUseCase getScoresUseCase() {
return new GetScoresUseCase(provideUserDataRepoProvider.get(), provideTimeManagerProvider.get(), provideSahhaErrorLoggerProvider.get());
}
private GetDemographicUseCase getDemographicUseCase() {
return new GetDemographicUseCase(provideUserDataRepoProvider.get());
}
private PostDemographicUseCase postDemographicUseCase() {
return new PostDemographicUseCase(provideUserDataRepoProvider.get());
}
private UserDataInteractionManager userDataInteractionManager() {
return new UserDataInteractionManager(AppModule_ProvideMainScopeFactory.provideMainScope(appModule), AppModule_ProvideIoScopeFactory.provideIoScope(appModule), provideAuthRepositoryProvider.get(), provideDeviceInfoRepoProvider.get(), provideSahhaConfigRepoProvider.get(), getScoresUseCase(), getDemographicUseCase(), postDemographicUseCase());
}
private SaveTokensUseCase saveTokensUseCase() {
return new SaveTokensUseCase(context, AppModule_ProvideIoScopeFactory.provideIoScope(appModule), provideAuthRepositoryProvider.get(), userDataInteractionManager());
}
private OpenAppSettingsUseCase openAppSettingsUseCase() {
return new OpenAppSettingsUseCase(providePermissionManagerProvider.get());
}
private PermissionInteractionManager permissionInteractionManager() {
return new PermissionInteractionManager(providePermissionManagerProvider.get(), openAppSettingsUseCase(), provideActivityCallbackProvider.get(), provideSahhaConfigRepoProvider.get(), provideSensorRepositoryProvider.get(), AppModule_ProvideDefaultScopeFactory.provideDefaultScope(appModule), AppModule_ProvideMainScopeFactory.provideMainScope(appModule));
}
private RestartWorkers restartWorkers() {
return new RestartWorkers(context, permissionInteractionManager());
}
private KillMainService killMainService() {
return new KillMainService(context);
}
private AuthInteractionManager authInteractionManager() {
return new AuthInteractionManager(AppModule_ProvideIoScopeFactory.provideIoScope(appModule), provideAuthRepositoryProvider.get(), provideSecurityDaoProvider.get(), provideDecryptorProvider.get(), provideHealthConnectRepoProvider.get(), provideBatchedDataRepositoryProvider.get(), provideDeviceInfoRepoProvider.get(), provideSensorRepositoryProvider.get(), provideSleepDaoProvider.get(), saveTokensUseCase(), restartWorkers(), killMainService());
}
private StartPostWorkersUseCase startPostWorkersUseCase() {
return new StartPostWorkersUseCase(AppModule_ProvideIoScopeFactory.provideIoScope(appModule), provideSensorRepositoryProvider.get(), provideSahhaConfigRepoProvider.get(), providePermissionManagerProvider.get());
}
private StartDataCollectionServiceUseCase startDataCollectionServiceUseCase() {
return new StartDataCollectionServiceUseCase(provideSahhaNotificationManagerProvider.get());
}
private PostAllSensorDataUseCase postAllSensorDataUseCase() {
return new PostAllSensorDataUseCase(provideSensorRepositoryProvider.get(), authInteractionManager(), provideSahhaErrorLoggerProvider.get());
}
private GetSensorDataUseCase getSensorDataUseCase() {
return new GetSensorDataUseCase(provideSensorRepositoryProvider.get());
}
private AddMetadata addMetadata() {
return new AddMetadata(provideTimeManagerProvider.get());
}
private PostSleepDataUseCase postSleepDataUseCase() {
return new PostSleepDataUseCase(provideSensorRepositoryProvider.get(), provideSleepRepositoryProvider.get(), addMetadata());
}
private PostDeviceDataUseCase postDeviceDataUseCase() {
return new PostDeviceDataUseCase(provideSensorRepositoryProvider.get(), provideDeviceUsageRepositoryProvider.get(), addMetadata());
}
private PostStepDataUseCase postStepDataUseCase() {
return new PostStepDataUseCase(provideSensorRepositoryProvider.get());
}
private StartCollectingStepDetectorData startCollectingStepDetectorData() {
return new StartCollectingStepDetectorData(provideSensorRepositoryProvider.get());
}
private StartCollectingPhoneScreenLockDataUseCase startCollectingPhoneScreenLockDataUseCase() {
return new StartCollectingPhoneScreenLockDataUseCase(provideReceiverManagerProvider.get());
}
private SensorInteractionManager sensorInteractionManager() {
return new SensorInteractionManager(provideHealthConnectRepoProvider.get(), provideSahhaConfigRepoProvider.get(), provideSensorRepositoryProvider.get(), provideBatchedDataRepositoryProvider.get(), providePermissionManagerProvider.get(), provideSahhaNotificationManagerProvider.get(), provideSensorManagerProvider.get(), provideConnectionStateManagerProvider.get(), startPostWorkersUseCase(), startDataCollectionServiceUseCase(), postAllSensorDataUseCase(), getSensorDataUseCase(), provideCalculateBatchLimitProvider.get(), provideBatchAggregateLogsProvider.get(), getBatchDataLogs(), getPostBatchData(), postSleepDataUseCase(), postDeviceDataUseCase(), postStepDataUseCase(), startCollectingStepDetectorData(), startCollectingPhoneScreenLockDataUseCase(), addMetadata(), provideSahhaErrorLoggerProvider.get());
}
private InsightsInteractionManager insightsInteractionManager() {
return new InsightsInteractionManager(provideAuthRepositoryProvider.get(), provideInsightsRepositoryProvider.get(), provideHealthConnectRepoProvider.get(), provideSahhaConfigRepoProvider.get(), provideTimeManagerProvider.get(), AppModule_ProvideIoScopeFactory.provideIoScope(appModule));
}
private UploadLatestCrashLog uploadLatestCrashLog() {
return new UploadLatestCrashLog(provideAppCrashRepoProvider.get(), provideSahhaErrorLoggerProvider.get(), provideTimeManagerProvider.get());
}
private FilterActivityOverlaps filterActivityOverlaps() {
return new FilterActivityOverlaps(provideBatchedDataRepositoryProvider.get(), provideTimeManagerProvider.get());
}
private LogAppEvent logAppEvent() {
return new LogAppEvent(context, provideBatchedDataRepositoryProvider.get(), provideHealthConnectConstantsMapperProvider.get());
}
@SuppressWarnings("unchecked")
private void initialize(final AppModule appModuleParam, final Context contextParam) {
this.provideSahhaEnvironmentProvider = DoubleCheck.provider(AppModule_ProvideSahhaEnvironmentFactory.create(appModuleParam));
this.contextProvider = InstanceFactory.create(contextParam);
this.provideDatabaseProvider = DoubleCheck.provider(AppModule_ProvideDatabaseFactory.create(appModuleParam, contextProvider));
this.provideGsonConverterProvider = DoubleCheck.provider(AppModule_ProvideGsonConverterFactory.create(appModuleParam));
this.provideOkHttpClientProvider = DoubleCheck.provider(AppModule_ProvideOkHttpClientFactory.create(appModuleParam));
this.provideSahhaApiProvider = DoubleCheck.provider(AppModule_ProvideSahhaApiFactory.create(appModuleParam, contextProvider, provideSahhaEnvironmentProvider, provideGsonConverterProvider, provideOkHttpClientProvider));
this.provideEncryptedSharedPreferencesProvider = DoubleCheck.provider(AppModule_ProvideEncryptedSharedPreferencesFactory.create(appModuleParam, contextProvider));
this.provideAuthRepositoryProvider = DoubleCheck.provider(AppModule_ProvideAuthRepositoryFactory.create(appModuleParam, provideSahhaApiProvider, provideEncryptedSharedPreferencesProvider));
this.provideSecurityDaoProvider = DoubleCheck.provider(AppModule_ProvideSecurityDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideDecryptorProvider = DoubleCheck.provider(AppModule_ProvideDecryptorFactory.create(appModuleParam, provideSecurityDaoProvider));
this.provideDefaultScopeProvider = AppModule_ProvideDefaultScopeFactory.create(appModuleParam);
this.provideIoScopeProvider = AppModule_ProvideIoScopeFactory.create(appModuleParam);
this.provideBatchMutexProvider = DoubleCheck.provider(AppModule_ProvideBatchMutexFactory.create(appModuleParam));
this.providePostChunkManagerProvider = DoubleCheck.provider(AppModule_ProvidePostChunkManagerFactory.create(appModuleParam, provideBatchMutexProvider));
this.provideConfigDaoProvider = DoubleCheck.provider(AppModule_ProvideConfigDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideSahhaConfigRepoProvider = DoubleCheck.provider(AppModule_ProvideSahhaConfigRepoFactory.create(appModuleParam, provideConfigDaoProvider));
this.provideDeviceUsageDaoProvider = DoubleCheck.provider(AppModule_ProvideDeviceUsageDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideDeviceUsageRepositoryProvider = DoubleCheck.provider(AppModule_ProvideDeviceUsageRepositoryFactory.create(appModuleParam, provideDeviceUsageDaoProvider));
this.provideSleepDaoProvider = DoubleCheck.provider(AppModule_ProvideSleepDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideMovementDaoProvider = DoubleCheck.provider(AppModule_ProvideMovementDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideSahhaErrorApiProvider = DoubleCheck.provider(AppModule_ProvideSahhaErrorApiFactory.create(appModuleParam, contextProvider, provideSahhaEnvironmentProvider, provideGsonConverterProvider, provideOkHttpClientProvider));
this.provideSahhaErrorLoggerProvider = DoubleCheck.provider(AppModule_ProvideSahhaErrorLoggerFactory.create(appModuleParam, contextProvider, provideSahhaConfigRepoProvider, provideSahhaErrorApiProvider, provideDefaultScopeProvider, provideAuthRepositoryProvider));
this.provideMutexProvider = DoubleCheck.provider(AppModule_ProvideMutexFactory.create(appModuleParam));
this.provideActivityCallbackProvider = DoubleCheck.provider(AppModule_ProvideActivityCallbackFactory.create(appModuleParam));
this.providePermissionHandlerProvider = DoubleCheck.provider(AppModule_ProvidePermissionHandlerFactory.create(appModuleParam, provideActivityCallbackProvider));
this.provideManualPermissionsDaoProvider = DoubleCheck.provider(AppModule_ProvideManualPermissionsDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideHealthConnectClientProvider = DoubleCheck.provider(AppModule_ProvideHealthConnectClientFactory.create(appModuleParam, contextProvider));
this.provideMainScopeProvider = AppModule_ProvideMainScopeFactory.create(appModuleParam);
this.providePermissionManagerProvider = DoubleCheck.provider(AppModule_ProvidePermissionManagerFactory.create(appModuleParam, providePermissionHandlerProvider, provideSahhaConfigRepoProvider, provideManualPermissionsDaoProvider, provideHealthConnectClientProvider, provideSahhaErrorLoggerProvider, provideEncryptedSharedPreferencesProvider, provideMainScopeProvider));
this.provideTimeManagerProvider = DoubleCheck.provider(AppModule_ProvideTimeManagerFactory.create(appModuleParam));
this.provideSensorRepositoryProvider = DoubleCheck.provider(AppModule_ProvideSensorRepositoryFactory.create(appModuleParam, contextProvider, provideDefaultScopeProvider, provideIoScopeProvider, provideSahhaConfigRepoProvider, provideDeviceUsageRepositoryProvider, provideSleepDaoProvider, provideMovementDaoProvider, provideAuthRepositoryProvider, provideSahhaErrorLoggerProvider, provideMutexProvider, provideSahhaApiProvider, providePostChunkManagerProvider, providePermissionManagerProvider, provideTimeManagerProvider));
this.provideWorkManagerProvider = DoubleCheck.provider(AppModule_ProvideWorkManagerFactory.create(appModuleParam, contextProvider));
this.provideHealthConfigDaoProvider = DoubleCheck.provider(AppModule_ProvideHealthConfigDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideHealthConnectConstantsMapperProvider = DoubleCheck.provider(AppModule_ProvideHealthConnectConstantsMapperFactory.create(appModuleParam));
this.provideIdManagerProvider = DoubleCheck.provider(AppModule_ProvideIdManagerFactory.create(appModuleParam, provideEncryptedSharedPreferencesProvider));
this.provideHealthConnectRepoProvider = DoubleCheck.provider(AppModule_ProvideHealthConnectRepoFactory.create(appModuleParam, contextProvider, provideDefaultScopeProvider, provideIoScopeProvider, providePostChunkManagerProvider, provideSahhaConfigRepoProvider, provideAuthRepositoryProvider, provideSensorRepositoryProvider, provideWorkManagerProvider, provideSahhaApiProvider, provideHealthConnectClientProvider, provideSahhaErrorLoggerProvider, provideTimeManagerProvider, provideHealthConfigDaoProvider, provideMovementDaoProvider, provideHealthConnectConstantsMapperProvider, provideIdManagerProvider));
this.provideBatchedDataDaoProvider = DoubleCheck.provider(AppModule_ProvideBatchedDataDaoFactory.create(appModuleParam, provideDatabaseProvider));
this.provideBatchedDataRepositoryProvider = DoubleCheck.provider(AppModule_ProvideBatchedDataRepositoryFactory.create(appModuleParam, provideBatchedDataDaoProvider));
this.provideDeviceInfoRepoProvider = DoubleCheck.provider(AppModule_ProvideDeviceInfoRepoFactory.create(appModuleParam, provideConfigDaoProvider, provideSahhaApiProvider, provideSahhaErrorLoggerProvider, provideIdManagerProvider));
this.provideUserDataRepoProvider = DoubleCheck.provider(AppModule_ProvideUserDataRepoFactory.create(appModuleParam, provideIoScopeProvider, provideAuthRepositoryProvider, provideSahhaApiProvider, provideSahhaErrorLoggerProvider));
this.provideNotificationManagerProvider = DoubleCheck.provider(AppModule_ProvideNotificationManagerFactory.create(appModuleParam, contextProvider));
this.provideSahhaNotificationManagerProvider = DoubleCheck.provider(AppModule_ProvideSahhaNotificationManagerFactory.create(appModuleParam, contextProvider, provideSahhaErrorLoggerProvider, provideNotificationManagerProvider, provideSahhaConfigRepoProvider, provideDefaultScopeProvider));
this.provideSensorManagerProvider = DoubleCheck.provider(AppModule_ProvideSensorManagerFactory.create(appModuleParam, contextProvider));
this.provideConnectionStateManagerProvider = DoubleCheck.provider(AppModule_ProvideConnectionStateManagerFactory.create(appModuleParam, contextProvider));
this.provideCalculateBatchLimitProvider = DoubleCheck.provider(AppModule_ProvideCalculateBatchLimitFactory.create(appModuleParam, provideBatchedDataRepositoryProvider));
this.providePermissionActionProvider = DoubleCheck.provider(AppModule_ProvidePermissionActionProviderFactory.create(appModuleParam, provideHealthConnectRepoProvider));
this.provideBatchAggregateLogsProvider = DoubleCheck.provider(AppModule_ProvideBatchAggregateLogsFactory.create(appModuleParam, provideTimeManagerProvider, providePermissionActionProvider, provideHealthConnectRepoProvider));
this.provideSleepRepositoryProvider = DoubleCheck.provider(AppModule_ProvideSleepRepositoryFactory.create(appModuleParam, provideSleepDaoProvider));
this.provideReceiverManagerProvider = DoubleCheck.provider(AppModule_ProvideReceiverManagerFactory.create(appModuleParam, contextProvider, provideMainScopeProvider));
this.provideInsightsRepositoryProvider = DoubleCheck.provider(AppModule_ProvideInsightsRepositoryFactory.create(appModuleParam, provideTimeManagerProvider, provideSahhaApiProvider, provideSahhaErrorLoggerProvider, provideHealthConnectClientProvider, provideIoScopeProvider));
this.provideActivityManagerProvider = DoubleCheck.provider(AppModule_ProvideActivityManagerFactory.create(appModuleParam, contextProvider));
this.provideAppCrashRepoProvider = DoubleCheck.provider(AppModule_ProvideAppCrashRepoFactory.create(appModuleParam, provideActivityManagerProvider));
this.providePowerManagerProvider = DoubleCheck.provider(AppModule_ProvidePowerManagerFactory.create(appModuleParam, contextProvider));
this.provideKeyguardManagerProvider = DoubleCheck.provider(AppModule_ProvideKeyguardManagerFactory.create(appModuleParam, contextProvider));
this.provideAppEventProcessorProvider = DoubleCheck.provider(AppModule_ProvideAppEventProcessorFactory.create(appModuleParam, contextProvider, provideHealthConnectConstantsMapperProvider, provideIdManagerProvider));
this.openAppSettingsUseCaseProvider = OpenAppSettingsUseCase_Factory.create(providePermissionManagerProvider);
this.permissionInteractionManagerProvider = PermissionInteractionManager_Factory.create(providePermissionManagerProvider, openAppSettingsUseCaseProvider, provideActivityCallbackProvider, provideSahhaConfigRepoProvider, provideSensorRepositoryProvider, provideDefaultScopeProvider, provideMainScopeProvider);
this.provideHostAppLifecycleObserverProvider = DoubleCheck.provider(AppModule_ProvideHostAppLifecycleObserverFactory.create(appModuleParam, contextProvider, provideAppEventProcessorProvider, provideBatchedDataRepositoryProvider, permissionInteractionManagerProvider, provideIoScopeProvider));
this.startPostWorkersUseCaseProvider = StartPostWorkersUseCase_Factory.create(provideIoScopeProvider, provideSensorRepositoryProvider, provideSahhaConfigRepoProvider, providePermissionManagerProvider);
this.startDataCollectionServiceUseCaseProvider = StartDataCollectionServiceUseCase_Factory.create(provideSahhaNotificationManagerProvider);
this.getScoresUseCaseProvider = GetScoresUseCase_Factory.create(provideUserDataRepoProvider, provideTimeManagerProvider, provideSahhaErrorLoggerProvider);
this.getDemographicUseCaseProvider = GetDemographicUseCase_Factory.create(provideUserDataRepoProvider);
this.postDemographicUseCaseProvider = PostDemographicUseCase_Factory.create(provideUserDataRepoProvider);
this.userDataInteractionManagerProvider = UserDataInteractionManager_Factory.create(provideMainScopeProvider, provideIoScopeProvider, provideAuthRepositoryProvider, provideDeviceInfoRepoProvider, provideSahhaConfigRepoProvider, getScoresUseCaseProvider, getDemographicUseCaseProvider, postDemographicUseCaseProvider);
this.saveTokensUseCaseProvider = SaveTokensUseCase_Factory.create(contextProvider, provideIoScopeProvider, provideAuthRepositoryProvider, userDataInteractionManagerProvider);
this.restartWorkersProvider = RestartWorkers_Factory.create(contextProvider, permissionInteractionManagerProvider);
this.killMainServiceProvider = KillMainService_Factory.create(contextProvider);
this.authInteractionManagerProvider = AuthInteractionManager_Factory.create(provideIoScopeProvider, provideAuthRepositoryProvider, provideSecurityDaoProvider, provideDecryptorProvider, provideHealthConnectRepoProvider, provideBatchedDataRepositoryProvider, provideDeviceInfoRepoProvider, provideSensorRepositoryProvider, provideSleepDaoProvider, saveTokensUseCaseProvider, restartWorkersProvider, killMainServiceProvider);
this.postAllSensorDataUseCaseProvider = PostAllSensorDataUseCase_Factory.create(provideSensorRepositoryProvider, authInteractionManagerProvider, provideSahhaErrorLoggerProvider);
this.getSensorDataUseCaseProvider = GetSensorDataUseCase_Factory.create(provideSensorRepositoryProvider);
this.batchDataLogsProvider = BatchDataLogs_Factory.create(provideBatchedDataRepositoryProvider, provideHealthConnectRepoProvider, provideTimeManagerProvider, provideHealthConnectConstantsMapperProvider);
this.filterActivityOverlapsProvider = FilterActivityOverlaps_Factory.create(provideBatchedDataRepositoryProvider, provideTimeManagerProvider);
this.addMetadataProvider = AddMetadata_Factory.create(provideTimeManagerProvider);
this.provideAggregationDataTypeMapperProvider = DoubleCheck.provider(AppModule_ProvideAggregationDataTypeMapperFactory.create(appModuleParam));
this.provideDataLogTransformerProvider = DoubleCheck.provider(AppModule_ProvideDataLogTransformerFactory.create(appModuleParam, provideAggregationDataTypeMapperProvider));
this.postBatchDataProvider = PostBatchData_Factory.create(contextProvider, provideSahhaApiProvider, providePostChunkManagerProvider, provideAuthRepositoryProvider, provideBatchedDataRepositoryProvider, provideSahhaErrorLoggerProvider, provideCalculateBatchLimitProvider, filterActivityOverlapsProvider, addMetadataProvider, provideDataLogTransformerProvider);
this.postSleepDataUseCaseProvider = PostSleepDataUseCase_Factory.create(provideSensorRepositoryProvider, provideSleepRepositoryProvider, addMetadataProvider);
this.postDeviceDataUseCaseProvider = PostDeviceDataUseCase_Factory.create(provideSensorRepositoryProvider, provideDeviceUsageRepositoryProvider, addMetadataProvider);
this.postStepDataUseCaseProvider = PostStepDataUseCase_Factory.create(provideSensorRepositoryProvider);
this.startCollectingStepDetectorDataProvider = StartCollectingStepDetectorData_Factory.create(provideSensorRepositoryProvider);
this.startCollectingPhoneScreenLockDataUseCaseProvider = StartCollectingPhoneScreenLockDataUseCase_Factory.create(provideReceiverManagerProvider);
this.sensorInteractionManagerProvider = SensorInteractionManager_Factory.create(provideHealthConnectRepoProvider, provideSahhaConfigRepoProvider, provideSensorRepositoryProvider, provideBatchedDataRepositoryProvider, providePermissionManagerProvider, provideSahhaNotificationManagerProvider, provideSensorManagerProvider, provideConnectionStateManagerProvider, startPostWorkersUseCaseProvider, startDataCollectionServiceUseCaseProvider, postAllSensorDataUseCaseProvider, getSensorDataUseCaseProvider, provideCalculateBatchLimitProvider, provideBatchAggregateLogsProvider, batchDataLogsProvider, postBatchDataProvider, postSleepDataUseCaseProvider, postDeviceDataUseCaseProvider, postStepDataUseCaseProvider, startCollectingStepDetectorDataProvider, startCollectingPhoneScreenLockDataUseCaseProvider, addMetadataProvider, provideSahhaErrorLoggerProvider);
this.provideDatBatcherRunnableProvider = DoubleCheck.provider(AppModule_ProvideDatBatcherRunnableFactory.create(appModuleParam, contextProvider, providePermissionManagerProvider, sensorInteractionManagerProvider, provideSahhaConfigRepoProvider));
this.provideHealthConnectMapperDefaultsProvider = DoubleCheck.provider(AppModule_ProvideHealthConnectMapperDefaultsFactory.create(appModuleParam, provideHealthConnectConstantsMapperProvider, provideTimeManagerProvider, provideIdManagerProvider));
this.provideEncryptorProvider = DoubleCheck.provider(AppModule_ProvideEncryptorFactory.create(appModuleParam, provideSecurityDaoProvider));
}
@Override
public Enum<SahhaEnvironment> getSahhaEnvironment() {
return provideSahhaEnvironmentProvider.get();
}
@Override
public SahhaDatabase getDatabase() {
return provideDatabaseProvider.get();
}
@Override
public SahhaInteractionManager getSahhaInteractionManager() {
return new SahhaInteractionManager(AppModule_ProvideMainScopeFactory.provideMainScope(appModule), AppModule_ProvideDefaultScopeFactory.provideDefaultScope(appModule), authInteractionManager(), permissionInteractionManager(), userDataInteractionManager(), sensorInteractionManager(), insightsInteractionManager(), uploadLatestCrashLog(), provideSahhaConfigRepoProvider.get(), provideSensorRepositoryProvider.get(), provideSahhaErrorLoggerProvider.get());
}
@Override
public Mutex getMutex() {
return provideMutexProvider.get();
}
@Override
public SensorRepo getSensorRepo() {
return provideSensorRepositoryProvider.get();
}
@Override
public PowerManager getPowerManager() {
return providePowerManagerProvider.get();
}
@Override
public KeyguardManager getKeyguardManager() {
return provideKeyguardManagerProvider.get();
}
@Override
public SensorManager getSensorManager() {
return provideSensorManagerProvider.get();
}
@Override
public SahhaNotificationManager getSahhaNotificationManager() {
return provideSahhaNotificationManagerProvider.get();
}
@Override
public ReceiverManager getReceiverManager() {
return provideReceiverManagerProvider.get();
}
@Override
public PermissionHandler getPermissionHandler() {
return providePermissionHandlerProvider.get();
}
@Override
public PermissionManager getPermissionManager() {
return providePermissionManagerProvider.get();
}
@Override
public PostChunkManager getPostChunkManager() {
return providePostChunkManagerProvider.get();
}
@Override
public SharedPreferences getEncryptedSharedPreferences() {
return provideEncryptedSharedPreferencesProvider.get();
}
@Override
public SahhaErrorLogger getSahhaErrorLogger() {
return provideSahhaErrorLoggerProvider.get();
}
@Override
public HostAppLifecycleObserver getHostAppLifecycleObserver() {
return provideHostAppLifecycleObserverProvider.get();
}
@Override
public DataBatcherRunnable getDataBatcherRunnable() {
return provideDatBatcherRunnableProvider.get();
}
@Override
public GsonConverterFactory getGson() {
return provideGsonConverterProvider.get();
}
@Override
public SahhaApi getApi() {
return provideSahhaApiProvider.get();
}
@Override
public SahhaErrorApi getSahhaErrorApi() {
return provideSahhaErrorApiProvider.get();
}
@Override
public SecurityDao getSecurityDao() {
return provideSecurityDaoProvider.get();
}
@Override
public MovementDao getMovementDao() {
return provideMovementDaoProvider.get();
}
@Override
public SleepDao getSleepDao() {
return provideSleepDaoProvider.get();
}
@Override
public ConfigurationDao getConfigurationDao() {
return provideConfigDaoProvider.get();
}
@Override
public DeviceUsageRepo getDeviceUsageRepo() {
return provideDeviceUsageRepositoryProvider.get();
}
@Override
public AuthRepo getAuthRepo() {
return provideAuthRepositoryProvider.get();
}
@Override
public DeviceInfoRepo getDeviceInfoRepo() {
return provideDeviceInfoRepoProvider.get();
}
@Override
public UserDataRepo getUserDataRepo() {
return provideUserDataRepoProvider.get();
}
@Override
public SahhaConfigRepo getSahhaConfigRepo() {
return provideSahhaConfigRepoProvider.get();
}
@Override
public InsightsRepo getInsightsRepo() {
return provideInsightsRepositoryProvider.get();
}
@Override
public BatchedDataRepo getBatchedDataRepo() {
return provideBatchedDataRepositoryProvider.get();
}
@Override
public BatchDataLogs getBatchDataLogs() {
return new BatchDataLogs(provideBatchedDataRepositoryProvider.get(), provideHealthConnectRepoProvider.get(), provideTimeManagerProvider.get(), provideHealthConnectConstantsMapperProvider.get());
}
@Override
public PostBatchData getPostBatchData() {
return new PostBatchData(context, provideSahhaApiProvider.get(), providePostChunkManagerProvider.get(), provideAuthRepositoryProvider.get(), provideBatchedDataRepositoryProvider.get(), provideSahhaErrorLoggerProvider.get(), provideCalculateBatchLimitProvider.get(), filterActivityOverlaps(), addMetadata(), provideDataLogTransformerProvider.get());
}
@Override
public GetStatsUseCase getGetStatsUseCase() {
return new GetStatsUseCase(providePermissionActionProvider.get());
}
@Override
public GetSamplesUseCase getGetSamplesUseCase() {
return new GetSamplesUseCase(providePermissionActionProvider.get());
}
@Override
public GetBiomarkersUseCase getGetBiomarkersUseCase() {
return new GetBiomarkersUseCase(provideUserDataRepoProvider.get(), AppModule_ProvideDefaultScopeFactory.provideDefaultScope(appModule), provideTimeManagerProvider.get());
}
@Override
public HealthConnectMapperDefaults getMapperDefaults() {
return provideHealthConnectMapperDefaultsProvider.get();
}
@Override
public CoroutineScope getMainScope() {
return AppModule_ProvideMainScopeFactory.provideMainScope(appModule);
}
@Override
public CoroutineScope getIoScope() {
return AppModule_ProvideIoScopeFactory.provideIoScope(appModule);
}
@Override
public CoroutineScope getDefaultScope() {
return AppModule_ProvideDefaultScopeFactory.provideDefaultScope(appModule);
}
@Override
public SahhaTimeManager getTimeManager() {
return provideTimeManagerProvider.get();
}
@Override
public Encryptor getEncryptor() {
return provideEncryptorProvider.get();
}
@Override
public Decryptor getDecryptor() {
return provideDecryptorProvider.get();
}
@Override
public HealthConnectClient getHealthConnectClient() {
return provideHealthConnectClientProvider.get();
}
@Override
public HealthConnectRepo getHealthConnectRepo() {
return provideHealthConnectRepoProvider.get();
}
@Override
public HealthConnectConstantsMapper getHealthConnectConstantsMapper() {
return provideHealthConnectConstantsMapperProvider.get();
}
@Override
public PostHealthConnectDataUseCase getPostHealthConnectDataUseCase() {
return new PostHealthConnectDataUseCase(provideAuthRepositoryProvider.get(), provideHealthConnectRepoProvider.get(), provideSahhaErrorLoggerProvider.get(), provideSahhaApiProvider.get(), provideHealthConnectConstantsMapperProvider.get(), AppModule_ProvideIoScopeFactory.provideIoScope(appModule));
}
@Override
public LogAppAliveState getLogAppAliveState() {
return new LogAppAliveState(logAppEvent(), provideHealthConnectRepoProvider.get());
}
@Override
public BatchAggregateLogs getBatchAggregateLogs() {
return provideBatchAggregateLogsProvider.get();
}
@Override
public ConnectionStateManager getConnectionStateManager() {
return provideConnectionStateManagerProvider.get();
}
@Override
public AggregateDataLogTransformer getDataLogTransformer() {
return provideDataLogTransformerProvider.get();
}
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/AuthInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.security.Decryptor;
import sdk.sahha.android.data.local.dao.SecurityDao;
import sdk.sahha.android.data.local.dao.SleepDao;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.use_case.SaveTokensUseCase;
import sdk.sahha.android.domain.use_case.background.KillMainService;
import sdk.sahha.android.domain.use_case.background.RestartWorkers;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AuthInteractionManager_Factory implements Factory<AuthInteractionManager> {
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<SecurityDao> securityDaoProvider;
private final Provider<Decryptor> decryptorProvider;
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
private final Provider<BatchedDataRepo> batchedDataRepoProvider;
private final Provider<DeviceInfoRepo> deviceInfoRepoProvider;
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<SleepDao> sleepDaoProvider;
private final Provider<SaveTokensUseCase> saveTokensUseCaseProvider;
private final Provider<RestartWorkers> restartWorkersProvider;
private final Provider<KillMainService> killMainServiceProvider;
public AuthInteractionManager_Factory(Provider<CoroutineScope> ioScopeProvider,
Provider<AuthRepo> authRepoProvider, Provider<SecurityDao> securityDaoProvider,
Provider<Decryptor> decryptorProvider, Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<BatchedDataRepo> batchedDataRepoProvider,
Provider<DeviceInfoRepo> deviceInfoRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<SleepDao> sleepDaoProvider, Provider<SaveTokensUseCase> saveTokensUseCaseProvider,
Provider<RestartWorkers> restartWorkersProvider,
Provider<KillMainService> killMainServiceProvider) {
this.ioScopeProvider = ioScopeProvider;
this.authRepoProvider = authRepoProvider;
this.securityDaoProvider = securityDaoProvider;
this.decryptorProvider = decryptorProvider;
this.healthConnectRepoProvider = healthConnectRepoProvider;
this.batchedDataRepoProvider = batchedDataRepoProvider;
this.deviceInfoRepoProvider = deviceInfoRepoProvider;
this.sensorRepoProvider = sensorRepoProvider;
this.sleepDaoProvider = sleepDaoProvider;
this.saveTokensUseCaseProvider = saveTokensUseCaseProvider;
this.restartWorkersProvider = restartWorkersProvider;
this.killMainServiceProvider = killMainServiceProvider;
}
@Override
public AuthInteractionManager get() {
return newInstance(ioScopeProvider.get(), authRepoProvider.get(), securityDaoProvider.get(), decryptorProvider.get(), healthConnectRepoProvider.get(), batchedDataRepoProvider.get(), deviceInfoRepoProvider.get(), sensorRepoProvider.get(), sleepDaoProvider.get(), saveTokensUseCaseProvider.get(), restartWorkersProvider.get(), killMainServiceProvider.get());
}
public static AuthInteractionManager_Factory create(Provider<CoroutineScope> ioScopeProvider,
Provider<AuthRepo> authRepoProvider, Provider<SecurityDao> securityDaoProvider,
Provider<Decryptor> decryptorProvider, Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<BatchedDataRepo> batchedDataRepoProvider,
Provider<DeviceInfoRepo> deviceInfoRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<SleepDao> sleepDaoProvider, Provider<SaveTokensUseCase> saveTokensUseCaseProvider,
Provider<RestartWorkers> restartWorkersProvider,
Provider<KillMainService> killMainServiceProvider) {
return new AuthInteractionManager_Factory(ioScopeProvider, authRepoProvider, securityDaoProvider, decryptorProvider, healthConnectRepoProvider, batchedDataRepoProvider, deviceInfoRepoProvider, sensorRepoProvider, sleepDaoProvider, saveTokensUseCaseProvider, restartWorkersProvider, killMainServiceProvider);
}
public static AuthInteractionManager newInstance(CoroutineScope ioScope, AuthRepo authRepo,
SecurityDao securityDao, Decryptor decryptor, HealthConnectRepo healthConnectRepo,
BatchedDataRepo batchedDataRepo, DeviceInfoRepo deviceInfoRepo, SensorRepo sensorRepo,
SleepDao sleepDao, SaveTokensUseCase saveTokensUseCase, RestartWorkers restartWorkers,
KillMainService killMainService) {
return new AuthInteractionManager(ioScope, authRepo, securityDao, decryptor, healthConnectRepo, batchedDataRepo, deviceInfoRepo, sensorRepo, sleepDao, saveTokensUseCase, restartWorkers, killMainService);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/InsightsInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.repository.InsightsRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class InsightsInteractionManager_Factory implements Factory<InsightsInteractionManager> {
private final Provider<AuthRepo> authRepoProvider;
private final Provider<InsightsRepo> insightsRepoProvider;
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<CoroutineScope> ioScopeProvider;
public InsightsInteractionManager_Factory(Provider<AuthRepo> authRepoProvider,
Provider<InsightsRepo> insightsRepoProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SahhaTimeManager> timeManagerProvider,
Provider<CoroutineScope> ioScopeProvider) {
this.authRepoProvider = authRepoProvider;
this.insightsRepoProvider = insightsRepoProvider;
this.healthConnectRepoProvider = healthConnectRepoProvider;
this.configRepoProvider = configRepoProvider;
this.timeManagerProvider = timeManagerProvider;
this.ioScopeProvider = ioScopeProvider;
}
@Override
public InsightsInteractionManager get() {
return newInstance(authRepoProvider.get(), insightsRepoProvider.get(), healthConnectRepoProvider.get(), configRepoProvider.get(), timeManagerProvider.get(), ioScopeProvider.get());
}
public static InsightsInteractionManager_Factory create(Provider<AuthRepo> authRepoProvider,
Provider<InsightsRepo> insightsRepoProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SahhaTimeManager> timeManagerProvider,
Provider<CoroutineScope> ioScopeProvider) {
return new InsightsInteractionManager_Factory(authRepoProvider, insightsRepoProvider, healthConnectRepoProvider, configRepoProvider, timeManagerProvider, ioScopeProvider);
}
public static InsightsInteractionManager newInstance(AuthRepo authRepo, InsightsRepo insightsRepo,
HealthConnectRepo healthConnectRepo, SahhaConfigRepo configRepo, SahhaTimeManager timeManager,
CoroutineScope ioScope) {
return new InsightsInteractionManager(authRepo, insightsRepo, healthConnectRepo, configRepo, timeManager, ioScope);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/PermissionInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.model.callbacks.ActivityCallback;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.use_case.permissions.OpenAppSettingsUseCase;
@ScopeMetadata
@QualifierMetadata({
"sdk.sahha.android.di.DefaultScope",
"sdk.sahha.android.di.MainScope"
})
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PermissionInteractionManager_Factory implements Factory<PermissionInteractionManager> {
private final Provider<PermissionManager> managerProvider;
private final Provider<OpenAppSettingsUseCase> openAppSettingsUseCaseProvider;
private final Provider<ActivityCallback> activityCallbackProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<CoroutineScope> mainScopeProvider;
public PermissionInteractionManager_Factory(Provider<PermissionManager> managerProvider,
Provider<OpenAppSettingsUseCase> openAppSettingsUseCaseProvider,
Provider<ActivityCallback> activityCallbackProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<CoroutineScope> defaultScopeProvider, Provider<CoroutineScope> mainScopeProvider) {
this.managerProvider = managerProvider;
this.openAppSettingsUseCaseProvider = openAppSettingsUseCaseProvider;
this.activityCallbackProvider = activityCallbackProvider;
this.configRepoProvider = configRepoProvider;
this.sensorRepoProvider = sensorRepoProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.mainScopeProvider = mainScopeProvider;
}
@Override
public PermissionInteractionManager get() {
return newInstance(managerProvider.get(), openAppSettingsUseCaseProvider.get(), activityCallbackProvider.get(), configRepoProvider.get(), sensorRepoProvider.get(), defaultScopeProvider.get(), mainScopeProvider.get());
}
public static PermissionInteractionManager_Factory create(
Provider<PermissionManager> managerProvider,
Provider<OpenAppSettingsUseCase> openAppSettingsUseCaseProvider,
Provider<ActivityCallback> activityCallbackProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<CoroutineScope> defaultScopeProvider, Provider<CoroutineScope> mainScopeProvider) {
return new PermissionInteractionManager_Factory(managerProvider, openAppSettingsUseCaseProvider, activityCallbackProvider, configRepoProvider, sensorRepoProvider, defaultScopeProvider, mainScopeProvider);
}
public static PermissionInteractionManager newInstance(PermissionManager manager,
OpenAppSettingsUseCase openAppSettingsUseCase, ActivityCallback activityCallback,
SahhaConfigRepo configRepo, SensorRepo sensorRepo, CoroutineScope defaultScope,
CoroutineScope mainScope) {
return new PermissionInteractionManager(manager, openAppSettingsUseCase, activityCallback, configRepo, sensorRepo, defaultScope, mainScope);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/SahhaInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.use_case.UploadLatestCrashLog;
@ScopeMetadata
@QualifierMetadata({
"sdk.sahha.android.di.MainScope",
"sdk.sahha.android.di.DefaultScope"
})
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class SahhaInteractionManager_Factory implements Factory<SahhaInteractionManager> {
private final Provider<CoroutineScope> mainScopeProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<AuthInteractionManager> authProvider;
private final Provider<PermissionInteractionManager> permissionProvider;
private final Provider<UserDataInteractionManager> userDataProvider;
private final Provider<SensorInteractionManager> sensorProvider;
private final Provider<InsightsInteractionManager> insightsProvider;
private final Provider<UploadLatestCrashLog> uploadLatestCrashLogProvider;
private final Provider<SahhaConfigRepo> sahhaConfigRepoProvider;
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
public SahhaInteractionManager_Factory(Provider<CoroutineScope> mainScopeProvider,
Provider<CoroutineScope> defaultScopeProvider, Provider<AuthInteractionManager> authProvider,
Provider<PermissionInteractionManager> permissionProvider,
Provider<UserDataInteractionManager> userDataProvider,
Provider<SensorInteractionManager> sensorProvider,
Provider<InsightsInteractionManager> insightsProvider,
Provider<UploadLatestCrashLog> uploadLatestCrashLogProvider,
Provider<SahhaConfigRepo> sahhaConfigRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
this.mainScopeProvider = mainScopeProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.authProvider = authProvider;
this.permissionProvider = permissionProvider;
this.userDataProvider = userDataProvider;
this.sensorProvider = sensorProvider;
this.insightsProvider = insightsProvider;
this.uploadLatestCrashLogProvider = uploadLatestCrashLogProvider;
this.sahhaConfigRepoProvider = sahhaConfigRepoProvider;
this.sensorRepoProvider = sensorRepoProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
}
@Override
public SahhaInteractionManager get() {
return newInstance(mainScopeProvider.get(), defaultScopeProvider.get(), authProvider.get(), permissionProvider.get(), userDataProvider.get(), sensorProvider.get(), insightsProvider.get(), uploadLatestCrashLogProvider.get(), sahhaConfigRepoProvider.get(), sensorRepoProvider.get(), sahhaErrorLoggerProvider.get());
}
public static SahhaInteractionManager_Factory create(Provider<CoroutineScope> mainScopeProvider,
Provider<CoroutineScope> defaultScopeProvider, Provider<AuthInteractionManager> authProvider,
Provider<PermissionInteractionManager> permissionProvider,
Provider<UserDataInteractionManager> userDataProvider,
Provider<SensorInteractionManager> sensorProvider,
Provider<InsightsInteractionManager> insightsProvider,
Provider<UploadLatestCrashLog> uploadLatestCrashLogProvider,
Provider<SahhaConfigRepo> sahhaConfigRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
return new SahhaInteractionManager_Factory(mainScopeProvider, defaultScopeProvider, authProvider, permissionProvider, userDataProvider, sensorProvider, insightsProvider, uploadLatestCrashLogProvider, sahhaConfigRepoProvider, sensorRepoProvider, sahhaErrorLoggerProvider);
}
public static SahhaInteractionManager newInstance(CoroutineScope mainScope,
CoroutineScope defaultScope, AuthInteractionManager auth,
PermissionInteractionManager permission, UserDataInteractionManager userData,
SensorInteractionManager sensor, InsightsInteractionManager insights,
UploadLatestCrashLog uploadLatestCrashLog, SahhaConfigRepo sahhaConfigRepo,
SensorRepo sensorRepo, SahhaErrorLogger sahhaErrorLogger) {
return new SahhaInteractionManager(mainScope, defaultScope, auth, permission, userData, sensor, insights, uploadLatestCrashLog, sahhaConfigRepo, sensorRepo, sahhaErrorLogger);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/SensorInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import android.hardware.SensorManager;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.domain.manager.ConnectionStateManager;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.manager.SahhaNotificationManager;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.use_case.CalculateBatchLimit;
import sdk.sahha.android.domain.use_case.GetSensorDataUseCase;
import sdk.sahha.android.domain.use_case.background.BatchAggregateLogs;
import sdk.sahha.android.domain.use_case.background.BatchDataLogs;
import sdk.sahha.android.domain.use_case.background.StartCollectingPhoneScreenLockDataUseCase;
import sdk.sahha.android.domain.use_case.background.StartCollectingStepDetectorData;
import sdk.sahha.android.domain.use_case.background.StartDataCollectionServiceUseCase;
import sdk.sahha.android.domain.use_case.metadata.AddMetadata;
import sdk.sahha.android.domain.use_case.post.PostAllSensorDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostBatchData;
import sdk.sahha.android.domain.use_case.post.PostDeviceDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostSleepDataUseCase;
import sdk.sahha.android.domain.use_case.post.PostStepDataUseCase;
import sdk.sahha.android.domain.use_case.post.StartPostWorkersUseCase;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class SensorInteractionManager_Factory implements Factory<SensorInteractionManager> {
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
private final Provider<SahhaConfigRepo> configRepoProvider;
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<BatchedDataRepo> batchedDataRepoProvider;
private final Provider<PermissionManager> permissionManagerProvider;
private final Provider<SahhaNotificationManager> notificationManagerProvider;
private final Provider<SensorManager> sensorManagerProvider;
private final Provider<ConnectionStateManager> connectionStateManagerProvider;
private final Provider<StartPostWorkersUseCase> startPostWorkersUseCaseProvider;
private final Provider<StartDataCollectionServiceUseCase> startDataCollectionServiceUseCaseProvider;
private final Provider<PostAllSensorDataUseCase> postAllSensorDataUseCaseProvider;
private final Provider<GetSensorDataUseCase> getSensorDataUseCaseProvider;
private final Provider<CalculateBatchLimit> calculateBatchLimitProvider;
private final Provider<BatchAggregateLogs> batchAggregateLogsProvider;
private final Provider<BatchDataLogs> batchDataLogsProvider;
private final Provider<PostBatchData> postBatchDataProvider;
private final Provider<PostSleepDataUseCase> postSleepDataUseCaseProvider;
private final Provider<PostDeviceDataUseCase> postDeviceDataUseCaseProvider;
private final Provider<PostStepDataUseCase> postStepDataUseCaseProvider;
private final Provider<StartCollectingStepDetectorData> startCollectingStepDetectorDataProvider;
private final Provider<StartCollectingPhoneScreenLockDataUseCase> startCollectingPhoneScreenLockDataUseCaseProvider;
private final Provider<AddMetadata> addMetadataProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
public SensorInteractionManager_Factory(Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<BatchedDataRepo> batchedDataRepoProvider,
Provider<PermissionManager> permissionManagerProvider,
Provider<SahhaNotificationManager> notificationManagerProvider,
Provider<SensorManager> sensorManagerProvider,
Provider<ConnectionStateManager> connectionStateManagerProvider,
Provider<StartPostWorkersUseCase> startPostWorkersUseCaseProvider,
Provider<StartDataCollectionServiceUseCase> startDataCollectionServiceUseCaseProvider,
Provider<PostAllSensorDataUseCase> postAllSensorDataUseCaseProvider,
Provider<GetSensorDataUseCase> getSensorDataUseCaseProvider,
Provider<CalculateBatchLimit> calculateBatchLimitProvider,
Provider<BatchAggregateLogs> batchAggregateLogsProvider,
Provider<BatchDataLogs> batchDataLogsProvider, Provider<PostBatchData> postBatchDataProvider,
Provider<PostSleepDataUseCase> postSleepDataUseCaseProvider,
Provider<PostDeviceDataUseCase> postDeviceDataUseCaseProvider,
Provider<PostStepDataUseCase> postStepDataUseCaseProvider,
Provider<StartCollectingStepDetectorData> startCollectingStepDetectorDataProvider,
Provider<StartCollectingPhoneScreenLockDataUseCase> startCollectingPhoneScreenLockDataUseCaseProvider,
Provider<AddMetadata> addMetadataProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
this.healthConnectRepoProvider = healthConnectRepoProvider;
this.configRepoProvider = configRepoProvider;
this.sensorRepoProvider = sensorRepoProvider;
this.batchedDataRepoProvider = batchedDataRepoProvider;
this.permissionManagerProvider = permissionManagerProvider;
this.notificationManagerProvider = notificationManagerProvider;
this.sensorManagerProvider = sensorManagerProvider;
this.connectionStateManagerProvider = connectionStateManagerProvider;
this.startPostWorkersUseCaseProvider = startPostWorkersUseCaseProvider;
this.startDataCollectionServiceUseCaseProvider = startDataCollectionServiceUseCaseProvider;
this.postAllSensorDataUseCaseProvider = postAllSensorDataUseCaseProvider;
this.getSensorDataUseCaseProvider = getSensorDataUseCaseProvider;
this.calculateBatchLimitProvider = calculateBatchLimitProvider;
this.batchAggregateLogsProvider = batchAggregateLogsProvider;
this.batchDataLogsProvider = batchDataLogsProvider;
this.postBatchDataProvider = postBatchDataProvider;
this.postSleepDataUseCaseProvider = postSleepDataUseCaseProvider;
this.postDeviceDataUseCaseProvider = postDeviceDataUseCaseProvider;
this.postStepDataUseCaseProvider = postStepDataUseCaseProvider;
this.startCollectingStepDetectorDataProvider = startCollectingStepDetectorDataProvider;
this.startCollectingPhoneScreenLockDataUseCaseProvider = startCollectingPhoneScreenLockDataUseCaseProvider;
this.addMetadataProvider = addMetadataProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
}
@Override
public SensorInteractionManager get() {
return newInstance(healthConnectRepoProvider.get(), configRepoProvider.get(), sensorRepoProvider.get(), batchedDataRepoProvider.get(), permissionManagerProvider.get(), notificationManagerProvider.get(), sensorManagerProvider.get(), connectionStateManagerProvider.get(), startPostWorkersUseCaseProvider.get(), startDataCollectionServiceUseCaseProvider.get(), postAllSensorDataUseCaseProvider.get(), getSensorDataUseCaseProvider.get(), calculateBatchLimitProvider.get(), batchAggregateLogsProvider.get(), batchDataLogsProvider.get(), postBatchDataProvider.get(), postSleepDataUseCaseProvider.get(), postDeviceDataUseCaseProvider.get(), postStepDataUseCaseProvider.get(), startCollectingStepDetectorDataProvider.get(), startCollectingPhoneScreenLockDataUseCaseProvider.get(), addMetadataProvider.get(), sahhaErrorLoggerProvider.get());
}
public static SensorInteractionManager_Factory create(
Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaConfigRepo> configRepoProvider, Provider<SensorRepo> sensorRepoProvider,
Provider<BatchedDataRepo> batchedDataRepoProvider,
Provider<PermissionManager> permissionManagerProvider,
Provider<SahhaNotificationManager> notificationManagerProvider,
Provider<SensorManager> sensorManagerProvider,
Provider<ConnectionStateManager> connectionStateManagerProvider,
Provider<StartPostWorkersUseCase> startPostWorkersUseCaseProvider,
Provider<StartDataCollectionServiceUseCase> startDataCollectionServiceUseCaseProvider,
Provider<PostAllSensorDataUseCase> postAllSensorDataUseCaseProvider,
Provider<GetSensorDataUseCase> getSensorDataUseCaseProvider,
Provider<CalculateBatchLimit> calculateBatchLimitProvider,
Provider<BatchAggregateLogs> batchAggregateLogsProvider,
Provider<BatchDataLogs> batchDataLogsProvider, Provider<PostBatchData> postBatchDataProvider,
Provider<PostSleepDataUseCase> postSleepDataUseCaseProvider,
Provider<PostDeviceDataUseCase> postDeviceDataUseCaseProvider,
Provider<PostStepDataUseCase> postStepDataUseCaseProvider,
Provider<StartCollectingStepDetectorData> startCollectingStepDetectorDataProvider,
Provider<StartCollectingPhoneScreenLockDataUseCase> startCollectingPhoneScreenLockDataUseCaseProvider,
Provider<AddMetadata> addMetadataProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
return new SensorInteractionManager_Factory(healthConnectRepoProvider, configRepoProvider, sensorRepoProvider, batchedDataRepoProvider, permissionManagerProvider, notificationManagerProvider, sensorManagerProvider, connectionStateManagerProvider, startPostWorkersUseCaseProvider, startDataCollectionServiceUseCaseProvider, postAllSensorDataUseCaseProvider, getSensorDataUseCaseProvider, calculateBatchLimitProvider, batchAggregateLogsProvider, batchDataLogsProvider, postBatchDataProvider, postSleepDataUseCaseProvider, postDeviceDataUseCaseProvider, postStepDataUseCaseProvider, startCollectingStepDetectorDataProvider, startCollectingPhoneScreenLockDataUseCaseProvider, addMetadataProvider, sahhaErrorLoggerProvider);
}
public static SensorInteractionManager newInstance(HealthConnectRepo healthConnectRepo,
SahhaConfigRepo configRepo, SensorRepo sensorRepo, BatchedDataRepo batchedDataRepo,
PermissionManager permissionManager, SahhaNotificationManager notificationManager,
SensorManager sensorManager, ConnectionStateManager connectionStateManager,
StartPostWorkersUseCase startPostWorkersUseCase,
StartDataCollectionServiceUseCase startDataCollectionServiceUseCase,
PostAllSensorDataUseCase postAllSensorDataUseCase, GetSensorDataUseCase getSensorDataUseCase,
CalculateBatchLimit calculateBatchLimit, BatchAggregateLogs batchAggregateLogs,
BatchDataLogs batchDataLogs, PostBatchData postBatchData,
PostSleepDataUseCase postSleepDataUseCase, PostDeviceDataUseCase postDeviceDataUseCase,
PostStepDataUseCase postStepDataUseCase,
StartCollectingStepDetectorData startCollectingStepDetectorData,
StartCollectingPhoneScreenLockDataUseCase startCollectingPhoneScreenLockDataUseCase,
AddMetadata addMetadata, SahhaErrorLogger sahhaErrorLogger) {
return new SensorInteractionManager(healthConnectRepo, configRepo, sensorRepo, batchedDataRepo, permissionManager, notificationManager, sensorManager, connectionStateManager, startPostWorkersUseCase, startDataCollectionServiceUseCase, postAllSensorDataUseCase, getSensorDataUseCase, calculateBatchLimit, batchAggregateLogs, batchDataLogs, postBatchData, postSleepDataUseCase, postDeviceDataUseCase, postStepDataUseCase, startCollectingStepDetectorData, startCollectingPhoneScreenLockDataUseCase, addMetadata, sahhaErrorLogger);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/interaction/UserDataInteractionManager_Factory.java | package sdk.sahha.android.domain.interaction;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
import sdk.sahha.android.domain.repository.SahhaConfigRepo;
import sdk.sahha.android.domain.use_case.GetDemographicUseCase;
import sdk.sahha.android.domain.use_case.GetScoresUseCase;
import sdk.sahha.android.domain.use_case.post.PostDemographicUseCase;
@ScopeMetadata
@QualifierMetadata({
"sdk.sahha.android.di.MainScope",
"sdk.sahha.android.di.IoScope"
})
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class UserDataInteractionManager_Factory implements Factory<UserDataInteractionManager> {
private final Provider<CoroutineScope> mainScopeProvider;
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<DeviceInfoRepo> deviceInfoRepoProvider;
private final Provider<SahhaConfigRepo> sahhaConfigRepoProvider;
private final Provider<GetScoresUseCase> getScoresUseCaseProvider;
private final Provider<GetDemographicUseCase> getDemographicUseCaseProvider;
private final Provider<PostDemographicUseCase> postDemographicUseCaseProvider;
public UserDataInteractionManager_Factory(Provider<CoroutineScope> mainScopeProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<AuthRepo> authRepoProvider,
Provider<DeviceInfoRepo> deviceInfoRepoProvider,
Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<GetScoresUseCase> getScoresUseCaseProvider,
Provider<GetDemographicUseCase> getDemographicUseCaseProvider,
Provider<PostDemographicUseCase> postDemographicUseCaseProvider) {
this.mainScopeProvider = mainScopeProvider;
this.ioScopeProvider = ioScopeProvider;
this.authRepoProvider = authRepoProvider;
this.deviceInfoRepoProvider = deviceInfoRepoProvider;
this.sahhaConfigRepoProvider = sahhaConfigRepoProvider;
this.getScoresUseCaseProvider = getScoresUseCaseProvider;
this.getDemographicUseCaseProvider = getDemographicUseCaseProvider;
this.postDemographicUseCaseProvider = postDemographicUseCaseProvider;
}
@Override
public UserDataInteractionManager get() {
return newInstance(mainScopeProvider.get(), ioScopeProvider.get(), authRepoProvider.get(), deviceInfoRepoProvider.get(), sahhaConfigRepoProvider.get(), getScoresUseCaseProvider.get(), getDemographicUseCaseProvider.get(), postDemographicUseCaseProvider.get());
}
public static UserDataInteractionManager_Factory create(
Provider<CoroutineScope> mainScopeProvider, Provider<CoroutineScope> ioScopeProvider,
Provider<AuthRepo> authRepoProvider, Provider<DeviceInfoRepo> deviceInfoRepoProvider,
Provider<SahhaConfigRepo> sahhaConfigRepoProvider,
Provider<GetScoresUseCase> getScoresUseCaseProvider,
Provider<GetDemographicUseCase> getDemographicUseCaseProvider,
Provider<PostDemographicUseCase> postDemographicUseCaseProvider) {
return new UserDataInteractionManager_Factory(mainScopeProvider, ioScopeProvider, authRepoProvider, deviceInfoRepoProvider, sahhaConfigRepoProvider, getScoresUseCaseProvider, getDemographicUseCaseProvider, postDemographicUseCaseProvider);
}
public static UserDataInteractionManager newInstance(CoroutineScope mainScope,
CoroutineScope ioScope, AuthRepo authRepo, DeviceInfoRepo deviceInfoRepo,
SahhaConfigRepo sahhaConfigRepo, GetScoresUseCase getScoresUseCase,
GetDemographicUseCase getDemographicUseCase, PostDemographicUseCase postDemographicUseCase) {
return new UserDataInteractionManager(mainScope, ioScope, authRepo, deviceInfoRepo, sahhaConfigRepo, getScoresUseCase, getDemographicUseCase, postDemographicUseCase);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/model | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/model/categories/PermissionHandler_Factory.java | package sdk.sahha.android.domain.model.categories;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.model.callbacks.ActivityCallback;
import sdk.sahha.android.source.SahhaSensorStatus;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PermissionHandler_Factory implements Factory<PermissionHandler> {
private final Provider<ActivityCallback> activityCallbackProvider;
private final Provider<Enum<SahhaSensorStatus>> sensorStatusProvider;
public PermissionHandler_Factory(Provider<ActivityCallback> activityCallbackProvider,
Provider<Enum<SahhaSensorStatus>> sensorStatusProvider) {
this.activityCallbackProvider = activityCallbackProvider;
this.sensorStatusProvider = sensorStatusProvider;
}
@Override
public PermissionHandler get() {
return newInstance(activityCallbackProvider.get(), sensorStatusProvider.get());
}
public static PermissionHandler_Factory create(
Provider<ActivityCallback> activityCallbackProvider,
Provider<Enum<SahhaSensorStatus>> sensorStatusProvider) {
return new PermissionHandler_Factory(activityCallbackProvider, sensorStatusProvider);
}
public static PermissionHandler newInstance(ActivityCallback activityCallback,
Enum<SahhaSensorStatus> sensorStatus) {
return new PermissionHandler(activityCallback, sensorStatus);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/transformer/AggregateDataLogTransformer_Factory.java | package sdk.sahha.android.domain.transformer;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.mapper.AggregationDataTypeMapper;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AggregateDataLogTransformer_Factory implements Factory<AggregateDataLogTransformer> {
private final Provider<AggregationDataTypeMapper> dataTypeMapperProvider;
public AggregateDataLogTransformer_Factory(
Provider<AggregationDataTypeMapper> dataTypeMapperProvider) {
this.dataTypeMapperProvider = dataTypeMapperProvider;
}
@Override
public AggregateDataLogTransformer get() {
return newInstance(dataTypeMapperProvider.get());
}
public static AggregateDataLogTransformer_Factory create(
Provider<AggregationDataTypeMapper> dataTypeMapperProvider) {
return new AggregateDataLogTransformer_Factory(dataTypeMapperProvider);
}
public static AggregateDataLogTransformer newInstance(AggregationDataTypeMapper dataTypeMapper) {
return new AggregateDataLogTransformer(dataTypeMapper);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/CalculateBatchLimit_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class CalculateBatchLimit_Factory implements Factory<CalculateBatchLimit> {
private final Provider<BatchedDataRepo> batchedDataRepoProvider;
public CalculateBatchLimit_Factory(Provider<BatchedDataRepo> batchedDataRepoProvider) {
this.batchedDataRepoProvider = batchedDataRepoProvider;
}
@Override
public CalculateBatchLimit get() {
return newInstance(batchedDataRepoProvider.get());
}
public static CalculateBatchLimit_Factory create(
Provider<BatchedDataRepo> batchedDataRepoProvider) {
return new CalculateBatchLimit_Factory(batchedDataRepoProvider);
}
public static CalculateBatchLimit newInstance(BatchedDataRepo batchedDataRepo) {
return new CalculateBatchLimit(batchedDataRepo);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetBiomarkersUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.repository.UserDataRepo;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.DefaultScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetBiomarkersUseCase_Factory implements Factory<GetBiomarkersUseCase> {
private final Provider<UserDataRepo> repositoryProvider;
private final Provider<CoroutineScope> defaultScopeProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
public GetBiomarkersUseCase_Factory(Provider<UserDataRepo> repositoryProvider,
Provider<CoroutineScope> defaultScopeProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
this.repositoryProvider = repositoryProvider;
this.defaultScopeProvider = defaultScopeProvider;
this.timeManagerProvider = timeManagerProvider;
}
@Override
public GetBiomarkersUseCase get() {
return newInstance(repositoryProvider.get(), defaultScopeProvider.get(), timeManagerProvider.get());
}
public static GetBiomarkersUseCase_Factory create(Provider<UserDataRepo> repositoryProvider,
Provider<CoroutineScope> defaultScopeProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
return new GetBiomarkersUseCase_Factory(repositoryProvider, defaultScopeProvider, timeManagerProvider);
}
public static GetBiomarkersUseCase newInstance(UserDataRepo repository,
CoroutineScope defaultScope, SahhaTimeManager timeManager) {
return new GetBiomarkersUseCase(repository, defaultScope, timeManager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetDemographicUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.UserDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetDemographicUseCase_Factory implements Factory<GetDemographicUseCase> {
private final Provider<UserDataRepo> repositoryProvider;
public GetDemographicUseCase_Factory(Provider<UserDataRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetDemographicUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetDemographicUseCase_Factory create(Provider<UserDataRepo> repositoryProvider) {
return new GetDemographicUseCase_Factory(repositoryProvider);
}
public static GetDemographicUseCase newInstance(UserDataRepo repository) {
return new GetDemographicUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetDeviceModelUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetDeviceModelUseCase_Factory implements Factory<GetDeviceModelUseCase> {
private final Provider<DeviceInfoRepo> repositoryProvider;
public GetDeviceModelUseCase_Factory(Provider<DeviceInfoRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetDeviceModelUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetDeviceModelUseCase_Factory create(Provider<DeviceInfoRepo> repositoryProvider) {
return new GetDeviceModelUseCase_Factory(repositoryProvider);
}
public static GetDeviceModelUseCase newInstance(DeviceInfoRepo repository) {
return new GetDeviceModelUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetPlatformUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetPlatformUseCase_Factory implements Factory<GetPlatformUseCase> {
private final Provider<DeviceInfoRepo> repositoryProvider;
public GetPlatformUseCase_Factory(Provider<DeviceInfoRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetPlatformUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetPlatformUseCase_Factory create(Provider<DeviceInfoRepo> repositoryProvider) {
return new GetPlatformUseCase_Factory(repositoryProvider);
}
public static GetPlatformUseCase newInstance(DeviceInfoRepo repository) {
return new GetPlatformUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetPlatformVersionUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetPlatformVersionUseCase_Factory implements Factory<GetPlatformVersionUseCase> {
private final Provider<DeviceInfoRepo> repositoryProvider;
public GetPlatformVersionUseCase_Factory(Provider<DeviceInfoRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetPlatformVersionUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetPlatformVersionUseCase_Factory create(
Provider<DeviceInfoRepo> repositoryProvider) {
return new GetPlatformVersionUseCase_Factory(repositoryProvider);
}
public static GetPlatformVersionUseCase newInstance(DeviceInfoRepo repository) {
return new GetPlatformVersionUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetSamplesUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetSamplesUseCase_Factory implements Factory<GetSamplesUseCase> {
private final Provider<PermissionActionProvider> providerProvider;
public GetSamplesUseCase_Factory(Provider<PermissionActionProvider> providerProvider) {
this.providerProvider = providerProvider;
}
@Override
public GetSamplesUseCase get() {
return newInstance(providerProvider.get());
}
public static GetSamplesUseCase_Factory create(
Provider<PermissionActionProvider> providerProvider) {
return new GetSamplesUseCase_Factory(providerProvider);
}
public static GetSamplesUseCase newInstance(PermissionActionProvider provider) {
return new GetSamplesUseCase(provider);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetScoresUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.repository.UserDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetScoresUseCase_Factory implements Factory<GetScoresUseCase> {
private final Provider<UserDataRepo> repositoryProvider;
private final Provider<SahhaTimeManager> sahhaTimeManagerProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
public GetScoresUseCase_Factory(Provider<UserDataRepo> repositoryProvider,
Provider<SahhaTimeManager> sahhaTimeManagerProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
this.repositoryProvider = repositoryProvider;
this.sahhaTimeManagerProvider = sahhaTimeManagerProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
}
@Override
public GetScoresUseCase get() {
return newInstance(repositoryProvider.get(), sahhaTimeManagerProvider.get(), sahhaErrorLoggerProvider.get());
}
public static GetScoresUseCase_Factory create(Provider<UserDataRepo> repositoryProvider,
Provider<SahhaTimeManager> sahhaTimeManagerProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
return new GetScoresUseCase_Factory(repositoryProvider, sahhaTimeManagerProvider, sahhaErrorLoggerProvider);
}
public static GetScoresUseCase newInstance(UserDataRepo repository,
SahhaTimeManager sahhaTimeManager, SahhaErrorLogger sahhaErrorLogger) {
return new GetScoresUseCase(repository, sahhaTimeManager, sahhaErrorLogger);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetSdkVersionUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.DeviceInfoRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetSdkVersionUseCase_Factory implements Factory<GetSdkVersionUseCase> {
private final Provider<DeviceInfoRepo> repositoryProvider;
public GetSdkVersionUseCase_Factory(Provider<DeviceInfoRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetSdkVersionUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetSdkVersionUseCase_Factory create(Provider<DeviceInfoRepo> repositoryProvider) {
return new GetSdkVersionUseCase_Factory(repositoryProvider);
}
public static GetSdkVersionUseCase newInstance(DeviceInfoRepo repository) {
return new GetSdkVersionUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetSensorDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetSensorDataUseCase_Factory implements Factory<GetSensorDataUseCase> {
private final Provider<SensorRepo> repositoryProvider;
public GetSensorDataUseCase_Factory(Provider<SensorRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public GetSensorDataUseCase get() {
return newInstance(repositoryProvider.get());
}
public static GetSensorDataUseCase_Factory create(Provider<SensorRepo> repositoryProvider) {
return new GetSensorDataUseCase_Factory(repositoryProvider);
}
public static GetSensorDataUseCase newInstance(SensorRepo repository) {
return new GetSensorDataUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/GetStatsUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class GetStatsUseCase_Factory implements Factory<GetStatsUseCase> {
private final Provider<PermissionActionProvider> providerProvider;
public GetStatsUseCase_Factory(Provider<PermissionActionProvider> providerProvider) {
this.providerProvider = providerProvider;
}
@Override
public GetStatsUseCase get() {
return newInstance(providerProvider.get());
}
public static GetStatsUseCase_Factory create(
Provider<PermissionActionProvider> providerProvider) {
return new GetStatsUseCase_Factory(providerProvider);
}
public static GetStatsUseCase newInstance(PermissionActionProvider provider) {
return new GetStatsUseCase(provider);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/SaveTokensUseCase_Factory.java | package sdk.sahha.android.domain.use_case;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.domain.interaction.UserDataInteractionManager;
import sdk.sahha.android.domain.repository.AuthRepo;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class SaveTokensUseCase_Factory implements Factory<SaveTokensUseCase> {
private final Provider<Context> contextProvider;
private final Provider<CoroutineScope> ioScopeProvider;
private final Provider<AuthRepo> repositoryProvider;
private final Provider<UserDataInteractionManager> userDataProvider;
public SaveTokensUseCase_Factory(Provider<Context> contextProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<AuthRepo> repositoryProvider,
Provider<UserDataInteractionManager> userDataProvider) {
this.contextProvider = contextProvider;
this.ioScopeProvider = ioScopeProvider;
this.repositoryProvider = repositoryProvider;
this.userDataProvider = userDataProvider;
}
@Override
public SaveTokensUseCase get() {
return newInstance(contextProvider.get(), ioScopeProvider.get(), repositoryProvider.get(), userDataProvider.get());
}
public static SaveTokensUseCase_Factory create(Provider<Context> contextProvider,
Provider<CoroutineScope> ioScopeProvider, Provider<AuthRepo> repositoryProvider,
Provider<UserDataInteractionManager> userDataProvider) {
return new SaveTokensUseCase_Factory(contextProvider, ioScopeProvider, repositoryProvider, userDataProvider);
}
public static SaveTokensUseCase newInstance(Context context, CoroutineScope ioScope,
AuthRepo repository, UserDataInteractionManager userData) {
return new SaveTokensUseCase(context, ioScope, repository, userData);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/UploadLatestCrashLog_Factory.java | package sdk.sahha.android.domain.use_case;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.repository.AppCrashRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class UploadLatestCrashLog_Factory implements Factory<UploadLatestCrashLog> {
private final Provider<AppCrashRepo> appCrashRepoProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
public UploadLatestCrashLog_Factory(Provider<AppCrashRepo> appCrashRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
this.appCrashRepoProvider = appCrashRepoProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.timeManagerProvider = timeManagerProvider;
}
@Override
public UploadLatestCrashLog get() {
return newInstance(appCrashRepoProvider.get(), sahhaErrorLoggerProvider.get(), timeManagerProvider.get());
}
public static UploadLatestCrashLog_Factory create(Provider<AppCrashRepo> appCrashRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
return new UploadLatestCrashLog_Factory(appCrashRepoProvider, sahhaErrorLoggerProvider, timeManagerProvider);
}
public static UploadLatestCrashLog newInstance(AppCrashRepo appCrashRepo,
SahhaErrorLogger sahhaErrorLogger, SahhaTimeManager timeManager) {
return new UploadLatestCrashLog(appCrashRepo, sahhaErrorLogger, timeManager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/BatchAggregateLogs_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.provider.PermissionActionProvider;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class BatchAggregateLogs_Factory implements Factory<BatchAggregateLogs> {
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<PermissionActionProvider> providerProvider;
private final Provider<HealthConnectRepo> repositoryProvider;
public BatchAggregateLogs_Factory(Provider<SahhaTimeManager> timeManagerProvider,
Provider<PermissionActionProvider> providerProvider,
Provider<HealthConnectRepo> repositoryProvider) {
this.timeManagerProvider = timeManagerProvider;
this.providerProvider = providerProvider;
this.repositoryProvider = repositoryProvider;
}
@Override
public BatchAggregateLogs get() {
return newInstance(timeManagerProvider.get(), providerProvider.get(), repositoryProvider.get());
}
public static BatchAggregateLogs_Factory create(Provider<SahhaTimeManager> timeManagerProvider,
Provider<PermissionActionProvider> providerProvider,
Provider<HealthConnectRepo> repositoryProvider) {
return new BatchAggregateLogs_Factory(timeManagerProvider, providerProvider, repositoryProvider);
}
public static BatchAggregateLogs newInstance(SahhaTimeManager timeManager,
PermissionActionProvider provider, HealthConnectRepo repository) {
return new BatchAggregateLogs(timeManager, provider, repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/BatchDataLogs_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class BatchDataLogs_Factory implements Factory<BatchDataLogs> {
private final Provider<BatchedDataRepo> batchRepoProvider;
private final Provider<HealthConnectRepo> healthConnectRepoProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
private final Provider<HealthConnectConstantsMapper> mapperProvider;
public BatchDataLogs_Factory(Provider<BatchedDataRepo> batchRepoProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaTimeManager> timeManagerProvider,
Provider<HealthConnectConstantsMapper> mapperProvider) {
this.batchRepoProvider = batchRepoProvider;
this.healthConnectRepoProvider = healthConnectRepoProvider;
this.timeManagerProvider = timeManagerProvider;
this.mapperProvider = mapperProvider;
}
@Override
public BatchDataLogs get() {
return newInstance(batchRepoProvider.get(), healthConnectRepoProvider.get(), timeManagerProvider.get(), mapperProvider.get());
}
public static BatchDataLogs_Factory create(Provider<BatchedDataRepo> batchRepoProvider,
Provider<HealthConnectRepo> healthConnectRepoProvider,
Provider<SahhaTimeManager> timeManagerProvider,
Provider<HealthConnectConstantsMapper> mapperProvider) {
return new BatchDataLogs_Factory(batchRepoProvider, healthConnectRepoProvider, timeManagerProvider, mapperProvider);
}
public static BatchDataLogs newInstance(BatchedDataRepo batchRepo,
HealthConnectRepo healthConnectRepo, SahhaTimeManager timeManager,
HealthConnectConstantsMapper mapper) {
return new BatchDataLogs(batchRepo, healthConnectRepo, timeManager, mapper);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/FilterActivityOverlaps_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class FilterActivityOverlaps_Factory implements Factory<FilterActivityOverlaps> {
private final Provider<BatchedDataRepo> repoProvider;
private final Provider<SahhaTimeManager> timeManagerProvider;
public FilterActivityOverlaps_Factory(Provider<BatchedDataRepo> repoProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
this.repoProvider = repoProvider;
this.timeManagerProvider = timeManagerProvider;
}
@Override
public FilterActivityOverlaps get() {
return newInstance(repoProvider.get(), timeManagerProvider.get());
}
public static FilterActivityOverlaps_Factory create(Provider<BatchedDataRepo> repoProvider,
Provider<SahhaTimeManager> timeManagerProvider) {
return new FilterActivityOverlaps_Factory(repoProvider, timeManagerProvider);
}
public static FilterActivityOverlaps newInstance(BatchedDataRepo repo,
SahhaTimeManager timeManager) {
return new FilterActivityOverlaps(repo, timeManager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/KillMainService_Factory.java | package sdk.sahha.android.domain.use_case.background;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class KillMainService_Factory implements Factory<KillMainService> {
private final Provider<Context> contextProvider;
public KillMainService_Factory(Provider<Context> contextProvider) {
this.contextProvider = contextProvider;
}
@Override
public KillMainService get() {
return newInstance(contextProvider.get());
}
public static KillMainService_Factory create(Provider<Context> contextProvider) {
return new KillMainService_Factory(contextProvider);
}
public static KillMainService newInstance(Context context) {
return new KillMainService(context);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/LogAppAliveState_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class LogAppAliveState_Factory implements Factory<LogAppAliveState> {
private final Provider<LogAppEvent> logAppEventProvider;
private final Provider<HealthConnectRepo> repoProvider;
public LogAppAliveState_Factory(Provider<LogAppEvent> logAppEventProvider,
Provider<HealthConnectRepo> repoProvider) {
this.logAppEventProvider = logAppEventProvider;
this.repoProvider = repoProvider;
}
@Override
public LogAppAliveState get() {
return newInstance(logAppEventProvider.get(), repoProvider.get());
}
public static LogAppAliveState_Factory create(Provider<LogAppEvent> logAppEventProvider,
Provider<HealthConnectRepo> repoProvider) {
return new LogAppAliveState_Factory(logAppEventProvider, repoProvider);
}
public static LogAppAliveState newInstance(LogAppEvent logAppEvent, HealthConnectRepo repo) {
return new LogAppAliveState(logAppEvent, repo);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/LogAppEvent_Factory.java | package sdk.sahha.android.domain.use_case.background;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class LogAppEvent_Factory implements Factory<LogAppEvent> {
private final Provider<Context> contextProvider;
private final Provider<BatchedDataRepo> repoProvider;
private final Provider<HealthConnectConstantsMapper> mapperProvider;
public LogAppEvent_Factory(Provider<Context> contextProvider,
Provider<BatchedDataRepo> repoProvider,
Provider<HealthConnectConstantsMapper> mapperProvider) {
this.contextProvider = contextProvider;
this.repoProvider = repoProvider;
this.mapperProvider = mapperProvider;
}
@Override
public LogAppEvent get() {
return newInstance(contextProvider.get(), repoProvider.get(), mapperProvider.get());
}
public static LogAppEvent_Factory create(Provider<Context> contextProvider,
Provider<BatchedDataRepo> repoProvider,
Provider<HealthConnectConstantsMapper> mapperProvider) {
return new LogAppEvent_Factory(contextProvider, repoProvider, mapperProvider);
}
public static LogAppEvent newInstance(Context context, BatchedDataRepo repo,
HealthConnectConstantsMapper mapper) {
return new LogAppEvent(context, repo, mapper);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/RestartWorkers_Factory.java | package sdk.sahha.android.domain.use_case.background;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.interaction.PermissionInteractionManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class RestartWorkers_Factory implements Factory<RestartWorkers> {
private final Provider<Context> contextProvider;
private final Provider<PermissionInteractionManager> pimProvider;
public RestartWorkers_Factory(Provider<Context> contextProvider,
Provider<PermissionInteractionManager> pimProvider) {
this.contextProvider = contextProvider;
this.pimProvider = pimProvider;
}
@Override
public RestartWorkers get() {
return newInstance(contextProvider.get(), pimProvider.get());
}
public static RestartWorkers_Factory create(Provider<Context> contextProvider,
Provider<PermissionInteractionManager> pimProvider) {
return new RestartWorkers_Factory(contextProvider, pimProvider);
}
public static RestartWorkers newInstance(Context context, PermissionInteractionManager pim) {
return new RestartWorkers(context, pim);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/StartCollectingPhoneScreenLockDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.ReceiverManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class StartCollectingPhoneScreenLockDataUseCase_Factory implements Factory<StartCollectingPhoneScreenLockDataUseCase> {
private final Provider<ReceiverManager> managerProvider;
public StartCollectingPhoneScreenLockDataUseCase_Factory(
Provider<ReceiverManager> managerProvider) {
this.managerProvider = managerProvider;
}
@Override
public StartCollectingPhoneScreenLockDataUseCase get() {
return newInstance(managerProvider.get());
}
public static StartCollectingPhoneScreenLockDataUseCase_Factory create(
Provider<ReceiverManager> managerProvider) {
return new StartCollectingPhoneScreenLockDataUseCase_Factory(managerProvider);
}
public static StartCollectingPhoneScreenLockDataUseCase newInstance(ReceiverManager manager) {
return new StartCollectingPhoneScreenLockDataUseCase(manager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/StartCollectingSleepDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.PermissionManager;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class StartCollectingSleepDataUseCase_Factory implements Factory<StartCollectingSleepDataUseCase> {
private final Provider<SensorRepo> repositoryProvider;
private final Provider<PermissionManager> permissionManagerProvider;
public StartCollectingSleepDataUseCase_Factory(Provider<SensorRepo> repositoryProvider,
Provider<PermissionManager> permissionManagerProvider) {
this.repositoryProvider = repositoryProvider;
this.permissionManagerProvider = permissionManagerProvider;
}
@Override
public StartCollectingSleepDataUseCase get() {
return newInstance(repositoryProvider.get(), permissionManagerProvider.get());
}
public static StartCollectingSleepDataUseCase_Factory create(
Provider<SensorRepo> repositoryProvider,
Provider<PermissionManager> permissionManagerProvider) {
return new StartCollectingSleepDataUseCase_Factory(repositoryProvider, permissionManagerProvider);
}
public static StartCollectingSleepDataUseCase newInstance(SensorRepo repository,
PermissionManager permissionManager) {
return new StartCollectingSleepDataUseCase(repository, permissionManager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/StartCollectingStepCounterData_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class StartCollectingStepCounterData_Factory implements Factory<StartCollectingStepCounterData> {
private final Provider<SensorRepo> repositoryProvider;
public StartCollectingStepCounterData_Factory(Provider<SensorRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public StartCollectingStepCounterData get() {
return newInstance(repositoryProvider.get());
}
public static StartCollectingStepCounterData_Factory create(
Provider<SensorRepo> repositoryProvider) {
return new StartCollectingStepCounterData_Factory(repositoryProvider);
}
public static StartCollectingStepCounterData newInstance(SensorRepo repository) {
return new StartCollectingStepCounterData(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/StartCollectingStepDetectorData_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class StartCollectingStepDetectorData_Factory implements Factory<StartCollectingStepDetectorData> {
private final Provider<SensorRepo> repositoryProvider;
public StartCollectingStepDetectorData_Factory(Provider<SensorRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public StartCollectingStepDetectorData get() {
return newInstance(repositoryProvider.get());
}
public static StartCollectingStepDetectorData_Factory create(
Provider<SensorRepo> repositoryProvider) {
return new StartCollectingStepDetectorData_Factory(repositoryProvider);
}
public static StartCollectingStepDetectorData newInstance(SensorRepo repository) {
return new StartCollectingStepDetectorData(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/background/StartDataCollectionServiceUseCase_Factory.java | package sdk.sahha.android.domain.use_case.background;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.SahhaNotificationManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class StartDataCollectionServiceUseCase_Factory implements Factory<StartDataCollectionServiceUseCase> {
private final Provider<SahhaNotificationManager> managerProvider;
public StartDataCollectionServiceUseCase_Factory(
Provider<SahhaNotificationManager> managerProvider) {
this.managerProvider = managerProvider;
}
@Override
public StartDataCollectionServiceUseCase get() {
return newInstance(managerProvider.get());
}
public static StartDataCollectionServiceUseCase_Factory create(
Provider<SahhaNotificationManager> managerProvider) {
return new StartDataCollectionServiceUseCase_Factory(managerProvider);
}
public static StartDataCollectionServiceUseCase newInstance(SahhaNotificationManager manager) {
return new StartDataCollectionServiceUseCase(manager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/metadata/AddMetadata_Factory.java | package sdk.sahha.android.domain.use_case.metadata;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaTimeManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class AddMetadata_Factory implements Factory<AddMetadata> {
private final Provider<SahhaTimeManager> timeManagerProvider;
public AddMetadata_Factory(Provider<SahhaTimeManager> timeManagerProvider) {
this.timeManagerProvider = timeManagerProvider;
}
@Override
public AddMetadata get() {
return newInstance(timeManagerProvider.get());
}
public static AddMetadata_Factory create(Provider<SahhaTimeManager> timeManagerProvider) {
return new AddMetadata_Factory(timeManagerProvider);
}
public static AddMetadata newInstance(SahhaTimeManager timeManager) {
return new AddMetadata(timeManager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/permissions/ActivateUseCase_Factory.java | package sdk.sahha.android.domain.use_case.permissions;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.PermissionManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class ActivateUseCase_Factory implements Factory<ActivateUseCase> {
private final Provider<PermissionManager> repositoryProvider;
public ActivateUseCase_Factory(Provider<PermissionManager> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public ActivateUseCase get() {
return newInstance(repositoryProvider.get());
}
public static ActivateUseCase_Factory create(Provider<PermissionManager> repositoryProvider) {
return new ActivateUseCase_Factory(repositoryProvider);
}
public static ActivateUseCase newInstance(PermissionManager repository) {
return new ActivateUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/permissions/OpenAppSettingsUseCase_Factory.java | package sdk.sahha.android.domain.use_case.permissions;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.PermissionManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class OpenAppSettingsUseCase_Factory implements Factory<OpenAppSettingsUseCase> {
private final Provider<PermissionManager> managerProvider;
public OpenAppSettingsUseCase_Factory(Provider<PermissionManager> managerProvider) {
this.managerProvider = managerProvider;
}
@Override
public OpenAppSettingsUseCase get() {
return newInstance(managerProvider.get());
}
public static OpenAppSettingsUseCase_Factory create(Provider<PermissionManager> managerProvider) {
return new OpenAppSettingsUseCase_Factory(managerProvider);
}
public static OpenAppSettingsUseCase newInstance(PermissionManager manager) {
return new OpenAppSettingsUseCase(manager);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/permissions/SetPermissionLogicUseCase_Factory.java | package sdk.sahha.android.domain.use_case.permissions;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.manager.PermissionManager;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class SetPermissionLogicUseCase_Factory implements Factory<SetPermissionLogicUseCase> {
private final Provider<PermissionManager> repositoryProvider;
public SetPermissionLogicUseCase_Factory(Provider<PermissionManager> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public SetPermissionLogicUseCase get() {
return newInstance(repositoryProvider.get());
}
public static SetPermissionLogicUseCase_Factory create(
Provider<PermissionManager> repositoryProvider) {
return new SetPermissionLogicUseCase_Factory(repositoryProvider);
}
public static SetPermissionLogicUseCase newInstance(PermissionManager repository) {
return new SetPermissionLogicUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/post/PostAllSensorDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case.post;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.domain.interaction.AuthInteractionManager;
import sdk.sahha.android.domain.repository.SensorRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PostAllSensorDataUseCase_Factory implements Factory<PostAllSensorDataUseCase> {
private final Provider<SensorRepo> repositoryProvider;
private final Provider<AuthInteractionManager> authManagerProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
public PostAllSensorDataUseCase_Factory(Provider<SensorRepo> repositoryProvider,
Provider<AuthInteractionManager> authManagerProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
this.repositoryProvider = repositoryProvider;
this.authManagerProvider = authManagerProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
}
@Override
public PostAllSensorDataUseCase get() {
return newInstance(repositoryProvider.get(), authManagerProvider.get(), sahhaErrorLoggerProvider.get());
}
public static PostAllSensorDataUseCase_Factory create(Provider<SensorRepo> repositoryProvider,
Provider<AuthInteractionManager> authManagerProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider) {
return new PostAllSensorDataUseCase_Factory(repositoryProvider, authManagerProvider, sahhaErrorLoggerProvider);
}
public static PostAllSensorDataUseCase newInstance(SensorRepo repository,
AuthInteractionManager authManager, SahhaErrorLogger sahhaErrorLogger) {
return new PostAllSensorDataUseCase(repository, authManager, sahhaErrorLogger);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/post/PostBatchData_Factory.java | package sdk.sahha.android.domain.use_case.post;
import android.content.Context;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.manager.PostChunkManager;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.BatchedDataRepo;
import sdk.sahha.android.domain.transformer.AggregateDataLogTransformer;
import sdk.sahha.android.domain.use_case.CalculateBatchLimit;
import sdk.sahha.android.domain.use_case.background.FilterActivityOverlaps;
import sdk.sahha.android.domain.use_case.metadata.AddMetadata;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PostBatchData_Factory implements Factory<PostBatchData> {
private final Provider<Context> contextProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<PostChunkManager> chunkManagerProvider;
private final Provider<AuthRepo> authRepoProvider;
private final Provider<BatchedDataRepo> batchRepoProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<CalculateBatchLimit> calculateBatchLimitProvider;
private final Provider<FilterActivityOverlaps> filterActivityOverlapsProvider;
private final Provider<AddMetadata> addMetadataProvider;
private final Provider<AggregateDataLogTransformer> dataLogTransformerProvider;
public PostBatchData_Factory(Provider<Context> contextProvider, Provider<SahhaApi> apiProvider,
Provider<PostChunkManager> chunkManagerProvider, Provider<AuthRepo> authRepoProvider,
Provider<BatchedDataRepo> batchRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<CalculateBatchLimit> calculateBatchLimitProvider,
Provider<FilterActivityOverlaps> filterActivityOverlapsProvider,
Provider<AddMetadata> addMetadataProvider,
Provider<AggregateDataLogTransformer> dataLogTransformerProvider) {
this.contextProvider = contextProvider;
this.apiProvider = apiProvider;
this.chunkManagerProvider = chunkManagerProvider;
this.authRepoProvider = authRepoProvider;
this.batchRepoProvider = batchRepoProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.calculateBatchLimitProvider = calculateBatchLimitProvider;
this.filterActivityOverlapsProvider = filterActivityOverlapsProvider;
this.addMetadataProvider = addMetadataProvider;
this.dataLogTransformerProvider = dataLogTransformerProvider;
}
@Override
public PostBatchData get() {
return newInstance(contextProvider.get(), apiProvider.get(), chunkManagerProvider.get(), authRepoProvider.get(), batchRepoProvider.get(), sahhaErrorLoggerProvider.get(), calculateBatchLimitProvider.get(), filterActivityOverlapsProvider.get(), addMetadataProvider.get(), dataLogTransformerProvider.get());
}
public static PostBatchData_Factory create(Provider<Context> contextProvider,
Provider<SahhaApi> apiProvider, Provider<PostChunkManager> chunkManagerProvider,
Provider<AuthRepo> authRepoProvider, Provider<BatchedDataRepo> batchRepoProvider,
Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<CalculateBatchLimit> calculateBatchLimitProvider,
Provider<FilterActivityOverlaps> filterActivityOverlapsProvider,
Provider<AddMetadata> addMetadataProvider,
Provider<AggregateDataLogTransformer> dataLogTransformerProvider) {
return new PostBatchData_Factory(contextProvider, apiProvider, chunkManagerProvider, authRepoProvider, batchRepoProvider, sahhaErrorLoggerProvider, calculateBatchLimitProvider, filterActivityOverlapsProvider, addMetadataProvider, dataLogTransformerProvider);
}
public static PostBatchData newInstance(Context context, SahhaApi api,
PostChunkManager chunkManager, AuthRepo authRepo, BatchedDataRepo batchRepo,
SahhaErrorLogger sahhaErrorLogger, CalculateBatchLimit calculateBatchLimit,
FilterActivityOverlaps filterActivityOverlaps, AddMetadata addMetadata,
AggregateDataLogTransformer dataLogTransformer) {
return new PostBatchData(context, api, chunkManager, authRepo, batchRepo, sahhaErrorLogger, calculateBatchLimit, filterActivityOverlaps, addMetadata, dataLogTransformer);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/post/PostDemographicUseCase_Factory.java | package sdk.sahha.android.domain.use_case.post;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.UserDataRepo;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PostDemographicUseCase_Factory implements Factory<PostDemographicUseCase> {
private final Provider<UserDataRepo> repositoryProvider;
public PostDemographicUseCase_Factory(Provider<UserDataRepo> repositoryProvider) {
this.repositoryProvider = repositoryProvider;
}
@Override
public PostDemographicUseCase get() {
return newInstance(repositoryProvider.get());
}
public static PostDemographicUseCase_Factory create(Provider<UserDataRepo> repositoryProvider) {
return new PostDemographicUseCase_Factory(repositoryProvider);
}
public static PostDemographicUseCase newInstance(UserDataRepo repository) {
return new PostDemographicUseCase(repository);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/post/PostDeviceDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case.post;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import sdk.sahha.android.domain.repository.DeviceUsageRepo;
import sdk.sahha.android.domain.repository.SensorRepo;
import sdk.sahha.android.domain.use_case.metadata.AddMetadata;
@ScopeMetadata
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PostDeviceDataUseCase_Factory implements Factory<PostDeviceDataUseCase> {
private final Provider<SensorRepo> sensorRepoProvider;
private final Provider<DeviceUsageRepo> deviceUsageRepoProvider;
private final Provider<AddMetadata> addMetadataProvider;
public PostDeviceDataUseCase_Factory(Provider<SensorRepo> sensorRepoProvider,
Provider<DeviceUsageRepo> deviceUsageRepoProvider,
Provider<AddMetadata> addMetadataProvider) {
this.sensorRepoProvider = sensorRepoProvider;
this.deviceUsageRepoProvider = deviceUsageRepoProvider;
this.addMetadataProvider = addMetadataProvider;
}
@Override
public PostDeviceDataUseCase get() {
return newInstance(sensorRepoProvider.get(), deviceUsageRepoProvider.get(), addMetadataProvider.get());
}
public static PostDeviceDataUseCase_Factory create(Provider<SensorRepo> sensorRepoProvider,
Provider<DeviceUsageRepo> deviceUsageRepoProvider,
Provider<AddMetadata> addMetadataProvider) {
return new PostDeviceDataUseCase_Factory(sensorRepoProvider, deviceUsageRepoProvider, addMetadataProvider);
}
public static PostDeviceDataUseCase newInstance(SensorRepo sensorRepo,
DeviceUsageRepo deviceUsageRepo, AddMetadata addMetadata) {
return new PostDeviceDataUseCase(sensorRepo, deviceUsageRepo, addMetadata);
}
}
|
0 | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case | java-sources/ai/sahha/sahha-android/1.2.0/sdk/sahha/android/domain/use_case/post/PostHealthConnectDataUseCase_Factory.java | package sdk.sahha.android.domain.use_case.post;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
import kotlinx.coroutines.CoroutineScope;
import sdk.sahha.android.common.SahhaErrorLogger;
import sdk.sahha.android.data.remote.SahhaApi;
import sdk.sahha.android.domain.mapper.HealthConnectConstantsMapper;
import sdk.sahha.android.domain.repository.AuthRepo;
import sdk.sahha.android.domain.repository.HealthConnectRepo;
@ScopeMetadata
@QualifierMetadata("sdk.sahha.android.di.IoScope")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava"
})
public final class PostHealthConnectDataUseCase_Factory implements Factory<PostHealthConnectDataUseCase> {
private final Provider<AuthRepo> authRepoProvider;
private final Provider<HealthConnectRepo> repoProvider;
private final Provider<SahhaErrorLogger> sahhaErrorLoggerProvider;
private final Provider<SahhaApi> apiProvider;
private final Provider<HealthConnectConstantsMapper> mapperProvider;
private final Provider<CoroutineScope> ioScopeProvider;
public PostHealthConnectDataUseCase_Factory(Provider<AuthRepo> authRepoProvider,
Provider<HealthConnectRepo> repoProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaApi> apiProvider, Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<CoroutineScope> ioScopeProvider) {
this.authRepoProvider = authRepoProvider;
this.repoProvider = repoProvider;
this.sahhaErrorLoggerProvider = sahhaErrorLoggerProvider;
this.apiProvider = apiProvider;
this.mapperProvider = mapperProvider;
this.ioScopeProvider = ioScopeProvider;
}
@Override
public PostHealthConnectDataUseCase get() {
return newInstance(authRepoProvider.get(), repoProvider.get(), sahhaErrorLoggerProvider.get(), apiProvider.get(), mapperProvider.get(), ioScopeProvider.get());
}
public static PostHealthConnectDataUseCase_Factory create(Provider<AuthRepo> authRepoProvider,
Provider<HealthConnectRepo> repoProvider, Provider<SahhaErrorLogger> sahhaErrorLoggerProvider,
Provider<SahhaApi> apiProvider, Provider<HealthConnectConstantsMapper> mapperProvider,
Provider<CoroutineScope> ioScopeProvider) {
return new PostHealthConnectDataUseCase_Factory(authRepoProvider, repoProvider, sahhaErrorLoggerProvider, apiProvider, mapperProvider, ioScopeProvider);
}
public static PostHealthConnectDataUseCase newInstance(AuthRepo authRepo, HealthConnectRepo repo,
SahhaErrorLogger sahhaErrorLogger, SahhaApi api, HealthConnectConstantsMapper mapper,
CoroutineScope ioScope) {
return new PostHealthConnectDataUseCase(authRepo, repo, sahhaErrorLogger, api, mapper, ioScope);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.