refactor(page): 删除旧版页面文件

.agents/skills/kotlin-tooling-java-to-kotlin/references/frameworks/DAGGER-HILT.md

@@ -0,0 +1,160 @@
+# Dagger / Hilt Conversion Guide
+
+## When This Applies
+
+This guide applies when the Java source contains imports matching `dagger.*` or
+`dagger.hilt.*`. This covers Dagger 2, Hilt for Android, and Hilt Jetpack integrations.
+
+## Key Rules
+
+### 1. @Inject constructor syntax
+
+Kotlin places `@Inject` before the `constructor` keyword in the primary constructor:
+
+```kotlin
+class Foo @Inject constructor(private val bar: Bar)
+```
+
+### 2. @Module classes with @Provides methods
+
+Keep `@Provides` methods `open`, or use `object` for modules that contain only
+`@JvmStatic` provides methods (companion object pattern):
+
+```kotlin
+@Module
+@InstallIn(SingletonComponent::class)
+object NetworkModule {
+    @Provides
+    @Singleton
+    fun provideOkHttpClient(): OkHttpClient = OkHttpClient.Builder().build()
+}
+```
+
+### 3. @Binds abstract methods
+
+`@Binds` methods work in abstract classes exactly as in Java. Convert the abstract
+class directly — no special Kotlin considerations.
+
+### 4. Hilt Android annotations
+
+`@HiltAndroidApp`, `@AndroidEntryPoint`, `@HiltViewModel` — preserve these exactly
+on Application, Activity, Fragment, and ViewModel classes.
+
+### 5. Scoping annotations
+
+`@Singleton`, `@ActivityScoped`, `@ViewModelScoped`, `@FragmentScoped` — preserve
+exactly. No annotation site target is needed.
+
+### 6. @AssistedInject / @AssistedFactory
+
+`@AssistedInject` replaces `@Inject` on the constructor. `@Assisted` parameters
+appear alongside regular injected parameters in the primary constructor:
+
+```kotlin
+class PlayerViewModel @AssistedInject constructor(
+    @Assisted private val playerId: String,
+    private val repository: PlayerRepository
+) : ViewModel()
+```
+
+### 7. @Component / @Subcomponent interfaces
+
+Convert directly to Kotlin interfaces. Dagger's annotation processing works
+identically with Kotlin interfaces via kapt or KSP.
+
+---
+
+## Examples
+
+### Example 1: Hilt ViewModel with @Inject Constructor and a @Module
+
+**Java:**
+
+```java
+package com.acme.feature;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.lifecycle.HiltViewModel;
+import dagger.hilt.components.SingletonComponent;
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+@HiltViewModel
+public class UserProfileViewModel extends ViewModel {
+
+    private final UserRepository userRepository;
+    private final AnalyticsTracker analyticsTracker;
+
+    @Inject
+    public UserProfileViewModel(UserRepository userRepository, AnalyticsTracker analyticsTracker) {
+        this.userRepository = userRepository;
+        this.analyticsTracker = analyticsTracker;
+    }
+
+    public LiveData<User> getUser(String userId) {
+        analyticsTracker.trackProfileView(userId);
+        return userRepository.getUser(userId);
+    }
+}
+
+@Module
+@InstallIn(SingletonComponent.class)
+public class AnalyticsModule {
+
+    @Provides
+    @Singleton
+    public AnalyticsTracker provideAnalyticsTracker(Application app) {
+        return new AnalyticsTracker(app);
+    }
+}
+```
+
+**Kotlin:**
+
+```kotlin
+package com.acme.feature
+
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.ViewModel
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@HiltViewModel
+class UserProfileViewModel @Inject constructor(
+    private val userRepository: UserRepository,
+    private val analyticsTracker: AnalyticsTracker
+) : ViewModel() {
+
+    fun getUser(userId: String): LiveData<User> {
+        analyticsTracker.trackProfileView(userId)
+        return userRepository.getUser(userId)
+    }
+}
+
+@Module
+@InstallIn(SingletonComponent::class)
+object AnalyticsModule {
+
+    @Provides
+    @Singleton
+    fun provideAnalyticsTracker(app: Application): AnalyticsTracker {
+        return AnalyticsTracker(app)
+    }
+}
+```
+
+Key changes:
+- `@Inject` moves before the `constructor` keyword in the primary constructor.
+- Constructor parameters become `private val` in the primary constructor.
+- The module class becomes an `object` since it contains only static-like provides methods.
+- `SingletonComponent.class` becomes `SingletonComponent::class` (Kotlin class reference).
+- Java getter method `getUser` becomes a regular function `getUser` (no `get` prefix
+  convention change needed here since it takes a parameter).