Uruchamianie aplikacji Zawiera Android Jetpack.

Biblioteka startowa aplikacji zapewnia prosty i wydajny sposób inicjowania komponentów podczas uruchamiania aplikacji. Deweloperzy bibliotek i deweloperzy aplikacji Może wykorzystać rozszerzenie App Startup, by usprawnić sekwencje uruchamiania i ustalić kolejność jego zainicjowania.

Zamiast definiować osobnych dostawców treści dla każdego komponentu, umożliwia zdefiniowanie inicjatorów komponentów, które mają wspólny jednego dostawcy treści. Może to znacznie skrócić czas uruchamiania aplikacji.

Konfiguracja

Aby używać Jetpack Startup w bibliotece lub aplikacji, dodaj do Gradle ten kod: plik:

Odlotowe

dependencies {
    implementation "androidx.startup:startup-runtime:1.1.1"
}

Kotlin

dependencies {
    implementation("androidx.startup:startup-runtime:1.1.1")
}

Inicjowanie komponentów podczas uruchamiania aplikacji

Aplikacje i biblioteki często wymagają od razu inicjowania komponentów po uruchomieniu aplikacji. Możesz sprostać tym potrzebom, korzystając z usług dostawców treści, inicjowania każdej zależności, ale utworzenie instancji przez dostawców treści jest kosztowne i może niepotrzebnie spowolnić sekwencję uruchamiania. Dodatkowo Android inicjuje dostawców treści w nieokreślonej kolejności. App Startup zapewnia wydajniejszy sposób inicjowania komponentów podczas uruchamiania aplikacji określić zależności.

Aby używać rozszerzenia App Startup do automatycznego inicjowania komponentów podczas uruchamiania, musisz zdefiniuj inicjator komponentów dla każdego komponentu, którego aplikacja potrzebuje zainicjować.

Wdrażanie inicjatorów komponentów

Każdy inicjator komponentów definiuje się, tworząc klasę, która implementuje Initializer<T>. Ten interfejs definiuje 2 ważne metody:

  • Metodę create(), która zawiera wszystkie operacje niezbędne do zainicjuje komponent i zwróci instancję T.
  • Metoda dependencies(), która zwraca listę pozostałych Initializer<T> obiektów, od których zależy inicjator. Możesz użyć tej do sterowania kolejnością uruchamiania inicjatorów przez aplikację.

Załóżmy na przykład, że Twoja aplikacja zależy od WorkManager i musi: zainicjować go podczas uruchamiania. Zdefiniuj klasę WorkManagerInitializer, która implementuje funkcję Initializer<WorkManager>:

Kotlin

// Initializes WorkManager.
class WorkManagerInitializer : Initializer<WorkManager> {
    override fun create(context: Context): WorkManager {
        val configuration = Configuration.Builder().build()
        WorkManager.initialize(context, configuration)
        return WorkManager.getInstance(context)
    }
    override fun dependencies(): List<Class<out Initializer<*>>> {
        // No dependencies on other libraries.
        return emptyList()
    }
}

Java

// Initializes WorkManager.
class WorkManagerInitializer implements Initializer<WorkManager> {

    @Override
    public WorkManager create(Context context) {
        Configuration configuration = Configuration.Builder().build();
        WorkManager.initialize(context, configuration);
        return WorkManager.getInstance(context);
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // No dependencies on other libraries.
        return emptyList();
    }

}

Metoda dependencies() zwraca pustą listę, ponieważ WorkManager nie zwraca nie są zależne od innych bibliotek.

Załóżmy, że Twoja aplikacja jest również zależna od biblioteki o nazwie ExampleLogger, która w Włączanie zależy od funkcji WorkManager. Ta zależność oznacza, że musisz upewnić się, który najpierw inicjuje program WorkManager. Zdefiniuj Klasa ExampleLoggerInitializer, która korzysta z Initializer<ExampleLogger>:

Kotlin

// Initializes ExampleLogger.
class ExampleLoggerInitializer : Initializer<ExampleLogger> {
    override fun create(context: Context): ExampleLogger {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context))
    }

    override fun dependencies(): List<Class<out Initializer<*>>> {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return listOf(WorkManagerInitializer::class.java)
    }
}

Java

// Initializes ExampleLogger.
class ExampleLoggerInitializer implements Initializer<ExampleLogger> {

    @Override
    public ExampleLogger create(Context context) {
        // WorkManager.getInstance() is non-null only after
        // WorkManager is initialized.
        return ExampleLogger(WorkManager.getInstance(context));
    }

    @Override
    public List<Class<Initializer<?>>> dependencies() {
        // Defines a dependency on WorkManagerInitializer so it can be
        // initialized after WorkManager is initialized.
        return Arrays.asList(WorkManagerInitializer.class);
    }
}

Ponieważ umieszczasz WorkManagerInitializer w metodzie dependencies(), aplikacja Podczas uruchamiania WorkManager jest inicjowane przed ExampleLogger.

Skonfiguruj wpisy w pliku manifestu

App Startup obejmuje specjalnego dostawcę treści o nazwie InitializationProvider jest używany do wykrywania i wywoływania inicjatorów komponentów. Uruchamianie aplikacji wykrywa inicjatory komponentów, sprawdzając najpierw wpis <meta-data>. w wpisie InitializationProvider pliku manifestu. Następnie App Startup wywołuje metodę Metody dependencies() dla wszystkich inicjatorów, które zostały już wykryte.

Oznacza to, że aby inicjator komponentu był wykrywalny przez aplikację Podczas uruchamiania musi być spełniony jeden z tych warunków:

  • Inicjator komponentu ma odpowiedni wpis <meta-data> w kolumnie InitializationProvider wpis w pliku manifestu.
  • Inicjator komponentu jest wymieniony w metodzie dependencies() z parametru inicjator, który jest już wykrywalny.

Rozważmy jeszcze raz przykład z elementami WorkManagerInitializer i ExampleLoggerInitializer Aby aplikacja App Startup mogła wykryć inicjatory, do pliku manifestu dodaj:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <!-- This entry makes ExampleLoggerInitializer discoverable. -->
    <meta-data  android:name="com.example.ExampleLoggerInitializer"
          android:value="androidx.startup" />
</provider>

Nie musisz dodawać wpisu <meta-data> dla WorkManagerInitializer, ponieważ WorkManagerInitializer jest zależnością typu ExampleLoggerInitializer. Oznacza to, że jeśli ExampleLoggerInitializer jest wykrywalny, to tak jest WorkManagerInitializer

Atrybut tools:node="merge" gwarantuje, że scalanie manifestu prawidłowo rozwiązuje wszelkie konflikty wpisów.

Uruchom sprawdzanie lintowania

Biblioteka uruchamiania aplikacji zawiera zestaw reguł lintowania, których możesz używać do sprawdzania czy poprawnie zdefiniujesz inicjatory komponentów. Możesz wykonać przeprowadzić tę kontrolę, uruchamiając ./gradlew :app:lintDebug z wiersza poleceń.

Ręczne inicjowanie komponentów

Zwykle, gdy używasz uruchamiania aplikacji, obiekt InitializationProvider używa wywołania encja o nazwie AppInitializer na automatycznie wykrywa i uruchamia inicjatory komponentów podczas uruchamiania aplikacji. Możesz też użyć bezpośrednio AppInitializer, aby ręcznie inicjować komponenty, których aplikacja nie potrzebuje przy uruchamianiu; Jest to tzw. leniwe inicjowanie i może pomóc zminimalizować koszty uruchamiania.

Musisz najpierw wyłączyć automatyczne inicjowanie dla wybranych komponentów aby zainicjować go ręcznie.

Wyłączanie automatycznego inicjowania pojedynczego komponentu

Aby wyłączyć automatyczne inicjowanie pojedynczego komponentu, usuń Wpis <meta-data> inicjatora tego komponentu z pliku manifestu.

Na przykład dodanie następującego tekstu do pliku manifestu wyłącza automatyczne zainicjowanie dla ExampleLogger:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data android:name="com.example.ExampleLoggerInitializer"
              tools:node="remove" />
</provider>

Zamiast usuwać wpis, używasz we wpisie tools:node="remove" aby mieć pewność, że narzędzie do scalania usunie wpis ze wszystkich scalonych plików manifestu.

Wyłącz automatyczne inicjowanie wszystkich komponentów

Aby wyłączyć całe automatyczne inicjowanie, usuń cały wpis dotyczący InitializationProvider z pliku manifestu:

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    tools:node="remove" />

Ręczne wywoływanie inicjatorów komponentów

Jeśli automatyczne inicjowanie komponentu jest wyłączone, możesz użyć AppInitializer, aby ręcznie zainicjować ten komponent i jego zależności.

Na przykład poniższy kod wywołuje AppInitializer i ręcznie inicjuje ExampleLogger:

Kotlin

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer::class.java)

Java

AppInitializer.getInstance(context)
    .initializeComponent(ExampleLoggerInitializer.class);

W rezultacie App Startup również inicjuje WorkManager, ponieważ WorkManager zależność ExampleLogger.

Prześlij opinię

Podziel się z nami swoimi opiniami i pomysłami, korzystając z tych zasobów:

Narzędzie do śledzenia błędów
Zgłoś problemy, abyśmy mogli je naprawić.
.
. .