Android Studio for NDK for Windows

The other day, I discovered that the version of Android Studio is constantly striving for a unit, and therefore I thought about studying this tool. So that it was not boring, I decided to share my experience and the collected rake in the form of an article-tutorial.

I just want to make a reservation that I am not the guru of Android development, so you will not find any revelations in the text. But there is a step-by-step instruction on installing and configuring Android Studio under Windows and creating the simplest project using Android NDK.
')
I also warn you in advance: the article turned out to be large and very detailed (honestly, I did not expect it myself), even though I almost hid all the screenshots and some code listings under the spoilers.

At the time of writing, the latest version of Android Studio was 0.8.1, for subsequent versions, the necessary actions may differ from those described below (I really hope for the better).

For those who are only interested in NDK
For those who are only interested in the settings Gradle for NDK

Install and configure Android Studio

1. You must install the JDK (Java Development Kit) and JRE (Java Runtime Environment).

Previously, the Android SDK only supported JDK version 6, but now it is in the past. It supports 7 and even 8 (at least, I specified the 8th version as JAVA_HOME and in the settings of Android Studio, and have not experienced any problems).
JRE is needed to run the studio itself. I use it with version 7.
Download JDK and JRE versions greater than 6 from the Oracle site .

The JAVA_HOME variable can now, it would seem, not be set, since in Android Studio we will set the path to the JDK in the settings. But I installed it. For this you need:

• Go to Control Panel \ System and Security \ System , select Additional System Settings on the left, find the Environment Variables button in the dialog that opens.
• Create a JAVA_HOME system or user variable and specify the path to the JDK for it. I have the following path: C: \ Program Files \ Java \ jdk1.8.0_05 .

2. If you have Android SDK installed.

Included with the Android Studio is your Android SDK. And, if you want to use it, then in some cases it may happen strange. For example, when updating the SDK through the SDK Manager, I recorded part of the files in the old folder, and there were problems when I deleted this folder. Most likely this happened due to the fact that the registry key was stored with the path to the old folder. Therefore, it makes sense to clean the registry. To do this, run regedit.exe and find HKEY_LOCAL_MACHINE \ Software \ Android SDK Tools for 32-bit machines or HKEY_LOCAL_MACHINE \ Software \ Wow6432Node \ Android SDK Tools for 64-bit machines and remove Android SDK Tools . If there are no such keys in the registry of your system, then everything is in order.

If you have the ANDROID_SDK_HOME environment variable set and you want it to point to the old installation, then, in theory, this should not be a problem, since when setting up Android Studio we will point it to the SDK. Problems can arise if this variable uses any of the applications included in the Android SDK.

3. Now proceed to install Android Studio.

You need to download Android Studio for your system from the official page and install it. By default, if you select “Install only for me”, it is placed in \ Users \ <user> \ AppData \ Local \ Android \ android-studio \ , otherwise it is placed in \ Program FIles (x86) \ Android \ android-studio \ . You can select another folder.

After installation, run Android Studio.

In it we do the following:

• Check for updates and, if necessary, update (to do this, click on Check at the bottom of the window)
• Go to Configure-> SDK Manager (just in case: SDK Manager is not part of Android Studio, but a utility from Android SDK) and install what you need. If you do not know what is necessary, then it is better to install everything that he offers.
  
  That's what he installed with me

  
  
  
• Then I changed the subject to Darcula.
  
  How to do it

  you need to go to Configure-> Settings-> Appearance :
  
  
• Next, go to Configure-> Project Defaults-> Project Structure and change the SDK Location to the path to your Android SDK, and the JDK Location to the path to the JDK.
  
  Screenshot

  

Project creation

1. New Project

Click New Project .

In it you can configure:

• Project name (I left by default: My Application )
• The domain of the company, by default <username> .example.com , in my case markedone.example.com
• The package name can also be edited by clicking on Edit to the right. The default is generated from the project name and company domain and looks like com.example. <Username>. <Project name in lowercase without spaces>, I changed it to com.example.markedone.myapp .
• The path where the project will be saved. I have specified my folder for any test projects.

When everything is entered, click Next .

2. Form Factors

In this dialog, select target platforms and APIs.

Here I left everything by default: Phone and Tablet and 4.0.3 IceCreamSandwich. If the API for some platforms is not installed, a Not Insatlled message is displayed. For example, as seen in the screenshot, I do not have libraries for Google Glass installed (this can be done via the SDK Manager).


Click Next .

3. Add Activity

Naturally, I could not get past the Fullscreen Activity and chose it. You can choose another Activity, but in this case we will have different source codes in Java, and you will have to add a call to the native method from Java yourself (however, there is nothing complicated about this).
Make a choice, click Next .

Here we are invited to configure the Activity.

• Activity Name - class name, I left the default: FullscreenActivity .
• Layout Name - the layout name, for the UI editor, is also left by default.
• Title - the default is FullscreenActivity, I put a space: Fullscreen Activity .

Click Finish .

Build and Run

1. Build the project

We launch the build via the menu: Build-> Make Project (icons and hot keys are shown for menu items, so it’s easy to figure out with them).
I had an error during the first build:

It happened in the file MyApplication / app / build.gradle
In order to understand what's the matter, just hover over the underlined line:

Everything is simple, version 19 is indicated here, and we have only 20 installed, and in the project settings we indicated 20 as the target one. Just change the number:

As you can see, the studio has not calmed down on this, and offers to install an even newer version. But now we do not need it.

Run Build-> Make Project again. This time I got everything together. I hope you have too.

2. Configure the virtual device

In order to run the program in the emulator, you need to configure a virtual device. Go to Tools-> Android-> AVD Manager (this, like the SDK Manager, is a utility from the Android SDK). We need the first tab, Android Virtual Device , it is open by default. On the right, we find the Create button ... and click it.

• AVD Name - the name of the virtual device, I entered TestPhone . Then I, however, chose the tablet, but did not change the name.
• Device - various preset device settings, the value is selected from the available in the drop-down list, I chose 7 '' WSVGA (Tablet) (1024 x 600: mdpi) .
• Target - the target version of the API, only those available in the SDK are available. You can install them through the SDK Manager.
  
  W in the name means Wear, the version for wearable devices (watches, etc.). Since we chose Tablet & Phone in the project settings, we need another item: Android L (Preview) - API Level L.
  
• CPU / ABI - platform, I chose ARM (armeabi-v7a) .
• Keyboard - here, I think, everything is clear.
• Skin - as I understood it, the appearance of the device, I chose the value corresponding to the set value of Device : WSVGA .
• Front Camera and Back Camera - the availability of cameras.
• Memory Options - RAM.
• Internal Storage - device hard disk.
• SD Card - I think it is clear.
• Emulation options : Snapshot - allows the emulator to maintain its state between launches, Use Host GPU - allows you to use a computer graphics card for OpenGL ES. I turned on the last option, but the OpenGL application later fell on this emulator on startup. Probably because of ARM vs x86_64.

At the bottom of the dialog you can see what error you made when setting up. For example, you cannot enter spaces in the device name, and some fields are required. When there is no label below, everything is entered correctly. Click OK .


Close the AVD Manager and return to the main window of Android Studio.

3. Run on emulator

Run Run-> Run 'app' .
We'll have to wait until the project builds to run.
Here, the only available option to choose from is our virtual device. He proposed to us immediately, so just click OK .


You can open Tools-> Android-> Android Device Monitor (utility from Android SDK) to see the logs from the emulator. It should automatically pick up the virtual device and immediately start displaying the log.

But after the emulator started up, the application did not open for me the first time, I had to click Run-> Run 'app' again.
Here the device migrated from the list to run in the list of already running. In this list, by itself, there are also real devices.

After that, it went, and the application quickly installed and started.
This is not the behavior of the system, the processing of a click occurs in the application (FullscreenActivity.java file):

// Set up the user interaction to manually show or hide the system UI. contentView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { if (TOGGLE_ON_CLICK) { mSystemUiHider.toggle(); } else { mSystemUiHider.show(); } } }); 

After launch, Android Studio suggested that I turn off the Android Device Monitor in order to integrate the output directly into the IDE.

4. Run in Debug mode

Run-> Debug 'app'
Click OK.

We are waiting for the application to start and connect the debugger. I put a breakpoint when I clicked on the Dummy Button.

A little annoying lack of panels with all sorts of Step Into, Step Out etc.

5. Running on 4.0.3

In the process of creating and launching a project, you probably noticed that we created an application compatible with version 4.0.3, but ran it only on the latest version of Android. Now we fix it. To do this, you need to install version 4.0.3 through Tools-> Android-> SDK Manager .

These are the SDK Platform , ARM EABI v7a System Image and Intel x86 Atom System Image . In fact, we ran the ARM emulator, and we don’t need to install Intel now. I put it especially because it is installed for Android L.
Now create another device for the new old version of Android (or you can edit the old one).

Run ( Run-> Run 'app' ).

And we look how the new emulator looks like - obviously more brutal.

5. Run on device

Before moving to work with NDK, let's run the project on a real device. I will run on the phone

The first thing to do is install the adb driver. Everything is quite simple with me, the driver is right on the phone, the only thing to do is to plug the cord into the computer, go into the mounted disk and run the executable file, which will install the adb driver. For other devices, things can be more complicated. For example, for the Prestigio tablet I once had to register Vendor ID in a special file (to use the standard Google driver), Samsung needs their own Kies, there was a separate driver for HTC and so on. In general, you will have to figure out how to install a driver for your device.

After the driver has been installed, you need to enable USB debugging on the device. On my phone for this you need to go to Settings-> For Developers-> USB Debugging . But for different devices, as well as assemblies and versions of Android, the location of this menu item may differ.

Now the phone will be Android SDK, and the developed applications will be installed. However, for Huawei, this is not all: there are no logs from the phone, you need to turn them on.

Now you can run the application on the device: Run-> Run 'app'

Run on the phone.

Install and configure Android NDK

1. Installing NDK

The Android SDK, as we have already found out, is included in the Android Studio package, but the NDK is not. Download the NDK that fits your system from here . We unpack the archive and put it in some folder, for example, in D: \ ndk , so that the ndk-build.cmd file is right in it. Important : it is necessary that there are no gaps in the path to the NDK.

2. Add the variable ANDROID_NDK_HOME

Go to Control Panel \ System and Security \ System , select Additional System Settings on the left, in the opened dialog, press the Environment Variables button. Create a variable with the name ANDROID_NDK_HOME and the value D: \ ndk (the path to your NDK).

Alternatively, instead of specifying a global variable, you can set the path to ndk in the local.properties file of your project (right in the root folder: MyApplication \ local.properties ). The contents of the file will look something like this (note the double backslashes, since this is critical for Windows):

 ## This file is automatically generated by Android Studio. # Do not modify this file -- YOUR CHANGES WILL BE ERASED! # # This file should *NOT* be checked into Version Control Systems, # as it contains information specific to your local configuration. # # Location of the SDK. This is only used by Gradle. # For customization when using a Version Control System, please read the # header note. sdk.dir=C:\\Users\\<user>\\AppData\\Local\\Android\\android-studio\\sdk ndk.dir=D:\\ndk 

Do not believe the disclaimer about "your changes will be discarded," in this case it is not. Please note that this file is recommended to be excluded from version control, as it contains only local information for the user. For a change in this we did not lie. And, of course, this change will not affect your other projects. When ANDROID_NDK_HOME is set, it is not necessary to register the path in local.properties.

3. Install the required version of the Android API

Go to the NDK \ platforms (I have this D: \ ndk \ platforms ) and see the maximum version of the available APIs. In my case, the maximum version is 19. But at the same time, we only have versions 20 and 15 installed in the SDK. So, go to the SDK Manager and download the SDK Platform version 19, otherwise nothing will come together.

4. Configure gradle to work with NDK

I took the information from the samples, you can download them here at the bottom of the page . I downloaded samples for version 0.11. I took ndkSanAngeles as the main example.


In our project, you need to select the correct build.gradle file, since there are two of them here. The fact is that MyApplication is a project, and the app is a project module (or subproject), and they have their own build.gradle. First consider the project file

From the comments in the code it is clear that we need a module file.

We configure it to work with NDK using build.gradle from ndkSanAngeles as a “donor”.

For a start, replace
compileSdkVersion 20
on
compileSdkVersion 19
since the NDK is limited to version 19.

We ’ll add the ndk settings to defaultConfig and also replace targetSdkVersion with 19:

 defaultConfig { applicationId "com.example.markedone.myapp" minSdkVersion 15 targetSdkVersion 19 versionCode 1 versionName "1.0" ndk { moduleName "myapp" cFlags "-DANDROID_NDK" ldLibs "log" stl "stlport_static" } } 

NDK settings include

• moduleName - the name of the module that will be used to name the * .so file
• cFlags - flags C
• ldLibs - the libraries that you want to connect to the native code
• stl - version of the library STL

In buildTypes, enable debug JNI build for debug:

  buildTypes { release { runProguard false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } debug.jniDebugBuild true } 

Now add the productFlavors . Here we indicate which collected * .so libraries to include in the assembly for a specific architecture. Thus, * .apk compiled for arm will contain the library version only for arm, under x86 - for x86 and so on. This piece is completely copied from ndkSanAngeles. Explanation of versionCode values ​​from comments: for x86 we set the maximum value to versionCode , since if the device supports both x86 and arm, then the x86 build is preferable (apparently, since it has a larger version, then it will be installed), and the minimum versionCode is written for fat (in theory, it should be “thick” * .apk, containing all possible versions of libraries at once).

  productFlavors { x86 { ndk { abiFilter "x86" } // this is the flavor part of the version code. // It must be higher than the arm one for devices supporting // both, as x86 is preferred. versionCode = 3 } arm { ndk { abiFilter "armeabi-v7a" } versionCode = 2 } mips { ndk { abiFilter "mips" } versionCode = 1 } fat { // fat binary, lowest version code to be // the last option versionCode = 0 } } 

“ Build ” the versionCode value for each of the build options:

  // make per-variant version code applicationVariants.all { variant -> // get the single flavor def flavorVersion = variant.productFlavors.get(0).versionCode // set the composite code variant.mergedFlavor.versionCode = flavorVersion * 1000000 + defaultConfig.versionCode } 

Finally, the last section, dependencies . If you remember, here we changed compile 'com.android.support:support-v4:19.+' to compile 'com.android.support:support-v4:20.+' to build with the only library version we have installed. Now you have to change back to 19.

 dependencies { compile fileTree(dir: 'libs', include: ['*.jar']) // You must install or update the Support Repository through the SDK manager to use this dependency. compile 'com.android.support:support-v4:19.+' } 

5. Create jni folder

In the jni folder, we will save C / C ++ files. This is what NDK expects of us. We need to create a folder in MyApplication / app / src / main . This can be done directly from Android Studio, and in two ways.
First, you can right-click on main and simply create a folder through

Secondly, you can use a special menu item.

6. Add C ++ files

There is no wizard for C ++ files, so to create the file we right-click on the jni folder and select

First, create the header file myapp.h :

 #pragma once #include <jni.h> #ifdef __cplusplus extern "C" { #endif JNIEXPORT jstring JNICALL Java_com_example_markedone_myapp_FullscreenActivity_stringFromJNI(JNIEnv* env, jclass clazz); #ifdef __cplusplus } #endif 

Now create an implementation file, myapp.cpp. In it we will write the following code:

 #include <android/log.h> #include <string> #include "myapp.h" JNIEXPORT jstring JNICALL Java_com_example_markedone_myapp_FullscreenActivity_stringFromJNI(JNIEnv* env, jclass clazz) { std::string tag("GREETING"); std::string message("Hello from C++!"); __android_log_print(ANDROID_LOG_INFO, tag.c_str(), "%s", message.c_str()); std::string jniMessage("Hello from JNI!"); return env->NewStringUTF(jniMessage.c_str()); }