You are here:

Project Templates

A new Android project can be created using the File > New > Project menu. Normal Visual C++ projects are created and set to use a custom Nsight Tegra platform. Projects can be set to build in the Visual Studio environment or using external build files.

Many project templates are available in the Nsight Tegra category.

Android Templates

Android Application

This template creates a basic Android project that includes a Native library. The project includes both Java and native C sources. One Activity is defined and includes a native JNI method that is implemented in the C source.

Package — Sets the package name for the application.
Min Target — Sets the minimum target API level for the application. The application will not run on a device using a lower API.
Namespace — Sets the namespace to use for the application.

Android Library (AAR)

This template creates a project that build an Android Library archive (an AAR file).

An Android library is structurally the same as an Android app module. It can include everything needed to build an app, including source code, resource files, and an Android manifest. However, instead of compiling into an APK that runs on a device, an Android library compiles into an Android Archive (AAR) file that you can use as a dependency for an Android app module. Unlike JAR files, AAR files can contain Android resources and a manifest file, which allows you to bundle in shared resources like layouts and drawables in addition to Java classes and methods.

Please see https://developer.android.com/studio/projects/android-library for additional details.

Android Project (External Build System)

This template creates a VC++ Makefile-like project to call external tools to build the Android project. This project allows debugging the built application as well as external APKs without the need to build them at all. It replaces the old "Debug Only" project type.

When you select this project type, you will be presented with the External Build System Project Wizard.

This allows you to set many of the options that you will later find on the Debugging Properties page.

Attach — Select whether you would like to attach to the process instead of launching it.
Working Directory — Set the directory where the tool will search for important files, such as the source, manifest, etc. Other paths may be absolute or relative to the working directory. If other path properties are not overridden, they are typically assumed to match the standard Tegra-Android project output.
Path to APK — (optional) Set the path to the APK that will be deployed to the target device, if debugging is launched instead of attached.
Path to gdb.setup — (optional) Choose where to find the optional setup file that can be used to issue GDB commands. Your external build system might not produce a setup file. Overrides the default relative to working directory.
Symbols directories — (optional) Select path(s) to directories where .so files reside with symbol information. Note that there are typically two copies of each .so file, so be sure to use the directory with the file that has not been stripped (typically the larger one). You can use Cygwin nm.exe to inspect the .so files.
Native source code directories — (optional) Set extra paths where source code may be found, if the paths built into the symbols are insufficient for GDB to resolve the source.
Java class directories — (optional) Select the paths to the compiled Java files, before they were converted to Android format.
Java source code directories — (optional) Set the base paths to the Java source code.

Note that this template is not called Makefile like Microsoft’s project type, to avoid confusion with makefiles used in other Android project types which utilize the NDK. Please see standard Microsoft VC++ Makefile help for more details.

Dynamic Library for Android Application

This template creates a basic dynamic native library for use in the Android applications. This project may contain only C/C++ code.

Static Library for Android Application

This template creates a basic static native library for use in the Android applications. This project may contain only C/C++ code.