3. Networking | Mastering Android NDK

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Mastering Android NDK

By : Sergey Kosarevsky, Viktor Latypov

5 (2)

Mastering Android NDK

5 (2)

By: Sergey Kosarevsky, Viktor Latypov

Overview of this book

Android NDK is used for multimedia applications that require direct access to system resources. NDK is also the key for portability, which in turn allows a reasonably comfortable development and debugging process using familiar tools such as GCC and Clang toolchains. This is a hands-on guide to extending your game development skills with Android NDK. The book takes you through many clear, step-by-step example applications to help you further explore the features of Android NDK and some popular C++ libraries and boost your productivity by debugging the development process. Through the course of this book, you will learn how to write portable multi-threaded native code, use HTTP networking in C++, play audio files, use OpenGL ES 3, and render high-quality text. Each chapter aims to take you one step closer to building your application. By the end of this book, you will be able to create an engaging, complete gaming application.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Using Command-line Tools

1. Using Command-line Tools

Using Android command-line tools on Windows

Using Android command-line tools on OS X

Using Android command-line tools on Linux

Creating an Ant-based application template manually

Creating a Gradle-based application template manually

Embedding native code

Building and signing release Android applications

Organizing the cross-platform code

Using TeamCity continuous integration server with Android applications

Summary

2. Native Libraries

2. Native Libraries

Dealing with precompiled static libraries

Dynamic linking on Windows platform

Curl

OpenSSL

FreeImage

Loading and saving images

FreeType

Theora

OpenAL

Linking the libraries to your application

Summary

3. Networking

3. Networking

Intrusive smart pointers

Portable multithreading primitives

Task queues

Message pumps and asynchronous callbacks

Asynchronous networking with libcurl

Android licensing in native applications

Flurry analytics

Summary

4. Organizing a Virtual Filesystem

4. Organizing a Virtual Filesystem

Mount points

Mount points and streams

Accessing files on the host filesystems

In-memory files

Aliasing

Writing files

Accessing the archive files

Accessing application assets

Summary

5. Cross-platform Audio Streaming

5. Cross-platform Audio Streaming

Initialization and playback

Streaming sounds

Stringed musical instrument model

Decoding compressed audio

Summary

6. OpenGL ES 3.1 and Cross-platform Rendering

6. OpenGL ES 3.1 and Cross-platform Rendering

Linear algebra and transformations

Graphics initialization using SDL2

OpenGL API binding

Cross-platform OpenGL abstractions

Feeding the geometry data to OpenGL

Shader programs

Textures

Summary

7. Cross-platform UI and Input System

7. Cross-platform UI and Input System

Rendering

Text rendering

Organizing the UI system

Summary

8. Writing a Rendering Engine

8. Writing a Rendering Engine

The scene graph

Lighting and shading

Lights and light nodes

Material system

Demo application and a rendering technique

Summary

9. Implementing Game Logic

9. Implementing Game Logic

Boids

Implementation of the flocking algorithms

Digression: helper routines

Collective behaviors

Rendering the swarm

Boids demonstration

The page-based user interface

Summary

10. Writing Asteroids Game

10. Writing Asteroids Game

Creating an on-screen joystick

Implementing the particle system

Asteroids game

Summary

Index

Index

Intrusive smart pointers

Tracking all native memory allocations in a multithreaded environment is notoriously difficult process, especially when it comes to passing objects ownership between different threads. In C++, memory management can be automated using smart pointers. The standard std::shared_ptr class is a good place to start with. However, we want to focus on more interesting and lightweight techniques. We will not use the Boost library either, since we really want to stay lean when it comes to compile times.

Note

The recent versions of the Android NDK support the C++ 11 Standard Library in full. If you feel more comfortable with std::shared_ptr or intrusive pointers from Boost, feel free to use smart pointers from those libraries.

In an intrusive smart pointer, as the name suggests, a reference counter is embedded into the object. The simplest way to do this is by inheriting from the following base class:

class iIntrusiveCounter
{
private:
  std::atomic<long> m_RefCounter;
public...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Mastering Android NDK

Search

Your notes and bookmarks