I'll create an Android image upload feature that matches the UI in your screenshot and implements the functionality you described. I'll use XML for the layout and Kotlin for the implementation.

Now let's create the necessary drawable resources:

Now let's implement the Kotlin code for the functionality:

Finally, let's add the necessary provider configuration to the AndroidManifest.xml:

And create the file_paths.xml resource:

How to Use This Implementation:

1. Create all the files as shown above in your Android project.

2. Make sure to add the necessary dependencies in your app's build.gradle file:

   implementation 'androidx.cardview:cardview:1.0.0' implementation 'androidx.constraintlayout:constraintlayout:2.1.4'

3. Add the required permissions to your AndroidManifest.xml:

   <uses-permission android:name="android.permission.CAMERA" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" />

Features Implemented:

1. UI matches the provided screenshot with the "Image Upload" title and "Add New Image" button
2. When the user clicks on the add button, they get options to take a photo or choose from gallery
3. After selecting an image, it's displayed in the preview area
4. A delete button allows the user to remove the image and return to the upload state
5. Only one image can be uploaded at a time
6. Proper permission handling for camera access
7. File provider configuration for camera captures

This implementation follows modern Android development practices using Kotlin and handles all the edge cases for image capture and selection.

I see the issue. You're encountering a "Canvas: trying to draw too large bitmap" error when users try to upload large images. Let's modify the code to handle large images properly by:

1. Checking and resizing large images before displaying them
2. Showing a proper error message when image size exceeds limits
3. Preventing the blank preview screen issue

Here's the updated implementation:

Key Changes Made:

1. Added Image Size Checking:

   • Added a MAX_IMAGE_SIZE constant (5MB) to limit file size
   • Added a method to check file size before processing

2. Added Bitmap Sampling and Resizing:

   • Added decodeSampledBitmapFromUri() method to safely load large images
   • Added calculateInSampleSize() to determine optimal sampling rate
   • Set maximum bitmap dimensions to prevent "Canvas: trying to draw too large bitmap" errors

3. Improved Error Handling:

   • Added specific error messages for different failure scenarios
   • Prevented blank preview screen by checking image validity before displaying

4. Memory Management:

   • Added bitmap recycling to prevent memory leaks
   • Used more memory-efficient bitmap configuration (RGB_565)
   • Properly closed input streams and file descriptors

5. Image Processing Workflow:

   • Created a new processSelectedImage() method that handles all validation and processing
   • Added a method to save resized bitmaps to temporary files

These changes will prevent the "Canvas: trying to draw too large bitmap" error and provide a better user experience by:

1. Showing clear error messages when images are too large
2. Automatically resizing large images to prevent crashes
3. Avoiding the blank preview screen issue
4. Properly handling memory to prevent OutOfMemoryError exceptions

The user will now see a toast message like "Image size exceeds limit (max 5MB). Please select a smaller image." instead of experiencing a crash or seeing a blank screen.