API reference

Complete API documentation for Amply SDK.

Core Classes

Amply

The main SDK class for tracking events and managing campaigns.

Android

class Amply(config: AmplyConfig, application: Application)

iOS

---

Methods

track

Tracks a custom event with optional properties.

Signature

Android

fun track(event: String, properties: Map<String, Any> = emptyMap())

iOS

Parameters

Parameter	Type	Description
event	String	The event name
properties	Map<String, Any>	Optional event properties

Example

amply.track("purchase_completed", mapOf(
    "product_id" to "SKU123",
    "price" to 29.99,
    "currency" to "USD"
))

---

registerDeepLinkListener

Registers a listener for deep link actions from campaigns.

Signature

Android

fun registerDeepLinkListener(listener: DeepLinkListener)

iOS

Parameters

Parameter	Type	Description
listener	DeepLinkListener	Callback for deep link events

DeepLinkListener Interface

interface DeepLinkListener {
    fun onDeepLink(url: String, info: Map<String, Any>): Boolean
}

Returns true if the deep link was handled, false otherwise.

---

setSystemEventsListener

Registers a listener for SDK system events.

Signature

Android

fun setSystemEventsListener(listener: SystemEventsListener)

iOS

SystemEventsListener Interface

interface SystemEventsListener {
    fun onEvent(event: EventInterface)
}

System Events

Event Name	Description
SDK_INITIALIZED	SDK initialization complete
SESSION_START	New session started
SESSION_END	Session ended
CAMPAIGNS_LOADED	Campaigns fetched from server

---

getRecentEvents

Retrieves recent events from local storage.

Signature

Android

suspend fun getRecentEvents(limit: Int = 30): List<EventInterface>

iOS

Parameters

Parameter	Type	Default	Description
limit	Int	30	Maximum events to return

Returns

List of EventInterface objects, newest first.

---

getDataSetSnapshot

Retrieves a snapshot of a dataset for debugging or preview.

Signature

Android

suspend fun getDataSetSnapshot(type: DataSetType): Map<String, Any>

iOS

Parameters

Parameter	Type	Description
type	DataSetType	The dataset type to retrieve

---

Configuration

AmplyConfig

Configuration class for SDK initialization.

Android (DSL)

val config = amplyConfig {
    api {
        appId = "your.app.id"
        apiKeyPublic = "your_public_key"
        apiKeySecret = "your_secret_key"
    }
    defaultConfig = null  // Optional JSON string
    network {
        configBaseUrl = "https://config.amply.tools"
        backendBaseUrl = "https://api.amply.tools"
    }
}

iOS

let config = AmplyConfig(
    appId: String,
    apiKeyPublic: String,
    apiKeySecret: String,
    defaultConfig: String?,
    configBaseUrl: String?,
    backendBaseUrl: String?
)

Properties

Property	Type	Required	Description
appId	String	Yes	Application identifier
apiKeyPublic	String	Yes	Public API key
apiKeySecret	String	Yes	Secret API key
defaultConfig	String?	No	Default campaign config JSON
configBaseUrl	String?	No	Config server URL override
backendBaseUrl	String?	No	Backend server URL override

---

Data Types

DataSetType

Sealed class representing dataset types for rule evaluation.

sealed class DataSetType {
    object Device : DataSetType()
    object User : DataSetType()
    object Session : DataSetType()
    data class TriggeredEvent(
        val eventName: String?,
        val params: List<Param>,
        val countStrategy: CountStrategy
    ) : DataSetType()
    data class Events(val data: List<Event>) : DataSetType()

    companion object {
        fun fromString(value: String, params: Map<String, Any> = emptyMap()): DataSetType?
    }
}

Creating DataSetType (iOS)

// Device
let deviceType = DataSetType.Companion.shared.fromString(value: "@device", params: [:])

// Session
let sessionType = DataSetType.Companion.shared.fromString(value: "@session", params: [:])

// Triggered Event
let eventType = DataSetType.Companion.shared.fromString(
    value: "@triggeredEvent",
    params: ["eventName": "purchase_completed"]
)

// Events
let eventsType = DataSetType.Companion.shared.fromString(value: "@events", params: [:])

---

EventInterface

Interface representing an event.

interface EventInterface {
    val name: String
    val timestamp: Long
    val properties: Map<String, Any>
    val type: EventType
}

Properties

Property	Type	Description
name	String	Event name
timestamp	Long	Unix timestamp (milliseconds)
properties	Map<String, Any>	Event properties
type	EventType	Event type (CUSTOM or SYSTEM)

---

EventType

Enum representing event types.

enum class EventType {
    CUSTOM,
    SYSTEM
}

---

Dataset Schemas

@device

Device properties collected by the SDK.

Property	Type	Description
platform	String	"Android" or "iOS"
model	String	Device model
osVersion	String	OS version
idfa	String?	Advertising ID (if available)
idfv	String?	Vendor ID (iOS only)
appVersion	String	App version
sdkVersion	String	SDK version
nowTs	Long	Server-synced timestamp

@session

Session properties.

Property	Type	Description
counter	Int	Total session count

@triggeredEvent

Event that triggered rule evaluation.

Property	Type	Description
name	String	Event name
counter	Int	Event count (based on strategy)
globalCounter	Int	All-time event count
sessionCounter	Int	Session event count
params	List<Map>	Event parameters
type	String	"custom" or "system"
lastTriggeredTs	Long?	Last trigger timestamp

@events

Historical event data.

Property	Type	Description
data	List<Map>	Array of event records

Each event record contains:

• name: Event name

• counter: Global count

• sessionCounter: Session count

• params: Parameters

• type: Event type

---

Constants

SDK Version

AmplySDKInterface.VERSION  // e.g., "1.0.0"

---

Error Handling

Android

try {
    val data = amply.getDataSetSnapshot(DataSetType.Device)
} catch (e: IllegalStateException) {
    // SDK not initialized
}

iOS

do {
    let data = try await amply.getDataSetSnapshot(type: deviceType)
} catch {
    print("Error: \(error)")
}

---

Thread Safety

• All public SDK methods are thread-safe

• Async methods should be called from appropriate contexts (coroutines on Android, async/await on iOS)

• Listeners may be called on background threads