Camera Usage Permission Defined In AndroidManifest.xml for Meta Quest Build

[Uralstech]

The usage of WebCamTexture in Runtime\AvatarCreator\Scripts\UI\Elements\PhotoCaptureElement.cs causes Unity to add the camera permission to our app's AndroidManifest.xml. As camera access is not allowed by Meta for their Quest platform, builds of our app cannot be uploaded to the Quest Store or App Lab.

See issue #244.

For those looking for a solution:

• Copy the RPM package at [Your project]\Library\PackageCache\com.readyplayerme.core and save it in another location.
• Remove the package from your Unity project using the Package Manager.
• Drag the RPM package folder to your project's Assets folder.
• Install GLTFast from the Package Manager (check this guide).
• Comment out the problematic lines from com.readyplayerme.core\Runtime\AvatarCreator\Scripts\UI\Elements\PhotoCaptureElement.cs like so:

using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;
#if UNITY_ANDROID
using UnityEngine.Android;
#endif
using UnityEngine.Events;
using UnityEngine.UI;

#pragma warning disable CS1998

namespace ReadyPlayerMe.AvatarCreator
{
    /// <summary>
    /// A Unity MonoBehaviour class for capturing photos from the device's camera.
    /// Allows starting and stopping the camera, capturing photos, and handling camera permissions.
    /// </summary>
    public class PhotoCaptureElement : MonoBehaviour
    {
        [Header("Settings")]
        [SerializeField] private RawImage cameraTextureTarget;
        [SerializeField] private bool initializeOnEnable = true;

        [Space(5)]
        [Header("Events")]
        public UnityEvent<Texture2D> OnPhotoCaptured;

        // private WebCamTexture cameraTexture;
        private bool isInitialized;

        private int videoRotationAngle;
        private bool videoVerticallyMirrored;

        private CancellationTokenSource ctxSource;

        private void OnEnable()
        {
            if (initializeOnEnable)
            {
                StartCamera();
            }
        }

        private void OnDisable()
        {
            ctxSource?.Cancel();
            StopCamera();
        }

        /// <summary>
        /// Starts the device's camera, requesting camera permissions if needed.
        /// </summary>
        public async void StartCamera()
        {
            await RequestCameraPermission();

            if (!isInitialized)
            {
                InitializeCamera();
            }

            // if (cameraTexture != null && !cameraTexture.isPlaying)
            // {
            //     cameraTexture.Play();
            // 
            //     var currentRotation = cameraTextureTarget.transform.rotation;
            //     cameraTextureTarget.transform.rotation = Quaternion.Euler(currentRotation.eulerAngles.x, currentRotation.eulerAngles.y, cameraTexture.videoRotationAngle);
            // 
            //     if (!cameraTexture.videoVerticallyMirrored)
            //     {
            //         cameraTextureTarget.transform.localScale = new Vector3(-1, 1, 1);
            //     }
            // }
        }

        /// <summary>
        /// Stops the device's camera.
        /// </summary>
        public void StopCamera()
        {
            // if (cameraTexture != null && cameraTexture.isPlaying)
            // {
            //     cameraTexture.Stop();
            // }
        }

        /// <summary>
        /// Takes a photo from the camera and invokes the onPhotoCaptured event with the captured texture.
        /// </summary>
        public void TakePhoto()
        {
            // if (cameraTexture == null || !cameraTexture.isPlaying)
            //     return;
            // 
            // var texture = new Texture2D(cameraTextureTarget.texture.width, cameraTextureTarget.texture.height, TextureFormat.ARGB32, false);
            // texture.SetPixels(cameraTexture.GetPixels());
            // texture.Apply();
            // 
            // OnPhotoCaptured?.Invoke(texture);
        }

        /// <summary>
        /// Requests camera permissions from the user for IOS and Android devices.
        /// </summary>
        private async Task RequestCameraPermission()
        {
            ctxSource?.Cancel();
            ctxSource = new CancellationTokenSource();

#if UNITY_ANDROID
            if (!Permission.HasUserAuthorizedPermission(Permission.Camera))
            {
                Permission.RequestUserPermission(Permission.Camera);
            }

            while (!Permission.HasUserAuthorizedPermission(Permission.Camera) && !ctxSource.IsCancellationRequested)
            {
                await Task.Yield();
            }

#elif UNITY_IOS
            if (!Application.HasUserAuthorization(UserAuthorization.WebCam))
            {
                var async = Application.RequestUserAuthorization(UserAuthorization.Microphone);
                while (!async.isDone && !ctxSource.IsCancellationRequested)
                {
                    await Task.Yield();
                }
            }
#endif

        }

        /// <summary>
        /// Finds the device's camera and sets up the camera texture.
        /// </summary>
        private void InitializeCamera()
        {
            // var webCamDevice = GetWebCamDevice();
            // SetupPhotoBoothTexture(webCamDevice?.name);
            // isInitialized = true;
        }

        /// <summary>
        /// Sets up the camera texture with the provided texture name.
        /// </summary>
        /// <param name="textureName">The name for the created WebCamTexture</param>
        private void SetupPhotoBoothTexture(string textureName)
        {
            // var size = cameraTextureTarget.rectTransform.sizeDelta;
            // cameraTexture = new WebCamTexture(textureName, (int) size.x, (int) size.y);
            // cameraTextureTarget.texture = cameraTexture;
        }

        /// <summary>
        /// Tries to find the device's front-facing camera or returns default camera.
        /// </summary>
        /// <returns>Returns the WebCamDevice if found</returns>
        // private static WebCamDevice? GetWebCamDevice()
        // {
        //     var devices = WebCamTexture.devices;
        // 
        //     if (devices.Length == 0)
        //         return null;
        // 
        //     var webCamDevice = devices.FirstOrDefault(device => device.isFrontFacing);
        // 
        //     return webCamDevice.Equals(default(WebCamDevice)) ? devices[0] : webCamDevice;
        // }
    }
}