Podstawy aplikacji

Aplikacje na Androida można pisać w Kotlin – języku programowania w Javie i językach C++. Narzędzia pakietu Android SDK kompilują kod wraz z danymi i plikami zasobów do pliku APK lub pakietu Android App Bundle.

Pakiet na Androida, który jest plikiem archiwum z sufiksem .apk, zawiera zawartość aplikacji na Androida wymaganej w czasie działania. To plik opracowany przez system urządzeń, na których aplikacja została zainstalowana.

Android App Bundle, który jest plikiem archiwum z sufiksem .aab, zawiera zawartość projektu aplikacji na Androida, w tym dodatkowe metadane, które nie są wymagane na w środowisku wykonawczym. Pakiet aplikacji na Androida jest formatem publikowania i nie można go zainstalować na urządzeniach z Androidem. it opóźnia wygenerowanie i podpisanie pliku APK na późniejszym etapie.

Gdy rozpowszechniasz aplikację w Google Na przykład serwery Google Play generują zoptymalizowane pliki APK, które zawierają wyłącznie zasoby które są wymagane przez konkretne urządzenie żądające zainstalowania aplikacji.

Każda aplikacja na Androida działa we własnej bezpiecznej piaskownicy, chroniona przez tych funkcji zabezpieczeń Androida:

• Android to system Linux dla wielu użytkowników, w którym każda aplikacja do innego użytkownika.
• Domyślnie system przypisuje każdej aplikacji unikalny identyfikator użytkownika systemu Linux, który jest używany system i jest dla aplikacji nieznany. System nadaje uprawnienia do wszystkich plików w aplikacji, aby dostęp do nich miał tylko identyfikator użytkownika przypisany do tej aplikacji.
• Każdy proces ma własną maszynę wirtualną, więc kod aplikacji działa niezależnie z innymi aplikacjami.
• Domyślnie każda aplikacja działa w osobnym procesie systemu Linux. System Android uruchomi się tego procesu komponentów aplikacji muszą zostać uruchomione, a potem zamyka proces po usunięciu lub gdy system musi odzyskać pamięć na potrzeby innych aplikacji.

W systemie Android obowiązuje zasada jak najmniejszych uprawnień. To znaczy, domyślnie każda aplikacja ma dostęp tylko do komponentów, które są jej niezbędne do działania. Już ich nie ma. Tworzy to bardzo bezpieczne środowisko, w którym aplikacja nie ma dostępu do części system, do którego nie przyznano uprawnień.

Istnieją jednak sposoby udostępniania z innymi aplikacjami, aby uzyskać dostęp do usług systemowych:

• Można skonfigurować tak, aby 2 aplikacje miały taki sam identyfikator użytkownika Linuksa. W takim przypadku i zezwalają na dostęp do cudzych plików. Aby oszczędzać zasoby systemowe, aplikacje z atrybutem o tym samym identyfikatorze użytkownika może też skonfigurować działanie w ramach tego samego procesu Linuksa i współużytkować tę samą maszynę wirtualną. również aplikacje muszą być podpisane tym samym certyfikatem.
• Aplikacja może prosić o dostęp do danych na urządzeniu, takich jak lokalizację, aparat i połączenie Bluetooth. Użytkownik ma jednoznacznie przyznać te uprawnienia. Więcej informacji o uprawnieniach znajdziesz w artykule Uprawnienia na Androidzie.

W pozostałej części tego dokumentu omawiamy następujące zagadnienia:

• Podstawowe komponenty platformy, które definiują aplikację.
• Plik manifestu, w którym zadeklarujesz komponenty i wymagane urządzenie funkcje platformy .
• Zasoby, które są niezależne od kodu aplikacji i umożliwiają aplikacji płynnie optymalizować jego działanie pod kątem różnych konfiguracji urządzeń.

Komponenty aplikacji

Komponenty aplikacji to podstawowe elementy aplikacji na Androida. Każdy Komponent to punkt wejścia, przez który system lub użytkownik może przejść do aplikacji. Niektóre zależą od innych elementów.

Istnieją 4 typy komponentów aplikacji:

• Działania
• Usługi
• Odbiorniki transmisji
• Dostawcy treści

Każdy typ służy do innych celów w obrębie odrębnego cyklu życia, który określa sposób tworzenia i niszczenia komponentu. W kolejnych sekcjach opisano 4 typy komponentów aplikacji.

Aktywności

Aktywność to punkt wejścia w interakcję z użytkownikiem. Reprezentuje ona z interfejsem. Przykład: aplikacja do poczty e-mail może mieć jedną aktywność, która wyświetla listę nowych e-maile, inne związane z pisaniem e-maili i inne związane z czytaniem e-maili. Chociaż współdziałają, aby zapewnić spójną obsługę poczty e-mail. jest niezależne od pozostałych.

Inna aplikacja może uruchomić jedno z tych działań (jeśli pozwala na to aplikacja do poczty e-mail). Na przykład aplikacja aparatu może uruchamiać aktywność w aplikacji do poczty e-mail, której celem jest napisanie nowego e-maila, aby umożliwić użytkownikowi udostępnienie zdjęcia.

Aktywność umożliwia kluczowe interakcje między systemem a aplikacją:

• Śledzenie tego, na czym aktualnie zależy użytkownikowi (co jest widoczne na ekranie), by umożliwić cały czas działa proces hostujący aktywność.
• informacje o tym, które wcześniej używane procesy zawierają zatrzymane działania, do których użytkownik może wrócić; i traktujemy je priorytetowo, aby były dostępne.
• Pomoc w zakończeniu procesu aplikacji, tak aby użytkownik mógł wrócić do swoich działań. z poprzednim stanem.
• Dzięki temu aplikacje mogą wdrożyć przepływ użytkowników między sobą, a system te procesy. Głównym przykładem jest udostępnianie.

implementujesz działanie jako podklasę klasy Activity. Więcej informacje o zajęciach Activity, zobacz Wprowadzenie do działań.

Usługi

Usługa to ogólny punkt wejścia umożliwiający działanie aplikacji w tle. z różnych powodów. To komponent, który działa w tle i działa długoterminowo lub do pracy nad procesami zdalnymi. Usługa nie ma interfejsu użytkownika.

Dla: na przykład usługa może odtwarzać muzykę w tle, gdy użytkownik korzysta z innej aplikacji. może pobierać dane przez sieć, nie blokując interakcji użytkownika z aktywnością. Inny (np. działanie) może uruchomić usługę i pozwolić jej na uruchomienie lub powiązanie z nią wchodzić z nim w interakcję.

Istnieją 2 typy usług, które informują system, jak zarządzać aplikacją: uruchomione usługi i powiązanych usług.

Uruchomione usługi informują system, że mają działać do momentu zakończenia pracy. Może to być synchronizacja niektórych danych w tle lub odtwarzanie muzyki nawet po zamknięciu aplikacji przez użytkownika. Synchronizacja danych w tle lub odtwarzana muzyka oznacza różne rodzaje rozpoczętych operacji usług, które system obsługuje w różny sposób:

• Użytkownik jest świadomy istnienia odtwarzania muzyki, a aplikacja informuje o tym system, informując, że chce działać na pierwszym planie, oraz informuje o tym, nazwę użytkownika. W takim przypadku system nadaje priorytet tej usłudze ponieważ może to negatywnie wpłynąć na wrażenia użytkownika.
• Zwykła usługa działająca w tle nie jest czymś, czego użytkownik nie wie bezpośrednio, system ma większą swobodę w zarządzaniu procesem. Może pozwolić, żeby ją zabić, ponowne uruchomienie usługi później, jeśli wymaga ona pamięci RAM do działań bardziej złożonych obawy użytkownika.

Usługi graniczne działają, ponieważ jakaś inna aplikacja (lub system) chce korzystać z protokołu posprzedażna. Powiązana usługa udostępnia interfejs API innemu procesowi, a system wie, że istnieje zależność między tymi procesami. Jeśli więc proces A jest powiązany z usługą w proces B, system wie, że musi kontynuować proces B i jego usługę dla A. Ponadto, jeśli proces A jest ważny dla użytkownika, dlatego wie, że proces B należy do niego użytkownik również jest zainteresowany.

Dzięki swojej elastyczności usługi są przydatne. elementy składowe różnych rodzajów koncepcji systemowych wyższego poziomu. Animowane tapety, powiadomienia detektory, wygaszacze ekranu, metody wprowadzania, usługi ułatwień dostępu i wiele innych podstawowych funkcji systemu są tworzone jako usługi implementowane przez aplikacje, z którymi system łączy się podczas uruchamiania.

Usługa jest zaimplementowana jako podklasa klasy Service. Więcej informacji na temat konfiguracji o zajęciach Service, zobacz Omówienie usług.

Uwaga: jeśli aplikacja jest kierowana na Androida 5.0 (poziom interfejsu API 21) lub nowszego, za pomocą zajęć JobScheduler możesz zaplanować działania. JobScheduler ma zaletą oszczędzania baterii przez optymalne planowanie zadań w celu zmniejszenia zużycia energii używając interfejsu API Doze. Więcej informacji o korzystaniu z tych zajęć znajdziesz tutaj: JobScheduler dokumentacji referencyjnej.

Odbiorniki transmisji

Odbiornik transmisji to komponent, który umożliwia systemowi dostarczanie zdarzeń do poza zwykłymi wzorcami użytkowników, aby mogła reagować na komunikat w całym systemie ogłoszeń. Ponieważ odbiorniki to kolejne dobrze zdefiniowany element aplikacji, system umożliwia transmitowanie nawet w przypadku aplikacji, które nie są aktualnie uruchomione.

Aplikacja może na przykład zaplanować alarm, aby opublikować powiadomienie informujące użytkownika o zbliżającym się wydarzeniu. Alarm jest dostarczany do urządzenia BroadcastReceiver w aplikacji, więc aplikacja nie musi tego robić pozostanie aktywny, dopóki nie włączy się alarm.

Wiele komunikatów pochodzi z systemu, np. komunikat o wyłączeniu ekranu bateria jest słaba lub zostanie zrobione zdjęcie. Aplikacje mogą też inicjować komunikaty, aby np. informować inne aplikacje, że: niektóre dane są pobierane na urządzenie i dostępne do użycia.

Chociaż transmisja odbiorcy nie wyświetlają interfejsu, mogą utworzyć powiadomienie na pasku stanu aby powiadamiać użytkownika o transmisji. Częściej jednak odbiornik jest jest tylko bramą do innych komponentów i ma wykonać na nim minimalny nakład pracy.

Nadawca może na przykład zaplanować, kiedy JobService ma wykonać określone działania w zdarzeniu przy użyciu JobScheduler. Nadajnikom często zdarza się, że aplikacje komunikują się ze sobą, dlatego ważne jest, aby wiedzieć, związanych z bezpieczeństwem konfiguracji.

Odbiornik transmisji jest zaimplementowany jako podklasa BroadcastReceiver, a każda transmisja jest dostarczana jako obiekt Intent. Aby dowiedzieć się więcej, zobacz zajęcia BroadcastReceiver.

Dostawcy treści

Dostawca treści zarządza wspólnym zbiorem danych aplikacji, w których możesz je zapisywać w systemie plików, w bazie danych SQLite, w internecie lub w innym trwałym miejscu lokalizację, w której aplikacji. Za pośrednictwem dostawcy treści inne aplikacje mogą wysyłać zapytania i modyfikować danych, o ile zezwala na to dostawca treści.

Na przykład system Android udostępnia treści firmie zarządzającej informacjami kontaktowymi użytkownika. Każda aplikacja z odpowiednim mogą wysyłać zapytania do dostawcy treści, na przykład używać ContactsContract.Data, aby odczytywać i zapisywać informacje o aplikacji do konkretnej osoby.

Może to być kuszące wyobrażenie sobie dostawcy treści jako abstrakcji w bazie danych, wiele interfejsów API i wsparcia w tym typowym przypadku. Mają one jednak inny z perspektywy projektowania systemu.

Dla systemu dostawca treści jest punktem wejścia do aplikacji służącej do publikowania nazwanych elementów danych. jest identyfikowana przez schemat URI. Pozwala to określić sposób mapowania zawartych w niej danych do przestrzeni nazw URI, przekazując te identyfikatory URI innym encjom, które mogą z nich korzystać do uzyskiwania dostępu do i skalowalnych danych. System może zarządzać aplikacją na kilka sposobów:

• Przypisanie identyfikatora URI nie wymaga, aby aplikacja pozostała uruchomiona, więc identyfikatory URI mogą być utrwalone po System musi jedynie zadbać o to, aby aplikacja była uruchomione po pobraniu danych aplikacji z odpowiedniego identyfikatora URI.
• Te identyfikatory URI zapewniają też ważny, szczegółowy model zabezpieczeń. Na przykład aplikacja może umieścić identyfikator URI obrazu w schowku, ale pozostawić jego treść dostawca jest zablokowany, więc inne aplikacje nie mogą mieć do niego swobodnego dostępu. Przy próbie drugiej aplikacji na dostęp do tego identyfikatora URI w schowku, system może zezwolić aplikacji uzyskiwanie dostępu do danych za pomocą tymczasowego przyznania uprawnień URI aby mieć dostęp tylko do danych powiązanych z tym identyfikatorem URI i do niczego innego w drugiej aplikacji.

Dostawcy treści przydają się również do odczytywania i zapisywania danych, które są prywatne bez udostępniania.

Dostawca treści został zaimplementowany jako podklasa klasy ContentProvider i muszą wdrożyć standardowy zestaw interfejsów API, które umożliwiają innym aplikacjom transakcji. Więcej informacji znajdziesz na stronie Dostawcy treści. Google.

Wyjątkową cechą systemu Android jest to, że każda aplikacja może uruchamiać inną. komponentem aplikacji. Jeśli na przykład chcesz, aby użytkownik przechwycił plik za pomocą aparatu urządzenia, prawdopodobnie istnieje inna aplikacja, która to robi. Aplikacja może z niego korzystać, zamiast tworzyć aktywność do samodzielnego robienia zdjęć. Ty nie dodać do niej kod lub nawet podać link do niego. Zamiast tego możesz rozpocząć aktywność w aplikacji aparatu, która zarejestruje zdjęcie. Po zakończeniu zdjęcie zostanie nawet przywrócone do aplikacji, aby można było z niego korzystać. Zdaniem użytkownika Zdaje się, że kamera jest w rzeczywistości częścią Twojej aplikacji.

Gdy system uruchamia komponent, rozpoczyna proces dla tej aplikacji, jeśli nie jest to jeszcze już uruchomiony i tworzy instancję klas potrzebnych dla komponentu. Jeśli na przykład plik rozpoczyna aktywność w aplikacji aparatu, która robi zdjęcie, tę aktywność jest uruchamiane w procesie należącym do aplikacji aparatu, a nie w procesie aplikacji. Dlatego w przeciwieństwie do aplikacji w większości innych systemów aplikacje na Androida nie mają punkt: nie ma funkcji main().

System uruchamia każdą aplikację w osobnym procesie z uprawnieniami dotyczącymi plików, które ogranicza dostęp do innych aplikacji, aplikacja nie może bezpośrednio aktywować komponentu innej aplikacji. Jest to jednak możliwe w systemie Android. Aby aktywować komponent do innej aplikacji, dostarczasz do systemu komunikat, który określa Twoją zamiar i uruchamiania konkretnego komponentu. System aktywuje komponent za Ciebie.

Aktywuj komponenty

Komunikat asynchroniczny nazywany intencją aktywuje 3 z 4 typów komponentów: działania, usługi odbiornikami. Intencje łączą poszczególne komponenty w czasie działania. Nasuwa się to czy też osoby wysyłające żądanie działania z innych komponentów, niezależnie od tego, do Twojej lub innej aplikacji.

Tworzona jest intencja z obiektem Intent, który definiuje wiadomość do aktywuj konkretny komponent (intencję jawną) lub konkretny typ komponentu. (intencje domyślne).

W przypadku działań i usług intencja określa działanie do wykonania. Na przykład: view lub wysyłanie i może określać identyfikator URI danych, na podstawie których będzie działać m.in. co może być potrzebne.

Na przykład intencja może przekazywać żądanie wyświetlenia aby wyświetlić obraz lub otworzyć stronę internetową. W niektórych przypadkach możesz działanie, aby otrzymać wynik. W takim przypadku działanie zwróci także wynik w postaci Intent. Możesz też wysyłać intencję zezwalającą użytkownik wybierze kontakt osobisty i zwróci go Tobie. Intencja zwrotu zawiera Identyfikator URI wskazujący wybrany kontakt.

W przypadku odbiorników intencja określa transmisji. Na przykład komunikat informujący o słabej baterii urządzenia zawiera tylko znany ciąg działania wskazujący wyczerpanie baterii.

W przeciwieństwie do aktywności, usług czy odbiorników dostawców treści aktywowana, gdy jest celem kierowania żądania z ContentResolver. Treść resolver obsługuje wszystkie bezpośrednie transakcje z dostawcą treści, a komponent transakcji z użyciem metod wywołań u dostawcy na ContentResolver obiekt. Pozostaje to poziom abstrakcji ze względów bezpieczeństwa pomiędzy dostawcy treści i komponentu żądającego informacji.

Każdy typ komponentu można aktywować w osobny sposób:

• Możesz rozpocząć aktywność lub nadać jej nowe zadanie. przekazywanie danych Intent do: startActivity() lub jeśli chcesz, aby aktywność zwracała wynik, startActivityForResult()
• W Androidzie 5.0 (poziom interfejsu API 21) i nowszych możesz używać JobScheduler, aby zaplanować działania. We wcześniejszych wersjach Androida możesz: usługi lub przekazać nowe instrukcje istniejącej usłudze, przekazując Intent do startService(). Możesz powiązać z usługą, przekazując Intent do bindService()
• Możesz zainicjować transmisję, przekazując Intent do metod takich jak sendBroadcast() lub sendOrderedBroadcast()
• Zapytanie do dostawcy treści możesz wysłać, wywołując query() – ContentResolver.

Więcej informacji o korzystaniu z intencji znajdziesz w sekcji Intencje Filtry intencji. Więcej informacji o aktywowaniu konkretnych komponentów znajdziesz w tych dokumentach: Wprowadzenie do działań, Omówienie usług, BroadcastReceiver i Dostawcy treści.

Plik manifestu

Zanim system Android będzie mógł uruchomić komponent aplikacji, musi wiedzieć, że można zobaczyć w pliku manifestu aplikacji AndroidManifest.xml. Aplikacja deklaruje wszystkie swoje komponenty w tym pliku, który znajduje się w katalogu głównym katalogu projektu aplikacji.

Oprócz deklarowania komponentów aplikacji plik manifestu ma szereg innych funkcji. na przykład:

• Identyfikuje wszelkie uprawnienia użytkownika wymagane przez aplikację, takie jak dostęp do internetu czy dostępu do odczytu kontaktów użytkownika.
• Deklaruje wartość minimalną Poziom interfejsu API wymaganych przez aplikację, w zależności od interfejsów API, których używa.
• deklaruje funkcje sprzętowe i oprogramowania używane lub wymagane przez aplikację, takie jak aparat, Usługi Bluetooth lub ekran wielodotykowy.
• Deklaruje biblioteki interfejsu API, z którymi aplikacja musi być połączona (inna niż platforma Androida) API), takie jak z biblioteki Map Google.

Deklarowanie komponentów

Głównym zadaniem pliku manifestu jest informowanie systemu o komponentach aplikacji. Dla: Na przykład plik manifestu może zadeklarować aktywność w następujący sposób:

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application android:icon="@drawable/app_icon.png" ... >
        <activity android:name="com.example.project.ExampleActivity"
                  android:label="@string/example_label" ... >
        </activity>
        ...
    </application>
</manifest>

W: <application> , atrybut android:icon wskazuje zasoby ikony, która reprezentuje .

W elemencie <activity> atrybut android:name określa pełną i jednoznaczną nazwę klasy klasy podklasa Activity i Atrybut android:label określa ciąg znaków i ma być używana jako etykieta widoczna dla użytkownika.

Musisz zadeklarować wszystkie komponenty aplikacji, korzystając z tych elementów:

• Elementy: <activity> dla aktywności
• <service> elementu dla usługi
• Elementy: <receiver> dla odbiorników
• Elementy: <provider> dla dostawców treści

Aktywności, usługi i dostawcy treści, których uwzględnisz w źródle, ale nie zadeklarujesz nie są widoczne dla systemu i dlatego nie mogą się nigdy uruchomić. Pamiętaj jednak: przesyłać mogą być zadeklarowane w manifeście lub tworzone dynamicznie w kodzie jako BroadcastReceiver i zarejestrowanych w systemie przez wywołanie registerReceiver()

Więcej informacji o strukturze pliku manifestu aplikacji znajdziesz w artykule Omówienie pliku manifestu aplikacji.

Deklarowanie możliwości komponentu

Jak wyjaśniliśmy w sekcji Aktywowanie komponentów, komponentu Intent, aby uruchomić działania, usługi i odbiorniki. Zrób to przez jawne nadanie w intencji nazwy komponentu docelowego z użyciem nazwy klasy komponentu. Możesz też użyć intencji niejawnej, opis działania, które ma zostać wykonane, oraz opcjonalnie dane, które chcesz na których trzeba wykonać działanie. Intencja niejawna pozwala systemowi znaleźć komponent na urządzeniu który potrafi wykonać i je uruchomić. Jeśli wiele komponentów może wykonać działanie opisane w tagu użytkownik wybiera odpowiedni segment.

Uwaga: jeśli używasz intencji, aby uruchomić tag Service, sprawdź, czy Twoja aplikacja jest bezpieczna, używając wulgaryzmy intencji. Użycie intencji ogólnej do uruchomienia usługi może zagrażać bezpieczeństwu, ponieważ nie masz pewności, która usługa zareaguje na intencję a użytkownik nie widzi, która usługa się uruchamia. Począwszy od Androida 5.0 (poziom interfejsu API 21) system zwróci wyjątek, jeśli wywołasz funkcję bindService() z intencją niejawną. Nie deklaruj filtrów intencji dla swoich usług.

System identyfikuje komponenty, które mogą reagować na intencję, porównując do filtrów intencji podanych w pliku manifestu innych aplikacji urządzenia.

Deklarując aktywność w pliku manifestu aplikacji, możesz opcjonalnie dodać atrybut filtry intencji, które deklarują możliwości działania umożliwiające reagowanie na intencje; z innych aplikacji. W tym celu dodaj element <intent-filter> jako element podrzędny elementu deklaracji komponentu.

Jeśli na przykład masz aplikację do poczty e-mail zawierającą aktywność związaną z tworzeniem nowego e-maila, możesz zadeklarowanie filtra intencji, który odpowie na polecenie „send” wysłali nowego e-maila, jak w tym przykładzie:

<manifest ... >
    ...
    <application ... >
        <activity android:name="com.example.project.ComposeEmailActivity">
            <intent-filter>
                <action android:name="android.intent.action.SEND" />
                <data android:type="*/*" />
                <category android:name="android.intent.category.DEFAULT" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Jeśli inna aplikacja tworzy intencję z działaniem ACTION_SEND i przekazuje ją do: startActivity(), system może rozpocząć aktywność, aby użytkownik mógł utworzyć wersję roboczą i wysłać e-mail.

Więcej informacji o tworzeniu filtrów intencji znajdziesz w artykule Intencje i filtry intencji.

Deklarowanie wymagań dotyczących aplikacji

Istnieje wiele urządzeń z Androidem, ale nie wszystkie z nich tych samych funkcji i możliwości. Aby uniemożliwić instalowanie aplikacji na urządzeniach które nie mają funkcji wymaganych przez aplikację, ważne jest, aby jasno określić profil typów urządzeń obsługiwanych przez aplikację. Aby to zrobić, deklaruj wymagania dotyczące urządzeń i oprogramowania manifestu.

Większość tych deklaracji ma jedynie charakter informacyjny. System nie odczytuje ale usługi zewnętrzne, takie jak Google Play, odczytują je na potrzeby filtrowania. użytkownikom, którzy szukają aplikacji na swoich urządzeniach.

Załóżmy na przykład, że aplikacja wymaga aparatu i korzysta z interfejsów API wprowadzonych w Androidzie 8.0 (poziom API 26). Musisz zadeklarować te wymagania. Wartości w polach minSdkVersion i targetSdkVersion są ustawione w plik build.gradle modułu aplikacji:

android {
  ...
  defaultConfig {
    ...
    minSdkVersion 26
    targetSdkVersion 29
  }
}

Uwaga: nie ustawiaj wartości minSdkVersion i targetSdkVersion bezpośrednio w pliku manifestu, ponieważ są zastępowane przez Gradle podczas kompilacji. Więcej informacji: Określanie wymagań dotyczących poziomu interfejsu API

Funkcję kamery deklarujesz w pliku manifestu aplikacji:

<manifest ... >
    <uses-feature android:name="android.hardware.camera.any"
                  android:required="true" />
    ...
</manifest>

Zgodnie z deklaracjami podanymi w tych przykładach urządzenia, które nie mają lub masz Nie można zainstalować aplikacji z Google Play w wersji starszej niż 8.0. Możesz też zadeklarować, że aplikacja używa aparatu, ale tego nie robi. wymagać. W tym celu ustaw required dla wartości false, sprawdź w czasie działania, czy urządzenie ma kamerę, a w razie potrzeby wyłącz wszystkie funkcje aparatu.

Więcej informacji o zarządzaniu zgodnością aplikacji z różnymi urządzeniami znajduje się w artykule Omówienie zgodności urządzeń.

Zasoby aplikacji

Aplikacja na Androida to nie tylko kod. Wymaga zasobów, które są niezależnie od kodu źródłowego, takich jak obrazy, pliki audio i wszystko, co jest związane z treściami wizualnymi, prezentacji aplikacji. Możesz na przykład definiować animacje, menu, style, kolory, a także układ interfejsów związanych z aktywnością za pomocą plików XML.

Korzystanie z zasobów aplikacji ułatwia aby aktualizować różne cechy aplikacji bez modyfikowania kodu. Dostarczanie zestawów alternatywnych zasobów umożliwiających optymalizację aplikacji pod kątem różnych konfiguracji urządzeń, np. różnych języków i rozmiarów ekranów.

Dla każdego zasobu uwzględnionego w projekcie na Androida narzędzia do kompilacji SDK definiują unikalne Liczba całkowita, której możesz użyć, aby odwołać się do zasobu z kodu aplikacji lub z inne zasoby zdefiniowane w kodzie XML. Jeśli na przykład aplikacja zawiera plik graficzny o nazwie logo.png (zapisany w katalogu res/drawable/), narzędzia SDK generują identyfikator zasobu o nazwie R.drawable.logo. Ten identyfikator jest mapowany na liczbę całkowitą specyficzną dla aplikacji, która możesz użyć odwołania do obrazu i wstawić go w interfejsie użytkownika.

Jednym z najważniejszych aspektów udostępniania zasobów oddzielnie od kodu źródłowego jest możliwość udostępnienia alternatywnych zasobów konfiguracji.

Na przykład definiowanie ciągów znaków interfejsu w formacie XML można przetłumaczyć struny na inne i zapisać te ciągi w osobnych plikach. Następnie Android stosuje odpowiednie ciągi językowe do interfejsu użytkownika na podstawie kwalifikatora języka dołączany do nazwy katalogu zasobów, na przykład res/values-fr/ w przypadku francuskiego ciągu znaków. oraz ustawienia języka użytkownika.

Android obsługuje wiele kwalifikatorów alternatywnych dla zasobów. kwalifikator to krótki ciąg znaków, który umieszcza się w nazwie katalogów zasobów, określać konfigurację urządzeń, do których mają być używane te zasoby.

Dla: możesz na przykład utworzyć różne układy aktywności w zależności od od orientacji i rozmiaru ekranu urządzenia. Gdy ekran urządzenia jest ustawiony pionowo (wysoki) układ z przyciskami rozmieszczonymi pionowo, ale gdy ekran jest w orientacji poziomej (szerokiej), spróbuj wyrównać przyciski w poziomie. Zmienianie układu w zależności od orientacji można zdefiniować dwa układy i zastosować odpowiednie kwalifikator do nazwy katalogu każdego układu. Następnie system automatycznie zastosuje odpowiednie w zależności od bieżącej orientacji urządzenia.

Aby uzyskać więcej informacji o różnych rodzajach zasobów, które możesz umieścić w swojej aplikacji, i o tym, jak tworzenia alternatywnych zasobów dla różnych konfiguracji urządzeń, znajdziesz w artykule Omówienie zasobów aplikacji. Do dowie się więcej o sprawdzonych metodach i projektowaniu solidnych aplikacji na poziomie produkcji, przeczytaj Przewodnik po architekturze aplikacji.

Dodatkowe materiały

Aby uzyskać informacje o programowaniu aplikacji na Androida, korzystając z filmów i samouczków dotyczących kodu, zapoznaj się z Tworzenie aplikacji na Androida przy pomocy Kotlin z kursu Udacity.