baseline before import-songs feature

This commit is contained in:
dev 2026-09-07 11:04:09 -05:00
commit 72e55ba319
2335 changed files with 59929 additions and 0 deletions

112
app/build.gradle.kts Normal file
View file

@ -0,0 +1,112 @@
plugins {
id("com.android.application")
id("org.jetbrains.kotlin.android")
id("org.jetbrains.kotlin.plugin.compose")
id("org.jetbrains.kotlin.plugin.serialization")
id("com.google.dagger.hilt.android")
id("com.google.devtools.ksp")
}
android {
namespace = "com.rada"
compileSdk = 35
defaultConfig {
applicationId = "com.rada"
minSdk = 26
targetSdk = 35
versionCode = 1
versionName = "0.1.0"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
isMinifyEnabled = true
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = "17"
}
buildFeatures {
compose = true
}
}
dependencies {
// Compose BOM
val composeBom = platform("androidx.compose:compose-bom:2024.12.01")
implementation(composeBom)
implementation("androidx.compose.ui:ui")
implementation("androidx.compose.ui:ui-graphics")
implementation("androidx.compose.ui:ui-tooling-preview")
implementation("androidx.compose.material3:material3")
implementation("androidx.compose.material:material-icons-extended")
debugImplementation("androidx.compose.ui:ui-tooling")
debugImplementation("androidx.compose.ui:ui-test-manifest")
// Core
implementation("androidx.core:core-ktx:1.15.0")
implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.7")
implementation("androidx.activity:activity-compose:1.9.3")
// Navigation
implementation("androidx.navigation:navigation-compose:2.8.5")
// Hilt
implementation("com.google.dagger:hilt-android:2.52")
ksp("com.google.dagger:hilt-android-compiler:2.52")
implementation("androidx.hilt:hilt-navigation-compose:1.2.0")
// Media3 (ExoPlayer)
implementation("androidx.media3:media3-exoplayer:1.5.1")
implementation("androidx.media3:media3-session:1.5.1")
implementation("androidx.media3:media3-ui:1.5.1")
// OkHttp
implementation("com.squareup.okhttp3:okhttp:4.12.0")
// Room (persistence layer: RadAmpDatabase / SavedSongDao / SavedSongEntity).
// Pre-existing gap: the data layer uses androidx.room but no Room
// dependency was declared, so the build could never resolve Room types
// (it was previously masked because dependency resolution failed earlier
// on the jaudiotagger group). 2.8.4 is the version present in the local
// Gradle cache; room-ktx provides the suspend/Flow DAO helpers, and
// room-compiler (via KSP) generates the Room implementation.
implementation("androidx.room:room-runtime:2.8.4")
implementation("androidx.room:room-ktx:2.8.4")
ksp("androidx.room:room-compiler:2.8.4")
// Kotlinx Serialization
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
// Coroutines
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
// Audio metadata (ID3 tags).
// NOTE: jaudiotagger is published under the Maven group `net.jthink` — the
// Java *package* is still `org.jaudiotagger.*` (the imports above are
// correct); only the dependency group was wrong (`org.jaudiotagger` does
// not exist on Maven Central), which made the build fail during
// dependency resolution before Kotlin was ever compiled.
implementation("net.jthink:jaudiotagger:2.2.5")
// Testing
testImplementation("junit:junit:4.13.2")
androidTestImplementation("androidx.test.ext:junit:1.2.1")
androidTestImplementation(composeBom)
androidTestImplementation("androidx.compose.ui:ui-test-junit4")
}

View file

@ -0,0 +1,767 @@
package com.rada;
import android.app.Activity;
import android.app.Service;
import android.view.View;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.SavedStateHandle;
import androidx.lifecycle.ViewModel;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.rada.data.local.RadAmpDatabase;
import com.rada.data.local.dao.PlaylistDao;
import com.rada.data.local.dao.SavedSongDao;
import com.rada.data.repository.LibraryRepository;
import com.rada.data.repository.PlaylistRepository;
import com.rada.data.repository.StationRepository;
import com.rada.data.repository.StreamFetcher;
import com.rada.data.repository.StreamRepository;
import com.rada.di.AppModule_ProvideDatabaseFactory;
import com.rada.di.AppModule_ProvideLibraryRepositoryFactory;
import com.rada.di.AppModule_ProvidePlaybackManagerFactory;
import com.rada.di.AppModule_ProvidePlaylistDaoFactory;
import com.rada.di.AppModule_ProvidePlaylistRepositoryFactory;
import com.rada.di.AppModule_ProvideSavedSongDaoFactory;
import com.rada.di.AppModule_ProvideStationRepositoryFactory;
import com.rada.player.PlaybackManager;
import com.rada.player.PlaybackService;
import com.rada.ui.MainActivity;
import com.rada.ui.MainActivity_MembersInjector;
import com.rada.ui.library.LibraryViewModel;
import com.rada.ui.library.LibraryViewModel_HiltModules;
import com.rada.ui.player.NowPlayingViewModel;
import com.rada.ui.player.NowPlayingViewModel_HiltModules;
import com.rada.ui.player.PlayerViewModel;
import com.rada.ui.player.PlayerViewModel_HiltModules;
import com.rada.ui.playlists.PlaylistManagerViewModel;
import com.rada.ui.playlists.PlaylistManagerViewModel_HiltModules;
import com.rada.ui.stations.StationBrowserViewModel;
import com.rada.ui.stations.StationBrowserViewModel_HiltModules;
import com.rada.ui.streams.StreamsViewModel;
import com.rada.ui.streams.StreamsViewModel_HiltModules;
import dagger.hilt.android.ActivityRetainedLifecycle;
import dagger.hilt.android.ViewModelLifecycle;
import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
import dagger.hilt.android.internal.builders.ViewComponentBuilder;
import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories_InternalFactoryFactory_Factory;
import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory;
import dagger.hilt.android.internal.managers.SavedStateHandleHolder;
import dagger.hilt.android.internal.modules.ApplicationContextModule;
import dagger.hilt.android.internal.modules.ApplicationContextModule_ProvideContextFactory;
import dagger.internal.DaggerGenerated;
import dagger.internal.DoubleCheck;
import dagger.internal.IdentifierNameString;
import dagger.internal.KeepFieldType;
import dagger.internal.LazyClassKeyMap;
import dagger.internal.Preconditions;
import dagger.internal.Provider;
import java.util.Map;
import java.util.Set;
import javax.annotation.processing.Generated;
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class DaggerRadAmpApp_HiltComponents_SingletonC {
private DaggerRadAmpApp_HiltComponents_SingletonC() {
}
public static Builder builder() {
return new Builder();
}
public static final class Builder {
private ApplicationContextModule applicationContextModule;
private Builder() {
}
public Builder applicationContextModule(ApplicationContextModule applicationContextModule) {
this.applicationContextModule = Preconditions.checkNotNull(applicationContextModule);
return this;
}
public RadAmpApp_HiltComponents.SingletonC build() {
Preconditions.checkBuilderRequirement(applicationContextModule, ApplicationContextModule.class);
return new SingletonCImpl(applicationContextModule);
}
}
private static final class ActivityRetainedCBuilder implements RadAmpApp_HiltComponents.ActivityRetainedC.Builder {
private final SingletonCImpl singletonCImpl;
private SavedStateHandleHolder savedStateHandleHolder;
private ActivityRetainedCBuilder(SingletonCImpl singletonCImpl) {
this.singletonCImpl = singletonCImpl;
}
@Override
public ActivityRetainedCBuilder savedStateHandleHolder(
SavedStateHandleHolder savedStateHandleHolder) {
this.savedStateHandleHolder = Preconditions.checkNotNull(savedStateHandleHolder);
return this;
}
@Override
public RadAmpApp_HiltComponents.ActivityRetainedC build() {
Preconditions.checkBuilderRequirement(savedStateHandleHolder, SavedStateHandleHolder.class);
return new ActivityRetainedCImpl(singletonCImpl, savedStateHandleHolder);
}
}
private static final class ActivityCBuilder implements RadAmpApp_HiltComponents.ActivityC.Builder {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private Activity activity;
private ActivityCBuilder(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
}
@Override
public ActivityCBuilder activity(Activity activity) {
this.activity = Preconditions.checkNotNull(activity);
return this;
}
@Override
public RadAmpApp_HiltComponents.ActivityC build() {
Preconditions.checkBuilderRequirement(activity, Activity.class);
return new ActivityCImpl(singletonCImpl, activityRetainedCImpl, activity);
}
}
private static final class FragmentCBuilder implements RadAmpApp_HiltComponents.FragmentC.Builder {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private Fragment fragment;
private FragmentCBuilder(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
}
@Override
public FragmentCBuilder fragment(Fragment fragment) {
this.fragment = Preconditions.checkNotNull(fragment);
return this;
}
@Override
public RadAmpApp_HiltComponents.FragmentC build() {
Preconditions.checkBuilderRequirement(fragment, Fragment.class);
return new FragmentCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, fragment);
}
}
private static final class ViewWithFragmentCBuilder implements RadAmpApp_HiltComponents.ViewWithFragmentC.Builder {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private final FragmentCImpl fragmentCImpl;
private View view;
private ViewWithFragmentCBuilder(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl,
FragmentCImpl fragmentCImpl) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
this.fragmentCImpl = fragmentCImpl;
}
@Override
public ViewWithFragmentCBuilder view(View view) {
this.view = Preconditions.checkNotNull(view);
return this;
}
@Override
public RadAmpApp_HiltComponents.ViewWithFragmentC build() {
Preconditions.checkBuilderRequirement(view, View.class);
return new ViewWithFragmentCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, fragmentCImpl, view);
}
}
private static final class ViewCBuilder implements RadAmpApp_HiltComponents.ViewC.Builder {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private View view;
private ViewCBuilder(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
ActivityCImpl activityCImpl) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
}
@Override
public ViewCBuilder view(View view) {
this.view = Preconditions.checkNotNull(view);
return this;
}
@Override
public RadAmpApp_HiltComponents.ViewC build() {
Preconditions.checkBuilderRequirement(view, View.class);
return new ViewCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, view);
}
}
private static final class ViewModelCBuilder implements RadAmpApp_HiltComponents.ViewModelC.Builder {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private SavedStateHandle savedStateHandle;
private ViewModelLifecycle viewModelLifecycle;
private ViewModelCBuilder(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
}
@Override
public ViewModelCBuilder savedStateHandle(SavedStateHandle handle) {
this.savedStateHandle = Preconditions.checkNotNull(handle);
return this;
}
@Override
public ViewModelCBuilder viewModelLifecycle(ViewModelLifecycle viewModelLifecycle) {
this.viewModelLifecycle = Preconditions.checkNotNull(viewModelLifecycle);
return this;
}
@Override
public RadAmpApp_HiltComponents.ViewModelC build() {
Preconditions.checkBuilderRequirement(savedStateHandle, SavedStateHandle.class);
Preconditions.checkBuilderRequirement(viewModelLifecycle, ViewModelLifecycle.class);
return new ViewModelCImpl(singletonCImpl, activityRetainedCImpl, savedStateHandle, viewModelLifecycle);
}
}
private static final class ServiceCBuilder implements RadAmpApp_HiltComponents.ServiceC.Builder {
private final SingletonCImpl singletonCImpl;
private Service service;
private ServiceCBuilder(SingletonCImpl singletonCImpl) {
this.singletonCImpl = singletonCImpl;
}
@Override
public ServiceCBuilder service(Service service) {
this.service = Preconditions.checkNotNull(service);
return this;
}
@Override
public RadAmpApp_HiltComponents.ServiceC build() {
Preconditions.checkBuilderRequirement(service, Service.class);
return new ServiceCImpl(singletonCImpl, service);
}
}
private static final class ViewWithFragmentCImpl extends RadAmpApp_HiltComponents.ViewWithFragmentC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private final FragmentCImpl fragmentCImpl;
private final ViewWithFragmentCImpl viewWithFragmentCImpl = this;
private ViewWithFragmentCImpl(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl,
FragmentCImpl fragmentCImpl, View viewParam) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
this.fragmentCImpl = fragmentCImpl;
}
}
private static final class FragmentCImpl extends RadAmpApp_HiltComponents.FragmentC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private final FragmentCImpl fragmentCImpl = this;
private FragmentCImpl(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl,
Fragment fragmentParam) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
}
@Override
public DefaultViewModelFactories.InternalFactoryFactory getHiltInternalFactoryFactory() {
return activityCImpl.getHiltInternalFactoryFactory();
}
@Override
public ViewWithFragmentComponentBuilder viewWithFragmentComponentBuilder() {
return new ViewWithFragmentCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl, fragmentCImpl);
}
}
private static final class ViewCImpl extends RadAmpApp_HiltComponents.ViewC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl;
private final ViewCImpl viewCImpl = this;
private ViewCImpl(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
ActivityCImpl activityCImpl, View viewParam) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.activityCImpl = activityCImpl;
}
}
private static final class ActivityCImpl extends RadAmpApp_HiltComponents.ActivityC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ActivityCImpl activityCImpl = this;
private ActivityCImpl(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, Activity activityParam) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
}
@Override
public void injectMainActivity(MainActivity mainActivity) {
injectMainActivity2(mainActivity);
}
@Override
public DefaultViewModelFactories.InternalFactoryFactory getHiltInternalFactoryFactory() {
return DefaultViewModelFactories_InternalFactoryFactory_Factory.newInstance(getViewModelKeys(), new ViewModelCBuilder(singletonCImpl, activityRetainedCImpl));
}
@Override
public Map<Class<?>, Boolean> getViewModelKeys() {
return LazyClassKeyMap.<Boolean>of(ImmutableMap.<String, Boolean>builderWithExpectedSize(6).put(LazyClassKeyProvider.com_rada_ui_library_LibraryViewModel, LibraryViewModel_HiltModules.KeyModule.provide()).put(LazyClassKeyProvider.com_rada_ui_player_NowPlayingViewModel, NowPlayingViewModel_HiltModules.KeyModule.provide()).put(LazyClassKeyProvider.com_rada_ui_player_PlayerViewModel, PlayerViewModel_HiltModules.KeyModule.provide()).put(LazyClassKeyProvider.com_rada_ui_playlists_PlaylistManagerViewModel, PlaylistManagerViewModel_HiltModules.KeyModule.provide()).put(LazyClassKeyProvider.com_rada_ui_stations_StationBrowserViewModel, StationBrowserViewModel_HiltModules.KeyModule.provide()).put(LazyClassKeyProvider.com_rada_ui_streams_StreamsViewModel, StreamsViewModel_HiltModules.KeyModule.provide()).build());
}
@Override
public ViewModelComponentBuilder getViewModelComponentBuilder() {
return new ViewModelCBuilder(singletonCImpl, activityRetainedCImpl);
}
@Override
public FragmentComponentBuilder fragmentComponentBuilder() {
return new FragmentCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl);
}
@Override
public ViewComponentBuilder viewComponentBuilder() {
return new ViewCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl);
}
private MainActivity injectMainActivity2(MainActivity instance) {
MainActivity_MembersInjector.injectPlaybackManager(instance, singletonCImpl.providePlaybackManagerProvider.get());
return instance;
}
@IdentifierNameString
private static final class LazyClassKeyProvider {
static String com_rada_ui_player_NowPlayingViewModel = "com.rada.ui.player.NowPlayingViewModel";
static String com_rada_ui_player_PlayerViewModel = "com.rada.ui.player.PlayerViewModel";
static String com_rada_ui_streams_StreamsViewModel = "com.rada.ui.streams.StreamsViewModel";
static String com_rada_ui_library_LibraryViewModel = "com.rada.ui.library.LibraryViewModel";
static String com_rada_ui_stations_StationBrowserViewModel = "com.rada.ui.stations.StationBrowserViewModel";
static String com_rada_ui_playlists_PlaylistManagerViewModel = "com.rada.ui.playlists.PlaylistManagerViewModel";
@KeepFieldType
NowPlayingViewModel com_rada_ui_player_NowPlayingViewModel2;
@KeepFieldType
PlayerViewModel com_rada_ui_player_PlayerViewModel2;
@KeepFieldType
StreamsViewModel com_rada_ui_streams_StreamsViewModel2;
@KeepFieldType
LibraryViewModel com_rada_ui_library_LibraryViewModel2;
@KeepFieldType
StationBrowserViewModel com_rada_ui_stations_StationBrowserViewModel2;
@KeepFieldType
PlaylistManagerViewModel com_rada_ui_playlists_PlaylistManagerViewModel2;
}
}
private static final class ViewModelCImpl extends RadAmpApp_HiltComponents.ViewModelC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ViewModelCImpl viewModelCImpl = this;
private Provider<LibraryViewModel> libraryViewModelProvider;
private Provider<NowPlayingViewModel> nowPlayingViewModelProvider;
private Provider<PlayerViewModel> playerViewModelProvider;
private Provider<PlaylistManagerViewModel> playlistManagerViewModelProvider;
private Provider<StationBrowserViewModel> stationBrowserViewModelProvider;
private Provider<StreamsViewModel> streamsViewModelProvider;
private ViewModelCImpl(SingletonCImpl singletonCImpl,
ActivityRetainedCImpl activityRetainedCImpl, SavedStateHandle savedStateHandleParam,
ViewModelLifecycle viewModelLifecycleParam) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
initialize(savedStateHandleParam, viewModelLifecycleParam);
}
@SuppressWarnings("unchecked")
private void initialize(final SavedStateHandle savedStateHandleParam,
final ViewModelLifecycle viewModelLifecycleParam) {
this.libraryViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 0);
this.nowPlayingViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 1);
this.playerViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 2);
this.playlistManagerViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 3);
this.stationBrowserViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 4);
this.streamsViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 5);
}
@Override
public Map<Class<?>, javax.inject.Provider<ViewModel>> getHiltViewModelMap() {
return LazyClassKeyMap.<javax.inject.Provider<ViewModel>>of(ImmutableMap.<String, javax.inject.Provider<ViewModel>>builderWithExpectedSize(6).put(LazyClassKeyProvider.com_rada_ui_library_LibraryViewModel, ((Provider) libraryViewModelProvider)).put(LazyClassKeyProvider.com_rada_ui_player_NowPlayingViewModel, ((Provider) nowPlayingViewModelProvider)).put(LazyClassKeyProvider.com_rada_ui_player_PlayerViewModel, ((Provider) playerViewModelProvider)).put(LazyClassKeyProvider.com_rada_ui_playlists_PlaylistManagerViewModel, ((Provider) playlistManagerViewModelProvider)).put(LazyClassKeyProvider.com_rada_ui_stations_StationBrowserViewModel, ((Provider) stationBrowserViewModelProvider)).put(LazyClassKeyProvider.com_rada_ui_streams_StreamsViewModel, ((Provider) streamsViewModelProvider)).build());
}
@Override
public Map<Class<?>, Object> getHiltViewModelAssistedMap() {
return ImmutableMap.<Class<?>, Object>of();
}
@IdentifierNameString
private static final class LazyClassKeyProvider {
static String com_rada_ui_stations_StationBrowserViewModel = "com.rada.ui.stations.StationBrowserViewModel";
static String com_rada_ui_player_PlayerViewModel = "com.rada.ui.player.PlayerViewModel";
static String com_rada_ui_library_LibraryViewModel = "com.rada.ui.library.LibraryViewModel";
static String com_rada_ui_playlists_PlaylistManagerViewModel = "com.rada.ui.playlists.PlaylistManagerViewModel";
static String com_rada_ui_streams_StreamsViewModel = "com.rada.ui.streams.StreamsViewModel";
static String com_rada_ui_player_NowPlayingViewModel = "com.rada.ui.player.NowPlayingViewModel";
@KeepFieldType
StationBrowserViewModel com_rada_ui_stations_StationBrowserViewModel2;
@KeepFieldType
PlayerViewModel com_rada_ui_player_PlayerViewModel2;
@KeepFieldType
LibraryViewModel com_rada_ui_library_LibraryViewModel2;
@KeepFieldType
PlaylistManagerViewModel com_rada_ui_playlists_PlaylistManagerViewModel2;
@KeepFieldType
StreamsViewModel com_rada_ui_streams_StreamsViewModel2;
@KeepFieldType
NowPlayingViewModel com_rada_ui_player_NowPlayingViewModel2;
}
private static final class SwitchingProvider<T> implements Provider<T> {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final ViewModelCImpl viewModelCImpl;
private final int id;
SwitchingProvider(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
ViewModelCImpl viewModelCImpl, int id) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.viewModelCImpl = viewModelCImpl;
this.id = id;
}
@SuppressWarnings("unchecked")
@Override
public T get() {
switch (id) {
case 0: // com.rada.ui.library.LibraryViewModel
return (T) new LibraryViewModel(singletonCImpl.provideLibraryRepositoryProvider.get(), singletonCImpl.providePlaylistRepositoryProvider.get(), singletonCImpl.providePlaybackManagerProvider.get());
case 1: // com.rada.ui.player.NowPlayingViewModel
return (T) new NowPlayingViewModel(singletonCImpl.providePlaybackManagerProvider.get());
case 2: // com.rada.ui.player.PlayerViewModel
return (T) new PlayerViewModel(singletonCImpl.providePlaybackManagerProvider.get(), singletonCImpl.provideStationRepositoryProvider.get(), singletonCImpl.providePlaylistRepositoryProvider.get());
case 3: // com.rada.ui.playlists.PlaylistManagerViewModel
return (T) new PlaylistManagerViewModel(singletonCImpl.providePlaylistRepositoryProvider.get());
case 4: // com.rada.ui.stations.StationBrowserViewModel
return (T) new StationBrowserViewModel(singletonCImpl.provideStationRepositoryProvider.get(), singletonCImpl.providePlaybackManagerProvider.get());
case 5: // com.rada.ui.streams.StreamsViewModel
return (T) new StreamsViewModel(singletonCImpl.streamRepositoryProvider.get(), singletonCImpl.streamFetcherProvider.get(), singletonCImpl.providePlaybackManagerProvider.get());
default: throw new AssertionError(id);
}
}
}
}
private static final class ActivityRetainedCImpl extends RadAmpApp_HiltComponents.ActivityRetainedC {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl = this;
private Provider<ActivityRetainedLifecycle> provideActivityRetainedLifecycleProvider;
private ActivityRetainedCImpl(SingletonCImpl singletonCImpl,
SavedStateHandleHolder savedStateHandleHolderParam) {
this.singletonCImpl = singletonCImpl;
initialize(savedStateHandleHolderParam);
}
@SuppressWarnings("unchecked")
private void initialize(final SavedStateHandleHolder savedStateHandleHolderParam) {
this.provideActivityRetainedLifecycleProvider = DoubleCheck.provider(new SwitchingProvider<ActivityRetainedLifecycle>(singletonCImpl, activityRetainedCImpl, 0));
}
@Override
public ActivityComponentBuilder activityComponentBuilder() {
return new ActivityCBuilder(singletonCImpl, activityRetainedCImpl);
}
@Override
public ActivityRetainedLifecycle getActivityRetainedLifecycle() {
return provideActivityRetainedLifecycleProvider.get();
}
private static final class SwitchingProvider<T> implements Provider<T> {
private final SingletonCImpl singletonCImpl;
private final ActivityRetainedCImpl activityRetainedCImpl;
private final int id;
SwitchingProvider(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
int id) {
this.singletonCImpl = singletonCImpl;
this.activityRetainedCImpl = activityRetainedCImpl;
this.id = id;
}
@SuppressWarnings("unchecked")
@Override
public T get() {
switch (id) {
case 0: // dagger.hilt.android.ActivityRetainedLifecycle
return (T) ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory.provideActivityRetainedLifecycle();
default: throw new AssertionError(id);
}
}
}
}
private static final class ServiceCImpl extends RadAmpApp_HiltComponents.ServiceC {
private final SingletonCImpl singletonCImpl;
private final ServiceCImpl serviceCImpl = this;
private ServiceCImpl(SingletonCImpl singletonCImpl, Service serviceParam) {
this.singletonCImpl = singletonCImpl;
}
@Override
public void injectPlaybackService(PlaybackService playbackService) {
}
}
private static final class SingletonCImpl extends RadAmpApp_HiltComponents.SingletonC {
private final ApplicationContextModule applicationContextModule;
private final SingletonCImpl singletonCImpl = this;
private Provider<RadAmpDatabase> provideDatabaseProvider;
private Provider<SavedSongDao> provideSavedSongDaoProvider;
private Provider<LibraryRepository> provideLibraryRepositoryProvider;
private Provider<PlaybackManager> providePlaybackManagerProvider;
private Provider<PlaylistDao> providePlaylistDaoProvider;
private Provider<PlaylistRepository> providePlaylistRepositoryProvider;
private Provider<StationRepository> provideStationRepositoryProvider;
private Provider<StreamRepository> streamRepositoryProvider;
private Provider<StreamFetcher> streamFetcherProvider;
private SingletonCImpl(ApplicationContextModule applicationContextModuleParam) {
this.applicationContextModule = applicationContextModuleParam;
initialize(applicationContextModuleParam);
}
@SuppressWarnings("unchecked")
private void initialize(final ApplicationContextModule applicationContextModuleParam) {
this.provideDatabaseProvider = DoubleCheck.provider(new SwitchingProvider<RadAmpDatabase>(singletonCImpl, 3));
this.provideSavedSongDaoProvider = DoubleCheck.provider(new SwitchingProvider<SavedSongDao>(singletonCImpl, 2));
this.provideLibraryRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<LibraryRepository>(singletonCImpl, 1));
this.providePlaybackManagerProvider = DoubleCheck.provider(new SwitchingProvider<PlaybackManager>(singletonCImpl, 0));
this.providePlaylistDaoProvider = DoubleCheck.provider(new SwitchingProvider<PlaylistDao>(singletonCImpl, 5));
this.providePlaylistRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<PlaylistRepository>(singletonCImpl, 4));
this.provideStationRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<StationRepository>(singletonCImpl, 6));
this.streamRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<StreamRepository>(singletonCImpl, 7));
this.streamFetcherProvider = DoubleCheck.provider(new SwitchingProvider<StreamFetcher>(singletonCImpl, 8));
}
@Override
public void injectRadAmpApp(RadAmpApp radAmpApp) {
}
@Override
public Set<Boolean> getDisableFragmentGetContextFix() {
return ImmutableSet.<Boolean>of();
}
@Override
public ActivityRetainedComponentBuilder retainedComponentBuilder() {
return new ActivityRetainedCBuilder(singletonCImpl);
}
@Override
public ServiceComponentBuilder serviceComponentBuilder() {
return new ServiceCBuilder(singletonCImpl);
}
private static final class SwitchingProvider<T> implements Provider<T> {
private final SingletonCImpl singletonCImpl;
private final int id;
SwitchingProvider(SingletonCImpl singletonCImpl, int id) {
this.singletonCImpl = singletonCImpl;
this.id = id;
}
@SuppressWarnings("unchecked")
@Override
public T get() {
switch (id) {
case 0: // com.rada.player.PlaybackManager
return (T) AppModule_ProvidePlaybackManagerFactory.providePlaybackManager(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule), singletonCImpl.provideLibraryRepositoryProvider.get());
case 1: // com.rada.data.repository.LibraryRepository
return (T) AppModule_ProvideLibraryRepositoryFactory.provideLibraryRepository(singletonCImpl.provideSavedSongDaoProvider.get());
case 2: // com.rada.data.local.dao.SavedSongDao
return (T) AppModule_ProvideSavedSongDaoFactory.provideSavedSongDao(singletonCImpl.provideDatabaseProvider.get());
case 3: // com.rada.data.local.RadAmpDatabase
return (T) AppModule_ProvideDatabaseFactory.provideDatabase(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
case 4: // com.rada.data.repository.PlaylistRepository
return (T) AppModule_ProvidePlaylistRepositoryFactory.providePlaylistRepository(singletonCImpl.providePlaylistDaoProvider.get());
case 5: // com.rada.data.local.dao.PlaylistDao
return (T) AppModule_ProvidePlaylistDaoFactory.providePlaylistDao(singletonCImpl.provideDatabaseProvider.get());
case 6: // com.rada.data.repository.StationRepository
return (T) AppModule_ProvideStationRepositoryFactory.provideStationRepository(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
case 7: // com.rada.data.repository.StreamRepository
return (T) new StreamRepository(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
case 8: // com.rada.data.repository.StreamFetcher
return (T) new StreamFetcher();
default: throw new AssertionError(id);
}
}
}
}
}

View file

@ -0,0 +1,54 @@
package com.rada;
import android.app.Application;
import androidx.annotation.CallSuper;
import dagger.hilt.android.internal.managers.ApplicationComponentManager;
import dagger.hilt.android.internal.managers.ComponentSupplier;
import dagger.hilt.android.internal.modules.ApplicationContextModule;
import dagger.hilt.internal.GeneratedComponentManagerHolder;
import dagger.hilt.internal.UnsafeCasts;
import java.lang.Object;
import java.lang.Override;
import javax.annotation.processing.Generated;
/**
* A generated base class to be extended by the @dagger.hilt.android.HiltAndroidApp annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
*/
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ApplicationGenerator")
public abstract class Hilt_RadAmpApp extends Application implements GeneratedComponentManagerHolder {
private boolean injected = false;
private final ApplicationComponentManager componentManager = new ApplicationComponentManager(new ComponentSupplier() {
@Override
public Object get() {
return DaggerRadAmpApp_HiltComponents_SingletonC.builder()
.applicationContextModule(new ApplicationContextModule(Hilt_RadAmpApp.this)).build();
}
});
@Override
public final ApplicationComponentManager componentManager() {
return componentManager;
}
@Override
public final Object generatedComponent() {
return this.componentManager().generatedComponent();
}
@CallSuper
@Override
public void onCreate() {
hiltInternalInject();
super.onCreate();
}
protected void hiltInternalInject() {
if (!injected) {
injected = true;
// This is a known unsafe cast, but is safe in the only correct use case:
// RadAmpApp extends Hilt_RadAmpApp
((RadAmpApp_GeneratedInjector) generatedComponent()).injectRadAmpApp(UnsafeCasts.<RadAmpApp>unsafeCast(this));
}
}
}

View file

@ -0,0 +1,17 @@
package com.rada;
import dagger.hilt.InstallIn;
import dagger.hilt.codegen.OriginatingElement;
import dagger.hilt.components.SingletonComponent;
import dagger.hilt.internal.GeneratedEntryPoint;
import javax.annotation.processing.Generated;
@OriginatingElement(
topLevelClass = RadAmpApp.class
)
@GeneratedEntryPoint
@InstallIn(SingletonComponent.class)
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
public interface RadAmpApp_GeneratedInjector {
void injectRadAmpApp(RadAmpApp radAmpApp);
}

View file

@ -0,0 +1,257 @@
package com.rada;
import com.rada.di.AppModule;
import com.rada.player.PlaybackService_GeneratedInjector;
import com.rada.ui.MainActivity_GeneratedInjector;
import com.rada.ui.library.LibraryViewModel_HiltModules;
import com.rada.ui.player.NowPlayingViewModel_HiltModules;
import com.rada.ui.player.PlayerViewModel_HiltModules;
import com.rada.ui.playlists.PlaylistManagerViewModel_HiltModules;
import com.rada.ui.stations.StationBrowserViewModel_HiltModules;
import com.rada.ui.streams.StreamsViewModel_HiltModules;
import dagger.Binds;
import dagger.Component;
import dagger.Module;
import dagger.Subcomponent;
import dagger.hilt.android.components.ActivityComponent;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.FragmentComponent;
import dagger.hilt.android.components.ServiceComponent;
import dagger.hilt.android.components.ViewComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.components.ViewWithFragmentComponent;
import dagger.hilt.android.flags.FragmentGetContextFix;
import dagger.hilt.android.flags.HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule;
import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
import dagger.hilt.android.internal.builders.ViewComponentBuilder;
import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
import dagger.hilt.android.internal.lifecycle.HiltViewModelFactory;
import dagger.hilt.android.internal.lifecycle.HiltWrapper_DefaultViewModelFactories_ActivityModule;
import dagger.hilt.android.internal.lifecycle.HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint;
import dagger.hilt.android.internal.lifecycle.HiltWrapper_HiltViewModelFactory_ViewModelModule;
import dagger.hilt.android.internal.managers.ActivityComponentManager;
import dagger.hilt.android.internal.managers.FragmentComponentManager;
import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint;
import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint;
import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_LifecycleModule;
import dagger.hilt.android.internal.managers.HiltWrapper_SavedStateHandleModule;
import dagger.hilt.android.internal.managers.ServiceComponentManager;
import dagger.hilt.android.internal.managers.ViewComponentManager;
import dagger.hilt.android.internal.modules.ApplicationContextModule;
import dagger.hilt.android.internal.modules.HiltWrapper_ActivityModule;
import dagger.hilt.android.scopes.ActivityRetainedScoped;
import dagger.hilt.android.scopes.ActivityScoped;
import dagger.hilt.android.scopes.FragmentScoped;
import dagger.hilt.android.scopes.ServiceScoped;
import dagger.hilt.android.scopes.ViewModelScoped;
import dagger.hilt.android.scopes.ViewScoped;
import dagger.hilt.components.SingletonComponent;
import dagger.hilt.internal.GeneratedComponent;
import dagger.hilt.migration.DisableInstallInCheck;
import javax.annotation.processing.Generated;
import javax.inject.Singleton;
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
public final class RadAmpApp_HiltComponents {
private RadAmpApp_HiltComponents() {
}
@Module(
subcomponents = ServiceC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ServiceCBuilderModule {
@Binds
ServiceComponentBuilder bind(ServiceC.Builder builder);
}
@Module(
subcomponents = ActivityRetainedC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ActivityRetainedCBuilderModule {
@Binds
ActivityRetainedComponentBuilder bind(ActivityRetainedC.Builder builder);
}
@Module(
subcomponents = ActivityC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ActivityCBuilderModule {
@Binds
ActivityComponentBuilder bind(ActivityC.Builder builder);
}
@Module(
subcomponents = ViewModelC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ViewModelCBuilderModule {
@Binds
ViewModelComponentBuilder bind(ViewModelC.Builder builder);
}
@Module(
subcomponents = ViewC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ViewCBuilderModule {
@Binds
ViewComponentBuilder bind(ViewC.Builder builder);
}
@Module(
subcomponents = FragmentC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface FragmentCBuilderModule {
@Binds
FragmentComponentBuilder bind(FragmentC.Builder builder);
}
@Module(
subcomponents = ViewWithFragmentC.class
)
@DisableInstallInCheck
@Generated("dagger.hilt.processor.internal.root.RootProcessor")
abstract interface ViewWithFragmentCBuilderModule {
@Binds
ViewWithFragmentComponentBuilder bind(ViewWithFragmentC.Builder builder);
}
@Component(
modules = {
AppModule.class,
ApplicationContextModule.class,
HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule.class,
ActivityRetainedCBuilderModule.class,
ServiceCBuilderModule.class
}
)
@Singleton
public abstract static class SingletonC implements RadAmpApp_GeneratedInjector,
FragmentGetContextFix.FragmentGetContextFixEntryPoint,
HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint,
ServiceComponentManager.ServiceComponentBuilderEntryPoint,
SingletonComponent,
GeneratedComponent {
}
@Subcomponent
@ServiceScoped
public abstract static class ServiceC implements PlaybackService_GeneratedInjector,
ServiceComponent,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ServiceComponentBuilder {
}
}
@Subcomponent(
modules = {
HiltWrapper_ActivityRetainedComponentManager_LifecycleModule.class,
HiltWrapper_SavedStateHandleModule.class,
LibraryViewModel_HiltModules.KeyModule.class,
NowPlayingViewModel_HiltModules.KeyModule.class,
PlayerViewModel_HiltModules.KeyModule.class,
PlaylistManagerViewModel_HiltModules.KeyModule.class,
ActivityCBuilderModule.class,
ViewModelCBuilderModule.class,
StationBrowserViewModel_HiltModules.KeyModule.class,
StreamsViewModel_HiltModules.KeyModule.class
}
)
@ActivityRetainedScoped
public abstract static class ActivityRetainedC implements ActivityRetainedComponent,
ActivityComponentManager.ActivityComponentBuilderEntryPoint,
HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ActivityRetainedComponentBuilder {
}
}
@Subcomponent(
modules = {
HiltWrapper_ActivityModule.class,
HiltWrapper_DefaultViewModelFactories_ActivityModule.class,
FragmentCBuilderModule.class,
ViewCBuilderModule.class
}
)
@ActivityScoped
public abstract static class ActivityC implements MainActivity_GeneratedInjector,
ActivityComponent,
DefaultViewModelFactories.ActivityEntryPoint,
HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint,
FragmentComponentManager.FragmentComponentBuilderEntryPoint,
ViewComponentManager.ViewComponentBuilderEntryPoint,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ActivityComponentBuilder {
}
}
@Subcomponent(
modules = {
HiltWrapper_HiltViewModelFactory_ViewModelModule.class,
LibraryViewModel_HiltModules.BindsModule.class,
NowPlayingViewModel_HiltModules.BindsModule.class,
PlayerViewModel_HiltModules.BindsModule.class,
PlaylistManagerViewModel_HiltModules.BindsModule.class,
StationBrowserViewModel_HiltModules.BindsModule.class,
StreamsViewModel_HiltModules.BindsModule.class
}
)
@ViewModelScoped
public abstract static class ViewModelC implements ViewModelComponent,
HiltViewModelFactory.ViewModelFactoriesEntryPoint,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ViewModelComponentBuilder {
}
}
@Subcomponent
@ViewScoped
public abstract static class ViewC implements ViewComponent,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ViewComponentBuilder {
}
}
@Subcomponent(
modules = ViewWithFragmentCBuilderModule.class
)
@FragmentScoped
public abstract static class FragmentC implements FragmentComponent,
DefaultViewModelFactories.FragmentEntryPoint,
ViewComponentManager.ViewWithFragmentComponentBuilderEntryPoint,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends FragmentComponentBuilder {
}
}
@Subcomponent
@ViewScoped
public abstract static class ViewWithFragmentC implements ViewWithFragmentComponent,
GeneratedComponent {
@Subcomponent.Builder
abstract interface Builder extends ViewWithFragmentComponentBuilder {
}
}
}

View file

@ -0,0 +1,21 @@
package dagger.hilt.internal.aggregatedroot.codegen;
import dagger.hilt.android.HiltAndroidApp;
import dagger.hilt.internal.aggregatedroot.AggregatedRoot;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedRoot(
root = "com.rada.RadAmpApp",
rootPackage = "com.rada",
originatingRoot = "com.rada.RadAmpApp",
originatingRootPackage = "com.rada",
rootAnnotation = HiltAndroidApp.class,
rootSimpleNames = "RadAmpApp",
originatingRootSimpleNames = "RadAmpApp"
)
@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
public class _com_rada_RadAmpApp {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.components.SingletonComponent",
entryPoints = "com.rada.RadAmpApp_GeneratedInjector"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_RadAmpApp_GeneratedInjector {
}

View file

@ -0,0 +1,114 @@
package com.rada;
import dagger.hilt.internal.aggregatedroot.codegen._com_rada_RadAmpApp;
import dagger.hilt.internal.componenttreedeps.ComponentTreeDeps;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ActivityComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ActivityRetainedComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_FragmentComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ServiceComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewModelComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewWithFragmentComponent;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ActivityComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ActivityRetainedComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_FragmentComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ServiceComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewModelComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewWithFragmentComponentBuilder;
import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_components_SingletonComponent;
import hilt_aggregated_deps._com_rada_RadAmpApp_GeneratedInjector;
import hilt_aggregated_deps._com_rada_di_AppModule;
import hilt_aggregated_deps._com_rada_player_PlaybackService_GeneratedInjector;
import hilt_aggregated_deps._com_rada_ui_MainActivity_GeneratedInjector;
import hilt_aggregated_deps._com_rada_ui_library_LibraryViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_library_LibraryViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._com_rada_ui_player_NowPlayingViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_player_NowPlayingViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._com_rada_ui_player_PlayerViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_player_PlayerViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._com_rada_ui_stations_StationBrowserViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_stations_StationBrowserViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._com_rada_ui_streams_StreamsViewModel_HiltModules_BindsModule;
import hilt_aggregated_deps._com_rada_ui_streams_StreamsViewModel_HiltModules_KeyModule;
import hilt_aggregated_deps._dagger_hilt_android_flags_FragmentGetContextFix_FragmentGetContextFixEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_flags_HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_ActivityEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_FragmentEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltViewModelFactory_ViewModelFactoriesEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_DefaultViewModelFactories_ActivityModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ViewModelModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ActivityComponentManager_ActivityComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_FragmentComponentManager_FragmentComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_LifecycleModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_SavedStateHandleModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ServiceComponentManager_ServiceComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ViewComponentManager_ViewComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ViewComponentManager_ViewWithFragmentComponentBuilderEntryPoint;
import hilt_aggregated_deps._dagger_hilt_android_internal_modules_ApplicationContextModule;
import hilt_aggregated_deps._dagger_hilt_android_internal_modules_HiltWrapper_ActivityModule;
@ComponentTreeDeps(
rootDeps = _com_rada_RadAmpApp.class,
defineComponentDeps = {
_dagger_hilt_android_components_ActivityComponent.class,
_dagger_hilt_android_components_ActivityRetainedComponent.class,
_dagger_hilt_android_components_FragmentComponent.class,
_dagger_hilt_android_components_ServiceComponent.class,
_dagger_hilt_android_components_ViewComponent.class,
_dagger_hilt_android_components_ViewModelComponent.class,
_dagger_hilt_android_components_ViewWithFragmentComponent.class,
_dagger_hilt_android_internal_builders_ActivityComponentBuilder.class,
_dagger_hilt_android_internal_builders_ActivityRetainedComponentBuilder.class,
_dagger_hilt_android_internal_builders_FragmentComponentBuilder.class,
_dagger_hilt_android_internal_builders_ServiceComponentBuilder.class,
_dagger_hilt_android_internal_builders_ViewComponentBuilder.class,
_dagger_hilt_android_internal_builders_ViewModelComponentBuilder.class,
_dagger_hilt_android_internal_builders_ViewWithFragmentComponentBuilder.class,
_dagger_hilt_components_SingletonComponent.class
},
aggregatedDeps = {
_com_rada_RadAmpApp_GeneratedInjector.class,
_com_rada_di_AppModule.class,
_com_rada_player_PlaybackService_GeneratedInjector.class,
_com_rada_ui_MainActivity_GeneratedInjector.class,
_com_rada_ui_library_LibraryViewModel_HiltModules_BindsModule.class,
_com_rada_ui_library_LibraryViewModel_HiltModules_KeyModule.class,
_com_rada_ui_player_NowPlayingViewModel_HiltModules_BindsModule.class,
_com_rada_ui_player_NowPlayingViewModel_HiltModules_KeyModule.class,
_com_rada_ui_player_PlayerViewModel_HiltModules_BindsModule.class,
_com_rada_ui_player_PlayerViewModel_HiltModules_KeyModule.class,
_com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_BindsModule.class,
_com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_KeyModule.class,
_com_rada_ui_stations_StationBrowserViewModel_HiltModules_BindsModule.class,
_com_rada_ui_stations_StationBrowserViewModel_HiltModules_KeyModule.class,
_com_rada_ui_streams_StreamsViewModel_HiltModules_BindsModule.class,
_com_rada_ui_streams_StreamsViewModel_HiltModules_KeyModule.class,
_dagger_hilt_android_flags_FragmentGetContextFix_FragmentGetContextFixEntryPoint.class,
_dagger_hilt_android_flags_HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule.class,
_dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_ActivityEntryPoint.class,
_dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_FragmentEntryPoint.class,
_dagger_hilt_android_internal_lifecycle_HiltViewModelFactory_ViewModelFactoriesEntryPoint.class,
_dagger_hilt_android_internal_lifecycle_HiltWrapper_DefaultViewModelFactories_ActivityModule.class,
_dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint.class,
_dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ViewModelModule.class,
_dagger_hilt_android_internal_managers_ActivityComponentManager_ActivityComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_managers_FragmentComponentManager_FragmentComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint.class,
_dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_LifecycleModule.class,
_dagger_hilt_android_internal_managers_HiltWrapper_SavedStateHandleModule.class,
_dagger_hilt_android_internal_managers_ServiceComponentManager_ServiceComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_managers_ViewComponentManager_ViewComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_managers_ViewComponentManager_ViewWithFragmentComponentBuilderEntryPoint.class,
_dagger_hilt_android_internal_modules_ApplicationContextModule.class,
_dagger_hilt_android_internal_modules_HiltWrapper_ActivityModule.class
}
)
public final class RadAmpApp_ComponentTreeDeps {
}

View file

@ -0,0 +1,9 @@
package dagger.hilt.internal.processedrootsentinel.codegen;
import dagger.hilt.internal.processedrootsentinel.ProcessedRootSentinel;
@ProcessedRootSentinel(
roots = "com.rada.RadAmpApp"
)
public final class _com_rada_RadAmpApp {
}

View file

@ -0,0 +1,17 @@
package com.rada;
import dagger.hilt.InstallIn;
import dagger.hilt.codegen.OriginatingElement;
import dagger.hilt.components.SingletonComponent;
import dagger.hilt.internal.GeneratedEntryPoint;
import javax.annotation.processing.Generated;
@OriginatingElement(
topLevelClass = RadAmpApp.class
)
@GeneratedEntryPoint
@InstallIn(SingletonComponent.class)
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
public interface RadAmpApp_GeneratedInjector {
void injectRadAmpApp(RadAmpApp radAmpApp);
}

View file

@ -0,0 +1,45 @@
package com.rada.data.repository;
import com.rada.data.local.dao.SavedSongDao;
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("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class LibraryRepository_Factory implements Factory<LibraryRepository> {
private final Provider<SavedSongDao> savedSongDaoProvider;
public LibraryRepository_Factory(Provider<SavedSongDao> savedSongDaoProvider) {
this.savedSongDaoProvider = savedSongDaoProvider;
}
@Override
public LibraryRepository get() {
return newInstance(savedSongDaoProvider.get());
}
public static LibraryRepository_Factory create(Provider<SavedSongDao> savedSongDaoProvider) {
return new LibraryRepository_Factory(savedSongDaoProvider);
}
public static LibraryRepository newInstance(SavedSongDao savedSongDao) {
return new LibraryRepository(savedSongDao);
}
}

View file

@ -0,0 +1,45 @@
package com.rada.data.repository;
import com.rada.data.local.dao.PlaylistDao;
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("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class PlaylistRepository_Factory implements Factory<PlaylistRepository> {
private final Provider<PlaylistDao> playlistDaoProvider;
public PlaylistRepository_Factory(Provider<PlaylistDao> playlistDaoProvider) {
this.playlistDaoProvider = playlistDaoProvider;
}
@Override
public PlaylistRepository get() {
return newInstance(playlistDaoProvider.get());
}
public static PlaylistRepository_Factory create(Provider<PlaylistDao> playlistDaoProvider) {
return new PlaylistRepository_Factory(playlistDaoProvider);
}
public static PlaylistRepository newInstance(PlaylistDao playlistDao) {
return new PlaylistRepository(playlistDao);
}
}

View file

@ -0,0 +1,45 @@
package com.rada.data.repository;
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("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",
"deprecation"
})
public final class StationRepository_Factory implements Factory<StationRepository> {
private final Provider<Context> contextProvider;
public StationRepository_Factory(Provider<Context> contextProvider) {
this.contextProvider = contextProvider;
}
@Override
public StationRepository get() {
return newInstance(contextProvider.get());
}
public static StationRepository_Factory create(Provider<Context> contextProvider) {
return new StationRepository_Factory(contextProvider);
}
public static StationRepository newInstance(Context context) {
return new StationRepository(context);
}
}

View file

@ -0,0 +1,41 @@
package com.rada.data.repository;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata("javax.inject.Singleton")
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class StreamFetcher_Factory implements Factory<StreamFetcher> {
@Override
public StreamFetcher get() {
return newInstance();
}
public static StreamFetcher_Factory create() {
return InstanceHolder.INSTANCE;
}
public static StreamFetcher newInstance() {
return new StreamFetcher();
}
private static final class InstanceHolder {
private static final StreamFetcher_Factory INSTANCE = new StreamFetcher_Factory();
}
}

View file

@ -0,0 +1,45 @@
package com.rada.data.repository;
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("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",
"deprecation"
})
public final class StreamRepository_Factory implements Factory<StreamRepository> {
private final Provider<Context> contextProvider;
public StreamRepository_Factory(Provider<Context> contextProvider) {
this.contextProvider = contextProvider;
}
@Override
public StreamRepository get() {
return newInstance(contextProvider.get());
}
public static StreamRepository_Factory create(Provider<Context> contextProvider) {
return new StreamRepository_Factory(contextProvider);
}
public static StreamRepository newInstance(Context context) {
return new StreamRepository(context);
}
}

View file

@ -0,0 +1,47 @@
package com.rada.di;
import android.content.Context;
import com.rada.data.local.RadAmpDatabase;
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",
"deprecation"
})
public final class AppModule_ProvideDatabaseFactory implements Factory<RadAmpDatabase> {
private final Provider<Context> contextProvider;
public AppModule_ProvideDatabaseFactory(Provider<Context> contextProvider) {
this.contextProvider = contextProvider;
}
@Override
public RadAmpDatabase get() {
return provideDatabase(contextProvider.get());
}
public static AppModule_ProvideDatabaseFactory create(Provider<Context> contextProvider) {
return new AppModule_ProvideDatabaseFactory(contextProvider);
}
public static RadAmpDatabase provideDatabase(Context context) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideDatabase(context));
}
}

View file

@ -0,0 +1,48 @@
package com.rada.di;
import com.rada.data.local.dao.SavedSongDao;
import com.rada.data.repository.LibraryRepository;
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",
"deprecation"
})
public final class AppModule_ProvideLibraryRepositoryFactory implements Factory<LibraryRepository> {
private final Provider<SavedSongDao> savedSongDaoProvider;
public AppModule_ProvideLibraryRepositoryFactory(Provider<SavedSongDao> savedSongDaoProvider) {
this.savedSongDaoProvider = savedSongDaoProvider;
}
@Override
public LibraryRepository get() {
return provideLibraryRepository(savedSongDaoProvider.get());
}
public static AppModule_ProvideLibraryRepositoryFactory create(
Provider<SavedSongDao> savedSongDaoProvider) {
return new AppModule_ProvideLibraryRepositoryFactory(savedSongDaoProvider);
}
public static LibraryRepository provideLibraryRepository(SavedSongDao savedSongDao) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideLibraryRepository(savedSongDao));
}
}

View file

@ -0,0 +1,54 @@
package com.rada.di;
import android.content.Context;
import com.rada.data.repository.LibraryRepository;
import com.rada.player.PlaybackManager;
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",
"deprecation"
})
public final class AppModule_ProvidePlaybackManagerFactory implements Factory<PlaybackManager> {
private final Provider<Context> contextProvider;
private final Provider<LibraryRepository> libraryRepositoryProvider;
public AppModule_ProvidePlaybackManagerFactory(Provider<Context> contextProvider,
Provider<LibraryRepository> libraryRepositoryProvider) {
this.contextProvider = contextProvider;
this.libraryRepositoryProvider = libraryRepositoryProvider;
}
@Override
public PlaybackManager get() {
return providePlaybackManager(contextProvider.get(), libraryRepositoryProvider.get());
}
public static AppModule_ProvidePlaybackManagerFactory create(Provider<Context> contextProvider,
Provider<LibraryRepository> libraryRepositoryProvider) {
return new AppModule_ProvidePlaybackManagerFactory(contextProvider, libraryRepositoryProvider);
}
public static PlaybackManager providePlaybackManager(Context context,
LibraryRepository libraryRepository) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.providePlaybackManager(context, libraryRepository));
}
}

View file

@ -0,0 +1,48 @@
package com.rada.di;
import com.rada.data.local.RadAmpDatabase;
import com.rada.data.local.dao.PlaylistDao;
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",
"deprecation"
})
public final class AppModule_ProvidePlaylistDaoFactory implements Factory<PlaylistDao> {
private final Provider<RadAmpDatabase> databaseProvider;
public AppModule_ProvidePlaylistDaoFactory(Provider<RadAmpDatabase> databaseProvider) {
this.databaseProvider = databaseProvider;
}
@Override
public PlaylistDao get() {
return providePlaylistDao(databaseProvider.get());
}
public static AppModule_ProvidePlaylistDaoFactory create(
Provider<RadAmpDatabase> databaseProvider) {
return new AppModule_ProvidePlaylistDaoFactory(databaseProvider);
}
public static PlaylistDao providePlaylistDao(RadAmpDatabase database) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.providePlaylistDao(database));
}
}

View file

@ -0,0 +1,48 @@
package com.rada.di;
import com.rada.data.local.dao.PlaylistDao;
import com.rada.data.repository.PlaylistRepository;
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",
"deprecation"
})
public final class AppModule_ProvidePlaylistRepositoryFactory implements Factory<PlaylistRepository> {
private final Provider<PlaylistDao> playlistDaoProvider;
public AppModule_ProvidePlaylistRepositoryFactory(Provider<PlaylistDao> playlistDaoProvider) {
this.playlistDaoProvider = playlistDaoProvider;
}
@Override
public PlaylistRepository get() {
return providePlaylistRepository(playlistDaoProvider.get());
}
public static AppModule_ProvidePlaylistRepositoryFactory create(
Provider<PlaylistDao> playlistDaoProvider) {
return new AppModule_ProvidePlaylistRepositoryFactory(playlistDaoProvider);
}
public static PlaylistRepository providePlaylistRepository(PlaylistDao playlistDao) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.providePlaylistRepository(playlistDao));
}
}

View file

@ -0,0 +1,48 @@
package com.rada.di;
import com.rada.data.local.RadAmpDatabase;
import com.rada.data.local.dao.SavedSongDao;
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",
"deprecation"
})
public final class AppModule_ProvideSavedSongDaoFactory implements Factory<SavedSongDao> {
private final Provider<RadAmpDatabase> databaseProvider;
public AppModule_ProvideSavedSongDaoFactory(Provider<RadAmpDatabase> databaseProvider) {
this.databaseProvider = databaseProvider;
}
@Override
public SavedSongDao get() {
return provideSavedSongDao(databaseProvider.get());
}
public static AppModule_ProvideSavedSongDaoFactory create(
Provider<RadAmpDatabase> databaseProvider) {
return new AppModule_ProvideSavedSongDaoFactory(databaseProvider);
}
public static SavedSongDao provideSavedSongDao(RadAmpDatabase database) {
return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideSavedSongDao(database));
}
}

View file

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

View file

@ -0,0 +1,57 @@
package com.rada.player;
import androidx.annotation.CallSuper;
import androidx.media3.session.MediaSessionService;
import dagger.hilt.android.internal.managers.ServiceComponentManager;
import dagger.hilt.internal.GeneratedComponentManagerHolder;
import dagger.hilt.internal.UnsafeCasts;
import java.lang.Object;
import java.lang.Override;
import javax.annotation.processing.Generated;
/**
* A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
*/
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ServiceGenerator")
public abstract class Hilt_PlaybackService extends MediaSessionService implements GeneratedComponentManagerHolder {
private volatile ServiceComponentManager componentManager;
private final Object componentManagerLock = new Object();
private boolean injected = false;
@CallSuper
@Override
public void onCreate() {
inject();
super.onCreate();
}
protected ServiceComponentManager createComponentManager() {
return new ServiceComponentManager(this);
}
@Override
public final ServiceComponentManager componentManager() {
if (componentManager == null) {
synchronized (componentManagerLock) {
if (componentManager == null) {
componentManager = createComponentManager();
}
}
}
return componentManager;
}
protected void inject() {
if (!injected) {
injected = true;
((PlaybackService_GeneratedInjector) this.generatedComponent()).injectPlaybackService(UnsafeCasts.<PlaybackService>unsafeCast(this));
}
}
@Override
public final Object generatedComponent() {
return this.componentManager().generatedComponent();
}
}

View file

@ -0,0 +1,17 @@
package com.rada.player;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ServiceComponent;
import dagger.hilt.codegen.OriginatingElement;
import dagger.hilt.internal.GeneratedEntryPoint;
import javax.annotation.processing.Generated;
@OriginatingElement(
topLevelClass = PlaybackService.class
)
@GeneratedEntryPoint
@InstallIn(ServiceComponent.class)
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
public interface PlaybackService_GeneratedInjector {
void injectPlaybackService(PlaybackService playbackService);
}

View file

@ -0,0 +1,107 @@
package com.rada.ui;
import android.content.Context;
import android.os.Bundle;
import androidx.activity.ComponentActivity;
import androidx.activity.contextaware.OnContextAvailableListener;
import androidx.annotation.CallSuper;
import androidx.lifecycle.ViewModelProvider;
import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
import dagger.hilt.android.internal.managers.ActivityComponentManager;
import dagger.hilt.android.internal.managers.SavedStateHandleHolder;
import dagger.hilt.internal.GeneratedComponentManager;
import dagger.hilt.internal.GeneratedComponentManagerHolder;
import dagger.hilt.internal.UnsafeCasts;
import java.lang.Object;
import java.lang.Override;
import javax.annotation.processing.Generated;
/**
* A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
*/
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ActivityGenerator")
public abstract class Hilt_MainActivity extends ComponentActivity implements GeneratedComponentManagerHolder {
private SavedStateHandleHolder savedStateHandleHolder;
private volatile ActivityComponentManager componentManager;
private final Object componentManagerLock = new Object();
private boolean injected = false;
Hilt_MainActivity(int contentLayoutId) {
super(contentLayoutId);
_initHiltInternal();
}
Hilt_MainActivity() {
super();
_initHiltInternal();
}
private void _initHiltInternal() {
addOnContextAvailableListener(new OnContextAvailableListener() {
@Override
public void onContextAvailable(Context context) {
inject();
}
});
}
private void initSavedStateHandleHolder() {
if (getApplication() instanceof GeneratedComponentManager) {
savedStateHandleHolder = componentManager().getSavedStateHandleHolder();
if (savedStateHandleHolder.isInvalid()) {
savedStateHandleHolder.setExtras(getDefaultViewModelCreationExtras());
}
}
}
@CallSuper
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initSavedStateHandleHolder();
}
@Override
protected void onDestroy() {
super.onDestroy();
if (savedStateHandleHolder != null) {
savedStateHandleHolder.clear();
}
}
@Override
public final Object generatedComponent() {
return this.componentManager().generatedComponent();
}
protected ActivityComponentManager createComponentManager() {
return new ActivityComponentManager(this);
}
@Override
public final ActivityComponentManager componentManager() {
if (componentManager == null) {
synchronized (componentManagerLock) {
if (componentManager == null) {
componentManager = createComponentManager();
}
}
}
return componentManager;
}
protected void inject() {
if (!injected) {
injected = true;
((MainActivity_GeneratedInjector) this.generatedComponent()).injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
}
}
@Override
public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
return DefaultViewModelFactories.getActivityFactory(this, super.getDefaultViewModelProviderFactory());
}
}

View file

@ -0,0 +1,17 @@
package com.rada.ui;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityComponent;
import dagger.hilt.codegen.OriginatingElement;
import dagger.hilt.internal.GeneratedEntryPoint;
import javax.annotation.processing.Generated;
@OriginatingElement(
topLevelClass = MainActivity.class
)
@GeneratedEntryPoint
@InstallIn(ActivityComponent.class)
@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
public interface MainActivity_GeneratedInjector {
void injectMainActivity(MainActivity mainActivity);
}

View file

@ -0,0 +1,46 @@
package com.rada.ui;
import com.rada.player.PlaybackManager;
import dagger.MembersInjector;
import dagger.internal.DaggerGenerated;
import dagger.internal.InjectedFieldSignature;
import dagger.internal.QualifierMetadata;
import javax.annotation.processing.Generated;
import javax.inject.Provider;
@QualifierMetadata
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
private final Provider<PlaybackManager> playbackManagerProvider;
public MainActivity_MembersInjector(Provider<PlaybackManager> playbackManagerProvider) {
this.playbackManagerProvider = playbackManagerProvider;
}
public static MembersInjector<MainActivity> create(
Provider<PlaybackManager> playbackManagerProvider) {
return new MainActivity_MembersInjector(playbackManagerProvider);
}
@Override
public void injectMembers(MainActivity instance) {
injectPlaybackManager(instance, playbackManagerProvider.get());
}
@InjectedFieldSignature("com.rada.ui.MainActivity.playbackManager")
public static void injectPlaybackManager(MainActivity instance, PlaybackManager playbackManager) {
instance.playbackManager = playbackManager;
}
}

View file

@ -0,0 +1,59 @@
package com.rada.ui.library;
import com.rada.data.repository.LibraryRepository;
import com.rada.data.repository.PlaylistRepository;
import com.rada.player.PlaybackManager;
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",
"cast",
"deprecation"
})
public final class LibraryViewModel_Factory implements Factory<LibraryViewModel> {
private final Provider<LibraryRepository> libraryRepositoryProvider;
private final Provider<PlaylistRepository> playlistRepositoryProvider;
private final Provider<PlaybackManager> playbackManagerProvider;
public LibraryViewModel_Factory(Provider<LibraryRepository> libraryRepositoryProvider,
Provider<PlaylistRepository> playlistRepositoryProvider,
Provider<PlaybackManager> playbackManagerProvider) {
this.libraryRepositoryProvider = libraryRepositoryProvider;
this.playlistRepositoryProvider = playlistRepositoryProvider;
this.playbackManagerProvider = playbackManagerProvider;
}
@Override
public LibraryViewModel get() {
return newInstance(libraryRepositoryProvider.get(), playlistRepositoryProvider.get(), playbackManagerProvider.get());
}
public static LibraryViewModel_Factory create(
Provider<LibraryRepository> libraryRepositoryProvider,
Provider<PlaylistRepository> playlistRepositoryProvider,
Provider<PlaybackManager> playbackManagerProvider) {
return new LibraryViewModel_Factory(libraryRepositoryProvider, playlistRepositoryProvider, playbackManagerProvider);
}
public static LibraryViewModel newInstance(LibraryRepository libraryRepository,
PlaylistRepository playlistRepository, PlaybackManager playbackManager) {
return new LibraryViewModel(libraryRepository, playlistRepository, playbackManager);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.library;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = LibraryViewModel.class
)
public final class LibraryViewModel_HiltModules {
private LibraryViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(LibraryViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(LibraryViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(LibraryViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.library;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class LibraryViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static LibraryViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return LibraryViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final LibraryViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new LibraryViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,46 @@
package com.rada.ui.player;
import com.rada.player.PlaybackManager;
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",
"cast",
"deprecation"
})
public final class NowPlayingViewModel_Factory implements Factory<NowPlayingViewModel> {
private final Provider<PlaybackManager> playbackManagerProvider;
public NowPlayingViewModel_Factory(Provider<PlaybackManager> playbackManagerProvider) {
this.playbackManagerProvider = playbackManagerProvider;
}
@Override
public NowPlayingViewModel get() {
return newInstance(playbackManagerProvider.get());
}
public static NowPlayingViewModel_Factory create(
Provider<PlaybackManager> playbackManagerProvider) {
return new NowPlayingViewModel_Factory(playbackManagerProvider);
}
public static NowPlayingViewModel newInstance(PlaybackManager playbackManager) {
return new NowPlayingViewModel(playbackManager);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.player;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = NowPlayingViewModel.class
)
public final class NowPlayingViewModel_HiltModules {
private NowPlayingViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(NowPlayingViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(NowPlayingViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(NowPlayingViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.player;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class NowPlayingViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static NowPlayingViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return NowPlayingViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final NowPlayingViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new NowPlayingViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,58 @@
package com.rada.ui.player;
import com.rada.data.repository.PlaylistRepository;
import com.rada.data.repository.StationRepository;
import com.rada.player.PlaybackManager;
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",
"cast",
"deprecation"
})
public final class PlayerViewModel_Factory implements Factory<PlayerViewModel> {
private final Provider<PlaybackManager> playbackManagerProvider;
private final Provider<StationRepository> stationRepositoryProvider;
private final Provider<PlaylistRepository> playlistRepositoryProvider;
public PlayerViewModel_Factory(Provider<PlaybackManager> playbackManagerProvider,
Provider<StationRepository> stationRepositoryProvider,
Provider<PlaylistRepository> playlistRepositoryProvider) {
this.playbackManagerProvider = playbackManagerProvider;
this.stationRepositoryProvider = stationRepositoryProvider;
this.playlistRepositoryProvider = playlistRepositoryProvider;
}
@Override
public PlayerViewModel get() {
return newInstance(playbackManagerProvider.get(), stationRepositoryProvider.get(), playlistRepositoryProvider.get());
}
public static PlayerViewModel_Factory create(Provider<PlaybackManager> playbackManagerProvider,
Provider<StationRepository> stationRepositoryProvider,
Provider<PlaylistRepository> playlistRepositoryProvider) {
return new PlayerViewModel_Factory(playbackManagerProvider, stationRepositoryProvider, playlistRepositoryProvider);
}
public static PlayerViewModel newInstance(PlaybackManager playbackManager,
StationRepository stationRepository, PlaylistRepository playlistRepository) {
return new PlayerViewModel(playbackManager, stationRepository, playlistRepository);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.player;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = PlayerViewModel.class
)
public final class PlayerViewModel_HiltModules {
private PlayerViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(PlayerViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(PlayerViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(PlayerViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.player;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class PlayerViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static PlayerViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return PlayerViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final PlayerViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new PlayerViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,46 @@
package com.rada.ui.playlists;
import com.rada.data.repository.PlaylistRepository;
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",
"cast",
"deprecation"
})
public final class PlaylistManagerViewModel_Factory implements Factory<PlaylistManagerViewModel> {
private final Provider<PlaylistRepository> playlistRepositoryProvider;
public PlaylistManagerViewModel_Factory(Provider<PlaylistRepository> playlistRepositoryProvider) {
this.playlistRepositoryProvider = playlistRepositoryProvider;
}
@Override
public PlaylistManagerViewModel get() {
return newInstance(playlistRepositoryProvider.get());
}
public static PlaylistManagerViewModel_Factory create(
Provider<PlaylistRepository> playlistRepositoryProvider) {
return new PlaylistManagerViewModel_Factory(playlistRepositoryProvider);
}
public static PlaylistManagerViewModel newInstance(PlaylistRepository playlistRepository) {
return new PlaylistManagerViewModel(playlistRepository);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.playlists;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = PlaylistManagerViewModel.class
)
public final class PlaylistManagerViewModel_HiltModules {
private PlaylistManagerViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(PlaylistManagerViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(PlaylistManagerViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(PlaylistManagerViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.playlists;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class PlaylistManagerViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static PlaylistManagerViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return PlaylistManagerViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final PlaylistManagerViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new PlaylistManagerViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,53 @@
package com.rada.ui.stations;
import com.rada.data.repository.StationRepository;
import com.rada.player.PlaybackManager;
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",
"cast",
"deprecation"
})
public final class StationBrowserViewModel_Factory implements Factory<StationBrowserViewModel> {
private final Provider<StationRepository> stationRepositoryProvider;
private final Provider<PlaybackManager> playbackManagerProvider;
public StationBrowserViewModel_Factory(Provider<StationRepository> stationRepositoryProvider,
Provider<PlaybackManager> playbackManagerProvider) {
this.stationRepositoryProvider = stationRepositoryProvider;
this.playbackManagerProvider = playbackManagerProvider;
}
@Override
public StationBrowserViewModel get() {
return newInstance(stationRepositoryProvider.get(), playbackManagerProvider.get());
}
public static StationBrowserViewModel_Factory create(
Provider<StationRepository> stationRepositoryProvider,
Provider<PlaybackManager> playbackManagerProvider) {
return new StationBrowserViewModel_Factory(stationRepositoryProvider, playbackManagerProvider);
}
public static StationBrowserViewModel newInstance(StationRepository stationRepository,
PlaybackManager playbackManager) {
return new StationBrowserViewModel(stationRepository, playbackManager);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.stations;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = StationBrowserViewModel.class
)
public final class StationBrowserViewModel_HiltModules {
private StationBrowserViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(StationBrowserViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(StationBrowserViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(StationBrowserViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.stations;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class StationBrowserViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static StationBrowserViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return StationBrowserViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final StationBrowserViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new StationBrowserViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,58 @@
package com.rada.ui.streams;
import com.rada.data.repository.StreamFetcher;
import com.rada.data.repository.StreamRepository;
import com.rada.player.PlaybackManager;
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",
"cast",
"deprecation"
})
public final class StreamsViewModel_Factory implements Factory<StreamsViewModel> {
private final Provider<StreamRepository> streamRepositoryProvider;
private final Provider<StreamFetcher> streamFetcherProvider;
private final Provider<PlaybackManager> playbackManagerProvider;
public StreamsViewModel_Factory(Provider<StreamRepository> streamRepositoryProvider,
Provider<StreamFetcher> streamFetcherProvider,
Provider<PlaybackManager> playbackManagerProvider) {
this.streamRepositoryProvider = streamRepositoryProvider;
this.streamFetcherProvider = streamFetcherProvider;
this.playbackManagerProvider = playbackManagerProvider;
}
@Override
public StreamsViewModel get() {
return newInstance(streamRepositoryProvider.get(), streamFetcherProvider.get(), playbackManagerProvider.get());
}
public static StreamsViewModel_Factory create(Provider<StreamRepository> streamRepositoryProvider,
Provider<StreamFetcher> streamFetcherProvider,
Provider<PlaybackManager> playbackManagerProvider) {
return new StreamsViewModel_Factory(streamRepositoryProvider, streamFetcherProvider, playbackManagerProvider);
}
public static StreamsViewModel newInstance(StreamRepository streamRepository,
StreamFetcher streamFetcher, PlaybackManager playbackManager) {
return new StreamsViewModel(streamRepository, streamFetcher, playbackManager);
}
}

View file

@ -0,0 +1,51 @@
package com.rada.ui.streams;
import androidx.lifecycle.ViewModel;
import dagger.Binds;
import dagger.Module;
import dagger.Provides;
import dagger.hilt.InstallIn;
import dagger.hilt.android.components.ActivityRetainedComponent;
import dagger.hilt.android.components.ViewModelComponent;
import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
import dagger.hilt.codegen.OriginatingElement;
import dagger.multibindings.IntoMap;
import dagger.multibindings.LazyClassKey;
import javax.annotation.processing.Generated;
@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
@OriginatingElement(
topLevelClass = StreamsViewModel.class
)
public final class StreamsViewModel_HiltModules {
private StreamsViewModel_HiltModules() {
}
@Module
@InstallIn(ViewModelComponent.class)
public abstract static class BindsModule {
private BindsModule() {
}
@Binds
@IntoMap
@LazyClassKey(StreamsViewModel.class)
@HiltViewModelMap
public abstract ViewModel binds(StreamsViewModel vm);
}
@Module
@InstallIn(ActivityRetainedComponent.class)
public static final class KeyModule {
private KeyModule() {
}
@Provides
@IntoMap
@LazyClassKey(StreamsViewModel.class)
@HiltViewModelMap.KeySet
public static boolean provide() {
return true;
}
}
}

View file

@ -0,0 +1,41 @@
package com.rada.ui.streams;
import dagger.internal.DaggerGenerated;
import dagger.internal.Factory;
import dagger.internal.QualifierMetadata;
import dagger.internal.ScopeMetadata;
import javax.annotation.processing.Generated;
@ScopeMetadata
@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
@DaggerGenerated
@Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://dagger.dev"
)
@SuppressWarnings({
"unchecked",
"rawtypes",
"KotlinInternal",
"KotlinInternalInJava",
"cast",
"deprecation"
})
public final class StreamsViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
@Override
public Boolean get() {
return provide();
}
public static StreamsViewModel_HiltModules_KeyModule_ProvideFactory create() {
return InstanceHolder.INSTANCE;
}
public static boolean provide() {
return StreamsViewModel_HiltModules.KeyModule.provide();
}
private static final class InstanceHolder {
private static final StreamsViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new StreamsViewModel_HiltModules_KeyModule_ProvideFactory();
}
}

View file

@ -0,0 +1,21 @@
package dagger.hilt.internal.aggregatedroot.codegen;
import dagger.hilt.android.HiltAndroidApp;
import dagger.hilt.internal.aggregatedroot.AggregatedRoot;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedRoot(
root = "com.rada.RadAmpApp",
rootPackage = "com.rada",
originatingRoot = "com.rada.RadAmpApp",
originatingRootPackage = "com.rada",
rootAnnotation = HiltAndroidApp.class,
rootSimpleNames = "RadAmpApp",
originatingRootSimpleNames = "RadAmpApp"
)
@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
public class _com_rada_RadAmpApp {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.components.SingletonComponent",
entryPoints = "com.rada.RadAmpApp_GeneratedInjector"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_RadAmpApp_GeneratedInjector {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.components.SingletonComponent",
modules = "com.rada.di.AppModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_di_AppModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ServiceComponent",
entryPoints = "com.rada.player.PlaybackService_GeneratedInjector"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_player_PlaybackService_GeneratedInjector {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityComponent",
entryPoints = "com.rada.ui.MainActivity_GeneratedInjector"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_MainActivity_GeneratedInjector {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.library.LibraryViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_library_LibraryViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.library.LibraryViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_library_LibraryViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.player.NowPlayingViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_player_NowPlayingViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.player.NowPlayingViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_player_NowPlayingViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.player.PlayerViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_player_PlayerViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.player.PlayerViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_player_PlayerViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.playlists.PlaylistManagerViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.playlists.PlaylistManagerViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.stations.StationBrowserViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_stations_StationBrowserViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.stations.StationBrowserViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_stations_StationBrowserViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ViewModelComponent",
modules = "com.rada.ui.streams.StreamsViewModel_HiltModules.BindsModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_streams_StreamsViewModel_HiltModules_BindsModule {
}

View file

@ -0,0 +1,15 @@
package hilt_aggregated_deps;
import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
import javax.annotation.processing.Generated;
/**
* This class should only be referenced by generated code! This class aggregates information across multiple compilations.
*/
@AggregatedDeps(
components = "dagger.hilt.android.components.ActivityRetainedComponent",
modules = "com.rada.ui.streams.StreamsViewModel_HiltModules.KeyModule"
)
@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
public class _com_rada_ui_streams_StreamsViewModel_HiltModules_KeyModule {
}

View file

@ -0,0 +1,174 @@
package com.rada.`data`.local
import androidx.room.InvalidationTracker
import androidx.room.RoomOpenDelegate
import androidx.room.migration.AutoMigrationSpec
import androidx.room.migration.Migration
import androidx.room.util.TableInfo
import androidx.room.util.TableInfo.Companion.read
import androidx.room.util.dropFtsSyncTriggers
import androidx.sqlite.SQLiteConnection
import androidx.sqlite.execSQL
import com.rada.`data`.local.dao.PlaylistDao
import com.rada.`data`.local.dao.PlaylistDao_Impl
import com.rada.`data`.local.dao.SavedSongDao
import com.rada.`data`.local.dao.SavedSongDao_Impl
import javax.`annotation`.processing.Generated
import kotlin.Lazy
import kotlin.String
import kotlin.Suppress
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.collections.MutableList
import kotlin.collections.MutableMap
import kotlin.collections.MutableSet
import kotlin.collections.Set
import kotlin.collections.mutableListOf
import kotlin.collections.mutableMapOf
import kotlin.collections.mutableSetOf
import kotlin.reflect.KClass
@Generated(value = ["androidx.room.RoomProcessor"])
@Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
public class RadAmpDatabase_Impl : RadAmpDatabase() {
private val _savedSongDao: Lazy<SavedSongDao> = lazy {
SavedSongDao_Impl(this)
}
private val _playlistDao: Lazy<PlaylistDao> = lazy {
PlaylistDao_Impl(this)
}
protected override fun createOpenDelegate(): RoomOpenDelegate {
val _openDelegate: RoomOpenDelegate = object : RoomOpenDelegate(2, "2b79f413c32596106b95e2cb0d4db33a", "2bc2edc138f333d01b0a9415d4844fe5") {
public override fun createAllTables(connection: SQLiteConnection) {
connection.execSQL("CREATE TABLE IF NOT EXISTS `saved_songs` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `fileName` TEXT NOT NULL, `filePath` TEXT NOT NULL, `artist` TEXT NOT NULL, `title` TEXT NOT NULL, `album` TEXT NOT NULL, `stationName` TEXT NOT NULL, `durationMs` INTEGER NOT NULL, `fileSize` INTEGER NOT NULL, `format` TEXT NOT NULL, `dateSaved` INTEGER NOT NULL, `isFavorite` INTEGER NOT NULL)")
connection.execSQL("CREATE TABLE IF NOT EXISTS `playlists` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `createdAt` INTEGER NOT NULL)")
connection.execSQL("CREATE TABLE IF NOT EXISTS `playlist_songs` (`playlistId` INTEGER NOT NULL, `songId` INTEGER NOT NULL, `addedAt` INTEGER NOT NULL, PRIMARY KEY(`playlistId`, `songId`), FOREIGN KEY(`playlistId`) REFERENCES `playlists`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`songId`) REFERENCES `saved_songs`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )")
connection.execSQL("CREATE INDEX IF NOT EXISTS `index_playlist_songs_songId` ON `playlist_songs` (`songId`)")
connection.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)")
connection.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '2b79f413c32596106b95e2cb0d4db33a')")
}
public override fun dropAllTables(connection: SQLiteConnection) {
connection.execSQL("DROP TABLE IF EXISTS `saved_songs`")
connection.execSQL("DROP TABLE IF EXISTS `playlists`")
connection.execSQL("DROP TABLE IF EXISTS `playlist_songs`")
}
public override fun onCreate(connection: SQLiteConnection) {
}
public override fun onOpen(connection: SQLiteConnection) {
connection.execSQL("PRAGMA foreign_keys = ON")
internalInitInvalidationTracker(connection)
}
public override fun onPreMigrate(connection: SQLiteConnection) {
dropFtsSyncTriggers(connection)
}
public override fun onPostMigrate(connection: SQLiteConnection) {
}
public override fun onValidateSchema(connection: SQLiteConnection): RoomOpenDelegate.ValidationResult {
val _columnsSavedSongs: MutableMap<String, TableInfo.Column> = mutableMapOf()
_columnsSavedSongs.put("id", TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("fileName", TableInfo.Column("fileName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("filePath", TableInfo.Column("filePath", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("artist", TableInfo.Column("artist", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("title", TableInfo.Column("title", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("album", TableInfo.Column("album", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("stationName", TableInfo.Column("stationName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("durationMs", TableInfo.Column("durationMs", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("fileSize", TableInfo.Column("fileSize", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("format", TableInfo.Column("format", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("dateSaved", TableInfo.Column("dateSaved", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsSavedSongs.put("isFavorite", TableInfo.Column("isFavorite", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
val _foreignKeysSavedSongs: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
val _indicesSavedSongs: MutableSet<TableInfo.Index> = mutableSetOf()
val _infoSavedSongs: TableInfo = TableInfo("saved_songs", _columnsSavedSongs, _foreignKeysSavedSongs, _indicesSavedSongs)
val _existingSavedSongs: TableInfo = read(connection, "saved_songs")
if (!_infoSavedSongs.equals(_existingSavedSongs)) {
return RoomOpenDelegate.ValidationResult(false, """
|saved_songs(com.rada.data.local.entity.SavedSongEntity).
| Expected:
|""".trimMargin() + _infoSavedSongs + """
|
| Found:
|""".trimMargin() + _existingSavedSongs)
}
val _columnsPlaylists: MutableMap<String, TableInfo.Column> = mutableMapOf()
_columnsPlaylists.put("id", TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
_columnsPlaylists.put("name", TableInfo.Column("name", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
_columnsPlaylists.put("createdAt", TableInfo.Column("createdAt", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
val _foreignKeysPlaylists: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
val _indicesPlaylists: MutableSet<TableInfo.Index> = mutableSetOf()
val _infoPlaylists: TableInfo = TableInfo("playlists", _columnsPlaylists, _foreignKeysPlaylists, _indicesPlaylists)
val _existingPlaylists: TableInfo = read(connection, "playlists")
if (!_infoPlaylists.equals(_existingPlaylists)) {
return RoomOpenDelegate.ValidationResult(false, """
|playlists(com.rada.data.local.entity.PlaylistEntity).
| Expected:
|""".trimMargin() + _infoPlaylists + """
|
| Found:
|""".trimMargin() + _existingPlaylists)
}
val _columnsPlaylistSongs: MutableMap<String, TableInfo.Column> = mutableMapOf()
_columnsPlaylistSongs.put("playlistId", TableInfo.Column("playlistId", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY))
_columnsPlaylistSongs.put("songId", TableInfo.Column("songId", "INTEGER", true, 2, null, TableInfo.CREATED_FROM_ENTITY))
_columnsPlaylistSongs.put("addedAt", TableInfo.Column("addedAt", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY))
val _foreignKeysPlaylistSongs: MutableSet<TableInfo.ForeignKey> = mutableSetOf()
_foreignKeysPlaylistSongs.add(TableInfo.ForeignKey("playlists", "CASCADE", "NO ACTION", listOf("playlistId"), listOf("id")))
_foreignKeysPlaylistSongs.add(TableInfo.ForeignKey("saved_songs", "CASCADE", "NO ACTION", listOf("songId"), listOf("id")))
val _indicesPlaylistSongs: MutableSet<TableInfo.Index> = mutableSetOf()
_indicesPlaylistSongs.add(TableInfo.Index("index_playlist_songs_songId", false, listOf("songId"), listOf("ASC")))
val _infoPlaylistSongs: TableInfo = TableInfo("playlist_songs", _columnsPlaylistSongs, _foreignKeysPlaylistSongs, _indicesPlaylistSongs)
val _existingPlaylistSongs: TableInfo = read(connection, "playlist_songs")
if (!_infoPlaylistSongs.equals(_existingPlaylistSongs)) {
return RoomOpenDelegate.ValidationResult(false, """
|playlist_songs(com.rada.data.local.entity.PlaylistSongEntity).
| Expected:
|""".trimMargin() + _infoPlaylistSongs + """
|
| Found:
|""".trimMargin() + _existingPlaylistSongs)
}
return RoomOpenDelegate.ValidationResult(true, null)
}
}
return _openDelegate
}
protected override fun createInvalidationTracker(): InvalidationTracker {
val _shadowTablesMap: MutableMap<String, String> = mutableMapOf()
val _viewTables: MutableMap<String, Set<String>> = mutableMapOf()
return InvalidationTracker(this, _shadowTablesMap, _viewTables, "saved_songs", "playlists", "playlist_songs")
}
public override fun clearAllTables() {
super.performClear(true, "saved_songs", "playlists", "playlist_songs")
}
protected override fun getRequiredTypeConverterClasses(): Map<KClass<*>, List<KClass<*>>> {
val _typeConvertersMap: MutableMap<KClass<*>, List<KClass<*>>> = mutableMapOf()
_typeConvertersMap.put(SavedSongDao::class, SavedSongDao_Impl.getRequiredConverters())
_typeConvertersMap.put(PlaylistDao::class, PlaylistDao_Impl.getRequiredConverters())
return _typeConvertersMap
}
public override fun getRequiredAutoMigrationSpecClasses(): Set<KClass<out AutoMigrationSpec>> {
val _autoMigrationSpecsSet: MutableSet<KClass<out AutoMigrationSpec>> = mutableSetOf()
return _autoMigrationSpecsSet
}
public override fun createAutoMigrations(autoMigrationSpecs: Map<KClass<out AutoMigrationSpec>, AutoMigrationSpec>): List<Migration> {
val _autoMigrations: MutableList<Migration> = mutableListOf()
return _autoMigrations
}
public override fun savedSongDao(): SavedSongDao = _savedSongDao.value
public override fun playlistDao(): PlaylistDao = _playlistDao.value
}

View file

@ -0,0 +1,300 @@
package com.rada.`data`.local.dao
import androidx.room.EntityDeleteOrUpdateAdapter
import androidx.room.EntityInsertAdapter
import androidx.room.RoomDatabase
import androidx.room.coroutines.createFlow
import androidx.room.util.getColumnIndexOrThrow
import androidx.room.util.performSuspending
import androidx.sqlite.SQLiteStatement
import com.rada.`data`.local.entity.PlaylistEntity
import com.rada.`data`.local.entity.PlaylistSongEntity
import com.rada.`data`.local.entity.SavedSongEntity
import javax.`annotation`.processing.Generated
import kotlin.Boolean
import kotlin.Int
import kotlin.Long
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.MutableList
import kotlin.collections.mutableListOf
import kotlin.reflect.KClass
import kotlinx.coroutines.flow.Flow
@Generated(value = ["androidx.room.RoomProcessor"])
@Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
public class PlaylistDao_Impl(
__db: RoomDatabase,
) : PlaylistDao {
private val __db: RoomDatabase
private val __insertAdapterOfPlaylistEntity: EntityInsertAdapter<PlaylistEntity>
private val __insertAdapterOfPlaylistSongEntity: EntityInsertAdapter<PlaylistSongEntity>
private val __deleteAdapterOfPlaylistEntity: EntityDeleteOrUpdateAdapter<PlaylistEntity>
init {
this.__db = __db
this.__insertAdapterOfPlaylistEntity = object : EntityInsertAdapter<PlaylistEntity>() {
protected override fun createQuery(): String = "INSERT OR ABORT INTO `playlists` (`id`,`name`,`createdAt`) VALUES (nullif(?, 0),?,?)"
protected override fun bind(statement: SQLiteStatement, entity: PlaylistEntity) {
statement.bindLong(1, entity.id)
statement.bindText(2, entity.name)
statement.bindLong(3, entity.createdAt)
}
}
this.__insertAdapterOfPlaylistSongEntity = object : EntityInsertAdapter<PlaylistSongEntity>() {
protected override fun createQuery(): String = "INSERT OR ABORT INTO `playlist_songs` (`playlistId`,`songId`,`addedAt`) VALUES (?,?,?)"
protected override fun bind(statement: SQLiteStatement, entity: PlaylistSongEntity) {
statement.bindLong(1, entity.playlistId)
statement.bindLong(2, entity.songId)
statement.bindLong(3, entity.addedAt)
}
}
this.__deleteAdapterOfPlaylistEntity = object : EntityDeleteOrUpdateAdapter<PlaylistEntity>() {
protected override fun createQuery(): String = "DELETE FROM `playlists` WHERE `id` = ?"
protected override fun bind(statement: SQLiteStatement, entity: PlaylistEntity) {
statement.bindLong(1, entity.id)
}
}
}
public override suspend fun createPlaylist(playlist: PlaylistEntity): Long = performSuspending(__db, false, true) { _connection ->
val _result: Long = __insertAdapterOfPlaylistEntity.insertAndReturnId(_connection, playlist)
_result
}
public override suspend fun addSongToPlaylist(playlistSong: PlaylistSongEntity): Unit = performSuspending(__db, false, true) { _connection ->
__insertAdapterOfPlaylistSongEntity.insert(_connection, playlistSong)
}
public override suspend fun deletePlaylist(playlist: PlaylistEntity): Unit = performSuspending(__db, false, true) { _connection ->
__deleteAdapterOfPlaylistEntity.handle(_connection, playlist)
}
public override fun getAllPlaylists(): Flow<List<PlaylistEntity>> {
val _sql: String = "SELECT * FROM playlists ORDER BY createdAt DESC"
return createFlow(__db, false, arrayOf("playlists")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfName: Int = getColumnIndexOrThrow(_stmt, "name")
val _columnIndexOfCreatedAt: Int = getColumnIndexOrThrow(_stmt, "createdAt")
val _result: MutableList<PlaylistEntity> = mutableListOf()
while (_stmt.step()) {
val _item: PlaylistEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpName: String
_tmpName = _stmt.getText(_columnIndexOfName)
val _tmpCreatedAt: Long
_tmpCreatedAt = _stmt.getLong(_columnIndexOfCreatedAt)
_item = PlaylistEntity(_tmpId,_tmpName,_tmpCreatedAt)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun getPlaylistById(playlistId: Long): PlaylistEntity? {
val _sql: String = "SELECT * FROM playlists WHERE id = ?"
return performSuspending(__db, true, false) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfName: Int = getColumnIndexOrThrow(_stmt, "name")
val _columnIndexOfCreatedAt: Int = getColumnIndexOrThrow(_stmt, "createdAt")
val _result: PlaylistEntity?
if (_stmt.step()) {
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpName: String
_tmpName = _stmt.getText(_columnIndexOfName)
val _tmpCreatedAt: Long
_tmpCreatedAt = _stmt.getLong(_columnIndexOfCreatedAt)
_result = PlaylistEntity(_tmpId,_tmpName,_tmpCreatedAt)
} else {
_result = null
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getSongsInPlaylist(playlistId: Long): Flow<List<SavedSongEntity>> {
val _sql: String = """
|
| SELECT s.* FROM saved_songs s
| INNER JOIN playlist_songs ps ON s.id = ps.songId
| WHERE ps.playlistId = ?
| ORDER BY ps.addedAt DESC
|
""".trimMargin()
return createFlow(__db, false, arrayOf("saved_songs", "playlist_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getPlaylistSongCount(playlistId: Long): Flow<Int> {
val _sql: String = "SELECT COUNT(*) FROM playlist_songs WHERE playlistId = ?"
return createFlow(__db, false, arrayOf("playlist_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
val _result: Int
if (_stmt.step()) {
val _tmp: Int
_tmp = _stmt.getLong(0).toInt()
_result = _tmp
} else {
_result = 0
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun isSongInPlaylist(playlistId: Long, songId: Long): Boolean {
val _sql: String = "SELECT EXISTS(SELECT 1 FROM playlist_songs WHERE playlistId = ? AND songId = ?)"
return performSuspending(__db, true, false) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
_argIndex = 2
_stmt.bindLong(_argIndex, songId)
val _result: Boolean
if (_stmt.step()) {
val _tmp: Int
_tmp = _stmt.getLong(0).toInt()
_result = _tmp != 0
} else {
_result = false
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun getPlaylistIdsForSong(songId: Long): List<Long> {
val _sql: String = "SELECT ps.playlistId FROM playlist_songs ps WHERE ps.songId = ?"
return performSuspending(__db, true, false) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, songId)
val _result: MutableList<Long> = mutableListOf()
while (_stmt.step()) {
val _item: Long
_item = _stmt.getLong(0)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun deletePlaylistById(playlistId: Long) {
val _sql: String = "DELETE FROM playlists WHERE id = ?"
return performSuspending(__db, false, true) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
_stmt.step()
} finally {
_stmt.close()
}
}
}
public override suspend fun removeSongFromPlaylist(playlistId: Long, songId: Long) {
val _sql: String = "DELETE FROM playlist_songs WHERE playlistId = ? AND songId = ?"
return performSuspending(__db, false, true) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, playlistId)
_argIndex = 2
_stmt.bindLong(_argIndex, songId)
_stmt.step()
} finally {
_stmt.close()
}
}
}
public companion object {
public fun getRequiredConverters(): List<KClass<*>> = emptyList()
}
}

View file

@ -0,0 +1,596 @@
package com.rada.`data`.local.dao
import androidx.room.EntityDeleteOrUpdateAdapter
import androidx.room.EntityInsertAdapter
import androidx.room.RoomDatabase
import androidx.room.coroutines.createFlow
import androidx.room.util.getColumnIndexOrThrow
import androidx.room.util.performSuspending
import androidx.sqlite.SQLiteStatement
import com.rada.`data`.local.entity.SavedSongEntity
import javax.`annotation`.processing.Generated
import kotlin.Boolean
import kotlin.Int
import kotlin.Long
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.MutableList
import kotlin.collections.mutableListOf
import kotlin.reflect.KClass
import kotlinx.coroutines.flow.Flow
@Generated(value = ["androidx.room.RoomProcessor"])
@Suppress(names = ["UNCHECKED_CAST", "DEPRECATION", "REDUNDANT_PROJECTION", "REMOVAL"])
public class SavedSongDao_Impl(
__db: RoomDatabase,
) : SavedSongDao {
private val __db: RoomDatabase
private val __insertAdapterOfSavedSongEntity: EntityInsertAdapter<SavedSongEntity>
private val __deleteAdapterOfSavedSongEntity: EntityDeleteOrUpdateAdapter<SavedSongEntity>
private val __updateAdapterOfSavedSongEntity: EntityDeleteOrUpdateAdapter<SavedSongEntity>
init {
this.__db = __db
this.__insertAdapterOfSavedSongEntity = object : EntityInsertAdapter<SavedSongEntity>() {
protected override fun createQuery(): String = "INSERT OR ABORT INTO `saved_songs` (`id`,`fileName`,`filePath`,`artist`,`title`,`album`,`stationName`,`durationMs`,`fileSize`,`format`,`dateSaved`,`isFavorite`) VALUES (nullif(?, 0),?,?,?,?,?,?,?,?,?,?,?)"
protected override fun bind(statement: SQLiteStatement, entity: SavedSongEntity) {
statement.bindLong(1, entity.id)
statement.bindText(2, entity.fileName)
statement.bindText(3, entity.filePath)
statement.bindText(4, entity.artist)
statement.bindText(5, entity.title)
statement.bindText(6, entity.album)
statement.bindText(7, entity.stationName)
statement.bindLong(8, entity.durationMs)
statement.bindLong(9, entity.fileSize)
statement.bindText(10, entity.format)
statement.bindLong(11, entity.dateSaved)
val _tmp: Int = if (entity.isFavorite) 1 else 0
statement.bindLong(12, _tmp.toLong())
}
}
this.__deleteAdapterOfSavedSongEntity = object : EntityDeleteOrUpdateAdapter<SavedSongEntity>() {
protected override fun createQuery(): String = "DELETE FROM `saved_songs` WHERE `id` = ?"
protected override fun bind(statement: SQLiteStatement, entity: SavedSongEntity) {
statement.bindLong(1, entity.id)
}
}
this.__updateAdapterOfSavedSongEntity = object : EntityDeleteOrUpdateAdapter<SavedSongEntity>() {
protected override fun createQuery(): String = "UPDATE OR ABORT `saved_songs` SET `id` = ?,`fileName` = ?,`filePath` = ?,`artist` = ?,`title` = ?,`album` = ?,`stationName` = ?,`durationMs` = ?,`fileSize` = ?,`format` = ?,`dateSaved` = ?,`isFavorite` = ? WHERE `id` = ?"
protected override fun bind(statement: SQLiteStatement, entity: SavedSongEntity) {
statement.bindLong(1, entity.id)
statement.bindText(2, entity.fileName)
statement.bindText(3, entity.filePath)
statement.bindText(4, entity.artist)
statement.bindText(5, entity.title)
statement.bindText(6, entity.album)
statement.bindText(7, entity.stationName)
statement.bindLong(8, entity.durationMs)
statement.bindLong(9, entity.fileSize)
statement.bindText(10, entity.format)
statement.bindLong(11, entity.dateSaved)
val _tmp: Int = if (entity.isFavorite) 1 else 0
statement.bindLong(12, _tmp.toLong())
statement.bindLong(13, entity.id)
}
}
}
public override suspend fun insert(song: SavedSongEntity): Long = performSuspending(__db, false, true) { _connection ->
val _result: Long = __insertAdapterOfSavedSongEntity.insertAndReturnId(_connection, song)
_result
}
public override suspend fun delete(song: SavedSongEntity): Unit = performSuspending(__db, false, true) { _connection ->
__deleteAdapterOfSavedSongEntity.handle(_connection, song)
}
public override suspend fun update(song: SavedSongEntity): Unit = performSuspending(__db, false, true) { _connection ->
__updateAdapterOfSavedSongEntity.handle(_connection, song)
}
public override fun getAllByDate(): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs ORDER BY dateSaved DESC"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getAllByArtist(): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs ORDER BY artist ASC, title ASC"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getAllByTitle(): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs ORDER BY title ASC"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getFavorites(): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs WHERE isFavorite = 1 ORDER BY dateSaved DESC"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override fun search(query: String): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs WHERE artist LIKE '%' || ? || '%' OR title LIKE '%' || ? || '%' OR stationName LIKE '%' || ? || '%'"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindText(_argIndex, query)
_argIndex = 2
_stmt.bindText(_argIndex, query)
_argIndex = 3
_stmt.bindText(_argIndex, query)
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun getById(id: Long): SavedSongEntity? {
val _sql: String = "SELECT * FROM saved_songs WHERE id = ?"
return performSuspending(__db, true, false) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, id)
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: SavedSongEntity?
if (_stmt.step()) {
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_result = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
} else {
_result = null
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun getByPath(path: String): SavedSongEntity? {
val _sql: String = "SELECT * FROM saved_songs WHERE filePath = ? LIMIT 1"
return performSuspending(__db, true, false) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindText(_argIndex, path)
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: SavedSongEntity?
if (_stmt.step()) {
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_result = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
} else {
_result = null
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getCount(): Flow<Int> {
val _sql: String = "SELECT COUNT(*) FROM saved_songs"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
val _result: Int
if (_stmt.step()) {
val _tmp: Int
_tmp = _stmt.getLong(0).toInt()
_result = _tmp
} else {
_result = 0
}
_result
} finally {
_stmt.close()
}
}
}
public override fun getRecentlySaved(limit: Int): Flow<List<SavedSongEntity>> {
val _sql: String = "SELECT * FROM saved_songs ORDER BY dateSaved DESC LIMIT ?"
return createFlow(__db, false, arrayOf("saved_songs")) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, limit.toLong())
val _columnIndexOfId: Int = getColumnIndexOrThrow(_stmt, "id")
val _columnIndexOfFileName: Int = getColumnIndexOrThrow(_stmt, "fileName")
val _columnIndexOfFilePath: Int = getColumnIndexOrThrow(_stmt, "filePath")
val _columnIndexOfArtist: Int = getColumnIndexOrThrow(_stmt, "artist")
val _columnIndexOfTitle: Int = getColumnIndexOrThrow(_stmt, "title")
val _columnIndexOfAlbum: Int = getColumnIndexOrThrow(_stmt, "album")
val _columnIndexOfStationName: Int = getColumnIndexOrThrow(_stmt, "stationName")
val _columnIndexOfDurationMs: Int = getColumnIndexOrThrow(_stmt, "durationMs")
val _columnIndexOfFileSize: Int = getColumnIndexOrThrow(_stmt, "fileSize")
val _columnIndexOfFormat: Int = getColumnIndexOrThrow(_stmt, "format")
val _columnIndexOfDateSaved: Int = getColumnIndexOrThrow(_stmt, "dateSaved")
val _columnIndexOfIsFavorite: Int = getColumnIndexOrThrow(_stmt, "isFavorite")
val _result: MutableList<SavedSongEntity> = mutableListOf()
while (_stmt.step()) {
val _item: SavedSongEntity
val _tmpId: Long
_tmpId = _stmt.getLong(_columnIndexOfId)
val _tmpFileName: String
_tmpFileName = _stmt.getText(_columnIndexOfFileName)
val _tmpFilePath: String
_tmpFilePath = _stmt.getText(_columnIndexOfFilePath)
val _tmpArtist: String
_tmpArtist = _stmt.getText(_columnIndexOfArtist)
val _tmpTitle: String
_tmpTitle = _stmt.getText(_columnIndexOfTitle)
val _tmpAlbum: String
_tmpAlbum = _stmt.getText(_columnIndexOfAlbum)
val _tmpStationName: String
_tmpStationName = _stmt.getText(_columnIndexOfStationName)
val _tmpDurationMs: Long
_tmpDurationMs = _stmt.getLong(_columnIndexOfDurationMs)
val _tmpFileSize: Long
_tmpFileSize = _stmt.getLong(_columnIndexOfFileSize)
val _tmpFormat: String
_tmpFormat = _stmt.getText(_columnIndexOfFormat)
val _tmpDateSaved: Long
_tmpDateSaved = _stmt.getLong(_columnIndexOfDateSaved)
val _tmpIsFavorite: Boolean
val _tmp: Int
_tmp = _stmt.getLong(_columnIndexOfIsFavorite).toInt()
_tmpIsFavorite = _tmp != 0
_item = SavedSongEntity(_tmpId,_tmpFileName,_tmpFilePath,_tmpArtist,_tmpTitle,_tmpAlbum,_tmpStationName,_tmpDurationMs,_tmpFileSize,_tmpFormat,_tmpDateSaved,_tmpIsFavorite)
_result.add(_item)
}
_result
} finally {
_stmt.close()
}
}
}
public override suspend fun deleteById(id: Long) {
val _sql: String = "DELETE FROM saved_songs WHERE id = ?"
return performSuspending(__db, false, true) { _connection ->
val _stmt: SQLiteStatement = _connection.prepare(_sql)
try {
var _argIndex: Int = 1
_stmt.bindLong(_argIndex, id)
_stmt.step()
} finally {
_stmt.close()
}
}
}
public companion object {
public fun getRequiredConverters(): List<KClass<*>> = emptyList()
}
}

View file

@ -0,0 +1 @@
{"hilt-android-compiler-2.52.jar (com.google.dagger:hilt-android-compiler:2.52)":"KSP_PROCESSOR","room-compiler-2.8.4.jar (androidx.room:room-compiler:2.8.4)":"KSP_PROCESSOR","dagger-compiler-2.52.jar (com.google.dagger:dagger-compiler:2.52)":"KSP_PROCESSOR"}

View file

@ -0,0 +1,2 @@
#- File Locator -
listingFile=../../../../outputs/apk/debug/output-metadata.json

View file

@ -0,0 +1,2 @@
appMetadataVersion=1.1
androidGradlePluginVersion=8.7.3

Some files were not shown because too many files have changed in this diff Show more