Performance class
is a standard first introduced in Android 12. A performance
class defines a set of device capabilities that goes beyond Android's baseline
requirements.
Each version of Android has its own corresponding performance class, which is
defined in that version's
Android Compatibility Definition Document
(CDD)
. The
Android Compatibility
Test Suite (CTS)
verifies the
CDD requirements.
Each Android-powered device declares the performance class that it supports.
Developers can find the device's performance class at runtime and provide
upgraded experiences that take full advantage of the device's capabilities.
To find a device's performance class level, use the Jetpack
Core
Performance
library. This library reports the device's media performance class as declared
in the
build version
information
or
based on data from Google Play services.
Start by adding a dependency for the relevant modules in your gradle file:
Kotlin
// Implementation of Jetpack Core library.
implementation("androidx.core:core-ktx:1.12.0")
// Enable APIs to query for device-reported performance class.
implementation("androidx.core:core-performance:1.0.0-beta02")
// Enable APIs to query Google Play Services for performance class.
implementation("androidx.core:core-performance-play-services:1.0.0-beta02")
Groovy
// Implementation of Jetpack Core library.
implementation 'androidx.core:core-ktx:1.12.0'
// Enable APIs to query for device-reported performance class.
implementation 'androidx.core:core-performance:1.0.0-beta02'
// Enable APIs to query Google Play Services for performance class.
implementation 'androidx.core:core-performance-play-services:1.0.0-beta02'
Then, create an instance of a
DevicePerformance
implementation, such as
PlayServicesDevicePerformance
,
in the
onCreate()
lifecycle event of your
Application
. This should only be
done once in your app.
Kotlin
import androidx.core.performance.play.services.PlayServicesDevicePerformance
class MyApplication : Application() {
lateinit var devicePerformance: DevicePerformance
override fun onCreate() {
// Use a class derived from the DevicePerformance interface
devicePerformance = PlayServicesDevicePerformance(applicationContext)
}
}
Java
import androidx.core.performance.play.services.PlayServicesDevicePerformance;
class MyApplication extends Application {
DevicePerformance devicePerformance;
@Override
public void onCreate() {
// Use a class derived from the DevicePerformance interface
devicePerformance = new PlayServicesDevicePerformance(applicationContext);
}
}
You can then retrieve the
mediaPerformanceClass
property to tailor your app's
experience based on the device's capabilities:
Kotlin
class MyActivity : Activity() {
private lateinit var devicePerformance: DevicePerformance
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Note: Good app architecture is to use a dependency framework. See
// https://developer.android.com/training/dependency-injection for more
// information.
devicePerformance = (application as MyApplication).devicePerformance
}
override fun onResume() {
super.onResume()
when {
devicePerformance.mediaPerformanceClass >= Build.VERSION_CODES.TIRAMISU -> {
// Performance class level 13 and later.
// Provide the most premium experience for the highest performing devices.
}
devicePerformance.mediaPerformanceClass == Build.VERSION_CODES.S -> {
// Performance class level 12.
// Provide a high quality experience.
}
else -> {
// Performance class level 11 or undefined.
// Remove extras to keep experience functional.
}
}
}
}
Java
class MyActivity extends Activity {
private DevicePerformance devicePerformance;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Note: Good app architecture is to use a dependency framework. See
// https://developer.android.com/training/dependency-injection for more
// information.
devicePerformance = ((MyApplication) getApplication()).devicePerformance;
}
@Override
public void onResume() {
super.onResume();
if (devicePerformance.getMediaPerformanceClass() >= Build.VERSION_CODES.TIRAMISU) {
// Performance class level 13 and later.
// Provide the most premium experience for the highest performing devices.
} else if (devicePerformance.getMediaPerformanceClass() == Build.VERSION_CODES.S) {
// Performance class level 12.
// Provide a high quality experience.
} else {
// Performance class level 11 or undefined.
// Remove extras to keep experience functional.
}
}
}
Performance classes are forward-compatible. A device can upgrade to a newer
platform version without updating its performance class. For example, a device
that initially supports performance class 12 can upgrade to Android 13 and
continue to report it supports class 12 if it doesn't meet the class 13
requirements. This means that a performance class provides a way to group
devices together without relying on a particular Android version.
Figure 1.
Devices can upgrade Android versions and
continue reporting that they support the class they originally
support.
Performance class 14
Performance class 14 builds on requirements introduced in performance class 13.
The specific performance class requirements are published in the
Android
CDD
.
In addition to increased requirements for items from performance class 13, the
CDD specifies requirements in the following areas:
- Film grain effect support in AV1 hardware decoders
- AVIF Baseline Profile
- AV1 encoder performance
- HDR video codecs
- RGBA_1010102 color format
- YUV texture sampling
- Video encoding quality
- Multichannel audio mixing
Camera
- Night mode extension
- HDR-capable primary camera
- Face detection scene mode
Generic
- Hardware overlays
- HDR display
Performance class 13
Performance class 13 builds on requirements introduced in performance class 12.
The specific performance class requirements are published in the
Android
CDD
.
In addition to increased requirements for items from performance class 12, the
CDD specifies requirements in the following areas:
- AV1 hardware decoder
- Secure hardware decoders
- Decoder initialization latency
- Round-trip audio latency
- Wired headsets and USB audio devices
- MIDI devices
- Hardware-backed trusted execution environment
Camera
- Preview stabilization
- Slow-mo recording
- Minimum zoom ratio for ultrawide cameras
- Concurrent camera
- Logical multi-camera
- Stream use case
Performance class 12
Performance class 12 focuses on media use cases. The specific performance class
requirements are published in the
Android
CDD
.
The CDD specifies requirements in the following areas:
- Concurrent video codec sessions
- Encoder initialization latency
- Decoder frame drops
- Encoding quality
Camera
- Resolution and frame rate
- Startup and capture latencies
FULL
or better hardware level
- Timestamp source is realtime
- RAW capability
Generic
- Memory
- Read and write performance
- Screen resolution
- Screen density
Performance class 11
Performance class 11 includes a subset of the requirements for performance class
12, letting developers provide a tailored experience on earlier but still highly
capable devices. The specific performance class requirements are published in
the
Android
CDD
.
Recommended for you