Running native java on android

HOWTO: Running Java code directly on Android (without creating an APK)

A step by step instruction for compiling a Java program into Android executable and using ADB to run it.

When you want to create a system / commandline tool for Android, you have to write it in C(++)… or do you?

TLDR; here’s the final proof of concept.

Sticking with Java would have the benefit of avoiding all of the native ABI hassle and also being able to call into the Android runtime. So how do we do that?

A (not so) simple Hello World program

Let’s start with the Java program we want to run. In order to make it a bit more interesting (and because any useful program has dependencies), it won’t just print the obligatory “Hello World” message, but also use the Apache Commons CLI library to parse its commandline arguments:

Setting up the working directory

We will have to manually run several commandline tools in the next step, assuming the following final directory structure:

Start by creating an empty directory in a convenient place. Download and unpack the following items there:

• Android SDK (either via Android Studio or the SDK Manager). NOTE: If you are an Android developer, you’ll have the Android SDK already installed. In that case, you don’t actually need to copy it to the working directory as long as you know the path to the dx tool.
• Apache Commons CLI library v1.3.1

Afterwards copy&paste the HelloWorld code from above into the source folder. You might also find my semantic version parser class useful later on (not required here, though).

Compiling and dexing the Java class

Next step is to compile the java class (keep in mind that Android is stuck with Java 7 — bytecode for later versions won’t work). In case you are not used to doing this outside of an IDE, here’s the command:

Make sure the program compiled properly:

Android cannot run Java class files directly. They have to be converted to Dalvik’s DEX format first (yes, even if you are using ART):

NOTE: Android Build Tools v28.0.2 and later contain a dx upgrade, called d8 . The d8 tool can process Java 8 class files. I’ll stick with dx for backwards compatibility reasons here.

Creating the startup shellscript

Android does not have a (normal) JRE, so JAR files cannot be started the same way as on a PC. You need a shellscript wrapper to do this. Copy&paste the one below to the workspace.

NOTE: DEX files can also be started directly using the dalvikvm command, but going through app_process gives us a pre-warmed VM from the Zygote process (it is also the method employed by framework commands like pm and am ).

Installing and running the (non-) app

Time to push everything to the device:

Moment of truth (fingers crossed):

NOTE: Since nothing was installed into the system, getting rid of the program is simply done by deleting the directory again.

It works, but how do I get a Context?!

Contexts represent an environment that is associated with an app (which we explicitly did not build) and are also device dependant. They can only be created by the ActivityThread class (a hidden system class that you cannot instantiate). If you want to interact with the Android runtime, you have to talk to the system services directly through their Binder interfaces. But that’s a topic for another article.

Источник

Introduction to Android Development

We now describe the basics of developing applications with Eclipse. We begin with a short C++ example that you can build and run in your development machine; then we will port the example to run on the Android device, first using Java, then using Java + native code (C/C++), and finally using only native code.

After you complete this topic you should be able to:

• Create Eclipse projects for host and Android devices.
• Run and debug C++ projects on your host machine.
• Run and debug Android Java Activities.
• Run and debug Android Java Activities that call native code.
• Run and debug Android Native Activities.

C++ project on your development machine

We will now create our first C++ example program using Eclipse. The goal of this lesson is to get you familiarized with the Eclipse environment, so we will focus on a simple program that you will run on your desktop computer.

To develop C/C++ projects, you must first open the C/C++ perspective. The Open Perspective toolbar icon is located on the top-right corner of your Eclipse IDE. Each perspective in Eclipse provides a different set of docking arrangements for viewing the content and semantics of your files and projects. The default is the Java perspective; there is also a Debug perspective, and a C++ perspective. Click on the Open Perspective icon, select Other and pick C/C++.

Once on the C++ perspective, we will create the Fibonacci project. Select File > New > C++ project . Enter the project name, Fibonacci, and select Empty Project.

The toolchain option allows you to select which compiler you will use for this project. This will be platform specific: on Linux select Linux GCC; on Windows either MinGW GCC or Cygwin GCC; on Mac select MacOSX GCC. Finally, click on Finish.
Next, select the newly created Fibonacci project, and right-click to select New > Header File. Enter Fibonacci.h under Header File: and click Finish.

Add the declaration for our Fibonacci function, as shown below. Enter the text and save the file.

Now it is time to create our main function. Right-click on the project name and select New > Source File . Enter main.cpp in the Source File: entry.

Our program entry point will call the Fibonacci function and print the result out to the console.

Now we will write the Fibonacci function. Create a new source file, name it Fibonacci.cpp and enter the text shown below.

The program is done, let’s build the executable. Before doing this, close any project in project explorer tab and remember to save any file before building. Then, right-click the project and select Build Project. In the Console tab, you should see the build progressing and succeeding.

Run the project. On the toolbar you will find two buttons, one for debugging and one for running the program.

Hit the run button (with the white triangle) and watch the Console tab in Eclipse, which will show the results of the compilation and then the output of the execution of the program.

Note: If you get an error message stating that the binary couldn’t be found, go back to the previous step and make sure the project is built correctly.

After the program prints out the result of the Fibonacci call, it will exit.

We will now debug the program to trace its execution.

Note: Debugging requires gdb to be in your PATH. On Windows, you will be either using Cygwin gdb or MinGW gdb. If you are using Cygwin as installed by CodeWorks for Android, gdb will be missing. Run setup.exe under NVPACK/cygwin, select «install from Internet» and install the gdb package (under Devel section). If this does not work yet, it could be because Cygwin recently changed the formatting of their mirror’s folder structure to support both x86 and x64. Because of this, setup.exe downloaded before this change no longer work due to them looking for the ini at ftp.someMirrorName.com\cygwin , where the new location is ftp.someMirrorName.com\cygwin\x86 . To resolve the issue, you can try to download setup-x86.exe or setup-x86_64.exe into the NVPACK/cygwin folder and use it instead of setup.exe .

Open main.cpp and insert a breakpoint by double-clicking on the left margin as shown below. (Alternatively, right-click and select Toggle Breakpoint.) The blue dot is an indication that the breakpoint has been set.

Now hit the debug button on the toolbar. When the program starts you may be asked if you want to open the Debug Perspective, select Yes.

Once in the Debug perspective the program execution should stop at the breakpoint you have inserted.

Note: If Eclipse complains that it can not find a source file, click on the Locate File. button, and browse to the location of the file.

The Debug toolbar allows you to select what to do next — continue running the program, step into, or step over the function.

We will step into the Fibonacci function to see it working. Select Step into or equivalently press F5. The execution will move into the Fibonacci function. The Debug Perspective shows a great deal of information: the calling stack, the current local variables, and the source code. In addition you can add watches, inspect memory, and even disassemble the code.

Instead of computing Fibonacci of 10, let’s compute Fibonacci of 15. In the local variables view, find the variable n and change its value from 10 to 15. After you are done, hit the Resume (F8) button.

You can even make breakpoints conditional: add a breakpoint to the Fibonacci function, right-click it and select Breakpoint Properties. > Common, set Condition: to n==5, and resume debugger (F8); now the debugger should stop when the function has been called with n equals 5.

In the previous steps, we left many details uncovered. Eclipse has an internal Makefile builder that creates the Makefile based on the sources that you add to the project. That is why we were able to build the program successfully. In addition, Eclipse has different build configurations for a project. In this example, both Debug and Release configurations were created. The Debug configuration builds the program for debugging, while the Release turns on compiler optimizations for the final program. If you want to change the build properties, right-click on the project, and press Alt + Enter (on Linux and Windows), or Cmd + I (on Mac) to bring up the properties sheet. Under C/C++ Build, you will find the build options.

Create your first Android Java Application

We will now create a similar Android project to run on our device. If this is the first time you develop an android application, it could be a good idea to visit first the getting started page for Android developers.

1. Open the Java perspective. An Android project is always a Java project with the possible addition of native code. (Later, we show projects that seem to be native-only, but in reality even they use Android Java runtime services.)
2. Select File > New > Android Application Project. In Application Name:, type Fibonacci. In Project Name, type AndroidFibonacci. This is the name of the project in Eclipse. We already have a Fibonacci project so we must choose a different name. Set the remaining properties as shown and click Next.

Note: Don’t use spaces in the project name, otherwise native debugging will fail to find the symbols.

An Activity is Android’s basic unit of user interaction. We will manually create an Activity, so uncheck the Create Activity box and click Finish.

You now have a basic Android project skeleton.

We will now create a new Java class. Right-click on src and select New > Class. Fill out the class properties as shown — we want to create a class that inherits from android.app.Activity within the package com.nvidia.example.fibonacci .

Open the FibonacciActivity.java and add a Fibonacci function to the class skeleton. Java doesn’t have unsigned types, so we will use integers instead and handle negative numbers correctly.

Note: After you copy and paste the code shown above, Eclipse will underline Bundle and TextView , and note them as undefined classes. These are Android framework classes that require an import declaration. To add the imports for these, hover the cursor over the underlined text, and select the import option from the possible fixes or press the shortcut combination Ctrl-Shift-M (Linux, Windows) or CMD-SHFT-M (on Mac). Of course, you can also just type the imports in, too.

All of our code has been written. Now we need to specify in the manifest which activity to launch for this application. There can be more than one activity within an application, and one of those can be marked as the main entry point. We have created a single activity so far, this will be our MAIN and LAUNCHER activity.

Open AndroidManifest.xml . Eclipse will open the manifest editor. Select the AndroidManifest.xml tab to view the xml file.

Then replace the activity tag with the code shown below:

:emphasize-lines: 2, 16-23

An Intent describes an operation to be performed. Activities with certain intent filters can perform the operations described by the intents.
Now, we can run the application on the device. Make sure the device is connected an powered on. Right-click on the project name and select Run As > Android Application. Alternatively, you can click the run button on the toolbar. The code will be built and packaged into an .apk file that is pushed to the device and launched. The first time you run the application, you will be shown the «Auto Monitor Logcat» dialog. Choose Yes. If the dialog does not appear, go to Window > Show View > Other and select Logcat.

Once the application is run, you should see:

The Logcat window provides messages that can be used to identify possible errors in the application. It also shows a list of messages that are useful for debugging.

This concludes our simple Java application tutorial.

1. Google’s building your first app tutorial guides you through the steps required for creating a new Android Project in Eclipse, building, and running the application on the device.
2. For an in-depth look at an Android application life cycle, please see How To: Develop Apps Using the Android Application Lifecycle.

Debugging with the debugger

Now that we have completed our first app, we will launch the debugger and trace execution of the Fibonacci function.

To avoid debugging the String construction, modify the code slightly as shown below and set a breakpoint on the line that calls Fibonacci (double-click on the left of the line):

Click on the Debug button, and if prompted about the Debug Configuration, select Android Application. The application package will be recompiled and copied to the device. You might see a message saying the application is waiting for the debugger to connect, this is normal. You will be taken to the Debug Perspective and will see the application hit a breakpoint. Press F5 to trace into the function call. (Note that you can click the images in this document to see them in full size.)

Try changing the value of n and hit F8 to continue running and see the displayed result.

Printing debug messages to the Android log

Android provides a system log mechanism for developers to use from their applications. The log has different levels of information:

• V — verbose
• D — debug
• I — info
• W — warning
• E — error
• F — fatal

All messages in the log include the process id that generated it. We will now add logging to our Fibonacci application.

Go back to Java perspective, open FibonacciActivity.java , and add the highlighted lines:

Each LOG message has a TAG that comes very handy for filtering messages out. A good TAG is a name that relates to your activity.
Run the application and open the LogCat view in Eclipse to see the message. Go to Window > Show View > LogCat. If you don’t see the LogCat option, go to Window > Show View > Other. and search for LogCat. The LogCat viewer can filter the messages by process or information level, and you can also search the log as it is being dumped.

Alternatively, you can display the logcat in a console window by running adb, which can be found under the android-sdk-[linux|windows|mac]/platform-tools directory.

Writing debug messages to a file

If you would like to write debug messages to a file, you need to be aware that in Android, every application runs under a different user id, and only a limited set of paths are writable by the application and visible to the user. If you are using a Tegra prototype device, you can create directory under data to store your log files. But on commercial devices, this location is usually protected and you will need to find a suitable user-accessible path. Android provides the means to do so. To keep it simple, let’s add logging to a file we create in external storage. Don’t get misled by the word external here, the external storage might not be the SD card. But files you write to external storage are not deleted when the application is uninstalled.

#. In FibonacciActivity.java , we will add code to write to a log file. We will create a logWriter class instance variable that we will use to write text messages to a file we will create.

Build and run the application. Because each Android device might have a different path to the external storage, we print the location of the file to the system log.

To view the file, first pause or end the application so that the file is closed and it can be read. Then transfer it to the host computer by typing the command below on the command line (check the path from the log message).

See also: An explanation on Android storage.

Adding Native Android code

Using our FibonacciActivity as a starting point, we will add a native library that computes the Fibonacci function.

We first tell the project to build both C++ and Java code. Right-click on the project name, and select Android Tools > Add Native Support. Set the library name to libfibonacci.so , and click on Finish.

You will notice that Eclipse has now changed to the C++ Perspective. In addition, there is a new folder in the project tree called jni that contains fibonacci.cpp and Android.mk .

Android.mk is a make file with the instructions on how to build our native sources.

The LOCAL_MODULE gives the module name which in turn is used for the output filename. LOCAL_SRC_FILES contains the list of files to build, and finally, the include command is used to include the rules for building a shared library. The output of the build will be libfibonacci.so . This library needs to be explicitly loaded by the Java VM, as we show next.
Create a new file under the jni folder named Application.mk. Right-click on jni and select New > File.

While the Android.mk file defines module settings, the Application.mk file is used to define per-application settings that apply to all modules. Set the contents of the new file as shown below:

In our modified class, the Fibonacci function doesn’t have an implementation, it is only marked as native.
Java VM machine relies on name mangling to link the Java native method with its actual implementation. You can use the javah utility to generate the function headers for you and avoid remembering the mangling rules. For this, you will first need to compile your project. Right-click on the project name and select Build Project.

You will notice that even though the fibonacci.cpp is empty, the C++ builder is invoked successfully. There is no error telling us that the native method has not been implemented. This kind of error will be a Java Exception raised by the virtual machine. You can see it for yourself; if you try to run the application, it will crash. You can look at the error by browsing the logcat:

If the LogCat window is too small, select the window and hit CTRL+M to expand the window, another CTRL+M brings back the other windows. Double-clicking the tab also does the same thing.
To generate the proper function header, open a console, go to your project directory (where the AndroidManifest.xml file is located), and run javah .

The output will be the file jni/com_nvidia_example_fibonacci_FibonacciActivity.h .

If it doesn’t work: We have found on some installations, that javah from a previous, non-Android Java installation was on the path before the one from Android toolkit. If you encounter errors, type which javah to find which version is used. It should return a path within NVPACK. On cygwin, we fixed this by editing /home/ /.bash_profile by adding a line:

Open the file fibonacci.cpp to continue working on our implementation. Create the Fibonacci function as shown and add an include for the new header.

1. The Android NDK documentation is located in your installed NDK under android-ndk-r9c/docs . The documentation is extensive and covers in detail the Android.mk and Application.mk files, plus the creation of reusable modules and prebuilt libraries to use on other projects.
2. There are multiple JNI tutorials available on the web that expand on the basic information we have presented here. In the next examples, we will expand more on JNI.

Debugging your native application

Now that we have built and deployed our mixed Java and native code Activity, we will show how to debug it. There are two Debug configurations that we can use. To debug Java code, we will debug as we did previously, by selecting Debug As > Android Application. This configuration launches a debugger that attaches to the Java VM. For native code, we will instead use Debug As > Android Native Application. This configuration now launches a gdbserver instance on the device that attaches to the application process.

To generate a binary library that is debugging-friendly, we need to modify the build command. Right-click on the AndroidFibonacci project, and select Properties > C/C++ Build. Uncheck the Use default build command option and add the NDK_DEBUG=1 option to the build command.

To make switching between Release and Debug mode faster, you can use Build Configurations. Right now you only have a configuration called Default, which is basically a Release build configuration created for you by Eclipse. Right-click on the project name in the Project Explorer pane, then Build Configurations, and you should see it:

Let’s create our Debug configuration. In the menu shown above, choose Manage. instead of Set Active. In the new window click New. In the field Name of the window that just opened, type «Debug» and hit OK. If you go to the project’s properties now, in the C/C++ Build, you should be able to pull down the Configuration menu and see your Debug configuration:

Select it and set the NDK_DEBUG=1 option as shown above. Hit OK. For Default configuration, re-select the Use default build command option. You can now switch between configurations by right-clicking the project’s name and then Build Configuration > Set Active:

The debugger attaches to the application process asynchronously, which means that the application will start and run until the point when gdbserver attaches to the process. As a consequence, if you are trying to put a breakpoint in code that runs early in your application, the program flow might have already gone by that point when the debugger is finally attached. To debug our Fibonacci function that is called when the application starts, we will modify fibonacci.cpp :

We have added a new function JNI_OnLoad with an infinite loop in it. JNI_OnLoad is called when the Java VM loads the library. The infinite loop will stall execution until the debugger is attached and we manually change the value of _dbg . It is marked volatile to make sure the compiler does not optimize the variable away so we can clear it from the debugger.

Launch the application for Native debugging by right-clicking on the project and selecting Debug As > Android Native Application. You will see the application starts, but there is no output on the screen. At the same time, Eclipse will change to the Debug Perspective.
If the debugging procedure does not start because of an Unknown Application ABI error, you can try to use Debug as Android NDK Application. Alternatively, you can set android:minSdkVersion and android:targetSdkVersion in AndroidFibonacciManifest.xml , and APP_PLATFORM in Application.mk to the same Android version. For instance, android:minSdkVersion=»19″ , android:targetSdkVersion=»19″ and APP_PLATFORM := android-19 .

When the Debug perspective is open, hit the Suspend button (two yellow vertical bars). In the Variables tab, change the value of _dbg from 1 to 0; also set a breakpoint on the call to Fibonacci. Finally, let the program continue running by pressing F8; you should immediately hit the breakpoint you have just set.

You can now trace into the function by pressing F5 or step over it by pressing F6. Change the value of n and press F8 to continue with the execution.

We are done! You have now seen the basics on how to do Java and native code debugging of Android applications running on the device from Eclipse.

Printing to Android log from native code

We can print debugging messages to the Android log from native code using the __android_log_print function.

Open fibonacci.cpp and add the following code at the top of the file.

Logging to a file from native code

When logging to a file from native code, we are still bound by the same restrictions we mentioned regarding user-accessible paths. Additionally, there is no native version of Environment.getExternalStorageDirectory() in the NDK, so we will have to pass the directory information from Java.

In FibonacciActivity.java , add a new native method that will enable native code logging into the specified file.

If you call the function a second time with an empty string, the file will be closed. In addition, because we are using ofstream , when the program exits, the gLogFile object will go out of scope and the file will be closed. Alternatively, you could add enableNativeLogging( «» ); in the onPause() method in the Java side.

Note that we repeated the step described above to generate the proper function header: in a console, go to your project directory and run javah:

You can exit from the shell with CTRL-D. The many lines in the file demonstrate that although this recursive implementation of Fibonacci number calculation is elegant, it’s not particularly efficient.

Calling Java functions from native code

We will extend our Fibonacci example further, by showing how to call Java methods from the native code. We will add the ability to log messages into the TextView, to mimic the behavior of a console application.

Open the file FibonacciActivity.java . Copy the new code for the FibonacciActivity class. We have moved the TextView to class member scope and we have added a function called printToConsole that we can call to append text to this TextView . In addition, we have a new native function called FibonacciSequence .

In order to call the printToConsole method on the passed Java object, we need to obtain its method ID from the Java VM. First, we ask for the jclass of the passed object by calling GetObjectClass . Then we obtain the jmethodID by calling GetMethodID and passing the corresponding jclass identifier, the method name, and the method signature. The method name is printToConsole and the signature (Ljava/lang/String;)V , which stands for a method returning void that takes an argument of type java.Lang.String .

When we call the retrieved method, we cannot pass a pointer to char as an argument, we need to pass it a String object. The JNI environment has a helper function to do this. The newStringUTF function takes a char * and returns a jstring instance. We can then call the Java function using the CallVoidMethod and passing the obj, the method ID, and the string.

Comment out the #define WAIT_FOR DEBUGGER; we will not be attaching the debugger for this run.

Build the program and run it. You will see the following output:

Creating a NativeActivity

Android provides a NativeActivity framework that can be used to run applications that are written entirely in native code. A NativeActivity can have event loops to receive user input, but will have no UI building blocks; it was developed for game developers and it is expected that the UI is built using OpenGL ES rendering.

As an introduction to NativeActivity, we will write our Fibonacci example using this framework. Since there is no Java code, let’s start with a new project. The following steps assume you have already performed all the previous tutorials.

1. From the Java perspective, create a new Android Application project as we did before. Set the Application, Project, and package names, and the minimum Android SDK version to 9.
2. Add Android Native Support. Set the Library Name to libfibonacci.so .
3. Create the jni/Application.mk file and set the APP_ABI to armeabi-v7a , and the Android platform to 14 (this is the first platform to support the NativeActivity). Also, set APP_STL to gnustl_static .

The new code includes android_native_app_glue.h which provides the callbacks for notification of Activity life cycle events. In addition, the native application glue also requires an android_main function to be defined as the entry point for the application.

To keep our sample short, we haven’t created any UI, so we simply print the result of Fibonacci(10) to the Android log. In addition, we do have to process application events for the Activity to remain responsive. This is done inside the event manager loop, where we process all events until the user requests the app to exit.

Note: As the comment says, app_dummy() is needed to make sure that the glue module is not stripped. Without it, none of the methods in the module would be called directly in the code, as the glue module is basically a bunch of callbacks, and the linker would strip the module, thus causing a RuntimeException.

Try running the application. The screen will remain blank. Check the log message for the output. A handy way to find it quickly is to type in the LogCat search line tag:fib .

Logging to a file within a NativeActivity

In an earlier example, we showed how we could log into a file from native code, with the full path filename being provided by the Java application. When running a NativeActivity, we will find the path available to the application using the externalDataPath member of the ANativeActivity struct.

Open fibonacci.cpp and add the following includes and static declarations.

Modify the manifest to give the app the rights to write to external storage.

Try it out. Note that the log file is likely to go to a different directory, to one that is specific to this application. You can find which directory it is by looking into the log cat output. The path could be something like /storage/sdcard0/Android/data/com.nvidia.nativeactfib/files/fibo_native_log.txt , depending on the project name, etc.

See also: The NDK native-activity sample. You can find it under android-ndk-r9b/samples/native-activity . The OpenGL ES tutorial section. We will provide a framework for drawing from a NativeActivity and interacting with touch and other events.

NVIDIAВ® GameWorksв„ў Documentation Rev. 1.0.211026 В©2014- 2021 . NVIDIA Corporation and affiliates. All Rights Reserved.

Источник

Читайте также:  Как обновлять систему андроида