com.azerion.bluestack 2.0.1 → 3.0.0-preview2

package/Plugins/iOS/BSUNativeAd.m

@@ -0,0 +1,82 @@
+#import "BSUNativeAd.h"
+#import "BSUPluginUtil.h"
+#import <CoreGraphics/CoreGraphics.h>
+#import <UIKit/UIKit.h>
+#import <BlueStackSDK/BlueStackSDK.h>
+
+@interface BSUNativeAd()<MNGAdsAdapterNativeDelegate, MNGClickDelegate>
+
+@property(nonatomic, strong) MNGAdsSDKFactory *nativeAdsFactory;
+
+@end
+
+@implementation BSUNativeAd
+
+- (instancetype)initWithNativeAdClientReference:(BSUTypeNativeAdClientRef *)nativeAdClient placementId:(NSString *_Nullable)placementId {
+    self = [super init];
+    if (self) {
+        self.nativeAdClient = nativeAdClient;
+        self.nativeAdsFactory = [[MNGAdsSDKFactory alloc] init];
+        self.nativeAdsFactory.nativeDelegate = self;
+        self.nativeAdsFactory.placementId = placementId;
+        self.nativeAdsFactory.clickDelegate = self;
+        self.nativeAdsFactory.viewController = [BSUPluginUtil unityGLViewController];
+    }
+    return self;
+}
+
+- (void)loadAd {
+    if (self.nativeAdsFactory) {
+        [self.nativeAdsFactory loadNative];
+    }
+}
+
+- (void)loadAdWithPreference:(BSUTypePreferenceRef)preferenceRef {
+    MNGPreference *preference = (__bridge MNGPreference *)preferenceRef;
+    if (self.nativeAdsFactory) {
+        [self.nativeAdsFactory loadNativeWithPreferences:preference withCover:NO];
+    }
+}
+
+- (void)destroy {
+    if (self.nativeAdsFactory) {
+        [self.nativeAdsFactory releaseMemory];
+        self.nativeAdsFactory = nil;
+    }
+}
+
+#pragma mark MNGAdsAdapterNativeDelegate
+
+// - (void)nativeObjectDidLoad:(MNGAdsAdapter *)adsAdapter {
+//     if (self.onDidLoadCallback != nil) {
+//         self.onDidLoadCallback(self.nativeAdClient);
+//     }
+// }
+
+-(void)adsAdapter:(MNGAdsAdapter *)adsAdapter nativeObjectDidLoad:(MNGNAtiveObject *)nativeObject{
+    NSLog(@"adsAdapterNativeObjectDidLoad:");
+    if (self.onDidLoadCallback != nil) {
+        self.title = nativeObject.title;
+        self.body = nativeObject.body;
+        self.badge = @"Ad"; //nativeObject.badge;
+        self.callToAction = nativeObject.callToAction;
+        self.clickUrl = @"https://developers.bluestack.app/"; //nativeObject.clickUrl;
+        self.iconUrl = @"https://creative.mng-ads.com/10/10394-15539.jpg"; //nativeObject.iconUrl;
+        self.coverImageUrl = @"https://creative.mng-ads.com/10/10394-15540.jpg"; //nativeObject.coverImageUrl;
+
+        self.onDidLoadCallback(self.nativeAdClient);
+    }
+
+    // //possibility to customize the badge title
+    // [nativeObject updateBadgeTitle:@"Publicité"];
+    // badgeView = nativeObject.badgeView;
+    // [_nativeObject registerViewForInteraction:self.nativeView withMediaView:self.backgroundImage withIconImageView:self.iconeImage withViewController:[APP_DELEGATE drawerViewController] withClickableView:self.callToActionButton];
+}
+
+- (void)adsAdapter:(MNGAdsAdapter *)adsAdapter nativeObjectDidFailWithError:(NSError *)error withCover:(BOOL)cover{
+    if (self.onDidFailCallback != nil) {
+        self.onDidFailCallback(self.nativeAdClient, (__bridge BSUTypeErrorRef)error);
+    }
+}
+
+@end

package/Plugins/iOS/BSUNativeAd.m.meta

@@ -0,0 +1,37 @@
+fileFormatVersion: 2
+guid: cfa93ef5fe2e245c7b8edf58470f900a
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 1
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 0
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  - first:
+      iPhone: iOS
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      tvOS: tvOS
+    second:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Plugins/iOS/BSUTypes.h

@@ -85,3 +85,15 @@ typedef void (*BSUOnBannerDidFailToRefreshCallback)(BSUTypeBannerClientRef *bann
 typedef void (*BSUOnBannerHideCallback)(BSUTypeBannerClientRef *bannerClient);
 
 typedef void (*BSUOnBannerDisplayCallback)(BSUTypeBannerClientRef *bannerClient);
+
+
+
+
+typedef const void *BSUTypeNativeAdRef;
+
+typedef const void *BSUTypeNativeAdClientRef;
+
+typedef void (*BSUOnNativeAdDidLoadCallback)(BSUTypeNativeAdClientRef *nativeAdClient);
+
+typedef void (*BSUOnNativeAdDidFailCallback)(
+    BSUTypeNativeAdClientRef *nativeAdClient, BSUTypeErrorRef error);

package/Runtime/API/BlueStackAds.cs

@@ -1,5 +1,6 @@
 using System;
 using Azerion.BlueStack.Internal;
+using Azerion.BlueStack.Common;
 using UnityEngine;
 
 namespace Azerion.BlueStack.API
@@ -23,6 +24,7 @@ namespace Azerion.BlueStack.API
             Instance._blueStackClient.Initialize(appId, settings, sdkInitCompleteAction, client => {
                 if (adaptersInitCompleteAction != null) adaptersInitCompleteAction.Invoke(new AdaptersInitializationStatus(client));
             });
+            AdsEventExecutor.Initialize();
         }
 
         internal static IClientsFactory GetClientsFactory()
@@ -44,9 +46,9 @@ namespace Azerion.BlueStack.API
                 else
                 {
                     const string factoryClassName = "Azerion.BlueStack.Platforms.UnityEditor.ClientsFactory";
-                    Debug.Log(factoryClassName);
+                    // Debug.Log(factoryClassName);
                     Type type = Type.GetType(factoryClassName, true);
-                    Debug.Log("Client Type: " + type.ToString());
+                    // Debug.Log("Client Type: " + type.ToString());
                     _clientsFactory = (IClientsFactory)Activator.CreateInstance(type);
                 }
             }

package/Runtime/API/NativeAd/NativeAd.cs

@@ -0,0 +1,182 @@
+using System;
+using Azerion.BlueStack.Internal;
+using Azerion.BlueStack.Common;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Azerion.BlueStack.API
+{
+    public class NativeAd
+    {
+        private INativeAdClient _nativeAdClient;
+        
+        private Texture2D _iconTexture;
+        private Texture2D _imageTexture;
+        private bool _isTextureLoaded;
+        
+        public event EventHandler<EventArgs> OnNativeAdDidLoad;
+        public event EventHandler<BlueStackError> OnNativeAdDidFail;
+        public event EventHandler<EventArgs> OnNativeAdImpression;
+        public event EventHandler<EventArgs> OnNativeAdClicked;
+        public event EventHandler<EventArgs> OnNativeAdOpening;
+        public event EventHandler<EventArgs> OnNativeAdClosed;
+        
+        private NativeAdInteractionHandler _nativeAdInteractionHandler;
+        
+        public NativeAd(string placementId) : this(placementId,
+            BlueStackAds.GetClientsFactory().CreateNativeAdClient())
+        {
+        }
+
+        internal NativeAd(string placementId, INativeAdClient nativeAdClient)
+        {
+            // AdsEventExecutor.Initialize();
+            _nativeAdClient = nativeAdClient;
+            _nativeAdClient.Create(placementId);
+            ConfigureEvents();
+            InitializeTextures();
+            _nativeAdInteractionHandler = new NativeAdInteractionHandler();
+        }
+
+        private void ConfigureEvents()
+        {
+            _nativeAdClient.OnNativeAdDidLoad += (sender, args) => {
+                AdsEventExecutor.ExecuteInUpdate(delegate
+                {
+                    LoadTextures();
+                });
+                SetClickUrl();
+            };
+            _nativeAdClient.OnNativeAdDidFail += (sender, args) => { OnNativeAdDidFail?.Invoke(this, args); };
+        }
+
+        public void Load()
+        {
+            _nativeAdClient.Load();
+        }
+
+        public void Load(Preference preference)
+        {
+            _nativeAdClient.Load(preference.getIPreferenceClient());
+        }
+
+        private void InitializeTextures()
+        {
+            this._iconTexture = null;
+            this._imageTexture = null;
+        }
+        
+        private void LoadTextures()
+        {
+            // Debug.Log("GetIconUrl: " + _nativeAdClient.GetIconUrl());
+            AdsEventExecutor.instance.StartCoroutine(NativeUtils.LoadImage(_nativeAdClient.GetIconUrl(),
+                delegate(Texture2D texture)
+                {
+                    this._iconTexture = texture;
+                    // Debug.Log("texture: " + this._iconTexture.name);
+                    if (this._imageTexture != null && this._iconTexture != null)
+                    {
+                        OnNativeAdDidLoad?.Invoke(this, EventArgs.Empty);
+                    }
+                }
+            ));
+            // Debug.Log("GetCoverImageUrl: " + _nativeAdClient.GetCoverImageUrl());
+            AdsEventExecutor.instance.StartCoroutine(NativeUtils.LoadImage(_nativeAdClient.GetCoverImageUrl(),
+                delegate(Texture2D texture)
+                {
+                    this._imageTexture = texture;
+                    if (this._imageTexture != null && this._iconTexture != null)
+                    {
+                        OnNativeAdDidLoad?.Invoke(this, EventArgs.Empty);
+                    }
+                }
+            ));
+        }
+        
+        public string GetTitle()
+        {
+            Debug.Log("GetTitle: " + _nativeAdClient.GetTitle());
+            // LoadTextures();
+            return _nativeAdClient.GetTitle();
+        }
+
+        public string GetBodyText()
+        {
+            return _nativeAdClient.GetBodyText();
+        }
+
+        public string GetCallToActionText()
+        {
+            return _nativeAdClient.GetCallToActionText();
+        }
+
+        public byte[] GetBadgeBytes()
+        {
+            return _nativeAdClient.GetBadgeBytes();
+        }
+
+        public string GetBadge()
+        {
+            return _nativeAdClient.GetBadge();
+        }
+        
+        public Texture2D GetIconTexture()
+        {
+            return this._iconTexture;
+        }
+        
+        public Texture2D GetCoverImageTexture()
+        {
+            return this._imageTexture;
+        }
+
+        private void SetClickUrl()
+        {
+            _nativeAdInteractionHandler.SetClickUrl(_nativeAdClient.GetClickUrl());
+        }
+        
+        public bool RegisterTitleTextGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterHeadlineTextGameObject(gameObject);
+        }
+
+        public bool RegisterBodyTextGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterBodyTextGameObject(gameObject);
+        }
+        
+        public bool RegisterImageGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterImageGameObjects(gameObject);
+        }
+        
+        public bool RegisterIconImageGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterIconImageGameObject(gameObject);
+        }
+        
+        public bool RegisterCallToActionGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterCallToActionGameObject(gameObject);
+        }
+
+        public bool RegisterBadgeTextGameObject(GameObject gameObject)
+        {
+            return _nativeAdInteractionHandler.RegisterAdvertiserTextGameObject(gameObject);
+        }
+
+        
+        public void Destroy()
+        {
+            _nativeAdClient.Destroy();
+        }
+        
+        ~NativeAd()
+        {
+            AdsEventExecutor.ExecuteInUpdate(delegate
+            {
+                Destroy();
+            });
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4d9acf1e8abb64d19870dd28810ae444
+timeCreated: 1669635731

package/Runtime/API/NativeAd/NativeAdEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace Azerion.BlueStack.API
+{
+    // Event that occurs when a native ad is loaded.
+    public class NativeAdEventArgs : EventArgs
+    {
+        public NativeAd nativeAd
+        {
+            get;
+            set;
+        }
+    }
+}

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

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

package/Runtime/API/NativeAd/NativeAdInteractionHandler.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using Azerion.BlueStack.Common;
+using Azerion.BlueStack.Internal;
+using Castle.Components.DictionaryAdapter.Xml;
+using UnityEngine;
+
+namespace Azerion.BlueStack.API
+{
+	public class NativeAdInteractionHandler
+	{
+		private List<NativeAdObject> _nativeAdObjects;
+
+		private INativeAdInteractionHandlerClient _nativeAdInteractionHandlerClient;
+		
+		// public NativeAdInteractionHandler(INativeAdInteractionHandlerClient interactionHandlerClient)
+
+		private string _clickUrl;
+		public NativeAdInteractionHandler()
+		{
+			// _nativeAdInteractionHandlerClient = interactionHandlerClient;
+			_nativeAdObjects = new List<NativeAdObject>();
+		}
+
+		public bool RegisterImageGameObjects(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Image);
+		}
+
+		public bool RegisterIconImageGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Icon);
+		}
+
+		public bool RegisterAdChoicesLogoGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.AdChoices);
+		}
+
+		public bool RegisterHeadlineTextGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Headline);
+		}
+
+		public bool RegisterBodyTextGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Body);
+		}
+
+		public bool RegisterCallToActionGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.CallToAction);
+		}
+
+		public bool RegisterAdvertiserTextGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Advertiser);
+		}
+
+		public bool RegisterPriceGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Price);
+		}
+
+		public bool RegisterStoreGameObject(GameObject gameObject)
+		{
+			return RegisterGameObject(gameObject, NativeAssetID.Store);
+		}
+
+		private bool RegisterGameObject(GameObject adObject, NativeAssetID assetID)
+		{
+			return Register(adObject, assetID.Value); // replace with GetAssetIDMappings
+		}
+
+		private bool Register(GameObject adObject, string assetID, bool isClickable = false)
+		{
+			NativeAdObject nativeAdObject = adObject.GetComponent<NativeAdObject>();
+			if (nativeAdObject != null)
+			{
+				UnityEngine.Object.DestroyImmediate(nativeAdObject);
+			}
+
+			nativeAdObject = adObject.AddComponent<NativeAdObject>();
+			_nativeAdObjects.Add(nativeAdObject);
+			nativeAdObject.OnAdDisplay += RecordImpression;
+			nativeAdObject.OnAdClick += RecordClick;
+			try
+			{
+				nativeAdObject.Initialize(assetID, isClickable);
+			}
+			catch (InvalidOperationException ex)
+			{
+				// Debug.LogWarning("Failed to Register " + assetID + " :" + ex.Message);
+				UnityEngine.Object.Destroy(nativeAdObject);
+				_nativeAdObjects.Remove(nativeAdObject);
+				return false;
+			}
+
+			return true;
+		}
+
+		private bool impressionComplete = false;
+		private bool clickComplete = false;
+
+		internal void SetClickUrl(string url)
+		{
+			_clickUrl = url;
+		}
+		
+		// Handle Ad Impression - Incomplete
+		private void RecordImpression(object sender, EventArgs eventArgs)
+		{
+			impressionComplete = true;
+			Debug.LogWarning("Impression Complete");
+			
+			if (sender is NativeAdObject nativeAdObject)
+			{
+				if (_nativeAdInteractionHandlerClient.RecordImpression(NativeAdInteractionUtils.CreateImpressionSignal(nativeAdObject, _nativeAdObjects)))
+				{
+					foreach (NativeAdObject adObject in _nativeAdObjects)
+					{
+						if(adObject != null)
+							adObject.StopImpressionCheck();
+					}
+				}
+			}
+		}
+		
+		// Handle Ad Clicked - Incomplete
+		private void RecordClick(object sender, ClickEventArgs clickEventArgs)
+		{
+			// clickComplete = true;
+			Debug.Log("Record Click");
+			
+			if (sender is NativeAdObject nativeAdObject)
+			{
+				Dictionary<string, string> touchEventSignal =
+					NativeAdInteractionUtils.CreateTouchEventSignal(clickEventArgs.startClick, clickEventArgs.endClick);
+				Dictionary<string, object> clickSignal = 
+					NativeAdInteractionUtils.CreateClickSignal(nativeAdObject, _nativeAdObjects, clickEventArgs.startClick, clickEventArgs.endClick);
+					
+				// _nativeAdInteractionHandlerClient.ReportTouchEvent(touchEventSignal);
+				Debug.LogWarning("InteractionHandlerClient: ReportTouchEvent!");
+				// _nativeAdInteractionHandlerClient.PerformClick(clickSignal);
+				Debug.LogWarning("InteractionHandlerClient: PerformClick!");
+				OpenURL();
+			}
+		}
+		
+		public void OpenURL()
+		{
+			Debug.Log("Opened URL");
+			Application.OpenURL(_clickUrl);
+		}
+
+	}
+}

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

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

package/Runtime/API/NativeAd/NativeAdInteractionUtils.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text;
+using Azerion.BlueStack.Common;
+using Azerion.BlueStack.Internal;
+using Castle.Components.DictionaryAdapter.Xml;
+using UnityEngine;
+
+// incomplete 
+namespace Azerion.BlueStack.API
+{
+    internal static class NativeAdInteractionUtils
+    {
+        public static Dictionary<string, string> CreateTouchEventSignal(ClickInfo currentPosition,
+            ClickInfo previousPosition)
+        {
+            Dictionary<string, string> signal = new Dictionary<string, string>();
+            signal.Add(GetHashedString("PreviousClickPosition.x"),
+                NativeUtils.ConvertPxToDp(previousPosition.clickPosition.x)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            signal.Add(GetHashedString("PreviousClickPosition.y"),
+                NativeUtils.ConvertPxToDp(previousPosition.clickPosition.y)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            signal.Add(GetHashedString("TimeInterval"),
+                Mathf.RoundToInt(previousPosition.clickTime - currentPosition.clickTime)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            return signal;
+        }
+
+        public static Dictionary<string, object> CreateClickSignal(NativeAdObject adComponent,
+            List<NativeAdObject> adComponents, ClickInfo currentPosition, ClickInfo previousPosition)
+        {
+            Dictionary<string, object> signal = new Dictionary<string, object>();
+            Dictionary<string, string> positionSignal = new Dictionary<string, string>();
+            Dictionary<string, object> clickSignal = new Dictionary<string, object>();
+            positionSignal.Add(GetHashedString("CurrentClickPosition.x"),
+                NativeUtils.ConvertPxToDp(currentPosition.clickPosition.x)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            positionSignal.Add(GetHashedString("CurrentClickPosition.y"),
+                NativeUtils.ConvertPxToDp(currentPosition.clickPosition.y)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            positionSignal.Add(GetHashedString("PreviousClickPosition.x"),
+                NativeUtils.ConvertPxToDp(previousPosition.clickPosition.x)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            positionSignal.Add(GetHashedString("PreviousClickPosition.y"),
+                NativeUtils.ConvertPxToDp(previousPosition.clickPosition.y)
+                    .ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            clickSignal = CreateImpressionSignal(adComponent, adComponents);
+            // positionSignal.Add(GetHashedString(""), GetHashedString(""));
+            signal.Add(GetHashedString("PositionSignal"), positionSignal);
+            signal.Add(GetHashedString("ObjectTag"), adComponent.ObjectTag);
+            clickSignal.Add(GetHashedString("Signal"), signal);
+            return clickSignal;
+        }
+
+        public static Dictionary<string, object> CreateImpressionSignal(NativeAdObject adComponent,
+            List<NativeAdObject> adComponents)
+        {
+            Dictionary<string, object> signal = new Dictionary<string, object>();
+            Dictionary<string, string> adData = new Dictionary<string, string>();
+            string version = BuildVersionString(NativeUtils.Version);
+            adData.Add(GetHashedString("Version"), version);
+            adData.Add(GetHashedString("InteractionTime"),
+                adComponent.InteractionTime.ToString((IFormatProvider)CultureInfo.InvariantCulture));
+            signal.Add(GetHashedString("AdData"), adData);
+            // signal.Add(GetHashedString(""), CreateAdData(adComponents));
+            return signal;
+        }
+        
+        private static string GetHashedString(uint hash)
+        {
+            // Return the string representation of the hash
+            return hash.ToString();
+        }
+
+        private static string GetHashedString(string text, string salt = "")
+        {
+            if (String.IsNullOrEmpty(text))
+            {
+                return String.Empty;
+            }
+    
+            // Uses SHA256 to create the hash
+            using (var sha = new System.Security.Cryptography.SHA256Managed())
+            {
+                // Convert the string to a byte array first, to be processed
+                byte[] textBytes = System.Text.Encoding.UTF8.GetBytes(text + salt);
+                byte[] hashBytes = sha.ComputeHash(textBytes);
+        
+                // Convert back to a string, removing the '-' that BitConverter adds
+                string hash = BitConverter
+                    .ToString(hashBytes)
+                    .Replace("-", String.Empty);
+
+                return hash;
+            }
+        }
+        
+        private static string Version
+        {
+            get
+            {
+                Version version = typeof(NativeAd).Assembly.GetName().Version;
+                return string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build);
+            }
+        }
+
+        internal static string BuildVersionString(string nativePluginVersion = null)
+        {
+            StringBuilder stringBuilder = new StringBuilder("unity-");
+            stringBuilder.Append(Version);
+            if (!string.IsNullOrEmpty(nativePluginVersion))
+            {
+                stringBuilder.Append("-native-");
+                stringBuilder.Append(nativePluginVersion);
+            }
+
+            return stringBuilder.ToString();
+        }
+    }
+}

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

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