跨App图片传递咨询：App A调用App B处理后无需存SD卡的实现

Hey there! Let's work through this cross-app image handoff scenario where you need to send a processed image from App B back to App A without saving to external storage. Your Base64 approach is valid, but it has limitations with larger images—so I'll cover both that optimized flow and a more robust solution using Content Providers.

Option 1: Optimized Base64 String Transfer #

This works well for small to medium-sized images, but be aware of Intent size limits (usually ~1MB) which can cause TransactionTooLargeException for bigger files.

Step 2 (App B: Process image and convert to Base64) #

After handling the camera, cropping, and adjustments, convert your processed Bitmap to a Base64 string:

// Assume processedBitmap is your final image after edits
ByteArrayOutputStream baos = new ByteArrayOutputStream();
processedBitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
byte[] imageBytes = baos.toByteArray();
String base64Image = Base64.encodeToString(imageBytes, Base64.DEFAULT);

Step 3 (App B: Send Base64 back to App A) #

Package the string into an Intent and return it as the result:

Intent resultIntent = new Intent();
resultIntent.putExtra("processed_image_base64", base64Image);
setResult(Activity.RESULT_OK, resultIntent);
finish();

Step 4 (App A: Receive and decode the Base64 string) #

In your onActivityResult method, parse the string back into a Bitmap:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == 100 && resultCode == Activity.RESULT_OK) {
        String base64Image = data.getStringExtra("processed_image_base64");
        byte[] imageBytes = Base64.decode(base64Image, Base64.DEFAULT);
        Bitmap processedBitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length);
        // Use the processed bitmap as needed
    }
}

Option 2: Content Provider (Recommended for Large Images) #

This method uses App B's internal cache storage and a Content Provider to share the image file directly, avoiding the Intent size limit entirely. No external SD card is involved.

Step 1: Set up Content Provider in App B #

First, register the provider in App B's AndroidManifest.xml:

<provider
    android:name=".ImageProvider"
    android:authorities="com.appb.imageprovider"
    android:exported="true"
    android:grantUriPermissions="true" />

Then implement the ImageProvider class to handle file access:

public class ImageProvider extends ContentProvider {
    @Override
    public boolean onCreate() {
        return true;
    }

    @Override
    public ParcelFileDescriptor openFile(Uri uri, String mode) throws FileNotFoundException {
        // Fetch the temporary file from App B's cache directory
        File file = new File(getContext().getCacheDir(), uri.getLastPathSegment());
        return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
    }

    // The following methods can return default values since we only need file access
    @Nullable
    @Override
    public Cursor query(@NonNull Uri uri, @Nullable String[] projection, @Nullable String selection, @Nullable String[] selectionArgs, @Nullable String sortOrder) {
        return null;
    }

    @Nullable
    @Override
    public String getType(@NonNull Uri uri) {
        return "image/*";
    }

    @Nullable
    @Override
    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
        return null;
    }

    @Override
    public int delete(@NonNull Uri uri, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }

    @Override
    public int update(@NonNull Uri uri, @Nullable ContentValues values, @Nullable String selection, @Nullable String[] selectionArgs) {
        return 0;
    }
}

Step 2: App B save processed image to cache and return Uri #

After editing the image, save it to App B's internal cache, then send the Content Uri to App A:

// processedBitmap is your edited image
File tempImageFile = new File(getCacheDir(), "processed_temp_img.png");

try (FileOutputStream fos = new FileOutputStream(tempImageFile)) {
    processedBitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
} catch (IOException e) {
    e.printStackTrace();
    setResult(Activity.RESULT_CANCELED);
    finish();
    return;
}

// Generate the Content Uri for the file
Uri imageUri = Uri.parse("content://com.appb.imageprovider/" + tempImageFile.getName());

// Grant temporary read permission to App A
Intent resultIntent = new Intent();
resultIntent.setData(imageUri);
resultIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);

setResult(Activity.RESULT_OK, resultIntent);
finish();

Step 3: App A load image from the Uri #

In App A's onActivityResult, use the Uri to stream the image directly:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == 100 && resultCode == Activity.RESULT_OK) {
        Uri imageUri = data.getData();
        if (imageUri != null) {
            try (InputStream inputStream = getContentResolver().openInputStream(imageUri)) {
                Bitmap processedBitmap = BitmapFactory.decodeStream(inputStream);
                // Use the processed bitmap
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Key Notes for Content Provider Approach: #

• The temporary file is stored in App B's internal cache—Android will automatically delete it if storage is low, or you can manually delete it in App B after returning the result.
• Using Intent.FLAG_GRANT_READ_URI_PERMISSION ensures App A has temporary access to the file without needing permanent permissions.

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