Czym jest modularność w kontekście tworzenia…

Modułowość wielomodułowa to podejście architektoniczne, w którym aplikacja jest dzielona na oddzielne, logicznie powiązane moduły. Każdy moduł stanowi samodzielną jednostkę kodu (np. moduł biblioteki lub moduł aplikacji), którą można zbudować i przetestować niezależnie.

Zalety modułowości wielomodułowej:

Przyspieszenie kompilacji: Wprowadzając zmiany tylko w jednym module, kompilowane są tylko zależne od niego moduły, co znacznie skraca czas budowania projektu.
Lepsza organizacja kodu: Kod staje się bardziej zarządzalny i czytelny, ponieważ jest podzielony na wyraźnie określone obszary odpowiedzialności.
Zwiększenie ponownego użycia: Wspólne funkcje i komponenty UI mogą być wyodrębnione do osobnych modułów i używane w różnych częściach aplikacji lub nawet w innych projektach.
Ułatwienie testowania: Moduły mogą być testowane izolowanie, co upraszcza pisanie i utrzymanie testów.
Wsparcie dla rozwoju zorientowanego na funkcje: Oddzielne funkcje (ekrany, funkcjonalności) mogą być rozwijane jako niezależne moduły.
Zwiększenie skalowalności: Duże zespoły mogą pracować równolegle nad różnymi modułami z minimalnymi konfliktami.

Typy modułów w Android:

Moduł aplikacji (Application module): Punkt wejścia do aplikacji, zawierający manifest i główne komponenty. Zależy od innych modułów.
Moduł biblioteki (Library module): Zawiera kod i zasoby, które mogą być używane przez inne moduły (np. komponenty UI, wspólna logika biznesowa, narzędzia pomocnicze).
Moduł funkcji dynamicznej (Dynamic Feature module): Umożliwia ładowanie określonych części funkcjonalności aplikacji na żądanie. Używany do zmniejszenia rozmiaru pliku instalacyjnego.

Przykład struktury projektu z modułami:

my-android-app/
├── app/              // Moduł aplikacji
│   └── src/
│       └── main/
│           └── ...
├── core/             // Główny moduł biblioteki (wspólne narzędzia)
│   └── src/
│       └── main/
│           └── ...
├── ui/               // Moduł biblioteki UI (niestandardowe komponenty UI)
│   └── src/
│       └── main/
│           └── ...
└── feature-login/    // Moduł funkcji logowania
    └── src/
        └── main/
            └── ...

W pliku settings.gradle.kts wskazuje się dołączone moduły:

// settings.gradle.kts
rootProject.name = "MyAndroidApp"
include(":app")
include(":core")
include(":ui")
include(":feature-login")

W pliku build.gradle.kts modułu określa się zależności:

// app/build.gradle.kts
plugins {
    id("com.android.application")
    // ... inne pluginy
}

android {
    // ...
}

dependencies {
    implementation(project(":core"))
    implementation(project(":ui"))
    implementation(project(":feature-login"))
    // ... inne zależności
}

// feature-login/build.gradle.kts
plugins {
    id("com.android.library")
    // ... inne pluginy
}

android {
    // ...
}

dependencies {
    implementation(project(":core")) // Zależność od modułu core
    // ... inne zależności
}

Modułowość wielomodułowa jest zalecanym podejściem do rozwoju dużych i średnich aplikacji Android.

Czym jest modularność w kontekście tworzenia aplikacji Android?