Android Gallery Picker Implementation: Evolution from ACTION_PICK to Modern Photo Picker

Introduction

In Android application development, selecting images from the device gallery is a common requirement. Developers often encounter issues with filtering specific file types, such as displaying only images without videos. This article systematically introduces various methods for implementing image selection functionality based on high-scoring Stack Overflow answers and official Android documentation.

Traditional Approach: Limitations of ACTION_PICK

Many developers initially use Intent.ACTION_PICK to implement image selection:

Intent intent = new Intent(Intent.ACTION_PICK, 
    android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
startActivityForResult(intent, TFRequestCodes.GALLERY);

The main issue with this approach is the inability to effectively filter file types. Even when specifying MediaStore.Images.Media.EXTERNAL_CONTENT_URI, some gallery applications on certain devices still display video files, which creates a poor user experience.

Improved Solution: ACTION_GET_CONTENT

A more reliable solution is using Intent.ACTION_GET_CONTENT, which provides better file type control:

Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(Intent.createChooser(intent, "Select Picture"), PICK_IMAGE);

By setting setType("image/*"), the system filters out non-image files, ensuring users can only select image format files.

Handling Selection Results

After selection completes, you need to process the returned data in the onActivityResult method:

public static final int PICK_IMAGE = 1;

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    if (requestCode == PICK_IMAGE && resultCode == Activity.RESULT_OK) {
        if (data == null) {
            // Handle selection failure
            return;
        }
        Uri selectedImageUri = data.getData();
        // Use ContentResolver to get file stream
        try {
            InputStream inputStream = getContentResolver().openInputStream(selectedImageUri);
            // Process image data
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Compatibility with Multiple Gallery Applications

To provide better user experience, you can support both system document applications and third-party gallery applications:

Intent getIntent = new Intent(Intent.ACTION_GET_CONTENT);
getIntent.setType("image/*");

Intent pickIntent = new Intent(Intent.ACTION_PICK, 
    android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
pickIntent.setType("image/*");

Intent chooserIntent = Intent.createChooser(getIntent, "Select Image");
chooserIntent.putExtra(Intent.EXTRA_INITIAL_INTENTS, new Intent[] {pickIntent});

startActivityForResult(chooserIntent, PICK_IMAGE);

This approach allows users to choose between using the system document application or their preferred gallery application for image selection.

Modern Solution: Photo Picker API

Android 11 and later versions introduced the Photo Picker API, providing a safer and more unified image selection experience:

// Register photo picker activity launcher
ActivityResultLauncher<PickVisualMediaRequest> pickMedia = 
    registerForActivityResult(new PickVisualMedia(), uri -> {
        if (uri != null) {
            Log.d("PhotoPicker", "Selected URI: " + uri);
        } else {
            Log.d("PhotoPicker", "No media selected");
        }
    });

// Launch photo picker, allowing only image selection
pickMedia.launch(new PickVisualMediaRequest.Builder()
    .setMediaType(PickVisualMedia.ImageOnly.INSTANCE)
    .build());

Multiple File Selection Support

The Photo Picker API also supports multiple file selection functionality:

// Register multiple selection photo picker, maximum 5 files
ActivityResultLauncher<PickVisualMediaRequest> pickMultipleMedia = 
    registerForActivityResult(new PickMultipleVisualMedia(5), uris -> {
        if (!uris.isEmpty()) {
            Log.d("PhotoPicker", "Number of items selected: " + uris.size());
        } else {
            Log.d("PhotoPicker", "No media selected");
        }
    });

Device Compatibility Considerations

Photo Picker is available on devices that meet the following criteria:

• Devices running Android 11 (API level 30) or higher
• Devices receiving modular system component changes through Google System Updates

For older devices, you can enable backward-compatible Photo Picker modules by adding specific manifest configurations.

Persistent File Access Permissions

For applications requiring long-term file processing (such as background uploads), you can request persistent URI permissions:

int flag = Intent.FLAG_GRANT_READ_URI_PERMISSION;
getContentResolver().takePersistableUriPermission(uri, flag);

HDR Video Transcoding Support

Android 13 introduced HDR video transcoding functionality to ensure applications can properly handle high dynamic range videos:

@RequiresApi(Build.VERSION_CODES.TIRAMISU)
private void launchPhotoPickerWithTranscoding() {
    MediaCapabilities mediaCapabilities = new MediaCapabilities.Builder()
        .addSupportedHdrType(MediaCapabilities.HdrType.TYPE_HLG10)
        .build();
    
    pickMedia.launch(new PickVisualMediaRequest.Builder()
        .setMediaType(PickVisualMedia.VideoOnly)
        .setMediaCapabilitiesForTranscoding(mediaCapabilities)
        .build());
}

Best Practices Summary

When choosing an image selection solution, consider the following factors:

• Target API Level: New applications should prioritize using the Photo Picker API
• File Type Filtering: Clearly specify required media types
• User Experience: Provide multiple selection methods to accommodate different user habits
• Security: Apply the principle of least privilege, requesting only necessary file access permissions
• Compatibility: Provide fallback solutions for older devices

Conclusion

Android image selection functionality has evolved from simple ACTION_PICK to feature-rich Photo Picker APIs. Developers should choose appropriate solutions based on their application's target audience and device compatibility requirements. Modern Photo Picker APIs offer the best security and user experience, while traditional methods still have value when broad compatibility is needed. By properly selecting and using these APIs, developers can build secure and user-friendly image selection functionality.