com.beanbag.huaweiads 0.0.1

package/Runtime/Scripts/Modeling3D/Modeling3dListenerManager.cs

@@ -0,0 +1,172 @@
+using HuaweiMobileServices.Modeling3D.MeterialGenerateSdk.Cloud;
+using HuaweiMobileServices.Modeling3D.ObjReconstructSdk.Cloud;
+using System;
+using UnityEngine;
+using static HuaweiMobileServices.Modeling3D.MeterialGenerateSdk.Cloud.Modeling3dTextureDownloadListener;
+using static HuaweiMobileServices.Modeling3D.MeterialGenerateSdk.Cloud.Modeling3dTexturePreviewListener;
+using static HuaweiMobileServices.Modeling3D.MeterialGenerateSdk.Cloud.Modeling3dTextureUploadListener;
+using static HuaweiMobileServices.Modeling3D.ModelingCaptureSdk.Modeling3dCaptureImageListener;
+using HuaweiMobileServices.Utils;
+
+namespace HmsPlugin
+{
+    public class Modeling3dReconstructUploadORDownloadORPreviewListener : IModeling3dReconstructUploadListener, IModeling3dReconstructDownloadListener, IModeling3dReconstructPreviewListener
+    {
+        private Action<string, double, AndroidJavaObject> Progress;
+        private Action<string, int, string> Error;
+        private Action<string, Modeling3dReconstructUploadResult, AndroidJavaObject> ResultUpload;
+        private Action<string, Modeling3dReconstructDownloadResult, AndroidJavaObject> ResultDownload;
+        private Action<string, AndroidJavaObject> ResultPreview;
+
+        public Modeling3dReconstructUploadORDownloadORPreviewListener(Action<string, double, AndroidJavaObject> UploadProgress,
+                                                    Action<string, int, string> Error,
+                                                     Action<string, Modeling3dReconstructUploadResult, AndroidJavaObject> ResultUpload)
+        {
+            this.Progress = UploadProgress;
+            this.Error = Error;
+            this.ResultUpload = ResultUpload;
+        }
+
+        public Modeling3dReconstructUploadORDownloadORPreviewListener(Action<string, double, AndroidJavaObject> DownloadProgress,
+                                             Action<string, int, string> Error,
+                                              Action<string, Modeling3dReconstructDownloadResult, AndroidJavaObject> ResultDownload)
+        {
+            this.Progress = DownloadProgress;
+            this.Error = Error;
+            this.ResultDownload = ResultDownload;
+        }
+
+        public Modeling3dReconstructUploadORDownloadORPreviewListener(Action<string, int, string> Error,
+                                                                Action<string, AndroidJavaObject> ResultPreview)
+        {
+            this.Error = Error;
+            this.ResultPreview = ResultPreview;
+        }
+
+        public void onDownloadProgress(string taskId, double progress, AndroidJavaObject javaObject)
+        {
+            Progress?.Invoke(taskId, progress, javaObject);
+        }
+
+        public void onError(string taskId, int errorCode, string errorMessage)
+        {
+            Error?.Invoke(taskId, errorCode, errorMessage);
+            HMSExceptionHandler.Instance.HandleLogForListener($"Modeling3dCaptureImageListener onError: {errorCode} {taskId}", string.Empty, LogType.Error);
+        }
+
+        public void onResult(string taskId, Modeling3dReconstructUploadResult result, AndroidJavaObject javaObject)
+        {
+            ResultUpload?.Invoke(taskId, result, javaObject);
+        }
+
+        public void onResult(string taskId, Modeling3dReconstructDownloadResult result, AndroidJavaObject javaObject)
+        {
+            ResultDownload?.Invoke(taskId, result, javaObject);
+        }
+
+        public void onResult(string taskId, AndroidJavaObject javaObject)
+        {
+            ResultPreview?.Invoke(taskId, javaObject);
+        }
+
+        public void onUploadProgress(string taskId, double progress, AndroidJavaObject javaObject)
+        {
+            Progress?.Invoke(taskId, progress, javaObject);
+        }
+    }
+
+    public class Modeling3dCaptureImageListener : IModeling3dCaptureImageListener
+    {
+        private Action<int> Progress;
+        private Action<int, string> Error;
+        private Action Result;
+        public Modeling3dCaptureImageListener(Action<int> Progress,
+                                                    Action<int, string> Error,
+                                                     Action Result)
+        {
+            this.Progress = Progress;
+            this.Error = Error;
+            this.Result = Result;
+        }
+        public void onError(int errorCode, string message)
+        {
+            Error?.Invoke(errorCode, message);
+            HMSExceptionHandler.Instance.HandleLogForListener($"Modeling3dCaptureImageListener onError: {errorCode} {message}", string.Empty, LogType.Error);
+        }
+
+        public void onProgress(int progress)
+        {
+            Progress?.Invoke(progress);
+        }
+
+        public void onResult()
+        {
+            Result?.Invoke();
+        }
+    }
+
+    public class Modeling3dTextureUploadORDownloadORPreviewListener : IModeling3dTextureUploadListener, IModeling3dTextureDownloadListener, IModeling3dTexturePreviewListener
+    {
+        private Action<string, double, AndroidJavaObject> Progress;
+        private Action<string, int, string> Error;
+        private Action<string, Modeling3dTextureUploadResult, JavaObject> UploadResult;
+        private Action<string, Modeling3dTextureDownloadResult, AndroidJavaObject> DownloadResult;
+        private Action<string, AndroidJavaObject> PreviewResult;
+
+        public Modeling3dTextureUploadORDownloadORPreviewListener(Action<string, double, AndroidJavaObject> Progress,
+                                                    Action<string, int, string> Error
+                                                    , Action<string, Modeling3dTextureUploadResult, JavaObject> UploadResult)
+        {
+            this.Progress = Progress;
+            this.Error = Error;
+            this.UploadResult = UploadResult;
+        }
+        public Modeling3dTextureUploadORDownloadORPreviewListener(Action<string, double, AndroidJavaObject> Progress,
+                                            Action<string, int, string> Error
+                                            , Action<string, Modeling3dTextureDownloadResult, AndroidJavaObject> DownloadResult)
+        {
+            this.Progress = Progress;
+            this.Error = Error;
+            this.DownloadResult = DownloadResult;
+        }
+
+        public Modeling3dTextureUploadORDownloadORPreviewListener(Action<string, double, AndroidJavaObject> Progress,
+                                            Action<string, int, string> Error
+                                            , Action<string, AndroidJavaObject> PreviewResult)
+        {
+            this.Progress = Progress;
+            this.Error = Error;
+            this.PreviewResult = PreviewResult;
+        }
+        public void onDownloadProgress(string taskId, double progress, AndroidJavaObject javaObject)
+        {
+            Progress?.Invoke(taskId, progress, javaObject);
+        }
+
+        public void onError(string taskId, int errorCode, string errorMessage)
+        {
+            Error?.Invoke(taskId, errorCode, errorMessage);
+            HMSExceptionHandler.Instance.HandleLogForListener($"Modeling3dCaptureImageListener onError: {errorCode} {taskId}", string.Empty, LogType.Error);
+        }
+
+        public void onResult(string taskId, Modeling3dTextureUploadResult result, JavaObject javaObject)
+        {
+            UploadResult?.Invoke(taskId, result, javaObject);
+        }
+
+        public void onResult(string taskId, Modeling3dTextureDownloadResult result, AndroidJavaObject javaObject)
+        {
+            DownloadResult?.Invoke(taskId, result, javaObject);
+        }
+
+        public void onResult(string taskId, AndroidJavaObject javaObject)
+        {
+            PreviewResult?.Invoke(taskId, javaObject);
+        }
+
+        public void onUploadProgress(string taskId, double progress, JavaObject javaObject)
+        {
+            // Progress?.Invoke(taskId, progress, javaObject);
+        }
+    }
+}

package/Runtime/Scripts/Modeling3D/Modeling3dListenerManager.cs.meta

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

package/Runtime/Scripts/Modeling3D.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 716fe8a978be8e046af3f10261ef5ae3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/NearbyService/HMSNearbyServiceManager.cs

@@ -0,0 +1,80 @@
+using HuaweiMobileServices.Nearby;
+using HuaweiMobileServices.Nearby.Discovery;
+using HuaweiMobileServices.Nearby.Transfer;
+using System;
+using UnityEngine;
+
+namespace HmsPlugin
+{
+    public class HMSNearbyServiceManager : HMSManagerSingleton<HMSNearbyServiceManager>
+    {
+        public string scanInfo, remoteEndpointId, transmittingMessage, myNameStr, mEndpointName, mFileServiceId;
+
+        //Starting Broadcasting
+        public void SendFilesInner(IConnectCallBack connectCallBack)
+        {
+            Action mOnFailureListener;
+            // Obtain the endpoint information.
+            // Select a broadcast policy.
+            BroadcastOption advBuilder = new BroadcastOption.Builder().SetPolicy(Policy.POLICY_P2P).Build();
+
+            // Start broadcasting.
+            Nearby.DiscoveryEngine.StartBroadcasting(mEndpointName, mFileServiceId, connectCallBack, advBuilder);
+            Debug.Log("Nearby: Start Broadcasting");
+        }
+
+        //Starting Scanning
+        public void OnScanResult(IScanEndpointCallback scanEndpointCallback)
+        {
+            Debug.Log("Nearby: OnScanResult1 Start Scan");
+            ScanOption scanBuilder = new ScanOption.Builder().SetPolicy(Policy.POLICY_P2P).Build(); ;
+            // Start scanning.
+            Nearby.DiscoveryEngine.StartScan(mFileServiceId, scanEndpointCallback, scanBuilder);
+        }
+
+        //Stopping Broadcasting
+        public void StopBroadCasting()
+        {
+            Nearby.DiscoveryEngine.StopBroadcasting();
+        }
+
+        //Stopping Scanning
+        public void StopScanning()
+        {
+            // Nearby.GetDiscoveryEngine(context).StopScan();
+            HuaweiMobileServices.Nearby.Message.GetOption reportPolicy = HuaweiMobileServices.Nearby.Message.GetOption.DEFAULT;
+            Debug.Log("Nearby: Start reportPolicy works" + reportPolicy);
+        }
+        public void InitiateConnection(string endpointId, ScanEndpointInfo scanEndpointInfo, IConnectCallBack connectCallBack)
+        {
+            if (scanEndpointInfo.Name.Equals(scanInfo))
+            {
+                Debug.Log("[HMS] Nearby Client found Server and request connection. Server id:" + scanEndpointInfo.Name);
+                // Initiate a connection.
+                Nearby.DiscoveryEngine.RequestConnect(myNameStr, endpointId, connectCallBack);
+            }
+        }
+
+        // Confirming the Connection
+        // Accept the connection request
+        public void AcceptConnectionRequest(string endpointId, ConnectInfo connectInfo, IDataCallback dataCallback)
+        {
+            Debug.Log("[HMS] Accept Connection Request, Endpoint Name:" + connectInfo.EndpointName);
+            Nearby.DiscoveryEngine.AcceptConnect(endpointId, dataCallback);
+        }
+
+        //Disconnecting from a Remote Endpoint
+        public void DisconnectAllConnection()
+        {
+            Nearby.DiscoveryEngine.DisconnectAll();
+        }
+
+        //Transmitting Byte Arrays
+        private void TransmittingBytes()
+        {
+            var message = System.Text.Encoding.UTF8.GetBytes(transmittingMessage);
+            Nearby.TransferEngine.SendData(remoteEndpointId, Data.FromBytes(message));
+        }
+    }
+}
+

package/Runtime/Scripts/NearbyService/HMSNearbyServiceManager.cs.meta

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

package/Runtime/Scripts/NearbyService.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 31562a983c3982846968b35837b24fa8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Push/HMSPushKitManager.cs

@@ -0,0 +1,134 @@
+using HuaweiMobileServices.Base;
+using HuaweiMobileServices.Id;
+using HuaweiMobileServices.Push;
+using HuaweiMobileServices.Utils;
+using System;
+using UnityEngine;
+
+namespace HmsPlugin
+{
+    public class HMSPushKitManager : HMSManagerSingleton<HMSPushKitManager>, IPushListener
+    {
+        public const string TAG = "[HMS] PushKitManager";
+        public Action<string> OnTokenSuccess { get; set; }
+        public Action<Exception> OnTokenFailure { get; set; }
+        public Action<string, Bundle> OnTokenBundleSuccess { get; set; }
+        public Action<Exception, Bundle> OnTokenBundleFailure { get; set; }
+        public Action<string> OnMessageSentSuccess { get; set; }
+        public Action<string, Exception> OnSendFailure { get; set; }
+        public Action<string, Exception> OnMessageDeliveredSuccess { get; set; }
+        public Action<RemoteMessage> OnMessageReceivedSuccess { get; set; }
+        public Action<NotificationData> OnNotificationMessage { get; set; }
+        public Action<NotificationData> NotificationMessageOnStart { get; set; }
+
+        public NotificationData notificationDataOnStart;
+
+        public HMSPushKitManager()
+        {
+            HMSManagerStart.Start(OnAwake, TAG);
+        }
+
+        private void OnAwake()
+        {
+            Debug.Log($"{TAG}: OnAwake");
+            PushManager.Listener = this;
+            notificationDataOnStart = PushManager.NotificationDataOnStart;
+        }
+
+        public void Init()
+        {
+            if (notificationDataOnStart.NotifyId != -1)
+            {
+                NotificationMessageOnStart?.Invoke(notificationDataOnStart);
+            }
+            PushManager.RegisterOnNotificationMessage((data) =>
+            {
+                OnNotificationMessage?.Invoke(data);
+            });
+
+            var token = PushManager.Token;
+            Debug.Log($"{TAG}: Push token from GetToken is {token}");
+            if (token != null)
+            {
+                OnTokenSuccess?.Invoke(token);
+            }
+        }
+
+        public void OnNewToken(string token)
+        {
+            Debug.Log($"{TAG}: Push token from OnNewToken is {token}");
+            if (token != null)
+            {
+                OnTokenSuccess?.Invoke(token);
+            }
+        }
+
+        public void OnTokenError(Exception e)
+        {
+            Debug.LogError($"{TAG}: Error asking for Push token");
+            Debug.LogError(e.StackTrace);
+            OnTokenFailure?.Invoke(e);
+        }
+
+        // This method only gets triggered if Data Message is sent by Push Kit Server/AGC.
+        public void OnMessageReceived(RemoteMessage remoteMessage)
+        {
+            Debug.Log($"{TAG}: Data Message received");
+            Debug.Log($"{TAG}: Data: " + remoteMessage.Data);
+            OnMessageReceivedSuccess?.Invoke(remoteMessage);
+        }
+
+        public void OnNewToken(string token, Bundle bundle)
+        {
+            OnTokenBundleSuccess?.Invoke(token, bundle);
+        }
+
+        public void OnTokenError(Exception exception, Bundle bundle)
+        {
+            OnTokenBundleFailure?.Invoke(exception, bundle);
+        }
+
+        public void OnMessageSent(string msgId)
+        {
+            OnMessageSentSuccess?.Invoke(msgId);
+        }
+
+        public void OnMessageDelivered(string msgId, Exception exception)
+        {
+            OnMessageDeliveredSuccess?.Invoke(msgId, exception);
+        }
+
+        public void OnSendError(string msgId, Exception exception)
+        {
+            OnSendFailure?.Invoke(msgId, exception);
+        }
+        public void TurnOnPush()
+        {
+            HmsMessaging.GetInstance().TurnOnPush().AddOnSuccessListener((type) =>
+            {
+                Debug.Log($"{TAG}: TurnOnPush Complete");
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError($"{TAG}: TurnOnPush Failed" + exception.Message);
+
+            });
+        }
+        public void TurnOffPush()
+        {
+            HmsMessaging.GetInstance().TurnOffPush().AddOnSuccessListener((type) =>
+            {
+                Debug.Log($"{TAG}: TurnOffPush Complete");
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError($"{TAG}: TurnOffPush Failed" + exception.Message);
+
+            });
+        }
+        public void DeleteToken()
+        {
+            HmsInstanceId.GetInstance().DeleteToken(MetadataHelper.AppId, HmsMessaging.DEFAULT_TOKEN_SCOPE);
+        }
+    }
+}

package/Runtime/Scripts/Push/HMSPushKitManager.cs.meta

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

package/Runtime/Scripts/Push.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 607bd7fbf52ac064d8650b457c6a93c6
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/RemoteConfig/HMSRemoteConfigManager.cs

@@ -0,0 +1,157 @@
+using System.Collections.Generic;
+using System;
+using UnityEngine;
+using HuaweiMobileServices.RemoteConfig;
+using HuaweiMobileServices.Base;
+using HuaweiMobileServices.Utils;
+
+
+namespace HmsPlugin
+{
+    public class HMSRemoteConfigManager : HMSManagerSingleton<HMSRemoteConfigManager>
+    {
+        const string TAG = "[HMS] RemoteConfigManager";
+
+        public Action<ConfigValues> OnFetchSuccess { get; set; }
+        public Action<HMSException> OnFetchFailure { get; set; }
+
+        IAGConnectConfig agc = null;
+
+        public HMSRemoteConfigManager()
+        {
+            HMSManagerStart.Start(OnAwake, TAG);
+        }
+
+        private void OnAwake()
+        {
+            GetInstance();
+            if (HMSRemoteConfigSettings.Instance != null)
+            {
+                SetDeveloperMode(HMSRemoteConfigSettings.Instance.Settings.GetBool(HMSRemoteConfigSettings.DeveloperMode));
+                if (HMSRemoteConfigSettings.Instance.Settings.GetBool(HMSRemoteConfigSettings.ApplyDefaultValues))
+                {
+                    var values = HMSRemoteDefaultValueSettings.Instance.GetDefaultValues();
+                    if (values != null && values.Count > 0)
+                    {
+                        ApplyDefault(values);
+                    }
+                }
+            }
+            Debug.Log($"{TAG}: Start() ");
+        }
+
+        //getInstance() Obtains an instance of AGConnectConfig.
+        public void GetInstance()
+        {
+            if (agc == null) agc = AGConnectConfig.GetInstance();
+            Debug.Log($"{TAG}: GetInstance() {agc}");
+        }
+
+        //applyDefault(int resId) Sets a default value for a parameter.
+        public void ApplyDefault(Dictionary<string, object> dictionary)
+        {
+            if (agc != null) agc.ApplyDefault(dictionary);
+            Debug.Log($"{TAG}: applyDefault with Dictionary");
+        }
+
+        //applyDefault(Map<String, Object> map) Sets a default value for a parameter. This path must be in Resources folder.
+        public void ApplyDefault(string xmlPath)
+        {
+            if (agc != null) agc.ApplyDefault(xmlPath);
+            Debug.Log($"{TAG}: applyDefault({xmlPath})");
+        }
+
+        //apply(ConfigValues values) Applies parameter values.
+        public void Apply(ConfigValues configValues)
+        {
+            if (agc != null) agc.Apply(configValues);
+            Debug.Log($"{TAG}: apply");
+        }
+
+        //fetch() Fetches latest parameter values from Remote Configuration at the default
+        //interval of 12 hours. If the method is called within an interval, cached data is returned.
+        public void Fetch()
+        {
+            ITask<ConfigValues> x = agc.Fetch();
+            x.AddOnSuccessListener((configValues) =>
+            {
+                Debug.Log($"{TAG}: Fetch success.");
+                OnFetchSuccess?.Invoke(configValues);
+            });
+            x.AddOnFailureListener((exception) =>
+            {
+                Debug.LogError($"{TAG}: Fetch failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnFetchFailure?.Invoke(exception);
+            });
+        }
+
+        //fetch(long intervalSeconds) Fetches latest parameter values from Remote Configuration at
+        //a customized interval. If the method is called within an interval, cached data is returned.
+        public void Fetch(long intervalSeconds)
+        {
+            ITask<ConfigValues> x = agc.Fetch(intervalSeconds);
+            x.AddOnSuccessListener((configValues) =>
+            {
+                OnFetchSuccess?.Invoke(configValues);
+            });
+            x.AddOnFailureListener((exception) =>
+            {
+                OnFetchFailure?.Invoke(exception);
+            });
+        }
+
+        //getMergedAll() Returns all values obtained after the combination of the default values and
+        //values in Remote Configuration.
+        public Dictionary<string, object> GetMergedAll()
+        {
+            Dictionary<string, object> dictionary = new Dictionary<string, object>();
+            if (agc != null) dictionary = agc.GetMergedAll();
+            /*foreach(KeyValuePair<string, object> kvp in values)
+            {
+                Debug.Log($"[Remote Config]: key:{kvp.Key} / value:{kvp.Value}");
+            }*/
+            return dictionary;
+        }
+
+        //loadLastFetched() Obtains the cached data that is successfully fetched last time.
+        public ConfigValues LoadLastFetched()
+        {
+            ConfigValues config = null;
+            if (agc != null) config = agc.LoadLastFetched();
+            return config;
+        }
+
+        //getSource(String key) Returns the source of a key.
+        public string GetSource(string key)
+        {
+            string source = "";
+            if (agc != null) source = agc.GetSource(key);
+            return source;
+        }
+
+        //clearAll() Clears all cached data, including the data fetched from Remote Configuration and
+        //the default values passed.
+        public void ClearAll()
+        {
+            if (agc != null) agc.ClearAll();
+            Debug.Log($"{TAG}: clearAll()");
+        }
+
+        //setDeveloperMode(boolean isDeveloperMode) Enables the developer mode, in which the number
+        //of times that the client obtains data from Remote Configuration is not limited, and traffic
+        //control is still performed over the cloud.
+        public void SetDeveloperMode(Boolean val)
+        {
+            if (agc != null) agc.DeveloperMode = val;
+            Debug.Log($"{TAG}: setDeveloperMode({val})");
+        }
+
+        //Returns the value for a key.
+        public bool GetValueAsBoolean(string paramString) => agc.GetValueAsBoolean(paramString);
+        public byte[] GetValueAsByteArray(string paramString) => agc.GetValueAsByteArray(paramString);
+        public double GetValueAsDouble(string paramString) => agc.GetValueAsDouble(paramString);
+        public long GetValueAsLong(string paramString) => agc.GetValueAsLong(paramString);
+        public string GetValueAsString(string paramString) => agc.GetValueAsString(paramString);
+
+    }
+}

package/Runtime/Scripts/RemoteConfig/HMSRemoteConfigManager.cs.meta

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

package/Runtime/Scripts/RemoteConfig.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 852892851429fe2428ff590ebf09afde
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: