com.azerion.bluestack 3.0.3 → 3.1.0-preview2

package/Runtime/API/NativeAd/NativeAdObject.cs

@@ -9,550 +9,566 @@ using UnityEngine.UI;
 
 namespace Azerion.BlueStack.API
 {
-	// Struct to store screen space bounds
-	internal struct VisibilityInfo 
-	{
-		public float PercentageOfVisibleArea; // Percentage of visible area
-		public float PercentageOfScreenSpace; // Percentage of screen space
-	}
-	
-	internal struct ClickInfo
-	{
-		public Vector3 ClickPosition;
-		public float ClickTime;
-	}
-	
-	internal class ClickEventArgs : EventArgs
-	{
-		public ClickInfo StartClick { get; set; }
-		public ClickInfo EndClick { get; set; }
-	}
-
-	internal enum HitStatus
-	{
-		Miss,
-		ObstructedHit,
-		UnobstructedHit,
-	}
-	
-	[AddComponentMenu(""), DisallowMultipleComponent, HideInInspector]
-	internal sealed class NativeAdObject : MonoBehaviour
-	{
-		private const float _timeInterval = 0.1f;
-		private const int _iterations = 5;
-		private float _lastInteractionTime;
-		private ClickInfo _clickInfo;
-		private bool _is2DColliderPresent;
-		private bool _isInteractionStarted;
-		private bool _isRectTransPresent; // check again
-		internal event EventHandler<EventArgs> OnAdDisplay;
-		internal event EventHandler<ClickEventArgs> OnAdClick;
-		internal bool IsImpressionChecked;
-		internal bool HasMadeImpression;
-		internal bool IsImpressive;
-		internal bool IsClickable;
-		
-		internal float InteractionTime { get; private set; }
-
-		internal string ObjectTag { get; private set; }
-
-		public void Start()
-		{
-			this._lastInteractionTime = 0f;
-			this.IsImpressionChecked = false;
-		}
-
-		public void Initialize(string nativeAssetID, bool isImpressive = false, bool isClickable = false)
-		{
-			ObjectTag = nativeAssetID;
-			IsImpressive = isImpressive;
-			IsClickable = isClickable;
-
-			if (GetComponent<Collider>() == null)
-			{
-				if (GetComponent<Collider2D>() == null)
-				{
-					throw new InvalidOperationException(" No Collider or Collider2D component found.");
-				}
-				else
-				{
-					_is2DColliderPresent = true;
-					Debug.Log("2D Collider Present!!!");
-				}
-			}
-			else
-			{
-				Debug.Log("Collider Present!!!");
-			}
-			
-			// Check if the GameObject has a Renderer component.
-			Renderer rendererComponent = GetComponent<Renderer>();
-			if (rendererComponent != null)
-			{
-				if (!rendererComponent.isVisible)
-				{
-					throw new InvalidOperationException(" Object is not visible.");
-				}
-			}
-			else if (IsValidUIObject())
-			{
-				Debug.Log("IsValidUIObject");
-				_isRectTransPresent = true;
-			}
-			else
-			{
-				throw new InvalidOperationException(" Not a valid Ad Object.");
-			}
-
-			if(IsImpressive)
-				InvokeRepeating("CheckForImpression", 0.0f, this.TimeInterval());
-		}
-
-		ClickInfo _startClick;
-		ClickInfo _endClick;
-		public void Update()
-		{
-			if(!IsClickable) return;
-			
-			// track clickable elements
-			this._lastInteractionTime += (Time.deltaTime - this._lastInteractionTime) * 0.1f;
-			
-			if (Input.GetMouseButtonDown(0))
-			{
-				this._isInteractionStarted = true;
-				_startClick.ClickPosition = Input.mousePosition;
-				_startClick.ClickTime = Time.time * 1000f;
-			}
-			else if (this._isInteractionStarted && Input.GetMouseButtonUp(0))
-			{
-				this._isInteractionStarted = false;
-				_endClick.ClickPosition = Input.mousePosition;
-				_endClick.ClickTime = Time.time * 1000f;
-
-				HitStatus hitStatus;
-
-				if (!_is2DColliderPresent)
-				{
-					hitStatus = CheckHitStatus3D(Input.mousePosition);
-
-				}
-				else
-				{
-					hitStatus = CheckHitStatus2D(Input.mousePosition);
-				}
-				
-				if (hitStatus == HitStatus.UnobstructedHit)
-				{
-					OnAdClick?.Invoke(this, new ClickEventArgs { StartClick = _startClick, EndClick = _endClick });
-				}
-			}
-		}
-		
-		// Method to get screen space bounds
-		internal VisibilityInfo GetVisibilityInfo()
-		{
-			// Get camera component
-			Camera mainCamera = NativeUtils.GetCamera();
-			VisibilityInfo visibilityInfo = new VisibilityInfo(); // Create a new struct
-			// Get gameobject to check bounds for
-			GameObject currentGameObject = this.gameObject;
-			// Get world space bounds
-			Bounds worldSpaceBounds; 
-			if (!_is2DColliderPresent) // Check if 3D object
-			{
-				worldSpaceBounds = currentGameObject.GetComponent<Collider>().bounds;
-			}
-			else 
-			{
-				worldSpaceBounds = currentGameObject.GetComponent<Collider2D>().bounds;
-			}
-			// Get max bounds 
-			Vector3 maxBounds = NativeUtils.GetBoundsMax(currentGameObject, mainCamera, worldSpaceBounds);
-			// Get min bounds
-			Vector3 minBounds = NativeUtils.GetBoundsMin(currentGameObject, mainCamera, worldSpaceBounds);
-			
-			// Calculate screen space bounds
-			float minX = Math.Max(0.0f, minBounds.x);  
-			float minY = Math.Max(0.0f, minBounds.y); 
-			float maxX = Math.Min(Screen.width, maxBounds.x); 
-			float maxY = Math.Min(Screen.height, maxBounds.y);
-			
-			// Increment amounts
-			int xDivisions = (int) ((maxX - minX) / 5.0); 
-			int yDivisions = (int) ((maxY - minY) / 5.0); 
-		
-			// Check if center is visible
-			if (xDivisions <= 0 || yDivisions <= 0) 
-			{
-				return visibilityInfo;
-			}
-
-			// Calculate actual area
-			float actualWidth = maxBounds.x - minBounds.x; 
-			float actualHeight = maxBounds.y - minBounds.y;
-			
-			// Calculate screen space area
-			float width = maxX - minX; 
-			float height = maxY - minY;
-		
-			// Check if height, width are neg
-			if (width <= 0.0f || height <= 0.0f) 
-			{
-				return visibilityInfo;
-			}
-			float areaOnScreen = width * height;
-			float percentageOfAreaOnScreen = areaOnScreen / (actualWidth * actualHeight);
-			
-			// visibilityInfo.PercentageOfVisibleArea = !this._is2DColliderPresent ? this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions)  
-			// 									: this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions);
-
-			// Set values in Visibility Info
-			visibilityInfo.PercentageOfVisibleArea = CalculatePercentageOfVisibleArea(minX, maxX, minY, maxY, xDivisions, yDivisions, percentageOfAreaOnScreen);
-			visibilityInfo.PercentageOfScreenSpace = areaOnScreen / (Screen.width * Screen.height);
-			return visibilityInfo;
-		}
-		
-		// Methods to check if the given input vector is obstructed or unobstructed 
-		private HitStatus CheckHitStatus2D(Vector3 position)
-		{
-			// Create a ray from the camera to the specified screen point
-			Ray ray = NativeUtils.GetCamera().ScreenPointToRay(position);
-
-			// Perform a 2D raycast and store the result
-			var rayIntersection = Physics2D.GetRayIntersection(ray);
-			// Check if the raycast hit is obstructed by a Collider component
-			if ((UnityEngine.Object)rayIntersection.collider != null)
-			{
-				if (rayIntersection.collider == GetComponent<Collider2D>())
-				{
-					// Perform a 3D raycast and store the result
-					if (Physics.Raycast(ray, out var hitInfo, float.PositiveInfinity))
-					{
-						// Check if the 3D raycast hit is closer than the 2D raycast hit
-						if (rayIntersection.distance >= hitInfo.distance)
-						{
-							return HitStatus.ObstructedHit;
-						}
-					}
-					// Return unobstructed hit if no obstructions were found
-					return HitStatus.UnobstructedHit;
-				}
-			}
-
-			// Perform a 2D raycast and store the results in an array
-			RaycastHit2D[] rayIntersectionAll = Physics2D.GetRayIntersectionAll(ray);
-			// Loop through the raycast hits
-			foreach (var raycastHit2D in rayIntersectionAll)
-			{
-				// Check if the raycast hit is obstructed by the Collider2D component
-				if (raycastHit2D.collider == GetComponent<Collider2D>())
-				{
-					return HitStatus.ObstructedHit;
-				}
-			}
-			return this.CheckHitStatusCanvas(position);
-		}
-		
-		private HitStatus CheckHitStatusCanvas(Vector3 position)
-		{
-			GraphicRaycaster parentGraphicRaycaster = GetComponentInParent<GraphicRaycaster>();
-			if(parentGraphicRaycaster == null)
-			{
-				return HitStatus.Miss;
-			}
-			EventSystem currentEventSystem = EventSystem.current;
-			if(currentEventSystem == null)
-			{
-				return HitStatus.Miss;
-			}
-			PointerEventData pointerEventData = new PointerEventData(currentEventSystem);
-			pointerEventData.position = position;
-			List<RaycastResult> raycastResults = new List<RaycastResult>();
-			parentGraphicRaycaster.Raycast(pointerEventData, raycastResults);
-			GameObject hitGameObject = null;
-			bool isHit = false;
-			int maxDepth = 0;
-			foreach(RaycastResult result in raycastResults)
-			{
-				if(result.gameObject == gameObject)
-				{
-					isHit = true;
-				}
-				if(result.depth > maxDepth)
-				{
-					maxDepth = result.depth;
-					hitGameObject = result.gameObject;
-				}
-			}
-			if(!isHit)
-			{
-				return HitStatus.Miss;
-			}
-			if(hitGameObject == gameObject)
-			{
-				return HitStatus.UnobstructedHit;
-			}
-			else
-			{
-				return HitStatus.ObstructedHit;
-			}
-		}
-		
-		private HitStatus CheckHitStatus3D(Vector3 position)
-		{
-			// Create a ray from the camera to the input vector
-			Ray ray = NativeUtils.GetCamera().ScreenPointToRay(position);
-			// Initialize variables for raycast hits
-			RaycastHit hitInfo;
-			RaycastHit2D rayIntersection;
-			// bool isHit = GetComponent<Collider>().Raycast(ray, out hitInfo, float.PositiveInfinity);
-
-			// Check for 3D raycast hit
-			if (Physics.Raycast(ray, out hitInfo, float.PositiveInfinity))
-			{
-				// Check if the hit object is the current object
-				if (hitInfo.collider == GetComponent<Collider>())
-				{
-					return HitStatus.UnobstructedHit;
-				}
-				else
-				{
-					// Check for 2D raycast hit
-					rayIntersection = Physics2D.GetRayIntersection(ray);
-					if ((UnityEngine.Object)rayIntersection.collider != null &&
-					    rayIntersection.distance <= hitInfo.distance)
-					{
-						return HitStatus.UnobstructedHit;
-					}
-					else
-					{
-						return HitStatus.ObstructedHit;
-					}
-				}
-			}
-			return this.CheckHitStatusCanvas(position);
-		}
-		
-		// Method to check for Unobstructed Visible Area in screen space
-		private float CalculatePercentageOfVisibleArea(float minX, float maxX, float minY, float maxY, int xDivisions, int yDivisions, float percentageOfAreaOnScreen)
-		{
-			// Initialize variables 
-			float numUnobstructedPoints = 0.0f;
-			float totalPoints = 0.0f;
-			float currentX = minX;
-			float currentY = minY;
-			// Increment through screen space
-			while (currentX <= maxX) 
-			{
-				while (currentY <= maxY)
-				{
-					// Check if point is unobstructed
-					HitStatus obstructionCheckResult = !_is2DColliderPresent
-						? CheckHitStatus3D(new Vector3(currentX, currentY, 0.0f))
-						: CheckHitStatus2D(new Vector3(currentX, currentY, 0.0f));
-					if (obstructionCheckResult == HitStatus.UnobstructedHit) 
-					{
-						numUnobstructedPoints++;
-						totalPoints++;
-					}
-					else if (obstructionCheckResult == HitStatus.ObstructedHit) 
-					{
-						totalPoints++;
-					}
-					currentY += yDivisions;
-				}
-				currentX += xDivisions;
-				currentY = minY;
-			}
-			
-			return percentageOfAreaOnScreen * (numUnobstructedPoints / totalPoints);
-		}
-		
-		public void OnDestroy()
-		{
-			base.CancelInvoke();
-		}
-
-		public void OnBecameVisible()
-		{
-			if (!this.IsImpressionChecked && IsImpressive)
-			{
-				InvokeRepeating("CheckForImpression", 1.0f, this.TimeInterval());
-			}
-		}
-
-		public void OnBecameInvisible() => CancelInvoke();
-		
-		public void StopImpressionCheck()
-		{
-			base.CancelInvoke();
-			this.IsImpressionChecked = true;
-		}
-
-		// Method to check if a UI element overlaps with the screen 
-		private bool DoesUIElementOverlapScreen()
-		{
-			// Get the RectTransform component
-			RectTransform rectTransform = this.GetComponent<RectTransform>();
-			// Create a rect for the screen size
-			Rect screenRect = new Rect(0.0f, 0.0f, Screen.width, Screen.height);
-			// Get the anchored position of the UI element
-			float x = rectTransform.anchoredPosition.x + rectTransform.position.x;
-			float y = Screen.height - rectTransform.position.y - rectTransform.anchoredPosition.y;
-			// Get the size of the UI element
-			Vector2 elementSize = Vector2.Scale(rectTransform.rect.size, rectTransform.lossyScale);
-			// Create a rect for the UI element
-			Rect elementRect = new Rect(x, y, elementSize.x, elementSize.y);
-			// Check if the UI element rect overlaps with the screen rect
-			Debug.LogWarning("Does screenRect.Overlaps: " + screenRect.Overlaps(elementRect, false));
-			if (screenRect.Overlaps(elementRect, false))
-			{
-				return true;
-			}
-			return false; 
-		}
-		
-		// Method to check if a gameobject is in the camera's view frustum
-		private bool IsInViewFrustum() 
-		{
-			// Check if the gameobject is rendered in the screen space overlay canvas
-			if (!NativeUtils.IsRenderedInScreenSpaceOverlayCanvas(gameObject))
-			{
-				// Get the camera component
-				Camera mainCamera = NativeUtils.GetCamera();
-				// Get the bounds of the gameobject
-				Bounds bounds;
-				if (_is2DColliderPresent)
-				{
-					bounds = this.GetComponent<Collider2D>().bounds;
-				}
-				else
-				{
-					bounds = this.GetComponent<Collider>().bounds;
-				}
-				// Debug.LogWarning("bounds: " + bounds);
-				
-				// Get the view frustum planes
-				Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
-				
-				// Check if the gameobject bounds intersect with the view frustum planes
-				// Debug.LogWarning("TestPlanesAABB: " + GeometryUtility.TestPlanesAABB(frustumPlanes, bounds));
-				if (!GeometryUtility.TestPlanesAABB(frustumPlanes, bounds))
-				{
-					return false;
-				}
-				
-				// Get the max bounds of the gameobject
-				Vector3 maxBounds = NativeUtils.GetBoundsMax(this.gameObject, mainCamera, bounds);
-				// Get the min bounds of the gameobject
-				Vector3 minBounds = NativeUtils.GetBoundsMin(this.gameObject, mainCamera, bounds);
-			
-				float height = Math.Min(Screen.height, maxBounds.y) - Math.Max(0.0f, minBounds.y);
-				float width = Math.Min(Screen.width, maxBounds.x) - Math.Max(0.0f, minBounds.x);
-			
-				// Debug.LogWarning("height: " + height);
-				// Debug.LogWarning("width: " + width);
-				
-				// Check if the gameobject bounds are too small to be visible
-				if (height <= 0.01f * Screen.height || width <= 0.01f * Screen.width) 
-				{
-					return false; 
-				}
-			}
-			else // When rendered in the screen space overlay canvas
-			{
-				Debug.LogWarning("DoesUIElementOverlapScreen: " + DoesUIElementOverlapScreen());
-
-				// Check if the UI element overlaps with the screen
-				if (!DoesUIElementOverlapScreen())
-				{
-					return false;
-				}
-			}
-
-			return true;
-		}
-		
-		private void CheckForImpression()
-		{
-			VisibilityInfo visibilityInfo = GetVisibilityInfo();
-			if (!IsImpressionChecked && IsInViewFrustum())
-			{
-				if (visibilityInfo.PercentageOfVisibleArea >= 0.5f) // if Visible Area is >= 50%
-				{
-					HasMadeImpression = true;
-					OnAdDisplay?.Invoke(this, EventArgs.Empty);
-				}
-				else
-				{
-					HasMadeImpression = false;
-				}
-			}
-		}
-		private float TimeInterval()
-		{
-			return 1.0f;
-		}
-		
-		// TODO: More testing and Improvement required
-		// TODO: BSSDK-401 : Move viewability to container level - may not have a container
-		private bool IsValidUIObject()
-		{
-			Canvas canvas = GetComponentInParent<Canvas>();
-			if (canvas == null)
-			{
-				Debug.Log("Unable to find Canvas component in parents");
-				return false;
-			}
-
-			RectTransform rectTransform = GetComponent<RectTransform>();
-			if (rectTransform == null)
-			{
-				Debug.Log("RectTransform component is null");
-				return false;
-			}
-			
-			CanvasRenderer canvasRenderer = GetComponent<CanvasRenderer>();
-			if (canvasRenderer == null)
-			{
-				Debug.Log("CanvasRenderer component is null");
-				return false;
-			}
-
-			// Rect rect = rectTransform.rect;
-			//
-			// // Get the center position of the RectTransform in its local coordinates
-			// Vector2 centerLocalPosition = new Vector2(rect.center.x, rect.center.y);
-			//
-			// // Convert the local center position to world position
-			// Vector3 centerWorldPosition = rectTransform.TransformPoint(centerLocalPosition);
-			// Debug.Log("centerWorldPosition: " + centerWorldPosition);
-			//
-			// Vector3 viewportPoint = NativeUtils.GetCamera().WorldToViewportPoint(centerWorldPosition);
-			// Debug.Log("viewportPoints: " + viewportPoint);
-			// if (viewportPoint.x >= 0 && viewportPoint.x <= 1 && viewportPoint.y >= 0 && viewportPoint.y <= 1 && viewportPoint.z > 0)
-			// {
-			// 	return true;
-			// }
-			
-			// Check if it is completely inside the viewport 
-			// Vector3[] corners = new Vector3[4];
-			// rectTransform.GetWorldCorners(corners);
-			// Debug.Log("Ad Object: " + this.name + " - " + corners.Length);
-			// foreach (Vector3 corner in corners)
-			// {
-			// 	// Debug.Log("corner: " + corner);
-			// 	Vector3 viewportPoint = Camera.main.WorldToViewportPoint(corner);
-			// 	// Debug.Log("viewportPoints: " + viewportPoint);
-			// 	if (viewportPoint.x >= 0 && viewportPoint.x <= 1 && viewportPoint.y >= 0 && viewportPoint.y <= 1 && viewportPoint.z > 0)
-			// 	{
-			// 		//return true;
-			// 	}
-			// }
-
-			// Debug.Log("Not a Valid UI Object!");
-			
-			return true;
-		}
-	}
-}
+    // Struct to store screen space bounds
+    internal struct VisibilityInfo
+    {
+        public float PercentageOfVisibleArea; // Percentage of visible area
+        public float PercentageOfScreenSpace; // Percentage of screen space
+    }
+
+    internal struct ClickInfo
+    {
+        public Vector3 ClickPosition;
+        public float ClickTime;
+    }
+
+    internal class ClickEventArgs : EventArgs
+    {
+        public ClickInfo StartClick { get; set; }
+        public ClickInfo EndClick { get; set; }
+    }
+
+    internal enum HitStatus
+    {
+        Miss,
+        ObstructedHit,
+        UnobstructedHit,
+    }
+
+    [AddComponentMenu(""), DisallowMultipleComponent, HideInInspector]
+    internal sealed class NativeAdObject : MonoBehaviour
+    {
+        private const float _timeInterval = 0.1f;
+        private const int _iterations = 5;
+        private float _lastInteractionTime;
+        private ClickInfo _clickInfo;
+        private bool _is2DColliderPresent;
+        private bool _isInteractionStarted;
+        private bool _isRectTransPresent; // check again
+        internal event EventHandler<EventArgs> OnAdDisplay;
+        internal event EventHandler<ClickEventArgs> OnAdClick;
+        internal bool IsImpressionChecked;
+        internal bool HasMadeImpression;
+        internal bool IsImpressive;
+        internal bool IsClickable;
+
+        internal float InteractionTime { get; private set; }
+
+        internal string ObjectTag { get; private set; }
+
+        public void Start()
+        {
+            this._lastInteractionTime = 0f;
+            this.IsImpressionChecked = false;
+        }
+
+        public void Initialize(string nativeAssetID, bool isImpressive = false, bool isClickable = false)
+        {
+            ObjectTag = nativeAssetID;
+            IsImpressive = isImpressive;
+            IsClickable = isClickable;
+
+            if (GetComponent<Collider>() == null)
+            {
+                if (GetComponent<Collider2D>() == null)
+                {
+                    throw new InvalidOperationException(" No Collider or Collider2D component found.");
+                }
+                else
+                {
+                    _is2DColliderPresent = true;
+                    Debug.Log("2D Collider Present!!!");
+                }
+            }
+            else
+            {
+                Debug.Log("Collider Present!!!");
+            }
+
+            // Check if the GameObject has a Renderer component.
+            Renderer rendererComponent = GetComponent<Renderer>();
+            if (rendererComponent != null)
+            {
+                if (!rendererComponent.isVisible)
+                {
+                    throw new InvalidOperationException(" Object is not visible.");
+                }
+            }
+            else if (IsValidUIObject())
+            {
+                Debug.Log("IsValidUIObject");
+                _isRectTransPresent = true;
+            }
+            else
+            {
+                throw new InvalidOperationException(" Not a valid Ad Object.");
+            }
+
+            if (IsImpressive)
+                InvokeRepeating("CheckForImpression", 0.0f, this.TimeInterval());
+        }
+
+        ClickInfo _startClick;
+        ClickInfo _endClick;
+
+        public void Update()
+        {
+            if (!IsClickable) return;
+
+            // track clickable elements
+            this._lastInteractionTime += (Time.deltaTime - this._lastInteractionTime) * 0.1f;
+
+            if (Input.GetMouseButtonDown(0))
+            {
+                this._isInteractionStarted = true;
+                _startClick.ClickPosition = Input.mousePosition;
+                _startClick.ClickTime = Time.time * 1000f;
+            }
+            else if (this._isInteractionStarted && Input.GetMouseButtonUp(0))
+            {
+                this._isInteractionStarted = false;
+                _endClick.ClickPosition = Input.mousePosition;
+                _endClick.ClickTime = Time.time * 1000f;
+
+                HitStatus hitStatus;
+
+                if (!_is2DColliderPresent)
+                {
+                    hitStatus = CheckHitStatus3D(Input.mousePosition);
+                }
+                else
+                {
+                    hitStatus = CheckHitStatus2D(Input.mousePosition);
+                }
+
+                if (hitStatus == HitStatus.UnobstructedHit)
+                {
+                    OnAdClick?.Invoke(this, new ClickEventArgs { StartClick = _startClick, EndClick = _endClick });
+                }
+            }
+        }
+
+        // Method to get screen space bounds
+        internal VisibilityInfo GetVisibilityInfo()
+        {
+            // Get camera component
+            Camera mainCamera = NativeUtils.GetCamera();
+            VisibilityInfo visibilityInfo = new VisibilityInfo(); // Create a new struct
+            // Get gameobject to check bounds for
+            GameObject currentGameObject = this.gameObject;
+            // Get world space bounds
+            Bounds worldSpaceBounds;
+            if (!_is2DColliderPresent) // Check if 3D object
+            {
+                worldSpaceBounds = currentGameObject.GetComponent<Collider>().bounds;
+            }
+            else
+            {
+                worldSpaceBounds = currentGameObject.GetComponent<Collider2D>().bounds;
+            }
+
+            // Get max bounds 
+            Vector3 maxBounds = NativeUtils.GetBoundsMax(currentGameObject, mainCamera, worldSpaceBounds);
+            // Get min bounds
+            Vector3 minBounds = NativeUtils.GetBoundsMin(currentGameObject, mainCamera, worldSpaceBounds);
+
+            // Calculate screen space bounds
+            float minX = Math.Max(0.0f, minBounds.x);
+            float minY = Math.Max(0.0f, minBounds.y);
+            float maxX = Math.Min(Screen.width, maxBounds.x);
+            float maxY = Math.Min(Screen.height, maxBounds.y);
+
+            // Increment amounts
+            int xDivisions = (int)((maxX - minX) / 5.0);
+            int yDivisions = (int)((maxY - minY) / 5.0);
+
+            // Check if center is visible
+            if (xDivisions <= 0 || yDivisions <= 0)
+            {
+                return visibilityInfo;
+            }
+
+            // Calculate actual area
+            float actualWidth = maxBounds.x - minBounds.x;
+            float actualHeight = maxBounds.y - minBounds.y;
+
+            // Calculate screen space area
+            float width = maxX - minX;
+            float height = maxY - minY;
+
+            // Check if height, width are neg
+            if (width <= 0.0f || height <= 0.0f)
+            {
+                return visibilityInfo;
+            }
+
+            float areaOnScreen = width * height;
+            float percentageOfAreaOnScreen = areaOnScreen / (actualWidth * actualHeight);
+
+            // visibilityInfo.PercentageOfVisibleArea = !this._is2DColliderPresent ? this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions)  
+            // 									: this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions);
+
+            // Set values in Visibility Info
+            visibilityInfo.PercentageOfVisibleArea = CalculatePercentageOfVisibleArea(minX, maxX, minY, maxY,
+                xDivisions, yDivisions, percentageOfAreaOnScreen);
+            visibilityInfo.PercentageOfScreenSpace = areaOnScreen / (Screen.width * Screen.height);
+            return visibilityInfo;
+        }
+
+        // Methods to check if the given input vector is obstructed or unobstructed 
+        private HitStatus CheckHitStatus2D(Vector3 position)
+        {
+            // Create a ray from the camera to the specified screen point
+            Ray ray = NativeUtils.GetCamera().ScreenPointToRay(position);
+
+            // Perform a 2D raycast and store the result
+            var rayIntersection = Physics2D.GetRayIntersection(ray);
+            // Check if the raycast hit is obstructed by a Collider component
+            if ((UnityEngine.Object)rayIntersection.collider != null)
+            {
+                if (rayIntersection.collider == GetComponent<Collider2D>())
+                {
+                    // Perform a 3D raycast and store the result
+                    if (Physics.Raycast(ray, out var hitInfo, float.PositiveInfinity))
+                    {
+                        // Check if the 3D raycast hit is closer than the 2D raycast hit
+                        if (rayIntersection.distance >= hitInfo.distance)
+                        {
+                            return HitStatus.ObstructedHit;
+                        }
+                    }
+
+                    // Return unobstructed hit if no obstructions were found
+                    return HitStatus.UnobstructedHit;
+                }
+            }
+
+            // Perform a 2D raycast and store the results in an array
+            RaycastHit2D[] rayIntersectionAll = Physics2D.GetRayIntersectionAll(ray);
+            // Loop through the raycast hits
+            foreach (var raycastHit2D in rayIntersectionAll)
+            {
+                // Check if the raycast hit is obstructed by the Collider2D component
+                if (raycastHit2D.collider == GetComponent<Collider2D>())
+                {
+                    return HitStatus.ObstructedHit;
+                }
+            }
+
+            return this.CheckHitStatusCanvas(position);
+        }
+
+        private HitStatus CheckHitStatusCanvas(Vector3 position)
+        {
+            GraphicRaycaster parentGraphicRaycaster = GetComponentInParent<GraphicRaycaster>();
+            if (parentGraphicRaycaster == null)
+            {
+                return HitStatus.Miss;
+            }
+
+            EventSystem currentEventSystem = EventSystem.current;
+            if (currentEventSystem == null)
+            {
+                return HitStatus.Miss;
+            }
+
+            PointerEventData pointerEventData = new PointerEventData(currentEventSystem);
+            pointerEventData.position = position;
+            List<RaycastResult> raycastResults = new List<RaycastResult>();
+            parentGraphicRaycaster.Raycast(pointerEventData, raycastResults);
+            GameObject hitGameObject = null;
+            bool isHit = false;
+            int maxDepth = 0;
+            foreach (RaycastResult result in raycastResults)
+            {
+                if (result.gameObject == gameObject)
+                {
+                    isHit = true;
+                }
+
+                if (result.depth > maxDepth)
+                {
+                    maxDepth = result.depth;
+                    hitGameObject = result.gameObject;
+                }
+            }
+
+            if (!isHit)
+            {
+                return HitStatus.Miss;
+            }
+
+            if (hitGameObject == gameObject)
+            {
+                return HitStatus.UnobstructedHit;
+            }
+            else
+            {
+                return HitStatus.ObstructedHit;
+            }
+        }
+
+        private HitStatus CheckHitStatus3D(Vector3 position)
+        {
+            // Create a ray from the camera to the input vector
+            Ray ray = NativeUtils.GetCamera().ScreenPointToRay(position);
+            // Initialize variables for raycast hits
+            RaycastHit hitInfo;
+            RaycastHit2D rayIntersection;
+            // bool isHit = GetComponent<Collider>().Raycast(ray, out hitInfo, float.PositiveInfinity);
+
+            // Check for 3D raycast hit
+            if (Physics.Raycast(ray, out hitInfo, float.PositiveInfinity))
+            {
+                // Check if the hit object is the current object
+                if (hitInfo.collider == GetComponent<Collider>())
+                {
+                    return HitStatus.UnobstructedHit;
+                }
+                else
+                {
+                    // Check for 2D raycast hit
+                    rayIntersection = Physics2D.GetRayIntersection(ray);
+                    if ((UnityEngine.Object)rayIntersection.collider != null &&
+                        rayIntersection.distance <= hitInfo.distance)
+                    {
+                        return HitStatus.UnobstructedHit;
+                    }
+                    else
+                    {
+                        return HitStatus.ObstructedHit;
+                    }
+                }
+            }
+
+            return this.CheckHitStatusCanvas(position);
+        }
+
+        // Method to check for Unobstructed Visible Area in screen space
+        private float CalculatePercentageOfVisibleArea(float minX, float maxX, float minY, float maxY, int xDivisions,
+            int yDivisions, float percentageOfAreaOnScreen)
+        {
+            // Initialize variables 
+            float numUnobstructedPoints = 0.0f;
+            float totalPoints = 0.0f;
+            float currentX = minX;
+            float currentY = minY;
+            // Increment through screen space
+            while (currentX <= maxX)
+            {
+                while (currentY <= maxY)
+                {
+                    // Check if point is unobstructed
+                    HitStatus obstructionCheckResult = !_is2DColliderPresent
+                        ? CheckHitStatus3D(new Vector3(currentX, currentY, 0.0f))
+                        : CheckHitStatus2D(new Vector3(currentX, currentY, 0.0f));
+                    if (obstructionCheckResult == HitStatus.UnobstructedHit)
+                    {
+                        numUnobstructedPoints++;
+                        totalPoints++;
+                    }
+                    else if (obstructionCheckResult == HitStatus.ObstructedHit)
+                    {
+                        totalPoints++;
+                    }
+
+                    currentY += yDivisions;
+                }
+
+                currentX += xDivisions;
+                currentY = minY;
+            }
+
+            return percentageOfAreaOnScreen * (numUnobstructedPoints / totalPoints);
+        }
+
+        public void OnDestroy()
+        {
+            base.CancelInvoke();
+        }
+
+        public void OnBecameVisible()
+        {
+            if (!this.IsImpressionChecked && IsImpressive)
+            {
+                InvokeRepeating("CheckForImpression", 1.0f, this.TimeInterval());
+            }
+        }
+
+        public void OnBecameInvisible() => CancelInvoke();
+
+        public void StopImpressionCheck()
+        {
+            base.CancelInvoke();
+            this.IsImpressionChecked = true;
+        }
+
+        // Method to check if a UI element overlaps with the screen 
+        private bool DoesUIElementOverlapScreen()
+        {
+            // Get the RectTransform component
+            RectTransform rectTransform = this.GetComponent<RectTransform>();
+            // Create a rect for the screen size
+            Rect screenRect = new Rect(0.0f, 0.0f, Screen.width, Screen.height);
+            // Get the anchored position of the UI element
+            float x = rectTransform.anchoredPosition.x + rectTransform.position.x;
+            float y = Screen.height - rectTransform.position.y - rectTransform.anchoredPosition.y;
+            // Get the size of the UI element
+            Vector2 elementSize = Vector2.Scale(rectTransform.rect.size, rectTransform.lossyScale);
+            // Create a rect for the UI element
+            Rect elementRect = new Rect(x, y, elementSize.x, elementSize.y);
+            // Check if the UI element rect overlaps with the screen rect
+            Debug.LogWarning("Does screenRect.Overlaps: " + screenRect.Overlaps(elementRect, false));
+            if (screenRect.Overlaps(elementRect, false))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        // Method to check if a gameobject is in the camera's view frustum
+        private bool IsInViewFrustum()
+        {
+            // Check if the gameobject is rendered in the screen space overlay canvas
+            if (!NativeUtils.IsRenderedInScreenSpaceOverlayCanvas(gameObject))
+            {
+                // Get the camera component
+                Camera mainCamera = NativeUtils.GetCamera();
+                // Get the bounds of the gameobject
+                Bounds bounds;
+                if (_is2DColliderPresent)
+                {
+                    bounds = this.GetComponent<Collider2D>().bounds;
+                }
+                else
+                {
+                    bounds = this.GetComponent<Collider>().bounds;
+                }
+                // Debug.LogWarning("bounds: " + bounds);
+
+                // Get the view frustum planes
+                Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
+
+                // Check if the gameobject bounds intersect with the view frustum planes
+                // Debug.LogWarning("TestPlanesAABB: " + GeometryUtility.TestPlanesAABB(frustumPlanes, bounds));
+                if (!GeometryUtility.TestPlanesAABB(frustumPlanes, bounds))
+                {
+                    return false;
+                }
+
+                // Get the max bounds of the gameobject
+                Vector3 maxBounds = NativeUtils.GetBoundsMax(this.gameObject, mainCamera, bounds);
+                // Get the min bounds of the gameobject
+                Vector3 minBounds = NativeUtils.GetBoundsMin(this.gameObject, mainCamera, bounds);
+
+                float height = Math.Min(Screen.height, maxBounds.y) - Math.Max(0.0f, minBounds.y);
+                float width = Math.Min(Screen.width, maxBounds.x) - Math.Max(0.0f, minBounds.x);
+
+                // Debug.LogWarning("height: " + height);
+                // Debug.LogWarning("width: " + width);
+
+                // Check if the gameobject bounds are too small to be visible
+                if (height <= 0.01f * Screen.height || width <= 0.01f * Screen.width)
+                {
+                    return false;
+                }
+            }
+            else // When rendered in the screen space overlay canvas
+            {
+                Debug.LogWarning("DoesUIElementOverlapScreen: " + DoesUIElementOverlapScreen());
+
+                // Check if the UI element overlaps with the screen
+                if (!DoesUIElementOverlapScreen())
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private void CheckForImpression()
+        {
+            VisibilityInfo visibilityInfo = GetVisibilityInfo();
+            if (!IsImpressionChecked && IsInViewFrustum())
+            {
+                if (visibilityInfo.PercentageOfVisibleArea >= 0.5f) // if Visible Area is >= 50%
+                {
+                    HasMadeImpression = true;
+                    OnAdDisplay?.Invoke(this, EventArgs.Empty);
+                }
+                else
+                {
+                    HasMadeImpression = false;
+                }
+            }
+        }
+
+        private float TimeInterval()
+        {
+            return 1.0f;
+        }
+
+        // TODO: More testing and Improvement required
+        // TODO: BSSDK-401 : Move viewability to container level - may not have a container
+        private bool IsValidUIObject()
+        {
+            Canvas canvas = GetComponentInParent<Canvas>();
+            if (canvas == null)
+            {
+                Debug.Log("Unable to find Canvas component in parents");
+                return false;
+            }
+
+            RectTransform rectTransform = GetComponent<RectTransform>();
+            if (rectTransform == null)
+            {
+                Debug.Log("RectTransform component is null");
+                return false;
+            }
+
+            CanvasRenderer canvasRenderer = GetComponent<CanvasRenderer>();
+            if (canvasRenderer == null)
+            {
+                Debug.Log("CanvasRenderer component is null");
+                return false;
+            }
+
+            // Rect rect = rectTransform.rect;
+            //
+            // // Get the center position of the RectTransform in its local coordinates
+            // Vector2 centerLocalPosition = new Vector2(rect.center.x, rect.center.y);
+            //
+            // // Convert the local center position to world position
+            // Vector3 centerWorldPosition = rectTransform.TransformPoint(centerLocalPosition);
+            // Debug.Log("centerWorldPosition: " + centerWorldPosition);
+            //
+            // Vector3 viewportPoint = NativeUtils.GetCamera().WorldToViewportPoint(centerWorldPosition);
+            // Debug.Log("viewportPoints: " + viewportPoint);
+            // if (viewportPoint.x >= 0 && viewportPoint.x <= 1 && viewportPoint.y >= 0 && viewportPoint.y <= 1 && viewportPoint.z > 0)
+            // {
+            // 	return true;
+            // }
+
+            // Check if it is completely inside the viewport 
+            // Vector3[] corners = new Vector3[4];
+            // rectTransform.GetWorldCorners(corners);
+            // Debug.Log("Ad Object: " + this.name + " - " + corners.Length);
+            // foreach (Vector3 corner in corners)
+            // {
+            // 	// Debug.Log("corner: " + corner);
+            // 	Vector3 viewportPoint = Camera.main.WorldToViewportPoint(corner);
+            // 	// Debug.Log("viewportPoints: " + viewportPoint);
+            // 	if (viewportPoint.x >= 0 && viewportPoint.x <= 1 && viewportPoint.y >= 0 && viewportPoint.y <= 1 && viewportPoint.z > 0)
+            // 	{
+            // 		//return true;
+            // 	}
+            // }
+
+            // Debug.Log("Not a Valid UI Object!");
+
+            return true;
+        }
+    }
+}