Dague-2 Android comment fournir la dépendance des paramètres méthode

Question

J'ai un module FragmentModule

@Module 
public class FragmentModule 
{ 
    @Provides 
    public static PickerDashboardFragment providesPickerDashboard(int status, String name, Object someComplexObject) 
    { 
     PickerDashboardFragment fragment = new PickerDashboardFragment(); 
     Bundle b = new Bundle(); 
     b.putInt("status", status); 
     b.putString("name", name); 
     b.putInt("object", someComplexObject); 
     fragment.setArguments(bundle); 
     return fragment; 
    } 

    @Provides 
    public static PickingFragment providesPickingFragment() 
    { 
     PickingFragment fragment = new PickingFragment(); 
     return fragment; 
    } 
} 

Voici ma classe Component

@Component(modules = {UtilModule.class, FragmentModule.class}) 
public interface ApplicationComponent 
{ 
    void inject(PickerDashboardActivity target); 
} 

Dans mon activité Voilà comment je suis l'injection du PickerDashboardActivity

@Inject 
PickerDashboardFragment frag; 

ApplicationComponent component = DaggerApplicationComponent.builder().build(); 
     component.inject(this); 

Ma question i s Quelle est la meilleure et la plus simple façon de fournir les dépendances pour le statut, le nom et someComplexObject de PickerDashboardFragment providesPickerDashboard(int status, String name, Object someComplexObject).

Cordialement

Answer 1

Ajouter des attributs et Provides méthodes à votre module comme celui-ci:

@Module 
public class FragmentModule 
{ 

    private final int status; 
    private final String name; 
    private final Object someComplexObject; 

    public FragmentModule(int status, String name, Object someComplexObject) { 
     this.status = status; 
     this.name = name; 
     this.someComplexObject = someComplexObject; 
    } 

    @Provides 
    int providesStatus() { 
     return status; 
    } 

    @Provides 
    String providesName() { 
     return name; 
    } 

    @Provides 
    Object providesSomeComplexObject() { 
     return someComplexObjext; 
    } 

    @Provides 
    public static PickerDashboardFragment providesPickerDashboard(int status, String name, Object someComplexObject) 
    { 
     PickerDashboardFragment fragment = new PickerDashboardFragment(); 
     Bundle b = new Bundle(); 
     b.putInt("status", status); 
     b.putString("name", name); 
     b.putInt("object", someComplexObject); 
     fragment.setArguments(bundle); 
     return fragment; 
    } 

    @Provides 
    public static PickingFragment providesPickingFragment() 
    { 
     PickingFragment fragment = new PickingFragment(); 
     return fragment; 
    } 
} 

Avoir un module fournissant ints et cordes va probablement vous faire utiliser des qualificatifs (tels que Named) afin de Évitez les collisions

Answer 2

N'injectez pas de fragments dans vos activités à l'aide de la dague 2. Pourquoi? Les fragments ont un cycle de vie contrôlé par le système d'exploitation Android. Lorsque vous ajoutez un fragment à une activité à l'aide d'une transaction, FragmentManager conserve une référence au fragment. Lorsque l'activité instanceState est enregistrée, les fragments ajoutés à FragmentManager seront enregistrés. Lorsque l'activité est restaurée, si vous demandez une injection sans vérifier la présence du fragment dans FragmentManager, votre activité commence à référencer deux instances du fragment et crée une fuite de mémoire. Pour cette raison, dans la méthode void onCreate(Bundle savedInstanceState), vous devez vérifier la présence du fragment conservé dans le gestionnaire de fragmentation plutôt que de demander l'injection de Dagger 2. Si le fragment n'est pas conservé, vous pouvez l'instancier à ce point. Il est parfaitement possible d'utiliser le mot-clé new ou des usines statiques pour cela.

Exemple:

MyFragment frag; 

void onCreate(Bundle savedInstanceState) { 
    setContentView(R.layout.content); 
    frag = fragmentManager.findFragmentByTag(MyFragment.TAG); 
    if (frag == null) { 
     frag = MyFragment.instantiate(new Bundle()); 
    } 
} 

Cependant, à un autre niveau, il semble que vous demandez comment combiner les paramètres et les dépendances. Une bonne solution pour ceux-ci est souvent Factories. Disons que vous avez un CAFETIÈRE:

class CoffeeMaker { 

    private final Kettle kettle; 
    private final Grinder grinder; 
    private final BeanFlavour beanFlavour; 

    CoffeeMaker(Kettle kettle, Grinder grinder, BeanFlavour beanFlavour) { 
     this.kettle = kettle; 
     this.grinder = grinder; 
     this.beanFlavour = beanFlavour; 
    } 
} 

Le beanFlavour est variable (sombre, rôti, etc.) et varie et est donc plus comme un paramètre d'une dépendance. Vous pouvez ensuite écrire un CoffeeMakerFactory et injectez cela en utilisant Dagger 2:

class CoffeeMakerFactory { 

    private final Kettle kettle; 
    private final Grinder grinder; 

    @Inject 
    CoffeeMakerFactory(Kettle kettle, Grinder grinder) { 
     this.kettle = kettle; 
     this.grinder = grinder; 
    } 

    public CoffeeMaker create(BeanFlavour beanFlavour) { 
     return new CoffeeMaker(kettle, grinder, beanFlavour); 
    } 
} 

usines sont la solution standard pour une combinaison de dépendance et les paramètres see here et ils peuvent même être être générées à l'aide des outils de génération de code comme Google Auto.