benshi.ai Android SDK

dependencies {
// Benshi SDK
implementation 'ai.benshi.android.sdk:1.0.0'

//LifecycleComponents
implementation 'androidx.lifecycle:lifecycle-process:2.3.1'
}

class MyApplication : Application(), LifecycleObserver {

    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get()
            .lifecycle.addObserver(this) // to observe Application lifecycle events

        BenshiLog.init(applicationContext, appSDKToken) //init SDK with your SDK token
        registerActivityLifecycleCallbacks(AppLifecycleTracker(applicationContext))

    }
}

/*
In onAppStop() function include the following function to dispatch WorkManager to update app events collected offline or isUpdateImmediately false
*/

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onAppStop() {
        BenshiLog.updateAppEvents(applicationContext) //this line
    }

<receiver android:name="ai.benshi.android.benshi_ingest.nudge.NudgeActionReceiver" />
<receiver android:name="ai.benshi.android.benshi_ingest.nudge.NotificationOnCancelBroadcastReceiver" />
<receiver android:name="ai.benshi.android.benshi_ingest.nudge.NotificationOnClickBroadcastReceiver" />
<receiver android:name="ai.benshi.android.benshi_ingest.nudge.GetNotificationService">
    <intent-filter>
        <action android:name="android.net.conn.CONNECTIVITY_CHANGE" />
    </intent-filter>
</receiver>

val userObjectSDK = UserRegisterObject(
            userId, //String
            country, //String
            region, //String
            district, //String
            city, //String

/*
Using function pattern, make sure to call `updateUserId` function before identity to update user id for logs
*/

BenshiLog.updateUserId(
    appSDKToken, // Required  - String - Token
    userId, // Required  - String
    context //Required - Context
    )

BenshiLog.track(
    context //Required - Context
    EventType.identify, // Required
    IdentifyType.register.name, // Required
    userRegisterObject // Optional  - UserRegisterObject
    )

/*
Using the Builder pattern, you don't need to call the `updateUserId` function as SDK will manage that.
*/

BenshiLogIdentifyEvent.Builder()
    .init(this) //Required -  Context
    .setAppSdkToken(appSDKToken) //Required - String
    .setAppUserId(userId) //Required String
    .setIdentifyType(IdentifyType.register) //Required
    .setCountry(country) //Optional - String
    .setRegionState(region) //Optional - String
    .setCity(city) //Optional - String
    .setDistrict(district) //Optional - String
    .build()

/*
You can also set use the Log event as:
*/

BenshiLogIdentifyEvent.Builder()
    .init(this) //Required -  Context
    .setAppSdkToken(appSDKToken) //Required - String
    .setAppUserId(userId) //Required String
    .setIdentifyType(IdentifyType.register) //Required
    .setUserRegisterObject(userObjectSDK) //Optional - UserRegisterObject
    .build()

/*
Using function pattern, make sure to call `updateUserId` function before identity to update user id for logs
*/

BenshiLog.updateUserId(appSDKToken, userId, this)
BenshiLog.track(this, EventType.identify, IdentifyType.login.name, null)


/*
Using the Builder pattern, you don't need to call the `updateUserId` function as SDK will manage that.
*/

BenshiLogIdentifyEvent.Builder()
    .init(this) //Required -  Context
    .setAppSdkToken(appSDKToken) //Required - String
    .setAppUserId(userId) //Required - String
    .setIdentifyType(IdentifyType.login) //Required
    .build()

/*
Using function pattern, make sure to use the SDK defined `PageObject` for mapping elements.
*/

val pageObject = PageObject(
    activity.packageName, // Required - String
    activity.localClassName, // Required - String
    duration, // Required - Double - Time in Nanoseconds user spend on that screen/activity/page
    meta, //Optional - Any [object, String, Int]
    )

BenshiLog.track(
    context, // Required - Context
    EventType.page, // Required
    activity.localClassName, // Required - String
    pageObject, // Required
    updateImmediately = false // Optional
    )

/*
Using the Builder pattern, you don't need to use the `PageObject` function as SDK will manage that.
*/

BenshiLogPageEvent.Builder()
    .init(context) //Required -  Context
    .setPageName(activity.localClassName) // Required - String
    .setPath(activity.packageName) // Required - String
    .setTitle(activity.localClassName) // Required - String
    .setDuration(sessionLength.toDouble()) // Required - Double - Time in Nanoseconds, user spend on that screen/activity/page
    .updateImmediately(false) //Optional - Boolean
    .setMeta(meta) //Optional - Any [object, String, Int]
    .build()

/*
Using function pattern, make sure to use the SDK defined `LevelObject` for mapping elements.
*/

val levelObject = LevelObject(
    levelNumber, //Required - Int
    meta //Optional - Any [object, String, Int]
    )

BenshiLog.track(
    context, //Required -  Context
    EventType.level, //Required
    eventName, //Required -  String
    levelObject //Required,
    )

/*
Using the Builder pattern, you don't need to use the `LevelObject` function as SDK will manage that.
*/

BenshiLogLevelEvent.Builder()
    .init(context) //Required -  Context
    .setLevelName(levelName) // Required - String
    .setLevelNumber(levelNumber) // Required - Int
    .setTitle(activity.localClassName) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, make sure to use the SDK defined `AttemptObject` for mapping elements.
*/
val attemptObject = AttemptObject(
    awardID, //Required - String
    success, //Required - Boolean
    meta //Optional - Any [object, String, Int]
    )

 BenshiLog.track(
    context, //Required -  Context
    EventType.attempt, //Required
    eventName, //Required - String
    attemptObject //Required
    )

/*
Using the Builder pattern, you don't need to use the `AttemptObject` function as SDK will manage that.
*/

BenshiLogAttemptEvent.Builder()
    .init(context) //Required -  Context
    .setAttemptName(attemptName) // Required - String
    .setAwardId(awardId) // Required - String
    .setSuccess(isSuccessful) // Required - Boolean
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, make sure to use the SDK defined `AwardObject` for mapping elements.
*/

val awardObject = AwardObject(
    awardID, //Required - String
    meta //Optional - Any [object, String, Int]
    )

 BenshiLog.track(
    context, //Required -  Context
    EventType.award, //Required
    eventName, //Required - String
    awardObject //Required
    )

/*
Using the Builder pattern, you don't need to use the `AttemptObject` function as SDK will manage that.
*/

BenshiLogAwardEvent.Builder()
    .init(context) //Required -  Context
    .setAwardName(awardName) // Required - String
    .setAwardId(awardId) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, make sure to use the SDK defined `PurchaseObject` for mapping elements.
*/
 val purchaseObject = PurchaseObject(
    price, //Required - Double
    currency, //Required - String
    purchaseId, //Required - String
    meta //Optional - Any [object, String, Int]
    )

BenshiLog.track(
    context, //Required -  Context
    EventType.purchase, //Required
    eventName, //Required - String
    purchaseObject //Required
)


/*
Using the Builder pattern, you don't need to use the `PurchaseObject` function as SDK will manage that.
*/

BenshiLogPurchaseEvent.Builder()
    .init(context) //Required -  Context
    .setItemName(purchaseItemName) // Required - String
    .setPrice(price) // Required - Double
    .setCurrency(currency) // Required - String
    .setItemId(itemId) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

val startScroll = ScrollUtil.getScrollViewPercentageInt(articleScrollView, //Required - scrollView
isStartScrollValue // Required - Boolean (For starting point set to 'true')
)

val endScroll = ScrollUtil.getScrollViewPercentageInt(articleScrollView, //Required - scrollView
isStartScrollValue // Required - Boolean (For end point set to 'false')
)


/*
Using function pattern, make sure to use the SDK defined `ScrollObject` for mapping elements.
*/

val scrollObject = ScrollObject(
    startScroll.toDouble(), //Required - Double
    endScroll.toDouble(), //Required - Double
    sessionLength.toDouble() //Required - Double - Time in nanoseconds
    )

BenshiLog.track(
    context, //Required -  Context
    EventType.scroll, //Required
    eventName, //Required - String
    scrollObject, //Required
    updateImmediately = false // Optional - Boolean
    )

/*
Using the Builder pattern, you don't need to use the `ScrollObject` function as SDK will manage that.
*/

BenshiLogScrollEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setStartPercentage(startScroll) // Required - Double
    .setEndPercentage(endScroll) // Required - Double
    .setDuration(sessionLength) // Required - Double
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, make sure to use the SDK defined `MessageObject` for mapping elements.
*/

val messageObject = MessageObject(
    notificationId, //Required - String
    MessageType.push, //Required - MessageType.push, MessageType.in_app
    title, //Required - String
    content, //Required - String
    "en", //Required - String - Language
    messageActionList //Optional - ArrayList<MessageActionObject>
    )

BenshiLog.track(
    context, //Required -  Context
    EventType.message, //Required
    eventName, //Required - String
    messageObject //Required
    )


/*
Using the Builder pattern, you don't need to use the `MessageObject` function as SDK will manage that.
*/

BenshiLogMessageEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setMessageId(messageId) // Required - String
    .setMessageType(MessageType.push) // Required - Required - MessageType.push, MessageType.in_app
    .setMessageTitle(title) // Required - String
    .setMessageContent(content) // Required - String
    .setMessageLanguage(language) // Required - String
    .addMessageActions(messageActionsObject) // Optional - MessageActionsObject
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
MessageActionsObject is used to store title for notification Action buttons (if any)
*/
val messageActionsObject = MessageActionsObject(
    title //Required - String
)

/*
Using the function pattern, make sure to use the SDK defined `MessageReactionObject` for mapping elements.
*/

val messageReactionObject = MessageReactionObject(
    messageId, //Required - String
    messageAction, //Required - String
    meta //Optional - Any [object, String, Int]
    )

 BenshiLog.track(
    context, //Required -  Context
    EventType.message_action, //Required
    eventName, //Required - String
    messageReactionObject, //Required
    updateImmediately  //Optional - Boolean
    )

/*
Using the Builder pattern, you don't need to use the `MessageReactionObject` function as SDK will manage that.
*/

BenshiLogMessageActionsEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setMessageId(messageId) // Required - String
    .setMessageAction(messageAction) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, make sure to use the SDK defined `MediaObject` for mapping elements.
*/

val mediaObject = MediaObject(
    mediaId, //Required - String
    MediaType.video, //Required - MediaType.video, MediaType.audio
    MediaAction.start, //Required
    duration //Required - Double
    meta //Optional - Any [object, String, Int]
    )

BenshiLog.track(
    context, //Required -  Context
    EventType.media, //Required
    eventName, //Required - String
    mediaObject //Required
    )

/*
Using the Builder pattern, you don't need to use the `MediaObject` function as SDK will manage that.
*/

BenshiLogMediaEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setMediaId(mediaId) // Required - String
    .setMediaType(MediaType.video) //Required - MediaType.video, MediaType.audio
    .setMediaAction(MediaAction.start) // Required - MediaAction
    .setTime(time) // Required - Double
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

start, // Start playing media
pause, // Pause media playing
seek, // When user seeks the controller
finish, // Media finishes playing
playing, // Media is playing , auto play
stop, // User stopped playing, change in context
delete, // User deletes media
download, // User downloads media

/*
Using function pattern, make sure to use the SDK defined `InteractObject` for mapping elements.
*/

val interactObject = InteractObject(
    InteractType.click, //Required - click, doubleclick, long press, swipe
    eventName, //Required - String
    meta //Optional - Any [object, String, Int]
    )

 BenshiLog.track(
    context, //Required -  Context
    EventType.interact, //Required
    eventName, //Required - String
    interactObject, //Required
    updateImmediately  //Optional - Boolean
    )

/*
Using the Builder pattern, you don't need to use the `InteractObject` function as SDK will manage that.
*/

BenshiLogInteractEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setActionType(InteractType.click) //Required - click, doubleclick, long press, swipe
    .setElementName(elementName) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

/*
Using function pattern, You can log custom interact details by passing your own params in the meta section.
*/

BenshiLog.track(
    context, //Required -  Context
    EventType.track, //Required
    eventName, //Required - String
    meta, //Optional - Any [object, String, Int]
    updateImmediately  //Optional - Boolean
    )

/*
Using the Builder pattern, you can track events. To log any specific data with a Track event you can use meta to log that. with .setMeta you can log any data type, object, string, integer or any other data Type. Another way is to use hashmap for key separated data.
*/

BenshiLogTrackEvent.Builder()
    .init(context) //Required -  Context
    .setEventName(eventName) // Required - String
    .setMeta(meta) //Optional - Any [object, String, Int]
    .updateImmediately(false) //Optional - Boolean
    .build()

val hashMap:HashMap<String, Any> = HashMap<String,Any>() //define empty hashmap

// Set key, value hashmap
hashMap.put("media_type",MediaType.image)
hashMap.put("media_action",MediaAction.upload)
hashMap.put("media_id",imageId)
hashMap.put("time",System.nanoTime().toDouble())

// log via BenshiLogTrackEvent
BenshiLogTrackEvent.Builder().init(context)
    .setEventName("profile_image_upload")
    .setMeta(hashMap).build()

dependencies {
    // Import the BoM for the Firebase platform
    implementation platform('com.google.firebase:firebase-bom:28.4.2')

    // Declare the dependencies for the Firebase Cloud Messaging and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation 'com.google.firebase:firebase-messaging-ktx'
    implementation 'com.google.firebase:firebase-analytics-ktx'
}

class MyFirebaseMessagingService : FirebaseMessagingService() {
    override fun onNewToken(token : String) {
BenshiLog.setFCMRegistrationID(token) // this one
    }
}

FirebaseMessaging.getInstance().token.addOnCompleteListener(OnCompleteListener { task ->
    if (!task.isSuccessful) {
        Log.w(TAG, "Fetching FCM registration token failed", task.exception)
        return@OnCompleteListener
    }

    // Get new FCM registration token
val token = task.result
BenshiLog.setFCMRegistrationID(token) // this one
})

override fun onMessageReceived(remoteMessage: RemoteMessage) {
    val data: Map<String, String> = remoteMessage.getData()
if(data != null) {
  if(data.containsKey("source") && "benshi" == data["source"]){
        NudgeScheduler.showMessage(remoteMessage)
   }
}
}

<service
    android:name=".MyFirebaseMessagingService">
    <intent-filter>
        <action android:name="com.google.firebase.MESSAGING_EVENT"/>
    </intent-filter>
</service>