Understanding Android API 23: Features and Development Guide

In the world of mobile software development, few milestones have reshaped the landscape quite like API 23—better known as Android 6.0 Marshmallow. Released by Google, this specific API level marked a philosophical and technical turning point for the Android ecosystem, shifting how applications interact with users, hardware, and privacy controls.

Whether you are an Android veteran reminiscing about the transition from “install-time” to “runtime” permissions or a curious developer exploring legacy requirements, API 23 remains a foundational cornerstone in mobile engineering history.

1. The Genesis: What is API 23?

API 23 corresponds to Android Marshmallow (SDK version 23), released commercially in late 2015. While it introduced user-facing features like Doze mode for battery optimization and Google Now on Tap, its under-the-hood architectural changes permanently altered Android app development.

Before API 23, Android operated under an all-or-nothing permission model. When users downloaded an app from the Google Play Store, a long list of requested permissions (access to the camera, contacts, location, storage) was displayed upfront. If you didn’t like a permission, your only choice was not to install the app. API 23 tore down that paradigm.

2. The Revolution: Runtime Permissions

The single most significant contribution of API 23 was the introduction of Runtime Permissions.

Instead of forcing users to grant all permissions upon installation, apps targeting API 23 (or higher) had to request sensitive permissions at the exact moment the feature was needed. For instance, an app could no longer quietly snap photos or read contacts in the background without explicit consent; a system dialog would pop up asking the user to Allow or Deny access on the fly.

• Developer Impact: Developers had to rewrite how they handled asynchronous user states. Codebases could no longer assume that Manifest.permission.ACCESS_FINE_LOCATION was granted just because it was declared in the AndroidManifest.xml.
• User Impact: Trust skyrocketed. Users gained granular control over their privacy, capable of revoking permissions later via system settings without breaking the entire application experience.

3. Other Defining Features of API 23

While runtime permissions stole the spotlight, API 23 introduced several other critical APIs and framework capabilities:

• Doze Mode and App Standby: Android 6.0 introduced aggressive power-saving features. API 23 gave developers tools to handle device idle states, ensuring apps queued background tasks efficiently rather than draining the battery.
• Fingerprint Authentication: API 23 standardized biometric authentication. For the first time, developers had a built-in, secure FingerprintManager API to integrate hardware fingerprint sensors into apps for logins and payments.
• Direct Share: Apps could now provide direct targets (like a specific chat thread or frequent contact) to the system share sheet, making sharing content deeply context-aware.
• Text Selection Actions: Floating toolbars appeared right next to selected text, allowing custom actions like translate, search, or share natively within text views.

4. API 23 in the Modern Ecosystem

As the Android ecosystem evolves toward higher API targets (often pushing past SDK 33, 34, and beyond), you might wonder why API 23 still pops up in technical discussions.

1. The Legacy Baseline: For many libraries and cross-platform frameworks (like early iterations of Android Jetpack tools), API 23 historically served as a common baseline floor (minSdk) because it guaranteed the presence of the runtime permission model.
2. Backward Compatibility: Because older devices still linger in the wild, understanding how API 23 handles permission checks gracefully alongside Android’s modern compatibility libraries (ActivityCompat.checkSelfPermission) remains a core competency for robust Android development.

Summary

API 23 wasn’t just a routine SDK increment; it was the moment Android grew up regarding digital privacy and user empowerment. By replacing the archaic “take it or leave it” install-time permission model with dynamic, context-aware runtime requests, Android 6.0 laid the groundwork for the secure, transparent mobile experiences we rely on every single day.