Manuel bağımlılık ekleme (Görünümler)

Kavramlar ve Jetpack Compose uygulaması

Android'in önerdiği uygulama mimarisi, kodu sınıflara bölerek sorumlulukların ayrılmasından yararlanmanızı teşvik eder. Bu ilkeye göre, hiyerarşideki her sınıfın tek bir tanımlanmış sorumluluğu vardır. Bu durum, birbirlerinin bağımlılıklarını karşılamak için bağlanması gereken daha fazla ve daha küçük sınıflara yol açar.

Android uygulamaları genellikle birçok sınıftan oluşur ve bu sınıfların bazıları birbirine bağlıdır.
Şekil 1. Android uygulamasının uygulama grafiği modeli

Sınıflar arasındaki bağımlılıklar, her sınıfın bağlı olduğu sınıflara bağlandığı bir grafik olarak gösterilebilir. Tüm sınıflarınızın ve bağımlılıklarının temsili, uygulama grafiğini oluşturur. Şekil 1'de uygulama grafiğinin bir soyutlamasını görebilirsiniz. A sınıfı (ViewModel) B sınıfına (Repository) bağlı olduğunda, bu bağımlılığı temsil eden ve A'dan B'ye doğru yönelen bir çizgi vardır.

Bağımlılık ekleme, bu bağlantıların kurulmasına yardımcı olur ve test için uygulamaları değiştirmenize olanak tanır. Örneğin, bir depoya bağlı olan bir ViewModel test ederken farklı durumları test etmek için sahteler veya taklitlerle Repository'nin farklı uygulamalarını iletebilirsiniz.

Manuel bağımlılık eklemenin temelleri

Bu bölümde, gerçek bir Android uygulaması senaryosunda manuel bağımlılık eklemenin nasıl uygulanacağı açıklanmaktadır. Bu dokümanda, uygulamanızda bağımlılık eklemeyi kullanmaya nasıl başlayabileceğinize dair yinelemeli bir yaklaşım açıklanmaktadır. Yaklaşım, Dagger'ın sizin için otomatik olarak oluşturacağı yaklaşıma çok benzeyen bir noktaya ulaşana kadar iyileştirilir. Dagger hakkında daha fazla bilgi için Dagger'ın temel özellikleri başlıklı makaleyi inceleyin.

Akış, uygulamanızdaki bir özelliğe karşılık gelen bir grup ekran olarak kabul edilir. Giriş, kayıt ve ödeme işlemleri akış örnekleridir.

Tipik bir Android uygulamasının giriş akışını kapsarken LoginActivity, LoginViewModel'ye, LoginViewModel ise UserRepository'ye bağlıdır. Ardından UserRepository, UserLocalDataSource ve UserRemoteDataSource'a bağlıdır. Bu da Retrofit hizmetine bağlıdır.

LoginActivity, oturum açma akışının giriş noktasıdır ve kullanıcı, etkinlikle etkileşimde bulunur. Bu nedenle, LoginActivity, tüm bağımlılıklarıyla birlikte LoginViewModel oluşturmalıdır.

Akışın Repository ve DataSource sınıfları şu şekilde görünür:

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;
   }

   ...
}

LoginActivity simgesi şu şekilde görünür:

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);
   }
}

Bu yaklaşımla ilgili sorunlar vardır:

  1. Çok fazla ortak metin kodu var. Kodun başka bir bölümünde LoginViewModel öğesinin başka bir örneğini oluşturmak istiyorsanız kod tekrarı olur.

  2. Bağımlılıklar sırayla beyan edilmelidir. UserRepository öğesini oluşturmak için LoginViewModel öğesinden önce başlatmanız gerekir.

  3. Nesneleri yeniden kullanmak zordur. UserRepository öğesini birden fazla özellikte yeniden kullanmak istiyorsanız tekil örnek oluşturma düzenine uymanız gerekir. Tüm testler aynı tekil örnekle paylaşıldığı için tekil örnek kalıbı, test etmeyi zorlaştırır.

Bağımlılıkları kapsayıcıyla yönetme

Nesneleri yeniden kullanma sorununu çözmek için bağımlılıkları almak üzere kullandığınız kendi dependencies container sınıfınızı oluşturabilirsiniz. Bu kapsayıcı tarafından sağlanan tüm örnekler herkese açık olabilir. Örnekte, yalnızca UserRepository örneğine ihtiyacınız olduğundan, bağımlılıklarını gizli yapabilirsiniz. İleride sağlanmaları gerekirse bunları herkese açık hale getirebilirsiniz:

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);
}

Bu bağımlılıklar uygulamanın tamamında kullanıldığından tüm etkinliklerin kullanabileceği ortak bir yere (Application sınıfı) yerleştirilmesi gerekir. AppContainer örneği içeren özel bir Application sınıfı oluşturun.

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();
}

Artık uygulamadan AppContainer örneğini alabilir ve paylaşılan UserRepository örneğini elde edebilirsiniz:

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);
   }
}

Bu şekilde, tekil UserRepository olmaz. Bunun yerine, grafikteki nesneleri içeren ve diğer sınıfların kullanabileceği bu nesnelerin örneklerini oluşturan, tüm etkinlikler arasında AppContainer paylaşılan bir alanınız vardır.

Uygulamada LoginViewModel öğesinin daha fazla yerde kullanılması gerekiyorsa LoginViewModel örneklerini oluşturacağınız merkezi bir yer olması mantıklıdır. LoginViewModel oluşturma işlemini kapsayıcıya taşıyabilir ve bu türden yeni nesneleri bir fabrika ile sağlayabilirsiniz. LoginViewModelFactory için kod şu şekilde görünür:

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);
   }
}

LoginViewModelFactory öğesini AppContainer içine ekleyebilir ve LoginActivity öğesinin bunu kullanmasını sağlayabilirsiniz:

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();
   }
}

Bu yaklaşım, önceki yaklaşımdan daha iyidir ancak yine de göz önünde bulundurulması gereken bazı zorluklar vardır:

  1. Tüm bağımlılıklar için örnekleri manuel olarak oluşturarak AppContainer'ı kendiniz yönetmeniz gerekir.
  2. Hâlâ çok fazla ortak metin kodu var. Bir nesneyi yeniden kullanmak isteyip istemediğinize bağlı olarak fabrikaları veya parametreleri manuel olarak oluşturmanız gerekir.

Uygulama akışlarında bağımlılıkları yönetme

AppContainer projeye daha fazla işlev eklemek istediğinizde karmaşık hale gelir. Uygulamanız büyüdüğünde ve farklı özellik akışları kullanmaya başladığınızda daha da fazla sorun ortaya çıkar:

  1. Farklı akışlarınız olduğunda nesnelerin yalnızca söz konusu akışın kapsamında yer almasını isteyebilirsiniz. Örneğin, LoginUserData oluştururken (yalnızca giriş akışında kullanılan kullanıcı adı ve paroladan oluşabilir) farklı bir kullanıcının eski giriş akışındaki verileri kalıcı hale getirmek istemezsiniz. Her yeni akış için yeni bir örnek istiyorsanız. Bunu, bir sonraki kod örneğinde gösterildiği gibi AppContainer içinde FlowContainer nesneleri oluşturarak yapabilirsiniz.
  2. Uygulama grafiğini ve akış kapsayıcılarını optimize etmek de zor olabilir. Bulunduğunuz akışa bağlı olarak, ihtiyacınız olmayan örnekleri silmeyi unutmayın.

Tek bir etkinlik (LoginActivity) ve birden fazla parçadan (LoginUsernameFragment ve LoginPasswordFragment) oluşan bir giriş akışınız olduğunu düşünün. Bu görünümler şunları yapmak istiyor:

  1. Giriş akışı tamamlanana kadar paylaşılması gereken aynı LoginUserData örneğine erişin.
  2. Akış yeniden başladığında LoginUserData öğesinin yeni bir örneğini oluşturun.

Bunu bir giriş akışı kapsayıcısıyla sağlayabilirsiniz. Bu kapsayıcı, giriş akışı başladığında oluşturulmalı ve akış sona erdiğinde bellekten kaldırılmalıdır.

Örnek koda LoginContainer ekleyelim. Uygulamada LoginContainer öğesinin birden fazla örneğini oluşturmak istiyorsunuz. Bu nedenle, tekil bir öğe oluşturmak yerine, giriş akışının AppContainer öğesinden ihtiyaç duyduğu bağımlılıkları içeren bir sınıf oluşturun.

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;
}

Bir akışa özel bir kapsayıcınız olduğunda kapsayıcı örneğini ne zaman oluşturacağınıza ve sileceğinize karar vermeniz gerekir. Giriş akışınız bir etkinlikte (LoginActivity) bağımsız olarak yer aldığından, bu kapsayıcının yaşam döngüsünü yöneten etkinliktir. LoginActivity, örneği onCreate içinde oluşturabilir ve onDestroy içinde silebilir.

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();
   }
}

LoginActivity gibi, giriş parçaları da AppContainer konumundaki LoginContainer öğesine erişebilir ve paylaşılan LoginUserData örneğini kullanabilir.

Bu durumda görünüm yaşam döngüsü mantığıyla uğraştığınız için lifecycle observation kullanmak mantıklıdır.