提交项目

Assets/ROAS/Editor.meta

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

Assets/ROAS/Editor/UserBuildSettings.cs

@@ -0,0 +1,181 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+#if UNITY_EDITOR
+public class UserBuildSettings : MonoBehaviour
+{
+    private const string MTG_iOS = "Mintegral / iOS Ad Mediation/";
+    private const string MTG_Android = "Mintegral / Android Ad Mediation/";
+   
+    private const string ironsource ="ironSource";
+    private const string admob = "AdMob";
+    private const string max = "MAX";
+    private const string tradplus = "TRADPLUS";
+
+   
+    private static void ShowTips(string title, string content)
+    {
+        // 展示提示信息.
+        EditorUtility.DisplayDialog(title, content, "OK");
+    }
+
+    private static void ShowPlayerTips4notiOS()
+    {
+
+#if !(UNITY_IPHONE || UNITY_IOS)
+        ShowTips("提示", "当前平台非iOS,请切换为iOS后重试");
+#endif
+    }
+    private static void ShowPlayerTips4notAndroid()
+    {
+#if !UNITY_ANDROID
+        ShowTips("提示", "当前平台非Android,请切换Android平台后重试");
+
+#endif
+    }
+
+    [MenuItem(MTG_iOS+ ironsource)]
+    public static void iOS_ironsource()
+    {
+        ShowPlayerTips4notiOS();
+#if UNITY_IPHONE || UNITY_IOS
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
+
+        Debug.Log("old " + str);
+        str = str.Replace(ironsource, null);
+
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS,
+                ironsource + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS));
+
+#endif
+    }
+
+    [MenuItem(MTG_iOS + admob)]
+    public static void iOS_admob()
+    {
+        ShowPlayerTips4notiOS();
+#if UNITY_IPHONE || UNITY_IOS
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
+
+        Debug.Log("old " + str);
+        str = str.Replace(admob, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS,
+               admob + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS));
+
+ 
+
+#endif
+    }
+
+    [MenuItem(MTG_iOS + max)]
+    public static void iOS_max()
+    {
+        ShowPlayerTips4notiOS();
+#if UNITY_IPHONE || UNITY_IOS
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
+
+        Debug.Log("old " + str);
+        str = str.Replace(max, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS,
+               max + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS));
+
+
+
+#endif
+    }
+    [MenuItem(MTG_iOS + tradplus)]
+    public static void iOS_tradplus()
+    {
+        ShowPlayerTips4notiOS();
+#if UNITY_IPHONE || UNITY_IOS
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS);
+
+        Debug.Log("old " + str);
+        str = str.Replace(tradplus, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS,
+               tradplus + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.iOS));
+
+
+
+#endif
+    }
+    
+    [MenuItem(MTG_Android + ironsource)]
+    public static void Android_ironsource()
+    {
+        ShowPlayerTips4notAndroid();
+
+
+#if UNITY_ANDROID
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android);
+        Debug.Log("old " + str);
+        str = str.Replace(ironsource, null);
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android,
+               ironsource + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android));
+
+#endif
+    }
+
+    [MenuItem(MTG_Android + admob)]
+    public static void Android_admob()
+    {
+        ShowPlayerTips4notAndroid();
+#if UNITY_ANDROID
+
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android);
+
+        Debug.Log("old " + str);
+        str = str.Replace(admob, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android,
+               admob + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android));
+
+#endif
+    }
+    [MenuItem(MTG_Android + max)]
+    public static void Android_max()
+    {
+        ShowPlayerTips4notAndroid();
+#if UNITY_ANDROID
+
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android);
+
+        Debug.Log("old " + str);
+        str = str.Replace(max, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android,
+                max + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android));
+
+#endif
+    }
+    [MenuItem(MTG_Android + tradplus)]
+    public static void Android_tradplus()
+    {
+        ShowPlayerTips4notAndroid();
+#if UNITY_ANDROID
+
+        string str = PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android);
+
+        Debug.Log("old " + str);
+        str = str.Replace(tradplus, null);
+
+        PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android,
+            tradplus + ";" + str);
+        Debug.Log("new " + PlayerSettings.GetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android));
+
+#endif
+    }
+}
+#endif

Assets/ROAS/Editor/UserBuildSettings.cs.meta

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

Assets/ROAS/Plugins.meta

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

Assets/ROAS/Plugins/Android.meta

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

Assets/ROAS/Plugins/Android/androidBridge4Roas.jar.meta

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

Assets/ROAS/Plugins/iOS.meta

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

Assets/ROAS/Plugins/iOS/UnityInternalCallMintegral.mm

@@ -0,0 +1,332 @@
+//
+//  UnityInternalCallMintegral.m
+//  Unity-iPhone
+//
+//  Created by iMengqing on 2023/8/9.
+//
+
+#import <Foundation/Foundation.h>
+#import <MTGSDK/MTGTrackAdRevenue.h>
+#import<MTGSDK/MTGSDK.h>
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+
+static NSString *const kMTG_Mediation_Admob = @"Admob";
+static NSString *const kMTG_Mediation_IronSource = @"IronSource";
+static NSString *const kMTG_Mediation_Max = @"Max";
+static NSString *const kMTG_Mediation_Tradeplus=@"Tradeplus";
+
+
+static NSString *const kMTG_mediationName = @"mediationName";
+static NSString *const kMTG_attributionPlatformName = @"attributionPlatformName";
+static NSString *const kMTG_attributionUserID = @"attributionUserID";
+static NSString *const kMTG_mBridge_Version=@"mBridge_Version";
+static NSString *const kMTG_u_p_v=@"u_p_v";
+
+///admob key
+static NSString *const kMTG_Admob_adType = @"adType";
+static NSString *const kMTG_Admob_adUnitID = @"adUnitID";
+static NSString *const kMTG_Admob_loadedadapterResponseInfo = @"loadedadapterResponseInfo";
+static NSString *const kMTG_Admob_AdapterClassName = @"AdapterClassName";
+static NSString *const kMTG_Admob_AdUnitMapping = @"AdUnitMapping";
+///admob  adValue key
+static NSString *const kMTG_Admob_adValue = @"adValue";
+static NSString *const kMTG_Admob_adValue_Precision = @"Precision";
+static NSString *const kMTG_Admob_adValue_CurrencyCode = @"CurrencyCode";
+static NSString *const kMTG_Admob_adValue_Value = @"Value";
+
+
+//ironsource key
+static NSString *const kMTG_IronSource_irinstanceid = @"irinstanceid";
+static NSString *const kMTG_IronSource_ironSourceImpressionData = @"ironSourceImpressionData";
+static NSString *const kMTG_IronSource_adUnit = @"adUnit";
+static NSString *const kMTG_IronSource_adNetwork = @"adNetwork";
+static NSString *const kMTG_IronSource_precision = @"precision";
+static NSString *const kMTG_IronSource_revenue = @"revenue";
+static NSString *const kMTG_IronSource_instanceId = @"instanceId";
+
+//max key
+static NSString *const kMTG_max_adInfo = @"adInfo";
+static NSString *const kMTG_max_AdUnitIdentifier = @"AdUnitIdentifier";
+static NSString *const kMTG_max_AdFormat = @"AdFormat";
+static NSString *const kMTG_max_NetworkName = @"NetworkName";
+static NSString *const kMTG_max_RevenuePrecision = @"RevenuePrecision";
+static NSString *const kMTG_max_Revenue = @"Revenue";
+static NSString *const kMTG_max_WaterfallInfo = @"WaterfallInfo";
+static NSString *const kMTG_max_NetworkResponses = @"NetworkResponses";
+static NSString *const kMTG_max_AdLoadState = @"AdLoadState";
+static NSString *const kMTG_max_Credentials = @"Credentials";
+static NSString *const kMTG_max_IsBidding = @"IsBidding";
+static NSString *const kMTG_max_DspName = @"DspName";
+
+
+
+//tradeplus key
+static NSString *const kMTG_tp_adInfo = @"adInfo";
+
+
+//Custom key
+static NSString *const KMTG_Custom_attributionPlatformName = @"AttributionPlatformName";
+static NSString *const KMTG_Custom_attributionPlatformUserId = @"AttributionPlatformUserId";
+static NSString *const KMTG_Custom_MediationName = @"MediationName";
+static NSString *const KMTG_Custom_MediationUnitId = @"MediationUnitId";
+static NSString *const KMTG_Custom_AdNetworkName = @"AdNetworkName";
+static NSString *const KMTG_Custom_Precision = @"Precision";
+static NSString *const KMTG_Custom_Currency = @"Currency";
+static NSString *const KMTG_Custom_Revenue = @"Revenue";
+static NSString *const KMTG_Custom_AdNetworkUnitInfo = @"AdNetworkUnitInfo";
+static NSString *const KMTG_Custom_IsBidding = @"IsBidding";
+static NSString *const KMTG_Custom_AdType = @"AdType";
+static NSString *const KMTG_Custom_DspId = @"DspId";
+static NSString *const KMTG_Custom_DspName = @"DspName";
+static NSString *const KMTG_Custom_AllInfo = @"AllInfo";
+
+static bool debug = false;
+static bool mtg_check_nsstring(NSString *arg) {
+    if (!arg || ![arg isKindOfClass:[NSString class]]
+        || ![arg respondsToSelector:@selector(length)] || arg.length == 0) {
+        return false;
+    }
+    return true;
+}
+
+static bool mtg_check_dict(NSDictionary *arg) {
+    if (!arg) {
+        return false;
+    }
+    if (![arg isKindOfClass:NSDictionary.class]) {
+        return false;
+    }
+    
+    if (arg.allKeys.count == 0) {
+        return false;
+    }
+
+    return true;
+}
+
+    void _initialize(char * appID,char * appKey){
+        NSString*appid=[[NSString alloc] initWithUTF8String:appID];
+        NSString*appkey=[[NSString alloc] initWithUTF8String:appKey];
+        if(mtg_check_nsstring(appid)&&mtg_check_nsstring(appkey))
+        [[MTGSDK sharedInstance] setAppID:appid ApiKey:appkey];
+    
+    }
+   void _setDebug(bool p){
+     debug=p;
+   }
+    //游戏层访问SDK的接口
+    void _trackAdRevenueWithAdRevenueModel(char * jsonpara)
+    {
+      
+        if (jsonpara == NULL)
+            return;
+        if(debug)
+            NSLog(@"ROAS _trackAdRevenueWithAdRevenueModel %s",jsonpara);
+        NSString*string=[[NSString alloc] initWithUTF8String:jsonpara];
+        
+        NSData *jsonData = [string dataUsingEncoding:NSUTF8StringEncoding];
+        NSDictionary *dics = [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingMutableContainers error:NULL];
+     
+        NSString *mediationName = dics[kMTG_mediationName];
+        if([mediationName isEqualToString:kMTG_Mediation_Tradeplus]){
+            MTGTrackAdRevenueTradPlusModel*tpModel=[[MTGTrackAdRevenueTradPlusModel alloc]init];
+             NSDictionary *adInfo = dics[kMTG_tp_adInfo];
+            tpModel.attributionPlatformName=dics[kMTG_attributionPlatformName];
+            tpModel.attributionUserID = dics[kMTG_attributionUserID];
+             if(mtg_check_dict(adInfo)){
+                 tpModel.adInfo=adInfo;
+             }
+            if(mtg_check_nsstring(dics[kMTG_mBridge_Version])){
+                tpModel.extraData = @{kMTG_u_p_v:dics[kMTG_mBridge_Version]};
+            }
+          
+            [MTGTrackAdRevenue trackAdRevenueWithAdRevenueModel:tpModel];
+            return;
+         }
+         
+        MTGTrackAdRevenueCustomModel *customModel = [[MTGTrackAdRevenueCustomModel alloc]init];
+       
+        customModel.attributionPlatformName =  dics[kMTG_attributionPlatformName];
+        customModel.attributionUserID = dics[kMTG_attributionUserID];
+      
+        if(mtg_check_nsstring(mediationName))
+        {
+            customModel.mediationName = mediationName;
+           
+            if ([mediationName isEqualToString:kMTG_Mediation_Admob]) {
+                customModel.adType = dics[kMTG_Admob_adType];//@"Banner";
+                customModel.mediationUnitId = dics[kMTG_Admob_adUnitID];
+                NSDictionary *adapterResponseInfo = dics[kMTG_Admob_loadedadapterResponseInfo];
+                if(mtg_check_dict(adapterResponseInfo)){
+                  
+                    customModel.adNetworkName =adapterResponseInfo[kMTG_Admob_AdapterClassName]; //self.bannerView.responseInfo.loadedAdNetworkResponseInfo.adNetworkClassName;
+                    customModel.adNetworkUnitInfo =adapterResponseInfo[kMTG_Admob_AdUnitMapping]; //self.bannerView.responseInfo.loadedAdNetworkResponseInfo.adUnitMapping;
+                    
+                    customModel.allInfo = adapterResponseInfo;
+                }
+                 NSDictionary *adValue = dics[kMTG_Admob_adValue];
+                if(mtg_check_dict(adValue)){
+                  
+                    customModel.precision = adValue[kMTG_Admob_adValue_Precision];//[NSString stringWithFormat:@"%ld",(long)value.precision];
+                    customModel.currency = adValue[kMTG_Admob_adValue_CurrencyCode];//value.currencyCode;
+                    customModel.revenue = @([adValue[kMTG_Admob_adValue_Value] doubleValue]);//value.value;
+                }
+                
+                customModel.dspName = @"";
+               
+            }else if([mediationName isEqualToString:kMTG_Mediation_IronSource]){
+// -----是不是instanceid
+                customModel.mediationUnitId = dics[kMTG_IronSource_irinstanceid];
+//  ------只能从ironSourceImpressionData中取
+              
+                NSDictionary *ironSourceImpressionData = dics[kMTG_IronSource_ironSourceImpressionData];
+                if(mtg_check_dict(ironSourceImpressionData)){
+                   
+                    customModel.adType = ironSourceImpressionData[kMTG_IronSource_adUnit];//@"Banner";
+                    customModel.adNetworkName =ironSourceImpressionData[kMTG_IronSource_adNetwork];// impressionData.ad_network;
+                    customModel.precision  =ironSourceImpressionData[kMTG_IronSource_precision];//impressionData.precision;
+                    customModel.revenue = ironSourceImpressionData[kMTG_IronSource_revenue];//impressionData.revenue;
+                    customModel.adNetworkUnitInfo = @{@"instanceId":ironSourceImpressionData[kMTG_IronSource_instanceId]};
+                    customModel.allInfo =ironSourceImpressionData;
+                    customModel.dspName = @"";
+                }
+            }
+            else if([mediationName isEqualToString:kMTG_Mediation_Max]){
+                NSDictionary *adInfo = dics[kMTG_max_adInfo];
+                if(mtg_check_dict(adInfo)){
+                    customModel.mediationUnitId = adInfo[kMTG_max_AdUnitIdentifier];//ad.adUnitIdentifier;
+                    customModel.adType = adInfo[kMTG_max_AdFormat];//ad.format.label;
+                    customModel.adNetworkName = adInfo[kMTG_max_NetworkName];//ad.networkName;
+                    customModel.precision = adInfo[kMTG_max_RevenuePrecision];//ad.revenuePrecision;
+                    
+                    customModel.revenue = @([adInfo[kMTG_max_Revenue] doubleValue]);//adInfo[@"Revenue"]
+
+                    NSDictionary *WaterfallInfo =  adInfo[kMTG_max_WaterfallInfo];
+                    if(mtg_check_dict(WaterfallInfo)){
+                      
+                        NSDictionary *NetworkResponses =  WaterfallInfo[@"NetworkResponses"];
+                        if(mtg_check_dict(NetworkResponses)){
+                       
+                            if([NetworkResponses[kMTG_max_AdLoadState] isEqual:@1]){
+                              
+                    customModel.adNetworkUnitInfo = NetworkResponses[kMTG_max_Credentials];//info.credentials;
+                                
+                        
+                    customModel.isBidding = [NetworkResponses[kMTG_max_IsBidding]boolValue] ;//info.isBidding;
+                            }
+                        }
+                            
+                    }
+
+                    customModel.allInfo =adInfo;
+                    customModel.dspName = adInfo[kMTG_max_DspName];//ad.DSPName;
+                    
+                }
+              
+                
+            }
+        }
+       // customModel.dspId =@"";
+      
+        if(mtg_check_nsstring(dics[kMTG_mBridge_Version])){
+            customModel.extraData = @{kMTG_u_p_v:dics[kMTG_mBridge_Version]};
+        }
+      
+        [MTGTrackAdRevenue trackAdRevenueWithAdRevenueModel:customModel];
+
+       
+    }
+
+void _trackAdRevenueWithAdCustomModel(char * jsonpara){
+    if (jsonpara == NULL)
+        return;
+    if(debug)
+        NSLog(@"ROAS _trackAdRevenueWithAdCustomModel %s",jsonpara);
+    NSString*string=[[NSString alloc] initWithUTF8String:jsonpara];
+    
+    NSData *jsonData = [string dataUsingEncoding:NSUTF8StringEncoding];
+    NSDictionary *dics = [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingMutableContainers error:NULL];
+ 
+    MTGTrackAdRevenueCustomModel *customModel = [[MTGTrackAdRevenueCustomModel alloc]init];
+    
+    NSString *AttributionPlatformName = dics[KMTG_Custom_attributionPlatformName];
+    if(mtg_check_nsstring( AttributionPlatformName))
+        customModel.attributionPlatformName =  AttributionPlatformName;
+    
+    
+    NSString *AttributionPlatformUserId = dics[KMTG_Custom_attributionPlatformUserId];
+    if(mtg_check_nsstring( AttributionPlatformUserId))
+        customModel.attributionUserID =  AttributionPlatformUserId;
+    
+    
+    NSString *MediationName = dics[KMTG_Custom_MediationName];
+    if(mtg_check_nsstring( MediationName))
+        customModel.mediationName =  MediationName;
+    
+    
+    NSString *MediationUnitId = dics[KMTG_Custom_MediationUnitId];
+    if(mtg_check_nsstring( MediationUnitId))
+        customModel.mediationUnitId =  MediationUnitId;
+    
+    
+    NSString *AdNetworkName = dics[KMTG_Custom_AdNetworkName];
+    if(mtg_check_nsstring( AdNetworkName))
+        customModel.adNetworkName =  AdNetworkName;
+    
+    
+    
+    NSString *Precision = dics[KMTG_Custom_Precision];
+    if(mtg_check_nsstring( Precision))
+        customModel.precision =  Precision;
+    
+    
+    
+    NSString *Currency = dics[KMTG_Custom_Currency];
+    if(mtg_check_nsstring( Currency))
+        customModel.currency = Currency;
+    
+    
+    NSNumber *Revenue  = dics[KMTG_Custom_Revenue];
+    if (Revenue != nil)
+        customModel.revenue = @([Revenue doubleValue]);
+        
+        
+    NSDictionary *AdNetworkUnitInfo = dics[KMTG_Custom_AdNetworkUnitInfo];
+    if(mtg_check_dict(AdNetworkUnitInfo))
+        customModel.adNetworkUnitInfo =  AdNetworkUnitInfo;
+    
+    
+    customModel.isBidding = [dics[KMTG_Custom_IsBidding]boolValue];
+    
+    
+    NSString *AdType = dics[KMTG_Custom_DspId];
+    if(mtg_check_nsstring( AdType))
+        customModel.dspId = AdType;
+    
+    
+    NSString *DspId = dics[KMTG_Custom_AdType];
+    if(mtg_check_nsstring( DspId))
+        customModel.adType = DspId;
+    
+    NSString *DspName = dics[KMTG_Custom_DspName];
+    if(mtg_check_nsstring( DspName))
+        customModel.dspName = DspName;
+    
+    
+    NSDictionary *AllInfo = dics[KMTG_Custom_AllInfo];
+    if(mtg_check_dict(AllInfo))
+        customModel.allInfo =  AllInfo;
+    
+    if(mtg_check_nsstring(dics[kMTG_mBridge_Version])){
+        customModel.extraData = @{kMTG_u_p_v:dics[kMTG_mBridge_Version]};
+    }
+  
+    [MTGTrackAdRevenue trackAdRevenueWithAdRevenueModel:customModel];
+ 
+}
+    
+}

Assets/ROAS/Plugins/iOS/UnityInternalCallMintegral.mm.meta

@@ -0,0 +1,37 @@
+fileFormatVersion: 2
+guid: 8c7844e06e7794f17a44a0dd264a1341
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  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: 

Assets/ROAS/Scripts.meta

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

Assets/ROAS/Scripts/MBridgeRevenueManager.cs

@@ -0,0 +1,244 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+public class MBridgeRevenueManager
+{
+    public const string MBridge_Version = "1.0.3";
+    
+#if UNITY_IOS || UNITY_IPHONE
+    [DllImport("__Internal")]
+    private static extern void _trackAdRevenueWithAdRevenueModel(string info);
+    
+    [DllImport("__Internal")]
+    private static extern void _trackAdRevenueWithAdCustomModel(string info);
+
+#endif
+
+    public static void TrackCustom(MBridgeRevenueCustomAdData adData)
+    {
+       Dictionary<string, object> dic = new Dictionary<string, object>();
+       var properties = typeof(MBridgeRevenueCustomAdData).GetProperties();
+       foreach (var property in properties)
+       {
+           var propertyName = property.Name;
+           var propertyValue = property.GetValue(adData);
+           if (propertyValue != null)
+           {
+               dic.Add(propertyName, propertyValue);
+           }
+       }
+       dic.Add("mBridge_Version", MBridge_Version);
+       var json=ROSA.ThirdParty.MiniJson.Json.Serialize(dic);
+#if UNITY_IOS || UNITY_IPHONE
+        _trackAdRevenueWithAdCustomModel(json);
+#elif UNITY_ANDROID
+        MUnityDataSendBridge.getInstance().trackAdCustom(json);
+#endif
+
+
+    }
+   public static void Track(MBridgeRevenueParamsEntity mBridgeRevenueParamsEntity)
+    {
+        try
+        {
+            Dictionary<string, object> dic = new Dictionary<string, object>();
+            dic.Add("attributionPlatformName", mBridgeRevenueParamsEntity.attributionPlatformName);
+            dic.Add("attributionUserID", mBridgeRevenueParamsEntity.attributionPlatformUserId);
+            dic.Add("mBridge_Version", MBridge_Version);
+            #region AdMob
+
+#if AdMob
+            dic.Add("mediationName", mediationName.Admob.ToString());
+            dic.Add("adUnitID", mBridgeRevenueParamsEntity.adUnitID);
+            if (mBridgeRevenueParamsEntity.adType == admobAdType.None)
+                dic.Add("adType", "");
+            else
+                dic.Add("adType", mBridgeRevenueParamsEntity.adType.ToString());
+
+            if (mBridgeRevenueParamsEntity.adValue == null)
+                dic.Add("adValue", "");
+            else
+            {
+                Dictionary<string, object> dicadValue = new Dictionary<string, object>();
+                dicadValue.Add("CurrencyCode", mBridgeRevenueParamsEntity.adValue.CurrencyCode);
+                dicadValue.Add("Precision", mBridgeRevenueParamsEntity.adValue.Precision);
+                dicadValue.Add("Value", mBridgeRevenueParamsEntity.adValue.Value);
+
+                dic.Add("adValue", dicadValue);
+            }
+            if (mBridgeRevenueParamsEntity.responseInfo == null)
+            {
+                dic.Add("loadedadapterResponseInfo", "");
+            }
+            else
+            {
+                var re = mBridgeRevenueParamsEntity.responseInfo.GetLoadedAdapterResponseInfo();
+                Dictionary<string, object> dicadapterResponseInfo = new Dictionary<string, object>();
+
+                dicadapterResponseInfo.Add("AdapterClassName", re.AdapterClassName);
+                dicadapterResponseInfo.Add("AdSourceId", re.AdSourceId);
+                dicadapterResponseInfo.Add("AdSourceName", re.AdSourceName);
+                dicadapterResponseInfo.Add("AdSourceInstanceId", re.AdSourceInstanceId);
+                dicadapterResponseInfo.Add("AdSourceInstanceName", re.AdSourceInstanceName);
+                dicadapterResponseInfo.Add("AdUnitMapping", re.AdUnitMapping);
+                dicadapterResponseInfo.Add("AdError", re.AdError);
+                dicadapterResponseInfo.Add("LatencyMillis", re.LatencyMillis);
+                dic.Add("loadedadapterResponseInfo", dicadapterResponseInfo);
+            }
+            var admobAdJson=ROSA.ThirdParty.MiniJson.Json.Serialize(dic);
+
+            if (MUnityDataSendBridge.getInstance().isDebug)
+                Debug.Log("ROAS  AdMob Ad JSON"+ admobAdJson);
+#if UNITY_IOS || UNITY_IPHONE
+            _trackAdRevenueWithAdRevenueModel(admobAdJson);
+#elif UNITY_ANDROID
+
+            var responseInfo = "";
+            if (mBridgeRevenueParamsEntity!=null && mBridgeRevenueParamsEntity.responseInfo!=null) {
+                responseInfo = mBridgeRevenueParamsEntity.responseInfo.ToString();
+            }
+
+            MUnityDataSendBridge.getInstance().trackAdRevenue(admobAdJson, responseInfo);
+
+#endif
+#endif
+            #endregion
+            
+            #region ironSource
+#if ironSource
+
+            if (mBridgeRevenueParamsEntity!=null && mBridgeRevenueParamsEntity.instanceid == null)
+            {
+                dic.Add("irinstanceid", "");
+            }
+            else {
+                dic.Add("irinstanceid", mBridgeRevenueParamsEntity.instanceid);
+            }
+           
+            dic.Add("mediationName", mediationName.IronSource.ToString());
+            if (mBridgeRevenueParamsEntity.ironSourceImpressionData == null)
+                dic.Add("ironSourceImpressionData","");
+            else
+                dic.Add("ironSourceImpressionData", ROSA.ThirdParty.MiniJson.Json.Deserialize(mBridgeRevenueParamsEntity.ironSourceImpressionData.allData));
+            var ironSourceAdJsonStr = ROSA.ThirdParty.MiniJson.Json.Serialize(dic);
+            if (MUnityDataSendBridge.getInstance().isDebug)
+                Debug.Log("ROAS  ironSource Ad JSON" + ironSourceAdJsonStr);
+#if UNITY_IOS || UNITY_IPHONE
+            _trackAdRevenueWithAdRevenueModel(ironSourceAdJsonStr);
+#elif UNITY_ANDROID
+            MUnityDataSendBridge.getInstance().trackAdRevenue(ironSourceAdJsonStr);        
+
+#endif
+#endif
+           #endregion
+
+            #region MAX
+#if MAX
+            dic.Add("mediationName", mediationName.Max.ToString());
+            if (mBridgeRevenueParamsEntity.AdInfo == null)
+                dic.Add("adInfo", "");
+            else
+            {
+                var adInfo = mBridgeRevenueParamsEntity.AdInfo;
+                Dictionary<string, object> dicadInfo = new Dictionary<string, object>();
+                dicadInfo.Add("AdUnitIdentifier", adInfo.AdUnitIdentifier);
+                dicadInfo.Add("AdFormat", adInfo.AdFormat);
+                dicadInfo.Add("NetworkName", adInfo.NetworkName);
+                dicadInfo.Add("NetworkPlacement", adInfo.NetworkPlacement);
+                dicadInfo.Add("Placement", adInfo.Placement);
+                dicadInfo.Add("Revenue", adInfo.Revenue);
+                dicadInfo.Add("CreativeIdentifier", adInfo.CreativeIdentifier);
+                dicadInfo.Add("RevenuePrecision", adInfo.RevenuePrecision);
+                var WaterfallInfo = mBridgeRevenueParamsEntity.AdInfo.WaterfallInfo;
+                Dictionary<string, object> dicWaterfallInfo = new Dictionary<string, object>();
+
+                dicWaterfallInfo.Add("Name", WaterfallInfo.Name);
+                dicWaterfallInfo.Add("TestName", WaterfallInfo.TestName);
+
+                var NetworkResponses = mBridgeRevenueParamsEntity.AdInfo.WaterfallInfo.NetworkResponses;
+                Dictionary<string, object> dicNetworkResponses = new Dictionary<string, object>();
+
+                foreach (var item in NetworkResponses)
+                {
+                    //Debug.Log("SerializeObject AdLoadState" + (int)item.AdLoadState);
+                    if ((int)item.AdLoadState == 1)
+                    {
+                        dicNetworkResponses.Add("AdLoadState", (int)item.AdLoadState);
+                        var MediatedNetwork = item.MediatedNetwork;
+                        Dictionary<string, object> dicMediatedNetwork = new Dictionary<string, object>();
+
+                        dicMediatedNetwork.Add("Name", MediatedNetwork.Name);
+                        dicMediatedNetwork.Add("AdapterClassName", MediatedNetwork.AdapterClassName);
+                        dicMediatedNetwork.Add("AdapterVersion", MediatedNetwork.AdapterVersion);
+                        dicMediatedNetwork.Add("SdkVersion", MediatedNetwork.SdkVersion);
+                        dicNetworkResponses.Add("MediatedNetwork", dicMediatedNetwork);
+                        dicNetworkResponses.Add("IsBidding", item.IsBidding);
+                        dicNetworkResponses.Add("Credentials", item.Credentials);
+                        dicNetworkResponses.Add("LatencyMillis", item.LatencyMillis);
+                        dicNetworkResponses.Add("Error", item.Error);
+                    }
+                }
+                dicWaterfallInfo.Add("NetworkResponses", dicNetworkResponses);
+                dicWaterfallInfo.Add("LatencyMillis", WaterfallInfo.LatencyMillis);
+
+                dicadInfo.Add("WaterfallInfo", dicWaterfallInfo);
+                dicadInfo.Add("DspName", adInfo.DspName);
+                dic.Add("adInfo", dicadInfo);
+            }
+            var maxJsonStr=ROSA.ThirdParty.MiniJson.Json.Serialize(dic);
+            if (MUnityDataSendBridge.getInstance().isDebug)
+                Debug.Log("ROAS  MAX Ad JSON" + maxJsonStr);
+#if UNITY_IOS || UNITY_IPHONE
+            _trackAdRevenueWithAdRevenueModel(maxJsonStr);
+
+#elif UNITY_ANDROID
+
+            MUnityDataSendBridge.getInstance().trackAdRevenue(maxJsonStr);
+
+#endif
+#endif
+            #endregion
+
+            #region TRADPLUS
+#if TRADPLUS
+            dic.Add("mediationName", mediationName.Tradeplus.ToString());
+            if (mBridgeRevenueParamsEntity.tradplusadInfo == null)
+                dic.Add("adInfo", "");
+            else
+                dic.Add("adInfo",mBridgeRevenueParamsEntity.tradplusadInfo);
+           
+            var TPAdJsonStr = ROSA.ThirdParty.MiniJson.Json.Serialize(dic);
+            if (MUnityDataSendBridge.getInstance().isDebug)
+                Debug.Log("ROAS  tradplus Ad JSON" + TPAdJsonStr);
+#if UNITY_IOS || UNITY_IPHONE
+            _trackAdRevenueWithAdRevenueModel(TPAdJsonStr);
+#elif UNITY_ANDROID
+            MUnityDataSendBridge.getInstance().trackAdRevenue(TPAdJsonStr);
+#endif
+#endif
+
+
+            #endregion
+        }
+        
+        catch (System.Exception ex)
+        {
+            Debug.LogError("ROSA Unity Plugins Error"+ ex);
+        }
+     
+
+
+
+
+    }
+
+}
+public enum mediationName
+{
+    Max,
+    Admob,
+    IronSource,
+    Tradeplus
+}

Assets/ROAS/Scripts/MBridgeRevenueManager.cs.meta

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

Assets/ROAS/Scripts/MBridgeRevenueParamsEntity.cs

@@ -0,0 +1,152 @@
+using System.Collections;
+using System.Collections.Generic;
+#if AdMob
+using GoogleMobileAds.Api;
+#endif
+
+using UnityEngine;
+
+
+public class MBridgeRevenueParamsEntity
+{
+
+    public const string ATTRIBUTION_PLATFORM_APPSFLYER = "AppsFlyer";
+    public const string ATTRIBUTION_PLATFORM_ADJUST = "Adjust";
+    public const string ATTRIBUTION_PLATFORM_TENJIN = "Tenjin";
+    public const string ATTRIBUTION_PLATFORM_SINGULAR = "Singular";
+    public const string ATTRIBUTION_PLATFORM_KOCHAVA = "Kochava";
+    public const string ATTRIBUTION_PLATFORM_BRANCH = "Branch";
+    public const string ATTRIBUTION_PLATFORM_REYUN = "Reyun";
+    public const string ATTRIBUTION_PLATFORM_SOLAR_ENGINE = "SolarEngine";
+    public const string ATTRIBUTION_PLATFORM_APP_METRICA = "AppMetrica";
+    public const string ATTRIBUTION_PLATFORM_MY_TRACKER = "MyTracker";
+    public const string ATTRIBUTION_PLATFORM_ADBRIX = "Adbrix";
+    public const string ATTRIBUTION_PLATFORM_APSALAR = "Apsalar";
+    public const string ATTRIBUTION_PLATFORM_DATA_EYE = "DataEye";
+    public const string ATTRIBUTION_PLATFORM_FOX = "Fox";
+    public const string ATTRIBUTION_PLATFORM_TALKING_DATA = "TalkingData";
+    public const string ATTRIBUTION_PLATFORM_UMENG = "Umeng";
+    public const string ATTRIBUTION_PLATFORM_AIRVRIDGE = "Airbridge";
+    public const string ATTRIBUTION_PLATFORM_JUST_TRACK = "JustTrack";
+
+    //第三方归因平台名字，取值有AppsFlyer，Adjust和Tenjin
+    public string attributionPlatformName = "";
+    //第三方归因平台，用户激活应用时生成的id
+    public string attributionPlatformUserId = "";
+
+    #region admob
+#if AdMob
+    public AdValue adValue = null;
+    public ResponseInfo responseInfo = null;
+    public string adUnitID = "";
+    public admobAdType adType = admobAdType.None;
+
+    public void SetAdmobAdValue(AdValue advalue)
+    {
+        this.adValue = advalue;
+    }
+
+    public void SetAdmobAdType(admobAdType adtype)
+    {
+        this.adType = adtype;
+    }
+
+    public void SetAdmobAdUnitid(string adunitid)
+    {
+        this.adUnitID = adunitid;
+    }
+
+    public void SetAdmobResponseInfo(ResponseInfo responseinfo)
+    {
+        this.responseInfo = responseinfo;
+    }
+#endif
+    #endregion
+
+    #region max
+
+#if MAX
+    public MaxSdkBase.AdInfo AdInfo=null;
+
+    public void SetMaxAdInfo(MaxSdkBase.AdInfo adInfo)
+    {
+        this.AdInfo = adInfo;
+    }
+#endif
+
+    #endregion
+
+
+    #region ironsource
+
+#if ironSource
+    public string instanceid="";
+
+    public IronSourceImpressionData ironSourceImpressionData=null;
+
+    public void SetIronSourceInstanceid(string instanceid)
+    {
+        this.instanceid = instanceid;
+    }
+    public void SetIronSourceImpressionData( IronSourceImpressionData data)
+    {
+        this.ironSourceImpressionData = data;
+    }
+#endif
+    #endregion
+
+
+
+    #region tradplus
+#if TRADPLUS
+    public Dictionary<string, object> tradplusadInfo = new Dictionary<string, object>();
+    public void SetTradplusAdInfo(Dictionary<string,object>adInfo)
+    {
+        this.tradplusadInfo = adInfo;
+    }
+#endif
+    #endregion
+
+    public MBridgeRevenueParamsEntity(string attributionPlatformName, string attributionPlatformUserId)
+    {
+        this.attributionPlatformName = attributionPlatformName;
+        this.attributionPlatformUserId = attributionPlatformUserId;
+    }
+
+    
+}
+
+public enum admobAdType
+{
+    // Rewarded|Banner|Interstitial|Native|AppOpen.
+
+    Rewarded,
+    Banner,
+    Interstitial,
+    Native,
+    AppOpen,
+    None
+}
+
+
+    public class MBridgeRevenueCustomAdData
+    {
+        public string AttributionPlatformName { get; set; }
+        public string AttributionPlatformUserId { get; set; }
+        public string MediationName { get; set; }
+        public string MediationUnitId { get; set; }
+        public string AdNetworkName { get; set; }
+        public string Precision { get; set; }
+        public string Currency { get; set; }
+        public double? Revenue { get; set; }
+        public Dictionary<string, object> AdNetworkUnitInfo { get; set; }
+        public bool IsBidding { get; set; }
+        public string AdType { get; set; }
+        public string DspId { get; set; }
+        public string DspName { get; set; }
+        public Dictionary<string, object> AllInfo { get; set; }
+      
+    }
+
+
+      

Assets/ROAS/Scripts/MBridgeRevenueParamsEntity.cs.meta

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

Assets/ROAS/Scripts/MBridgeSDKManager.cs

@@ -0,0 +1,21 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+public class MBridgeSDKManager
+{
+#if UNITY_IOS || UNITY_IPHONE
+    [DllImport("__Internal")]
+    private static extern void _initialize(string appid,string appkey);
+
+#endif
+    public static void initialize(string appID, string appKey)
+    {
+#if UNITY_ANDROID
+        MUnityDataSendBridge.getInstance().initialize(appID,appKey);
+#elif UNITY_IOS || UNITY_IPHONE
+        _initialize(appID, appKey);
+#endif
+    }
+}

Assets/ROAS/Scripts/MBridgeSDKManager.cs.meta

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

Assets/ROAS/Scripts/MUnityDataSendBridge.cs

@@ -0,0 +1,129 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+public class MUnityDataSendBridge
+{
+    private static MUnityDataSendBridge _instance = new MUnityDataSendBridge();
+    private readonly AndroidJavaObject _mUnityDataSend;
+    public bool isDebug = false;
+#if UNITY_IOS || UNITY_IPHONE
+    [DllImport("__Internal")]
+    private static extern void _setDebug(bool debug);
+
+#endif
+    private MUnityDataSendBridge()
+    {
+        if (Application.platform == RuntimePlatform.Android) {
+            _mUnityDataSend = new AndroidJavaObject("com.mbridge.msdk.unity.MUnityDataReceiver");
+        }
+    }
+
+    public static MUnityDataSendBridge getInstance()
+    {
+        return _instance;
+    }
+
+    public void initialize(string appID, string appKey)
+    {
+        try
+        {
+            AndroidJavaObject applicationContext = getApplicationContext();
+            if (applicationContext != null)
+            {
+                _mUnityDataSend.CallStatic("initialize", applicationContext, appID, appKey);
+            }
+            else
+            {
+                Debug.LogError("Failed to get application context.");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError("Exception occurred while calling trackAdRevenue: " + ex.Message);
+        }
+    }
+
+    public void trackAdRevenue(string trackAdJsonStr,string extraJsonStr)
+    {
+        
+        try
+        {
+            AndroidJavaObject applicationContext = getApplicationContext();
+            if (applicationContext != null)
+            {
+                _mUnityDataSend.CallStatic("trackAdRevenue", applicationContext, trackAdJsonStr, extraJsonStr);
+            }
+            else
+            {
+                Debug.LogError("Failed to get application context.");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError("Exception occurred while calling trackAdRevenue: " + ex.Message);
+        }
+    }
+
+    public void trackAdRevenue(string trackAdJsonStr)
+    {
+        trackAdRevenue(trackAdJsonStr,"");
+    }
+
+    public void trackAdCustom(string trackAdJsonStr)
+    {
+        try
+        {
+            AndroidJavaObject applicationContext = getApplicationContext();
+            if (applicationContext != null)
+            {
+                _mUnityDataSend.CallStatic("trackAdCustom", applicationContext, trackAdJsonStr);
+            }
+            else
+            {
+                Debug.LogError("Failed to get application context.");
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError("Exception occurred while calling trackAdRevenue: " + ex.Message);
+        }
+    }
+
+    private AndroidJavaObject getApplicationContext()
+    {
+        try
+        {
+            using (AndroidJavaClass jc = new AndroidJavaClass("com.unity3d.player.UnityPlayer"))
+            {
+                using (AndroidJavaObject jo = jc.GetStatic<AndroidJavaObject>("currentActivity"))
+                {
+                    return jo.Call<AndroidJavaObject>("getApplicationContext");
+                }
+            }
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError("Exception occurred while getting application context: " + ex.Message);
+        }
+        return null;
+    }
+
+    public void setDebug(bool debug)
+    {
+        try
+        {
+            isDebug = debug;
+#if UNITY_ANDROID
+            _mUnityDataSend.CallStatic("setDebug", debug);
+#elif UNITY_IOS || UNITY_IPHONE
+            _setDebug(debug);
+#endif
+        }
+        catch (System.Exception ex)
+        {
+            Debug.LogError("Exception occurred while calling trackAdRevenue: " + ex.Message);
+        }
+    }
+}

Assets/ROAS/Scripts/MUnityDataSendBridge.cs.meta

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

Assets/ROAS/Scripts/ThirdParty.meta

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

Assets/ROAS/Scripts/ThirdParty/ROSAMiniJson.cs

@@ -0,0 +1,692 @@
+/*
+ * Copyright (c) 2013 Calvin Rien
+ *
+ * Based on the JSON parser by Patrick van Bergen
+ * http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html
+ *
+ * Simplified it so that it doesn't throw exceptions
+ * and can be used in Unity iPhone with maximum code stripping.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace ROSA.ThirdParty.MiniJson
+{
+	// Example usage:
+	//
+	//  using UnityEngine;
+	//  using UnityEditor;
+	//  using System.Collections;
+	//  using System.Collections.Generic;
+	//
+	//  public class MiniJSONTest : MonoBehaviour {
+	//      void Start () {
+	//          var jsonString = "{ \"array\": [1.44,2,3], " +
+	//                          "\"object\": {\"key1\":\"value1\", \"key2\":256}, " +
+	//                          "\"string\": \"The quick brown fox \\\"jumps\\\" over the lazy dog \", " +
+	//                          "\"unicode\": \"\\u3041 Men\u00fa sesi\u00f3n\", " +
+	//                          "\"int\": 65536, " +
+	//                          "\"float\": 3.1415926, " +
+	//                          "\"bool\": true, " +
+	//                          "\"null\": null }";
+	//
+	//          var dict = Json.Deserialize (jsonString) as Dictionary<string,object>;
+	//
+	//          Debug.Log ("deserialized: " + dict.GetType ());
+	//          Debug.Log ("dict['array'][0]: " + ((List<object>) dict["array"])[0]);
+	//          Debug.Log ("dict['string']: " + (string) dict["string"]);
+	//          Debug.Log ("dict['float']: " + (double) dict["float"]); // floats come out as doubles
+	//          Debug.Log ("dict['int']: " + (long) dict["int"]); // ints come out as longs
+	//          Debug.Log ("dict['unicode']: " + (string) dict["unicode"]);
+	//
+	//          var str = Json.Serialize (dict);
+	//
+	//          Debug.Log ("serialized: " + str);
+	//      }
+	//  }
+
+	/// <summary>
+	/// This class encodes and decodes JSON strings.
+	/// Spec. details, see http://www.json.org/
+	///
+	/// JSON uses Arrays and Objects. These correspond here to the datatypes IList and IDictionary.
+	/// All numbers are parsed to doubles.
+	/// </summary>
+	internal static class Json
+	{
+		/// <summary>
+		/// Parses the string json into a value
+		/// </summary>
+		/// <param name="json">A JSON string.</param>
+		/// <returns>An List&lt;object&gt;, a Dictionary&lt;string, object&gt;, a double, an integer,a string, null, true, or false</returns>
+		public static object Deserialize (string json)
+		{
+			// save the string for debug information
+			if (json == null)
+			{
+				return null;
+			}
+
+			return Parser.Parse (json);
+		}
+
+		sealed class Parser : IDisposable
+		{
+			const string WORD_BREAK = "{}[],:\"";
+
+			public static bool IsWordBreak (char c)
+			{
+				return Char.IsWhiteSpace (c) || WORD_BREAK.IndexOf (c) != -1;
+			}
+
+			enum TOKEN
+			{
+				NONE,
+				CURLY_OPEN,
+				CURLY_CLOSE,
+				SQUARED_OPEN,
+				SQUARED_CLOSE,
+				COLON,
+				COMMA,
+				STRING,
+				NUMBER,
+				TRUE,
+				FALSE,
+				NULL
+			}
+
+			StringReader json;
+
+			Parser (string jsonString)
+			{
+				json = new StringReader (jsonString);
+			}
+
+			public static object Parse (string jsonString)
+			{
+				using (var instance = new Parser (jsonString))
+				{
+					return instance.ParseValue ();
+				}
+			}
+
+			public void Dispose ()
+			{
+				json.Dispose ();
+				json = null;
+			}
+
+			Dictionary<string, object> ParseObject ()
+			{
+				Dictionary<string, object> table = new Dictionary<string, object> ();
+
+				// ditch opening brace
+				json.Read ();
+
+				// {
+				while (true)
+				{
+					switch (NextToken)
+					{
+						case TOKEN.NONE:
+							return null;
+						case TOKEN.COMMA:
+							continue;
+						case TOKEN.CURLY_CLOSE:
+							return table;
+						default:
+							// name
+							string name = ParseString ();
+							if (name == null)
+							{
+								return null;
+							}
+
+							// :
+							if (NextToken != TOKEN.COLON)
+							{
+								return null;
+							}
+							// ditch the colon
+							json.Read ();
+
+							// value
+							table[name] = ParseValue ();
+							break;
+					}
+				}
+			}
+
+			List<object> ParseArray ()
+			{
+				List<object> array = new List<object> ();
+
+				// ditch opening bracket
+				json.Read ();
+
+				// [
+				var parsing = true;
+				while (parsing)
+				{
+					TOKEN nextToken = NextToken;
+
+					switch (nextToken)
+					{
+						case TOKEN.NONE:
+							return null;
+						case TOKEN.COMMA:
+							continue;
+						case TOKEN.SQUARED_CLOSE:
+							parsing = false;
+							break;
+						default:
+							object value = ParseByToken (nextToken);
+
+							array.Add (value);
+							break;
+					}
+				}
+
+				return array;
+			}
+
+			object ParseValue ()
+			{
+				TOKEN nextToken = NextToken;
+				return ParseByToken (nextToken);
+			}
+
+			object ParseByToken (TOKEN token)
+			{
+				switch (token)
+				{
+					case TOKEN.STRING:
+						return ParseString ();
+					case TOKEN.NUMBER:
+						return ParseNumber ();
+					case TOKEN.CURLY_OPEN:
+						return ParseObject ();
+					case TOKEN.SQUARED_OPEN:
+						return ParseArray ();
+					case TOKEN.TRUE:
+						return true;
+					case TOKEN.FALSE:
+						return false;
+					case TOKEN.NULL:
+						return null;
+					default:
+						return null;
+				}
+			}
+
+			string ParseString ()
+			{
+				StringBuilder s = new StringBuilder ();
+				char c;
+
+				// ditch opening quote
+				json.Read ();
+
+				bool parsing = true;
+				while (parsing)
+				{
+
+					if (json.Peek () == -1)
+					{
+						parsing = false;
+						break;
+					}
+
+					c = NextChar;
+					switch (c)
+					{
+						case '"':
+							parsing = false;
+							break;
+						case '\\':
+							if (json.Peek () == -1)
+							{
+								parsing = false;
+								break;
+							}
+
+							c = NextChar;
+							switch (c)
+							{
+								case '"':
+								case '\\':
+								case '/':
+									s.Append (c);
+									break;
+								case 'b':
+									s.Append ('\b');
+									break;
+								case 'f':
+									s.Append ('\f');
+									break;
+								case 'n':
+									s.Append ('\n');
+									break;
+								case 'r':
+									s.Append ('\r');
+									break;
+								case 't':
+									s.Append ('\t');
+									break;
+								case 'u':
+									var hex = new char[4];
+
+									for (int i=0; i< 4; i++)
+									{
+										hex[i] = NextChar;
+									}
+
+									s.Append ((char) Convert.ToInt32 (new string (hex), 16));
+									break;
+							}
+							break;
+						default:
+							s.Append (c);
+							break;
+					}
+				}
+
+				return s.ToString ();
+			}
+
+			object ParseNumber ()
+			{
+				string number = NextWord;
+
+                if (Int64.TryParse(number, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out var parsedInt))
+				{
+					return parsedInt;
+				}
+
+                Double.TryParse(number, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture, out var parsedDouble);
+                return parsedDouble;
+            }
+
+            void EatWhitespace ()
+			{
+				while (Char.IsWhiteSpace (PeekChar))
+				{
+					json.Read ();
+
+					if (json.Peek () == -1)
+					{
+						break;
+					}
+				}
+			}
+
+			char PeekChar
+			{
+				get
+				{
+					return Convert.ToChar (json.Peek ());
+				}
+			}
+
+			char NextChar
+			{
+				get
+				{
+					return Convert.ToChar (json.Read ());
+				}
+			}
+
+			string NextWord
+			{
+				get
+				{
+					StringBuilder word = new StringBuilder ();
+
+					while (!IsWordBreak (PeekChar))
+					{
+						word.Append (NextChar);
+
+						if (json.Peek () == -1)
+						{
+							break;
+						}
+					}
+
+					return word.ToString ();
+				}
+			}
+
+			TOKEN NextToken
+			{
+				get
+				{
+					EatWhitespace ();
+
+					if (json.Peek () == -1)
+					{
+						return TOKEN.NONE;
+					}
+
+					switch (PeekChar)
+					{
+						case '{':
+							return TOKEN.CURLY_OPEN;
+						case '}':
+							json.Read ();
+							return TOKEN.CURLY_CLOSE;
+						case '[':
+							return TOKEN.SQUARED_OPEN;
+						case ']':
+							json.Read ();
+							return TOKEN.SQUARED_CLOSE;
+						case ',':
+							json.Read ();
+							return TOKEN.COMMA;
+						case '"':
+							return TOKEN.STRING;
+						case ':':
+							return TOKEN.COLON;
+						case '0':
+						case '1':
+						case '2':
+						case '3':
+						case '4':
+						case '5':
+						case '6':
+						case '7':
+						case '8':
+						case '9':
+						case '-':
+							return TOKEN.NUMBER;
+					}
+
+					switch (NextWord)
+					{
+						case "false":
+							return TOKEN.FALSE;
+						case "true":
+							return TOKEN.TRUE;
+						case "null":
+							return TOKEN.NULL;
+					}
+
+					return TOKEN.NONE;
+				}
+			}
+		}
+
+		/// <summary>
+		/// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string
+		/// </summary>
+		/// <param name="json">A Dictionary&lt;string, object&gt; / List&lt;object&gt;</param>
+		/// <param name="pretty">A boolean to indicate whether or not JSON should be prettified, default is false.</param>
+		/// <param name="indentText">A string to ibe used as indentText, default is 2 spaces.</param>
+		/// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
+		public static string Serialize (object obj, bool pretty = false, string indentText = "  ")
+		{
+			return Serializer.Serialize (obj, pretty, indentText);
+		}
+
+		sealed class Serializer
+		{
+			readonly string indentText;
+			bool pretty;
+			StringBuilder builder;
+
+			Serializer (bool pretty, string indentText)
+			{
+				builder = new StringBuilder ();
+				this.pretty = pretty;
+				this.indentText = indentText;
+			}
+
+			public static string Serialize (object obj, bool pretty, string indentText)
+			{
+				var instance = new Serializer (pretty, indentText);
+
+				instance.SerializeValue (obj, 0);
+
+				return instance.builder.ToString ();
+			}
+
+			void SerializeValue (object value, int indent)
+			{
+				IList asList;
+				IDictionary asDict;
+				string asStr;
+
+				if (value == null || value is Delegate)
+				{
+					builder.Append ("null");
+				}
+				else if ((asStr = value as string) != null)
+				{
+					SerializeString (asStr);
+				}
+				else if (value is bool)
+				{
+					builder.Append ((bool) value ? "true" : "false");
+				}
+				else if ((asList = value as IList) != null)
+				{
+					SerializeArray (asList, indent);
+				}
+				else if ((asDict = value as IDictionary) != null)
+				{
+					SerializeObject (asDict, indent);
+				}
+				else if (value is char)
+				{
+					SerializeString (new string ((char) value, 1));
+				}
+				else
+				{
+					SerializeOther (value, indent);
+				}
+			}
+
+			void SerializeObject (IDictionary obj, int indent)
+			{
+				if (pretty && obj.Keys.Count == 0)
+				{
+						builder.Append("{}");
+						return;
+				}
+
+				bool first = true;
+				string indentLine = null;
+
+				builder.Append ('{');
+				if (pretty)
+				{
+					builder.Append('\n');
+					indentLine = string.Concat(Enumerable.Repeat(indentText, indent).ToArray());
+				}
+
+				foreach (object e in obj.Keys)
+				{
+					if (!first)
+					{
+						builder.Append (',');
+						if (pretty)
+							builder.Append ('\n');
+					}
+
+					if (pretty)
+					{
+						builder.Append(indentLine);
+						builder.Append(indentText);
+					}
+
+					SerializeString (e.ToString ());
+					builder.Append (':');
+					if (pretty)
+						builder.Append (' ');
+
+					SerializeValue (obj[e], indent + 1);
+
+					first = false;
+				}
+
+				if (pretty)
+				{
+					builder.Append('\n');
+					builder.Append(indentLine);
+				}
+				builder.Append ('}');
+			}
+
+			void SerializeArray (IList anArray, int indent)
+			{
+				if (pretty && anArray.Count == 0)
+				{
+						builder.Append("[]");
+						return;
+				}
+
+				bool first = true;
+				string indentLine = null;
+
+				builder.Append ('[');
+				if (pretty)
+				{
+					builder.Append('\n');
+					indentLine = string.Concat(Enumerable.Repeat(indentText, indent).ToArray());
+				}
+
+				foreach (object obj in anArray)
+				{
+					if (!first)
+					{
+						builder.Append (',');
+						if (pretty)
+							builder.Append ('\n');
+					}
+
+					if (pretty)
+					{
+						builder.Append(indentLine);
+						builder.Append(indentText);
+					}
+
+					SerializeValue (obj, indent + 1);
+
+					first = false;
+				}
+
+				if (pretty)
+				{
+					builder.Append('\n');
+					builder.Append(indentLine);
+				}
+				builder.Append (']');
+			}
+
+			void SerializeString (string str)
+			{
+				builder.Append ('\"');
+
+				char[] charArray = str.ToCharArray ();
+				foreach (var c in charArray)
+				{
+					switch (c)
+					{
+						case '"':
+							builder.Append ("\\\"");
+							break;
+						case '\\':
+							builder.Append ("\\\\");
+							break;
+						case '\b':
+							builder.Append ("\\b");
+							break;
+						case '\f':
+							builder.Append ("\\f");
+							break;
+						case '\n':
+							builder.Append ("\\n");
+							break;
+						case '\r':
+							builder.Append ("\\r");
+							break;
+						case '\t':
+							builder.Append ("\\t");
+							break;
+						default:
+							int codepoint = Convert.ToInt32 (c);
+							if ((codepoint >= 32) && (codepoint <= 126))
+							{
+								builder.Append (c);
+							}
+							else
+							{
+								builder.Append ("\\u");
+								builder.Append (codepoint.ToString ("x4"));
+							}
+							break;
+					}
+				}
+
+				builder.Append ('\"');
+			}
+
+			void SerializeOther (object value, int indent)
+			{
+				// NOTE: decimals lose precision during serialization.
+				// They always have, I'm just letting you know.
+				// Previously floats and doubles lost precision too.
+				if (value is float)
+				{
+					builder.Append (((float) value).ToString ("R", System.Globalization.CultureInfo.InvariantCulture));
+				}
+				else if (value is int || value is uint || value is long || value is sbyte || value is byte || value is short || value is ushort || value is ulong)
+				{
+					builder.Append (value);
+				}
+				else if (value is double || value is decimal)
+				{
+					builder.Append (Convert.ToDouble (value).ToString ("R", System.Globalization.CultureInfo.InvariantCulture));
+				}
+				else
+				{
+					Dictionary<string, object> map = new Dictionary<string, object> ();
+					List<FieldInfo> fields = value.GetType ().GetFields (BindingFlags.Instance | BindingFlags.Public).ToList ();
+					foreach (FieldInfo field in fields)
+					{
+						map.Add (field.Name, field.GetValue (value));
+					}
+					List<PropertyInfo> properties = value.GetType ().GetProperties (BindingFlags.Instance | BindingFlags.Public).ToList ();
+					foreach (PropertyInfo property in properties)
+					{
+						map.Add (property.Name, property.GetValue (value, null));
+					}
+					SerializeObject (map, indent);
+				}
+			}
+		}
+	}
+}

Assets/ROAS/Scripts/ThirdParty/ROSAMiniJson.cs.meta

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