[add] first

Libraries/com.unity.ads/Plugins/iOS/UnityAdsInitializationListener.h

@@ -0,0 +1,10 @@
+#import "UnityAds/UnityAds.h"
+
+typedef void (*InitSuccessCallback)(void *initListener);
+typedef void (*InitFailCallback)(void *initListener, int error, const char *message);
+
+@interface UnityAdsInitializationListener : NSObject <UnityAdsInitializationDelegate>
+@property (assign) InitSuccessCallback initSuccessCallback;
+@property (assign) InitFailCallback initFailCallback;
+- (id)initWithSuccessCallback:(InitSuccessCallback)initSuccessCallback failCallback:(InitFailCallback)initFailCallback;
+@end

Libraries/com.unity.ads/Plugins/iOS/UnityAdsInitializationListener.mm

@@ -0,0 +1,50 @@
+#import "UnityAdsInitializationListener.h"
+
+@implementation UnityAdsInitializationListener
+
+- (id)initWithSuccessCallback:(InitSuccessCallback)initSuccessCallback failCallback:(InitFailCallback)initFailCallback {
+    self = [super init];
+
+    if (self) {
+        self.initSuccessCallback = initSuccessCallback;
+        self.initFailCallback = initFailCallback;
+    }
+
+    return self;
+}
+
+- (void)initializationFailed:(UnityAdsInitializationError)error withMessage:(NSString *)message {
+    if (self.initFailCallback) {
+        self.initFailCallback((__bridge void *)self, (int)error, [message UTF8String]);
+    }
+}
+
+- (void)initializationComplete {
+    if (self.initSuccessCallback) {
+        self.initSuccessCallback((__bridge void *)self);
+    }
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void * UnityAdsInitializationListenerCreate(InitSuccessCallback initSuccessCallback, InitFailCallback initFailCallback) {
+    UnityAdsInitializationListener *listener = [[UnityAdsInitializationListener alloc] initWithSuccessCallback:initSuccessCallback failCallback:initFailCallback];
+    return (__bridge_retained void *)listener;
+}
+
+void UnityAdsInitializationListenerDestroy(void *ptr) {
+    if (!ptr) return;
+
+    UnityAdsInitializationListener *listener = (__bridge_transfer UnityAdsInitializationListener *)ptr;
+
+    listener.initSuccessCallback = nil;
+    listener.initFailCallback = nil;
+}
+
+#ifdef __cplusplus
+}
+#endif

Libraries/com.unity.ads/Plugins/iOS/UnityAdsLoadListener.h

@@ -0,0 +1,10 @@
+#import "UnityAds/UnityAds.h"
+
+typedef void (*LoadSuccessCallback)(void *loadListener, const char *placementId);
+typedef void (*LoadFailureCallback)(void *loadListener, const char *placementId, int error, const char *message);
+
+@interface UnityAdsLoadListener : NSObject <UnityAdsLoadDelegate>
+@property (assign) LoadSuccessCallback loadSuccessCallback;
+@property (assign) LoadFailureCallback loadFailureCallback;
+- (id)initWithSuccessCallback:(LoadSuccessCallback)loadSuccessCallback failCallback:(LoadFailureCallback)loadFailureCallback;
+@end

Libraries/com.unity.ads/Plugins/iOS/UnityAdsLoadListener.mm

@@ -0,0 +1,50 @@
+#import "UnityAdsLoadListener.h"
+
+@implementation UnityAdsLoadListener
+
+- (id)initWithSuccessCallback:(LoadSuccessCallback)loadSuccessCallback failCallback:(LoadFailureCallback)loadFailureCallback {
+    self = [super init];
+
+    if (self) {
+        self.loadSuccessCallback = loadSuccessCallback;
+        self.loadFailureCallback = loadFailureCallback;
+    }
+
+    return self;
+}
+
+- (void)unityAdsAdFailedToLoad:(NSString *)placementId withError:(UnityAdsLoadError)error withMessage:(NSString *)message {
+    if (self.loadFailureCallback) {
+        self.loadFailureCallback((__bridge void *)self, [placementId UTF8String], (int)error, [message UTF8String]);
+    }
+}
+
+- (void)unityAdsAdLoaded:(NSString *)placementId {
+    if (self.loadSuccessCallback) {
+        self.loadSuccessCallback((__bridge void *)self, [placementId UTF8String]);
+    }
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void * UnityAdsLoadListenerCreate(LoadSuccessCallback loadSuccessCallback, LoadFailureCallback loadFailureCallback) {
+    UnityAdsLoadListener *listener = [[UnityAdsLoadListener alloc] initWithSuccessCallback:loadSuccessCallback failCallback:loadFailureCallback];
+    return (__bridge_retained void *)listener;
+}
+
+void UnityAdsLoadListenerDestroy(void *ptr) {
+    if (!ptr) return;
+
+    UnityAdsLoadListener *listener = (__bridge_transfer UnityAdsLoadListener *)ptr;
+
+    listener.loadSuccessCallback = nil;
+    listener.loadFailureCallback = nil;
+}
+
+#ifdef __cplusplus
+}
+#endif

Libraries/com.unity.ads/Plugins/iOS/UnityAdsNativeObject.m

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void UnityAdsBridgeTransfer(void *x) {
+    if (!x) return;
+
+    (__bridge_transfer id)x;
+}
+
+#ifdef __cplusplus
+}
+#endif

Libraries/com.unity.ads/Plugins/iOS/UnityAdsPurchasingWrapper.h

@@ -0,0 +1,6 @@
+typedef void (*UnityAdsPurchasingDidInitiatePurchasingCommandCallback)(const char * eventString);
+typedef void (*UnityAdsPurchasingGetProductCatalogCallback)();
+typedef void (*UnityAdsPurchasingGetPurchasingVersionCallback)();
+typedef void (*UnityAdsPurchasingInitializeCallback)();
+
+void InitializeUnityAdsPurchasingWrapper();

Libraries/com.unity.ads/Plugins/iOS/UnityAdsPurchasingWrapper.m

@@ -0,0 +1,71 @@
+#import "UnityAds/UADSPurchasing.h"
+#import "UnityAdsPurchasingWrapper.h"
+
+#import "UnityAdsUtilities.h"
+
+static UnityAdsPurchasingDidInitiatePurchasingCommandCallback iapCommandCallback = NULL;
+static UnityAdsPurchasingGetProductCatalogCallback iapCatalogCallback = NULL;
+static UnityAdsPurchasingGetPurchasingVersionCallback iapVersionCallback = NULL;
+static UnityAdsPurchasingInitializeCallback iapInitializeCallback = NULL;
+
+@interface UnityAdsPurchasingWrapperDelegate : NSObject <UADSPurchasingDelegate>
+@end
+
+@implementation UnityAdsPurchasingWrapperDelegate
+- (void)unityAdsPurchasingGetProductCatalog {
+    if(iapCatalogCallback != NULL) {
+        iapCatalogCallback();
+    }
+}
+
+- (void)unityAdsPurchasingGetPurchasingVersion {
+    if(iapVersionCallback != NULL) {
+        iapVersionCallback();
+    }
+}
+
+- (void)unityAdsPurchasingInitialize {
+    if(iapInitializeCallback != NULL) {
+        iapInitializeCallback();
+    }
+}
+
+- (void)unityAdsPurchasingDidInitiatePurchasingCommand:(NSString *)eventString {
+    if(iapCommandCallback != NULL) {
+        const char * rawEventString = UnityAdsCopyString([eventString UTF8String]);
+        iapCommandCallback(rawEventString);
+        free((void *)rawEventString);
+    }
+}
+@end
+
+void InitializeUnityAdsPurchasingWrapper() {
+    static id<UADSPurchasingDelegate> delegate = nil;
+    if (delegate == nil) {
+        delegate = [[UnityAdsPurchasingWrapperDelegate alloc] init];
+        [UADSPurchasing initialize:delegate];
+    }
+}
+
+void UnityAdsSetDidInitiatePurchasingCommandCallback(UnityAdsPurchasingDidInitiatePurchasingCommandCallback callback) {
+    iapCommandCallback = callback;
+}
+
+void UnityAdsSetGetProductCatalogCallback(UnityAdsPurchasingGetProductCatalogCallback callback) {
+    iapCatalogCallback = callback;
+}
+
+void UnityAdsSetGetVersionCallback(UnityAdsPurchasingGetPurchasingVersionCallback callback) {
+    iapVersionCallback = callback;
+}
+
+void UnityAdsSetInitializePurchasingCallback(UnityAdsPurchasingInitializeCallback callback) {
+    iapInitializeCallback = callback;
+}
+
+void UnityAdsPurchasingDispatchReturnEvent(UnityAdsPurchasingEvent event, const char * payload) {
+    if (payload == NULL) {
+        payload = "";
+    }
+    [UADSPurchasing dispatchReturnEvent:event withPayload:[NSString stringWithUTF8String:payload]];
+}

Libraries/com.unity.ads/Plugins/iOS/UnityAdsShowListener.h

@@ -0,0 +1,15 @@
+#import "UnityAds/UnityAds.h"
+
+typedef void (*ShowFailureCallback)(void *showlistener, const char *placementId, int error, const char *message);
+typedef void (*ShowStartCallback)(void *showListener, const char *placementId);
+typedef void (*ShowClickCallback)(void *showListener, const char *placementId);
+typedef void (*ShowCompleteCallback)(void *showListener, const char *placementId, int completionState);
+
+@interface UnityAdsShowListener : NSObject <UnityAdsShowDelegate>
+@property (assign) ShowFailureCallback showFailureCallback;
+@property (assign) ShowStartCallback showStartCallback;
+@property (assign) ShowClickCallback showClickCallback;
+@property (assign) ShowCompleteCallback showCompleteCallback;
+
+- (id)initWithFailureCallback:(ShowFailureCallback)showFailureCallback startCallback:(ShowStartCallback)showStartCallback clickCallback:(ShowClickCallback)showClickCallback completeCallback:(ShowCompleteCallback)showCompleteCallback;
+@end

Libraries/com.unity.ads/Plugins/iOS/UnityAdsShowListener.mm

@@ -0,0 +1,65 @@
+#import "UnityAdsShowListener.h"
+
+@implementation UnityAdsShowListener
+- (id)initWithFailureCallback:(ShowFailureCallback)showFailureCallback startCallback:(ShowStartCallback)showStartCallback clickCallback:(ShowClickCallback)showClickCallback completeCallback:(ShowCompleteCallback)showCompleteCallback {
+    self = [super init];
+
+    if (self) {
+        self.showFailureCallback = showFailureCallback;
+        self.showStartCallback = showStartCallback;
+        self.showClickCallback = showClickCallback;
+        self.showCompleteCallback = showCompleteCallback;
+    }
+
+    return self;
+}
+
+- (void)unityAdsShowFailed:(NSString *)placementId withError:(UnityAdsShowError)error withMessage:(NSString *)message {
+    if (self.showFailureCallback) {
+        self.showFailureCallback((__bridge void *)self, [placementId UTF8String], (int)error, [message UTF8String]);
+    }
+}
+
+- (void)unityAdsShowStart:(NSString *)placementId {
+    if (self.showStartCallback) {
+        self.showStartCallback((__bridge void *)self, [placementId UTF8String]);
+    }
+}
+
+- (void)unityAdsShowClick:(NSString *)placementId {
+    if (self.showClickCallback) {
+        self.showClickCallback((__bridge void *)self, [placementId UTF8String]);
+    }
+}
+
+- (void)unityAdsShowComplete:(NSString *)placementId withFinishState:(UnityAdsShowCompletionState)state {
+    if (self.showCompleteCallback) {
+        self.showCompleteCallback((__bridge void *)self, [placementId UTF8String], (int)state);
+    }
+}
+
+@end
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void * UnityAdsShowListenerCreate(ShowFailureCallback showFailureCallback, ShowStartCallback showStartCallback, ShowClickCallback showClickCallback, ShowCompleteCallback showCompleteCallback) {
+    UnityAdsShowListener *listener = [[UnityAdsShowListener alloc] initWithFailureCallback:showFailureCallback startCallback:showStartCallback clickCallback:showClickCallback completeCallback:showCompleteCallback];
+    return (__bridge_retained void *)listener;
+}
+
+void UnityAdsShowListenerDestroy(void *ptr) {
+    if (!ptr) return;
+
+    UnityAdsShowListener *listener = (__bridge_transfer UnityAdsShowListener *)ptr;
+
+    listener.showFailureCallback = nil;
+    listener.showStartCallback = nil;
+    listener.showClickCallback = nil;
+    listener.showCompleteCallback = nil;
+}
+
+#ifdef __cplusplus
+}
+#endif

Libraries/com.unity.ads/Plugins/iOS/UnityAdsUnityWrapper.m

@@ -0,0 +1,160 @@
+#import "UnityAppController.h"
+#import "Unity/UnityInterface.h"
+
+#import "UnityAds/UnityAds.h"
+#import <UnityAds/UADSBanner.h>
+#import "UnityAds/UADSMetaData.h"
+
+#import "UnityAdsUtilities.h"
+#import "UnityAdsPurchasingWrapper.h"
+#import "UnityAdsInitializationListener.h"
+#import "UnityAdsLoadListener.h"
+#import "UnityAdsShowListener.h"
+#import <UnityAds/UnityAdsFinishState.h>
+
+typedef void (*UnityAdsReadyCallback)(const char * placementId);
+typedef void (*UnityAdsDidErrorCallback)(long rawError, const char * message);
+typedef void (*UnityAdsDidStartCallback)(const char * placementId);
+typedef void (*UnityAdsDidFinishCallback)(const char * placementId, long rawFinishState);
+
+static UnityAdsReadyCallback readyCallback = NULL;
+static UnityAdsDidErrorCallback errorCallback = NULL;
+static UnityAdsDidStartCallback startCallback = NULL;
+static UnityAdsDidFinishCallback finishCallback = NULL;
+
+@interface UnityAdsUnityWrapperDelegate : NSObject <UnityAdsDelegate>
+@end
+
+@implementation UnityAdsUnityWrapperDelegate
+
+- (void)unityAdsReady:(NSString *)placementId {
+    if(readyCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        readyCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+}
+
+- (void)unityAdsDidError:(UnityAdsError)error withMessage:(NSString *)message {
+    if(errorCallback != NULL) {
+        const char * rawMessage = UnityAdsCopyString([message UTF8String]);
+        errorCallback(error, rawMessage);
+        free((void *)rawMessage);
+    }
+}
+
+- (void)unityAdsDidStart:(NSString *)placementId {
+    UnityPause(1);
+    if(startCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        startCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+}
+
+- (void)unityAdsDidFinish:(NSString *)placementId withFinishState:(UnityAdsFinishState)state {
+    UnityPause(0);
+    if(finishCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        finishCallback(rawPlacementId, state);
+        free((void *)rawPlacementId);
+    }
+}
+
+@end
+
+void UnityAdsInitialize(const char * gameId, bool testMode, bool enablePerPlacementLoad, void *listenerPtr) {
+    UnityAdsInitializationListener *listener = listenerPtr ? (__bridge UnityAdsInitializationListener *)listenerPtr : nil;
+    [UnityAds initialize:[NSString stringWithUTF8String:gameId] testMode:testMode enablePerPlacementLoad:enablePerPlacementLoad initializationDelegate:listener];
+    InitializeUnityAdsPurchasingWrapper();
+}
+
+void UnityAdsLoad(const char * placementId, void *listenerPtr) {
+    UnityAdsLoadListener *listener = listenerPtr ? (__bridge UnityAdsLoadListener *)listenerPtr : nil;
+    [UnityAds load:[NSString stringWithUTF8String:placementId] loadDelegate:listener];
+}
+
+void UnityAdsShow(const char * placementId, void *listenerPtr) {
+    UnityAdsShowListener *listener = listenerPtr ? (__bridge UnityAdsShowListener *)listenerPtr : nil;
+    [UnityAds show:UnityGetGLViewController() placementId:NSSTRING_OR_EMPTY(placementId) showDelegate:listener];
+}
+
+const char *UnityAdsGetDefaultPlacementID() {
+    NSString *returnedPlacementID = @"";
+    id placement = NSClassFromString(@"UADSPlacement");
+    if (placement) {
+        SEL getPlacementSelector = NSSelectorFromString(@"getDefaultPlacement");
+        if ([placement respondsToSelector:getPlacementSelector]) {
+            IMP getPlacementIMP = [placement methodForSelector:getPlacementSelector];
+            id (*getPlacementFunc)(void) = (void *) getPlacementIMP;
+            NSString *placementString = getPlacementFunc();
+            if (placementString != NULL) {
+                returnedPlacementID = placementString;
+            }
+        }
+    }
+    return CStringFromNSString(returnedPlacementID);
+}
+
+bool UnityAdsGetDebugMode() {
+    return [UnityAds getDebugMode];
+}
+
+void UnityAdsSetDebugMode(bool debugMode) {
+    [UnityAds setDebugMode:debugMode];
+}
+
+bool UnityAdsIsSupported() {
+    return [UnityAds isSupported];
+}
+
+bool UnityAdsIsReady(const char * placementId) {
+    if(placementId == NULL) {
+        return [UnityAds isReady];
+    } else {
+        return [UnityAds isReady:[NSString stringWithUTF8String:placementId]];
+    }
+}
+
+long UnityAdsGetPlacementState(const char * placementId) {
+    if(placementId == NULL) {
+        return [UnityAds getPlacementState];
+    } else {
+        return [UnityAds getPlacementState:[NSString stringWithUTF8String:placementId]];
+    }
+}
+
+const char * UnityAdsGetVersion() {
+    return UnityAdsCopyString([[UnityAds getVersion] UTF8String]);
+}
+
+bool UnityAdsIsInitialized() {
+    return [UnityAds isInitialized];
+}
+
+void UnityAdsSetMetaData(const char * category, const char * data) {
+    if(category != NULL && data != NULL) {
+        UADSMetaData* metaData = [[UADSMetaData alloc] initWithCategory:[NSString stringWithUTF8String:category]];
+        NSDictionary* json = [NSJSONSerialization JSONObjectWithData:[[NSString stringWithUTF8String:data] dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+        for(id key in json) {
+            [metaData set:key value:[json objectForKey:key]];
+        }
+        [metaData commit];
+    }
+}
+
+void UnityAdsSetReadyCallback(UnityAdsReadyCallback callback) {
+    readyCallback = callback;
+}
+
+void UnityAdsSetDidErrorCallback(UnityAdsDidErrorCallback callback) {
+    errorCallback = callback;
+}
+
+void UnityAdsSetDidStartCallback(UnityAdsDidStartCallback callback) {
+    startCallback = callback;
+}
+
+void UnityAdsSetDidFinishCallback(UnityAdsDidFinishCallback callback) {
+    finishCallback = callback;
+}

Libraries/com.unity.ads/Plugins/iOS/UnityAdsUtilities.h

@@ -0,0 +1,23 @@
+const char * UnityAdsCopyString(const char * string);
+
+/**
+ * Returns the size of an Il2CppString
+ */
+size_t Il2CppStringLen(const ushort* str);
+
+/**
+ * Converts an ushort string to an NSString
+ */
+NSString* NSStringFromIl2CppString(const ushort* str);
+
+/**
+ * Converts a char string to an NSString. Does pre checks for null pointer
+ */
+NSString* NSStringFromCString(const char* string);
+
+/**
+ * Converts a NSString to a char string.Does pre checks for null pointer
+ */
+const char * CStringFromNSString(const NSString * string);
+
+#define NSSTRING_OR_EMPTY(string) NSStringFromCString(string) ?: @""

Libraries/com.unity.ads/Plugins/iOS/UnityAdsUtilities.m

@@ -0,0 +1,38 @@
+const char * UnityAdsCopyString(const char * string) {
+    char * copy = (char *)malloc(strlen(string) + 1);
+    strcpy(copy, string);
+    return copy;
+}
+
+/**
+ * Returns the size of an Il2CppString
+ */
+size_t Il2CppStringLen(const ushort* str) {
+    const ushort* start = str;
+    while (*str) ++str;
+    return str - start;
+}
+
+/**
+ * Converts an ushort string to an NSString
+ */
+NSString* NSStringFromIl2CppString(const ushort* str) {
+    size_t len = Il2CppStringLen(str);
+    return [[NSString alloc] initWithBytes:(const void*)str
+                                    length:sizeof(ushort) * len
+                                  encoding:NSUTF16LittleEndianStringEncoding];
+}
+
+/**
+ * Converts an NSString to a char string.Does pre checks for null pointer
+ */
+const char * CStringFromNSString(const NSString * string) {
+    return string != NULL ? UnityAdsCopyString([string UTF8String]) : NULL;
+}
+
+/**
+ * Converts a char string to an NSString.Does pre checks for null pointer
+ */
+NSString* NSStringFromCString(const char* string) {
+    return string != NULL ?  [NSString stringWithUTF8String: string] : NULL;
+}

Libraries/com.unity.ads/Plugins/iOS/UnityAnalyticsWrapper.m

@@ -0,0 +1,31 @@
+#import <UnityAds/UANAApiAnalytics.h>
+#import "UnityAdsUtilities.h"
+
+typedef void (*UANAEngineTriggerAddExtras)(const char *payload);
+
+static UANAEngineTriggerAddExtras triggerAddExtras = NULL;
+
+void UANAEngineDelegateSetTriggerAddExtras(UANAEngineTriggerAddExtras trigger) {
+    triggerAddExtras = trigger;
+}
+
+@interface UANAEngineWrapper : NSObject <UANAEngineDelegate>
+@end
+
+@implementation UANAEngineWrapper
+- (void)addExtras:(NSString *)extras {
+    if (triggerAddExtras) {
+        const char * rawExtrasString = UnityAdsCopyString([extras UTF8String]);
+        triggerAddExtras(rawExtrasString);
+        free((void *)rawExtrasString);
+    }
+}
+@end
+
+void InitializeUANAEngineWrapper() {
+    static id<UANAEngineDelegate> delegate = nil;
+    if (delegate == nil) {
+        delegate = [[UANAEngineWrapper alloc] init];
+        [UANAApiAnalytics setAnalyticsDelegate:delegate];
+    }
+}

Libraries/com.unity.ads/Plugins/iOS/UnityBannerUnityWrapper.m

@@ -0,0 +1,140 @@
+#import <UnityAds/UADSBanner.h>
+#import "UnityAdsUtilities.h"
+
+typedef void (*UnityAdsBannerShowCallback)(const char* placementId);
+typedef void (*UnityAdsBannerHideCallback)(const char* placementId);
+typedef void (*UnityAdsBannerClickCallback)(const char* placementId);
+typedef void (*UnityAdsBannerUnloadCallback)(const char* placementId);
+typedef void (*UnityAdsBannerLoadCallback)(const char* placementId);
+typedef void (*UnityAdsBannerErrorCallback)(const char* message);
+
+static UnityAdsBannerShowCallback bannerShowCallback = NULL;
+static UnityAdsBannerHideCallback bannerHideCallback = NULL;
+static UnityAdsBannerClickCallback bannerClickCallback = NULL;
+static UnityAdsBannerErrorCallback bannerErrorCallback = NULL;
+static UnityAdsBannerLoadCallback bannerLoadCallback = NULL;
+static UnityAdsBannerUnloadCallback bannerUnloadCallback = NULL;
+
+static UIView* s_banner;
+static bool s_showAfterLoad;
+
+@interface UnityBannersUnityWrapper : NSObject<UnityAdsBannerDelegate>
+@end
+
+@implementation UnityBannersUnityWrapper
+- (void)unityAdsBannerDidError:(NSString *)message {
+    if (bannerErrorCallback != NULL) {
+        const char * rawMessage = UnityAdsCopyString([message UTF8String]);
+        bannerErrorCallback(rawMessage);
+        free((void *)rawMessage);
+    }
+}
+
+- (void)unityAdsBannerDidHide:(NSString *)placementId {
+    if (bannerHideCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        bannerHideCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+}
+
+-(void)unityAdsBannerDidClick:(NSString *)placementId {
+    if (bannerClickCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        bannerClickCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+}
+
+- (void)unityAdsBannerDidShow:(NSString *)placementId {
+    if (bannerShowCallback != NULL) {
+        const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        bannerShowCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+}
+
+- (void)unityAdsBannerDidLoad:(NSString *)placementId view:(UIView*)view {
+    s_banner = view;
+    const char * rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+    if (bannerLoadCallback != NULL) {
+        bannerLoadCallback(rawPlacementId);
+        free((void *)rawPlacementId);
+    }
+    if (s_showAfterLoad) {
+        s_showAfterLoad = false;
+        UIView *container = UnityGetGLViewController().view;
+        [container addSubview:s_banner];
+        bannerShowCallback(rawPlacementId);
+    }
+}
+
+- (void)unityAdsBannerDidUnload:(NSString *)placementId {
+}
+@end
+
+void UnityAdsBannerShow(const char * placementId, bool showAfterLoad) {
+    if (s_banner == nil) {
+        s_showAfterLoad = showAfterLoad;
+        if(placementId == NULL) {
+            [UnityAdsBanner loadBanner];
+        } else {
+            [UnityAdsBanner loadBanner:[NSString stringWithUTF8String:placementId]];
+        }
+    } else {
+        if (s_banner.superview == nil) {
+            UIView *container = UnityGetGLViewController().view;
+            [container addSubview:s_banner];
+            bannerShowCallback(placementId);
+        }
+    }
+}
+
+void UnityAdsBannerHide(bool shouldDestroy) {
+    if (shouldDestroy) {
+        [UnityAdsBanner destroy];
+        s_banner = nil;
+    } else {
+        if (s_banner != nil && s_banner.superview != nil) {
+            [s_banner removeFromSuperview];
+        }
+    }
+}
+
+bool UnityAdsBannerIsLoaded() {
+    return s_banner != nil;
+}
+
+void UnityAdsBannerSetPosition(int position) {
+    [UnityAdsBanner setBannerPosition:(UnityAdsBannerPosition)position];
+}
+
+void UnityAdsSetBannerShowCallback(UnityAdsBannerShowCallback callback) {
+    bannerShowCallback = callback;
+}
+
+void UnityAdsSetBannerHideCallback(UnityAdsBannerHideCallback callback) {
+    bannerHideCallback = callback;
+}
+
+void UnityAdsSetBannerClickCallback(UnityAdsBannerClickCallback callback) {
+    bannerClickCallback = callback;
+}
+
+void UnityAdsSetBannerErrorCallback(UnityAdsBannerErrorCallback callback) {
+    bannerErrorCallback = callback;
+}
+void UnityAdsSetBannerUnloadCallback(UnityAdsBannerUnloadCallback callback) {
+    bannerUnloadCallback = callback;
+}
+void UnityAdsSetBannerLoadCallback(UnityAdsBannerLoadCallback callback) {
+    bannerLoadCallback = callback;
+}
+
+void UnityBannerInitialize() {
+    static UnityBannersUnityWrapper* delegate = nil;
+    if (delegate == nil) {
+        delegate = [[UnityBannersUnityWrapper alloc] init];
+    }
+    [UnityAdsBanner setDelegate:delegate];
+}

Libraries/com.unity.ads/Plugins/iOS/UnityJsonAdditions.h

@@ -0,0 +1,19 @@
+#import <UnityAds/UPURTransactionDetails.h>
+#import <UnityAds/UPURTransactionErrorDetails.h>
+#import <UnityAds/UMONCustomEvent.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface UPURTransactionDetails (UnityJsonAdditions)
++(nullable instancetype)buildWithJson:(NSString *)json error:(NSError **)error;
+@end
+
+@interface UPURTransactionErrorDetails (UnityJsonAdditions)
++(nullable instancetype)buildWithJson:(NSString *)json error:(NSError **)error; 
+@end
+
+@interface UMONCustomEvent (UnityJsonAdditions)
++(nullable instancetype)buildWithJson:(NSString *)json error: (NSError **)error;
+@end
+
+NS_ASSUME_NONNULL_END

Libraries/com.unity.ads/Plugins/iOS/UnityJsonAdditions.m

@@ -0,0 +1,139 @@
+#import "UnityJsonAdditions.h"
+
+NSString *const NSUnityPurchasingTransactionDetailErrorDomain = @"NSUPURTransactionDetailErrorDomain";
+NSString *const NSUnityPurchasingTransactionErrorDetailErrorDomain = @"NSUPURTransactionErrorDetailErrorDomain";
+
+UPURTransactionError UPURTransactionErrorFromNSString(NSString *error) {
+    if (error) {
+        if ([error isEqualToString:@"NotSupported"]) {
+            return kUPURTransactionErrorNotSupported;
+        } else if ([error isEqualToString:@"Item_Unavailable"]) {
+            return kUPURTransactionErrorItemUnavailable;
+        } else if ([error isEqualToString:@"UserCancelled"]) {
+            return kUPURTransactionErrorUserCancelled;
+        } else if ([error isEqualToString:@"NetworkError"]) {
+            return kUPURTransactionErrorNetworkError;
+        } else if ([error isEqualToString:@"ServerError"]) {
+            return kUPURTransactionErrorServerError;
+        } else if ([error isEqualToString:@"UnknownError"]) {
+            return kUPURTransactionErrorUnknownError;
+        } else {
+            return kUPURTransactionErrorUnknownError;
+        }
+    } else {
+        return kUPURTransactionErrorUnknownError;
+    }
+}
+
+UPURStore UPURStoreFromNSString(NSString *store) {
+    if (store) {
+        if ([store isEqualToString:@"GooglePlay"]) {
+            return kUPURStoreGooglePlay;
+        } else if ([store isEqualToString:@"AmazonAppStore"]) {
+            return kUPURStoreAmazonAppStore;
+        } else if ([store isEqualToString:@"CloudMoolah"]) {
+            return kUPURStoreCloudMoolah;
+        } else if ([store isEqualToString:@"SamsungApps"]) {
+            return kUPURStoreSamsungApps;
+        } else if ([store isEqualToString:@"XiaomiMiPay"]) {
+            return kUPURStoreXiaomiMiPay;
+        } else if ([store isEqualToString:@"MacAppStore"]) {
+            return kUPURStoreMacAppStore;
+        } else if ([store isEqualToString:@"AppleAppStore"]) {
+            return kUPURStoreAppleAppStore;
+        } else if ([store isEqualToString:@"WinRT"]) {
+            return kUPURStoreWinRT;
+        } else if ([store isEqualToString:@"TizenStore"]) {
+            return kUPURStoreTizenStore;
+        } else if ([store isEqualToString:@"FacebookStore"]) {
+            return kUPURStoreFacebookStore;
+        } else if ([store isEqualToString:@"NotSpecified"]) {
+            return kUPURStoreNotSpecified;
+        } else {
+            return kUPURStoreNotSpecified;
+        }
+    } else {
+        return kUPURStoreNotSpecified;
+    }
+}
+
+@implementation UPURTransactionDetails (UnityJsonAdditions)
+// must check error before using object
++(instancetype)buildWithJson:(NSString *)json error:(NSError **)error {
+    id object = [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingAllowFragments error:error];
+    if (*error) {
+        NSLog(@"UPURTransactionDetails Unable to serialize from json: %@", [*error description]);
+        return nil;
+    } else if ([object isKindOfClass:[NSDictionary class]]) {
+        return [UPURTransactionDetails build:^(UPURTransactionDetailsBuilder *builder) {
+            NSDictionary *dictionary = (NSDictionary *) object;
+            builder.productId = [dictionary valueForKey:@"productId"];
+            builder.transactionId = [dictionary valueForKey:@"transactionId"];
+            builder.receipt = [dictionary valueForKey:@"receipt"];
+            builder.price = [dictionary valueForKey:@"price"];
+            builder.currency = [dictionary valueForKey:@"currency"];
+            id extras = [dictionary valueForKey:@"extras"];
+            if (![extras isKindOfClass:[NSNull class]]) {
+                builder.extras = extras;
+            }
+        }];
+    } else {
+        NSMutableDictionary *info = [NSMutableDictionary dictionary];
+        [info setValue:@"UPURTransactionDetails Expected json object to be a NSDictionary but it was not" forKey:@"Reason"];
+        *error = [NSError errorWithDomain:NSUnityPurchasingTransactionDetailErrorDomain code:1 userInfo:info];
+        return nil;
+    }
+}
+@end
+
+@implementation UPURTransactionErrorDetails (UnityJsonAdditions)
+// must check error before using object
++(instancetype)buildWithJson:(NSString *)json error:(NSError **)error {
+    id object = [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options: NSJSONReadingAllowFragments error:error];
+    if (*error) {
+        NSLog(@"UPURTransactionErrorDetails Unable to serialize from json: %@", [*error description]);
+        return nil;
+    } else if ([object isKindOfClass:[NSDictionary class]]) {
+        return [UPURTransactionErrorDetails build:^(UPURTransactionErrorDetailsBuilder *builder) {
+            NSDictionary *dictionary = (NSDictionary *) object;
+            builder.transactionError = UPURTransactionErrorFromNSString([dictionary valueForKey:@"transactionError"]);
+            builder.exceptionMessage = [dictionary valueForKey:@"exceptionMessage"];
+            builder.store = UPURStoreFromNSString([dictionary valueForKey:@"store"]);
+            builder.storeSpecificErrorCode = [dictionary valueForKey:@"storeSpecificErrorCode"];
+            id extras = [dictionary valueForKey:@"extras"];
+            if (![extras isKindOfClass:[NSNull class]]) {
+                builder.extras = extras;
+            }
+        }];
+    } else {
+        NSMutableDictionary *info = [NSMutableDictionary dictionary];
+        [info setValue:@"UPURTransactionErrorDetails Expected json object to be a NSDictionary but it was not" forKey:@"Reason"];
+        *error = [NSError errorWithDomain:NSUnityPurchasingTransactionErrorDetailErrorDomain code:1 userInfo:info];
+        return nil;
+    }
+}
+@end
+
+@implementation UMONCustomEvent (UnityJsonAdditions)
+// must check error before using object
++(instancetype)buildWithJson:(NSString *)json error: (NSError **)error {
+    id object = [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingAllowFragments error:error];
+    if (*error) {
+        NSLog(@"UMONCustomEvent Unable to serialize from json: %@", [*error description]);
+        return nil;
+    } else if ([object isKindOfClass:[NSDictionary class]]) {
+        return [UMONCustomEvent build:^(UMONCustomEventBuilder *builder) {
+            NSDictionary *dictionary = (NSDictionary *) object;
+            builder.category = [dictionary valueForKey:@"category"];
+            builder.type = [dictionary valueForKey:@"type"];
+            builder.userInfo = [dictionary valueForKey:@"userInfo"];
+        }];
+    } else {
+        NSMutableDictionary *info = [NSMutableDictionary dictionary];
+        [info setValue:@"UMONCustomEvent Expected json object to be a NSDictionary but it was not" forKey:@"Reason"];
+        *error = [NSError errorWithDomain:NSUnityPurchasingTransactionDetailErrorDomain code:1 userInfo:info];
+        return nil;
+    }
+}
+
+@end

Libraries/com.unity.ads/Plugins/iOS/UnityMonetizationDecisionWrapper.m

@@ -0,0 +1,177 @@
+#import <UnityAds/UnityMonetization.h>
+#import <Unity/UnityInterface.h>
+#import "UnityAdsUtilities.h"
+#import "UnityJsonAdditions.h"
+
+typedef void (*UnityMonetizationShowAdStartCallback)();
+typedef void (*UnityMonetizationShowAdFinishCallback)(int finishState);
+
+@interface UnityMonetizationUnityShowAdDelegate : NSObject<UMONShowAdDelegate>
+@property (nonatomic) UnityMonetizationShowAdStartCallback startCallback;
+@property (nonatomic) UnityMonetizationShowAdFinishCallback finishCallback;
+
+-(instancetype)initWithCallbacks:(UnityMonetizationShowAdStartCallback)startCallback finishCallback:(UnityMonetizationShowAdFinishCallback)finishCallback;
+@end
+
+@implementation UnityMonetizationUnityShowAdDelegate
+- (instancetype)initWithCallbacks:(UnityMonetizationShowAdStartCallback)startCallback finishCallback:(UnityMonetizationShowAdFinishCallback)finishCallback {
+    if (self = [super init]) {
+        self.startCallback = startCallback;
+        self.finishCallback = finishCallback;
+    }
+    return self;
+}
+-(void)unityAdsDidFinish:(NSString *)placementId withFinishState:(UnityAdsFinishState)finishState {
+    UnityPause(0);
+    if (self.finishCallback) {
+        self.finishCallback(finishState);
+    }
+}
+-(void)unityAdsDidStart:(NSString *)placementId {
+    if (self.startCallback) {
+        self.startCallback();
+    }
+}
+@end
+
+const ushort* Il2CppStringFromNSString(NSString* str) {
+    size_t len = str.length;
+    NSData* cStr = [str dataUsingEncoding:NSUTF16LittleEndianStringEncoding];
+    ushort* buffer = (ushort*)malloc(len * sizeof(ushort) + 1);
+    memset(buffer, 0, (len + 1) * sizeof(ushort));
+    [cStr getBytes:buffer length:len * sizeof(ushort)];
+    return buffer;
+}
+
+const ushort* serializeJsonToIl2CppString(NSDictionary* dict) {
+    NSError* error;
+    NSData* data = [NSJSONSerialization dataWithJSONObject:dict options:0 error:&error];
+    NSString* str = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+    if (data != nil) {
+        return Il2CppStringFromNSString(str);
+    }
+    return NULL;
+}
+
+NSDictionary* getJsonDictionaryFromItem(UMONItem* item) {
+    return @{
+             @"itemType": item.type ? item.type : [NSNull null],
+             @"productId": item.productId ? item.productId : [NSNull null],
+             @"quantity": @(item.quantity)
+    };
+}
+
+NSArray* getJsonArrayFromItemArray(NSArray<UMONItem*>* items) {
+    NSMutableArray* array = [[NSMutableArray alloc] init];
+    for (UMONItem* item in items) {
+        [array addObject:getJsonDictionaryFromItem(item)];
+    }
+    return [array copy];
+}
+
+BOOL isValidPrice(NSDecimalNumber* number) {
+    return number && ![number isEqualToNumber:[NSDecimalNumber notANumber]];
+}
+
+NSDictionary* getJsonDictionaryFromProduct(UPURProduct* product) {
+    return @{
+             @"productId": product.productId ? product.productId : [NSNull null],
+             @"localizedTitle": product.localizedTitle ? product.localizedTitle : [NSNull null],
+             @"localizedDescription": product.localizedDescription ? product.localizedDescription : [NSNull null],
+             @"localizedPriceString": product.localizedPriceString ? product.localizedPriceString : [NSNull null],
+             @"isoCurrencyCode": product.isoCurrencyCode ? product.isoCurrencyCode : [NSNull null],
+             @"localizedPrice": isValidPrice(product.localizedPrice) ? product.localizedPrice : [NSNull null],
+             @"productType": product.productType ? product.productType : [NSNull null]
+    };
+}
+
+NSDictionary* getPromoMetadataDictionary(UMONPromoMetaData* metadata) {
+    return @{
+             @"impressionDate": metadata.impressionDate ? @([metadata.impressionDate timeIntervalSince1970] * 1000) : [NSNull null],
+             @"offerDuration": @(metadata.offerDuration),
+             @"costs": getJsonArrayFromItemArray(metadata.costs),
+             @"payouts": getJsonArrayFromItemArray(metadata.payouts),
+             @"premiumProduct": getJsonDictionaryFromProduct(metadata.premiumProduct)
+    };
+}
+
+const ushort* serializePromoMetadataToJson(UMONPromoMetaData* metadata) {
+    NSDictionary* dict = getPromoMetadataDictionary(metadata);
+    return serializeJsonToIl2CppString([dict copy]);
+}
+
+
+
+bool UnityMonetizationPlacementContentIsReady(const void* pPlacementContent) {
+    UMONPlacementContent* placementContent = (__bridge UMONPlacementContent*)pPlacementContent;
+    return placementContent.ready;
+}
+
+bool UnityMonetizationPlacementContentSendCustomEvent(const void* pPlacementContent, const ushort* customEventJson) {
+    NSString *customEventJsonString = NSStringFromIl2CppString(customEventJson);
+    NSError *error = nil;
+    UMONCustomEvent *event = [UMONCustomEvent buildWithJson:customEventJsonString error:&error];
+    if (error) {
+        // do nothing
+        NSLog(@"UnityMonetizationPlacementContentSendCustomEvent error occurred : %@", [error description]);
+        return false;
+    } else if (event) {
+        // make sure details is non-null
+        UMONPlacementContent* placementContent = (__bridge UMONPlacementContent*)pPlacementContent;
+        [placementContent sendCustomEvent:event];
+        return true;
+    } else {
+        NSLog(@"UnityMonetizationPlacementContentSendCustomEvent was not able to send event");
+        return false;
+    }
+}
+
+const ushort* UnityMonetizationGetPlacementContentExtras(const void* pPlacementContent) {
+    if (pPlacementContent) {
+        UMONPlacementContent* placementContent = (__bridge UMONPlacementContent*) pPlacementContent;
+        NSDictionary* dict = placementContent.userInfo;
+        if (dict != nil) {
+            return serializeJsonToIl2CppString(dict);
+        }
+    }
+    return NULL;
+}
+
+bool UnityMonetizationPlacementContentIsRewarded(const void* pPlacementContent) {
+    UMONRewardablePlacementContent* placementContent = (__bridge UMONRewardablePlacementContent*)pPlacementContent;
+    return placementContent.rewarded;
+}
+
+const ushort* UnityMonetizationPlacementContentGetRewardId(const void* pPlacementContent) {
+    UMONRewardablePlacementContent* placementContent = (__bridge UMONRewardablePlacementContent*)pPlacementContent;
+    return Il2CppStringFromNSString(placementContent.rewardId);
+}
+
+void UnityMonetizationPlacementContentShowAd(const void* pPlacementContent, UnityMonetizationShowAdStartCallback startCallback, UnityMonetizationShowAdFinishCallback finishCallback) {
+    UMONShowAdPlacementContent* placementContent = (__bridge UMONShowAdPlacementContent*)pPlacementContent;
+    UnityPause(1);
+    [placementContent show:UnityGetGLViewController() withDelegate:[[UnityMonetizationUnityShowAdDelegate alloc] initWithCallbacks:startCallback finishCallback:finishCallback]];
+}
+
+const ushort* UnityMonetizationGetPromoAdMetadata(const void* pPlacementContent) {
+    if (pPlacementContent) {
+        UMONPromoAdPlacementContent* placementContent = (__bridge UMONPromoAdPlacementContent*)pPlacementContent;
+        return serializePromoMetadataToJson(placementContent.metadata);
+    }
+    return NULL;
+}
+
+const char* UnityMonetizationGetPlacementContentType(const void* pPlacementContent) {
+    UMONPlacementContent* placementContent = (__bridge UMONPlacementContent*)pPlacementContent;
+    // NOTE: il2cpp will free this pointer after invocation!
+    return UnityAdsCopyString([placementContent.type UTF8String]);
+}
+
+int UnityMonetizationGetPlacementContentState(const void* pPlacementContent) {
+    UMONPlacementContent* placementContent = (__bridge UMONPlacementContent*)pPlacementContent;
+    return placementContent.state;
+}
+
+void UnityMonetizationPlacementContentReleaseReference(const void* pPlacementContent) {
+    CFBridgingRelease(pPlacementContent);
+}

Libraries/com.unity.ads/Plugins/iOS/UnityMonetizationNativePromoAdapterWrapper.m

@@ -0,0 +1,36 @@
+#import <UnityAds/UnityMonetization.h>
+#import "UnityJsonAdditions.h"
+
+const void* UnityMonetizationCreateNativePromoAdapter(const void* pPlacementContent) {
+    if (pPlacementContent) {
+        UMONPromoAdPlacementContent* placementContent = (__bridge UMONPromoAdPlacementContent*)pPlacementContent;
+        UMONNativePromoAdapter* adapter = [[UMONNativePromoAdapter alloc] initWithPromo:placementContent];
+        return CFBridgingRetain(adapter);
+    }
+    return NULL;
+}
+
+void UnityMonetizationReleaseNativePromoAdapter(const void* pPlacementContent) {
+    CFBridgingRelease(pPlacementContent);
+}
+
+void UnityMonetizationNativePromoAdapterOnShown(const void* pNativePromoAdapter, int showType) {
+    if (pNativePromoAdapter) {
+        UMONNativePromoAdapter* adapter = (__bridge UMONNativePromoAdapter*)pNativePromoAdapter;
+        [adapter promoDidShow:(UMONNativePromoShowType)showType];
+    }
+}
+
+void UnityMonetizationNativePromoAdapterOnClicked(const void* pNativePromoAdapter) {
+    if (pNativePromoAdapter) {
+        UMONNativePromoAdapter* adapter = (__bridge UMONNativePromoAdapter*)pNativePromoAdapter;
+        [adapter promoDidClick];
+    }
+}
+
+void UnityMonetizationNativePromoAdapterOnClosed(const void* pNativePromoAdapter) {
+    if (pNativePromoAdapter) {
+        UMONNativePromoAdapter* adapter = (__bridge UMONNativePromoAdapter*)pNativePromoAdapter;
+        [adapter promoDidClose];
+    }
+}

Libraries/com.unity.ads/Plugins/iOS/UnityMonetizationPurchasingAdapter.m

@@ -0,0 +1,146 @@
+#import <UnityAds/USRVUnityPurchasing.h>
+
+#import "UnityAdsUtilities.h"
+#import "UnityJsonAdditions.h"
+
+struct UnityPurchasingProduct {
+    const ushort* productId;
+    const ushort* localizedTitle;
+    const ushort* localizedDescription;
+    const ushort* localizedPriceString;
+    const ushort* isoCurrencyCode;
+    const ushort* productType;
+    double localizedPrice;
+};
+
+struct UnityPurchasingPurchaseCallbacks {
+    const void* completionHandler;
+    const void* errorHandler;
+};
+
+// Callback called to C# that handles retrieiving the products.
+// It is assumed that pDelegate will be the same delegate passed into
+// UnityPurchasingInvokeRetrieveProductsCallback.
+typedef void (*UnityPurchasingOnRetrieveProductsCallback)(const void *pDelegate);
+UnityPurchasingOnRetrieveProductsCallback unityPurchasingOnRetrieveProductsCallback;
+
+// Callback called to C# that handles the purchasing flow.
+// It is assumed that pDelegate will be the same delegate passed into
+// UnityPurchasingInvokeTransactionCompleteCallback and
+// UnityPurchasingInvokeTransactionErrorCallback
+typedef void (*UnityPurchasingOnPurchaseCallback)(const char *productId, struct UnityPurchasingPurchaseCallbacks* callbacks);
+UnityPurchasingOnPurchaseCallback unityPurchasingOnPurchaseCallback;
+
+struct UnityPurchasingAdapterCallbacks {
+    UnityPurchasingOnRetrieveProductsCallback unityPurchasingOnRetrieveProductsCallback;
+    UnityPurchasingOnPurchaseCallback unityPurchasingOnPurchaseCallback;
+};
+
+@interface UnityPurchasingAdapterDelegate : NSObject <USRVUnityPurchasingDelegate>
+@end
+
+@implementation UnityPurchasingAdapterDelegate
+-(void)loadProducts:(void (^)(NSArray<UPURProduct*> *products))completionHandler {
+    unityPurchasingOnRetrieveProductsCallback(CFBridgingRetain(completionHandler));
+}
+-(void)purchaseProduct:(NSString *)productId completionHandler:(UnityPurchasingTransactionCompletionHandler)completionHandler errorHandler:(UnityPurchasingTransactionErrorHandler)errorHandler userInfo:(nullable NSDictionary *)extras {
+    struct UnityPurchasingPurchaseCallbacks* callbacks;
+    callbacks->completionHandler = CFBridgingRetain(completionHandler);
+    callbacks->errorHandler = CFBridgingRetain(errorHandler);
+    unityPurchasingOnPurchaseCallback([productId UTF8String], callbacks);
+}
+
+@end
+
+static id <USRVUnityPurchasingDelegate> unityPurchasingAdapterDelegate;
+/**
+* Sets the callbacks for invoking purchasing adapter functionality into C#.
+*/
+void UnityPurchasingSetPurchasingAdapterCallbacks(struct UnityPurchasingAdapterCallbacks *callbacks) {
+    unityPurchasingOnRetrieveProductsCallback = callbacks->unityPurchasingOnRetrieveProductsCallback;
+    unityPurchasingOnPurchaseCallback = callbacks->unityPurchasingOnPurchaseCallback;
+    if (unityPurchasingAdapterDelegate == NULL) {
+        unityPurchasingAdapterDelegate = [[UnityPurchasingAdapterDelegate alloc] init];
+        [USRVUnityPurchasing setDelegate:unityPurchasingAdapterDelegate];
+    }
+}
+
+/**
+* Allocates a fixed sized array to be returned as a pointer to C#.
+*/
+const void *UnityPurchasingAdapterAllocateProductsArray(int num) {
+    NSMutableArray *array = [NSMutableArray arrayWithCapacity:num];
+    return CFBridgingRetain(array);
+}
+
+/**
+* Appends the given product to the end of the product array.
+*/
+void UnityPurchasingAddItemToProductsArray(const void *pArray, struct UnityPurchasingProduct *pProduct) {
+    NSMutableArray *array = (__bridge NSMutableArray *) pArray;
+    UPURProduct *product = [UPURProduct build:^(UPURProductBuilder* builder) {
+        builder.productId = NSStringFromIl2CppString(pProduct->productId);
+        builder.localizedTitle = NSStringFromIl2CppString(pProduct->localizedTitle);
+        builder.localizedDescription = NSStringFromIl2CppString(pProduct->localizedDescription);
+        builder.localizedPriceString = NSStringFromIl2CppString(pProduct->localizedPriceString);
+        builder.isoCurrencyCode = NSStringFromIl2CppString(pProduct->isoCurrencyCode);
+        builder.productType = NSStringFromIl2CppString(pProduct->productType);
+        builder.localizedPrice = [[NSDecimalNumber alloc] initWithDouble:pProduct->localizedPrice];
+    }];
+    [array addObject:product];
+}
+
+/**
+* Invokes the given retrieve products delegate with the given products.
+*/
+void UnityPurchasingInvokeRetrieveProductsCallback(const void *pDelegate, const void *pProducts) {
+    if (pDelegate != NULL && pProducts != NULL) {
+        NSArray *products = (__bridge NSArray *) pProducts;
+        UnityPurchasingLoadProductsCompletionHandler completionHandler = (__bridge UnityPurchasingLoadProductsCompletionHandler)pDelegate;
+        completionHandler(products);
+        CFBridgingRelease(pDelegate);
+        CFBridgingRelease(pProducts);
+    }
+}
+
+/**
+* Invokes the given transaction delegate's complete callback with the given details
+*/
+void UnityPurchasingInvokeTransactionCompleteCallback(struct UnityPurchasingPurchaseCallbacks* callbacks, ushort* transactionDetailsJson) {
+    if (callbacks != NULL && transactionDetailsJson != NULL) {
+        NSString *transactionDetailsJsonString = NSStringFromIl2CppString(transactionDetailsJson);
+        NSError *error = nil;
+        UPURTransactionDetails *details = [UPURTransactionDetails buildWithJson:transactionDetailsJsonString error:&error];
+        if (error) {
+            // do nothing
+        } else if (details) {
+            // make sure details is non-null
+            UnityPurchasingTransactionCompletionHandler handler = (__bridge UnityPurchasingTransactionCompletionHandler)(callbacks->completionHandler);
+            handler(details);
+        }
+        CFBridgingRelease(callbacks->completionHandler);
+        CFBridgingRelease(callbacks->errorHandler);
+        free(callbacks);
+    }
+}
+
+/**
+* Invokes the given transaction delegate's error callback with the given error and message.
+*/
+void UnityPurchasingInvokeTransactionErrorCallback(struct UnityPurchasingPurchaseCallbacks* callbacks, ushort* transactionErrorDetailsJson) {
+    if (callbacks != NULL && transactionErrorDetailsJson != NULL) {
+        NSString *transactionErrorDetailsJsonString = NSStringFromIl2CppString(transactionErrorDetailsJson);
+        NSError *error = nil;
+        UPURTransactionErrorDetails *details = [UPURTransactionErrorDetails buildWithJson: transactionErrorDetailsJsonString error:&error];
+        if (error) {
+            // do nothing
+        } else if (details) {
+            // make sure details is non-null
+            UnityPurchasingTransactionErrorHandler handler = (__bridge UnityPurchasingTransactionErrorHandler)(callbacks->errorHandler);
+            handler(details);
+        }
+        CFBridgingRelease(callbacks->completionHandler);
+        CFBridgingRelease(callbacks->errorHandler);
+        free(callbacks);
+    }
+}

Libraries/com.unity.ads/Plugins/iOS/UnityMonetizationUnityWrapper.m

@@ -0,0 +1,82 @@
+#import <UnityAds/UnityMonetization.h>
+#import "UnityAdsUtilities.h"
+#import <UnityAds/UnityServices.h>
+#import "UnityAdsPurchasingWrapper.h"
+
+/**
+ * Callback invoked into C# when a decision state has changed.
+ */
+typedef void (*UnityMonetizationPlacementContentStateChangedCallback)(const char *placementId, const void *pDecision, int newState, int oldState);
+static UnityMonetizationPlacementContentStateChangedCallback unityMonetizationPlacementContentStateChangedCallback = NULL;
+
+/**
+ * Callback invoked into C# when a decision is ready.
+ */
+typedef void (*UnityMonetizationPlacementContentReadyCallback)(const char *placementId, const void *pDecision);
+static UnityMonetizationPlacementContentReadyCallback unityMonetizationPlacementContentReadyCallback = NULL;
+
+/**
+ * Callback invoked into C# when an error occurred
+ */
+typedef void (*UnityMonetizationErrorCallback)(long err, const char* message);
+static UnityMonetizationErrorCallback unityMonetizationErrorCallback = NULL;
+
+struct UnityMonetizationMonetizationCallbacks {
+    UnityMonetizationPlacementContentReadyCallback unityMonetizationDecisionReadyCallback;
+    UnityMonetizationPlacementContentStateChangedCallback unityMonetizationDecisionStateChangedCallback;
+    UnityMonetizationErrorCallback unityMonetizationErrorCallback;
+};
+
+static id<UnityMonetizationDelegate> monetizationDelegate = nil;
+
+@interface UnityMonetizationUnityDecisionDelegate : NSObject<UnityMonetizationDelegate>
+@end
+
+@implementation UnityMonetizationUnityDecisionDelegate
+-(void)placementContentReady:(NSString *)placementId placementContent:(UMONPlacementContent *)decision {
+    if (unityMonetizationPlacementContentReadyCallback != NULL) {
+        const char* rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        // Note, we are bridging instead of retaining as we don't need to track the lifecycle of this
+        // object in C#. When the decision is replaced, ready will be called and C# will be notified.
+        unityMonetizationPlacementContentReadyCallback(rawPlacementId, CFBridgingRetain(decision));
+        free((void*)rawPlacementId);
+    }
+}
+-(void)placementContentStateDidChange:(NSString *)placementId placementContent:(UMONPlacementContent *)placementContent previousState:(UnityMonetizationPlacementContentState)previousState newState:(UnityMonetizationPlacementContentState)newState {
+    if (unityMonetizationPlacementContentStateChangedCallback != NULL) {
+        const char* rawPlacementId = UnityAdsCopyString([placementId UTF8String]);
+        unityMonetizationPlacementContentStateChangedCallback(rawPlacementId, (__bridge void*)placementContent, previousState, newState);
+        free((void*)rawPlacementId);
+    }
+}
+-(void)unityServicesDidError:(UnityServicesError)error withMessage:(NSString *)message {
+    if (unityMonetizationErrorCallback != NULL) {
+        const char* rawError = UnityAdsCopyString([message UTF8String]);
+        unityMonetizationErrorCallback(error, rawError);
+        free((void*)rawError);
+    }
+}
+
+@end
+
+void UnityMonetizationSetMonetizationCallbacks(struct UnityMonetizationMonetizationCallbacks *callbacks) {
+    unityMonetizationPlacementContentStateChangedCallback = callbacks->unityMonetizationDecisionStateChangedCallback;
+    unityMonetizationPlacementContentReadyCallback = callbacks->unityMonetizationDecisionReadyCallback;
+    unityMonetizationErrorCallback = callbacks->unityMonetizationErrorCallback;
+    if (monetizationDelegate == nil) {
+        monetizationDelegate = [[UnityMonetizationUnityDecisionDelegate alloc] init];
+    }
+}
+
+void UnityMonetizationInitialize(const char *gameId, bool isTestMode) {
+    InitializeUnityAdsPurchasingWrapper();
+    [UnityMonetization initialize:[NSString stringWithUTF8String:gameId] delegate:monetizationDelegate testMode:isTestMode];
+}
+
+bool UnityMonetizationIsReady(const char* placementId) {
+    return [UnityMonetization isReady:[NSString stringWithUTF8String:placementId]];
+}
+
+bool UnityMonetizationIsSupported() {
+    return [UnityServices isSupported];
+}