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ć gotową bibliotekę natywną.
  2. Skonfiguruj CMake, aby skompilować natywny kod źródłowy w bibliotece. Ten skrypt kompilacji jest wymagany, jeśli importujesz i łączysz zasoby z gotowych bibliotek lub bibliotek platformy.
    • Pomiń ten krok, jeśli masz bibliotekę natywną, która zawiera już skrypt kompilacji CMakeLists.txt lub korzysta z ndk-build i zawiera skrypt kompilacji Android.mk.
  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 debugować kod natywny 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 musisz używać tego komponentu, jeśli planujesz 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 pakietów 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 podczas tworzenia dowolnego innego projektu w Android Studio, ale dodaj dodatkowy krok:

  1. W kreatorze w sekcji Wybierz projekt wybierz typ projektu Natywny projekt 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 C++ Standard.
    • Z listy wybierz standard C++, którego chcesz używać. 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 natywnych.

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 omówiliśmy zdarzenia występujące podczas kompilacji i uruchamiania przykładowej aplikacji:

  1. Gradle wywołuje Twój zewnętrzny skrypt kompilacji (CMakeLists.txt).
  2. CMake wykonuje polecenie w skrypcie kompilacji, aby skompilować plik źródłowy C++ (native-lib.cpp) do udostępnionej biblioteki obiektów i nadać mu nazwę 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 funkcji biblioteki, stringFromJNI(), jest teraz dostępna dla aplikacji.
  4. Funkcja MainActivity.onCreate() wywołuje stringFromJNI(), które zwraca "Hello from C++" i używa go do zaktualizowania TextView.

Aby sprawdzić, czy Gradle pakuje bibliotekę natywną w aplikacji, użyj Analizatora plików APK:

  1. Kliknij Utwórz > Utwórz pakiety > Utwórz pakiety APK > Utwórz pakiety APK.
  2. Wybierz Kompilacja > Analiza pliku 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 New > C/C++ Source File (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, na przykład .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 do projektu nowych plików w C/C++ musisz jeszcze skonfigurować CMake, aby uwzględniać 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