---
description: Add, import, and configure AATKit
---

# Initialization

### Configure AATKit

Before loading ads, the app must initialize AATKit first. This only needs to be done once per app session, ideally at the app launch. You should call the `AATKit.init(configuration)` as early as possible in order to ensure optimal ad performance. We advise doing it in your application's `onCreate` method.

Call the initialization method with an [AATKitConfiguration](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit-configuration/index.html) instance which contains the necessary configuration data needed to initialize AATKit. Through [AATKit.Delegate](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit/-delegate/index.html), you can listen to AATKit callbacks such as obtaining mediation rules from the backend or unknown bundleID events.

{% tabs %}
{% tab title="Java" %}
```java
AATKitConfiguration configuration = new AATKitConfiguration(this);
configuration.setDelegate(this); //optional, pass the implementation of AATKit.Delegate to listen to callbacks
AATKit.init(configuration);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
val configuration = AATKitConfiguration(this)
configuration.delegate = this //optional, pass the implementation of AATKit.Delegate to listen to callbacks
AATKit.init(configuration)
```
{% endtab %}
{% endtabs %}

### Handling Activity lifecycle

It is required to pass the Activity lifecycle events to AATKit before starting to request ads from placements. You should override `onResume()` and `onPause()` methods in every Activity of your app.

{% hint style="warning" %}
Make sure to only pass lifecycle events of Activities belonging to your application. Using ActivityLifecycleCallbacks and passing lifecycle callbacks for also ad Activities (like the ones belonging to ad networks and used for presenting fullscreen ads) will cause issues.
{% endhint %}

{% hint style="info" %}
Placements will not start loading ads before having the current activity passed to AATKit.
{% endhint %}

**Notify about activity resume**

{% tabs %}
{% tab title="Java" %}
```java
@Override
protected void onResume() {
    super.onResume();
    AATKit.onActivityResume(this);
}
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
override protected fun onResume() {
    super.onResume()
    AATKit.onActivityResume(this)
}
```
{% endtab %}
{% endtabs %}

**Notify about activity pause**

{% tabs %}
{% tab title="Java" %}
```java
@Override
protected void onPause() {
    AATKit.onActivityPause(this);
    super.onPause();
}
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
override protected fun onPause() {
    AATKit.onActivityPause(this)
    super.onPause()
}
```
{% endtab %}
{% endtabs %}

### Reconfigure AATKit

AATKit enables reconfiguring it at runtime. This might be needed for some cases like reacting to consent changes or geo-location settings changes. To reconfigure AATKit, use the reconfigure public API passing an instance of [AATKitRuntimeConfiguration](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit-runtime-configuration/index.html).

{% tabs %}
{% tab title="Java" %}
```java
AATKitRuntimeConfiguration newConfiguration = new AATKitRuntimeConfiguration();
newConfiguration.setConsentRequired(true);
newConfiguration.setConsent(new SimpleConsent(NonIABConsent.OBTAINED));
newConfiguration.setUseGeoLocation(true);
AATKit.reconfigure(newConfiguration);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
val newConfiguration = AATKitRuntimeConfiguration()
newConfiguration.isConsentRequired = true
newConfiguration.consent = SimpleConsent(NonIABConsent.OBTAINED)
newConfiguration.isUseGeoLocation = true
AATKit.reconfigure(newConfiguration)
```
{% endtab %}
{% endtabs %}

### Test Mode

AATKit’s test mode provides ads even before your app has been set up at Gravite. This is convenient for testing your integration. Please use your `testModeAccountId` to activate the test mode. Set the `testModeAccountId` in your [AATKitConfiguration](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit-configuration/index.html) object. The `testModeAccountId` will be sent to you via email after registering at [Gravite](https://dashboard.gravite.net/register).

{% tabs %}
{% tab title="Java" %}
```java
AATKitConfiguration configuration = new AATKitConfiguration(this);
configuration.setDelegate(this);
configuration.setTestModeAccountId(<TEST_MODE_ID>);
AATKit.init(configuration);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
val configuration = AATKitConfiguration(this)
configuration.delegate = this
configuration.setTestModeAccountId(<TEST_MODE_ID>)
AATKit.init(configuration)
```
{% endtab %}
{% endtabs %}

{% hint style="info" %}
Make sure to remove the `testModeAccountId` from your `AATConfiguration` object, before you publish your app to the AppStore. Otherwise, your app will not earn any ad revenue.
{% endhint %}

### Using an Alternative bundle ID

Gravite recognises and identifies your app using its bundle ID. Should you need to use a different bundle ID for publishing or testing or other purposes, you can override the default bundle ID of your app by setting an "alternative bundle ID" for the [AATKitConfiguration](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit-configuration/index.html) object. But: before you can use the alternative bundle ID properly, please make sure that our [support](mailto:support@addapptr.com) has set up your app for the alternative bundle ID, as this is not a standard procedure.

AATKit will do dashboard reporting using your alternative bundle ID by default if you set it.&#x20;

If for any reason reporting should still be done using your app's real bundle ID, you can set the `shouldReportUsingAlternativeBundleId` property of the [AATKitConfiguration](https://android-sdk.aatkit.com/references/-a-a-t-kit/com.intentsoftware.addapptr/-a-a-t-kit-configuration/index.html) object to false.

{% tabs %}
{% tab title="Java" %}
<pre class="language-java"><code class="lang-java">configuration.setAlternativeBundleId("com.alternativeBundleId");

// if you still need to report on the physical bundleID call this:
<strong>// configuration.setShouldReportUsingAlternativeBundleId(false); 
</strong></code></pre>
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
configuration.setAlternativeBundleId("com.alternativeBundleId")

// if you still need to report on the physical bundleID call this:
// configuration.isShouldReportUsingAlternativeBundleId = false
```
{% endtab %}
{% endtabs %}

{% hint style="info" %}
If you decided to use an alternative bundle ID, please get in touch with our [support](mailto:support@addapptr.com).
{% endhint %}

### Log Levels

AATKit supports the following log levels:

**Verbose**

Verbose-level messages are intended to capture **verbose**, **debug**, **info**, **warning** and **error** messages. It’s convenient in an intensive development environment.

{% tabs %}
{% tab title="Java" %}
```java
AATKit.setLogLevel(Log.VERBOSE);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
AATKit.setLogLevel(Log.VERBOSE)
```
{% endtab %}
{% endtabs %}

**Debug**

Debug-level messages are intended to capture **debug**, **info**, **warning** and **error** messages. It’s convenient in a normal development environment.

{% tabs %}
{% tab title="Java" %}
```java
AATKit.setLogLevel(Log.DEBUG);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
AATKit.setLogLevel(Log.DEBUG)
```
{% endtab %}
{% endtabs %}

**Info**

Info-level messages are intended to capture **info**, **warning** and **error** messages. Info-level may be helpful but isn’t enough for troubleshooting.

{% tabs %}
{% tab title="Java" %}
```java
AATKit.setLogLevel(Log.INFO);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
AATKit.setLogLevel(Log.INFO)
```
{% endtab %}
{% endtabs %}

**Warn**

Warn-level messages are intended to capture **warning** and **error** messages only.

{% tabs %}
{% tab title="Java" %}
```java
AATKit.setLogLevel(Log.WARN);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
AATKit.setLogLevel(Log.WARN)
```
{% endtab %}
{% endtabs %}

**Error**

Error-level messages are intended to capture **error** messages only.

{% tabs %}
{% tab title="Java" %}
```java
AATKit.setLogLevel(Log.ERROR);
```
{% endtab %}

{% tab title="Kotlin" %}
```kotlin
AATKit.setLogLevel(Log.ERROR)
```
{% endtab %}
{% endtabs %}

#### Obtaining debug logs in already built apps <a href="#markdown-header-obtaining-debug-logs" id="markdown-header-obtaining-debug-logs"></a>

If you would want to obtain more debug logs from AATKit without recompiling the app, paste the following line:

```
adb shell setprop log.tag.AATKit VERBOSE
```

into the terminal when your testing device is attached. You can also choose different log level, like DEBUG.
