---
description: Integrate AppOpen Ads
---

# AppOpen (Google)

App open ads are a special fullscreen ad format (created by Google) intended for publishers wishing to monetize their app loading screens (“splash screens”). App open ads can be closed at any time, and are designed to be shown when your users bring your app to the foreground.

### Create Placement <a href="#create-placement" id="create-placement"></a>

You need to create the AppOpen placement as soon as the app becomes active in the `applicationDidBecomeActive()` method in your `AppDelegate`.

To create an instance of [AATAppOpenAdPlacement](https://ios-sdk.aatkit.com/references/documentation/aatkit/aatappopenadplacement), use the following API:

{% tabs %}
{% tab title="Swift" %}
```swift
var placement = AATSDK.createAppOpenAdPlacement(placementName: "<PLACEMENT_NAME>")
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
id<AATAppOpenAdPlacement> placement = [AATSDK createAppOpenAdPlacementWithPlacementName:@"<PLACEMENT_NAME>"];
```
{% endtab %}
{% endtabs %}

### Listen to Callbacks (Optional) <a href="#listen-to-callbacks-optional" id="listen-to-callbacks-optional"></a>

Through the use of [AATAppOpenPlacementDelegate](https://ios-sdk.aatkit.com/references/documentation/aatkit/aatappopenplacementdelegate), you can listen to the different placement callbacks.

{% tabs %}
{% tab title="Swift" %}
```swift
placement.delegate = self
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
placement.delegate = self;
```
{% endtab %}
{% endtabs %}

### Request Ad (In AppDelegate)

After creating the placement you need to start placement auto-reloading to get an ad as soon as possible.

{% tabs %}
{% tab title="Swift" %}
```swift
func applicationDidBecomeActive(_ application: UIApplication) {
    // Start loading Ads as soon as app become active
    guard let placement = self.placement else { return }
    
    // Set placement viewController
    AATSDK.controllerViewDidAppear(controller: <ROOT_VIEW_CONTROLLER>)
    
    // Start placement autoreloading
    placement.startAutoReload()
}
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
-(void)applicationDidBecomeActive:(UIApplication *)application {
    // Start loading Ads as soon as app become active
    // Set placement viewController
    [AATSDK controllerViewDidAppearWithController: <ROOT_VIEW_CONTROLLER>];

    // Start placement autoreloading
    [self.placement startAutoReload];
}
```
{% endtab %}
{% endtabs %}

### Request Ad (In Loading Screen)

App Open Placement is meant to monetize your App Loading screen, so the most proper place to display the Ad is in your own `LoadingViewController`, so while the user is waiting for your App to be ready to use. If AATKit has successfully obtained an Ad you should display it before sending the user to the main content. To do so you will need your `LoadingViewController` to conform to the `AATAppOpenPlacementDelegate` protocol:

{% tabs %}
{% tab title="Swift" %}
```swift
class LoadingViewController: UIViewController {
    // Create the placement
    var placement = AATSDK.createAppOpenAdPlacement(name: "<PLACEMENT_NAME>")
 
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        
        // [IMPORTANT] Notify AATKit about the currently active view controller
        AATSDK.controllerViewDidAppear(controller: self)
        
        // Set placement delegate to listen to the callbacks
        placement.delegate = self
        
        // Start autoreloading the placement.
        placement.startAutoReload()
    }
    
    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        // [IMPORTANT] Remove the currently active view controller
        AATSDK.controllerViewWillDisappear()
        // [IMPORTANT] Stop placement autoreload
        placement?.stopAutoReload()
    }
}

extenstion LoadingViewController: AATAppOpenPlacementDelegate {
    func aatHaveAd(placement: AATPlacement) {
        // The placement has loaded a new ad
    }

    func aatNoAd(placement: AATPlacement) {
        // The placement could not load a new ad
    }
    
    func aatAdCurrentlyDisplayed(placement: AATPlacement) {
        // Ad has been displayed on the screen
    }

    func aatResumeAfterAd(placement: AATPlacement) {
        // Back to the app
    }
}
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
@interface LoadingViewController () <AATAppOpenPlacementDelegate>
@property (nonatomic, getter=fullscreenPlacement, readonly) id<AATAppOpenPlacement> placement;
@end

@implementation LoadingViewController
- (void)viewDidAppear:(BOOL)animated {
    [super viewDidAppear:animated];
    
    // [IMPORTANT] Notify AATKit about the currently active view controller
    [AATSDK controllerViewDidAppearWithController:self];
    
    // Create the placement
    self.placement = [AATSDK createAppOpenAdPlacementWithPlacementName:@"<PLACEMENT_NAME>"];
    
    // Set placement delegate to listen to the callbacks
    self.placement.delegate = self;
    
    // Start autoreloading the placement.
    [self.placement startAutoReload];
}

- (void)viewWillDisappear:(BOOL)animated {
    [super viewWillDisappear:animated];
    // [IMPORTANT] Remove the currently active view controller
    [AATSDK controllerViewWillDisappear];
    // [IMPORTANT] Stop placement autoreload
    [self.placement stopAutoReload];
}

#pragma mark - AATAppOpenPlacementDelegate
- (void)aatHaveAdWithPlacement:(id<AATPlacement> _Nonnull)placement {
    // The placement has loaded a new ad
}

- (void)aatNoAdWithPlacement:(id<AATPlacement> _Nonnull)placement {
    // The placement could not load a new ad
}

- (void)aatAdCurrentlyDisplayedWithPlacement:(id<AATPlacement> _Nonnull)placement {
    // Ad has been displayed on the screen
}

- (void)aatResumeAfterAdWithPlacement:(id<AATPlacement> _Nonnull)placement {
    // Back to the app
}
```
{% endtab %}
{% endtabs %}

After the user closes the Ad you should send the user to your app's main content, you will get notified when the fullscreen ad is closed in `func aatResumeAfterAd(placement: AATPlacement)` delegate method.

### Display Ad

You should display that ad at the start of the app session by calling `show()` method. If the AppOpen placement has a ready ad, It will present it.

{% tabs %}
{% tab title="Swift" %}
```swift
placement.show()
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
[self.placement show];
```
{% endtab %}
{% endtabs %}

### Complete Code Example

{% tabs %}
{% tab title="Swift" %}
```swift
@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    var window: UIWindow?

    var placement = AATSDK.createAppOpenAdPlacement(placementName: "<PLACEMENT_NAME>")
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        // AATKit initialization
        let configuration = AATConfiguration()
        AATSDK.initAATKit(with: configuration)
        return true
    }
    
    func applicationDidBecomeActive(_ application: UIApplication) {
        // Start loading Ads as soon as app become active
        guard let placement = self.placement else { return }
        
        // Pass the root view controller to AATKit
        AATSDK.controllerViewDidAppear(controller: <ROOT_VIEW_CONTROLLER>)
        
        // Start placement autoreloading
        placement.startAutoReload()
        
        // display loaded ad if available
        placement.show()
    }
    
    func applicationWillResignActive(_ application: UIApplication) {
        // disable placement autoreloading
        placement?.stopAutoreloading()
    }
}
```
{% endtab %}

{% tab title="Objective-C" %}
```objectivec
@interface AppDelegate ()
@property id<AATAppOpenAdPlacement> placement;
@end

@implementation AppDelegate


- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    AATConfiguration *conf = [[AATConfiguration alloc] init];
    [AATSDK initAATKitWith:conf];

    self.placement = [AATSDK createAppOpenAdPlacementWithPlacementName:@"<PLACEMENT_NAME>"];
    return YES;
}

- (void)applicationDidBecomeActive:(UIApplication *)application {

    // Set placement viewController
    [AATSDK controllerViewDidAppearWithController:<ROOT_VIEW_CONTROLLER>];

    // Start placement autoreloading
    [self.placement startAutoReload];

    // display loaded ad if available
    [self.placement show];
}

@end
```
{% endtab %}
{% endtabs %}

### Loading Screen

The above code example assumes that you only show app open ads when users foreground your app after it is suspended in memory. So, if the user launches the app either for the first time since booting or after killing the application, the app will never have a ready ad.

In this case, it’s preferred to use a loading screen (that might be used to load your assets) and only show the ad from the loading screen (Only if the ad is ready and the loading screen is still active) to avoid surprising the user with an ad while using your app.

If you have a loading screen under the app open ad, and your loading screen completes loading before the ad is dismissed, you may want to dismiss your loading screen in the `func aatResumeAfterAd()` callback of the `AATAppOpenPlacementDelegate`.
