השהיה באפליקציות עם מודולים מרובים

כדי ליצור קוד Hilt נדרשת גישה לכל המודולים של Gradle שמשתמשים ב-Hilt. מודול Gradle שמרכיבים את בכיתה Application צריכים להיות כל הפריטים של Hilt של המודולים ושל המחלקות המוחדרות ל-constructor במסגרת יחסי התלות המעבריים שלהם.

אם הפרויקט מרובה המודולים מורכב ממודולים רגילים של Gradle, אתם יכולים השתמשו ב-Hilt כפי שמתואר בהחדרת תלות עם עילית. עם זאת, זו לא במקרה של אפליקציות שכוללות את התכונה מודולים.

מודולים של פיצ'רים

במודולים של תכונות, האופן שבו המודולים בדרך כלל תלויים זה בזה הוא הפוך. לכן, Hilt לא יכול לעבד הערות במודולים של תכונות. צריך משתמשים ב-Dagger כדי לבצע החדרת תלות במודולים של התכונות.

כדי לפתור את הבעיה הזו במודולים של מאפיינים, צריך להשתמש ביחסי תלות של רכיבים. הוספה למעקב את השלבים הבאים:

1. להצהיר על הממשק @EntryPoint במודול app (או בכל מודול אחר שניתן לעבד על ידי Hilt) ביחסי התלות שדרושים למודול התכונה.
2. יוצרים רכיב Dagger שתלוי בממשק של @EntryPoint.
3. משתמשים ב-Dagger כרגיל במודול התכונה.

ניקח לדוגמה את הדוגמה מהחדרת תלות עם עמוד. נניח שהוספת login מודול של פיצ'ר לפרויקט. אתם מטמיעים את תכונת ההתחברות עם פעילות בשם LoginActivity. זה אומר שאפשר לקבל קישורים רק מהרכיב של האפליקציה.

כדי להשתמש בתכונה הזו, צריך OkHttpClient עם הקישור authInterceptor.

קודם כול צריך ליצור ממשק @EntryPoint שמותקן דרך SingletonComponent עם הקישורים שנחוצים למודול login:

// LoginModuleDependencies.kt - File in the app module.

@EntryPoint
@InstallIn(SingletonComponent::class)
interface LoginModuleDependencies {

  @AuthInterceptorOkHttpClient
  fun okHttpClient(): OkHttpClient
}

// LoginModuleDependencies.java - File in the app module.

@EntryPoint
@InstallIn(SingletonComponent.class)
public interface LoginModuleDependencies {

  @AuthInterceptorOkHttpClient
  OkHttpClient okHttpClient();
}

כדי לבצע החדרת שדה ב-LoginActivity, צריך ליצור צלבון רכיב שתלוי בממשק @EntryPoint:

// LoginComponent.kt - File in the login module.

@Component(dependencies = [LoginModuleDependencies::class])
interface LoginComponent {

  fun inject(activity: LoginActivity)

  @Component.Builder
  interface Builder {
    fun context(@BindsInstance context: Context): Builder
    fun appDependencies(loginModuleDependencies: LoginModuleDependencies): Builder
    fun build(): LoginComponent
  }
}

// LoginComponent.java - File in the login module.

@Component(dependencies = LoginModuleDependencies.class)
public interface LoginComponent {

  void inject(LoginActivity loginActivity);

  @Component.Builder
  interface Builder {
    Builder context(@BindsInstance Context context);
    Builder appDependencies(LoginModuleDependencies loginModuleDependencies);
    LoginComponent build();
  }
}

לאחר השלמת השלבים, משתמשים ב-Dagger כרגיל במודול התכונה. עבור אפשר להשתמש בקישורים מ-SingletonComponent התלות במחלקה:

// LoginAnalyticsAdapter.kt - File in the login module.

class LoginAnalyticsAdapter @Inject constructor(
  @AuthInterceptorOkHttpClient okHttpClient: OkHttpClient
) { ... }

// LoginAnalyticsAdapter.java - File in the login module.

public class LoginAnalyticsAdapter {

  private final OkHttpClient okHttpClient;

  @Inject
  LoginAnalyticsAdapter(
    @AuthInterceptorOkHttpClient OkHttpClient okHttpClient
  ) {
    this.okHttpClient = okHttpClient;
  }
  ...
}

כדי לבצע החדרת שדה, צריך ליצור מופע של רכיב Dagger משתמשים ב-applicationContext כדי לקבל את יחסי התלות של SingletonComponent:

// LoginActivity.kt - File in the login module.

class LoginActivity : AppCompatActivity() {

  @Inject
  lateinit var loginAnalyticsAdapter: LoginAnalyticsAdapter

  override fun onCreate(savedInstanceState: Bundle?) {
    DaggerLoginComponent.builder()
        .context(this)
        .appDependencies(
          EntryPointAccessors.fromApplication(
            applicationContext,
            LoginModuleDependencies::class.java
          )
        )
        .build()
        .inject(this)

    super.onCreate(savedInstanceState)
    ...
  }
}

// LoginActivity.java - File in the login module.

public class LoginActivity extends AppCompatActivity {

  @Inject
  LoginAnalyticsAdapter loginAnalyticsAdapter;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    DaggerLoginComponent.builder()
        .context(this)
        .appDependencies(
          EntryPointAccessors.fromApplication(
            getApplicationContext(),
            LoginModuleDependencies.class
          )
        )
        .build()
        .inject(this);

    super.onCreate(savedInstanceState);
    ...
  }
}

למידע נוסף על יחסי תלות של מודולים במודולים של תכונות, ראו יחסי תלות של רכיבים עם תכונה מודולים.

למידע נוסף על Dagger ב-Android, ראו שימוש ב-Dagger ב-Android. של Google.