将URL转换为Uri并传入AsyncTask<>的技术实现咨询

Hey there! Let's take a close look at your implementation, discuss its validity, and go over key technical considerations you should keep in mind:

What’s Working Correctly #

• URL-to-Uri Conversion: Converting the image URL string to a Uri makes perfect sense—Android’s system APIs (like ContentResolver or media loading utilities) often prefer Uri over raw strings, as it standardizes handling of different resource types (local files, content provider assets, remote URLs).
• Async Task for Background Work: Using an AsyncTask (or any background thread) to handle image resizing is the right call. Image processing is CPU-intensive and time-consuming, so offloading it from the main thread prevents UI freezes and ANRs (Application Not Responding) — this aligns with Android’s core threading best practices.

Potential Issues & Key Improvements #

Let’s dig into the areas that could cause problems or be optimized:

1. Conflicting AsyncTask Constructor & Parameters #

Your BackgroundImageResize is initialized with a bitmap parameter, but you’re passing a Uri to execute(). This creates a logical conflict:

• If you already have a Bitmap to resize, why pass a Uri (which would require reloading the image)?
• If you need to load the image from the Uri first, the constructor’s bitmap argument is redundant and could waste memory (holding an unused bitmap in memory).

Fix this by clarifying the task’s purpose:

• If resizing an existing Bitmap: Modify the AsyncTask to accept Bitmap as input, not Uri, and remove the Uri parameter from execute().
• If loading from Uri then resizing: Remove the bitmap argument from the constructor, and handle loading/processing entirely from the Uri in doInBackground().

2. Missing Uri Validation #

Uri.parse(imgUrl) doesn’t validate the input string. If imgUrl is null, empty, or malformed (e.g., missing a scheme like file:// or content://), this will either throw a NullPointerException or result in an invalid Uri that breaks subsequent operations.

Add validation to avoid crashes:

imgUrl = intent.getStringExtra(getString(R.string.selected_image));
Log.d(TAG, "Image URL: " + imgUrl);

if (imgUrl == null || imgUrl.trim().isEmpty()) {
    Log.e(TAG, "Image URL is null or empty");
    return;
}

imageUri = Uri.parse(imgUrl);
// Validate the Uri has a valid scheme
if (imageUri.getScheme() == null) {
    Log.e(TAG, "Invalid Uri: No scheme specified (e.g., file://, content://)");
    return;
}

Log.d(TAG, "Image URI: " + imageUri);

3. AsyncTask is Deprecated #

As of Android API 30, AsyncTask is marked as deprecated. Google recommends using modern alternatives for background work, which offer better control, lifecycle awareness, and compatibility:

• Kotlin Coroutines: The simplest option for Kotlin (or Java with coroutines support) — use lifecycleScope to tie work to your component’s lifecycle.
• ExecutorService + Handler: A solid Java-compatible alternative for direct thread management.
• WorkManager: For persistent, deferrable tasks (e.g., resizing images that need to survive app restarts).

Example with ExecutorService (Java):

ExecutorService backgroundExecutor = Executors.newSingleThreadExecutor();
Handler mainHandler = new Handler(Looper.getMainLooper());

backgroundExecutor.execute(() -> {
    // Do image resizing work in background
    byte[] resizedImageBytes = resizeImageFromUri(imageUri);
    
    // Post result back to main thread
    mainHandler.post(() -> {
        // Update UI or process the result here
    });
});

4. Bitmap Memory Management #

If your AsyncTask loads a Bitmap from the Uri, you risk OutOfMemoryErrors (OOM) if the image is large. Always use BitmapFactory.Options to sample down the image before loading it into memory:

// Inside doInBackground(Uri... params)
Uri imageUri = params[0];
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 2; // Halves width/height, reduces memory usage by 75%
// Calculate inSampleSize dynamically based on target dimensions for better control

Bitmap bitmap = BitmapFactory.decodeStream(getContentResolver().openInputStream(imageUri), null, options);
// Resize the bitmap...

// Recycle unused bitmaps to free memory
if (bitmap != null && !bitmap.isRecycled()) {
    bitmap.recycle();
}

5. Log Readability #

Tweak your log statements to add spacing for better readability:

Log.d(TAG, "Image URL: " + imgUrl);
Log.d(TAG, "Image URI: " + imageUri);

Final Recommendations #

1. Clarify the purpose of BackgroundImageResize to resolve the constructor/parameter conflict.
2. Add strict validation for the input URL and resulting Uri to prevent crashes.
3. Migrate from AsyncTask to a modern background processing solution for long-term compatibility.
4. Implement proper Bitmap sampling and memory recycling to avoid OOM issues.

内容的提问来源于stack exchange，提问作者Aditya Sissodiya