Capacitor Camera restarts apps on certain Android 13 devices

[klaurtar]

Bug Report

Plugin(s)

@capacitor/camera v5.X.X

Capacitor Version

💊   Capacitor Doctor  💊 

Latest Dependencies:

  @capacitor/cli: 5.2.3
  @capacitor/core: 5.2.3
  @capacitor/android: 5.2.3
  @capacitor/ios: 5.2.3

Installed Dependencies:

  @capacitor/cli: 5.0.3
  @capacitor/core: 5.2.2
  @capacitor/android: 5.0.3
  @capacitor/ios: 5.0.3

[success] iOS looking great! 👌
[error] Missing <manifest package=""> attribute in app/src/main

Platform(s)

Certain Android devices running Android 13 with SDK version 33
Reports of this happening have come from:

• Samsung SM-A426U
• Samsung Galaxy S21FE
• Samsung Galaxy S21 5G

Current Behavior

When Camera.getPhoto() is called the system allows the user to choose a photo or take a photo. When take a photo is clicked, the system's camera UI is displayed. A user is then allowed to take a photo. When the photo is taken, it will then ask the user if they would like to retry the photo or if it is ok. When the ok option is selected, the app restarts as if the user had just opened the app. No debugging occurs as the console is wiped everytime this happens.

Screen_Recording_20230814_223820_bad_camera_android.mp4

Expected Behavior

Camera.getPhoto() should allow Android 13 users to take a photo, and then approve the photo. This should not restart the app.

Record_2023-08-14-22-40-15.mp4

Code Reproduction

Here is a working recreation of the bug

Run the Android app on a physical Samsung Android 13 device like I listed above. Click the + icon on the placeholder image to take a photo. Then quickly click the ok or checkmark button. This should cause the app to restart. I had to take a photo 3 times before the bug started occurring. If it is not occuring, kill the app and restart it and repeat the process.

Other Technical Details

Additional Context

I found this related Ionic forum post about this issue

I also noticed from testing that if a user with an effected device takes a photo, then waits for about 10 seconds before pressing ok or the checkmark on the system UI, it will work as it should. However, if a user quickly takes a photo and accepts it, the app restarts.

I unfortunately need a fix for this asap. My business relies on this feature. Thanks!

[klaurtar]

Can anyone from the Capacitor team at least let me know they've seen this report? My Android app is getting review bombed due to this bug

[dallastjames]

Hey @klaurtar!
We took a good look at this yesterday and were not able to reproduce it across our suite of devices. I believe that the issue you're running into is actually a fairly common issue with Android. When the camera is launched, it's a new "activity" and that puts your application in the background. The behavior of the Android OS is that if it needs more memory, it'll kill things that are in the background, and that can include your application. All symptoms in your report seem to point to that being what's going on: no crash report, app is restarting, occurs when you finish the flow with the camera app and it's trying to return to your application.

There are two pieces you need to handle this in your application. When you go to open something over the top of your application, in this case camera, but it could apply to other things too, you should save enough information about the state of your application that you can restore it if the OS kills your application. That might include things like what page the user was on, any form data, etc. This would allow you to restore your app state on init again if needed. Then, whenever you return from this other "something" that you're doing, you would clear that data from memory, so you don't restore to this state later when it doesn't make sense. That's the first half.

The second half is "how do I get the data from the camera if the webview was restarted?" Obviously, you'll have no more promise to await, however, the camera data will still be made available through the appRestoredResult. This is our way of providing your app with any data sent to your application if it had been closed due to the Android OS killing your app in the background (same as described in the SO link above).

Put those two pieces together, and you can smoothly handle your app restarting due to Android low memory behavior!
Hope this helps!

[klaurtar]

Thank you for the detailed reply. I will see if this helps.

[LeonardoRT96]

I had the same problem, my solution was to change CameraResultType.Uri to CameraResultType.Base64. But I need an effective solution that allows me to use CameraResultType.Uri.

[michael-arboleda]

I am still getting this issue. Not only on Android but iOS as well. I added Crashlytics log around Camera.getPhoto since this is where the app restarts. According to Crashlytics, the device does have a good amount of RAM and Disk memory free.

Here are the device details of an Android device restarting:
Device
Brand: Samsung
Model: Galaxy S20 FE 5G
RAM free: 1.68 GB
Disk free: 71.4 GB

Operating System
Version: Android 13
Orientation: Portrait
Rooted: No

[klaurtar]

@michael-arboleda Yeah that is my thoughts as well. The phones have plenty of memory left when this happens. I have started working on adding the fix the Capacitor team recommended above. It is a bit of a hacky workaround having to access the pre-crash state and then get the user back to where they were. Were you able to recreate the issue on the sample application I provided?

[klaurtar]

@dallastjames Anyway to get a second look at this? @michael-arboleda brings up a good point with his above comment. I still think Capacitor could have a bug

[klaurtar]

UPDATE: When the application is in the camera UI from calling the Camera.getPhoto method, the bug almost NEVER occurs when the flash is turned on.

[dallastjames]

@klaurtar I'm happy to look at this issue again, but I do still believe that this is most likely the Android OS just killing the app in the background. We've looked at the sample provided and tested across our devices and have not been able to replicate this issue, so at the moment, there really isn't anything we can do about without additional information. If the application is crashing, there should be crash logs from that, and I believe you can typically get those from your play store console to help debug crashes in production. Any chance you could provide those here?

The most likely case here is just the Android OS killing your app in the background. According to the Android Activity lifecycle docs the state of having the camera in the foreground puts your application in the higher category for the OS killing your application. The method I described above, while it might feel hacky, is the recommended approach given by Android and is just abstracted away into the Capacitor appRestoredResult handler. Unfortunately, just looking at the amount of RAM available when the app was killed isn't a way to judge if the app was terminated by the OS or not. The example provided above, assuming the lower-end S20 FE 5G (6 gb ram) still puts ram usage at ~75% (and ~80% for the 8gb model) at the time the app was killed. There's no information available from Android that details limits and thresholds, but it seems plausible that it might happen in the case.

Anyways, if you do have crash logs I'd love to see them and we can take a look to see if there's something telling within the logs that can help us track down if there is a bug in Capacitor. If there is, we'll happily take a look and see what we can do!

[dallastjames]

One other resource one of the other team members brought up. It hasn't been updated super recently, but we haven't seen anything indicating that anything has changed since Android 11 anyways. https://dontkillmyapp.com/samsung Samsung is notoriously quick to kill background apps, so it's not surprising that all the reported devices here as Samsung devices as well.

[klaurtar]

@dallastjames Thanks for the update. I've implemented the above fix you mentioned and it's working. I'll continue to do some digging and see if I can gain any insights on the issue, and report back. I'm glad Capacitor has an answer for this out of the box. Thank you!

[ZioCain]

I have a very lowend Android and as time goes by, it kills more and more apps while taking pictures.
My user solution was to reduce the quality of the images taken by the camera so that it would take less computing effort and has to kill fewer apps.

It's not a good solution, but it might help to lower the overall quality from the camera settings (at least for testing purposes)