Pierwsze kroki z pakietem NDK
Zadbaj o dobrą organizację dzięki kolekcji
Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.
Natywna wersja deweloperska (NDK) to zestaw narzędzi, które umożliwiają korzystanie
i kodu w C++ na Androidzie oraz biblioteki platformy, których można używać do zarządzania
aktywności natywnych oraz dostęp do komponentów urządzeń fizycznych, takich jak czujniki
dotykowe wprowadzanie danych. Pakiet NDK może nie być odpowiedni dla większości początkujących użytkowników Androida
dla programistów, którzy korzystają wyłącznie z kodu w Javie i interfejsów API platformy
i aplikacjami. NDK może być jednak przydatne w przypadkach, gdy trzeba
któreś z tych problemów:
- Zwiększ wydajność urządzenia, aby zmniejszyć opóźnienie lub działało
w aplikacjach wymagających dużej mocy obliczeniowej, takich jak gry lub symulacje fizyki.
- Wykorzystaj ponownie własne lub innych deweloperów biblioteki C lub C++.
W Android Studio 2.2 lub nowszym możesz:
używaj narzędzia NDK do skompilowania kodu C i C++ w natywnej biblioteki i spakowania go
do pliku APK za pomocą Gradle, zintegrowanego systemu kompilacji IDE. Twój kod w Javie
mogą następnie wywoływać funkcje w bibliotece natywnej za pomocą platformy JNI (Java Native Interface). Aby się uczyć
Więcej informacji o Gradle i systemie kompilacji Androida znajdziesz w artykule Konfigurowanie kompilacji.
Domyślnym narzędziem kompilacji w Android Studio do kompilowania bibliotek natywnych jest CMake. Android Studio też
obsługuje polecenie ndk-build, ponieważ jest duży
istniejących projektów, które korzystają z narzędzia do kompilacji. Jeśli jednak używasz
podczas tworzenia nowej biblioteki natywnej, użyj CMake.
Niniejszy przewodnik zawiera informacje potrzebne do rozpoczęcia korzystania z
NDK w Android Studio. Jeśli nie masz najnowszej wersji Androida
Studio, pobierz i zainstaluj ją teraz.
Uwaga: użytkownicy korzystający z wersji eksperymentalnej Gradle: rozważ
przejście na wtyczkę w wersji 2.2.0 lub nowszej i używanie CMake lub ndk-build
do tworzenia bibliotek natywnych, jeśli któraś z tych sytuacji:
projekt natywny używa już CMake lub ndk-build; wolisz użyć stabilnej wersji
wersję systemu kompilacji Gradle; lub potrzebujesz pomocy w zakresie dodatków,
na przykład CCache.
W przeciwnym razie możesz nadal korzystać z
eksperymentalną wersję Gradle i wtyczki na Androida.
Pobierz NDK i narzędzia
Aby skompilować i debugować kod natywny aplikacji, potrzebujesz tych elementów:
komponenty:
- Android Native Development Kit (NDK) to zestaw narzędzi, dzięki którym
kodu C i C++ na Androidzie.
- CMake: zewnętrznego narzędzia do kompilacji, które współpracuje z Gradle przy tworzeniu
biblioteki natywnej. Nie potrzebujesz tego komponentu, jeśli planujesz używać go tylko
ndk-build.
-
LLDB: debuger używany przez Android Studio do debugowania kodu natywnego.
Informacje o instalowaniu tych komponentów znajdziesz w artykule Instalowanie i konfigurowanie pakietów NDK i CMake.
Tworzenie lub importowanie projektu natywnego
Po skonfigurowaniu Android Studio możesz po prostu utworzyć nowy projekt
Obsługa języka C/C++. Jeśli jednak chcesz dodać lub zaimportować kod natywny do
istniejącego projektu Android Studio, musisz skorzystać z tej podstawowej procedury:
-
Utwórz nowe
natywnych plików źródłowych i dodać je do projektu Android Studio.
- Możesz pominąć ten krok, jeśli masz już kod natywny lub chcesz
zaimportować gotową bibliotekę natywną.
-
Utwórz
skrypt kompilacji CMake, który wskaże CMake, jak utworzyć źródła natywne;
do biblioteki. Potrzebujesz go również, jeśli importujesz i
z wykorzystaniem gotowych bibliotek lub bibliotek platformy.
- Możesz pominąć ten krok, jeśli Twoja biblioteka natywna ma już
CMakeLists.txt skrypt kompilacji lub używa polecenia ndk-build i zawiera
Android.mk
skrypt kompilacji.
-
Połącz Gradle z
do biblioteki natywnej, podając ścieżkę do pliku CMake lub ndk-build
skrypt. Gradle używa skryptu kompilacji do zaimportowania kodu źródłowego
projekt Android Studio i spakuj bibliotekę natywną (plik SO) do
plik APK.
Uwaga: jeśli Twój istniejący projekt używa wycofanych plików
ndkCompile, otwórz
build.properties i usuń następujący wiersz kodu
zanim skonfigurujesz Gradle tak, aby używał CMake lub ndk-build:
// Remove this line
android.useDeprecatedNdk = true
-
Utwórz i uruchom aplikację, klikając
Uruchom
. Dodanie Gradle
w procesie CMake lub ndk-build jako zależność do kompilowania, kompilacji
i spakować bibliotekę natywną do pliku APK.
Gdy aplikacja zostanie uruchomiona na urządzeniu fizycznym lub w emulatorze, możesz używać
w Android Studio, aby debugować aplikację.
Więcej informacji na temat pakietu NDK i jego komponentów znajdziesz na stronie Pojęcia.
Treść strony i umieszczone na niej fragmenty kodu podlegają licencjom opisanym w Licencji na treści. Java i OpenJDK są znakami towarowymi lub zastrzeżonymi znakami towarowymi należącymi do firmy Oracle lub jej podmiotów stowarzyszonych.
Ostatnia aktualizacja: 2025-07-26 UTC.
[[["Łatwo zrozumieć","easyToUnderstand","thumb-up"],["Rozwiązało to mój problem","solvedMyProblem","thumb-up"],["Inne","otherUp","thumb-up"]],[["Brak potrzebnych mi informacji","missingTheInformationINeed","thumb-down"],["Zbyt skomplikowane / zbyt wiele czynności do wykonania","tooComplicatedTooManySteps","thumb-down"],["Nieaktualne treści","outOfDate","thumb-down"],["Problem z tłumaczeniem","translationIssue","thumb-down"],["Problem z przykładami/kodem","samplesCodeIssue","thumb-down"],["Inne","otherDown","thumb-down"]],["Ostatnia aktualizacja: 2025-07-26 UTC."],[],[],null,["# Get started with the NDK\n\nThe Native Development Kit (NDK) is a set of tools that allows you to use C\nand C++ code with Android, and provides [platform libraries](/ndk/guides/stable_apis) you can use to manage\nnative activities and access physical device components, such as sensors and\ntouch input. The NDK may not be appropriate for most novice Android\nprogrammers who need to use only Java code and framework APIs to develop\ntheir apps. However, the NDK can be useful for cases in which you need to do\none or more of the following:\n\n- Squeeze extra performance out of a device to achieve low latency or run computationally intensive applications, such as games or physics simulations.\n- Reuse your own or other developers' C or C++ libraries.\n\n\nUsing [Android Studio 2.2 and higher](/studio), you can\nuse the NDK to compile C and C++ code into a native library and package it\ninto your APK using Gradle, the IDE's integrated build system. Your Java code\ncan then call functions in your native library through the [Java Native Interface (JNI)](http://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/jniTOC.html) framework. To learn\nmore about Gradle and the Android build system, read [Configure Your Build](/studio/build).\n\n\nAndroid Studio's default build tool to compile native libraries is [CMake](https://cmake.org/). Android Studio also\nsupports [ndk-build](/ndk/guides/ndk-build) due to the large\nnumber of existing projects that use the build toolkit. However, if you are\ncreating a new native library, you should use CMake.\n\n\nThis guide gives you the information you need to get up and running with the\nNDK on Android Studio. If you don't have the latest version of Android\nStudio, [download and install it now](/studio).\n\n\n**Attention experimental Gradle users:** Consider [migrating to plugin version 2.2.0 or higher](http://tools.android.com/tech-docs/new-build-system/gradle-experimental/migrate-to-stable), and using CMake or ndk-build\nto build your native libraries if any of the following apply to you: Your\nnative project already uses CMake or ndk-build; you would rather use a stable\nversion of the Gradle build system; or you want support for add-on tools,\nsuch as [CCache](https://ccache.samba.org/).\nOtherwise, you can continue to [use\nthe experimental version of Gradle and the Android plugin](http://tools.android.com/tech-docs/new-build-system/gradle-experimental).\n\nDownload the NDK and tools\n--------------------------\n\n\nTo compile and debug native code for your app, you need the following\ncomponents:\n\n- The Android Native Development Kit (NDK): a set of tools that allows you to use C and C++ code with Android.\n- CMake: an external build tool that works alongside Gradle to build your native library. You do not need this component if you only plan to use ndk-build.\n- *LLDB*: the debugger Android Studio uses to debug native code.\n\n\nFor information on installing these components, see [Install and configure the NDK and CMake](/studio/projects/install-ndk).\n\nCreate or import a native project\n---------------------------------\n\n\nOnce you set up Android Studio, you can simply [Create a New Project with\nC/C++ Support](/studio/projects/add-native-code#new-project). However, if you want to add or import native code to an\nexisting Android Studio project, you need to follow this basic process:\n\n1. [Create new\n native source files](/studio/projects/add-native-code#create-sources) and add them to your Android Studio project.\n - You can skip this step if you already have native code or want to import a prebuilt native library.\n2. [Create\n a CMake build script](/studio/projects/configure-cmake#create_script) to tell CMake how to build your native sources into a library. You also require this build script if you are importing and linking against prebuilt or platform libraries.\n - You can skip this step if your existing native library already has a `CMakeLists.txt` build script, or uses ndk-build and includes an [`Android.mk`](/ndk/guides/android_mk) build script.\n3. [Link Gradle to\n your native library](/studio/projects/gradle-external-native-builds) by providing a path to your CMake or ndk-build script file. Gradle uses the build script to import source code into your Android Studio project and package your native library (the SO file) into the APK.\n\n\n **Note:** If your existing project uses the deprecated\n `ndkCompile` tool, you should open your\n `build.properties` file and remove the following line of code\n before configuring Gradle to use CMake or ndk-build: \n\n ```\n // Remove this line\n android.useDeprecatedNdk = true\n ```\n4. [Build and run your app](/studio/run) by clicking **Run** . Gradle adds your CMake or ndk-build process as a dependency to compile, build, and package your native library with your APK.\n\n\nOnce your app is running on a physical device or the emulator, you can use\nAndroid Studio to [Debug your app](/studio/debug).\nOtherwise, to learn more about the NDK and its components, read the [Concepts](/ndk/guides/concepts) page."]]
