Second Camera Tearing on Android

I was ultimately able to fix this by creating a camera that gets rendered before any other cameras (depth -100). This camera has its script execution order set to run after everything else. Each frame it does the following:

1. In LateUpdate it disables all other cameras.

2. In OnRenderImage, it sets texture of each camera to the source render texture and renders them manually (it internally keeps a list of depth sorted cameras).

3. A coroutine I set to run (in LateUpdate) that yields WaitForEndOfFrame reenables all of the cameras (a lot of logic in other parts of the code depended on various cameras existing/being enabled).

Unfortunately rendering to texture is SLOW on any version of Unity prior to 3.5.3 (a separate issue we're looking into) and we are having problems with 3.5.3 and later crashing so aren't actually using this solution right now.

Here's the code in case anybody is interested:

 public class CameraCombiner : MonoBehaviour
 {
     private int frameSkip = 0;
     private List<Camera> camerasToCombine = new List<Camera>();
     
     private static CameraCombiner instance;
     
     private static bool quitting = false;
     
     void OnApplicationQuit() {
         quitting = true;
     }
     
     public static CameraCombiner Instance() {
         if (Application.isPlaying && instance == null && !quitting) {
             Debug.LogWarning("CREATING CAMERA COMBINER");
             Debug.LogWarning("###################################################################################");
             
             GameObject cameraCombinerGameObject = GameObject.Find("CameraCombiner"); 
             if (cameraCombinerGameObject == null) {
                 cameraCombinerGameObject = new GameObject("CameraCombiner");
                 Object.DontDestroyOnLoad(cameraCombinerGameObject);
             }
             
             Camera fakeCamera = cameraCombinerGameObject.GetComponent<Camera>();
             if (fakeCamera == null) {
                 fakeCamera = cameraCombinerGameObject.AddComponent<Camera>();
             }
             fakeCamera.cullingMask = 0;
             fakeCamera.depth = -100;
             
             CameraCombiner combiner = cameraCombinerGameObject.GetComponent<CameraCombiner>();
             if (combiner == null ) {
                 combiner = cameraCombinerGameObject.AddComponent<CameraCombiner>();
             }
             instance = combiner;
         }
         return instance;
     }
     
     void OnEnable()
     {
         if (Application.isPlaying)
         {
             frameSkip = 1;
         }
     }
     
     private IEnumerator OnFinishedRenderingEverything() {
         yield return new WaitForEndOfFrame();
         foreach (Camera cameraToCombine in camerasToCombine) {
             if (cameraToCombine != null && cameraToCombine.gameObject.active) {
                 cameraToCombine.enabled = true;
             }
         }
     }
     
     void LateUpdate() {
         StartCoroutine(OnFinishedRenderingEverything());
         foreach (Camera cameraToCombine in camerasToCombine) {
             if (cameraToCombine != null && cameraToCombine.gameObject.active) {                
                 cameraToCombine.enabled = false;
             }
         }
     }
     
     void OnRenderImage(RenderTexture source, RenderTexture destination) {
         if (frameSkip > 0)
         {
             frameSkip--;
             return;
         }
         
         foreach (Camera cameraToCombine in camerasToCombine) {
             if (cameraToCombine != null && cameraToCombine.gameObject.active) {                
                 cameraToCombine.targetTexture = source;
                 cameraToCombine.Render();
                 cameraToCombine.targetTexture = null;
             }
         }
         
         Graphics.Blit(source, destination);
     }
     
     private static int CompareCameraDepths(Camera lhs, Camera rhs) {
         if (lhs == rhs) return 0;
         if (lhs == null) return -1;
         if (rhs == null) return 1;
         return lhs.depth.CompareTo(rhs.depth);
     }
     
     public void RegisterCamera(Camera camera) {
         if (!camerasToCombine.Contains(camera)) {
             camerasToCombine.Add(camera);
             camerasToCombine.Sort(CompareCameraDepths);
         }
     }
     
     public void DeregisterCamera(Camera camera) {
         camerasToCombine.Remove(camera);
     }
 }