nikita/radiola-android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: auth screen with auto-redirect, sync favorites/history with backend

Browse Source
This commit is contained in:
nk
2026-06-02 19:12:07 +03:00
parent d4adb1e7be
commit a83672b455
2934 changed files with 97351 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideAuthRepositoryFactory.java Normal file
View File

@@ -0,0 +1,47 @@
package com.radiola.di;
import com.radiola.data.repository.AuthRepositoryImpl;
import com.radiola.domain.repository.AuthRepository;
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",
"cast"
})
public final class AppModule_ProvideAuthRepositoryFactory implements Factory<AuthRepository> {
private final Provider<AuthRepositoryImpl> implProvider;
public AppModule_ProvideAuthRepositoryFactory(Provider<AuthRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public AuthRepository get() {
return provideAuthRepository(implProvider.get());
}
public static AppModule_ProvideAuthRepositoryFactory create(
Provider<AuthRepositoryImpl> implProvider) {
return new AppModule_ProvideAuthRepositoryFactory(implProvider);
}
public static AuthRepository provideAuthRepository(AuthRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideAuthRepository(impl));
}
}

42
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideBaseOkHttpClientFactory.java Normal file
View File

@@ -0,0 +1,42 @@
package com.radiola.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",
"cast"
})
public final class AppModule_ProvideBaseOkHttpClientFactory implements Factory<OkHttpClient> {
@Override
public OkHttpClient get() {
return provideBaseOkHttpClient();
}
public static AppModule_ProvideBaseOkHttpClientFactory create() {
return InstanceHolder.INSTANCE;
}
public static OkHttpClient provideBaseOkHttpClient() {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideBaseOkHttpClient());
}
private static final class InstanceHolder {
private static final AppModule_ProvideBaseOkHttpClientFactory INSTANCE = new AppModule_ProvideBaseOkHttpClientFactory();
}
}

46
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideDatabaseFactory.java Normal file
View File

@@ -0,0 +1,46 @@
package com.radiola.di;
import android.content.Context;
import com.radiola.data.local.AppDatabase;
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("dagger.hilt.android.qualifiers.ApplicationContext")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideDatabaseFactory implements Factory<AppDatabase> {
private final Provider<Context> contextProvider;
public AppModule_ProvideDatabaseFactory(Provider<Context> contextProvider) {
this.contextProvider = contextProvider;
}
@Override
public AppDatabase get() {
return provideDatabase(contextProvider.get());
}
public static AppModule_ProvideDatabaseFactory create(Provider<Context> contextProvider) {
return new AppModule_ProvideDatabaseFactory(contextProvider);
}
public static AppDatabase provideDatabase(Context context) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideDatabase(context));
}
}

48
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideFavoritesRepositoryFactory.java Normal file
View File

@@ -0,0 +1,48 @@
package com.radiola.di;
import com.radiola.data.repository.FavoritesRepositoryImpl;
import com.radiola.domain.repository.FavoritesRepository;
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",
"cast"
})
public final class AppModule_ProvideFavoritesRepositoryFactory implements Factory<FavoritesRepository> {
private final Provider<FavoritesRepositoryImpl> implProvider;
public AppModule_ProvideFavoritesRepositoryFactory(
Provider<FavoritesRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public FavoritesRepository get() {
return provideFavoritesRepository(implProvider.get());
}
public static AppModule_ProvideFavoritesRepositoryFactory create(
Provider<FavoritesRepositoryImpl> implProvider) {
return new AppModule_ProvideFavoritesRepositoryFactory(implProvider);
}
public static FavoritesRepository provideFavoritesRepository(FavoritesRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideFavoritesRepository(impl));
}
}

42
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideJsonFactory.java Normal file
View File

@@ -0,0 +1,42 @@
package com.radiola.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.serialization.json.Json;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideJsonFactory implements Factory<Json> {
@Override
public Json get() {
return provideJson();
}
public static AppModule_ProvideJsonFactory create() {
return InstanceHolder.INSTANCE;
}
public static Json provideJson() {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideJson());
}
private static final class InstanceHolder {
private static final AppModule_ProvideJsonFactory INSTANCE = new AppModule_ProvideJsonFactory();
}
}

52
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideLocalStationDataSourceFactory.java Normal file
View File

@@ -0,0 +1,52 @@
package com.radiola.di;
import android.content.Context;
import com.radiola.data.local.LocalStationDataSource;
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.serialization.json.Json;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideLocalStationDataSourceFactory implements Factory<LocalStationDataSource> {
private final Provider<Context> contextProvider;
private final Provider<Json> jsonProvider;
public AppModule_ProvideLocalStationDataSourceFactory(Provider<Context> contextProvider,
Provider<Json> jsonProvider) {
this.contextProvider = contextProvider;
this.jsonProvider = jsonProvider;
}
@Override
public LocalStationDataSource get() {
return provideLocalStationDataSource(contextProvider.get(), jsonProvider.get());
}
public static AppModule_ProvideLocalStationDataSourceFactory create(
Provider<Context> contextProvider, Provider<Json> jsonProvider) {
return new AppModule_ProvideLocalStationDataSourceFactory(contextProvider, jsonProvider);
}
public static LocalStationDataSource provideLocalStationDataSource(Context context, Json json) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideLocalStationDataSource(context, json));
}
}

48
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideNowPlayingRepositoryFactory.java Normal file
View File

@@ -0,0 +1,48 @@
package com.radiola.di;
import com.radiola.data.repository.NowPlayingRepositoryImpl;
import com.radiola.domain.repository.NowPlayingRepository;
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",
"cast"
})
public final class AppModule_ProvideNowPlayingRepositoryFactory implements Factory<NowPlayingRepository> {
private final Provider<NowPlayingRepositoryImpl> implProvider;
public AppModule_ProvideNowPlayingRepositoryFactory(
Provider<NowPlayingRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public NowPlayingRepository get() {
return provideNowPlayingRepository(implProvider.get());
}
public static AppModule_ProvideNowPlayingRepositoryFactory create(
Provider<NowPlayingRepositoryImpl> implProvider) {
return new AppModule_ProvideNowPlayingRepositoryFactory(implProvider);
}
public static NowPlayingRepository provideNowPlayingRepository(NowPlayingRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideNowPlayingRepository(impl));
}
}

46
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRadiolaApiFactory.java Normal file
View File

@@ -0,0 +1,46 @@
package com.radiola.di;
import com.radiola.data.remote.RadiolaApi;
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 retrofit2.Retrofit;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideRadiolaApiFactory implements Factory<RadiolaApi> {
private final Provider<Retrofit> retrofitProvider;
public AppModule_ProvideRadiolaApiFactory(Provider<Retrofit> retrofitProvider) {
this.retrofitProvider = retrofitProvider;
}
@Override
public RadiolaApi get() {
return provideRadiolaApi(retrofitProvider.get());
}
public static AppModule_ProvideRadiolaApiFactory create(Provider<Retrofit> retrofitProvider) {
return new AppModule_ProvideRadiolaApiFactory(retrofitProvider);
}
public static RadiolaApi provideRadiolaApi(Retrofit retrofit) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRadiolaApi(retrofit));
}
}

53
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRadiolaOkHttpClientFactory.java Normal file
View File

@@ -0,0 +1,53 @@
package com.radiola.di;
import com.radiola.data.remote.AuthInterceptor;
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;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideRadiolaOkHttpClientFactory implements Factory<OkHttpClient> {
private final Provider<OkHttpClient> baseClientProvider;
private final Provider<AuthInterceptor> authInterceptorProvider;
public AppModule_ProvideRadiolaOkHttpClientFactory(Provider<OkHttpClient> baseClientProvider,
Provider<AuthInterceptor> authInterceptorProvider) {
this.baseClientProvider = baseClientProvider;
this.authInterceptorProvider = authInterceptorProvider;
}
@Override
public OkHttpClient get() {
return provideRadiolaOkHttpClient(baseClientProvider.get(), authInterceptorProvider.get());
}
public static AppModule_ProvideRadiolaOkHttpClientFactory create(
Provider<OkHttpClient> baseClientProvider,
Provider<AuthInterceptor> authInterceptorProvider) {
return new AppModule_ProvideRadiolaOkHttpClientFactory(baseClientProvider, authInterceptorProvider);
}
public static OkHttpClient provideRadiolaOkHttpClient(OkHttpClient baseClient,
AuthInterceptor authInterceptor) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRadiolaOkHttpClient(baseClient, authInterceptor));
}
}

52
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRadiolaRetrofitFactory.java Normal file
View File

@@ -0,0 +1,52 @@
package com.radiola.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.serialization.json.Json;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideRadiolaRetrofitFactory implements Factory<Retrofit> {
private final Provider<OkHttpClient> okHttpClientProvider;
private final Provider<Json> jsonProvider;
public AppModule_ProvideRadiolaRetrofitFactory(Provider<OkHttpClient> okHttpClientProvider,
Provider<Json> jsonProvider) {
this.okHttpClientProvider = okHttpClientProvider;
this.jsonProvider = jsonProvider;
}
@Override
public Retrofit get() {
return provideRadiolaRetrofit(okHttpClientProvider.get(), jsonProvider.get());
}
public static AppModule_ProvideRadiolaRetrofitFactory create(
Provider<OkHttpClient> okHttpClientProvider, Provider<Json> jsonProvider) {
return new AppModule_ProvideRadiolaRetrofitFactory(okHttpClientProvider, jsonProvider);
}
public static Retrofit provideRadiolaRetrofit(OkHttpClient okHttpClient, Json json) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRadiolaRetrofit(okHttpClient, json));
}
}

46
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRecordApiFactory.java Normal file
View File

@@ -0,0 +1,46 @@
package com.radiola.di;
import com.radiola.data.remote.RecordApi;
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 retrofit2.Retrofit;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideRecordApiFactory implements Factory<RecordApi> {
private final Provider<Retrofit> retrofitProvider;
public AppModule_ProvideRecordApiFactory(Provider<Retrofit> retrofitProvider) {
this.retrofitProvider = retrofitProvider;
}
@Override
public RecordApi get() {
return provideRecordApi(retrofitProvider.get());
}
public static AppModule_ProvideRecordApiFactory create(Provider<Retrofit> retrofitProvider) {
return new AppModule_ProvideRecordApiFactory(retrofitProvider);
}
public static RecordApi provideRecordApi(Retrofit retrofit) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRecordApi(retrofit));
}
}

52
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRecordRetrofitFactory.java Normal file
View File

@@ -0,0 +1,52 @@
package com.radiola.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.serialization.json.Json;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata("javax.inject.Named")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast"
})
public final class AppModule_ProvideRecordRetrofitFactory implements Factory<Retrofit> {
private final Provider<OkHttpClient> okHttpClientProvider;
private final Provider<Json> jsonProvider;
public AppModule_ProvideRecordRetrofitFactory(Provider<OkHttpClient> okHttpClientProvider,
Provider<Json> jsonProvider) {
this.okHttpClientProvider = okHttpClientProvider;
this.jsonProvider = jsonProvider;
}
@Override
public Retrofit get() {
return provideRecordRetrofit(okHttpClientProvider.get(), jsonProvider.get());
}
public static AppModule_ProvideRecordRetrofitFactory create(
Provider<OkHttpClient> okHttpClientProvider, Provider<Json> jsonProvider) {
return new AppModule_ProvideRecordRetrofitFactory(okHttpClientProvider, jsonProvider);
}
public static Retrofit provideRecordRetrofit(OkHttpClient okHttpClient, Json json) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRecordRetrofit(okHttpClient, json));
}
}

48
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideRecordingRepositoryFactory.java Normal file
View File

@@ -0,0 +1,48 @@
package com.radiola.di;
import com.radiola.data.repository.RecordingRepositoryImpl;
import com.radiola.domain.repository.RecordingRepository;
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",
"cast"
})
public final class AppModule_ProvideRecordingRepositoryFactory implements Factory<RecordingRepository> {
private final Provider<RecordingRepositoryImpl> implProvider;
public AppModule_ProvideRecordingRepositoryFactory(
Provider<RecordingRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public RecordingRepository get() {
return provideRecordingRepository(implProvider.get());
}
public static AppModule_ProvideRecordingRepositoryFactory create(
Provider<RecordingRepositoryImpl> implProvider) {
return new AppModule_ProvideRecordingRepositoryFactory(implProvider);
}
public static RecordingRepository provideRecordingRepository(RecordingRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRecordingRepository(impl));
}
}

47
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideSettingsRepositoryFactory.java Normal file
View File

@@ -0,0 +1,47 @@
package com.radiola.di;
import com.radiola.data.repository.SettingsRepositoryImpl;
import com.radiola.domain.repository.SettingsRepository;
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",
"cast"
})
public final class AppModule_ProvideSettingsRepositoryFactory implements Factory<SettingsRepository> {
private final Provider<SettingsRepositoryImpl> implProvider;
public AppModule_ProvideSettingsRepositoryFactory(Provider<SettingsRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public SettingsRepository get() {
return provideSettingsRepository(implProvider.get());
}
public static AppModule_ProvideSettingsRepositoryFactory create(
Provider<SettingsRepositoryImpl> implProvider) {
return new AppModule_ProvideSettingsRepositoryFactory(implProvider);
}
public static SettingsRepository provideSettingsRepository(SettingsRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideSettingsRepository(impl));
}
}

47
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideStationRepositoryFactory.java Normal file
View File

@@ -0,0 +1,47 @@
package com.radiola.di;
import com.radiola.data.repository.StationRepositoryImpl;
import com.radiola.domain.repository.StationRepository;
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",
"cast"
})
public final class AppModule_ProvideStationRepositoryFactory implements Factory<StationRepository> {
private final Provider<StationRepositoryImpl> implProvider;
public AppModule_ProvideStationRepositoryFactory(Provider<StationRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public StationRepository get() {
return provideStationRepository(implProvider.get());
}
public static AppModule_ProvideStationRepositoryFactory create(
Provider<StationRepositoryImpl> implProvider) {
return new AppModule_ProvideStationRepositoryFactory(implProvider);
}
public static StationRepository provideStationRepository(StationRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideStationRepository(impl));
}
}

47
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideSyncRepositoryFactory.java Normal file
View File

@@ -0,0 +1,47 @@
package com.radiola.di;
import com.radiola.data.repository.SyncRepositoryImpl;
import com.radiola.domain.repository.SyncRepository;
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",
"cast"
})
public final class AppModule_ProvideSyncRepositoryFactory implements Factory<SyncRepository> {
private final Provider<SyncRepositoryImpl> implProvider;
public AppModule_ProvideSyncRepositoryFactory(Provider<SyncRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public SyncRepository get() {
return provideSyncRepository(implProvider.get());
}
public static AppModule_ProvideSyncRepositoryFactory create(
Provider<SyncRepositoryImpl> implProvider) {
return new AppModule_ProvideSyncRepositoryFactory(implProvider);
}
public static SyncRepository provideSyncRepository(SyncRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideSyncRepository(impl));
}
}

49
app/build/generated/ksp/debug/java/com/radiola/di/AppModule_ProvideTrackHistoryRepositoryFactory.java Normal file
View File

@@ -0,0 +1,49 @@
package com.radiola.di;
import com.radiola.data.repository.TrackHistoryRepositoryImpl;
import com.radiola.domain.repository.TrackHistoryRepository;
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",
"cast"
})
public final class AppModule_ProvideTrackHistoryRepositoryFactory implements Factory<TrackHistoryRepository> {
private final Provider<TrackHistoryRepositoryImpl> implProvider;
public AppModule_ProvideTrackHistoryRepositoryFactory(
Provider<TrackHistoryRepositoryImpl> implProvider) {
this.implProvider = implProvider;
}
@Override
public TrackHistoryRepository get() {
return provideTrackHistoryRepository(implProvider.get());
}
public static AppModule_ProvideTrackHistoryRepositoryFactory create(
Provider<TrackHistoryRepositoryImpl> implProvider) {
return new AppModule_ProvideTrackHistoryRepositoryFactory(implProvider);
}
public static TrackHistoryRepository provideTrackHistoryRepository(
TrackHistoryRepositoryImpl impl) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideTrackHistoryRepository(impl));
}
}