From a947fce312fb0670ed4e5a486cf9dbd226baa948 Mon Sep 17 00:00:00 2001
From: Dirk Dougherty The Android NDK provides tools that allow Android application developers
-to embed components that make use of native code in their Android applications.
- Android applications run in the Dalvik virtual machine. The NDK allows
-developers to implement parts of their applications using native-code languages
-such as C and C++. This can provide benefits to certain classes of applications,
-in the form of reuse of existing code and in some cases increased speed. The NDK provides: This release of the NDK supports the ARMv5TE machine instruction set
-and provides stable headers for libc (the C library), libm (the Math library),
-the JNI interface, and other libraries. The NDK will not benefit most applications. As a developer, you will need
-to balance its benefits against its drawbacks; notably, using native code does
-not result in an automatic performance increase, but does always increase
-application complexity. Typical good candidates for the NDK are self-contained,
-CPU-intensive operations that don't allocate much memory, such as signal processing,
-physics simulation, and so on. Simply re-coding a method to run in C usually does
-not result in a large performance increase. The NDK can, however, can be
-an effective way to reuse a large corpus of existing C/C++ code. Please note that the NDK does not enable you to develop native-only
-applications. Android's primary runtime remains the Dalvik virtual machine. The NDK includes a set of cross-toolchains (compilers, linkers, etc..) that
-can generate native ARM binaries on Linux, OS X, and Windows (with Cygwin)
-platforms. It provides a set of system headers for stable native APIs that are
-guaranteed to be supported in all later releases of the platform: The NDK also provides a build system that lets you work efficiently with your
-sources, without having to handle the toolchain/platform/CPU/ABI details. You
-create very short build files to describe which sources to compile and which
-Android application will use them — the build system compiles the sources
-and places the shared libraries directly in your application project. Important: With the exception of the
-libraries listed above, native system libraries in the Android 1.5 platform are
-not stable and may change in future platform versions.
-Your applications should only make use of the stable native system
-libraries provided in this NDK. The NDK package includes a set of documentation that describes the
-capabilities of the NDK and how to use it to create shared libraries for your
-Android applications. In this release, the documentation is provided only in the
-downloadable NDK package. You can find the documentation in the
- Additionally, the package includes detailed information about the "bionic"
-C library provided with the Android platform that you should be aware of, if you
-are developing using the NDK. You can find the documentation in the
- The NDK includes two sample Android applications that illustrate how to use
-native code in your Android applications: For more information, see Using the Sample
-Applications. The sections below describe the system and software requirements for using
-the Android NDK, as well as platform compatibility considerations that affect
-applications using libraries produced with the NDK. Installing the NDK on your development computer is straightforward and
-involves extracting the NDK from its download package and running a host-setup
-script. Before you get started make sure that you have downloaded the latest Android SDK and upgraded your applications
-and environment as needed. The NDK will not work with older versions of the
-Android SDK. Also, take a moment to review the System
-and Software Requirements for the NDK, if you haven't already. To install the NDK, follow these steps: If the script completes successfully, it prints a "Host setup complete."
-message. If it fails, it prints instructions that you can follow to correct any
-problems. Once you have run the host-setup script, you are ready start working with the
-NDK. Once you've installed the NDK successfully, take a few minutes to read the
-documentation included in the NDK. You can find the documentation in the
- Here's the general outline of how you work with the NDK tools: The build tools copy the stripped, shared libraries needed by your
-application to the proper location in the application's project directory.What is the Android NDK?
-
-
-
-
-Contents of the NDK
-
-Development tools
-
-
-
-
-Documentation
-
-<ndk>/docs/ directory. Included are these files:
-
-
-<ndk>/docs/system/libc/ directory:
-
-
-Sample applications
-
-
-
-
-hello-jni — A simple application that loads a string from
-a native method implemented in a shared library and then displays it in the
-application UI. two-libs — A simple application that loads a shared
-library dynamically and calls a native method provided by the library. In this
-case, the method is implemented in a static library that is imported by the
-shared library. System and Software Requirements
-
-The Android SDK
-
-
-
-Supported operating systems
-
-
-
-Required development tools
-
-
-
-Android platform compatibility
-
-
-
-<uses-library> element
-in its manifest file, with the attribute
-android:minSdkVersion="3".Installing the NDK
-
-
-
-
-android-ndk-<version>. You can rename the NDK directory if
-necessary and you can move it to any location on your computer. This
-documentation refers to the NDK directory as <ndk>. <ndk>/build/host-setup.shGetting Started with the NDK
-
-<ndk>/docs/ directory. In particular, please read the
-OVERVIEW.TXT document completely, so that you understand the intent of the NDK
-and how to use it.
-
<ndk>/sources/<my_src>/.... If you want, you can place
-a symlink to your sources, rather than the sources themselves. The sources you
-reference here are not strictly associated with a specific shared library or
-Android application. Instead, they are accessible to any build configuration and
-can be used to produce any number of shared libraries that can be used by any
-Android application.<ndk>/sources/<my_src>/Android.mk to
-describe your native sources to the NDK build system<ndk>/apps/<my_app>/Application.mk to
-describe your Android application and native sources it needs to the NDK build
-system. This file sets up the link between an Android SDK application project
-and any number of shared libraries defined in the
-<ndk>/sources/ folder and it specifies the path to the
-application project that will receive the shared library built from the
-sources.$ make APP=<my_app>
For complete information on all of the steps listed above, please see the -documentation included with the NDK package.
- - -The NDK includes two sample applications that illustrate how to use native -code in your Android applications:
- -hello-jni — A simple application that loads a string from
-a native method implemented in a shared library and then displays it in the
-application UI. two-libs — A simple application that loads a shared
-library dynamically and calls a native method provided by the library. In this
-case, the method is implemented in a static library imported by the shared
-library. For each sample, the NDK includes an Android application project, as well as
-the corresponding C source code and the necessary Android.mk and Application.mk
-files. The application projects are provided in
-<ndk>/apps/<app_name>/project/ and the C source for
-each application is provided in
-<ndk>/sources/samples/<library>/.
Once you have installed the NDK, you can build the shared libraries from the -NDK by using these commands from the root of the NDK directory:
-$ make APP=hello-jni — compiles
-<ndk>/sources/samples/hello-jni/hello-jni.c and outputs a
-shared library to
-<ndk>/apps/hello-jni/project/libs/armeabi/libhello-jni.so.
-$ make APP=two-libs — compiles
-<ndk>/sources/samples/two-libs/second.c and
-first.c and outputs a shared library to
-<ndk>/apps/two-libs/project/libs/armeabi/libtwolib-second.so.
-Next, build the sample Android applications that use the shared -libraries:
- -<ndk>/apps/<app_name>/project/. Then, set up an AVD, if
-necessary, and build/run the application in the emulator. For more information
-about creating a new Android project in Eclipse, see Developing in
-Eclipse.android tool to create
-the build file for each of the sample projects at
-<ndk>/apps/<app_name>/project/. Then set up an AVD, if
-necessary, build your project in the usual way, and run it in the emulator.
-For more information, see Developing in Other
-IDEs.If you have questions about the NDK or would like to read or contribute to -discussions about it, please visit the android-ndk group and -mailing list.
- - diff --git a/docs/html/sdk/ndk/1.6_r1/index.jd b/docs/html/sdk/ndk/1.6_r1/index.jd index e066f9589b86b..090dcdc378672 100644 --- a/docs/html/sdk/ndk/1.6_r1/index.jd +++ b/docs/html/sdk/ndk/1.6_r1/index.jd @@ -1,360 +1,5 @@ -ndk=true -ndk.version=1.6 -ndk.rel.id=1 -ndk.date=September 2009 - -ndk.win_download=android-ndk-1.6_r1-windows.zip -ndk.win_bytes=25896444 -ndk.win_checksum=a213c9592f24c61620755c6c43f85210 - -ndk.mac_download=android-ndk-1.6_r1-darwin-x86.zip -ndk.mac_bytes=20611080 -ndk.mac_checksum=93c5b8b92a1f7b1cdadf267cab8ec403 - -ndk.linux_download=android-ndk-1.6_r1-linux-x86.zip -ndk.linux_bytes=19421662 -ndk.linux_checksum=464d3dc02739b82917e6f0591e17edd1 - page.title=Android 1.6 NDK, Release 1 +sdk.redirect=true +sdk.redirect.path=ndk/index.html + @jd:body - -The Android NDK provides tools that allow Android application developers -to embed components that make use of native code in their Android applications. -
- -Android applications run in the Dalvik virtual machine. The NDK allows -developers to implement parts of their applications using native-code languages -such as C and C++. This can provide benefits to certain classes of applications, -in the form of reuse of existing code and in some cases increased speed.
- -The NDK provides:
- -This release of the NDK supports the ARMv5TE machine instruction set -and provides stable headers for libc (the C library), libm (the Math library), -OpenGL ES 1.1 (3D graphics library), the JNI interface, and other libraries.
- -The NDK will not benefit most applications. As a developer, you will need -to balance its benefits against its drawbacks; notably, using native code does -not result in an automatic performance increase, but does always increase -application complexity. Typical good candidates for the NDK are self-contained, -CPU-intensive operations that don't allocate much memory, such as signal processing, -physics simulation, and so on. Simply re-coding a method to run in C usually does -not result in a large performance increase. The NDK can, however, can be -an effective way to reuse a large corpus of existing C/C++ code.
- -Please note that the NDK does not enable you to develop native-only -applications. Android's primary runtime remains the Dalvik virtual machine.
- -The NDK includes a set of cross-toolchains (compilers, linkers, etc..) that -can generate native ARM binaries on Linux, OS X, and Windows (with Cygwin) -platforms.
- -It provides a set of system headers for stable native APIs that are -guaranteed to be supported in all later releases of the platform:
- -The NDK also provides a build system that lets you work efficiently with your -sources, without having to handle the toolchain/platform/CPU/ABI details. You -create very short build files to describe which sources to compile and which -Android application will use them — the build system compiles the sources -and places the shared libraries directly in your application project.
- -Important: With the exception of the -libraries listed above, native system libraries in the Android platform are -not stable and may change in future platform versions. -Your applications should only make use of the stable native system -libraries provided in this NDK.
- -The NDK package includes a set of documentation that describes the
-capabilities of the NDK and how to use it to create shared libraries for your
-Android applications. In this release, the documentation is provided only in the
-downloadable NDK package. You can find the documentation in the
-<ndk>/docs/ directory. Included are these files:
Additionally, the package includes detailed information about the "bionic"
-C library provided with the Android platform that you should be aware of, if you
-are developing using the NDK. You can find the documentation in the
-<ndk>/docs/system/libc/ directory:
The NDK includes three sample Android applications that illustrate how to use -native code in your Android applications:
- -hello-jni — A simple application that loads a string from
-a native method implemented in a shared library and then displays it in the
-application UI. two-libs — A simple application that loads a shared
-library dynamically and calls a native method provided by the library. In this
-case, the method is implemented in a static library that is imported by the
-shared library. san-angeles — A simple application that renders 3D
-graphics through the native OpenGL ES APIs, while managing activity lifecycle
-with a {@link android.opengl.GLSurfaceView GLSurfaceView} object. For more information, see Using the Sample -Applications.
- -The sections below describe the system and software requirements for using -the Android NDK, as well as platform compatibility considerations that affect -appplications using libraries produced with the NDK.
- -<uses-library>
-element in its manifest file, with an android:minSdkVersion attribute
-value of "3" or higher. For example:
-
-<manifest> - ... - <uses-sdk android:minSdkVersion="3" /> - ... -</manifest>- -
Additionally, if you use this NDK to create a native library that uses the
-OpenGL ES APIs, the application containing the library can be deployed only to
-devices running Android 1.6 or later. To ensure compatibility in this case,
-the application must declare an android:minSdkVersion
-attribute value of "4" or higher.
For more information about API Level and its relationship to Android -platform versions, see -Android API Levels.
Installing the NDK on your development computer is straightforward and -involves extracting the NDK from its download package and running a host-setup -script.
- -Before you get started make sure that you have downloaded the latest Android SDK and upgraded your applications -and environment as needed. The NDK will not work with older versions of the -Android SDK. Also, take a moment to review the System -and Software Requirements for the NDK, if you haven't already.
- -To install the NDK, follow these steps:
- -android-ndk-<version>. You can rename the NDK directory if
-necessary and you can move it to any location on your computer. This
-documentation refers to the NDK directory as <ndk>. <ndk>/build/host-setup.sh
If the script completes successfully, it prints a "Host setup complete." -message. If it fails, it prints instructions that you can follow to correct any -problems.
-Once you have run the host-setup script, you are ready start working with the -NDK.
- -Once you've installed the NDK successfully, take a few minutes to read the
-documentation included in the NDK. You can find the documentation in the
-<ndk>/docs/ directory. In particular, please read the
-OVERVIEW.TXT document completely, so that you understand the intent of the NDK
-and how to use it.
If you used a previous version of the NDK, take a moment to review the -list of NDK changes in the CHANGES.TXT document.
- -Here's the general outline of how you work with the NDK tools:
- -<project>/jni/...<project>/jni/Android.mk to
-describe your native sources to the NDK build system<ndk>/apps/<my_app>/Application.mk to
-describe your Android application and native sources it needs to the NDK build
-system. This file sets up the link between an Android SDK application project
-and any number of shared libraries defined in the
-<project>/jni/ folder and it specifies the path to the
-application project that will receive the shared library built from the
-sources.$ make APP=<my_app>
The build tools copy the stripped, shared libraries needed by your -application to the proper location in the application's project directory.
-For complete information on all of the steps listed above, please see the -documentation included with the NDK package.
- - -The NDK includes three sample applications that illustrate how to use native -code in your Android applications:
- -hello-jni — A simple application that loads a string from
-a native method implemented in a shared library and then displays it in the
-application UI. two-libs — A simple application that loads a shared
-library dynamically and calls a native method provided by the library. In this
-case, the method is implemented in a static library imported by the shared
-library. san-angeles — A simple application that renders 3D
-graphics through the native OpenGL ES APIs, while managing activity lifecycle
-with a {@link android.opengl.GLSurfaceView GLSurfaceView} object. For each sample, the NDK includes an Android application project, as well as
-the corresponding C source code and the necessary Android.mk and Application.mk
-files. The application projects are provided in
-<ndk>/apps/<app_name>/project/ and the C source for
-each application is provided in
-<ndk>/apps/<app_name>/project/jni/.
Once you have installed the NDK, you can build the shared libraries from the -NDK by using these commands from the root of the NDK directory:
-$ make APP=hello-jni — compiles
-<ndk>/apps/hello-jni/project/jni/hello-jni.c and outputs a
-shared library to
-<ndk>/apps/hello-jni/project/libs/armeabi/libhello-jni.so.
-$ make APP=two-libs — compiles
-<ndk>/apps/two-libs/project/jni/second.c and
-first.c and outputs a shared library to
-<ndk>/apps/two-libs/project/libs/armeabi/libtwolib-second.so.
-Next, build the sample Android applications that use the shared -libraries:
- -<ndk>/apps/<app_name>/project/. Then, set up an AVD, if
-necessary, and build/run the application in the emulator. For more information
-about creating a new Android project in Eclipse, see Developing in
-Eclipse.android tool to create
-the build file for each of the sample projects at
-<ndk>/apps/<app_name>/project/. Then set up an AVD, if
-necessary, build your project in the usual way, and run it in the emulator.
-For more information, see Developing in Other
-IDEs.If you have questions about the NDK or would like to read or contribute to -discussions about it, please visit the android-ndk group and -mailing list.
- - diff --git a/docs/html/sdk/ndk/index.jd b/docs/html/sdk/ndk/index.jd new file mode 100644 index 0000000000000..fa2e712cf1075 --- /dev/null +++ b/docs/html/sdk/ndk/index.jd @@ -0,0 +1,477 @@ +ndk=true + +ndk.win_download=android-ndk-r3-windows.zip +ndk.win_bytes=36473391 +ndk.win_checksum=4ce5c93a15f261b6dcade1b69da00902 + +ndk.mac_download=android-ndk-r3-darwin-x86.zip +ndk.mac_bytes=38258228 +ndk.mac_checksum=a083ccc36aa9a3a35404861e7d51d1ae + +ndk.linux_download=android-ndk-r3-linux-x86.zip +ndk.linux_bytes=37403241 +ndk.linux_checksum=f3b1700a195aae3a6e9b5637e5c49359 + +page.title=Android NDK +@jd:body + +The sections below provide information and notes about successive releases of +the NDK, as denoted by revision number.
+ + + + +
+Android NDK, Revision 3 (March 2010)
+ hello-gl2, that illustrates the use of
+OpenGL ES 2.0 vertex and fragment shaders.
+Android NDK, Revision 2 (September 2009)
+ Originally released as "Android 1.6 NDK, Release 1".
+san-angeles, that renders 3D
+graphics through the native OpenGL ES APIs, while managing activity
+lifecycle with a {@link android.opengl.GLSurfaceView} object.
+
+Android NDK, Revision 1 (June 2009)
+ Originally released as "Android 1.5 NDK, Release 1".
+The Android NDK is a toolset that lets you embed components that make use +of native code in your Android applications. +
+ +Android applications run in the Dalvik virtual machine. The NDK allows +you to implement parts of your applications using native-code languages +such as C and C++. This can provide benefits to certain classes of applications, +in the form of reuse of existing code and in some cases increased speed.
+ +The NDK provides:
+ +This release of the NDK supports the ARMv5TE machine instruction set and +provides stable headers for libc (the C library), libm (the Math library), +OpenGL ES (3D graphics library), the JNI interface, and other libraries, as +listed in the section below.
+ +The NDK will not benefit most applications. As a developer, you will need +to balance its benefits against its drawbacks; notably, using native code does +not result in an automatic performance increase, but does always increase +application complexity. Typical good candidates for the NDK are self-contained, +CPU-intensive operations that don't allocate much memory, such as signal processing, +physics simulation, and so on. Simply re-coding a method to run in C usually does +not result in a large performance increase. The NDK can, however, can be +an effective way to reuse a large corpus of existing C/C++ code.
+ +Please note that the NDK does not enable you to develop native-only +applications. Android's primary runtime remains the Dalvik virtual machine.
+ +The NDK includes a set of cross-toolchains (compilers, linkers, etc..) that +can generate native ARM binaries on Linux, OS X, and Windows (with Cygwin) +platforms.
+ +It provides a set of system headers for stable native APIs that are +guaranteed to be supported in all later releases of the platform:
+ +The NDK also provides a build system that lets you work efficiently with your +sources, without having to handle the toolchain/platform/CPU/ABI details. You +create very short build files to describe which sources to compile and which +Android application will use them — the build system compiles the sources +and places the shared libraries directly in your application project.
+ +Important: With the exception of the +libraries listed above, native system libraries in the Android platform are +not stable and may change in future platform versions. +Your applications should only make use of the stable native system +libraries provided in this NDK.
+ +The NDK package includes a set of documentation that describes the
+capabilities of the NDK and how to use it to create shared libraries for your
+Android applications. In this release, the documentation is provided only in the
+downloadable NDK package. You can find the documentation in the
+<ndk>/docs/ directory. Included are these files:
Additionally, the package includes detailed information about the "bionic"
+C library provided with the Android platform that you should be aware of, if you
+are developing using the NDK. You can find the documentation in the
+<ndk>/docs/system/libc/ directory:
The NDK includes sample Android applications that illustrate how to use +native code in your Android applications. For more information, see +Using the Sample Applications.
+ +The sections below describe the system and software requirements for using +the Android NDK, as well as platform compatibility considerations that affect +appplications using libraries produced with the NDK.
+ +<uses-sdk>
+element in its manifest file, with an android:minSdkVersion attribute
+value of "3" or higher. For example:
+
+<manifest> + ... + <uses-sdk android:minSdkVersion="3" /> + ... +</manifest>+
android:minSdkVersion attribute value, as given in the table.
+
+| OpenGL ES Version Used | +Compatible Android Platform(s) | +Required uses-sdk Attribute | +
|---|---|---|
| OpenGL ES 1.1 | Android 1.6 and higher | android:minSdkVersion="4" |
| OpenGL ES 2.0 | Android 2.0 and higher | android:minSdkVersion="5" |
For more information about API Level and its relationship to Android +platform versions, see +Android API Levels.
Installing the NDK on your development computer is straightforward and +involves extracting the NDK from its download package and running a host-setup +script.
+ +Before you get started make sure that you have downloaded the latest Android SDK and upgraded your applications +and environment as needed. The NDK will not work with older versions of the +Android SDK. Also, take a moment to review the System +and Software Requirements for the NDK, if you haven't already.
+ +To install the NDK, follow these steps:
+ +android-ndk-<version>. You can rename the NDK directory if
+necessary and you can move it to any location on your computer. This
+documentation refers to the NDK directory as <ndk>. <ndk>/build/host-setup.sh
If the script completes successfully, it prints a "Host setup complete." +message. If it fails, it prints instructions that you can follow to correct any +problems.
+Once you have run the host-setup script, you are ready start working with the +NDK.
+ +Once you've installed the NDK successfully, take a few minutes to read the
+documentation included in the NDK. You can find the documentation in the
+<ndk>/docs/ directory. In particular, please read the
+OVERVIEW.TXT document completely, so that you understand the intent of the NDK
+and how to use it.
If you used a previous version of the NDK, take a moment to review the +list of NDK changes in the CHANGES.TXT document.
+ +Here's the general outline of how you work with the NDK tools:
+ +<project>/jni/...<project>/jni/Android.mk to
+describe your native sources to the NDK build system<ndk>/apps/<my_app>/Application.mk to
+describe your Android application and native sources it needs to the NDK build
+system. This file sets up the link between an Android SDK application project
+and any number of shared libraries defined in the
+<project>/jni/ folder and it specifies the path to the
+application project that will receive the shared library built from the
+sources.$ make APP=<my_app>
The build tools copy the stripped, shared libraries needed by your +application to the proper location in the application's project directory.
+For complete information on all of the steps listed above, please see the +documentation included with the NDK package.
+ + +The NDK includes four sample applications that illustrate how to use native +code in your Android applications:
+ +hello-jni — a simple application that loads a string from
+a native method implemented in a shared library and then displays it in the
+application UI. two-libs — a simple application that loads a shared
+library dynamically and calls a native method provided by the library. In this
+case, the method is implemented in a static library imported by the shared
+library. san-angeles — a simple application that renders 3D
+graphics through the native OpenGL ES APIs, while managing activity lifecycle
+with a {@link android.opengl.GLSurfaceView} object. hello-gl2 — a simple application that renders a triangle
+using OpenGL ES 2.0 vertex and fragment shaders.For each sample, the NDK includes an Android application project, as well as
+the corresponding C source code and the necessary Android.mk and Application.mk
+files. The application projects are provided in
+<ndk>/apps/<app_name>/project/ and the C source for
+each application is provided in
+<ndk>/apps/<app_name>/project/jni/.
Once you have installed the NDK and run $ build/host-setup.sh from
+the root of the NDK directory, you can build the shared libraries for the
+sample apps by using these commands:
$ make APP=hello-jni — compiles
+hello-jni.c and outputs a shared library to
+<ndk>/apps/hello-jni/project/libs/armeabi/libhello-jni.so.
+$ make APP=two-libs — compiles
+first.c and second.c and outputs a shared library to
+<ndk>/apps/two-libs/project/libs/armeabi/libtwolib-second.so.
+$ make APP=san-angeles — compiles
+importgl.c, demo.c,and app-android.c and
+outputs a shared library to <ndk>/apps/san-angeles/project/libs/armeabi/libsangeles.so.
+$ make APP=hello-gl2 — compiles
+gl_code.cpp and outputs a shared library to
+<ndk>/apps/hello-gl2/project/libs/armeabi/libgl2jni.so.
+Next, build the sample Android applications that use the shared +libraries:
+ +<ndk>/apps/<app_name>/project/. Then, set up an AVD, if
+necessary, and build/run the application in the emulator. For more information
+about creating a new Android project in Eclipse, see Developing in
+Eclipse.android tool to create
+the build file for each of the sample projects at
+<ndk>/apps/<app_name>/project/. Then set up an AVD, if
+necessary, build your project in the usual way, and run it in the emulator.
+For more information, see Developing in Other
+IDEs.If you have questions about the NDK or would like to read or contribute to +discussions about it, please visit the android-ndk group and +mailing list.
+ + diff --git a/docs/html/sdk/sdk_toc.cs b/docs/html/sdk/sdk_toc.cs index 556f78164241b..b790218819ff1 100644 --- a/docs/html/sdk/sdk_toc.cs +++ b/docs/html/sdk/sdk_toc.cs @@ -126,7 +126,8 @@ Windows, r3 new!