baseline before import-songs feature

.directory

@@ -0,0 +1,2 @@
+[Desktop Entry]
+Icon=folder-orange

.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sun Sep 06 12:10:29 CDT 2026
+gradle.version=8.11.1

app/build.gradle.kts

@@ -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")
+}

app/build/generated/hilt/component_sources/debug/com/rada/DaggerRadAmpApp_HiltComponents_SingletonC.java

@@ -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);
+        }
+      }
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/com/rada/Hilt_RadAmpApp.java

@@ -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));
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/com/rada/RadAmpApp_GeneratedInjector.java

@@ -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);
+}

app/build/generated/hilt/component_sources/debug/com/rada/RadAmpApp_HiltComponents.java

@@ -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 {
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/dagger/hilt/internal/aggregatedroot/codegen/_com_rada_RadAmpApp.java

@@ -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 {
+}

app/build/generated/hilt/component_sources/debug/hilt_aggregated_deps/_com_rada_RadAmpApp_GeneratedInjector.java

@@ -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 {
+}

app/build/generated/hilt/component_trees/debug/com/rada/RadAmpApp_ComponentTreeDeps.java

@@ -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 {
+}

app/build/generated/hilt/component_trees/debug/dagger/hilt/internal/processedrootsentinel/codegen/_com_rada_RadAmpApp.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/com/rada/RadAmpApp_GeneratedInjector.java

@@ -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);
+}

app/build/generated/ksp/debug/java/com/rada/data/repository/LibraryRepository_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/data/repository/PlaylistRepository_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/data/repository/StationRepository_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/data/repository/StreamFetcher_Factory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/data/repository/StreamRepository_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvideDatabaseFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvideLibraryRepositoryFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvidePlaybackManagerFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvidePlaylistDaoFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvidePlaylistRepositoryFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvideSavedSongDaoFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/di/AppModule_ProvideStationRepositoryFactory.java

@@ -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));
+  }
+}

app/build/generated/ksp/debug/java/com/rada/player/Hilt_PlaybackService.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/player/PlaybackService_GeneratedInjector.java

@@ -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);
+}

app/build/generated/ksp/debug/java/com/rada/ui/Hilt_MainActivity.java

@@ -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());
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/MainActivity_GeneratedInjector.java

@@ -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);
+}

app/build/generated/ksp/debug/java/com/rada/ui/MainActivity_MembersInjector.java

@@ -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;
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/library/LibraryViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/library/LibraryViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/library/LibraryViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/NowPlayingViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/NowPlayingViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/NowPlayingViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/PlayerViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/PlayerViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/player/PlayerViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/playlists/PlaylistManagerViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/playlists/PlaylistManagerViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/playlists/PlaylistManagerViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/stations/StationBrowserViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/stations/StationBrowserViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/stations/StationBrowserViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/streams/StreamsViewModel_Factory.java

@@ -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);
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/streams/StreamsViewModel_HiltModules.java

@@ -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;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rada/ui/streams/StreamsViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -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();
+  }
+}

app/build/generated/ksp/debug/java/dagger/hilt/internal/aggregatedroot/codegen/_com_rada_RadAmpApp.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_RadAmpApp_GeneratedInjector.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_di_AppModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_player_PlaybackService_GeneratedInjector.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_MainActivity_GeneratedInjector.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_library_LibraryViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_library_LibraryViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_player_NowPlayingViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_player_NowPlayingViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_player_PlayerViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_player_PlayerViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_playlists_PlaylistManagerViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_stations_StationBrowserViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_stations_StationBrowserViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_streams_StreamsViewModel_HiltModules_BindsModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rada_ui_streams_StreamsViewModel_HiltModules_KeyModule.java

@@ -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 {
+}

app/build/generated/ksp/debug/kotlin/com/rada/data/local/RadAmpDatabase_Impl.kt

@@ -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
+}

app/build/generated/ksp/debug/kotlin/com/rada/data/local/dao/PlaylistDao_Impl.kt

@@ -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()
+  }
+}

app/build/generated/ksp/debug/kotlin/com/rada/data/local/dao/SavedSongDao_Impl.kt

@@ -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()
+  }
+}

app/build/intermediates/annotation_processor_list/debug/javaPreCompileDebug/annotationProcessors.json

@@ -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"}

app/build/intermediates/apk_ide_redirect_file/debug/createDebugApkListingFileRedirect/redirect.txt

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

app/build/intermediates/app_metadata/debug/writeDebugAppMetadata/app-metadata.properties

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