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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/Hilt_MainActivity.java

@@ -0,0 +1,107 @@
+package com.radiola;
+
+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/kspCaches/debug/backups/java/byRounds/1/com/radiola/MainActivity_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.radiola;
+
+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/kspCaches/debug/backups/java/byRounds/1/com/radiola/MainActivity_MembersInjector.java

@@ -0,0 +1,45 @@
+package com.radiola;
+
+import com.radiola.data.local.TokenDataStore;
+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"
+})
+public final class MainActivity_MembersInjector implements MembersInjector<MainActivity> {
+  private final Provider<TokenDataStore> tokenDataStoreProvider;
+
+  public MainActivity_MembersInjector(Provider<TokenDataStore> tokenDataStoreProvider) {
+    this.tokenDataStoreProvider = tokenDataStoreProvider;
+  }
+
+  public static MembersInjector<MainActivity> create(
+      Provider<TokenDataStore> tokenDataStoreProvider) {
+    return new MainActivity_MembersInjector(tokenDataStoreProvider);
+  }
+
+  @Override
+  public void injectMembers(MainActivity instance) {
+    injectTokenDataStore(instance, tokenDataStoreProvider.get());
+  }
+
+  @InjectedFieldSignature("com.radiola.MainActivity.tokenDataStore")
+  public static void injectTokenDataStore(MainActivity instance, TokenDataStore tokenDataStore) {
+    instance.tokenDataStore = tokenDataStore;
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/RadiolaApplication_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.radiola;
+
+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 = RadiolaApplication.class
+)
+@GeneratedEntryPoint
+@InstallIn(SingletonComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface RadiolaApplication_GeneratedInjector {
+  void injectRadiolaApplication(RadiolaApplication radiolaApplication);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/AppDatabase_Impl.java

@@ -0,0 +1,290 @@
+package com.radiola.data.local;
+
+import androidx.annotation.NonNull;
+import androidx.room.DatabaseConfiguration;
+import androidx.room.InvalidationTracker;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomOpenHelper;
+import androidx.room.migration.AutoMigrationSpec;
+import androidx.room.migration.Migration;
+import androidx.room.util.DBUtil;
+import androidx.room.util.TableInfo;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import androidx.sqlite.db.SupportSQLiteOpenHelper;
+import com.radiola.data.local.dao.RecordingDao;
+import com.radiola.data.local.dao.RecordingDao_Impl;
+import com.radiola.data.local.dao.StationDao;
+import com.radiola.data.local.dao.StationDao_Impl;
+import com.radiola.data.local.dao.TagDao;
+import com.radiola.data.local.dao.TagDao_Impl;
+import com.radiola.data.local.dao.TrackHistoryDao;
+import com.radiola.data.local.dao.TrackHistoryDao_Impl;
+import java.lang.Class;
+import java.lang.Override;
+import java.lang.String;
+import java.lang.SuppressWarnings;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.Generated;
+
+@Generated("androidx.room.RoomProcessor")
+@SuppressWarnings({"unchecked", "deprecation"})
+public final class AppDatabase_Impl extends AppDatabase {
+  private volatile StationDao _stationDao;
+
+  private volatile TrackHistoryDao _trackHistoryDao;
+
+  private volatile TagDao _tagDao;
+
+  private volatile RecordingDao _recordingDao;
+
+  @Override
+  @NonNull
+  protected SupportSQLiteOpenHelper createOpenHelper(@NonNull final DatabaseConfiguration config) {
+    final SupportSQLiteOpenHelper.Callback _openCallback = new RoomOpenHelper(config, new RoomOpenHelper.Delegate(4) {
+      @Override
+      public void createAllTables(@NonNull final SupportSQLiteDatabase db) {
+        db.execSQL("CREATE TABLE IF NOT EXISTS `stations` (`id` INTEGER NOT NULL, `name` TEXT NOT NULL, `prefix` TEXT NOT NULL, `streamUrl` TEXT NOT NULL, `coverUrl` TEXT NOT NULL, `genre` TEXT NOT NULL, `tags` TEXT NOT NULL, `sortOrder` INTEGER NOT NULL, `source` TEXT NOT NULL, `isFavorite` INTEGER NOT NULL, PRIMARY KEY(`id`))");
+        db.execSQL("CREATE TABLE IF NOT EXISTS `track_history` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `artist` TEXT NOT NULL, `song` TEXT NOT NULL, `stationName` TEXT NOT NULL, `coverUrl` TEXT, `timestamp` INTEGER NOT NULL)");
+        db.execSQL("CREATE TABLE IF NOT EXISTS `tags` (`name` TEXT NOT NULL, PRIMARY KEY(`name`))");
+        db.execSQL("CREATE TABLE IF NOT EXISTS `recordings` (`id` INTEGER NOT NULL, `stationName` TEXT NOT NULL, `stationId` INTEGER NOT NULL, `filePath` TEXT NOT NULL, `startTime` INTEGER NOT NULL, `endTime` INTEGER, `trackName` TEXT, `duration` INTEGER, PRIMARY KEY(`id`))");
+        db.execSQL("CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)");
+        db.execSQL("INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'e66acf3ece4f92f5907a7e4e20146574')");
+      }
+
+      @Override
+      public void dropAllTables(@NonNull final SupportSQLiteDatabase db) {
+        db.execSQL("DROP TABLE IF EXISTS `stations`");
+        db.execSQL("DROP TABLE IF EXISTS `track_history`");
+        db.execSQL("DROP TABLE IF EXISTS `tags`");
+        db.execSQL("DROP TABLE IF EXISTS `recordings`");
+        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
+        if (_callbacks != null) {
+          for (RoomDatabase.Callback _callback : _callbacks) {
+            _callback.onDestructiveMigration(db);
+          }
+        }
+      }
+
+      @Override
+      public void onCreate(@NonNull final SupportSQLiteDatabase db) {
+        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
+        if (_callbacks != null) {
+          for (RoomDatabase.Callback _callback : _callbacks) {
+            _callback.onCreate(db);
+          }
+        }
+      }
+
+      @Override
+      public void onOpen(@NonNull final SupportSQLiteDatabase db) {
+        mDatabase = db;
+        internalInitInvalidationTracker(db);
+        final List<? extends RoomDatabase.Callback> _callbacks = mCallbacks;
+        if (_callbacks != null) {
+          for (RoomDatabase.Callback _callback : _callbacks) {
+            _callback.onOpen(db);
+          }
+        }
+      }
+
+      @Override
+      public void onPreMigrate(@NonNull final SupportSQLiteDatabase db) {
+        DBUtil.dropFtsSyncTriggers(db);
+      }
+
+      @Override
+      public void onPostMigrate(@NonNull final SupportSQLiteDatabase db) {
+      }
+
+      @Override
+      @NonNull
+      public RoomOpenHelper.ValidationResult onValidateSchema(
+          @NonNull final SupportSQLiteDatabase db) {
+        final HashMap<String, TableInfo.Column> _columnsStations = new HashMap<String, TableInfo.Column>(10);
+        _columnsStations.put("id", new TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("name", new TableInfo.Column("name", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("prefix", new TableInfo.Column("prefix", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("streamUrl", new TableInfo.Column("streamUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("coverUrl", new TableInfo.Column("coverUrl", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("genre", new TableInfo.Column("genre", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("tags", new TableInfo.Column("tags", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("sortOrder", new TableInfo.Column("sortOrder", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("source", new TableInfo.Column("source", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsStations.put("isFavorite", new TableInfo.Column("isFavorite", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        final HashSet<TableInfo.ForeignKey> _foreignKeysStations = new HashSet<TableInfo.ForeignKey>(0);
+        final HashSet<TableInfo.Index> _indicesStations = new HashSet<TableInfo.Index>(0);
+        final TableInfo _infoStations = new TableInfo("stations", _columnsStations, _foreignKeysStations, _indicesStations);
+        final TableInfo _existingStations = TableInfo.read(db, "stations");
+        if (!_infoStations.equals(_existingStations)) {
+          return new RoomOpenHelper.ValidationResult(false, "stations(com.radiola.data.local.entity.StationEntity).\n"
+                  + " Expected:\n" + _infoStations + "\n"
+                  + " Found:\n" + _existingStations);
+        }
+        final HashMap<String, TableInfo.Column> _columnsTrackHistory = new HashMap<String, TableInfo.Column>(6);
+        _columnsTrackHistory.put("id", new TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsTrackHistory.put("artist", new TableInfo.Column("artist", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsTrackHistory.put("song", new TableInfo.Column("song", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsTrackHistory.put("stationName", new TableInfo.Column("stationName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsTrackHistory.put("coverUrl", new TableInfo.Column("coverUrl", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsTrackHistory.put("timestamp", new TableInfo.Column("timestamp", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        final HashSet<TableInfo.ForeignKey> _foreignKeysTrackHistory = new HashSet<TableInfo.ForeignKey>(0);
+        final HashSet<TableInfo.Index> _indicesTrackHistory = new HashSet<TableInfo.Index>(0);
+        final TableInfo _infoTrackHistory = new TableInfo("track_history", _columnsTrackHistory, _foreignKeysTrackHistory, _indicesTrackHistory);
+        final TableInfo _existingTrackHistory = TableInfo.read(db, "track_history");
+        if (!_infoTrackHistory.equals(_existingTrackHistory)) {
+          return new RoomOpenHelper.ValidationResult(false, "track_history(com.radiola.data.local.entity.TrackHistoryEntity).\n"
+                  + " Expected:\n" + _infoTrackHistory + "\n"
+                  + " Found:\n" + _existingTrackHistory);
+        }
+        final HashMap<String, TableInfo.Column> _columnsTags = new HashMap<String, TableInfo.Column>(1);
+        _columnsTags.put("name", new TableInfo.Column("name", "TEXT", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
+        final HashSet<TableInfo.ForeignKey> _foreignKeysTags = new HashSet<TableInfo.ForeignKey>(0);
+        final HashSet<TableInfo.Index> _indicesTags = new HashSet<TableInfo.Index>(0);
+        final TableInfo _infoTags = new TableInfo("tags", _columnsTags, _foreignKeysTags, _indicesTags);
+        final TableInfo _existingTags = TableInfo.read(db, "tags");
+        if (!_infoTags.equals(_existingTags)) {
+          return new RoomOpenHelper.ValidationResult(false, "tags(com.radiola.data.local.entity.TagEntity).\n"
+                  + " Expected:\n" + _infoTags + "\n"
+                  + " Found:\n" + _existingTags);
+        }
+        final HashMap<String, TableInfo.Column> _columnsRecordings = new HashMap<String, TableInfo.Column>(8);
+        _columnsRecordings.put("id", new TableInfo.Column("id", "INTEGER", true, 1, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("stationName", new TableInfo.Column("stationName", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("stationId", new TableInfo.Column("stationId", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("filePath", new TableInfo.Column("filePath", "TEXT", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("startTime", new TableInfo.Column("startTime", "INTEGER", true, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("endTime", new TableInfo.Column("endTime", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("trackName", new TableInfo.Column("trackName", "TEXT", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        _columnsRecordings.put("duration", new TableInfo.Column("duration", "INTEGER", false, 0, null, TableInfo.CREATED_FROM_ENTITY));
+        final HashSet<TableInfo.ForeignKey> _foreignKeysRecordings = new HashSet<TableInfo.ForeignKey>(0);
+        final HashSet<TableInfo.Index> _indicesRecordings = new HashSet<TableInfo.Index>(0);
+        final TableInfo _infoRecordings = new TableInfo("recordings", _columnsRecordings, _foreignKeysRecordings, _indicesRecordings);
+        final TableInfo _existingRecordings = TableInfo.read(db, "recordings");
+        if (!_infoRecordings.equals(_existingRecordings)) {
+          return new RoomOpenHelper.ValidationResult(false, "recordings(com.radiola.data.local.entity.RecordingEntity).\n"
+                  + " Expected:\n" + _infoRecordings + "\n"
+                  + " Found:\n" + _existingRecordings);
+        }
+        return new RoomOpenHelper.ValidationResult(true, null);
+      }
+    }, "e66acf3ece4f92f5907a7e4e20146574", "cf0c06f8e8004ceadfe196a57366bf3d");
+    final SupportSQLiteOpenHelper.Configuration _sqliteConfig = SupportSQLiteOpenHelper.Configuration.builder(config.context).name(config.name).callback(_openCallback).build();
+    final SupportSQLiteOpenHelper _helper = config.sqliteOpenHelperFactory.create(_sqliteConfig);
+    return _helper;
+  }
+
+  @Override
+  @NonNull
+  protected InvalidationTracker createInvalidationTracker() {
+    final HashMap<String, String> _shadowTablesMap = new HashMap<String, String>(0);
+    final HashMap<String, Set<String>> _viewTables = new HashMap<String, Set<String>>(0);
+    return new InvalidationTracker(this, _shadowTablesMap, _viewTables, "stations","track_history","tags","recordings");
+  }
+
+  @Override
+  public void clearAllTables() {
+    super.assertNotMainThread();
+    final SupportSQLiteDatabase _db = super.getOpenHelper().getWritableDatabase();
+    try {
+      super.beginTransaction();
+      _db.execSQL("DELETE FROM `stations`");
+      _db.execSQL("DELETE FROM `track_history`");
+      _db.execSQL("DELETE FROM `tags`");
+      _db.execSQL("DELETE FROM `recordings`");
+      super.setTransactionSuccessful();
+    } finally {
+      super.endTransaction();
+      _db.query("PRAGMA wal_checkpoint(FULL)").close();
+      if (!_db.inTransaction()) {
+        _db.execSQL("VACUUM");
+      }
+    }
+  }
+
+  @Override
+  @NonNull
+  protected Map<Class<?>, List<Class<?>>> getRequiredTypeConverters() {
+    final HashMap<Class<?>, List<Class<?>>> _typeConvertersMap = new HashMap<Class<?>, List<Class<?>>>();
+    _typeConvertersMap.put(StationDao.class, StationDao_Impl.getRequiredConverters());
+    _typeConvertersMap.put(TrackHistoryDao.class, TrackHistoryDao_Impl.getRequiredConverters());
+    _typeConvertersMap.put(TagDao.class, TagDao_Impl.getRequiredConverters());
+    _typeConvertersMap.put(RecordingDao.class, RecordingDao_Impl.getRequiredConverters());
+    return _typeConvertersMap;
+  }
+
+  @Override
+  @NonNull
+  public Set<Class<? extends AutoMigrationSpec>> getRequiredAutoMigrationSpecs() {
+    final HashSet<Class<? extends AutoMigrationSpec>> _autoMigrationSpecsSet = new HashSet<Class<? extends AutoMigrationSpec>>();
+    return _autoMigrationSpecsSet;
+  }
+
+  @Override
+  @NonNull
+  public List<Migration> getAutoMigrations(
+      @NonNull final Map<Class<? extends AutoMigrationSpec>, AutoMigrationSpec> autoMigrationSpecs) {
+    final List<Migration> _autoMigrations = new ArrayList<Migration>();
+    return _autoMigrations;
+  }
+
+  @Override
+  public StationDao stationDao() {
+    if (_stationDao != null) {
+      return _stationDao;
+    } else {
+      synchronized(this) {
+        if(_stationDao == null) {
+          _stationDao = new StationDao_Impl(this);
+        }
+        return _stationDao;
+      }
+    }
+  }
+
+  @Override
+  public TrackHistoryDao trackHistoryDao() {
+    if (_trackHistoryDao != null) {
+      return _trackHistoryDao;
+    } else {
+      synchronized(this) {
+        if(_trackHistoryDao == null) {
+          _trackHistoryDao = new TrackHistoryDao_Impl(this);
+        }
+        return _trackHistoryDao;
+      }
+    }
+  }
+
+  @Override
+  public TagDao tagDao() {
+    if (_tagDao != null) {
+      return _tagDao;
+    } else {
+      synchronized(this) {
+        if(_tagDao == null) {
+          _tagDao = new TagDao_Impl(this);
+        }
+        return _tagDao;
+      }
+    }
+  }
+
+  @Override
+  public RecordingDao recordingDao() {
+    if (_recordingDao != null) {
+      return _recordingDao;
+    } else {
+      synchronized(this) {
+        if(_recordingDao == null) {
+          _recordingDao = new RecordingDao_Impl(this);
+        }
+        return _recordingDao;
+      }
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/LocalStationDataSource_Factory.java

@@ -0,0 +1,50 @@
+package com.radiola.data.local;
+
+import android.content.Context;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class LocalStationDataSource_Factory implements Factory<LocalStationDataSource> {
+  private final Provider<Context> contextProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  public LocalStationDataSource_Factory(Provider<Context> contextProvider,
+      Provider<Json> jsonProvider) {
+    this.contextProvider = contextProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public LocalStationDataSource get() {
+    return newInstance(contextProvider.get(), jsonProvider.get());
+  }
+
+  public static LocalStationDataSource_Factory create(Provider<Context> contextProvider,
+      Provider<Json> jsonProvider) {
+    return new LocalStationDataSource_Factory(contextProvider, jsonProvider);
+  }
+
+  public static LocalStationDataSource newInstance(Context context, Json json) {
+    return new LocalStationDataSource(context, json);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/TokenDataStore_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.local;
+
+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"
+})
+public final class TokenDataStore_Factory implements Factory<TokenDataStore> {
+  private final Provider<Context> contextProvider;
+
+  public TokenDataStore_Factory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public TokenDataStore get() {
+    return newInstance(contextProvider.get());
+  }
+
+  public static TokenDataStore_Factory create(Provider<Context> contextProvider) {
+    return new TokenDataStore_Factory(contextProvider);
+  }
+
+  public static TokenDataStore newInstance(Context context) {
+    return new TokenDataStore(context);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/dao/RecordingDao_Impl.java

@@ -0,0 +1,302 @@
+package com.radiola.data.local.dao;
+
+import android.database.Cursor;
+import android.os.CancellationSignal;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.room.CoroutinesRoom;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import com.radiola.data.local.entity.RecordingEntity;
+import java.lang.Class;
+import java.lang.Exception;
+import java.lang.Long;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.String;
+import java.lang.SuppressWarnings;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import javax.annotation.processing.Generated;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.Flow;
+
+@Generated("androidx.room.RoomProcessor")
+@SuppressWarnings({"unchecked", "deprecation"})
+public final class RecordingDao_Impl implements RecordingDao {
+  private final RoomDatabase __db;
+
+  private final EntityInsertionAdapter<RecordingEntity> __insertionAdapterOfRecordingEntity;
+
+  private final SharedSQLiteStatement __preparedStmtOfDeleteById;
+
+  private final SharedSQLiteStatement __preparedStmtOfUpdateEndTime;
+
+  public RecordingDao_Impl(@NonNull final RoomDatabase __db) {
+    this.__db = __db;
+    this.__insertionAdapterOfRecordingEntity = new EntityInsertionAdapter<RecordingEntity>(__db) {
+      @Override
+      @NonNull
+      protected String createQuery() {
+        return "INSERT OR ABORT INTO `recordings` (`id`,`stationName`,`stationId`,`filePath`,`startTime`,`endTime`,`trackName`,`duration`) VALUES (?,?,?,?,?,?,?,?)";
+      }
+
+      @Override
+      protected void bind(@NonNull final SupportSQLiteStatement statement,
+          @NonNull final RecordingEntity entity) {
+        statement.bindLong(1, entity.getId());
+        statement.bindString(2, entity.getStationName());
+        statement.bindLong(3, entity.getStationId());
+        statement.bindString(4, entity.getFilePath());
+        statement.bindLong(5, entity.getStartTime());
+        if (entity.getEndTime() == null) {
+          statement.bindNull(6);
+        } else {
+          statement.bindLong(6, entity.getEndTime());
+        }
+        if (entity.getTrackName() == null) {
+          statement.bindNull(7);
+        } else {
+          statement.bindString(7, entity.getTrackName());
+        }
+        if (entity.getDuration() == null) {
+          statement.bindNull(8);
+        } else {
+          statement.bindLong(8, entity.getDuration());
+        }
+      }
+    };
+    this.__preparedStmtOfDeleteById = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "DELETE FROM recordings WHERE id = ?";
+        return _query;
+      }
+    };
+    this.__preparedStmtOfUpdateEndTime = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "UPDATE recordings SET endTime = ?, duration = ? WHERE id = ?";
+        return _query;
+      }
+    };
+  }
+
+  @Override
+  public Object insert(final RecordingEntity recording,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        __db.beginTransaction();
+        try {
+          __insertionAdapterOfRecordingEntity.insert(recording);
+          __db.setTransactionSuccessful();
+          return Unit.INSTANCE;
+        } finally {
+          __db.endTransaction();
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object deleteById(final long id, final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfDeleteById.acquire();
+        int _argIndex = 1;
+        _stmt.bindLong(_argIndex, id);
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfDeleteById.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object updateEndTime(final long id, final long endTime, final long duration,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfUpdateEndTime.acquire();
+        int _argIndex = 1;
+        _stmt.bindLong(_argIndex, endTime);
+        _argIndex = 2;
+        _stmt.bindLong(_argIndex, duration);
+        _argIndex = 3;
+        _stmt.bindLong(_argIndex, id);
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfUpdateEndTime.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Flow<List<RecordingEntity>> getAll() {
+    final String _sql = "SELECT * FROM recordings ORDER BY startTime DESC";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"recordings"}, new Callable<List<RecordingEntity>>() {
+      @Override
+      @NonNull
+      public List<RecordingEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfStationName = CursorUtil.getColumnIndexOrThrow(_cursor, "stationName");
+          final int _cursorIndexOfStationId = CursorUtil.getColumnIndexOrThrow(_cursor, "stationId");
+          final int _cursorIndexOfFilePath = CursorUtil.getColumnIndexOrThrow(_cursor, "filePath");
+          final int _cursorIndexOfStartTime = CursorUtil.getColumnIndexOrThrow(_cursor, "startTime");
+          final int _cursorIndexOfEndTime = CursorUtil.getColumnIndexOrThrow(_cursor, "endTime");
+          final int _cursorIndexOfTrackName = CursorUtil.getColumnIndexOrThrow(_cursor, "trackName");
+          final int _cursorIndexOfDuration = CursorUtil.getColumnIndexOrThrow(_cursor, "duration");
+          final List<RecordingEntity> _result = new ArrayList<RecordingEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final RecordingEntity _item;
+            final long _tmpId;
+            _tmpId = _cursor.getLong(_cursorIndexOfId);
+            final String _tmpStationName;
+            _tmpStationName = _cursor.getString(_cursorIndexOfStationName);
+            final int _tmpStationId;
+            _tmpStationId = _cursor.getInt(_cursorIndexOfStationId);
+            final String _tmpFilePath;
+            _tmpFilePath = _cursor.getString(_cursorIndexOfFilePath);
+            final long _tmpStartTime;
+            _tmpStartTime = _cursor.getLong(_cursorIndexOfStartTime);
+            final Long _tmpEndTime;
+            if (_cursor.isNull(_cursorIndexOfEndTime)) {
+              _tmpEndTime = null;
+            } else {
+              _tmpEndTime = _cursor.getLong(_cursorIndexOfEndTime);
+            }
+            final String _tmpTrackName;
+            if (_cursor.isNull(_cursorIndexOfTrackName)) {
+              _tmpTrackName = null;
+            } else {
+              _tmpTrackName = _cursor.getString(_cursorIndexOfTrackName);
+            }
+            final Long _tmpDuration;
+            if (_cursor.isNull(_cursorIndexOfDuration)) {
+              _tmpDuration = null;
+            } else {
+              _tmpDuration = _cursor.getLong(_cursorIndexOfDuration);
+            }
+            _item = new RecordingEntity(_tmpId,_tmpStationName,_tmpStationId,_tmpFilePath,_tmpStartTime,_tmpEndTime,_tmpTrackName,_tmpDuration);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Object getById(final long id, final Continuation<? super RecordingEntity> $completion) {
+    final String _sql = "SELECT * FROM recordings WHERE id = ?";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 1);
+    int _argIndex = 1;
+    _statement.bindLong(_argIndex, id);
+    final CancellationSignal _cancellationSignal = DBUtil.createCancellationSignal();
+    return CoroutinesRoom.execute(__db, false, _cancellationSignal, new Callable<RecordingEntity>() {
+      @Override
+      @Nullable
+      public RecordingEntity call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfStationName = CursorUtil.getColumnIndexOrThrow(_cursor, "stationName");
+          final int _cursorIndexOfStationId = CursorUtil.getColumnIndexOrThrow(_cursor, "stationId");
+          final int _cursorIndexOfFilePath = CursorUtil.getColumnIndexOrThrow(_cursor, "filePath");
+          final int _cursorIndexOfStartTime = CursorUtil.getColumnIndexOrThrow(_cursor, "startTime");
+          final int _cursorIndexOfEndTime = CursorUtil.getColumnIndexOrThrow(_cursor, "endTime");
+          final int _cursorIndexOfTrackName = CursorUtil.getColumnIndexOrThrow(_cursor, "trackName");
+          final int _cursorIndexOfDuration = CursorUtil.getColumnIndexOrThrow(_cursor, "duration");
+          final RecordingEntity _result;
+          if (_cursor.moveToFirst()) {
+            final long _tmpId;
+            _tmpId = _cursor.getLong(_cursorIndexOfId);
+            final String _tmpStationName;
+            _tmpStationName = _cursor.getString(_cursorIndexOfStationName);
+            final int _tmpStationId;
+            _tmpStationId = _cursor.getInt(_cursorIndexOfStationId);
+            final String _tmpFilePath;
+            _tmpFilePath = _cursor.getString(_cursorIndexOfFilePath);
+            final long _tmpStartTime;
+            _tmpStartTime = _cursor.getLong(_cursorIndexOfStartTime);
+            final Long _tmpEndTime;
+            if (_cursor.isNull(_cursorIndexOfEndTime)) {
+              _tmpEndTime = null;
+            } else {
+              _tmpEndTime = _cursor.getLong(_cursorIndexOfEndTime);
+            }
+            final String _tmpTrackName;
+            if (_cursor.isNull(_cursorIndexOfTrackName)) {
+              _tmpTrackName = null;
+            } else {
+              _tmpTrackName = _cursor.getString(_cursorIndexOfTrackName);
+            }
+            final Long _tmpDuration;
+            if (_cursor.isNull(_cursorIndexOfDuration)) {
+              _tmpDuration = null;
+            } else {
+              _tmpDuration = _cursor.getLong(_cursorIndexOfDuration);
+            }
+            _result = new RecordingEntity(_tmpId,_tmpStationName,_tmpStationId,_tmpFilePath,_tmpStartTime,_tmpEndTime,_tmpTrackName,_tmpDuration);
+          } else {
+            _result = null;
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+          _statement.release();
+        }
+      }
+    }, $completion);
+  }
+
+  @NonNull
+  public static List<Class<?>> getRequiredConverters() {
+    return Collections.emptyList();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/dao/StationDao_Impl.java

@@ -0,0 +1,420 @@
+package com.radiola.data.local.dao;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.room.CoroutinesRoom;
+import androidx.room.EntityDeletionOrUpdateAdapter;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import com.radiola.data.local.entity.StationEntity;
+import java.lang.Boolean;
+import java.lang.Class;
+import java.lang.Exception;
+import java.lang.Integer;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.String;
+import java.lang.SuppressWarnings;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import javax.annotation.processing.Generated;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.Flow;
+
+@Generated("androidx.room.RoomProcessor")
+@SuppressWarnings({"unchecked", "deprecation"})
+public final class StationDao_Impl implements StationDao {
+  private final RoomDatabase __db;
+
+  private final EntityInsertionAdapter<StationEntity> __insertionAdapterOfStationEntity;
+
+  private final EntityDeletionOrUpdateAdapter<StationEntity> __updateAdapterOfStationEntity;
+
+  private final SharedSQLiteStatement __preparedStmtOfSetFavorite;
+
+  public StationDao_Impl(@NonNull final RoomDatabase __db) {
+    this.__db = __db;
+    this.__insertionAdapterOfStationEntity = new EntityInsertionAdapter<StationEntity>(__db) {
+      @Override
+      @NonNull
+      protected String createQuery() {
+        return "INSERT OR REPLACE INTO `stations` (`id`,`name`,`prefix`,`streamUrl`,`coverUrl`,`genre`,`tags`,`sortOrder`,`source`,`isFavorite`) VALUES (?,?,?,?,?,?,?,?,?,?)";
+      }
+
+      @Override
+      protected void bind(@NonNull final SupportSQLiteStatement statement,
+          @NonNull final StationEntity entity) {
+        statement.bindLong(1, entity.getId());
+        statement.bindString(2, entity.getName());
+        statement.bindString(3, entity.getPrefix());
+        statement.bindString(4, entity.getStreamUrl());
+        statement.bindString(5, entity.getCoverUrl());
+        statement.bindString(6, entity.getGenre());
+        statement.bindString(7, entity.getTags());
+        statement.bindLong(8, entity.getSortOrder());
+        statement.bindString(9, entity.getSource());
+        final int _tmp = entity.isFavorite() ? 1 : 0;
+        statement.bindLong(10, _tmp);
+      }
+    };
+    this.__updateAdapterOfStationEntity = new EntityDeletionOrUpdateAdapter<StationEntity>(__db) {
+      @Override
+      @NonNull
+      protected String createQuery() {
+        return "UPDATE OR ABORT `stations` SET `id` = ?,`name` = ?,`prefix` = ?,`streamUrl` = ?,`coverUrl` = ?,`genre` = ?,`tags` = ?,`sortOrder` = ?,`source` = ?,`isFavorite` = ? WHERE `id` = ?";
+      }
+
+      @Override
+      protected void bind(@NonNull final SupportSQLiteStatement statement,
+          @NonNull final StationEntity entity) {
+        statement.bindLong(1, entity.getId());
+        statement.bindString(2, entity.getName());
+        statement.bindString(3, entity.getPrefix());
+        statement.bindString(4, entity.getStreamUrl());
+        statement.bindString(5, entity.getCoverUrl());
+        statement.bindString(6, entity.getGenre());
+        statement.bindString(7, entity.getTags());
+        statement.bindLong(8, entity.getSortOrder());
+        statement.bindString(9, entity.getSource());
+        final int _tmp = entity.isFavorite() ? 1 : 0;
+        statement.bindLong(10, _tmp);
+        statement.bindLong(11, entity.getId());
+      }
+    };
+    this.__preparedStmtOfSetFavorite = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "UPDATE stations SET isFavorite = ? WHERE id = ?";
+        return _query;
+      }
+    };
+  }
+
+  @Override
+  public Object insertAll(final List<StationEntity> stations,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        __db.beginTransaction();
+        try {
+          __insertionAdapterOfStationEntity.insert(stations);
+          __db.setTransactionSuccessful();
+          return Unit.INSTANCE;
+        } finally {
+          __db.endTransaction();
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object update(final StationEntity station, final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        __db.beginTransaction();
+        try {
+          __updateAdapterOfStationEntity.handle(station);
+          __db.setTransactionSuccessful();
+          return Unit.INSTANCE;
+        } finally {
+          __db.endTransaction();
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object setFavorite(final int id, final boolean isFavorite,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfSetFavorite.acquire();
+        int _argIndex = 1;
+        final int _tmp = isFavorite ? 1 : 0;
+        _stmt.bindLong(_argIndex, _tmp);
+        _argIndex = 2;
+        _stmt.bindLong(_argIndex, id);
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfSetFavorite.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Flow<List<StationEntity>> getAll() {
+    final String _sql = "SELECT * FROM stations ORDER BY sortOrder ASC";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"stations"}, new Callable<List<StationEntity>>() {
+      @Override
+      @NonNull
+      public List<StationEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
+          final int _cursorIndexOfPrefix = CursorUtil.getColumnIndexOrThrow(_cursor, "prefix");
+          final int _cursorIndexOfStreamUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "streamUrl");
+          final int _cursorIndexOfCoverUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "coverUrl");
+          final int _cursorIndexOfGenre = CursorUtil.getColumnIndexOrThrow(_cursor, "genre");
+          final int _cursorIndexOfTags = CursorUtil.getColumnIndexOrThrow(_cursor, "tags");
+          final int _cursorIndexOfSortOrder = CursorUtil.getColumnIndexOrThrow(_cursor, "sortOrder");
+          final int _cursorIndexOfSource = CursorUtil.getColumnIndexOrThrow(_cursor, "source");
+          final int _cursorIndexOfIsFavorite = CursorUtil.getColumnIndexOrThrow(_cursor, "isFavorite");
+          final List<StationEntity> _result = new ArrayList<StationEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final StationEntity _item;
+            final int _tmpId;
+            _tmpId = _cursor.getInt(_cursorIndexOfId);
+            final String _tmpName;
+            _tmpName = _cursor.getString(_cursorIndexOfName);
+            final String _tmpPrefix;
+            _tmpPrefix = _cursor.getString(_cursorIndexOfPrefix);
+            final String _tmpStreamUrl;
+            _tmpStreamUrl = _cursor.getString(_cursorIndexOfStreamUrl);
+            final String _tmpCoverUrl;
+            _tmpCoverUrl = _cursor.getString(_cursorIndexOfCoverUrl);
+            final String _tmpGenre;
+            _tmpGenre = _cursor.getString(_cursorIndexOfGenre);
+            final String _tmpTags;
+            _tmpTags = _cursor.getString(_cursorIndexOfTags);
+            final int _tmpSortOrder;
+            _tmpSortOrder = _cursor.getInt(_cursorIndexOfSortOrder);
+            final String _tmpSource;
+            _tmpSource = _cursor.getString(_cursorIndexOfSource);
+            final boolean _tmpIsFavorite;
+            final int _tmp;
+            _tmp = _cursor.getInt(_cursorIndexOfIsFavorite);
+            _tmpIsFavorite = _tmp != 0;
+            _item = new StationEntity(_tmpId,_tmpName,_tmpPrefix,_tmpStreamUrl,_tmpCoverUrl,_tmpGenre,_tmpTags,_tmpSortOrder,_tmpSource,_tmpIsFavorite);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Flow<List<StationEntity>> getFavorites() {
+    final String _sql = "SELECT * FROM stations WHERE isFavorite = 1 ORDER BY sortOrder ASC";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"stations"}, new Callable<List<StationEntity>>() {
+      @Override
+      @NonNull
+      public List<StationEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
+          final int _cursorIndexOfPrefix = CursorUtil.getColumnIndexOrThrow(_cursor, "prefix");
+          final int _cursorIndexOfStreamUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "streamUrl");
+          final int _cursorIndexOfCoverUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "coverUrl");
+          final int _cursorIndexOfGenre = CursorUtil.getColumnIndexOrThrow(_cursor, "genre");
+          final int _cursorIndexOfTags = CursorUtil.getColumnIndexOrThrow(_cursor, "tags");
+          final int _cursorIndexOfSortOrder = CursorUtil.getColumnIndexOrThrow(_cursor, "sortOrder");
+          final int _cursorIndexOfSource = CursorUtil.getColumnIndexOrThrow(_cursor, "source");
+          final int _cursorIndexOfIsFavorite = CursorUtil.getColumnIndexOrThrow(_cursor, "isFavorite");
+          final List<StationEntity> _result = new ArrayList<StationEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final StationEntity _item;
+            final int _tmpId;
+            _tmpId = _cursor.getInt(_cursorIndexOfId);
+            final String _tmpName;
+            _tmpName = _cursor.getString(_cursorIndexOfName);
+            final String _tmpPrefix;
+            _tmpPrefix = _cursor.getString(_cursorIndexOfPrefix);
+            final String _tmpStreamUrl;
+            _tmpStreamUrl = _cursor.getString(_cursorIndexOfStreamUrl);
+            final String _tmpCoverUrl;
+            _tmpCoverUrl = _cursor.getString(_cursorIndexOfCoverUrl);
+            final String _tmpGenre;
+            _tmpGenre = _cursor.getString(_cursorIndexOfGenre);
+            final String _tmpTags;
+            _tmpTags = _cursor.getString(_cursorIndexOfTags);
+            final int _tmpSortOrder;
+            _tmpSortOrder = _cursor.getInt(_cursorIndexOfSortOrder);
+            final String _tmpSource;
+            _tmpSource = _cursor.getString(_cursorIndexOfSource);
+            final boolean _tmpIsFavorite;
+            final int _tmp;
+            _tmp = _cursor.getInt(_cursorIndexOfIsFavorite);
+            _tmpIsFavorite = _tmp != 0;
+            _item = new StationEntity(_tmpId,_tmpName,_tmpPrefix,_tmpStreamUrl,_tmpCoverUrl,_tmpGenre,_tmpTags,_tmpSortOrder,_tmpSource,_tmpIsFavorite);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Flow<StationEntity> getById(final int id) {
+    final String _sql = "SELECT * FROM stations WHERE id = ?";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 1);
+    int _argIndex = 1;
+    _statement.bindLong(_argIndex, id);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"stations"}, new Callable<StationEntity>() {
+      @Override
+      @Nullable
+      public StationEntity call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
+          final int _cursorIndexOfPrefix = CursorUtil.getColumnIndexOrThrow(_cursor, "prefix");
+          final int _cursorIndexOfStreamUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "streamUrl");
+          final int _cursorIndexOfCoverUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "coverUrl");
+          final int _cursorIndexOfGenre = CursorUtil.getColumnIndexOrThrow(_cursor, "genre");
+          final int _cursorIndexOfTags = CursorUtil.getColumnIndexOrThrow(_cursor, "tags");
+          final int _cursorIndexOfSortOrder = CursorUtil.getColumnIndexOrThrow(_cursor, "sortOrder");
+          final int _cursorIndexOfSource = CursorUtil.getColumnIndexOrThrow(_cursor, "source");
+          final int _cursorIndexOfIsFavorite = CursorUtil.getColumnIndexOrThrow(_cursor, "isFavorite");
+          final StationEntity _result;
+          if (_cursor.moveToFirst()) {
+            final int _tmpId;
+            _tmpId = _cursor.getInt(_cursorIndexOfId);
+            final String _tmpName;
+            _tmpName = _cursor.getString(_cursorIndexOfName);
+            final String _tmpPrefix;
+            _tmpPrefix = _cursor.getString(_cursorIndexOfPrefix);
+            final String _tmpStreamUrl;
+            _tmpStreamUrl = _cursor.getString(_cursorIndexOfStreamUrl);
+            final String _tmpCoverUrl;
+            _tmpCoverUrl = _cursor.getString(_cursorIndexOfCoverUrl);
+            final String _tmpGenre;
+            _tmpGenre = _cursor.getString(_cursorIndexOfGenre);
+            final String _tmpTags;
+            _tmpTags = _cursor.getString(_cursorIndexOfTags);
+            final int _tmpSortOrder;
+            _tmpSortOrder = _cursor.getInt(_cursorIndexOfSortOrder);
+            final String _tmpSource;
+            _tmpSource = _cursor.getString(_cursorIndexOfSource);
+            final boolean _tmpIsFavorite;
+            final int _tmp;
+            _tmp = _cursor.getInt(_cursorIndexOfIsFavorite);
+            _tmpIsFavorite = _tmp != 0;
+            _result = new StationEntity(_tmpId,_tmpName,_tmpPrefix,_tmpStreamUrl,_tmpCoverUrl,_tmpGenre,_tmpTags,_tmpSortOrder,_tmpSource,_tmpIsFavorite);
+          } else {
+            _result = null;
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Flow<Boolean> isFavorite(final int id) {
+    final String _sql = "SELECT isFavorite FROM stations WHERE id = ?";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 1);
+    int _argIndex = 1;
+    _statement.bindLong(_argIndex, id);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"stations"}, new Callable<Boolean>() {
+      @Override
+      @NonNull
+      public Boolean call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final Boolean _result;
+          if (_cursor.moveToFirst()) {
+            final int _tmp;
+            _tmp = _cursor.getInt(0);
+            _result = _tmp != 0;
+          } else {
+            _result = false;
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Flow<List<Integer>> getFavoriteIds() {
+    final String _sql = "SELECT id FROM stations WHERE isFavorite = 1";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"stations"}, new Callable<List<Integer>>() {
+      @Override
+      @NonNull
+      public List<Integer> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final List<Integer> _result = new ArrayList<Integer>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final Integer _item;
+            _item = _cursor.getInt(0);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @NonNull
+  public static List<Class<?>> getRequiredConverters() {
+    return Collections.emptyList();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/dao/TagDao_Impl.java

@@ -0,0 +1,141 @@
+package com.radiola.data.local.dao;
+
+import android.database.Cursor;
+import androidx.annotation.NonNull;
+import androidx.room.CoroutinesRoom;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import com.radiola.data.local.entity.TagEntity;
+import java.lang.Class;
+import java.lang.Exception;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.String;
+import java.lang.SuppressWarnings;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import javax.annotation.processing.Generated;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.Flow;
+
+@Generated("androidx.room.RoomProcessor")
+@SuppressWarnings({"unchecked", "deprecation"})
+public final class TagDao_Impl implements TagDao {
+  private final RoomDatabase __db;
+
+  private final EntityInsertionAdapter<TagEntity> __insertionAdapterOfTagEntity;
+
+  private final SharedSQLiteStatement __preparedStmtOfClearAll;
+
+  public TagDao_Impl(@NonNull final RoomDatabase __db) {
+    this.__db = __db;
+    this.__insertionAdapterOfTagEntity = new EntityInsertionAdapter<TagEntity>(__db) {
+      @Override
+      @NonNull
+      protected String createQuery() {
+        return "INSERT OR REPLACE INTO `tags` (`name`) VALUES (?)";
+      }
+
+      @Override
+      protected void bind(@NonNull final SupportSQLiteStatement statement,
+          @NonNull final TagEntity entity) {
+        statement.bindString(1, entity.getName());
+      }
+    };
+    this.__preparedStmtOfClearAll = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "DELETE FROM tags";
+        return _query;
+      }
+    };
+  }
+
+  @Override
+  public Object insertAll(final List<TagEntity> tags,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        __db.beginTransaction();
+        try {
+          __insertionAdapterOfTagEntity.insert(tags);
+          __db.setTransactionSuccessful();
+          return Unit.INSTANCE;
+        } finally {
+          __db.endTransaction();
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object clearAll(final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfClearAll.acquire();
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfClearAll.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Flow<List<TagEntity>> getAll() {
+    final String _sql = "SELECT * FROM tags ORDER BY name";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"tags"}, new Callable<List<TagEntity>>() {
+      @Override
+      @NonNull
+      public List<TagEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfName = CursorUtil.getColumnIndexOrThrow(_cursor, "name");
+          final List<TagEntity> _result = new ArrayList<TagEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final TagEntity _item;
+            final String _tmpName;
+            _tmpName = _cursor.getString(_cursorIndexOfName);
+            _item = new TagEntity(_tmpName);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @NonNull
+  public static List<Class<?>> getRequiredConverters() {
+    return Collections.emptyList();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/local/dao/TrackHistoryDao_Impl.java

@@ -0,0 +1,258 @@
+package com.radiola.data.local.dao;
+
+import android.database.Cursor;
+import android.os.CancellationSignal;
+import androidx.annotation.NonNull;
+import androidx.room.CoroutinesRoom;
+import androidx.room.EntityInsertionAdapter;
+import androidx.room.RoomDatabase;
+import androidx.room.RoomSQLiteQuery;
+import androidx.room.SharedSQLiteStatement;
+import androidx.room.util.CursorUtil;
+import androidx.room.util.DBUtil;
+import androidx.sqlite.db.SupportSQLiteStatement;
+import com.radiola.data.local.entity.TrackHistoryEntity;
+import java.lang.Class;
+import java.lang.Exception;
+import java.lang.Object;
+import java.lang.Override;
+import java.lang.String;
+import java.lang.SuppressWarnings;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Callable;
+import javax.annotation.processing.Generated;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlinx.coroutines.flow.Flow;
+
+@Generated("androidx.room.RoomProcessor")
+@SuppressWarnings({"unchecked", "deprecation"})
+public final class TrackHistoryDao_Impl implements TrackHistoryDao {
+  private final RoomDatabase __db;
+
+  private final EntityInsertionAdapter<TrackHistoryEntity> __insertionAdapterOfTrackHistoryEntity;
+
+  private final SharedSQLiteStatement __preparedStmtOfDeleteById;
+
+  private final SharedSQLiteStatement __preparedStmtOfCleanupOld;
+
+  public TrackHistoryDao_Impl(@NonNull final RoomDatabase __db) {
+    this.__db = __db;
+    this.__insertionAdapterOfTrackHistoryEntity = new EntityInsertionAdapter<TrackHistoryEntity>(__db) {
+      @Override
+      @NonNull
+      protected String createQuery() {
+        return "INSERT OR ABORT INTO `track_history` (`id`,`artist`,`song`,`stationName`,`coverUrl`,`timestamp`) VALUES (nullif(?, 0),?,?,?,?,?)";
+      }
+
+      @Override
+      protected void bind(@NonNull final SupportSQLiteStatement statement,
+          @NonNull final TrackHistoryEntity entity) {
+        statement.bindLong(1, entity.getId());
+        statement.bindString(2, entity.getArtist());
+        statement.bindString(3, entity.getSong());
+        statement.bindString(4, entity.getStationName());
+        if (entity.getCoverUrl() == null) {
+          statement.bindNull(5);
+        } else {
+          statement.bindString(5, entity.getCoverUrl());
+        }
+        statement.bindLong(6, entity.getTimestamp());
+      }
+    };
+    this.__preparedStmtOfDeleteById = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "DELETE FROM track_history WHERE id = ?";
+        return _query;
+      }
+    };
+    this.__preparedStmtOfCleanupOld = new SharedSQLiteStatement(__db) {
+      @Override
+      @NonNull
+      public String createQuery() {
+        final String _query = "DELETE FROM track_history WHERE id NOT IN (SELECT id FROM track_history ORDER BY timestamp DESC LIMIT 200)";
+        return _query;
+      }
+    };
+  }
+
+  @Override
+  public Object insert(final TrackHistoryEntity track,
+      final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        __db.beginTransaction();
+        try {
+          __insertionAdapterOfTrackHistoryEntity.insert(track);
+          __db.setTransactionSuccessful();
+          return Unit.INSTANCE;
+        } finally {
+          __db.endTransaction();
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object deleteById(final int id, final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfDeleteById.acquire();
+        int _argIndex = 1;
+        _stmt.bindLong(_argIndex, id);
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfDeleteById.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Object cleanupOld(final Continuation<? super Unit> $completion) {
+    return CoroutinesRoom.execute(__db, true, new Callable<Unit>() {
+      @Override
+      @NonNull
+      public Unit call() throws Exception {
+        final SupportSQLiteStatement _stmt = __preparedStmtOfCleanupOld.acquire();
+        try {
+          __db.beginTransaction();
+          try {
+            _stmt.executeUpdateDelete();
+            __db.setTransactionSuccessful();
+            return Unit.INSTANCE;
+          } finally {
+            __db.endTransaction();
+          }
+        } finally {
+          __preparedStmtOfCleanupOld.release(_stmt);
+        }
+      }
+    }, $completion);
+  }
+
+  @Override
+  public Flow<List<TrackHistoryEntity>> getAll() {
+    final String _sql = "SELECT * FROM track_history ORDER BY timestamp DESC LIMIT 200";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 0);
+    return CoroutinesRoom.createFlow(__db, false, new String[] {"track_history"}, new Callable<List<TrackHistoryEntity>>() {
+      @Override
+      @NonNull
+      public List<TrackHistoryEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfArtist = CursorUtil.getColumnIndexOrThrow(_cursor, "artist");
+          final int _cursorIndexOfSong = CursorUtil.getColumnIndexOrThrow(_cursor, "song");
+          final int _cursorIndexOfStationName = CursorUtil.getColumnIndexOrThrow(_cursor, "stationName");
+          final int _cursorIndexOfCoverUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "coverUrl");
+          final int _cursorIndexOfTimestamp = CursorUtil.getColumnIndexOrThrow(_cursor, "timestamp");
+          final List<TrackHistoryEntity> _result = new ArrayList<TrackHistoryEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final TrackHistoryEntity _item;
+            final int _tmpId;
+            _tmpId = _cursor.getInt(_cursorIndexOfId);
+            final String _tmpArtist;
+            _tmpArtist = _cursor.getString(_cursorIndexOfArtist);
+            final String _tmpSong;
+            _tmpSong = _cursor.getString(_cursorIndexOfSong);
+            final String _tmpStationName;
+            _tmpStationName = _cursor.getString(_cursorIndexOfStationName);
+            final String _tmpCoverUrl;
+            if (_cursor.isNull(_cursorIndexOfCoverUrl)) {
+              _tmpCoverUrl = null;
+            } else {
+              _tmpCoverUrl = _cursor.getString(_cursorIndexOfCoverUrl);
+            }
+            final long _tmpTimestamp;
+            _tmpTimestamp = _cursor.getLong(_cursorIndexOfTimestamp);
+            _item = new TrackHistoryEntity(_tmpId,_tmpArtist,_tmpSong,_tmpStationName,_tmpCoverUrl,_tmpTimestamp);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+        }
+      }
+
+      @Override
+      protected void finalize() {
+        _statement.release();
+      }
+    });
+  }
+
+  @Override
+  public Object search(final String query,
+      final Continuation<? super List<TrackHistoryEntity>> $completion) {
+    final String _sql = "SELECT * FROM track_history WHERE artist LIKE '%' || ? || '%' OR song LIKE '%' || ? || '%' ORDER BY timestamp DESC";
+    final RoomSQLiteQuery _statement = RoomSQLiteQuery.acquire(_sql, 2);
+    int _argIndex = 1;
+    _statement.bindString(_argIndex, query);
+    _argIndex = 2;
+    _statement.bindString(_argIndex, query);
+    final CancellationSignal _cancellationSignal = DBUtil.createCancellationSignal();
+    return CoroutinesRoom.execute(__db, false, _cancellationSignal, new Callable<List<TrackHistoryEntity>>() {
+      @Override
+      @NonNull
+      public List<TrackHistoryEntity> call() throws Exception {
+        final Cursor _cursor = DBUtil.query(__db, _statement, false, null);
+        try {
+          final int _cursorIndexOfId = CursorUtil.getColumnIndexOrThrow(_cursor, "id");
+          final int _cursorIndexOfArtist = CursorUtil.getColumnIndexOrThrow(_cursor, "artist");
+          final int _cursorIndexOfSong = CursorUtil.getColumnIndexOrThrow(_cursor, "song");
+          final int _cursorIndexOfStationName = CursorUtil.getColumnIndexOrThrow(_cursor, "stationName");
+          final int _cursorIndexOfCoverUrl = CursorUtil.getColumnIndexOrThrow(_cursor, "coverUrl");
+          final int _cursorIndexOfTimestamp = CursorUtil.getColumnIndexOrThrow(_cursor, "timestamp");
+          final List<TrackHistoryEntity> _result = new ArrayList<TrackHistoryEntity>(_cursor.getCount());
+          while (_cursor.moveToNext()) {
+            final TrackHistoryEntity _item;
+            final int _tmpId;
+            _tmpId = _cursor.getInt(_cursorIndexOfId);
+            final String _tmpArtist;
+            _tmpArtist = _cursor.getString(_cursorIndexOfArtist);
+            final String _tmpSong;
+            _tmpSong = _cursor.getString(_cursorIndexOfSong);
+            final String _tmpStationName;
+            _tmpStationName = _cursor.getString(_cursorIndexOfStationName);
+            final String _tmpCoverUrl;
+            if (_cursor.isNull(_cursorIndexOfCoverUrl)) {
+              _tmpCoverUrl = null;
+            } else {
+              _tmpCoverUrl = _cursor.getString(_cursorIndexOfCoverUrl);
+            }
+            final long _tmpTimestamp;
+            _tmpTimestamp = _cursor.getLong(_cursorIndexOfTimestamp);
+            _item = new TrackHistoryEntity(_tmpId,_tmpArtist,_tmpSong,_tmpStationName,_tmpCoverUrl,_tmpTimestamp);
+            _result.add(_item);
+          }
+          return _result;
+        } finally {
+          _cursor.close();
+          _statement.release();
+        }
+      }
+    }, $completion);
+  }
+
+  @NonNull
+  public static List<Class<?>> getRequiredConverters() {
+    return Collections.emptyList();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/remote/AuthInterceptor_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.remote;
+
+import com.radiola.data.local.TokenDataStore;
+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"
+})
+public final class AuthInterceptor_Factory implements Factory<AuthInterceptor> {
+  private final Provider<TokenDataStore> tokenDataStoreProvider;
+
+  public AuthInterceptor_Factory(Provider<TokenDataStore> tokenDataStoreProvider) {
+    this.tokenDataStoreProvider = tokenDataStoreProvider;
+  }
+
+  @Override
+  public AuthInterceptor get() {
+    return newInstance(tokenDataStoreProvider.get());
+  }
+
+  public static AuthInterceptor_Factory create(Provider<TokenDataStore> tokenDataStoreProvider) {
+    return new AuthInterceptor_Factory(tokenDataStoreProvider);
+  }
+
+  public static AuthInterceptor newInstance(TokenDataStore tokenDataStore) {
+    return new AuthInterceptor(tokenDataStore);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/AuthRepositoryImpl_Factory.java

@@ -0,0 +1,50 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.local.TokenDataStore;
+import com.radiola.data.remote.RadiolaApi;
+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"
+})
+public final class AuthRepositoryImpl_Factory implements Factory<AuthRepositoryImpl> {
+  private final Provider<RadiolaApi> apiProvider;
+
+  private final Provider<TokenDataStore> tokenDataStoreProvider;
+
+  public AuthRepositoryImpl_Factory(Provider<RadiolaApi> apiProvider,
+      Provider<TokenDataStore> tokenDataStoreProvider) {
+    this.apiProvider = apiProvider;
+    this.tokenDataStoreProvider = tokenDataStoreProvider;
+  }
+
+  @Override
+  public AuthRepositoryImpl get() {
+    return newInstance(apiProvider.get(), tokenDataStoreProvider.get());
+  }
+
+  public static AuthRepositoryImpl_Factory create(Provider<RadiolaApi> apiProvider,
+      Provider<TokenDataStore> tokenDataStoreProvider) {
+    return new AuthRepositoryImpl_Factory(apiProvider, tokenDataStoreProvider);
+  }
+
+  public static AuthRepositoryImpl newInstance(RadiolaApi api, TokenDataStore tokenDataStore) {
+    return new AuthRepositoryImpl(api, tokenDataStore);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/FavoritesRepositoryImpl_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.local.AppDatabase;
+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"
+})
+public final class FavoritesRepositoryImpl_Factory implements Factory<FavoritesRepositoryImpl> {
+  private final Provider<AppDatabase> dbProvider;
+
+  public FavoritesRepositoryImpl_Factory(Provider<AppDatabase> dbProvider) {
+    this.dbProvider = dbProvider;
+  }
+
+  @Override
+  public FavoritesRepositoryImpl get() {
+    return newInstance(dbProvider.get());
+  }
+
+  public static FavoritesRepositoryImpl_Factory create(Provider<AppDatabase> dbProvider) {
+    return new FavoritesRepositoryImpl_Factory(dbProvider);
+  }
+
+  public static FavoritesRepositoryImpl newInstance(AppDatabase db) {
+    return new FavoritesRepositoryImpl(db);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/NowPlayingRepositoryImpl_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.remote.RecordApi;
+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"
+})
+public final class NowPlayingRepositoryImpl_Factory implements Factory<NowPlayingRepositoryImpl> {
+  private final Provider<RecordApi> apiProvider;
+
+  public NowPlayingRepositoryImpl_Factory(Provider<RecordApi> apiProvider) {
+    this.apiProvider = apiProvider;
+  }
+
+  @Override
+  public NowPlayingRepositoryImpl get() {
+    return newInstance(apiProvider.get());
+  }
+
+  public static NowPlayingRepositoryImpl_Factory create(Provider<RecordApi> apiProvider) {
+    return new NowPlayingRepositoryImpl_Factory(apiProvider);
+  }
+
+  public static NowPlayingRepositoryImpl newInstance(RecordApi api) {
+    return new NowPlayingRepositoryImpl(api);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/RecordingRepositoryImpl_Factory.java

@@ -0,0 +1,55 @@
+package com.radiola.data.repository;
+
+import android.content.Context;
+import com.radiola.data.local.AppDatabase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class RecordingRepositoryImpl_Factory implements Factory<RecordingRepositoryImpl> {
+  private final Provider<AppDatabase> dbProvider;
+
+  private final Provider<OkHttpClient> okHttpClientProvider;
+
+  private final Provider<Context> contextProvider;
+
+  public RecordingRepositoryImpl_Factory(Provider<AppDatabase> dbProvider,
+      Provider<OkHttpClient> okHttpClientProvider, Provider<Context> contextProvider) {
+    this.dbProvider = dbProvider;
+    this.okHttpClientProvider = okHttpClientProvider;
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public RecordingRepositoryImpl get() {
+    return newInstance(dbProvider.get(), okHttpClientProvider.get(), contextProvider.get());
+  }
+
+  public static RecordingRepositoryImpl_Factory create(Provider<AppDatabase> dbProvider,
+      Provider<OkHttpClient> okHttpClientProvider, Provider<Context> contextProvider) {
+    return new RecordingRepositoryImpl_Factory(dbProvider, okHttpClientProvider, contextProvider);
+  }
+
+  public static RecordingRepositoryImpl newInstance(AppDatabase db, OkHttpClient okHttpClient,
+      Context context) {
+    return new RecordingRepositoryImpl(db, okHttpClient, context);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/SettingsRepositoryImpl_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.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
+@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class SettingsRepositoryImpl_Factory implements Factory<SettingsRepositoryImpl> {
+  private final Provider<Context> contextProvider;
+
+  public SettingsRepositoryImpl_Factory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public SettingsRepositoryImpl get() {
+    return newInstance(contextProvider.get());
+  }
+
+  public static SettingsRepositoryImpl_Factory create(Provider<Context> contextProvider) {
+    return new SettingsRepositoryImpl_Factory(contextProvider);
+  }
+
+  public static SettingsRepositoryImpl newInstance(Context context) {
+    return new SettingsRepositoryImpl(context);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/StationRepositoryImpl_Factory.java

@@ -0,0 +1,55 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.local.AppDatabase;
+import com.radiola.data.local.LocalStationDataSource;
+import com.radiola.data.remote.RecordApi;
+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"
+})
+public final class StationRepositoryImpl_Factory implements Factory<StationRepositoryImpl> {
+  private final Provider<RecordApi> apiProvider;
+
+  private final Provider<AppDatabase> dbProvider;
+
+  private final Provider<LocalStationDataSource> localDataSourceProvider;
+
+  public StationRepositoryImpl_Factory(Provider<RecordApi> apiProvider,
+      Provider<AppDatabase> dbProvider, Provider<LocalStationDataSource> localDataSourceProvider) {
+    this.apiProvider = apiProvider;
+    this.dbProvider = dbProvider;
+    this.localDataSourceProvider = localDataSourceProvider;
+  }
+
+  @Override
+  public StationRepositoryImpl get() {
+    return newInstance(apiProvider.get(), dbProvider.get(), localDataSourceProvider.get());
+  }
+
+  public static StationRepositoryImpl_Factory create(Provider<RecordApi> apiProvider,
+      Provider<AppDatabase> dbProvider, Provider<LocalStationDataSource> localDataSourceProvider) {
+    return new StationRepositoryImpl_Factory(apiProvider, dbProvider, localDataSourceProvider);
+  }
+
+  public static StationRepositoryImpl newInstance(RecordApi api, AppDatabase db,
+      LocalStationDataSource localDataSource) {
+    return new StationRepositoryImpl(api, db, localDataSource);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/StationTester_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.repository;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class StationTester_Factory implements Factory<StationTester> {
+  private final Provider<OkHttpClient> okHttpClientProvider;
+
+  public StationTester_Factory(Provider<OkHttpClient> okHttpClientProvider) {
+    this.okHttpClientProvider = okHttpClientProvider;
+  }
+
+  @Override
+  public StationTester get() {
+    return newInstance(okHttpClientProvider.get());
+  }
+
+  public static StationTester_Factory create(Provider<OkHttpClient> okHttpClientProvider) {
+    return new StationTester_Factory(okHttpClientProvider);
+  }
+
+  public static StationTester newInstance(OkHttpClient okHttpClient) {
+    return new StationTester(okHttpClient);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/SyncRepositoryImpl_Factory.java

@@ -0,0 +1,50 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.local.TokenDataStore;
+import com.radiola.data.remote.RadiolaApi;
+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"
+})
+public final class SyncRepositoryImpl_Factory implements Factory<SyncRepositoryImpl> {
+  private final Provider<RadiolaApi> apiProvider;
+
+  private final Provider<TokenDataStore> tokenDataStoreProvider;
+
+  public SyncRepositoryImpl_Factory(Provider<RadiolaApi> apiProvider,
+      Provider<TokenDataStore> tokenDataStoreProvider) {
+    this.apiProvider = apiProvider;
+    this.tokenDataStoreProvider = tokenDataStoreProvider;
+  }
+
+  @Override
+  public SyncRepositoryImpl get() {
+    return newInstance(apiProvider.get(), tokenDataStoreProvider.get());
+  }
+
+  public static SyncRepositoryImpl_Factory create(Provider<RadiolaApi> apiProvider,
+      Provider<TokenDataStore> tokenDataStoreProvider) {
+    return new SyncRepositoryImpl_Factory(apiProvider, tokenDataStoreProvider);
+  }
+
+  public static SyncRepositoryImpl newInstance(RadiolaApi api, TokenDataStore tokenDataStore) {
+    return new SyncRepositoryImpl(api, tokenDataStore);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/data/repository/TrackHistoryRepositoryImpl_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.data.repository;
+
+import com.radiola.data.local.AppDatabase;
+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"
+})
+public final class TrackHistoryRepositoryImpl_Factory implements Factory<TrackHistoryRepositoryImpl> {
+  private final Provider<AppDatabase> dbProvider;
+
+  public TrackHistoryRepositoryImpl_Factory(Provider<AppDatabase> dbProvider) {
+    this.dbProvider = dbProvider;
+  }
+
+  @Override
+  public TrackHistoryRepositoryImpl get() {
+    return newInstance(dbProvider.get());
+  }
+
+  public static TrackHistoryRepositoryImpl_Factory create(Provider<AppDatabase> dbProvider) {
+    return new TrackHistoryRepositoryImpl_Factory(dbProvider);
+  }
+
+  public static TrackHistoryRepositoryImpl newInstance(AppDatabase db) {
+    return new TrackHistoryRepositoryImpl(db);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideAuthRepositoryFactory.java

@@ -0,0 +1,47 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.AuthRepositoryImpl;
+import com.radiola.domain.repository.AuthRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideAuthRepositoryFactory implements Factory<AuthRepository> {
+  private final Provider<AuthRepositoryImpl> implProvider;
+
+  public AppModule_ProvideAuthRepositoryFactory(Provider<AuthRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public AuthRepository get() {
+    return provideAuthRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideAuthRepositoryFactory create(
+      Provider<AuthRepositoryImpl> implProvider) {
+    return new AppModule_ProvideAuthRepositoryFactory(implProvider);
+  }
+
+  public static AuthRepository provideAuthRepository(AuthRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideAuthRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideBaseOkHttpClientFactory.java

@@ -0,0 +1,42 @@
+package com.radiola.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideBaseOkHttpClientFactory implements Factory<OkHttpClient> {
+  @Override
+  public OkHttpClient get() {
+    return provideBaseOkHttpClient();
+  }
+
+  public static AppModule_ProvideBaseOkHttpClientFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static OkHttpClient provideBaseOkHttpClient() {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideBaseOkHttpClient());
+  }
+
+  private static final class InstanceHolder {
+    private static final AppModule_ProvideBaseOkHttpClientFactory INSTANCE = new AppModule_ProvideBaseOkHttpClientFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideDatabaseFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideFavoritesRepositoryFactory.java

@@ -0,0 +1,48 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.FavoritesRepositoryImpl;
+import com.radiola.domain.repository.FavoritesRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideFavoritesRepositoryFactory implements Factory<FavoritesRepository> {
+  private final Provider<FavoritesRepositoryImpl> implProvider;
+
+  public AppModule_ProvideFavoritesRepositoryFactory(
+      Provider<FavoritesRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public FavoritesRepository get() {
+    return provideFavoritesRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideFavoritesRepositoryFactory create(
+      Provider<FavoritesRepositoryImpl> implProvider) {
+    return new AppModule_ProvideFavoritesRepositoryFactory(implProvider);
+  }
+
+  public static FavoritesRepository provideFavoritesRepository(FavoritesRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideFavoritesRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideJsonFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideLocalStationDataSourceFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideNowPlayingRepositoryFactory.java

@@ -0,0 +1,48 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.NowPlayingRepositoryImpl;
+import com.radiola.domain.repository.NowPlayingRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideNowPlayingRepositoryFactory implements Factory<NowPlayingRepository> {
+  private final Provider<NowPlayingRepositoryImpl> implProvider;
+
+  public AppModule_ProvideNowPlayingRepositoryFactory(
+      Provider<NowPlayingRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public NowPlayingRepository get() {
+    return provideNowPlayingRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideNowPlayingRepositoryFactory create(
+      Provider<NowPlayingRepositoryImpl> implProvider) {
+    return new AppModule_ProvideNowPlayingRepositoryFactory(implProvider);
+  }
+
+  public static NowPlayingRepository provideNowPlayingRepository(NowPlayingRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideNowPlayingRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideOkHttpClientFactory.java

@@ -0,0 +1,42 @@
+package com.radiola.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideOkHttpClientFactory implements Factory<OkHttpClient> {
+  @Override
+  public OkHttpClient get() {
+    return provideOkHttpClient();
+  }
+
+  public static AppModule_ProvideOkHttpClientFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static OkHttpClient provideOkHttpClient() {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideOkHttpClient());
+  }
+
+  private static final class InstanceHolder {
+    private static final AppModule_ProvideOkHttpClientFactory INSTANCE = new AppModule_ProvideOkHttpClientFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRadiolaApiFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRadiolaOkHttpClientFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRadiolaRetrofitFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRecordApiFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRecordRetrofitFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRecordingRepositoryFactory.java

@@ -0,0 +1,48 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.RecordingRepositoryImpl;
+import com.radiola.domain.repository.RecordingRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideRecordingRepositoryFactory implements Factory<RecordingRepository> {
+  private final Provider<RecordingRepositoryImpl> implProvider;
+
+  public AppModule_ProvideRecordingRepositoryFactory(
+      Provider<RecordingRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public RecordingRepository get() {
+    return provideRecordingRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideRecordingRepositoryFactory create(
+      Provider<RecordingRepositoryImpl> implProvider) {
+    return new AppModule_ProvideRecordingRepositoryFactory(implProvider);
+  }
+
+  public static RecordingRepository provideRecordingRepository(RecordingRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideRecordingRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideRetrofitFactory.java

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

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideSettingsRepositoryFactory.java

@@ -0,0 +1,47 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.SettingsRepositoryImpl;
+import com.radiola.domain.repository.SettingsRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideSettingsRepositoryFactory implements Factory<SettingsRepository> {
+  private final Provider<SettingsRepositoryImpl> implProvider;
+
+  public AppModule_ProvideSettingsRepositoryFactory(Provider<SettingsRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public SettingsRepository get() {
+    return provideSettingsRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideSettingsRepositoryFactory create(
+      Provider<SettingsRepositoryImpl> implProvider) {
+    return new AppModule_ProvideSettingsRepositoryFactory(implProvider);
+  }
+
+  public static SettingsRepository provideSettingsRepository(SettingsRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideSettingsRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideStationRepositoryFactory.java

@@ -0,0 +1,47 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.StationRepositoryImpl;
+import com.radiola.domain.repository.StationRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideStationRepositoryFactory implements Factory<StationRepository> {
+  private final Provider<StationRepositoryImpl> implProvider;
+
+  public AppModule_ProvideStationRepositoryFactory(Provider<StationRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public StationRepository get() {
+    return provideStationRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideStationRepositoryFactory create(
+      Provider<StationRepositoryImpl> implProvider) {
+    return new AppModule_ProvideStationRepositoryFactory(implProvider);
+  }
+
+  public static StationRepository provideStationRepository(StationRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideStationRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideSyncRepositoryFactory.java

@@ -0,0 +1,47 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.SyncRepositoryImpl;
+import com.radiola.domain.repository.SyncRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideSyncRepositoryFactory implements Factory<SyncRepository> {
+  private final Provider<SyncRepositoryImpl> implProvider;
+
+  public AppModule_ProvideSyncRepositoryFactory(Provider<SyncRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public SyncRepository get() {
+    return provideSyncRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideSyncRepositoryFactory create(
+      Provider<SyncRepositoryImpl> implProvider) {
+    return new AppModule_ProvideSyncRepositoryFactory(implProvider);
+  }
+
+  public static SyncRepository provideSyncRepository(SyncRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideSyncRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/di/AppModule_ProvideTrackHistoryRepositoryFactory.java

@@ -0,0 +1,49 @@
+package com.radiola.di;
+
+import com.radiola.data.repository.TrackHistoryRepositoryImpl;
+import com.radiola.domain.repository.TrackHistoryRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import javax.inject.Provider;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class AppModule_ProvideTrackHistoryRepositoryFactory implements Factory<TrackHistoryRepository> {
+  private final Provider<TrackHistoryRepositoryImpl> implProvider;
+
+  public AppModule_ProvideTrackHistoryRepositoryFactory(
+      Provider<TrackHistoryRepositoryImpl> implProvider) {
+    this.implProvider = implProvider;
+  }
+
+  @Override
+  public TrackHistoryRepository get() {
+    return provideTrackHistoryRepository(implProvider.get());
+  }
+
+  public static AppModule_ProvideTrackHistoryRepositoryFactory create(
+      Provider<TrackHistoryRepositoryImpl> implProvider) {
+    return new AppModule_ProvideTrackHistoryRepositoryFactory(implProvider);
+  }
+
+  public static TrackHistoryRepository provideTrackHistoryRepository(
+      TrackHistoryRepositoryImpl impl) {
+    return Preconditions.checkNotNullFromProvides(AppModule.INSTANCE.provideTrackHistoryRepository(impl));
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/GetNowPlayingUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.domain.repository.NowPlayingRepository;
+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"
+})
+public final class GetNowPlayingUseCase_Factory implements Factory<GetNowPlayingUseCase> {
+  private final Provider<NowPlayingRepository> nowPlayingRepositoryProvider;
+
+  public GetNowPlayingUseCase_Factory(Provider<NowPlayingRepository> nowPlayingRepositoryProvider) {
+    this.nowPlayingRepositoryProvider = nowPlayingRepositoryProvider;
+  }
+
+  @Override
+  public GetNowPlayingUseCase get() {
+    return newInstance(nowPlayingRepositoryProvider.get());
+  }
+
+  public static GetNowPlayingUseCase_Factory create(
+      Provider<NowPlayingRepository> nowPlayingRepositoryProvider) {
+    return new GetNowPlayingUseCase_Factory(nowPlayingRepositoryProvider);
+  }
+
+  public static GetNowPlayingUseCase newInstance(NowPlayingRepository nowPlayingRepository) {
+    return new GetNowPlayingUseCase(nowPlayingRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/GetStationsUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.domain.repository.StationRepository;
+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"
+})
+public final class GetStationsUseCase_Factory implements Factory<GetStationsUseCase> {
+  private final Provider<StationRepository> stationRepositoryProvider;
+
+  public GetStationsUseCase_Factory(Provider<StationRepository> stationRepositoryProvider) {
+    this.stationRepositoryProvider = stationRepositoryProvider;
+  }
+
+  @Override
+  public GetStationsUseCase get() {
+    return newInstance(stationRepositoryProvider.get());
+  }
+
+  public static GetStationsUseCase_Factory create(
+      Provider<StationRepository> stationRepositoryProvider) {
+    return new GetStationsUseCase_Factory(stationRepositoryProvider);
+  }
+
+  public static GetStationsUseCase newInstance(StationRepository stationRepository) {
+    return new GetStationsUseCase(stationRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/PlayStationUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.domain.repository.SettingsRepository;
+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"
+})
+public final class PlayStationUseCase_Factory implements Factory<PlayStationUseCase> {
+  private final Provider<SettingsRepository> settingsRepositoryProvider;
+
+  public PlayStationUseCase_Factory(Provider<SettingsRepository> settingsRepositoryProvider) {
+    this.settingsRepositoryProvider = settingsRepositoryProvider;
+  }
+
+  @Override
+  public PlayStationUseCase get() {
+    return newInstance(settingsRepositoryProvider.get());
+  }
+
+  public static PlayStationUseCase_Factory create(
+      Provider<SettingsRepository> settingsRepositoryProvider) {
+    return new PlayStationUseCase_Factory(settingsRepositoryProvider);
+  }
+
+  public static PlayStationUseCase newInstance(SettingsRepository settingsRepository) {
+    return new PlayStationUseCase(settingsRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/RefreshStationsUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.domain.repository.StationRepository;
+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"
+})
+public final class RefreshStationsUseCase_Factory implements Factory<RefreshStationsUseCase> {
+  private final Provider<StationRepository> stationRepositoryProvider;
+
+  public RefreshStationsUseCase_Factory(Provider<StationRepository> stationRepositoryProvider) {
+    this.stationRepositoryProvider = stationRepositoryProvider;
+  }
+
+  @Override
+  public RefreshStationsUseCase get() {
+    return newInstance(stationRepositoryProvider.get());
+  }
+
+  public static RefreshStationsUseCase_Factory create(
+      Provider<StationRepository> stationRepositoryProvider) {
+    return new RefreshStationsUseCase_Factory(stationRepositoryProvider);
+  }
+
+  public static RefreshStationsUseCase newInstance(StationRepository stationRepository) {
+    return new RefreshStationsUseCase(stationRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/SearchTrackInServiceUseCase_Factory.java

@@ -0,0 +1,40 @@
+package com.radiola.domain.usecase;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast"
+})
+public final class SearchTrackInServiceUseCase_Factory implements Factory<SearchTrackInServiceUseCase> {
+  @Override
+  public SearchTrackInServiceUseCase get() {
+    return newInstance();
+  }
+
+  public static SearchTrackInServiceUseCase_Factory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static SearchTrackInServiceUseCase newInstance() {
+    return new SearchTrackInServiceUseCase();
+  }
+
+  private static final class InstanceHolder {
+    private static final SearchTrackInServiceUseCase_Factory INSTANCE = new SearchTrackInServiceUseCase_Factory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/TestStationsUseCase_Factory.java

@@ -0,0 +1,58 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.data.repository.StationTester;
+import com.radiola.domain.repository.NowPlayingRepository;
+import com.radiola.domain.repository.StationRepository;
+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"
+})
+public final class TestStationsUseCase_Factory implements Factory<TestStationsUseCase> {
+  private final Provider<StationRepository> stationRepositoryProvider;
+
+  private final Provider<NowPlayingRepository> nowPlayingRepositoryProvider;
+
+  private final Provider<StationTester> stationTesterProvider;
+
+  public TestStationsUseCase_Factory(Provider<StationRepository> stationRepositoryProvider,
+      Provider<NowPlayingRepository> nowPlayingRepositoryProvider,
+      Provider<StationTester> stationTesterProvider) {
+    this.stationRepositoryProvider = stationRepositoryProvider;
+    this.nowPlayingRepositoryProvider = nowPlayingRepositoryProvider;
+    this.stationTesterProvider = stationTesterProvider;
+  }
+
+  @Override
+  public TestStationsUseCase get() {
+    return newInstance(stationRepositoryProvider.get(), nowPlayingRepositoryProvider.get(), stationTesterProvider.get());
+  }
+
+  public static TestStationsUseCase_Factory create(
+      Provider<StationRepository> stationRepositoryProvider,
+      Provider<NowPlayingRepository> nowPlayingRepositoryProvider,
+      Provider<StationTester> stationTesterProvider) {
+    return new TestStationsUseCase_Factory(stationRepositoryProvider, nowPlayingRepositoryProvider, stationTesterProvider);
+  }
+
+  public static TestStationsUseCase newInstance(StationRepository stationRepository,
+      NowPlayingRepository nowPlayingRepository, StationTester stationTester) {
+    return new TestStationsUseCase(stationRepository, nowPlayingRepository, stationTester);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/ToggleFavoriteUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase;
+
+import com.radiola.domain.repository.FavoritesRepository;
+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"
+})
+public final class ToggleFavoriteUseCase_Factory implements Factory<ToggleFavoriteUseCase> {
+  private final Provider<FavoritesRepository> favoritesRepositoryProvider;
+
+  public ToggleFavoriteUseCase_Factory(Provider<FavoritesRepository> favoritesRepositoryProvider) {
+    this.favoritesRepositoryProvider = favoritesRepositoryProvider;
+  }
+
+  @Override
+  public ToggleFavoriteUseCase get() {
+    return newInstance(favoritesRepositoryProvider.get());
+  }
+
+  public static ToggleFavoriteUseCase_Factory create(
+      Provider<FavoritesRepository> favoritesRepositoryProvider) {
+    return new ToggleFavoriteUseCase_Factory(favoritesRepositoryProvider);
+  }
+
+  public static ToggleFavoriteUseCase newInstance(FavoritesRepository favoritesRepository) {
+    return new ToggleFavoriteUseCase(favoritesRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/GetAuthStateUseCase_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.AuthRepository;
+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"
+})
+public final class GetAuthStateUseCase_Factory implements Factory<GetAuthStateUseCase> {
+  private final Provider<AuthRepository> repositoryProvider;
+
+  public GetAuthStateUseCase_Factory(Provider<AuthRepository> repositoryProvider) {
+    this.repositoryProvider = repositoryProvider;
+  }
+
+  @Override
+  public GetAuthStateUseCase get() {
+    return newInstance(repositoryProvider.get());
+  }
+
+  public static GetAuthStateUseCase_Factory create(Provider<AuthRepository> repositoryProvider) {
+    return new GetAuthStateUseCase_Factory(repositoryProvider);
+  }
+
+  public static GetAuthStateUseCase newInstance(AuthRepository repository) {
+    return new GetAuthStateUseCase(repository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/GetCurrentUserUseCase_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.AuthRepository;
+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"
+})
+public final class GetCurrentUserUseCase_Factory implements Factory<GetCurrentUserUseCase> {
+  private final Provider<AuthRepository> repositoryProvider;
+
+  public GetCurrentUserUseCase_Factory(Provider<AuthRepository> repositoryProvider) {
+    this.repositoryProvider = repositoryProvider;
+  }
+
+  @Override
+  public GetCurrentUserUseCase get() {
+    return newInstance(repositoryProvider.get());
+  }
+
+  public static GetCurrentUserUseCase_Factory create(Provider<AuthRepository> repositoryProvider) {
+    return new GetCurrentUserUseCase_Factory(repositoryProvider);
+  }
+
+  public static GetCurrentUserUseCase newInstance(AuthRepository repository) {
+    return new GetCurrentUserUseCase(repository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/LogoutUseCase_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.AuthRepository;
+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"
+})
+public final class LogoutUseCase_Factory implements Factory<LogoutUseCase> {
+  private final Provider<AuthRepository> repositoryProvider;
+
+  public LogoutUseCase_Factory(Provider<AuthRepository> repositoryProvider) {
+    this.repositoryProvider = repositoryProvider;
+  }
+
+  @Override
+  public LogoutUseCase get() {
+    return newInstance(repositoryProvider.get());
+  }
+
+  public static LogoutUseCase_Factory create(Provider<AuthRepository> repositoryProvider) {
+    return new LogoutUseCase_Factory(repositoryProvider);
+  }
+
+  public static LogoutUseCase newInstance(AuthRepository repository) {
+    return new LogoutUseCase(repository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/PushFavoriteUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.SyncRepository;
+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"
+})
+public final class PushFavoriteUseCase_Factory implements Factory<PushFavoriteUseCase> {
+  private final Provider<SyncRepository> syncRepositoryProvider;
+
+  public PushFavoriteUseCase_Factory(Provider<SyncRepository> syncRepositoryProvider) {
+    this.syncRepositoryProvider = syncRepositoryProvider;
+  }
+
+  @Override
+  public PushFavoriteUseCase get() {
+    return newInstance(syncRepositoryProvider.get());
+  }
+
+  public static PushFavoriteUseCase_Factory create(
+      Provider<SyncRepository> syncRepositoryProvider) {
+    return new PushFavoriteUseCase_Factory(syncRepositoryProvider);
+  }
+
+  public static PushFavoriteUseCase newInstance(SyncRepository syncRepository) {
+    return new PushFavoriteUseCase(syncRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/PushHistoryUseCase_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.SyncRepository;
+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"
+})
+public final class PushHistoryUseCase_Factory implements Factory<PushHistoryUseCase> {
+  private final Provider<SyncRepository> syncRepositoryProvider;
+
+  public PushHistoryUseCase_Factory(Provider<SyncRepository> syncRepositoryProvider) {
+    this.syncRepositoryProvider = syncRepositoryProvider;
+  }
+
+  @Override
+  public PushHistoryUseCase get() {
+    return newInstance(syncRepositoryProvider.get());
+  }
+
+  public static PushHistoryUseCase_Factory create(Provider<SyncRepository> syncRepositoryProvider) {
+    return new PushHistoryUseCase_Factory(syncRepositoryProvider);
+  }
+
+  public static PushHistoryUseCase newInstance(SyncRepository syncRepository) {
+    return new PushHistoryUseCase(syncRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/RequestMagicLinkUseCase_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.AuthRepository;
+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"
+})
+public final class RequestMagicLinkUseCase_Factory implements Factory<RequestMagicLinkUseCase> {
+  private final Provider<AuthRepository> repositoryProvider;
+
+  public RequestMagicLinkUseCase_Factory(Provider<AuthRepository> repositoryProvider) {
+    this.repositoryProvider = repositoryProvider;
+  }
+
+  @Override
+  public RequestMagicLinkUseCase get() {
+    return newInstance(repositoryProvider.get());
+  }
+
+  public static RequestMagicLinkUseCase_Factory create(
+      Provider<AuthRepository> repositoryProvider) {
+    return new RequestMagicLinkUseCase_Factory(repositoryProvider);
+  }
+
+  public static RequestMagicLinkUseCase newInstance(AuthRepository repository) {
+    return new RequestMagicLinkUseCase(repository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/SyncFavoritesUseCase_Factory.java

@@ -0,0 +1,52 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.FavoritesRepository;
+import com.radiola.domain.repository.SyncRepository;
+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"
+})
+public final class SyncFavoritesUseCase_Factory implements Factory<SyncFavoritesUseCase> {
+  private final Provider<FavoritesRepository> favoritesRepositoryProvider;
+
+  private final Provider<SyncRepository> syncRepositoryProvider;
+
+  public SyncFavoritesUseCase_Factory(Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<SyncRepository> syncRepositoryProvider) {
+    this.favoritesRepositoryProvider = favoritesRepositoryProvider;
+    this.syncRepositoryProvider = syncRepositoryProvider;
+  }
+
+  @Override
+  public SyncFavoritesUseCase get() {
+    return newInstance(favoritesRepositoryProvider.get(), syncRepositoryProvider.get());
+  }
+
+  public static SyncFavoritesUseCase_Factory create(
+      Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<SyncRepository> syncRepositoryProvider) {
+    return new SyncFavoritesUseCase_Factory(favoritesRepositoryProvider, syncRepositoryProvider);
+  }
+
+  public static SyncFavoritesUseCase newInstance(FavoritesRepository favoritesRepository,
+      SyncRepository syncRepository) {
+    return new SyncFavoritesUseCase(favoritesRepository, syncRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/domain/usecase/auth/VerifyMagicLinkUseCase_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.domain.usecase.auth;
+
+import com.radiola.domain.repository.AuthRepository;
+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"
+})
+public final class VerifyMagicLinkUseCase_Factory implements Factory<VerifyMagicLinkUseCase> {
+  private final Provider<AuthRepository> repositoryProvider;
+
+  public VerifyMagicLinkUseCase_Factory(Provider<AuthRepository> repositoryProvider) {
+    this.repositoryProvider = repositoryProvider;
+  }
+
+  @Override
+  public VerifyMagicLinkUseCase get() {
+    return newInstance(repositoryProvider.get());
+  }
+
+  public static VerifyMagicLinkUseCase_Factory create(Provider<AuthRepository> repositoryProvider) {
+    return new VerifyMagicLinkUseCase_Factory(repositoryProvider);
+  }
+
+  public static VerifyMagicLinkUseCase newInstance(AuthRepository repository) {
+    return new VerifyMagicLinkUseCase(repository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/service/Hilt_PlayerService.java

@@ -0,0 +1,61 @@
+package com.radiola.service;
+
+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_PlayerService extends MediaSessionService implements GeneratedComponentManagerHolder {
+  private volatile ServiceComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_PlayerService() {
+    super();
+  }
+
+  @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;
+      ((PlayerService_GeneratedInjector) this.generatedComponent()).injectPlayerService(UnsafeCasts.<PlayerService>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/service/PlayerController_Factory.java

@@ -0,0 +1,44 @@
+package com.radiola.service;
+
+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"
+})
+public final class PlayerController_Factory implements Factory<PlayerController> {
+  private final Provider<Context> contextProvider;
+
+  public PlayerController_Factory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public PlayerController get() {
+    return newInstance(contextProvider.get());
+  }
+
+  public static PlayerController_Factory create(Provider<Context> contextProvider) {
+    return new PlayerController_Factory(contextProvider);
+  }
+
+  public static PlayerController newInstance(Context context) {
+    return new PlayerController(context);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/service/PlayerService_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.radiola.service;
+
+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 = PlayerService.class
+)
+@GeneratedEntryPoint
+@InstallIn(ServiceComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface PlayerService_GeneratedInjector {
+  void injectPlayerService(PlayerService playerService);
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/service/PlayerService_MembersInjector.java

@@ -0,0 +1,45 @@
+package com.radiola.service;
+
+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"
+})
+public final class PlayerService_MembersInjector implements MembersInjector<PlayerService> {
+  private final Provider<PlayerController> playerControllerProvider;
+
+  public PlayerService_MembersInjector(Provider<PlayerController> playerControllerProvider) {
+    this.playerControllerProvider = playerControllerProvider;
+  }
+
+  public static MembersInjector<PlayerService> create(
+      Provider<PlayerController> playerControllerProvider) {
+    return new PlayerService_MembersInjector(playerControllerProvider);
+  }
+
+  @Override
+  public void injectMembers(PlayerService instance) {
+    injectPlayerController(instance, playerControllerProvider.get());
+  }
+
+  @InjectedFieldSignature("com.radiola.service.PlayerService.playerController")
+  public static void injectPlayerController(PlayerService instance,
+      PlayerController playerController) {
+    instance.playerController = playerController;
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/auth/AuthViewModel_Factory.java

@@ -0,0 +1,52 @@
+package com.radiola.ui.auth;
+
+import com.radiola.domain.usecase.auth.RequestMagicLinkUseCase;
+import com.radiola.domain.usecase.auth.VerifyMagicLinkUseCase;
+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"
+})
+public final class AuthViewModel_Factory implements Factory<AuthViewModel> {
+  private final Provider<RequestMagicLinkUseCase> requestMagicLinkUseCaseProvider;
+
+  private final Provider<VerifyMagicLinkUseCase> verifyMagicLinkUseCaseProvider;
+
+  public AuthViewModel_Factory(Provider<RequestMagicLinkUseCase> requestMagicLinkUseCaseProvider,
+      Provider<VerifyMagicLinkUseCase> verifyMagicLinkUseCaseProvider) {
+    this.requestMagicLinkUseCaseProvider = requestMagicLinkUseCaseProvider;
+    this.verifyMagicLinkUseCaseProvider = verifyMagicLinkUseCaseProvider;
+  }
+
+  @Override
+  public AuthViewModel get() {
+    return newInstance(requestMagicLinkUseCaseProvider.get(), verifyMagicLinkUseCaseProvider.get());
+  }
+
+  public static AuthViewModel_Factory create(
+      Provider<RequestMagicLinkUseCase> requestMagicLinkUseCaseProvider,
+      Provider<VerifyMagicLinkUseCase> verifyMagicLinkUseCaseProvider) {
+    return new AuthViewModel_Factory(requestMagicLinkUseCaseProvider, verifyMagicLinkUseCaseProvider);
+  }
+
+  public static AuthViewModel newInstance(RequestMagicLinkUseCase requestMagicLinkUseCase,
+      VerifyMagicLinkUseCase verifyMagicLinkUseCase) {
+    return new AuthViewModel(requestMagicLinkUseCase, verifyMagicLinkUseCase);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/auth/AuthViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.ui.auth;
+
+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 = AuthViewModel.class
+)
+public final class AuthViewModel_HiltModules {
+  private AuthViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(AuthViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(AuthViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(AuthViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/favorites/FavoritesViewModel_Factory.java

@@ -0,0 +1,65 @@
+package com.radiola.ui.favorites;
+
+import com.radiola.domain.repository.FavoritesRepository;
+import com.radiola.domain.usecase.ToggleFavoriteUseCase;
+import com.radiola.domain.usecase.auth.PushFavoriteUseCase;
+import com.radiola.domain.usecase.auth.SyncFavoritesUseCase;
+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"
+})
+public final class FavoritesViewModel_Factory implements Factory<FavoritesViewModel> {
+  private final Provider<FavoritesRepository> favoritesRepositoryProvider;
+
+  private final Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider;
+
+  private final Provider<PushFavoriteUseCase> pushFavoriteUseCaseProvider;
+
+  private final Provider<SyncFavoritesUseCase> syncFavoritesUseCaseProvider;
+
+  public FavoritesViewModel_Factory(Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<PushFavoriteUseCase> pushFavoriteUseCaseProvider,
+      Provider<SyncFavoritesUseCase> syncFavoritesUseCaseProvider) {
+    this.favoritesRepositoryProvider = favoritesRepositoryProvider;
+    this.toggleFavoriteUseCaseProvider = toggleFavoriteUseCaseProvider;
+    this.pushFavoriteUseCaseProvider = pushFavoriteUseCaseProvider;
+    this.syncFavoritesUseCaseProvider = syncFavoritesUseCaseProvider;
+  }
+
+  @Override
+  public FavoritesViewModel get() {
+    return newInstance(favoritesRepositoryProvider.get(), toggleFavoriteUseCaseProvider.get(), pushFavoriteUseCaseProvider.get(), syncFavoritesUseCaseProvider.get());
+  }
+
+  public static FavoritesViewModel_Factory create(
+      Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<PushFavoriteUseCase> pushFavoriteUseCaseProvider,
+      Provider<SyncFavoritesUseCase> syncFavoritesUseCaseProvider) {
+    return new FavoritesViewModel_Factory(favoritesRepositoryProvider, toggleFavoriteUseCaseProvider, pushFavoriteUseCaseProvider, syncFavoritesUseCaseProvider);
+  }
+
+  public static FavoritesViewModel newInstance(FavoritesRepository favoritesRepository,
+      ToggleFavoriteUseCase toggleFavoriteUseCase, PushFavoriteUseCase pushFavoriteUseCase,
+      SyncFavoritesUseCase syncFavoritesUseCase) {
+    return new FavoritesViewModel(favoritesRepository, toggleFavoriteUseCase, pushFavoriteUseCase, syncFavoritesUseCase);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/favorites/FavoritesViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.ui.favorites;
+
+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 = FavoritesViewModel.class
+)
+public final class FavoritesViewModel_HiltModules {
+  private FavoritesViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(FavoritesViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(FavoritesViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(FavoritesViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/history/HistoryViewModel_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.ui.history;
+
+import com.radiola.domain.repository.TrackHistoryRepository;
+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"
+})
+public final class HistoryViewModel_Factory implements Factory<HistoryViewModel> {
+  private final Provider<TrackHistoryRepository> trackHistoryRepositoryProvider;
+
+  public HistoryViewModel_Factory(Provider<TrackHistoryRepository> trackHistoryRepositoryProvider) {
+    this.trackHistoryRepositoryProvider = trackHistoryRepositoryProvider;
+  }
+
+  @Override
+  public HistoryViewModel get() {
+    return newInstance(trackHistoryRepositoryProvider.get());
+  }
+
+  public static HistoryViewModel_Factory create(
+      Provider<TrackHistoryRepository> trackHistoryRepositoryProvider) {
+    return new HistoryViewModel_Factory(trackHistoryRepositoryProvider);
+  }
+
+  public static HistoryViewModel newInstance(TrackHistoryRepository trackHistoryRepository) {
+    return new HistoryViewModel(trackHistoryRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/history/HistoryViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.ui.history;
+
+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 = HistoryViewModel.class
+)
+public final class HistoryViewModel_HiltModules {
+  private HistoryViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(HistoryViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(HistoryViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(HistoryViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/player/PlayerViewModel_Factory.java

@@ -0,0 +1,110 @@
+package com.radiola.ui.player;
+
+import com.radiola.domain.repository.NowPlayingRepository;
+import com.radiola.domain.repository.RecordingRepository;
+import com.radiola.domain.repository.SettingsRepository;
+import com.radiola.domain.repository.StationRepository;
+import com.radiola.domain.repository.TrackHistoryRepository;
+import com.radiola.domain.usecase.GetNowPlayingUseCase;
+import com.radiola.domain.usecase.GetStationsUseCase;
+import com.radiola.domain.usecase.SearchTrackInServiceUseCase;
+import com.radiola.domain.usecase.ToggleFavoriteUseCase;
+import com.radiola.domain.usecase.auth.PushHistoryUseCase;
+import com.radiola.service.PlayerController;
+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"
+})
+public final class PlayerViewModel_Factory implements Factory<PlayerViewModel> {
+  private final Provider<PlayerController> playerControllerProvider;
+
+  private final Provider<StationRepository> stationRepositoryProvider;
+
+  private final Provider<NowPlayingRepository> nowPlayingRepositoryProvider;
+
+  private final Provider<GetStationsUseCase> getStationsUseCaseProvider;
+
+  private final Provider<GetNowPlayingUseCase> getNowPlayingUseCaseProvider;
+
+  private final Provider<SearchTrackInServiceUseCase> searchTrackInServiceUseCaseProvider;
+
+  private final Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider;
+
+  private final Provider<TrackHistoryRepository> trackHistoryRepositoryProvider;
+
+  private final Provider<SettingsRepository> settingsRepositoryProvider;
+
+  private final Provider<RecordingRepository> recordingRepositoryProvider;
+
+  private final Provider<PushHistoryUseCase> pushHistoryUseCaseProvider;
+
+  public PlayerViewModel_Factory(Provider<PlayerController> playerControllerProvider,
+      Provider<StationRepository> stationRepositoryProvider,
+      Provider<NowPlayingRepository> nowPlayingRepositoryProvider,
+      Provider<GetStationsUseCase> getStationsUseCaseProvider,
+      Provider<GetNowPlayingUseCase> getNowPlayingUseCaseProvider,
+      Provider<SearchTrackInServiceUseCase> searchTrackInServiceUseCaseProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<TrackHistoryRepository> trackHistoryRepositoryProvider,
+      Provider<SettingsRepository> settingsRepositoryProvider,
+      Provider<RecordingRepository> recordingRepositoryProvider,
+      Provider<PushHistoryUseCase> pushHistoryUseCaseProvider) {
+    this.playerControllerProvider = playerControllerProvider;
+    this.stationRepositoryProvider = stationRepositoryProvider;
+    this.nowPlayingRepositoryProvider = nowPlayingRepositoryProvider;
+    this.getStationsUseCaseProvider = getStationsUseCaseProvider;
+    this.getNowPlayingUseCaseProvider = getNowPlayingUseCaseProvider;
+    this.searchTrackInServiceUseCaseProvider = searchTrackInServiceUseCaseProvider;
+    this.toggleFavoriteUseCaseProvider = toggleFavoriteUseCaseProvider;
+    this.trackHistoryRepositoryProvider = trackHistoryRepositoryProvider;
+    this.settingsRepositoryProvider = settingsRepositoryProvider;
+    this.recordingRepositoryProvider = recordingRepositoryProvider;
+    this.pushHistoryUseCaseProvider = pushHistoryUseCaseProvider;
+  }
+
+  @Override
+  public PlayerViewModel get() {
+    return newInstance(playerControllerProvider.get(), stationRepositoryProvider.get(), nowPlayingRepositoryProvider.get(), getStationsUseCaseProvider.get(), getNowPlayingUseCaseProvider.get(), searchTrackInServiceUseCaseProvider.get(), toggleFavoriteUseCaseProvider.get(), trackHistoryRepositoryProvider.get(), settingsRepositoryProvider.get(), recordingRepositoryProvider.get(), pushHistoryUseCaseProvider.get());
+  }
+
+  public static PlayerViewModel_Factory create(Provider<PlayerController> playerControllerProvider,
+      Provider<StationRepository> stationRepositoryProvider,
+      Provider<NowPlayingRepository> nowPlayingRepositoryProvider,
+      Provider<GetStationsUseCase> getStationsUseCaseProvider,
+      Provider<GetNowPlayingUseCase> getNowPlayingUseCaseProvider,
+      Provider<SearchTrackInServiceUseCase> searchTrackInServiceUseCaseProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<TrackHistoryRepository> trackHistoryRepositoryProvider,
+      Provider<SettingsRepository> settingsRepositoryProvider,
+      Provider<RecordingRepository> recordingRepositoryProvider,
+      Provider<PushHistoryUseCase> pushHistoryUseCaseProvider) {
+    return new PlayerViewModel_Factory(playerControllerProvider, stationRepositoryProvider, nowPlayingRepositoryProvider, getStationsUseCaseProvider, getNowPlayingUseCaseProvider, searchTrackInServiceUseCaseProvider, toggleFavoriteUseCaseProvider, trackHistoryRepositoryProvider, settingsRepositoryProvider, recordingRepositoryProvider, pushHistoryUseCaseProvider);
+  }
+
+  public static PlayerViewModel newInstance(PlayerController playerController,
+      StationRepository stationRepository, NowPlayingRepository nowPlayingRepository,
+      GetStationsUseCase getStationsUseCase, GetNowPlayingUseCase getNowPlayingUseCase,
+      SearchTrackInServiceUseCase searchTrackInServiceUseCase,
+      ToggleFavoriteUseCase toggleFavoriteUseCase, TrackHistoryRepository trackHistoryRepository,
+      SettingsRepository settingsRepository, RecordingRepository recordingRepository,
+      PushHistoryUseCase pushHistoryUseCase) {
+    return new PlayerViewModel(playerController, stationRepository, nowPlayingRepository, getStationsUseCase, getNowPlayingUseCase, searchTrackInServiceUseCase, toggleFavoriteUseCase, trackHistoryRepository, settingsRepository, recordingRepository, pushHistoryUseCase);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/player/PlayerViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.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/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/recordings/RecordingsViewModel_Factory.java

@@ -0,0 +1,45 @@
+package com.radiola.ui.recordings;
+
+import com.radiola.domain.repository.RecordingRepository;
+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"
+})
+public final class RecordingsViewModel_Factory implements Factory<RecordingsViewModel> {
+  private final Provider<RecordingRepository> recordingRepositoryProvider;
+
+  public RecordingsViewModel_Factory(Provider<RecordingRepository> recordingRepositoryProvider) {
+    this.recordingRepositoryProvider = recordingRepositoryProvider;
+  }
+
+  @Override
+  public RecordingsViewModel get() {
+    return newInstance(recordingRepositoryProvider.get());
+  }
+
+  public static RecordingsViewModel_Factory create(
+      Provider<RecordingRepository> recordingRepositoryProvider) {
+    return new RecordingsViewModel_Factory(recordingRepositoryProvider);
+  }
+
+  public static RecordingsViewModel newInstance(RecordingRepository recordingRepository) {
+    return new RecordingsViewModel(recordingRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/recordings/RecordingsViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.ui.recordings;
+
+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 = RecordingsViewModel.class
+)
+public final class RecordingsViewModel_HiltModules {
+  private RecordingsViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(RecordingsViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(RecordingsViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(RecordingsViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/settings/SettingsViewModel_Factory.java

@@ -0,0 +1,71 @@
+package com.radiola.ui.settings;
+
+import com.radiola.domain.repository.SettingsRepository;
+import com.radiola.domain.usecase.TestStationsUseCase;
+import com.radiola.domain.usecase.auth.GetAuthStateUseCase;
+import com.radiola.domain.usecase.auth.GetCurrentUserUseCase;
+import com.radiola.domain.usecase.auth.LogoutUseCase;
+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"
+})
+public final class SettingsViewModel_Factory implements Factory<SettingsViewModel> {
+  private final Provider<SettingsRepository> settingsRepositoryProvider;
+
+  private final Provider<TestStationsUseCase> testStationsUseCaseProvider;
+
+  private final Provider<GetAuthStateUseCase> getAuthStateUseCaseProvider;
+
+  private final Provider<GetCurrentUserUseCase> getCurrentUserUseCaseProvider;
+
+  private final Provider<LogoutUseCase> logoutUseCaseProvider;
+
+  public SettingsViewModel_Factory(Provider<SettingsRepository> settingsRepositoryProvider,
+      Provider<TestStationsUseCase> testStationsUseCaseProvider,
+      Provider<GetAuthStateUseCase> getAuthStateUseCaseProvider,
+      Provider<GetCurrentUserUseCase> getCurrentUserUseCaseProvider,
+      Provider<LogoutUseCase> logoutUseCaseProvider) {
+    this.settingsRepositoryProvider = settingsRepositoryProvider;
+    this.testStationsUseCaseProvider = testStationsUseCaseProvider;
+    this.getAuthStateUseCaseProvider = getAuthStateUseCaseProvider;
+    this.getCurrentUserUseCaseProvider = getCurrentUserUseCaseProvider;
+    this.logoutUseCaseProvider = logoutUseCaseProvider;
+  }
+
+  @Override
+  public SettingsViewModel get() {
+    return newInstance(settingsRepositoryProvider.get(), testStationsUseCaseProvider.get(), getAuthStateUseCaseProvider.get(), getCurrentUserUseCaseProvider.get(), logoutUseCaseProvider.get());
+  }
+
+  public static SettingsViewModel_Factory create(
+      Provider<SettingsRepository> settingsRepositoryProvider,
+      Provider<TestStationsUseCase> testStationsUseCaseProvider,
+      Provider<GetAuthStateUseCase> getAuthStateUseCaseProvider,
+      Provider<GetCurrentUserUseCase> getCurrentUserUseCaseProvider,
+      Provider<LogoutUseCase> logoutUseCaseProvider) {
+    return new SettingsViewModel_Factory(settingsRepositoryProvider, testStationsUseCaseProvider, getAuthStateUseCaseProvider, getCurrentUserUseCaseProvider, logoutUseCaseProvider);
+  }
+
+  public static SettingsViewModel newInstance(SettingsRepository settingsRepository,
+      TestStationsUseCase testStationsUseCase, GetAuthStateUseCase getAuthStateUseCase,
+      GetCurrentUserUseCase getCurrentUserUseCase, LogoutUseCase logoutUseCase) {
+    return new SettingsViewModel(settingsRepository, testStationsUseCase, getAuthStateUseCase, getCurrentUserUseCase, logoutUseCase);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/settings/SettingsViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.ui.settings;
+
+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 = SettingsViewModel.class
+)
+public final class SettingsViewModel_HiltModules {
+  private SettingsViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(SettingsViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(SettingsViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(SettingsViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/stations/StationsViewModel_Factory.java

@@ -0,0 +1,78 @@
+package com.radiola.ui.stations;
+
+import com.radiola.domain.repository.FavoritesRepository;
+import com.radiola.domain.repository.StationRepository;
+import com.radiola.domain.usecase.GetStationsUseCase;
+import com.radiola.domain.usecase.PlayStationUseCase;
+import com.radiola.domain.usecase.RefreshStationsUseCase;
+import com.radiola.domain.usecase.ToggleFavoriteUseCase;
+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"
+})
+public final class StationsViewModel_Factory implements Factory<StationsViewModel> {
+  private final Provider<GetStationsUseCase> getStationsUseCaseProvider;
+
+  private final Provider<RefreshStationsUseCase> refreshStationsUseCaseProvider;
+
+  private final Provider<PlayStationUseCase> playStationUseCaseProvider;
+
+  private final Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider;
+
+  private final Provider<FavoritesRepository> favoritesRepositoryProvider;
+
+  private final Provider<StationRepository> stationRepositoryProvider;
+
+  public StationsViewModel_Factory(Provider<GetStationsUseCase> getStationsUseCaseProvider,
+      Provider<RefreshStationsUseCase> refreshStationsUseCaseProvider,
+      Provider<PlayStationUseCase> playStationUseCaseProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<StationRepository> stationRepositoryProvider) {
+    this.getStationsUseCaseProvider = getStationsUseCaseProvider;
+    this.refreshStationsUseCaseProvider = refreshStationsUseCaseProvider;
+    this.playStationUseCaseProvider = playStationUseCaseProvider;
+    this.toggleFavoriteUseCaseProvider = toggleFavoriteUseCaseProvider;
+    this.favoritesRepositoryProvider = favoritesRepositoryProvider;
+    this.stationRepositoryProvider = stationRepositoryProvider;
+  }
+
+  @Override
+  public StationsViewModel get() {
+    return newInstance(getStationsUseCaseProvider.get(), refreshStationsUseCaseProvider.get(), playStationUseCaseProvider.get(), toggleFavoriteUseCaseProvider.get(), favoritesRepositoryProvider.get(), stationRepositoryProvider.get());
+  }
+
+  public static StationsViewModel_Factory create(
+      Provider<GetStationsUseCase> getStationsUseCaseProvider,
+      Provider<RefreshStationsUseCase> refreshStationsUseCaseProvider,
+      Provider<PlayStationUseCase> playStationUseCaseProvider,
+      Provider<ToggleFavoriteUseCase> toggleFavoriteUseCaseProvider,
+      Provider<FavoritesRepository> favoritesRepositoryProvider,
+      Provider<StationRepository> stationRepositoryProvider) {
+    return new StationsViewModel_Factory(getStationsUseCaseProvider, refreshStationsUseCaseProvider, playStationUseCaseProvider, toggleFavoriteUseCaseProvider, favoritesRepositoryProvider, stationRepositoryProvider);
+  }
+
+  public static StationsViewModel newInstance(GetStationsUseCase getStationsUseCase,
+      RefreshStationsUseCase refreshStationsUseCase, PlayStationUseCase playStationUseCase,
+      ToggleFavoriteUseCase toggleFavoriteUseCase, FavoritesRepository favoritesRepository,
+      StationRepository stationRepository) {
+    return new StationsViewModel(getStationsUseCase, refreshStationsUseCase, playStationUseCase, toggleFavoriteUseCase, favoritesRepository, stationRepository);
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/com/radiola/ui/stations/StationsViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.radiola.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 = StationsViewModel.class
+)
+public final class StationsViewModel_HiltModules {
+  private StationsViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(StationsViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(StationsViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(StationsViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/1/dagger/hilt/internal/aggregatedroot/codegen/_com_radiola_RadiolaApplication.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.radiola.RadiolaApplication",
+    rootPackage = "com.radiola",
+    originatingRoot = "com.radiola.RadiolaApplication",
+    originatingRootPackage = "com.radiola",
+    rootAnnotation = HiltAndroidApp.class,
+    rootSimpleNames = "RadiolaApplication",
+    originatingRootSimpleNames = "RadiolaApplication"
+)
+@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
+public class _com_radiola_RadiolaApplication {
+}

app/build/kspCaches/debug/backups/java/byRounds/1/hilt_aggregated_deps/_com_radiola_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.radiola.di.AppModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_di_AppModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/auth/AuthViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.ui.auth;
+
+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"
+})
+public final class AuthViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static AuthViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return AuthViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final AuthViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new AuthViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/favorites/FavoritesViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.ui.favorites;
+
+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"
+})
+public final class FavoritesViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static FavoritesViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return FavoritesViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final FavoritesViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new FavoritesViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/history/HistoryViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.ui.history;
+
+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"
+})
+public final class HistoryViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static HistoryViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return HistoryViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final HistoryViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new HistoryViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/player/PlayerViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.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"
+})
+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/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/recordings/RecordingsViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.ui.recordings;
+
+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"
+})
+public final class RecordingsViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static RecordingsViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return RecordingsViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final RecordingsViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new RecordingsViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/settings/SettingsViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.ui.settings;
+
+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"
+})
+public final class SettingsViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static SettingsViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return SettingsViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final SettingsViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new SettingsViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/com/radiola/ui/stations/StationsViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,40 @@
+package com.radiola.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"
+})
+public final class StationsViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static StationsViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return StationsViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    private static final StationsViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new StationsViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_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.radiola.MainActivity_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_MainActivity_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_RadiolaApplication_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.radiola.RadiolaApplication_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_RadiolaApplication_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_service_PlayerService_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.radiola.service.PlayerService_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_service_PlayerService_GeneratedInjector {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_auth_AuthViewModel_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.radiola.ui.auth.AuthViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_auth_AuthViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_auth_AuthViewModel_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.radiola.ui.auth.AuthViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_auth_AuthViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_favorites_FavoritesViewModel_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.radiola.ui.favorites.FavoritesViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_favorites_FavoritesViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_favorites_FavoritesViewModel_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.radiola.ui.favorites.FavoritesViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_favorites_FavoritesViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_history_HistoryViewModel_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.radiola.ui.history.HistoryViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_history_HistoryViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_history_HistoryViewModel_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.radiola.ui.history.HistoryViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_history_HistoryViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_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.radiola.ui.player.PlayerViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_player_PlayerViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_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.radiola.ui.player.PlayerViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_player_PlayerViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_recordings_RecordingsViewModel_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.radiola.ui.recordings.RecordingsViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_recordings_RecordingsViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_recordings_RecordingsViewModel_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.radiola.ui.recordings.RecordingsViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_recordings_RecordingsViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_settings_SettingsViewModel_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.radiola.ui.settings.SettingsViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_settings_SettingsViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_settings_SettingsViewModel_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.radiola.ui.settings.SettingsViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_settings_SettingsViewModel_HiltModules_KeyModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_stations_StationsViewModel_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.radiola.ui.stations.StationsViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_stations_StationsViewModel_HiltModules_BindsModule {
+}

app/build/kspCaches/debug/backups/java/byRounds/2/hilt_aggregated_deps/_com_radiola_ui_stations_StationsViewModel_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.radiola.ui.stations.StationsViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_radiola_ui_stations_StationsViewModel_HiltModules_KeyModule {
+}