Pro Android C++ with the NDK

Android is one of the major players in the mobile phone market. Android is a mobile platform that is built on the top of Linux operating system. The native-code support on Android offers endless opportunities to application developers, not limited the functionality that is provided by Android framework. __Pro Android C++ with the NDK__ is an advanced tutorial and professional reference for today's more sophisticated app developers now porting, developing or employing C++ and other native code to integrate into the Android platform to run sophisticated native apps and better performing apps in general. Using a game app case study, this book explores tools for troubleshooting, debugging, analyzing memory issues, unit testing, unit test code coverage, performance measurement, on native applications, as well as integrating the Android NDK toolchain into existing Autoconf, Makefile, CMake, or JAM based build systems. __Pro Android C++ with the NDK__ also covers the following: · * The Android platform, and getting up to speed with the Android NDK, and exploring the APIs that are provided in native space. * An overview of Java Native Interface (JNI), and auto-generating JNI code through Simplified Wrapper and Interface Generator (SWIG). * An introduction to Bionic API, native networking. native multithreading, and the C++ Standard Template Library (STL) support. * Native graphics and sound using JNI Graphics, OpenGL ES, and OpenSL ES. * Debugging and troubleshooting native applications using Logging, GNU Debugger (GDB), Eclipse Debugger, Valgrind, strace, and other tools. * Profiling native code using GProf to identify performance bottlenecks, and NEON/SIMD optimization from an advanced perspective, with tips and recommendations. Pro Android C++ with the NDK Contents at a Glance Contents About the Author About the Technical Reviewer Preface Chapter 1: Getting Started with C++ on Android Microsoft Windows Downloading and Installing the Java Development Kit on Windows Downloading and Installing the Apache ANT on Windows Downloading and Installing the Android SDK on Windows Downloading and Installing the Cygwin on Windows Downloading and Installing the Android NDK on Windows Downloading and Installing the Eclipse on Windows Apple Mac OS X Installing Xcode on Mac Validating the Java Development Kit on Mac Validating the Apache ANT on Mac Validating the GNU Make Downloading and Installing the Android SDK on Mac Downloading and Installing the Android NDK on Mac Downloading and Installing the Eclipse on Mac Ubuntu Linux Checking the GNU C Library Version Enabling the 32-Bit Support on 64-Bit Systems Downloading and Installing the Java Development Kit on Linux Downloading and Installing the Apache ANT on Linux Downloading and Installing the GNU Make on Linux Downloading and Installing the Android SDK on Linux Downloading and Installing the Android NDK on Linux Downloading and Installing the Eclipse on Linux Downloading and Installing the ADT Installing the Android Platform Packages Configuring the Emulator Summary Chapter 2: Exploring the Android NDK Components Provided with the Android NDK Structure of the Android NDK Starting with an Example Specifying the Android NDK Location Importing the Sample Project Adding Native Support to Project Running the Project Building from the Command Line Examining the Structure of an Android NDK Project Build System Android.mk Building a Shared Library Building Multiple Shared Libraries Building Static Libraries Sharing Common Modules using Shared Libraries Sharing Modules between Multiple NDK Projects Using Prebuilt Libraries Building Standalone Executable Other Build System Variables Other Build System Function Macros Defining New Variables Conditional Operations Application.mk Using the NDK-Build Script Troubleshooting Build System Problems Summary Chapter 3: Communicating with Native Code using JNI What is JNI? Starting with an Example Declaration of Native Methods Loading the Shared Libraries Implementing the Native Methods C/C++ Header Generator: javah Running from Command Line Running from Eclipse IDE Method Declarations JNIEnv Interface Pointer Instance vs. Static Methods Data Types Primitive Types Reference Types Operations on Reference Types String Operations New String Converting a Java String to C String Releasing Strings Array Operations New Array Accessing the Array Elements Operating on a Copy Operating on Direct Pointer NIO Operations New Direct Byte Buffer Getting the Direct Byte Buffer Accessing Fields Getting the Field ID Getting the Field Calling Methods Getting the Method ID Calling the Method Field and Method Descriptors Java Class File Disassembler: javap Running from Command Line Running from Eclipse IDE Exception Handling Catching Exceptions Throwing Exceptions Local and Global References Local References Global References New Global Reference Deleting a Global Reference Weak Global References New Weak Global Reference Validating a Weak Global Reference Deleting a Weak Global Reference Threading Synchronization Native Threads Summary Chapter 4: Auto-Generate JNI Code Using SWIG What is SWIG? Installation Installing on Windows Installing on Mac OS X Installing on Ubuntu Linux Experimenting with SWIG Through an Example Interface File Comments Module Name User-Defined Code Type Definitions Function Prototypes Invoking SWIG from Command Line Java Package for Proxy Classes Invoking SWIG Integrating SWIG into Android Build Process Android Build System Fragment for SWIG Integrating SWIG into Android.mk Updating the Activity Executing the Application Exploring Generated Code Wrapping C Code Global Variables Constants Read-Only Variables Enumerations Anonymous Type-Safe Type-Unsafe Java Enumerations Structures Pointers Wrapping C++ Code Pointers, References, and Values Default Arguments Overloaded Functions Classes Exception Handling Memory Management Calling Java from Native Code Asynchronous Communication Enabling Directors Enabling RTTI Overriding the Callback Method Updating the HelloJni Activity Summary Chapter 5: Logging , Debugging, and Troubleshooting Logging Framework Native Logging APIs Log Message Logging Functions Controlled Logging Log Wrapper Adding Logging Updating Android.mk Log Tag Log Level Applying the Logging Configuration Observing Log Messages Through Logcat Console Logging Debugging Prerequisites Debug Session Setup Setting up the Example for Debugging Starting the Debugger Fix for Windows Users Using Eclipse The Command Line Useful GDB Commands Troubleshooting Stack Trace Analysis Extended Checking of JNI Enabling CheckJNI Memory Issues Using Libc Debug Mode Valgrind Using the Prebuilt Binaries Building from Source Code Deploying Valgrind to Emulator Valgrind Wrapper Running Valgrind Strace Summary Chapter 6: Bionic API Primer Reviewing Standard Libraries Yet Another C Library? Binary Compatibility What is Provided? What is Missing? Memory Management Memory Allocation Dynamic Memory Management for C Allocating Dynamic Memory in C Freeing Dynamic Memory in C Changing Dynamic Memory Allocation in C Dynamic Memory Management for C++ Allocating Dynamic Memory in C++ Freeing Dynamic Memory in C++ Changing Dynamic Memory Allocation in C++ Mixing the Memory Functions and the Keywords Standard File I/O Standard Streams Using the Stream I/O Opening Streams Writing to Streams Writing Block of Data to Streams Writing Character Sequences to Streams Writing a Single Character to Streams Writing Formatted Data to Streams Flushing the Buffer Reading from Streams Reading Block of Data from Streams Reading Character Sequences from Streams Reading a Single Character from Streams Reading Formatted Data from Streams Checking for End of File Seeking Position Checking Errors Closing Streams Interacting with Processes Executing a Shell Command Communicating with the Child Process System Configuration Getting a System Property Value by Name Getting a System Property by Name Users and Groups Getting the Application User and Group IDs Getting the Application User Name Inter-Process Communication Summary Chapter 7: Native Threads Creating the Threads Example Project Creating the Android Project Adding the Native Support Declaring the String Resources Creating a Simple User Interface Implementing the Main Activity Generating the C/C++ Header File Implementing the Native Functions Updating the Android.mk Build Script Java Threads Updating the Example Application to use Java Threads Executing the Java Threads Example Pros and Cons of using Java Threads for Native Code POSIX Threads Using POSIX Threads in Native Code Creating Threads using pthread_create Updating the Example Application to use POSIX Threads Updating the Main Activity Regenerating the C/C++ Header File for posixThreads Method Updating the Native Code Executing the POSIX Threads Example Return Result from POSIX Threads Updating the Native Code to Use pthread_join Synchronizing POSIX Threads Synchronizing POSIX Threads using Mutexes Initializing Mutexes Locking Mutexes Unlocking Mutexes Destroying Mutexes Updating the Example Application to Use a Mutex Synchronizing POSIX Threads Using Semaphores Initializing Semaphores Locking Semaphores Unlocking Semaphores Destroying Semaphores Priority and Scheduling Strategy for POSIX Threads POSIX Thread Scheduling Strategy POSIX Thread Priority Summary Chapter 8: POSIX Socket API: Connection-Oriented Communication Echo Socket Example Application Echo Android Application Project Abstract Echo Activity Echo Application String Resources Native Echo Module Connection-Oriented Communication through TCP Sockets Echo Server Activity Layout Echo Server Activity Implementing the Native TCP Server Creating a Socket: socket Binding the Socket to an Address: bind Network Byte Ordering Listen for Incoming Connections: listen Accepting Incoming Connections: accept Receiving Data from the Socket: recv Sending Data to the Socket: send Native TCP Server Method Echo Client Activity Layout Echo Client Activity Implementing the Native TCP Client Connect to Address: connect Native TCP Client Method Updating the Android Manifest Running the TCP Sockets Example Configuring the Echo TCP Server Interconnecting Emulators for TCP Configuring the Echo TCP Client Summary Chapter 9: POSIX Socket API: Connectionless Communication Adding Native UDP Server Method to Echo Server Activity Implementing the Native UDP Server New UDP Socket: socket Receive Datagram from Socket: recvfrom Send Datagram to Socket: sendto Native UDP Server Method Adding Native UDP Client Method to Echo Client Activity Implementing the Native UDP Client Native UDP Client Method Running the UDP Sockets Example Interconnecting the Emulators for UDP Starting the Echo UDP Client Summary Chapter 10: POSIX Socket API: Local Communication Echo Local Activity Layout Echo Local Activity Implementing the Native Local Socket Server New Local Socket: socket Bind Local Socket to Name: bind Accept on Local Socket: accept Native Local Socket Server Adding Local Echo Activity to Manifest Running the Local Sockets Example Asynchronous I/O Summary Chapter 11: C++ Support Supported C++ Runtimes GAbi++ C++ Runtime STLport C++ Runtime GNU STL C++ Runtime Specifying the C++ Runtime Static vs. Shared Runtimes C++ Exception Support C++ RTTI Support C++ Standard Library Primer Containers Sequence Associative Container Sorted Associative Container Hashed Associative Container Adaptors String Iterators Algorithms Thread Safety of C++ Runtime C++ Runtime Debug Mode GNU STL Debug Mode Using Individual GNU STL Debugging Containers Enabling GNU STL Debug Mode STLport Debug Mode Redirecting Debug Mode Messages to Android Logs Summary Chapter 12: Native Graphics API Availability of Native Graphics API Creating an AVI Video Player Make AVILib a NDK Import Module Create the AVI Player Android Application Create the AVI Player Main Activity Creating the Abstract Player Activity Rendering using JNI Graphics API Enabling the JNI Graphics API Using the JNI Graphics API Retrieving Information about a Bitmap Object Accessing the Native Pixel Buffer Releasing the Native Pixel Buffer Updating AVI Player with Bitmap Renderer Running the AVI Player with Bitmap Renderer Rendering Using OpenGL ES Using the OpenGL ES API Enabling OpenGL ES 1.x API Enabling OpenGL ES 2.0 API Updating AVI Player with OpenGL ES Renderer Rendering Using Native Window API Enabling the Native Window API Using the Native Window API Retrieving Native Window from a Surface Object Acquiring a Reference on a Native Window Instance Releasing the Native Window Reference Retrieving Native Window Information Setting the Native Window Buffer Geometry Accessing the Native Window Buffer Releasing the Native Window Buffer Updating AVI Player with Native Window Renderer EGL Graphics Library Summary Chapter 13: Native Sound API Using the OpenSL ES API Compatibility with the OpenSL ES Standard Audio Permissions Creating the WAVE Audio Player Make WAVELib a NDK Import Module Create the WAVE Player Android Application Creating the WAVE Player Main Activity Implementing WAVE Audio Playback Running the WAVE Audio Player Summary Chapter 14: Profiling and NEON Optimization GNU Profiler for Measuring Performance Installing the Android NDK Profiler Enabling the Android NDK Profiler Analyzing gmon.out using GNU Profiler Optimization using ARM NEON Intrinsics Overview of ARM NEON Technology Adding a Brightness Filter to AVI Player Enabling the Android NDK Profiler for AVI Player Profiling the AVI Player Optimizing the Brightness Filter using NEON Intrinsics Automatic Vectorization Enabling Automatic Vectorization Troubleshooting Automatic Vectorization Summary Index

Android is one of the major players in the mobile phone market. Android is a mobile platform that is built on the top of Linux operating system. The native-code support on Android offers endless opportunities to application developers, not limited the functionality that is provided by Android framework. Pro Android C++ with the NDKis an advanced tutorial and professional reference for today's more sophisticated app developers now porting, developing or employing C++ and other native codeto integrateinto the Android platform to run sophisticated native apps and better performing apps in general. Using a game app case study, this book explores tools for troubleshooting, debugging, analyzing memory issues, unit testing, unit test code coverage, performance measurement, on native applications, as well as integrating the Android NDK toolchain into existing Autoconf, Makefile, CMake, or JAM based build systems. Pro Android C++ with the NDKalso covers the following:
·

• The Android platform, and getting up to speed with the Android NDK, and exploring the APIs that are provided in native space.
• An overview of Java Native Interface (JNI), and auto-generating JNI code through Simplified Wrapper and Interface Generator (SWIG).
• An introduction to Bionic API, native networking. native multithreading,and the C++ Standard Template Library (STL) support.
• Native graphics and sound using JNI Graphics, OpenGL ES, and OpenSL ES.
• Debugging and troubleshooting native applications using Logging, GNU Debugger (GDB), Eclipse Debugger, Valgrind, strace, and other tools.
• Profiling native code using GProf to identify performance bottlenecks, and NEON/SIMD optimization from an advanced perspective, with tips and recommendations.

What you’ll learn

• What is the Android platform, and getting up to speed with the Android NDK.
• Using the Eclipse IDE to streamline developing native applications
• How to use Java Native Interface (JNI) to connect native code to Java world.
• Auto-generate JNI code using Simplified Wrapper and Interface Generator (SWIG).
• Introduction to Bionic API
• Networking through POSIX sockets
• Developing multithreaded applications using POSIX Threads, and Java Threads.
• Debug through Logging, GNU Debugger (GDB), and Eclipse Debugger
• Analyze memory issues through Valgrind
• C++ Support and Standard Template Library STL
• Native Graphics through JNI Graphics and OpenGL ES
• Native Sound through OpenSL ES
• Profiling the native code using GProf to identify performance bottlenecks
• Optimize code using SIMD/NEON

Who this book is for

This book is for software professionals who are interested in leveraging the Android NDK to port their existing native-codeapp, such as C++, to the Android platform, as well as existing Android developers who are interested in improving their apps overall performance by utilizing native-code.

Table of Contents

1. Getting Started with C++ on Android
2. Exploring the Android NDK
3. Communicating with Native Code using JNI
4. Auto-Generate JNI Code Using SWIG
5. Logging, Debugging, and Troubleshooting
6. Bionic API Primer
7. Native Threads
8. POSIX Socket API: Connection Oriented Communication
9. POSIX Socket API: Connetionless Communication
10. POSIX Socket API: Local Communication
11. C++ Support
12. Native Graphics API
13. Sound NativeAPI
14. Profiling and NEON Optimization

Android is one of the major players in the mobile phone market. Android is a mobile platform that is built on the top of Linux operating system. The native-code support on Android offers endless opportunities to application developers, not limited the functionality that is provided by Android framework. Pro Android C++ with the NDK is an advanced tutorial and professional reference for today's more sophisticated app developers now porting, developing or employing C++ and other native code to integrate into the Android platform to run sophisticated native apps and better performing apps in general. Using a game app case study, this book explores tools for troubleshooting, debugging, analyzing memory issues, unit testing, unit test code coverage, performance measurement, on native applications, as well as integrating the Android NDK toolchain into existing Autoconf, Makefile, CMake, or JAM based build systems. Pro Android C++ with the NDK also covers the following: ʺ The Android platform, and getting up to speed with the Android NDK, and exploring the APIs that are provided in native space. An overview of Java Native Interface (JNI), and auto-generating JNI code through Simplified Wrapper and Interface Generator (SWIG). An introduction to Bionic API, native networking. native multithreading, and the C++ Standard Template Library (STL) support. Native graphics and sound using JNI Graphics, OpenGL ES, and OpenSL ES. Debugging and troubleshooting native applications using Logging, GNU Debugger (GDB), Eclipse Debugger, Valgrind, strace, and other tools. Profiling native code using GProf to identify performance bottlenecks, and NEON/SIMD optimization from an advanced perspective, with tips and recommendations