Step 2: Basic Integration

How to use AppConsentUnified

1. Get your AppKey

On AppConsent configuration interface https://app.appconsent.io, create your unified SDK source.

Then create your notice and retrieve your generated YOUR_APP_KEY

2. Initialise AppConsentUnified

The second step is to initialise the SDK Our AppConsentUnified iOS SDK supports the following target:

iOS, (iPhone, iPad and macOS through mac Catalyst) minimum deployment target 13.0

Our AppConsentUnified framework is built in Swift and UIKit, and supported integration within a Swift and Objective-C app. It is possible to use within a SwiftUI app following various approaches (one of them is in the example below)

INFO AppConsentUnified SDK supports the new App Tracking Transparency framework (> iOS 14+ available). You must register the NSUserTrackingUsageDescription key in your Info.plist of your application otherwise your app will crash. See App Tracking Transparency for details.

INFO

In the example below, the code focuses on using the SDK exclusively.

import AppConsentUnified

class ExampleViewController: UIViewController {

   // AppConsent Object
    private(set) var appConsent: ACNotice!
    
    override func viewDidLoad() {
        super.viewDidLoad()
       
        self.appConsent = ACNotice(withAppKey: "YOUR_APP_KEY")
                
        // Present CMP when you need it (it can after some internal logic on your end not necessarely here as the example shows)
        self.appConsent.presentNotice(viewController: self)
    }
}

INFO In the example below, the code focuses on using the SDK exclusively.

First import our Swift header declaration

#import <AppConsentUnified/AppConsentUnified-Swift.h>
#import <AppConsentUnified/ACNotice.h>

If you are mixing Swift + Objective-C you will need to important as well your "App-Swift.h" file. For example:

#import "YourAppModule-Swift.h"

Once this is done, here below a basic implementation:

#import <UIKit/UIKit.h>
#import <AppConsentUnified/ACNotice.h>
#import <AppConsentUnified/AppConsentUnified-Swift.h>

NS_ASSUME_NONNULL_BEGIN
@interface ExampleObjcViewController : UIViewController
@end
NS_ASSUME_NONNULL_END

Create a property ACNotice in your implementation file (.m)

#import "ExampleObjcViewController.h"

@interface ExampleObjcViewController ()
@property(nonatomic, strong) ACNotice *appConsent;
@end

@implementation ExampleObjcViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // initialise notice
    self.appConsent = [[ACNotice alloc] initWithAppKey:@"YOUR_APP_KEY"];
    // Present Notice
    [self.appConsent presentNoticeWithViewController:self];
}
@end

INFO Our SDK is developed with UIKit therefore it requires some adjustments for SwiftUI. For this example below we showcased an integration using top keyWindow. In order to achieve it, some extension class have been created. You can other ways of integrating our SDK, for example using UIViewRepresentable.

(Optional) First create a ViewModel in order to encapsulate all business logic from our SDK into a view model that conform to observable protocol. Later this object will be use within the view

final class AppConsentViewModel: ObservableObject {
    
    private(set) var appConsent: ACNotice

    init(ac: ACNotice) {
        self.appConsent = ac
    }
    
    func presentNotice() {
        if let rootVC = UIApplication.shared.keyWindow?.rootViewController {
            appConsent.presentNotice(viewController: rootVC)
        } else {
            noticeError = NSError(domain: "your_bundle_id", 
            code: 999, // Choose your internal code if needed
            userInfo: [
            NSLocalizedFailureReasonErrorKey: 
            "Unable to present notice, keyWindow is nil"
            ])
        }
    }
}

(Optional) If you are using Scene Delegate or Scenes, then (if not already done on your end) create a small extension in order to be able to grab the proper keyWindow.

extension UIApplication {
    var keyWindow: UIWindow? {
        if #available(iOS 15.0, *) {
            return connectedScenes
                .compactMap { $0 as? UIWindowScene }
                .first(where: { $0.activationState == .foregroundActive })?
                .windows
                .first(where: { $0.isKeyWindow })
        } else {
            // iOS 13–14 fallback
            return windows.first { $0.isKeyWindow }
        }
    }
}

Your final View should looks like this and is fully implemented

import SwiftUI
import AppConsentUnified

struct ContentView: View {
    @StateObject private var appConsentViewModel: AppConsentViewModel
    
    init(appConsentViewModel: AppConsentViewModel) {
        self._appConsentViewModel = StateObject(wrappedValue: appConsentViewModel)
    }
    var body: some View {
        VStack {
            // YOUR VIEW ELEMENTS
            Text("My View")
        }.onAppear {
            let appConsent = ACNotice(withAppKey: "YOUR_APP_KEY")
            // present notice
            appConsentViewModel.presentNotice()
        }
    }
}

PreviousStep 1: Get Started NextStep 3: Advanced Integration

Last updated 2 months ago