UGUI SafeArea 适配

最近有在做手游。各个厂商手机屏幕的尺寸和比例都各不相同。UI适配可以说是一大难题叻。UI美术那边在制作的也有考虑到适配方面的问题，有许多元素是需要我们根据安全区来适配的。
但比较坑爹的一些情况是这样的，要求页面A下方有个按钮托盘，按钮托盘打开的时候要有一个大图背景去阻挡玩家点击原本页面A上的元素。这个按钮托盘还是在其他页面中也有用到的。为了解决这个问题，做了两个Rect适配的脚本。
还没完成，但是感觉基本能用，就先拉上来记一下。

这两个脚本都依赖与当前UI使用的相机和根Canvas。所以在实际使用的时候需要准备好这两个东西。

    public interface UIAreaRect
    {
        Camera GetUICamera();
        Canvas GetRootCanvas();
        void Refresh();
    }

    [ExecuteAlways]
    [RequireComponent(typeof(RectTransform))]
    public class SafeAreaRect : UIBehaviour, ILayoutSelfController
    {
        private static readonly Vector2 s_specialPivot = Vector2.zero; // HACK @Hiko self pivot
        [SerializeField]
        private RectOffset _rectOffset = new RectOffset();

        [SerializeField]
        private Camera _uiCamera;
        [SerializeField]
        private Canvas _rootCanvas;

        private RectTransform m_rect;
        private DrivenRectTransformTracker m_tracker;

        private RectTransform selfRectTransform
        {
            get
            {
                if (m_rect == null)
                {
                    m_rect = GetComponent<RectTransform>();
                }
                return m_rect;
            }
        }

        public void SetLayoutHorizontal()
        {
            Refresh();
        }

        public void SetLayoutVertical()
        {
            Refresh();
        }

        [ContextMenu("Refresh")]
        public void Refresh()
        {
#if UNITY_EDITOR
            RebuildTracker();
#endif
            Canvas rootCanvas = GetRootCanvas();
            Camera uiCamera = GetUICamera();
            RectTransform rectTransform = selfRectTransform, rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            RectTransform parent = rectTransform.transform as RectTransform;
            if (parent == null)
            {
                Debug.LogError("This behaviour can not to be used on root recttransform");
            }
            if (rootCanvas == null || uiCamera == null)
            {
                return;
            }
            Rect safeRect = CalcultateCurrentSafeAreaRect();
            rectTransform.pivot = s_specialPivot;
            Vector3 worldUIPos;
            Vector2 localPos = rootCanvasRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            localPos.x += safeRect.x + _rectOffset.left;
            float deltaX = _rectOffset.horizontal;
            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, safeRect.width - deltaX);
            localPos.y += safeRect.y + _rectOffset.bottom;
            float deltaY = _rectOffset.vertical;
            rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, safeRect.height - deltaY);
            worldUIPos = rootCanvasRectTransform.TransformPoint(localPos);
            rectTransform.position = worldUIPos;
        }

        public Camera GetUICamera()
        {
            // TODO implement the actual code to get camera while in game or in editor 
            return _uiCamera;
        }

        public Canvas GetRootCanvas()
        {
            // TODO implement the actual code to get root canvas while in game or in editor 
            return _rootCanvas;
        }

        private Rect CalcultateCurrentSafeAreaRect()
        {
            Rect safeRect;
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Rect rootCanvasRect = rootRectTransform.rect;
            float rootCanvasWidth = rootCanvasRect.width;
            float rootCanvasHeight = rootCanvasRect.height;

            // temp pretend it is ip12
            float horizontalGap = 0.055f;
            float verticalGap = 0.053f;
            switch (SystemInfo.deviceType)
            {
                case DeviceType.Handheld:
                    Rect deviceSafeRect = Screen.safeArea;
                    if (Mathf.Approximately(deviceSafeRect.x, 0f))
                    {
                        // a device with saferect as fullrect
                        safeRect = new Rect(new Vector2(rootCanvasWidth * horizontalGap, 0f), new Vector2(rootCanvasWidth * (1f - 2 * horizontalGap), rootCanvasHeight * (1f - verticalGap)));
                    }
                    else
                    {
                        Resolution resolution = Screen.currentResolution;
                        float scale = rootCanvasWidth / resolution.width;
                        safeRect = new Rect(deviceSafeRect.x * scale, deviceSafeRect.y * scale, deviceSafeRect.width * scale, deviceSafeRect.height * scale);
                    }
                    break;
                default:
                    // HACK @Hiko it's on PC, create a temp saferect and pretend it is ip12
                    safeRect = new Rect(new Vector2(rootCanvasWidth * horizontalGap, 0f), new Vector2(rootCanvasWidth * (1f - 2 * horizontalGap), rootCanvasHeight * (1f - verticalGap)));
                    break;
            }
            return safeRect;
        }

        private void RebuildTracker()
        {
            m_tracker.Clear();
            m_tracker.Add(this, selfRectTransform, DrivenTransformProperties.All);
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            RebuildTracker();
            SetDirty();
            if (Application.isPlaying)
            {
                Refresh();
            }
        }

        protected override void OnDisable()
        {
            m_tracker.Clear();
            LayoutRebuilder.MarkLayoutForRebuild(selfRectTransform);
            base.OnDisable();
        }

        private void SetDirty()
        {
            if (!IsActive())
            {
                return;
            }
            LayoutRebuilder.MarkLayoutForRebuild(selfRectTransform);
        }

#if UNITY_EDITOR

        [Header("Editor readonly debug stuff")]
        [SerializeField]
        private Rect _editorSafeRect;
        [SerializeField]
        private Vector2 _editorCurrentResolution;
        [SerializeField]
        private Vector2 _editorScreenSize;
        [SerializeField]
        private float _editorScreenFactor;
        [SerializeField]
        private float _editorScreenDpi;
        [SerializeField]
        private float _editorCanvasFactor;
        [SerializeField]
        private Rect _editorRootCanvasRect;

        private void OnDrawGizmosSelected()
        {
            UpdateEditorPreviewData();
            Color color = Color.blue;
            Rect safeRect = CalcultateCurrentSafeAreaRect();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Vector2 bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            bottomLeft.x += safeRect.x;
            bottomLeft.y += safeRect.y;
            DrawBox(rootRectTransform, bottomLeft, safeRect.size, color);
            // draw safe area end

            if (Mathf.Approximately(_rectOffset.horizontal, 0f) && Mathf.Approximately(_rectOffset.vertical, 0f))
            {
                return;
            }
            Rect nextRect = safeRect;
            nextRect.width -= _rectOffset.horizontal;
            nextRect.height -= _rectOffset.vertical;
            nextRect.x += _rectOffset.left;
            nextRect.y += _rectOffset.bottom;
            bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            bottomLeft.x += nextRect.x;
            bottomLeft.y += nextRect.y;
            color.a *= 0.8f;
            DrawBox(rootRectTransform, bottomLeft, nextRect.size, color);
            // draw actual safe area end
        }

        private void DrawBox(RectTransform reference, Vector2 bottomLeftLocalPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            if (reference != null)
            {
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
                Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            }
            Gizmos.color = cachedColor;
        }

        private void UpdateEditorPreviewData()
        {
            _editorSafeRect = CalcultateCurrentSafeAreaRect();
            _editorScreenSize = new Vector2(Screen.width, Screen.height);
            _editorCurrentResolution = new Vector2(Screen.currentResolution.width, Screen.currentResolution.height);
            _editorScreenFactor = Screen.currentResolution.width / Screen.width;
            _editorScreenDpi = Screen.dpi;
            Canvas rootCanvas = GetRootCanvas();
            if (rootCanvas != null)
            {
                _editorCanvasFactor = rootCanvas.scaleFactor;
                _editorRootCanvasRect = (rootCanvas.transform as RectTransform).rect;
            }
        }

#endif

    }

     [ExecuteAlways]
    [RequireComponent(typeof(RectTransform))]
    public class ScreenRawRect : UIBehaviour, ILayoutSelfController, UIAreaRect
    {
        private static readonly Vector2 s_specialPivot = Vector2.zero; // HACK @Hiko self pivot

        [SerializeField]
        private RectOffset _rectOffset = new RectOffset();

        private RectTransform m_rect;

        private RectTransform selfRectTransform
        {
            get
            {
                if (m_rect == null)
                {
                    m_rect = GetComponent<RectTransform>();
                }
                return m_rect;
            }
        }

        // temp solution for testing
        [SerializeField]
        private Camera m_uiCamera;
        [SerializeField]
        private Canvas m_rootCanvas;

        private DrivenRectTransformTracker m_tracker;
        private RectTransform m_rectTransform;

        private RectTransform rectTransform
        {
            get
            {
                if (m_rectTransform == null)
                    m_rectTransform = GetComponent<RectTransform>();
                return m_rectTransform;
            }
        }

        public void SetLayoutHorizontal()
        {
            Refresh();
        }

        public void SetLayoutVertical()
        {
            Refresh();
        }

        [ContextMenu("Refresh")]
        public void Refresh()
        {
            Camera uiCamera = GetUICamera();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootCanvasRectTransform = rootCanvas.transform as RectTransform;
            Rect sizeRect = rootCanvasRectTransform.rect;
            RectTransform selfRectTransform = rectTransform;
            selfRectTransform.pivot = s_specialPivot;
            Vector3 worldUIPos = RectTransformEx.ScreenToWorld(Vector2.zero, rootCanvas, uiCamera);
            selfRectTransform.position = worldUIPos;
            Vector2 localPos = selfRectTransform.localPosition;
            float leftOffset = _rectOffset.left;
            localPos.x += leftOffset;
            float deltaX = _rectOffset.horizontal;
            selfRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, sizeRect.width - deltaX);
            float bottomOffset = _rectOffset.bottom;
            localPos.y += bottomOffset;
            float deltaY = _rectOffset.vertical;
            selfRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, sizeRect.height - deltaY);
            selfRectTransform.localPosition = localPos;
        }

        public Camera GetUICamera()
        {
            return m_uiCamera;
        }

        public Canvas GetRootCanvas()
        {
            return m_rootCanvas;
        }

        private void SetDirty()
        {
            if (!IsActive())
            {
                return;
            }
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
        }

        private void RebuildTracker()
        {
            m_tracker.Clear();
            m_tracker.Add(this, selfRectTransform, DrivenTransformProperties.All);
        }

        protected override void OnEnable()
        {
            base.OnEnable();
            RebuildTracker();
            SetDirty();
        }

        protected override void OnDisable()
        {
            m_tracker.Clear();
            LayoutRebuilder.MarkLayoutForRebuild(rectTransform);
            base.OnDisable();
        }

#if UNITY_EDITOR

        [Header("Editor readonly debug stuff")]
        [SerializeField]
        private Vector2 _editorCurrentResolution;
        [SerializeField]
        private Vector2 _editorScreenSize;
        [SerializeField]
        private float _editorScreenFactor;
        [SerializeField]
        private float _editorScreenDpi;
        [SerializeField]
        private float _editorCanvasFactor;
        [SerializeField]
        private Rect _editorRootCanvasRect;

        private void OnDrawGizmosSelected()
        {
            Color color = Color.blue;
            UpdateEditorPreviewData();
            Canvas rootCanvas = GetRootCanvas();
            RectTransform rootRectTransform = rootCanvas.transform as RectTransform;
            Rect rect = rootRectTransform.rect;
            Vector2 bottomLeft = rootRectTransform.GetLocalRectPosition(RectPositionType.BottomLeft);
            DrawBox(rootRectTransform, bottomLeft, new Vector2(rect.width, rect.height), color);
            // draw raw rect

            if (Mathf.Approximately(_rectOffset.horizontal, 0f) && Mathf.Approximately(_rectOffset.vertical, 0f))
            {
                return;
            }
            rect.width -= _rectOffset.horizontal;
            rect.height -= _rectOffset.vertical;
            bottomLeft.x += _rectOffset.left;
            bottomLeft.y += _rectOffset.bottom;
            DrawBox(rootRectTransform, bottomLeft, new Vector2(rect.width, rect.height), color);
        }

        private void DrawBox(RectTransform reference, Vector2 bottomLeftLocalPos, Vector2 size, Color color)
        {
            Color cachedColor = Gizmos.color;
            Gizmos.color = color;
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos), reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            Gizmos.DrawLine(reference.TransformPoint(bottomLeftLocalPos + Vector2.up * size.y), reference.TransformPoint(bottomLeftLocalPos + Vector2.right * size.x + Vector2.up * size.y));
            Gizmos.color = cachedColor;
        }

        private void UpdateEditorPreviewData()
        {
            _editorScreenSize = new Vector2(Screen.width, Screen.height);
            _editorCurrentResolution = new Vector2(Screen.currentResolution.width, Screen.currentResolution.height);
            _editorScreenFactor = Screen.currentResolution.width / Screen.width;
            _editorScreenDpi = Screen.dpi;
            Canvas rootCanvas = GetRootCanvas();
            if (rootCanvas != null)
            {
                _editorCanvasFactor = rootCanvas.scaleFactor;
                _editorRootCanvasRect = (rootCanvas.transform as RectTransform).rect;
            }
        }

#endif
    }

    public static class RectTransformEx
    {
        public static Vector3 GetLocalRectPosition(this RectTransform target, RectPositionType offsetType)
        {
            Vector3 result = Vector3.zero;
            Vector2 targetSize = target.rect.size;
            Vector2 targetPivot = target.pivot;

            Vector2 pivotOffset = Vector2.one * 0.5f - targetPivot;
            pivotOffset.x *= targetSize.x;
            pivotOffset.y *= targetSize.y;

            result += (Vector3)pivotOffset;

            switch (offsetType)
            {
                case RectPositionType.Top:
                    result.y += targetSize.y * 0.5f;
                    break;
                case RectPositionType.Bottom:
                    result.y -= targetSize.y * 0.5f;
                    break;
                case RectPositionType.Left:
                    result.x -= targetSize.x * 0.5f;
                    break;
                case RectPositionType.Right:
                    result.x += targetSize.x * 0.5f;
                    break;

                case RectPositionType.TopLeft:
                    result.y += targetSize.y * 0.5f;
                    result.x -= targetSize.x * 0.5f;
                    break;
                case RectPositionType.TopRight:
                    result.y += targetSize.y * 0.5f;
                    result.x += targetSize.x * 0.5f;
                    break;

                case RectPositionType.BottomLeft:
                    result.y -= targetSize.y * 0.5f;
                    result.x -= targetSize.x * 0.5f;
                    break;

                case RectPositionType.BottomRight:
                    result.y -= targetSize.y * 0.5f;
                    result.x += targetSize.x * 0.5f;
                    break;

                default:
                    break;
            }

            return result;
        }

        public static Vector3 ScreenToWorld(Vector2 screenPoint, Canvas rootCanvas, Camera uiCamera)
        {
            switch (rootCanvas.renderMode)
            {
                case RenderMode.ScreenSpaceOverlay:
                    return screenPoint;
                case RenderMode.ScreenSpaceCamera:
                    RectTransformUtility.ScreenPointToWorldPointInRectangle((RectTransform)rootCanvas.transform, screenPoint, uiCamera, out Vector3 worldPoint);
                    return worldPoint;
                case RenderMode.WorldSpace:
                    break;
            }
            throw new System.NotImplementedException();
        }

    }

最开始做的时候我很粗心的直接把 Screen.SafeArea 的大小直接给应用到 RectTransform 上了。后来发现这样是不对的，Screen.SafeArea 获取到的是实际的物理尺寸的安全区。
后来我是算出物理尺寸和根Canvas尺寸的笔直，再去计算出实际的RectTransform大小。

基本上可以凑合使用了。还比较遗憾的一点是，我没有能够让其支持只适配四个方向中的任1或者任2方向。比较简单的解决方法就是让不同适配的RectTransform互相套一下。

UI同学在调整动效以及物体布局的时候，会用Unity中的Device Simulator尝试切换不同的机型来查看不同设备上的UI 预览。这个时候可能需要有一个编辑器的监听器去监听设备变更的事件，然后发起全部UI尺寸刷新的请求。
这样会更方便他们做预览。