Ta strona została przetłumaczona przez Cloud Translation API.

Pojęcia

Zanim zaczniesz

W tym przewodniku zakładamy, że znasz już pojęcia programowania natywnego oraz programowania na Androida.

Wprowadzenie

Ta sekcja zawiera ogólne wyjaśnienie sposobu działania NDK. Pakiet Android NDK na Androida składa się to narzędzia umożliwiające umieszczanie w aplikacjach na Androida treści w języku C lub C++ („kod natywny”). Możliwość korzystania może być szczególnie przydatny dla programistów, którzy chcą utworzyć następujące:

przenosić aplikacje między platformami;
Możesz korzystać z istniejących bibliotek lub udostępniać własne.
Zwiększenie wydajności w niektórych przypadkach, zwłaszcza wymagających dużych ilości obliczeń na przykład gry.

Jak to działa

W tej sekcji przedstawiamy główne komponenty używane do tworzenia reklam natywnych aplikacji na Androida oraz opisuje proces tworzenia sposób prezentacji.

Główne komponenty

Podczas tworzenia swojej witryny zapoznaj się z następującymi elementami: aplikacja:

Natywne biblioteki udostępnione: NDK kompiluje te biblioteki (pliki .so) na podstawie kodu źródłowego w C/C++.
Natywne biblioteki statyczne: pakiet NDK może też tworzyć biblioteki statyczne lub .a które można połączyć z innymi bibliotekami.
Javy (JNI): JNI to interfejs, za pomocą którego Komponenty C++ komunikują się ze sobą. W tym przewodniku zakładamy, że masz wiedzę na temat JNI; Więcej informacji na ten temat znajdziesz w specyfikacji interfejsu natywnego Java.
Interfejs binarny aplikacji (ABI): ABI dokładnie definiuje sposób że kod maszynowy będzie wchodzić w interakcję z systemem w czasie jego działania. NDK tworzy pliki .so na podstawie tych definicji. Różne interfejsy ABI odpowiadają różnych architektur: pakiet NDK zawiera obsługę ABI dla 32-bitowych architektur ARM, AArch64, x86 i x86-64. Więcej informacji znajdziesz w artykule Android interfejsy ABI.
Plik manifestu: jeśli piszesz aplikację bez komponentu Java, musisz zadeklarować klasę NativeActivity w manifestuj. Patrz sekcja Korzystanie z interfejsunative_activity.h.

Płynięcie

Ogólna procedura tworzenia aplikacji natywnej na Androida wygląda tak:

Projektowanie aplikacji, wybór części do wdrożenia w Javie które mają zostać zaimplementowane jako kod natywny.

Uwaga: można całkowicie unikać Javy, ale raczej nie przyniesie to rezultatów platforma Java Androida przydatna do zadań, w tym do sterowania wyświetlaniem i UI.
Utwórz projekt aplikacji na Androida tak jak każdy inny projekt na Androida.
Jeśli tworzysz aplikację tylko natywną, zadeklaruj klasę NativeActivity w AndroidManifest.xml Więcej informacji znajdziesz w artykule Aktywności natywne aplikacji.
Utwórz plik Android.mk opisujący bibliotekę natywną, w tym jej nazwę flagi, dołączonych bibliotek i plików źródłowych do skompilowania w „JNI” katalogu.
Opcjonalnie możesz utworzyć plik Application.mk konfigurujący środowisko docelowe interfejsy ABI, łańcuch narzędzi, tryb wydania/debugowania i STL. W przypadku każdej z tych czynności nie określono, używane są odpowiednio następujące wartości domyślne:
- ABI: wszystkie niewycofane interfejsy ABI
- Tryb: zwalnianie
- STL: system
Umieść źródło natywne w katalogu jni projektu.
Użyj narzędzia ndk-build, aby skompilować biblioteki natywne (.so, .a).
Utwórz komponent Java, tworząc wykonywalny plik .dex.
Spakuj wszystko do pliku APK zawierającego m.in. .so i .dex pliki potrzebne do uruchomienia aplikacji.

Aktywności i aplikacje natywne

Pakiet Android SDK udostępnia klasę pomocniczą NativeActivity, która umożliwia tworzyć całkowicie natywną aktywność. NativeActivity obsługuje komunikację między platformą Androida a kodem natywnym, lub wywołaj jej metody. Wystarczy, że zadeklarujesz aplikację aby były natywne w pliku AndroidManifest.xml, i zacznij tworzyć aplikacji.

Aplikacja na Androida, która korzysta z metody NativeActivity, nadal działa w swojej wirtualnej wersji odseparowany od innych aplikacji. W związku z tym nadal możesz uzyskać dostęp Interfejsy API platformy Android za pomocą JNI. W niektórych przypadkach, na przykład z czujników, zdarzenia i zasoby wejściowe, NDK udostępnia natywne interfejsy, bez konieczności dzwonienia do JNI. Więcej informacji na temat pomocy znajdziesz w artykule na temat natywnych interfejsów API.

Niezależnie od tego, czy tworzysz aktywność natywną, czy nie, zalecamy podczas tworzenia projektów za pomocą tradycyjnych narzędzi Android Build Tools. Robię to pomaga w tworzeniu aplikacji na Androida i ich tworzeniu w pakietach do jego struktury.

Pakiet Android NDK na Androida udostępnia 2 opcje implementacji aktywności natywnej:

Nagłówek native_activity.h określa natywną wersję klasy NativeActivity. Zawiera on interfejsu wywołania zwrotnego i struktur danych potrzebnych do tworzenia reklam natywnych działania. Główny wątek aplikacji obsługuje wywołania zwrotne, implementacje wywołań zwrotnych nie mogą blokować. W przeciwnym razie występuje błąd ANR (Aplikacja nie odpowiada), ponieważ wątek główny jest nie odpowiada, dopóki wywołanie zwrotne nie zostanie zwrócone.
Plik android_native_app_glue.h definiuje statyczną bibliotekę pomocniczą, na podstawie której w górnej części interfejsu native_activity.h. Powstaje kolejny wątek, obsługuje takie elementy jak wywołania zwrotne czy zdarzenia wejściowe w pętli zdarzeń. Ruchoma te wydarzenia do osobnego wątku, aby żadne wywołania zwrotne nie blokowały w wątku głównym.

<ndk_root>/sources/android/native_app_glue/android_native_app_glue.c dostępne jest też źródło, co pozwala modyfikować implementację.

Więcej informacji o korzystaniu z tej biblioteki statycznej znajdziesz w Przykładowa aplikacja do aktywności natywnej i jej dokumentacja. Więcej informacji to dostępne również w komentarzach w <ndk_root>/sources/android/native_app_glue/android_native_app_glue.h .

Korzystanie z interfejsu natywny_activity.h

Aby zaimplementować natywną aktywność za pomocą interfejsu native_activity.h:

Utwórz katalog jni/ w katalogu głównym projektu. Ten katalog który zawiera cały kod natywny.

Zadeklaruj aktywność natywną w pliku AndroidManifest.xml.

Twoja aplikacja nie ma kodu Java, dlatego ustaw android:hasCode na false.

<application android:label="@string/app_name" android:hasCode="false">

Atrybut android:name tagu aktywności musi mieć wartość NativeActivity.

<activity android:name="android.app.NativeActivity"
          android:label="@string/app_name">

Atrybut android:value tagu meta-data określa nazwę tagu biblioteka udostępniona zawierająca punkt wejścia do aplikacji (np. C/C++ main), pomijając w bibliotece prefiks lib i sufiks .so imię i nazwisko.

<manifest>
  <application>
    <activity>
      <meta-data android:name="android.app.lib_name"
                 android:value="native-activity" />
      <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
      </intent-filter>
    </activity>
  </application>
</manifest>

Utwórz plik aktywności natywnej i zaimplementuj funkcję o nazwie zmienną ANativeActivity_onCreate. Aplikacja wywołuje tę funkcję, gdy rozpoczyna się aktywność natywna. Ta funkcja, analogiczna do funkcji main w języku C/C++, otrzymuje wskaźnik do struktury ANativeActivity, która zawiera wskaźniki funkcji do różnych implementacji wywołań zwrotnych. Ustaw parametr odpowiednie wskaźniki funkcji wywołania zwrotnego w ANativeActivity->callbacks do na temat implementacji wywołań zwrotnych.
W polu ANativeActivity->instance ustaw adres dowolnej instancji i konkretne dane, których chcesz używać.
Na początku zaimplementuj wszystkie inne działania, które chcesz wykonać w ramach aktywności.
Wdróż pozostałe wywołania zwrotne ANativeActivity->callbacks Więcej informacji o tym, kiedy wywołania zwrotne są Więcej informacji znajdziesz w artykule Zarządzanie cyklem życia aktywności.
Opracuj resztę aplikacji.
Utwórz w katalogu jni/ swojego projektu obiekt Android.mk file, aby i opisz moduł natywny w systemie kompilacji. Więcej informacji: Android.mk
Gdy masz już plik Android.mk, skompiluj kod natywny za pomocą ndk-build.
```
cd <path>/<to>/<project>
$NDK/ndk-build
```
Zbuduj i zainstaluj projekt na Androida w zwykły sposób. Jeśli Twój kod natywny zawiera do katalogu jni/, skrypt kompilacji automatycznie pakuje .so plików wbudowanych w jego pakiecie APK.

Dodatkowy przykładowy kod

Aby pobrać próbki NDK, wyświetl próbki NDK.