**New**:

- Added two new static event calls to UiService that are triggered when the app changes resolution and another trigger when changes screen orientation
- The new *UiServiceMonoComponent* was added to the project for internal purposes, in order to support Unity's loop or generic *GameObjects* dependency code (e.g. the screen resolution trigger change)
- Added new *AdjustScreenSizeFitter* to extend the ui behaviour of Unity's *ContentSizeFitter* in order to allow the *LayoutElement* to fit between the *LayoutElement.minSize* & *LayoutElement.flexibleSize*, values defined in the Unity's inspector

**Changed**:
- Renamed *UiPresenterData<T>* to *UiPresenter<T>* to make it less verbose

Author: CoderGamester

CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html)
 
+## [0.11.0] - 2025-01-05
+
+**New**:
+- Added two new static event calls to UiService that are triggered when the app changes resolution and another trigger when changes screen orientation
+- The new *UiServiceMonoComponent* was added to the project for internal purposes, in order to support Unity's loop or generic *GameObjects* dependency code (e.g. the screen resolution trigger change)
+- Added new *AdjustScreenSizeFitter* to extend the ui behaviour of Unity's *ContentSizeFitter* in order to allow the *LayoutElement* to fit between the *LayoutElement.minSize* & *LayoutElement.flexibleSize*, values defined in the Unity's inspector
+
+**Changed**:
+- Renamed *UiPresenterData<T>* to *UiPresenter<T>* to make it less verbose
+
 ## [0.10.0] - 2024-11-13
 
 **New**:

Runtime/AdjustScreenSizeFitter.cs

@@ -0,0 +1,138 @@
+using System;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace GameLovers.UiService
+{ 
+    /// <summary>
+    /// Resizes a RectTransform to fit the size of its content.
+    /// </summary>
+    /// <remarks>
+    /// Similar to <see cref="ContentSizeFitter"/>, but rounds the size of its content between min and preferred sizes.
+    /// Works better with explicit size anchors and not fitting size anchors
+    /// </remarks>
+    [AddComponentMenu("Layout/Adjust Size Fitter", 141)]
+    [ExecuteAlways]
+    [RequireComponent(typeof(RectTransform), typeof(LayoutElement))]
+    public class AdjustScreenSizeFitter : UIBehaviour, ILayoutSelfController
+    {
+        [SerializeField] private RectOffset _padding = new RectOffset();
+        [SerializeField] private RectTransform _canvasTransform;
+        [SerializeField] private RectTransform _rectTransform;
+        
+        private Vector2 _previousSize;
+        
+        private RectTransform RectTransform
+        {
+            get
+            {
+                if (_rectTransform == null) _rectTransform = GetComponent<RectTransform>();
+                return _rectTransform;
+            }
+        }
+        
+        private RectTransform CanvasRectTransform
+        {
+            get
+            {
+                if (_canvasTransform == null) _canvasTransform = GetComponentInParent<Canvas>().GetComponent<RectTransform>();
+                
+                _previousSize = _canvasTransform.sizeDelta;
+                
+                return _canvasTransform;
+            }
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            SetDirty();
+        }
+        
+        protected override void OnDisable()
+        {
+            LayoutRebuilder.MarkLayoutForRebuild(RectTransform);
+            base.OnDisable();
+        }
+
+        private void LateUpdate()
+        {
+            var previousSize = _previousSize;
+
+            if (previousSize == CanvasRectTransform.sizeDelta)
+            {
+                return;
+            }
+            
+            _previousSize = CanvasRectTransform.sizeDelta;
+            SetDirty();
+        }
+
+        /// <summary>
+        /// Method called by the layout system. Has no effect
+        /// </summary>
+        public virtual void SetLayoutHorizontal() {}
+
+        /// <summary>
+        /// Method called by the layout system. Has no effect
+        /// </summary>
+        public virtual void SetLayoutVertical() {}
+        
+        protected override void OnTransformParentChanged()
+        {
+            base.OnTransformParentChanged();
+
+            SetDirty();
+        }
+
+        private void SetDirty()
+        {
+            if (!IsActive())
+                return;
+            
+            var resolution = CanvasRectTransform.sizeDelta;
+            var oldSize = RectTransform.sizeDelta;
+            var newWidth = GetSize((int) RectTransform.Axis.Horizontal, resolution);
+            var newHeight = GetSize((int) RectTransform.Axis.Vertical, resolution);
+
+            if (!Mathf.Approximately(newWidth, oldSize.x))
+            {
+                RectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, newWidth);
+            }
+
+            if (!Mathf.Approximately(newHeight, oldSize.y))
+            {
+                RectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, newHeight);
+            }
+        }
+
+        private float GetSize(int axis, Vector2 resolution)
+        {
+            var minSize = LayoutUtility.GetMinSize(RectTransform, axis);
+            var maxSize = LayoutUtility.GetFlexibleSize(RectTransform, axis);
+            var resolutionX = resolution.x - _padding.left - _padding.right;
+            var resolutionY = resolution.y - _padding.top - _padding.bottom;
+            
+            if (axis == 0)
+            {
+                if(resolutionX < minSize && minSize > 0) return minSize;
+                if(resolutionX >= maxSize && maxSize > minSize && maxSize > 1) return maxSize;
+
+                return RectTransform.sizeDelta.x > resolutionX && resolutionX > 0 ? resolutionX : RectTransform.sizeDelta.x;
+            }
+            
+            if(resolutionY < minSize && minSize > 0) return minSize;
+            if(resolutionY >= maxSize && maxSize > minSize && maxSize > 1) return maxSize;
+            
+            return RectTransform.sizeDelta.y > resolutionY && resolutionY > 0 ? resolutionY : RectTransform.sizeDelta.y;
+        }
+
+    #if UNITY_EDITOR
+        protected override void OnValidate()
+        {
+            SetDirty();
+        }
+    #endif
+    }
+}

Runtime/AdjustScreenSizeFitter.cs.meta

@@ -86,7 +86,7 @@ internal virtual void InternalClose(bool destroy)
 	/// <remarks>
 	/// Extends the <see cref="UiPresenter"/> behaviour to hold data of type <typeparamref name="T"/>
 	/// </remarks>
-	public abstract class UiPresenterData<T> : UiPresenter, IUiPresenterData where T : struct
+	public abstract class UiPresenter<T> : UiPresenter, IUiPresenterData where T : struct
 	{
 		/// <summary>
 		/// The Ui data defined when opened via the <see cref="UiService"/>

Runtime/UiPresenter.cs

@@ -1,10 +1,9 @@
 using Cysharp.Threading.Tasks;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using UnityEngine;
+using UnityEngine.Events;
+using Object = UnityEngine.Object;
 
 // ReSharper disable CheckNamespace
 
@@ -13,6 +12,9 @@ namespace GameLovers.UiService
 	/// <inheritdoc />
 	public class UiService : IUiServiceInit
 	{
+		public static readonly UnityEvent<DeviceOrientation, DeviceOrientation> OnOrientationChanged = new ();
+		public static readonly UnityEvent<Vector2, Vector2> OnResolutionChanged = new ();
+		
 		private readonly IUiAssetLoader _assetLoader;
 		private readonly IDictionary<Type, UiConfig> _uiConfigs = new Dictionary<Type, UiConfig>();
 		private readonly IList<Type> _visibleUiList = new List<Type>();
@@ -61,11 +63,12 @@ public void Init(UiConfigs configs)
 			_uiParent = new GameObject("Ui").transform;
 			_loadingSpinnerType = configs.LoadingSpinnerType;
 
-			GameObject.DontDestroyOnLoad(_uiParent.gameObject);
+			_uiParent.gameObject.AddComponent<UiServiceMonoComponent>();
+			Object.DontDestroyOnLoad(_uiParent.gameObject);
 
 			if (_loadingSpinnerType != null)
 			{
-				_ = LoadUiAsync(_loadingSpinnerType);
+				LoadUiAsync(_loadingSpinnerType).Forget();
 			}
 		}
 
@@ -249,9 +252,16 @@ public async UniTask<UiPresenter> OpenUiAsync(Type type)
 		public async UniTask<UiPresenter> OpenUiAsync<TData>(Type type, TData initialData) where TData : struct
 		{
 			var ui = await GetOrLoadUiAsync(type);
-			var uiPresenterData = ui as UiPresenterData<TData>;
+			var uiPresenter = ui as UiPresenter<TData>;
+			
+			if (uiPresenter == null)
+			{
+				Debug.LogError($"The UiPresenter {type} is not a UiPresenter<TData> type you. " +
+				               $"Implement it to allow it to open with initial defined data");
+				return ui;
+			}
 
-			uiPresenterData.InternalSetData(initialData);
+			uiPresenter.InternalSetData(initialData);
 			OpenUi(type);
 
 			return ui;

Runtime/UiService.cs

@@ -0,0 +1,48 @@
+using UnityEngine;
+
+namespace GameLovers.UiService
+{
+    /// <summary>
+    /// This class is responsible for updating the resolution and device orientation of the <see cref="UiService"/>
+    /// </summary>
+    public class UiServiceMonoComponent : MonoBehaviour
+    {
+        private Vector2 _resolution;
+        private DeviceOrientation _orientation;
+        
+        private void Awake()
+        {
+            _resolution = new Vector2(Screen.width, Screen.height);
+            _orientation = Input.deviceOrientation;
+        }
+        
+        private void Update()
+        {
+            if (!Mathf.Approximately(_resolution.x, Screen.width) || !Mathf.Approximately(_resolution.y, Screen.height)) 
+            {
+                var previousResolution = _resolution;
+                
+                _resolution = new Vector2(Screen.width, Screen.height);
+                
+                UiService.OnResolutionChanged.Invoke(previousResolution, _resolution);
+            }
+            
+            switch (Input.deviceOrientation) {
+                case DeviceOrientation.Unknown:            // Ignore
+                case DeviceOrientation.FaceUp:            // Ignore
+                case DeviceOrientation.FaceDown:        // Ignore
+                    break;
+                default:
+                    if (_orientation != Input.deviceOrientation) 
+                    {
+                        var previousOrientation = _orientation;
+                        
+                        _orientation = Input.deviceOrientation;
+                        
+                        UiService.OnOrientationChanged.Invoke(previousOrientation, _orientation);
+                    }
+                    break;
+            }
+        }
+    }
+}

Runtime/UiServiceMonoComponent.cs

@@ -2,7 +2,7 @@
   "name": "com.gamelovers.uiservice",
   "displayName": "UiService",
   "author": "Miguel Tomas",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "unity": "2022.3",
   "license": "MIT",
   "description": "This package provides a service to help manage an Unity's, game UI.\nIt allows to open, close, load, unload and request any Ui Configured in the game.\nThe package provides a Ui Set that allows to group a set of Ui Presenters to help load, open and close multiple Uis at the same time.\n\nTo help configure the game's UI you need to create a UiConfigs Scriptable object by:\n- Right Click on the Project View > Create > ScriptableObjects > Configs > UiConfigs",