As of API level 22, Android developers may have noticed a significant change in how drawable resources are accessed in applications. Specifically, the getResources().getDrawable() method has been deprecated. This change reflects a broader effort to enforce backward compatibility and enhance application performance across a myriad of devices. Let's delve into the reasons for this deprecation, the recommended alternatives, and provide a technical guide to migrating existing codebases.

Understanding getResources().getDrawable()

The getResources().getDrawable() method was traditionally used to retrieve drawable resources using a resource identifier. It returned a Drawable object associated with a particular resource ID. For example:

Drawable myIcon = getResources().getDrawable(R.drawable.my_icon);

Under the hood, this method loaded the drawable, but due to how resources might differ on different devices and system configurations, it could lead to inconsistencies and errors, especially regarding themes and styling.

Reasons for Deprecation

The primary reason for the deprecation of getResources().getDrawable() is to promote theme-awareness in drawable retrieval.

• Theme Awareness: The deprecated method does not consider the current theme of the application, leading to drawables that might not properly adapt to theme changes.
• Resource Efficiency: With the growth of Android devices and screen sizes, resource efficiency becomes pivotal. Using context-aware methods helps ensure that the most appropriate resources are chosen for given conditions.
• Future Compatibility: Adapting more flexible resource methods ensures that applications can easily migrate with future Android platform changes without substantial code alterations.

Recommended Alternatives

The recommended approach to retrieve a Drawable, post-deprecation, involves using the ContextCompat class or using the Resources.getDrawable(int, Theme) method, which includes a Theme parameter.

Using ContextCompat

Drawable myIcon = ContextCompat.getDrawable(context, R.drawable.my_icon);

Here, context refers to an activity or application context. This approach inherently respects the currently applied theme.

Using Resources.getDrawable(int, Theme)

Drawable myIcon = getResources().getDrawable(R.drawable.my_icon, context.getTheme());

This method takes a Theme parameter, which ensures that the correctly themed resource is obtained. If no theme is required, you can pass null.

Example of Migration

To demonstrate how to migrate existing code, let's consider a scenario where drawable resources are dynamically loaded based on user interaction.

Deprecated Approach

1public void changeIcon() {
2    Drawable oldIcon = getResources().getDrawable(R.drawable.old_icon);
3    imageView.setImageDrawable(oldIcon);
4}

Modern Approach

1public void changeIcon() {
2    Drawable newIcon = ContextCompat.getDrawable(context, R.drawable.new_icon);
3    imageView.setImageDrawable(newIcon);
4}

In the updated version, ContextCompat ensures compatibility with the given Android version and applies the current theme contextually.

A Summary of Key Points

Additional Considerations

• Compatibility Libraries: When targeting a broad range of Android versions, ensure that compatibility libraries are included, as they provide backward-compatible classes and methods.
• Performance: Avoid frequent loading of drawables in performance-sensitive areas. Consider caching drawables where possible to enhance application responsiveness.
• State Lists: For stateful behavior, such as different images for button states, use StateListDrawable to define different drawable states in XML.

Conclusion

The deprecation of getResources().getDrawable() in API level 22 reflects Android's commitment to better theme management, resource efficiency, and futureproofing applications. Developers are encouraged to transition to the use of ContextCompat or theme-aware drawable retrieval mechanisms to ensure their applications are robust, visually consistent, and adaptable to future changes in the Android ecosystem. By doing so, applications not only enhance their compatibility but also improve their performance and visual fidelity across a wide array of devices.