Attention Android Developers: 16 KB Memory Page Sizes Update

Introduction

Google has made some announcements that are very important for Android developers. All new apps and updates to existing apps that target Android 15+ devices will need to support 16 KB memory page sizes on 64-bit devices starting November 1st, 2025. Previously, only 4 KB memory page sizes were needed to be supported.

This post will not only explain what and why the change is happening, but also walk you through updating your Android application that uses the Vonage Client SDK. It will also go over a fix for audio recording on Android 14 devices.

Note: The Vonage Video Client SDK supports 16 KB memory page sizes as of v2.30.0.

What and Why

Android is changing how it manages memory at the system level, and this could affect your app. Here's what you need to know:

What's a page size? A page is a fixed block of memory that your device's operating system allocates to apps. Think of it like standard-sized shipping containers - your app's memory needs to get packed into these containers. Currently, Android uses 4KB pages (like small containers), but newer devices will use 16KB pages (larger containers).

If your app needs 20MB of RAM, the system currently gives you 5,120 small containers (4KB each). With 16KB pages, you'd get 1,280 larger containers instead.

Why is Android making this change? Larger page sizes bring several benefits:

• Faster app startup with lower power consumption

• Quicker device boot times

• Better overall system performance

Does this affect my app? This change primarily impacts apps that use native code - meaning:

• Apps using the Android NDK

• Apps with native libraries (C/C++ code)

• Apps using third-party SDKs that contain native components (like the Vonage Client SDK)

If your app is pure Java/Kotlin without native dependencies, you're likely fine and can stop reading here.

What problems might occur? Apps with native code may experience:

• Memory alignment issues causing crashes

• Compatibility problems with older native libraries

• Unexpected behavior during memory allocation

What should you do? Google Play will require apps to be compatible with 16KB page sizes. To prepare:

1. Follow this guide to update your implementation of the Vonage Client SDK

2. Update any native libraries to versions that support 16KB pages

3. Test your app on devices with 16KB pages (or emulators configured for this)

4. Review your NDK code for hardcoded page size assumptions

This requirement ensures your app will work smoothly when the first 16KB page size devices hit the market.

Updating Your Application

Prerequisites

• An Android project with Gradle setup.

• Access to the Vonage Client SDK.

• Minimum Android API 36 as compile and target SDK.

1. Update the Vonage Android SDK Version

First, update your Gradle configuration to use the new SDK and target Android API 36.

In your app/build.gradle file:

android {
    ...
    compileSdk 36
    defaultConfig {
        ...
        targetSdk 36
        ...
    }
}

dependencies {
    ...
    // Vonage Client SDK
    implementation("com.vonage:client-sdk-voice:2.1.0")
}

2. Apply the Android 14+ Audio Hotfix

Starting with API level 34 (Android 14), Android requires a Foreground Service (FGS) to record audio - even if the app is in the foreground.

To comply, start an FGS whenever you handle an outbound or inbound call.

Outbound Calls

When placing an outbound call:

client.serverCall(context) { err, callId ->
    err?.let {
        println("Error starting outbound call: $it")
    } ?: callId?.let {
        println("Start outbound Call success: $it")
        requireActivity().getSharedPreferences("legid", Context.MODE_PRIVATE).edit().apply {
            putString("legid", it)
            apply()
        }
        activeCallId = it
        telecomHelper.startOutgoingCall(it, "SERVER-CALL")        

        // Required on API 34+: Start FGS for audio recording
        startForegroundService(requireContext())
    }
}

Inbound Calls

When handling incoming calls:

client.setCallInviteListener { callId, from, type ->
    activeCallId = callId
    println("Call from: $from, via channel $callId, channelType: $type")
    telecomHelper.startIncomingCall(callId, from, type)

    // Required on API 34+: Start FGS for audio recording
    startForegroundService(requireContext())
}

3. Add a Foreground Service with Notification

Android requires any FGS that records audio to display a persistent notification informing the user that recording is active.

You’ll need to implement an AudioRecorderService. A reference implementation is available here: AudioRecorderService.kt (GitHub)

Summary

To support Android 16 KB memory page sizes with Vonage Client SDK:

1. Update Gradle to target API 36 and include the latest SDK version.

2. For Android 14+:

   • Start a Foreground Service when handling calls.

   • Ensure the service posts a notification about the audio recording.

This ensures compliance with Android’s new policies and prevents audio issues during calls.

Thanks to Nathan and Salvatore from the Client SDK team for their technical expertise in putting together this walkthrough. Have you already updated or created a new application that supports 16 KB memory page sizes yet? How was your experience? Let us know in our Developer Community on Slack.