com.azerion.bluestack 2.0.1 → 3.0.0-preview2

package/Runtime/API/NativeAd/NativeAdLoader.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using Azerion.BlueStack.Common;
+using Azerion.BlueStack.Internal;
+using UnityEngine;
+
+// WIP
+namespace Azerion.BlueStack.API
+{
+    public class NativeAdLoader
+    {
+        private IAdLoaderClient _adLoaderClient;
+        public event EventHandler<BlueStackError> OnNativeAdFailedToLoad;
+        public event EventHandler<NativeAdEventArgs> OnNativeAdLoaded; 
+
+        internal bool IsAdLoaded;
+        internal GameObject AdGameObject;
+        private NativeAd _nativeAd;
+            
+        public NativeAdLoader(string adUnitId)
+        {
+            AdUnitId = adUnitId; 
+             
+            NativeUtils.CheckInitialization();
+            
+            _nativeAd = new NativeAd(AdUnitId);
+            
+            _nativeAd.OnNativeAdDidFail += (sender, args) =>
+            {
+                OnNativeAdFailedToLoad?.Invoke(this, args);
+            };
+            
+            _nativeAd.OnNativeAdDidLoad +=(_sender, _args) =>
+            {
+                NativeAdEventArgs nativeAdEventArgs = new NativeAdEventArgs
+                {
+                    nativeAd = _nativeAd
+                };
+
+                this.OnNativeAdLoaded?.Invoke(this, nativeAdEventArgs);
+            };
+            
+        }
+        
+        public string AdUnitId { get; private set; }
+        public HashSet<NativeAdType> AdTypes { get; private set; }
+        public HashSet<string> FormatIds { get; private set; }
+        internal int NumberOfAdsToLoad { get; private set; }
+    
+        public void Load() => this._nativeAd.Load();
+        public void Load(Preference preference) => this._nativeAd.Load(preference);
+        
+    }
+
+}

package/Runtime/API/NativeAd/NativeAdLoader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4b51ca047054b4fecabe0b6d10e0f7fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/API/NativeAd/NativeAdObject.cs

@@ -0,0 +1,520 @@
+using Azerion.BlueStack.Common;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+using UnityEngine.EventSystems;
+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 _interactionTime;
+		private float _lastInteractionTime;
+		private bool _isVisible;
+		private ClickInfo _clickInfo;
+		private string _objectTag;
+		private bool _is2DColliderPresent;
+		private bool _isRectTransPresent;
+		private bool _isInteractionStarted;
+		internal event EventHandler<EventArgs> OnAdDisplay;
+		internal event EventHandler<ClickEventArgs> OnAdClick;
+		internal float InteractionTime
+		{
+			get
+			{
+				return this._interactionTime;
+			}
+		}
+
+		internal string ObjectTag
+		{
+			get
+			{
+				return this._objectTag;
+			}
+		}
+
+		public void Start()
+		{
+			this._lastInteractionTime = 0f;
+			this._isVisible = false;
+		}
+
+		public void Initialize(string tag, bool isClickable = false)
+		{
+			_objectTag = tag;
+			string exMessage;
+
+			// Check if the GameObject has a Renderer component.
+			Renderer rendererComponent = GetComponent<Renderer>();
+			if (rendererComponent != null)
+			{
+				_isVisible = rendererComponent.isVisible;
+				
+				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!!!");
+				}
+			}
+			else if (IsValidUIObject())
+			{
+				_isVisible = true;
+				_isRectTransPresent = true;
+			}
+			else
+			{
+				throw new InvalidOperationException(" Not a valid Ad Object.");
+			}
+
+			if (!_isVisible)
+			{
+				throw new InvalidOperationException(" Object is not visible.");
+			}
+
+			InvokeRepeating("CheckForImpression", 0f, this.TimeInterval());
+		}
+
+		ClickInfo _startClick;
+		ClickInfo _endClick;
+		
+		public void Update()
+		{
+			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);
+				}
+				
+				// hitStatus = CheckHitStatusCanvas(Input.mousePosition);
+				// Debug.Log("Hit Status::::::: " + hitStatus.ToString());
+				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 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 area = width * height;
+		
+			 // Set values in Visibility Info
+			// visibilityInfo.PercentageOfVisibleArea = !this._is2DColliderPresent ? this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions)  
+			// 									: this.CalculatePercentageOfVisibleArea3D(minX, maxX, minY, maxY, xDivisions, yDivisions);
+
+			visibilityInfo.PercentageOfVisibleArea = CalculatePercentageOfVisibleArea(minX, maxX, minY, maxY, xDivisions, yDivisions);
+			visibilityInfo.PercentageOfScreenSpace = area / (Screen.width * Screen.height);
+			 return visibilityInfo;
+		}
+		
+		// Methods to check if the given input vector is obstructed or unobstructed v
+
+		public 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 (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 != (UnityEngine.Object)null &&
+					    (double)rayIntersection.distance <= (double)hitInfo.distance)
+					{
+						return HitStatus.UnobstructedHit;
+					}
+					else
+					{
+						return HitStatus.ObstructedHit;
+					}
+				}
+			}
+			return this.CheckHitStatusCanvas(position);
+		}
+		
+		// Method to check for Visible Area in screen space
+		private float CalculatePercentageOfVisibleArea(float minX, float maxX, float minY, float maxY, int xDivisions, int yDivisions)
+		{
+			// 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 numUnobstructedPoints / totalPoints;
+		}
+		
+		public void OnDestroy()
+		{
+			base.CancelInvoke();
+		}
+
+		public void OnBecameVisible()
+		{
+			if (!this._isVisible)
+			{
+				InvokeRepeating("CheckForImpression", 0f, this.TimeInterval());
+			}
+		}
+
+		public void OnBecameInvisible() => CancelInvoke();
+		
+		public void StopImpressionCheck()
+		{
+			base.CancelInvoke();
+			this._isVisible = 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
+			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;
+				}
+
+				// Get the view frustum planes
+				Plane[] frustumPlanes = GeometryUtility.CalculateFrustumPlanes(mainCamera);
+				
+				// Check if the gameobject bounds intersect with the view frustum planes
+				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);
+			
+				// 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
+			{
+				// Check if the UI element overlaps with the screen
+				if (!DoesUIElementOverlapScreen())
+				{
+					return false;
+				}
+			}
+
+			return true;
+		}
+		
+		private void CheckForImpression()
+		{
+			if (_isVisible && IsInViewFrustum())
+			{
+				OnAdDisplay?.Invoke(this, EventArgs.Empty);
+			}
+		}
+		private float TimeInterval()
+		{
+			return 0.1f;
+		}
+		
+		// TODO: BSSDK-401 : Move viewability to container level
+		private bool IsValidUIObject()
+		{
+			Canvas canvas = GetComponentInParent<Canvas>();
+			if (canvas == null)
+			{
+				Debug.Log("GetComponentInParent<Canvas>()");
+				return false;
+			}
+
+			RectTransform rectTransform = GetComponent<RectTransform>();
+			if (rectTransform == null)
+			{
+				Debug.Log("uiObject.GetComponent<RectTransform>()");
+				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;
+			}
+
+			Debug.Log("Object Not visible!");
+			return false;
+		}
+	}
+}

package/Runtime/API/NativeAd/NativeAdObject.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 02e4998a1faad46319b58609c5155cf9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/API/NativeAd/NativeAdType.cs

@@ -0,0 +1,8 @@
+namespace Azerion.BlueStack.API
+{
+	public enum NativeAdType
+	{
+		CustomNativeAd,
+		NativeAd
+	}
+}

package/Runtime/API/NativeAd/NativeAdType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ddf94da7a551f42c4a1708a454c2d68d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/API/NativeAd/NativeAssetID.cs

@@ -0,0 +1,30 @@
+namespace Azerion.BlueStack.API
+{
+	public class NativeAssetID
+	{
+		public string Value { get; set; }
+
+		public static NativeAssetID Image => new NativeAssetID("Image");
+
+		public static NativeAssetID Icon => new NativeAssetID("Icon");
+
+		public static NativeAssetID AdChoices => new NativeAssetID("AdChoices");
+
+		public static NativeAssetID Headline => new NativeAssetID("Headline");
+
+		public static NativeAssetID Body => new NativeAssetID("Body");
+
+		public static NativeAssetID CallToAction => new NativeAssetID("CallToAction");
+
+		public static NativeAssetID Advertiser => new NativeAssetID("Advertiser");
+
+		public static NativeAssetID Price => new NativeAssetID("Price");
+
+		public static NativeAssetID Store => new NativeAssetID("Store");
+
+		private NativeAssetID(string value)
+		{
+			Value = value;
+		}
+	}
+}

package/Runtime/API/NativeAd/NativeAssetID.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 55538319baea14f20bc2337f2c102722
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/API/NativeAd/NativeClientFactoryManager.cs

@@ -0,0 +1,32 @@
+using System;
+using Azerion.BlueStack.Common;
+using Azerion.BlueStack.Internal;
+using UnityEngine;
+
+internal class NativeClientFactoryManager
+{ 
+    private static INativeClientFactory _nativeClientFactory; 
+    internal static INativeClientFactory GetNativeClientFactory()
+    {
+        if (NativeClientFactoryManager._nativeClientFactory == null)
+        {
+            string typeName;
+            switch (Application.platform)
+            {
+                case RuntimePlatform.IPhonePlayer:
+                    typeName = "Azerion.BlueStack.Platforms.Android.ClientsFactory";
+                    break;
+                case RuntimePlatform.Android:
+                    typeName = "Azerion.BlueStack.Platforms.iOS.ClientsFactory";
+                    break;
+                default:
+                    typeName = "Azerion.BlueStack.Platforms.UnityEditor.ClientsFactory";
+                    break;
+            }
+            NativeClientFactoryManager._nativeClientFactory = (INativeClientFactory) Activator.CreateInstance(System.Type.GetType(typeName));
+        }
+        return NativeClientFactoryManager._nativeClientFactory;
+    }
+
+    internal static IAdLoaderClient CreateAdLoaderClient(AdLoaderClientArgs args) => NativeClientFactoryManager.GetNativeClientFactory().BuildAdLoaderClient(args); 
+}