Inserimento manuale delle dipendenze (visualizzazioni)

Concetti e implementazione di Jetpack Compose

L'architettura dell'app consigliata da Android incoraggia a dividere il codice in classi per sfruttare la separazione delle responsabilità, un principio in base al quale ogni classe della gerarchia ha una singola responsabilità definita. Ciò porta a un numero maggiore di classi più piccole che devono essere collegate per soddisfare le dipendenze reciproche.

Le app per Android sono in genere costituite da molte classi e alcune di queste dipendono l'una dall'altra.
Figura 1. Un modello del grafico dell'applicazione di un'app Android

Le dipendenze tra le classi possono essere rappresentate come un grafico, in cui ogni classe è collegata alle classi da cui dipende. La rappresentazione di tutte le classi e delle relative dipendenze costituisce il grafico dell'applicazione. Nella figura 1 puoi vedere un'astrazione del grafico dell'applicazione. Quando la classe A (ViewModel) dipende dalla classe B (Repository), è presente una linea che punta da A a B che rappresenta la dipendenza.

L'iniezione delle dipendenze consente di stabilire queste connessioni e di sostituire le implementazioni per i test. Ad esempio, quando testi un ViewModel che dipende da un repository, puoi passare implementazioni diverse diRepository con dati fittizi o simulazioni per testare i diversi casi.

Nozioni di base sull'iniezione manuale delle dipendenze

Questa sezione spiega come applicare l'iniezione manuale delle dipendenze in uno scenario reale di un'app Android. Descrive un approccio iterativo su come iniziare a utilizzare l'iniezione delle dipendenze nella tua app. L'approccio migliora fino a raggiungere un punto molto simile a quello che Dagger genererebbe automaticamente per te. Per ulteriori informazioni su Dagger, consulta Nozioni di base su Dagger.

Considera un flusso come un gruppo di schermate nella tua app che corrispondono a una funzionalità. L'accesso, la registrazione e il pagamento sono tutti esempi di flussi.

Quando si tratta di un flusso di accesso per una tipica app per Android, LoginActivity dipende da LoginViewModel, che a sua volta dipende da UserRepository. Poi UserRepository dipende da un UserLocalDataSource e da un UserRemoteDataSource, che a loro volta dipendono da un servizio Retrofit.

LoginActivity è il punto di ingresso del flusso di accesso e l'utente interagisce con l'attività. Pertanto, LoginActivity deve creare LoginViewModel con tutte le relative dipendenze.

Le classi Repository e DataSource del flusso sono le seguenti:

Kotlin

class UserRepository(
   private val localDataSource: UserLocalDataSource,
   private val remoteDataSource: UserRemoteDataSource
) { ... }

class UserLocalDataSource { ... }
class UserRemoteDataSource(
   private val loginService: LoginRetrofitService
) { ... }

Java

class UserLocalDataSource {
   public UserLocalDataSource() { }
   ...
}

class UserRemoteDataSource {

   private final Retrofit retrofit;

   public UserRemoteDataSource(Retrofit retrofit) {
       this.retrofit = retrofit;
   }

   ...
}

class UserRepository {

   private final UserLocalDataSource userLocalDataSource;
   private final UserRemoteDataSource userRemoteDataSource;

   public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) {
       this.userLocalDataSource = userLocalDataSource;
       this.userRemoteDataSource = userRemoteDataSource;
   }

   ...
}

Ecco come si presenta LoginActivity:

Kotlin

class LoginActivity: Activity() {

   private lateinit var loginViewModel: LoginViewModel

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)

       // In order to satisfy the dependencies of LoginViewModel, you have to also
       // satisfy the dependencies of all of its dependencies recursively.
       // First, create retrofit which is the dependency of UserRemoteDataSource
       val retrofit = Retrofit.Builder()
           .baseUrl("https://example.com")
           .build()
           .create(LoginService::class.java)

       // Then, satisfy the dependencies of UserRepository
       val remoteDataSource = UserRemoteDataSource(retrofit)
       val localDataSource = UserLocalDataSource()

       // Now you can create an instance of UserRepository that LoginViewModel needs
       val userRepository = UserRepository(localDataSource, remoteDataSource)

       // Lastly, create an instance of LoginViewModel with userRepository
       loginViewModel = LoginViewModel(userRepository)
   }
}

Java

public class MainActivity extends Activity {

   private LoginViewModel loginViewModel;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       // In order to satisfy the dependencies of LoginViewModel, you have to also
       // satisfy the dependencies of all of its dependencies recursively.
       // First, create retrofit which is the dependency of UserRemoteDataSource
       Retrofit retrofit = new Retrofit.Builder()
               .baseUrl("https://example.com")
               .build()
               .create(LoginService.class);

       // Then, satisfy the dependencies of UserRepository
       UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
       UserLocalDataSource localDataSource = new UserLocalDataSource();

       // Now you can create an instance of UserRepository that LoginViewModel needs
       UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

       // Lastly, create an instance of LoginViewModel with userRepository
       loginViewModel = new LoginViewModel(userRepository);
   }
}

Questo approccio presenta alcuni problemi:

  1. C'è molto codice boilerplate. Se volessi creare un'altra istanza di LoginViewModel in un'altra parte del codice, avresti una duplicazione del codice.

  2. Le dipendenze devono essere dichiarate in ordine. Devi creare un'istanza di UserRepository prima di LoginViewModel per poterla creare.

  3. È difficile riutilizzare gli oggetti. Se volessi riutilizzare UserRepository in più funzionalità, dovresti farlo seguire il pattern singleton. Il pattern singleton rende più difficili i test perché tutti i test condividono la stessa istanza singleton.

Gestire le dipendenze con un container

Per risolvere il problema del riutilizzo degli oggetti, puoi creare una tua classe container delle dipendenze da utilizzare per ottenere le dipendenze. Tutte le istanze fornite da questo container possono essere pubbliche. Nell'esempio, poiché hai bisogno solo di un'istanza di UserRepository, puoi rendere private le relative dipendenze con la possibilità di renderle pubbliche in futuro se devono essere fornite:

Kotlin

// Container of objects shared across the whole app
class AppContainer {

   // Since you want to expose userRepository out of the container, you need to satisfy
   // its dependencies as you did before
   private val retrofit = Retrofit.Builder()
                           .baseUrl("https://example.com")
                           .build()
                           .create(LoginService::class.java)

   private val remoteDataSource = UserRemoteDataSource(retrofit)
   private val localDataSource = UserLocalDataSource()

   // userRepository is not private; it'll be exposed
   val userRepository = UserRepository(localDataSource, remoteDataSource)
}

Java

// Container of objects shared across the whole app
public class AppContainer {

   // Since you want to expose userRepository out of the container, you need to satisfy
   // its dependencies as you did before
   private Retrofit retrofit = new Retrofit.Builder()
           .baseUrl("https://example.com")
           .build()
           .create(LoginService.class);

   private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit);
   private UserLocalDataSource localDataSource = new UserLocalDataSource();

   // userRepository is not private; it'll be exposed
   public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);
}

Poiché queste dipendenze vengono utilizzate in tutta l'applicazione, devono essere inserite in un luogo comune che tutte le attività possono utilizzare: la classe Application. Crea una classe Application personalizzata che contenga un'istanza AppContainer.

Kotlin

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
class MyApplication : Application() {

   // Instance of AppContainer that will be used by all the Activities of the app
   val appContainer = AppContainer()
}

Java

// Custom Application class that needs to be specified
// in the AndroidManifest.xml file
public class MyApplication extends Application {

   // Instance of AppContainer that will be used by all the Activities of the app
   public AppContainer appContainer = new AppContainer();
}

Ora puoi ottenere l'istanza di AppContainer dall'applicazione e ottenere l'istanza di UserRepository condivisa:

Kotlin

class LoginActivity: Activity() {

   private lateinit var loginViewModel: LoginViewModel

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)

       // Gets userRepository from the instance of AppContainer in Application
       val appContainer = (application as MyApplication).appContainer
       loginViewModel = LoginViewModel(appContainer.userRepository)
   }
}

Java

public class MainActivity extends Activity {

   private LoginViewModel loginViewModel;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       // Gets userRepository from the instance of AppContainer in Application
       AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
       loginViewModel = new LoginViewModel(appContainer.userRepository);
   }
}

In questo modo, non hai un UserRepository singleton. Hai invece un AppContainer condiviso in tutte le attività che contiene oggetti del grafico e crea istanze di questi oggetti che altre classi possono utilizzare.

Se LoginViewModel è necessario in più punti dell'applicazione, è utile avere un luogo centralizzato in cui creare istanze di LoginViewModel. Puoi spostare la creazione di LoginViewModel nel container e fornire nuovi oggetti di questo tipo con una factory. Il codice per un LoginViewModelFactory è il seguente:

Kotlin

// Definition of a Factory interface with a function to create objects of a type
interface Factory<T> {
   fun create(): T
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory(private val userRepository: UserRepository) : Factory<LoginViewModel> {
   override fun create(): LoginViewModel {
       return LoginViewModel(userRepository)
   }
}

Java

// Definition of a Factory interface with a function to create objects of a type
public interface Factory<T> {
   T create();
}

// Factory for LoginViewModel.
// Since LoginViewModel depends on UserRepository, in order to create instances of
// LoginViewModel, you need an instance of UserRepository that you pass as a parameter.
class LoginViewModelFactory implements Factory<LoginViewModel> {

   private final UserRepository userRepository;

   public LoginViewModelFactory(UserRepository userRepository) {
       this.userRepository = userRepository;
   }

   @Override
   public LoginViewModel create() {
       return new LoginViewModel(userRepository);
   }
}

Puoi includere LoginViewModelFactory in AppContainer e fare in modo che LoginActivity lo utilizzi:

Kotlin

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
class AppContainer {
   ...
   val userRepository = UserRepository(localDataSource, remoteDataSource)

   val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

class LoginActivity: Activity() {

   private lateinit var loginViewModel: LoginViewModel

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)

       // Gets LoginViewModelFactory from the application instance of AppContainer
       // to create a new LoginViewModel instance
       val appContainer = (application as MyApplication).appContainer
       loginViewModel = appContainer.loginViewModelFactory.create()
   }
}

Java

// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory
public class AppContainer {
   ...

   public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

   public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository);
}

public class MainActivity extends Activity {

   private LoginViewModel loginViewModel;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       // Gets LoginViewModelFactory from the application instance of AppContainer
       // to create a new LoginViewModel instance
       AppContainer appContainer = ((MyApplication) getApplication()).appContainer;
       loginViewModel = appContainer.loginViewModelFactory.create();
   }
}

Questo approccio è migliore del precedente, ma ci sono ancora alcune sfide da considerare:

  1. Devi gestire AppContainer autonomamente, creando le istanze per tutte le dipendenze a mano.
  2. C'è ancora molto codice boilerplate. Devi creare factory o parametri a mano a seconda che tu voglia riutilizzare un oggetto o meno.

Gestire le dipendenze nei flussi delle applicazioni

AppContainer diventa complicato quando vuoi includere più funzionalità nel progetto. Quando l'app diventa più grande e inizi a introdurre diversi flussi di funzionalità, si presentano ancora più problemi:

  1. Quando hai flussi diversi, potresti voler che gli oggetti esistano solo nell'ambito di quel flusso. Ad esempio, quando crei LoginUserData (che potrebbe essere costituito dal nome utente e dalla password utilizzati solo nel flusso di accesso), non vuoi conservare i dati di un vecchio flusso di accesso di un altro utente. Vuoi una nuova istanza per ogni nuovo flusso. Puoi farlo creando oggetti FlowContainer all'interno di AppContainer, come mostrato nel seguente esempio di codice.
  2. Anche l'ottimizzazione del grafico dell'applicazione e dei container di flusso può essere difficile. Devi ricordarti di eliminare le istanze di cui non hai bisogno, a seconda del flusso in cui ti trovi.

Supponiamo di avere un flusso di accesso composto da un'attività (LoginActivity) e più fragment (LoginUsernameFragment e LoginPasswordFragment). Queste visualizzazioni vogliono:

  1. Accedere alla stessa istanza LoginUserData che deve essere condivisa fino al termine del flusso di accesso.
  2. Creare una nuova istanza di LoginUserData all'avvio del flusso.

Puoi farlo con un container del flusso di accesso. Questo container deve essere creato all'avvio del flusso di accesso e rimosso dalla memoria al termine del flusso.

Aggiungiamo un LoginContainer al codice di esempio. Poiché vuoi poter creare più istanze di LoginContainer nell'app, anziché renderlo un singleton, rendilo una classe con le dipendenze di cui il flusso di accesso ha bisogno da AppContainer.

Kotlin

class LoginContainer(val userRepository: UserRepository) {

   val loginData = LoginUserData()

   val loginViewModelFactory = LoginViewModelFactory(userRepository)
}

// AppContainer contains LoginContainer now
class AppContainer {
   ...
   val userRepository = UserRepository(localDataSource, remoteDataSource)

   // LoginContainer will be null when the user is NOT in the login flow
   var loginContainer: LoginContainer? = null
}

Java

// Container with Login-specific dependencies
class LoginContainer {

   private final UserRepository userRepository;

   public LoginContainer(UserRepository userRepository) {
       this.userRepository = userRepository;
       loginViewModelFactory = new LoginViewModelFactory(userRepository);
   }

   public LoginUserData loginData = new LoginUserData();

   public LoginViewModelFactory loginViewModelFactory;
}

// AppContainer contains LoginContainer now
public class AppContainer {
   ...
   public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource);

   // LoginContainer will be null when the user is NOT in the login flow
   public LoginContainer loginContainer;
}

Una volta che hai un container specifico per un flusso, devi decidere quando creare ed eliminare l'istanza del container. Poiché il flusso di accesso è autonomo in un'attività (LoginActivity), è l'attività a gestire il ciclo di vita di quel container. LoginActivity può creare l'istanza in onCreate ed eliminarla in onDestroy.

Kotlin

class LoginActivity: Activity() {

   private lateinit var loginViewModel: LoginViewModel
   private lateinit var loginData: LoginUserData
   private lateinit var appContainer: AppContainer

   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       appContainer = (application as MyApplication).appContainer

       // Login flow has started. Populate loginContainer in AppContainer
       appContainer.loginContainer = LoginContainer(appContainer.userRepository)

       loginViewModel = appContainer.loginContainer.loginViewModelFactory.create()
       loginData = appContainer.loginContainer.loginData
   }

   override fun onDestroy() {
       // Login flow is finishing
       // Removing the instance of loginContainer in the AppContainer
       appContainer.loginContainer = null
       super.onDestroy()
   }
}

Java

public class LoginActivity extends Activity {

   private LoginViewModel loginViewModel;
   private LoginData loginData;
   private AppContainer appContainer;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);

       appContainer = ((MyApplication) getApplication()).appContainer;

       // Login flow has started. Populate loginContainer in AppContainer
       appContainer.loginContainer = new LoginContainer(appContainer.userRepository);

       loginViewModel = appContainer.loginContainer.loginViewModelFactory.create();
       loginData = appContainer.loginContainer.loginData;
   }

   @Override
   protected void onDestroy() {
       // Login flow is finishing
       // Removing the instance of loginContainer in the AppContainer
       appContainer.loginContainer = null;

       super.onDestroy();
   }
}

Come LoginActivity, i fragment di accesso possono accedere a LoginContainer da AppContainer e utilizzare l'istanza LoginUserData condivisa.

Poiché in questo caso hai a che fare con la logica del ciclo di vita della visualizzazione, è utile utilizzare l'osservazione del ciclo di vita.