Dodaj do projektu kod w językach C i C++

Dodaj kod C i C++ do projektu Androida, umieszczając go w katalogu cpp w module projektu. Gdy kompilujesz projekt, ten kod jest kompilowany do biblioteki natywnej, którą Gradle może zapakować z aplikacją. Następnie kod Java lub Kotlin może wywoływać funkcje w bibliotece natywnej za pomocą interfejsu JNI (Java Native Interface). Więcej informacji o ramach JNI znajdziesz w artykule Wskazówki dotyczące JNI na Androida.

Android Studio obsługuje CMake, co jest przydatne w przypadku projektów wieloplatformowych. Android Studio obsługuje też ndk-build, który może być szybszy niż CMake, ale obsługuje tylko Androida. Korzystanie z CMake i ndk-build w tym samym module nie jest obecnie obsługiwane.

Aby zaimportować istniejącą bibliotekę ndk-build do projektu w Android Studio, dowiedz się, jak połączyć Gradle z projektem biblioteki natywnej.

Na tej stronie znajdziesz informacje o tym, jak skonfigurować Android Studio z wymaganymi narzędziami do kompilacji, utworzyć nowy projekt z obsługą języka C/C++, a także dodać do projektu nowe pliki C/C++.

Jeśli chcesz dodać kod natywny do istniejącego projektu, wykonaj te czynności:

  1. Utwórz nowe natywne pliki źródłowe i dodaj je do projektu w Android Studio.
    • Pomiń ten krok, jeśli masz już kod natywny lub chcesz zaimportować wstępnie utworzoną bibliotekę natywną.
  2. Skonfiguruj CMake, aby skompilować natywny kod źródłowy w bibliotece. Ten skrypt kompilacji jest wymagany, jeśli importujesz i linkujesz biblioteki wstępnie skompilowane lub platformowe.
    • Jeśli masz już bibliotekę natywną z dołączonym skryptem kompilacji CMakeLists.txt lub używasz biblioteki ndk-build i skryptu kompilacji Android.mk, pomiń ten krok.
  3. Skonfiguruj Gradle, podając ścieżkę do pliku skryptu CMake lub ndk-build. Gradle używa skryptu kompilacji, aby zaimportować kod źródłowy do projektu w Android Studio i zapakować natywną bibliotekę do aplikacji.

Po skonfigurowaniu projektu możesz uzyskać dostęp do natywnych funkcji z kodu Java lub Kotlin za pomocą ramy JNI. Aby skompilować i uruchomić aplikację, kliknij Uruchom uruchom aplikację z paska menu.

Uwaga: jeśli istniejący projekt używa przestarzałego narzędzia ndkCompile, zmień je na CMake lub ndk-build.

Pobieranie NDK i narzędzi do kompilowania

Aby skompilować i przeprowadzić debugowanie kodu natywnego aplikacji, potrzebujesz tych komponentów:

  • Pakiet Native Development Kit (NDK) na Androida: zestaw narzędzi, który umożliwia korzystanie z kodu C i C++ na Androidzie. NDK udostępnia biblioteki platformy, które umożliwiają zarządzanie natywną aktywnością i dostęp do komponentów urządzeń fizycznych, takich jak czujniki i wyświetlacze dotykowe.
  • CMake: zewnętrzne narzędzie do kompilacji, które współpracuje z Gradle w celu kompilowania natywnej biblioteki. Nie potrzebujesz tego komponentu, jeśli zamierzasz używać tylko ndk-build.
  • LLDB: debuger w Android Studio, który debuguje kod natywny.

Informacje o instalowaniu tych komponentów znajdziesz w artykule Instalowanie i konfigurowanie NDK i CMake.

Tworzenie nowego projektu z obsługą C/C++

Aby utworzyć nowy projekt z obsługą kodu natywnego, wykonaj te same czynności co przy tworzeniu dowolnego innego projektu Android Studio, ale z dodatkowym krokiem:

  1. W sekcji kreatora Wybierz projekt wybierz typ projektu Natywny C++.
  2. Kliknij Dalej.
  3. Wypełnij pozostałe pola w kolejnych sekcjach kreatora.
  4. Kliknij Dalej.
  5. W sekcji Dostosowywanie obsługi C++ w kreatorze możesz dostosować swój projekt za pomocą pola Standard C++.
    • Na liście wybierz standard C++, którego chcesz użyć. Wybranie opcji Toolchain Default powoduje użycie domyślnego ustawienia CMake.
  6. Kliknij Zakończ.

Gdy Android Studio utworzy nowy projekt, otwórz panel Projekt po lewej stronie środowiska IDE i w menu wybierz widok Android. Jak widać na rysunku 1, Android Studio dodaje grupę cpp:

Rysunek 1. Grupy widoku Androida dla natywnych źródeł i zewnętrznych skryptów kompilacji.

Uwaga: to widok nie odzwierciedla rzeczywistej hierarchii plików na dysku, ale grupowanie podobnych plików w celu uproszczenia nawigacji po projekcie.

W grupie cpp znajdziesz wszystkie natywne pliki źródłowe, nagłówki, skrypty kompilacji dla CMake lub ndk-build oraz wstępnie skompilowane biblioteki, które są częścią projektu. W przypadku nowych projektów Android Studio tworzy przykładowy plik źródłowy C++, native-lib.cpp, i umiejsca go w katalogu src/main/cpp/ modułu aplikacji. Ten przykładowy kod zawiera prostą funkcję C++, stringFromJNI(), która zwraca ciąg znaków "Hello from C++". Dowiedz się, jak dodać dodatkowe pliki źródłowe do projektu w sekcji Tworzenie nowych plików źródłowych.

Podobnie jak pliki build.gradle podają Gradle instrukcje kompilowania aplikacji, CMake i ndk-build wymagają skryptu kompilacji, aby wiedzieć, jak skompilować natywną bibliotekę. W przypadku nowych projektów Android Studio tworzy skrypt kompilacji CMakeCMakeLists.txt i umieszcza go w katalogu głównym modułu. Więcej informacji o treści tego skryptu kompilacji znajdziesz w artykule Konfigurowanie CMake.

Tworzenie i uruchamianie przykładowej aplikacji

Gdy klikniesz Uruchom uruchom aplikację z paska menu, Android Studio skompiluje i uruchomi aplikację, która wyświetli na urządzeniu z Androidem lub w emulatorze tekst „Hello from C++”. Poniżej omawiamy zdarzenia, które występują podczas tworzenia i uruchamiania aplikacji przykładowej:

  1. Gradle wywołuje zewnętrzny skrypt kompilacji: CMakeLists.txt.
  2. CMake wykonuje polecenia w skrypcie kompilacji, aby skompilować plik źródłowy C++ (native-lib.cpp) do współdzielonej biblioteki obiektów i nazwać ją libnative-lib.so. Gradle pakuje je następnie w aplikację.
  3. Podczas działania aplikacji funkcja MainActivity wczytuje natywną bibliotekę za pomocą funkcji System.loadLibrary(). Funkcja natywnych bibliotek stringFromJNI() jest teraz dostępna dla aplikacji.
  4. MainActivity.onCreate() wywołuje stringFromJNI(), która zwraca "Hello from C++" i używa jej do zaktualizowania TextView.

Aby sprawdzić, czy Gradle pakuje bibliotekę natywną w aplikacji, użyj narzędzia APK Analyzer:

  1. Kliknij Utwórz > Utwórz pakiety > Utwórz pakiety APK > Utwórz pakiety APK.
  2. Kliknij Utwórz > Przeanalizuj APK.
  3. Wybierz plik APK lub AAB z katalogu app/build/outputs/ i kliknij OK.
  4. Jak widać na rysunku 2, w oknie Analizatora APK w sekcji lib/<ABI>/ możesz zobaczyć libnative-lib.so.

    Rysunek 2. Znajdź bibliotekę natywną za pomocą narzędzia APK Analyzer.

Wskazówka: jeśli chcesz eksperymentować z innymi aplikacjami na Androida, które używają kodu natywnego, kliknij Plik > Nowy > Importuj przykład i wybierz przykładowy projekt z listy Ndk.

Tworzenie nowych plików źródłowych C/C++

Aby dodać nowe pliki źródłowe C/C++ do istniejącego projektu, wykonaj te czynności:

  1. Jeśli w głównym zbiorze źródeł aplikacji nie ma jeszcze katalogu cpp/, utwórz go w ten sposób:
    1. Otwórz panel Projekt po lewej stronie środowiska IDE i w menu wybierz widok Projekt.
    2. Kliknij your-module > src.
    3. Kliknij prawym przyciskiem myszy katalog główny i wybierz Nowy > Katalog.
    4. Wpisz cpp jako nazwę katalogu i kliknij OK.

  2. Kliknij prawym przyciskiem myszy katalog cpp/ i wybierz Nowy > Plik źródłowy C/C++.

  3. Wpisz nazwę pliku źródłowego, np. native-lib.

  4. W menu Typ wybierz rozszerzenie pliku źródłowego, np. .cpp.
    • Kliknij Edytuj typy plików , aby dodać do menu inne typy plików, takie jak .cxx lub .hxx. W wyświetlonym oknie Nowe rozszerzenia plików wybierz inną rozszerzenie pliku z menu Rozszerzenie źródła i Rozszerzenie nagłówka, a następnie kliknij OK.

  5. Aby utworzyć plik nagłówka, zaznacz pole wyboru Utwórz powiązany nagłówek.

  6. Kliknij OK.

Po dodaniu nowych plików C/C++ do projektu musisz skonfigurować CMake, aby uwzględnić te pliki w bibliotece natywnej.

Dodatkowe materiały

Więcej informacji o obsługiwaniu kodu C/C++ w aplikacji znajdziesz w tym materiale.

Ćwiczenia z programowania