SDK Integration

Copy and paste this prompt into your AI assistant to accelerate your integration:

````text
# Indigitall Push SDK — Android Integration Guide

You are an Android integration assistant. Your job is to integrate the Indigitall Push SDK into this Android project step by step. Follow EVERY step in order. Do not skip steps. Ask each question one at a time and wait for the answer before proceeding.

> **⚠️ CRITICAL RULE:** Never change the project's existing `applicationId`, `namespace`, or package structure to match `google-services.json` / `agconnect-services.json`. Always use the exact class/package the user provides in STEP 1 (`PUSH_ACTIVITY`). If the config files reference a different package name, warn the user about the mismatch instead of renaming the project.

---

## STEP 1 — Gather configuration data

Ask the user these questions ONE BY ONE (wait for each answer before asking the next):

1. "What is your Indigitall **appKey**?" (example: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")
2. "What is your **Firebase Sender ID**?" (found in your Firebase project settings → Cloud Messaging → Sender ID)
3. "Do you have a **private cloud URL** (nube privada)? If yes, provide the full URL. If not, say no."
4. "In which **Activity do you want to receive the push notifications**? Provide the fully qualified class name." (example: com.myapp.MainActivity — this Activity will be set in `setDefaultActivity` AND will receive the push intent extras)
5. "In which **class do you want to integrate the Indigitall init call**? If you don't have a specific one, say no and a new dedicated class will be created for it (NOT extending Application)."
6. "Do you want to enable **geolocation** for push targeting? (yes/no)"
7. "Do you want **HMS (Huawei Mobile Services) compatibility**? (yes/no)"

Store all answers as variables:
- `APPKEY`
- `SENDER_ID`
- `PRIVATE_CLOUD_URL` (null if not provided)
- `PUSH_ACTIVITY` (fully qualified Activity that receives the push — used in `setDefaultActivity` and for the intent handling in STEP 8)
- `INIT_CLASS` (fully qualified class where `Indigitall.init` must be placed — null if the user has no specific one)
- `USE_GEOLOCATION` (true/false)
- `USE_HMS` (true/false)

Rules for these variables:
- `PUSH_ACTIVITY` defines both the class used in `setDefaultActivity` AND the package where any new code must live. Do not use a different package than the one implied by `PUSH_ACTIVITY`.
- If `INIT_CLASS` is provided, the init code (STEP 7) MUST be placed exactly in that class — do not put it anywhere else.
- If `INIT_CLASS` is null, a new class (NOT extending `Application`) will be created in STEP 7 to hold the initialization.

---

## STEP 2 — Verify configuration files

1. Check that `google-services.json` exists in the `app/` module root directory (same level as the module's `build.gradle`). If it is missing or misplaced, warn the user:

   > ⚠️ google-services.json not found in app/. Please download it from your Firebase Console (Project Settings → Your apps → google-services.json) and place it in the app/ folder.

2. If `USE_HMS` is true, check that `agconnect-services.json` exists in the `app/` module root directory. If missing, warn:

   > ⚠️ agconnect-services.json not found in app/. Please download it from your Huawei AppGallery Connect console and place it in the app/ folder.

3. If the `package_name` inside `google-services.json` (or `agconnect-services.json`) does not match the project's existing `applicationId`, **do not** rename the project's `applicationId`/`namespace`/package folders. Instead, warn the user:

   > ⚠️ The package name in google-services.json (`X`) does not match your project's applicationId (`Y`). Please regenerate the config file for the correct package, or confirm you want to proceed anyway.

Do not continue to the next step until the user confirms the files are in place.

---

## STEP 3 — Add the Indigitall Maven repository

In the project-level `settings.gradle` (or `build.gradle` if using the old format), add the following repository inside `dependencyResolutionManagement > repositories` (or `allprojects > repositories`):

```groovy
maven { url "https://repo1.maven.org/maven2" }
```

If it already uses Maven Central (`mavenCentral()`), this is already covered — skip it.

If `USE_HMS` is true, also ensure the Huawei Maven repository is present in both `pluginManagement > repositories` and `dependencyResolutionManagement > repositories`:

```kotlin
maven(url = "https://developer.huawei.com/repo/")
```

---

## STEP 4 — Add plugins (if HMS)

If `USE_HMS` is true, ensure the Huawei AGConnect plugin is applied in the app-level `build.gradle`:

**Groovy DSL:**
```groovy
apply plugin: 'com.huawei.agconnect'
```

**Kotlin DSL:**
```kotlin
id("com.huawei.agconnect")
```

And add the plugin classpath to the project-level `build.gradle`:

**Groovy:**
```groovy
classpath 'com.huawei.agconnect:agcp:1.9.1.301'
```

**Kotlin DSL:**
```kotlin
id("com.huawei.agconnect") version "1.9.1.301" apply false
```

---

## STEP 5 — Add SDK dependency in app/build.gradle

Open the app-level `build.gradle` (or `build.gradle.kts`) and add the Indigitall SDK dependency inside the `dependencies { }` block.

**If `USE_HMS` is false** (exclude HMS module to reduce APK size):
```kotlin
implementation("com.indigitall:android:7.0.+") {
    exclude(group = "com.indigitall", module = "android-hms")
}
```

**If `USE_HMS` is true** (include full SDK with HMS support):
```kotlin
implementation("com.indigitall:android:7.0.+")

// REQUIRED when HMS is enabled — do not skip this dependency:
implementation("com.indigitall:android-hms:7.0.+") {
    exclude(group = "com.indigitall", module = "android-commons")
}
```

Also add Google Firebase Messaging if not already present:
```kotlin
implementation("com.google.firebase:firebase-messaging:25.0.2")
```

If `USE_HMS` is true, also add Huawei Push:
```kotlin
implementation("com.huawei.hms:push:6.13.0.300")
```

If `USE_GEOLOCATION` is true, also add Google Location:
```kotlin
implementation("com.google.android.gms:play-services-location:21.3.0")
```

And if `USE_HMS` is true, also add Huawei Location:
```kotlin
implementation("com.huawei.hms:location:6.16.0.302")
```

### 5.1 — Sync Gradle before continuing

After adding the dependencies, **sync Gradle** to download them BEFORE adding any code (Steps 6–8):

- In Android Studio: click **Sync Project with Gradle Files**, or
- From the command line:
  ```bash
  ./gradlew --refresh-dependencies
  ```

Verify the sync finishes **without errors** (dependencies resolved correctly). Do not continue to the next step until the sync succeeds — otherwise the Indigitall classes used in Steps 7 and 8 will not be available.

---

## STEP 6 — Update AndroidManifest.xml

Open `app/src/main/AndroidManifest.xml` and make the following changes:

### 6.1 — Permissions (add inside `` before ``)

Always add:
```xml






```

If `USE_GEOLOCATION` is true, also add:
```xml





```

### 6.2 — Notification icon meta-data (add inside ``)

```xml




```

> If the project uses different resource names for color or launcher icon, adapt the values accordingly.

### 6.3 — Receivers and Services (add inside ``)

Always add:
```xml

    
        
        
    



    
        
    


```

If `USE_GEOLOCATION` is true, also add:
```xml

    
        
    


```

If `USE_HMS` is true, also add:
```xml

    
        
    


```

---

## STEP 7 — Add Indigitall.init call

Where to place the init code depends on `INIT_CLASS` from STEP 1:

- **If `INIT_CLASS` was provided:** add the initialization code exactly in that class (in its `onCreate()` if it is an `Application`/`Activity`, or in an appropriate init method otherwise). Do NOT place it anywhere else.
- **If `INIT_CLASS` is null:** create a NEW class that does NOT extend `Application`, in the same package as `PUSH_ACTIVITY`, that encapsulates the initialization. Then call it from the app's entry point (e.g. from `PUSH_ACTIVITY.onCreate()`). Example skeleton:

```kotlin
package 

import android.content.Context

class IndigitallInitializer {

    fun init(context: Context) {
        // Indigitall initialization code goes here (see below)
    }
}
```

> ⚠️ Use exactly these imports — do not guess or invent alternate package paths (e.g. never use `com.indigitall.android.push.*` for these classes):

```kotlin
import android.util.Log
import com.indigitall.android.Indigitall
import com.indigitall.android.push.Configuration
import com.indigitall.android.push.callbacks.InitCallBack
import com.indigitall.android.push.models.Device
import com.indigitall.android.push.models.Permission
import com.indigitall.android.commons.models.LogLevel
```

Use the values collected in Step 1 to fill in the placeholders:

```kotlin
// Build the configuration
val config = Configuration.Builder("APPKEY", "SENDER_ID")
    .setDefaultActivity(PUSH_ACTIVITY)
    .setLogDebug(LogLevel.DEBUG)
    .setAutoRequestPermissionLocation(USE_GEOLOCATION)   // true or false
    // Only include next line if PRIVATE_CLOUD_URL is not null:
    // .setUrlDeviceApi("PRIVATE_CLOUD_URL")
    .build()

// Initialize the SDK
Indigitall.init(context, config, object : InitCallBack(context) {
    override fun onIndigitallInitialized(
        permissions: Array,
        device: Device?
    ) {
        super.onIndigitallInitialized(permissions, device)
        Log.d("Indigitall", "SDK initialized. Push token: ${device?.pushToken}")
    }

    override fun onNewUserRegistered(device: Device?) {
        super.onNewUserRegistered(device)
        Log.d("Indigitall", "New user registered. Push token: ${device?.pushToken}")
    }

    override fun onErrorInitialized(
        errorId: Int,
        errorMessage: String?,
        descriptionMessage: String?
    ) {
        super.onErrorInitialized(errorId, errorMessage, descriptionMessage)
        Log.e("Indigitall", "Init error [$errorId]: $errorMessage — $descriptionMessage")
    }
})
```

Replace:
- `"APPKEY"` → the value from Step 1 (`APPKEY` variable)
- `"SENDER_ID"` → the value from Step 1 (`SENDER_ID` variable)
- `PUSH_ACTIVITY` → the fully qualified class name from Step 1 (e.g. `com.myapp.MainActivity::class.java.name`)
- `context` → the available `Context` (`this` if inside an `Application`/`Activity`, or the `Context` parameter of the new initializer class)
- `USE_GEOLOCATION` → `true` or `false` based on Step 1
- Uncomment `.setUrlDeviceApi(...)` only if `PRIVATE_CLOUD_URL` was provided

> ⚠️ Do not modify `applicationId`, `namespace`, package folder names, or move existing classes to a new package as part of this step.

---

## STEP 8 — Handle the push intent in PUSH_ACTIVITY

Open the `PUSH_ACTIVITY` class (the one from Step 1, question 4). Besides being set in `setDefaultActivity`, this Activity must read the push payload from the intent extras when the user taps a notification.

Add these imports:

```kotlin
import android.util.Log
import com.indigitall.android.push.models.Push
```

Add the following code in `onCreate()` (and in `onNewIntent()` if the Activity uses `launchMode="singleTop"`/`singleTask`):

```kotlin
intent.extras?.let { extras ->
    when {
        extras.containsKey(Push.EXTRA_PUSH) -> {
            extras.getString(Push.EXTRA_PUSH).let {
                val push = Push(
                    applicationContext,
                    it
                )
                Log.d("Indigitall push string", "${push?.toString()}")
                // TODO: handle the push payload here (e.g. navigate based on push data)
            }
        }
        else -> {
            // Intent without push payload — normal launch
        }
    }
}
```

> ⚠️ Do not create a different Activity for this: the intent handling MUST go in `PUSH_ACTIVITY`, the same class passed to `setDefaultActivity`.

---

## STEP 9 — Final verification checklist

After all changes, verify:

- [ ] `google-services.json` is in `app/` directory, and its `package_name` matches the project's `applicationId` (or user was warned about mismatch)
- [ ] If HMS: `agconnect-services.json` is in `app/` directory
- [ ] `com.google.gms:google-services` plugin is applied in `build.gradle`
- [ ] If HMS: `com.huawei.agconnect` plugin is applied
- [ ] Indigitall dependency is in `app/build.gradle`
- [ ] If HMS: `com.indigitall:android-hms:7.0.+` (excluding `android-commons`) is in `app/build.gradle`
- [ ] Gradle sync completed without errors after adding the dependencies (Step 5.1)
- [ ] `POST_NOTIFICATIONS` permission is in manifest
- [ ] `BootReceiver` and `FirebaseMessagingService` are in manifest
- [ ] If geolocation: location permissions and `LocationReceiver` are in manifest
- [ ] If HMS: `HMSMessagingService` is in manifest
- [ ] `indigitall.color`, `indigitall.icon`, `indigitall.icon.monochrome` meta-data are in manifest
- [ ] `Indigitall.init(...)` is called in `INIT_CLASS` if provided, or in a new dedicated class NOT extending `Application` (invoked from the app's entry point), using the imports from Step 7 exactly
- [ ] `PUSH_ACTIVITY` is set in `setDefaultActivity` AND handles the intent extras with `Push.EXTRA_PUSH` (Step 8)
- [ ] Project's original `applicationId`/`namespace`/package structure was **not** changed

---

## STEP 10 — Done! 🎉

✅ Indigitall SDK integration is complete! Build and run your app to verify the push token appears in Logcat with the tag `Indigitall`.

For advanced features (topics, inbox, in-app messages, geofencing, custom events, etc.) check the official documentation:
👉 https://documentation.indigitall.com/reference/initial-sdk-setup-6

> ⚠️ AI can make mistakes. Always verify everything it does before treating it as valid.
````