@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/src/main/java/com/hydralib/hydrasdk/HydraPushNotification.kt

@@ -0,0 +1,299 @@
+package com.hydralib.hydrasdk
+
+import android.annotation.SuppressLint
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import com.hydralib.delegates.NonHydraNotificationActivity
+import androidx.core.app.NotificationCompat
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.capillary.hydra.firebase.HydraFirebaseAPI
+import com.capillary.hydra.firebase.listener.NonHydraPushListener
+import com.capillary.hydra.pushbase.HydraPushApi
+import com.capillary.hydra.pushbase.listener.HydraPushNotificationListener
+import com.capillary.hydra.pushbase.listener.NotificationPermissionListener
+import com.capillary.hydra.pushbase.listener.TokenAvailableListener
+import com.capillary.hydra.pushbase.notification.model.CTA
+import com.capillary.hydra.pushbase.notification.model.NotificationPayload
+import com.facebook.react.bridge.Promise
+import com.google.firebase.messaging.RemoteMessage
+import com.google.gson.Gson
+import com.hydralib.delegates.NonHydraNotificationActivity.Companion.EXTRA_REMOTE_MESSAGE
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import com.hydralib.utils.getDrawableId
+
+object HydraPushNotification {
+  private var fcmToken: String? = null
+  private var notificationChannelCreated = false
+
+  private fun asTokenListener() = TokenAvailableListener {
+    Logger.d(
+      "HydraPushNotification.TokenAvailableListener",
+      " fcmToken received in android = ${it.token}"
+    )
+    fcmToken = it.token
+    HydraEventEmitter.sendEvent(HydraEventType.ON_TOKEN_AVAILABLE, fcmToken)
+  }
+
+  private fun asNonHydraPushNotificationListener() = object : NonHydraPushListener {
+    override fun onPushReceived(remoteMessage: RemoteMessage) {
+      Logger.d(
+        "HydraPushNotification.NonHydraPushListener",
+        "Received Non Hydra Push, Details = $remoteMessage"
+      )
+
+      // Show notification in system tray
+      showNotificationInTray(remoteMessage)
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_NON_HYDRA_NOTIFICATION_RECEIVED,
+        remoteMessage.toMap()
+      )
+    }
+  }
+
+  private fun asHydraPushNotificationListener() = object : HydraPushNotificationListener {
+    override fun handleCustomAction(context: Context, payload: String) {
+      Logger.d(
+        "HydraPushNotification.HydraPushNotificationListener.handleCustomAction",
+        "Custom action, payload = $payload"
+      )
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.HANDLE_CUSTOM_ACTION,
+        payload
+      )
+    }
+
+    override fun onNotificationClick(
+      context: Context,
+      payload: NotificationPayload,
+      cta: CTA?
+    ): Boolean {
+      Logger.d(
+        "HydraPushNotification.HydraPushNotificationListener.onNotificationClick",
+        "payload = $payload, cta=$cta"
+      )
+      val detailMap = mutableMapOf<String, Any>()
+
+      if (cta != null) {
+        detailMap["cta"] = cta.toMap()
+      }
+      detailMap["payload"] = payload.toMap()
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_CLICKED,
+        detailMap
+      )
+
+      return true
+    }
+
+    override fun onNotificationDismissed(context: Context, payload: NotificationPayload) {
+      Logger.d(
+        "HydraPushNotification.HydraPushNotificationListener.onNotificationDismissed",
+        "payload = $payload"
+      )
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_DISMISSED,
+        payload.toMap()
+      )
+    }
+
+    override fun onNotificationReceived(context: Context, payload: NotificationPayload) {
+      Logger.d(
+        "HydraPushNotification.HydraPushNotificationListener.onNotificationReceived",
+        "payload = $payload"
+      )
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_RECEIVED,
+        payload.toMap()
+      )
+    }
+
+    override fun onNotificationShown(context: Context, payload: NotificationPayload) {
+      Logger.d(
+        "HydraPushNotification.HydraPushNotificationListener.onNotificationShown",
+        "payload = $payload"
+      )
+
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_HYDRA_NOTIFICATION_SHOWN,
+        payload.toMap()
+      )
+    }
+  }
+
+  fun registerListenersNotDependentOnAccountId() {
+    HydraFirebaseAPI.getInstance().addTokenListener(asTokenListener())
+    HydraFirebaseAPI.getInstance().addNonHydraPushListener(asNonHydraPushNotificationListener())
+    Logger.d("HydraPushNotification.registerListeners", "Listeners registered successfully")
+  }
+
+  fun registerHydraPushNotificationListener() {
+    HydraPushApi.getInstance().registerPushNotificationListener(asHydraPushNotificationListener())
+    Logger.d(
+      "HydraPushNotification.registerHydraPushNotificationListener",
+      "Listener registered successfully"
+    )
+  }
+
+  fun requestPermission(promise: Promise?) {
+    if (Build.VERSION.SDK_INT < 33) {
+      Logger.d(
+        "HydraPushNotification.requestPermission",
+        "SDK version less than 33, No need to ask for permission"
+      )
+      promise?.resolve(true)
+      return
+    }
+
+    var listener: NotificationPermissionListener? = null
+    listener = NotificationPermissionListener { isGranted ->
+      Logger.d(
+        "HydraPushNotification.requestPermission",
+        "Hydra push permission request result = $isGranted"
+      )
+      promise?.resolve(isGranted)
+      HydraPushApi.getInstance().removePermissionResponseListener(listener!!)
+    }
+    HydraPushApi.getInstance().addPermissionResponseListener(listener)
+    HydraPushApi.getInstance().requestPushPermission(HydraCore.appContext!!)
+    Logger.d("HydraPushNotification.requestPermission", "Hydra push permission requested")
+  }
+
+  fun openExternalUrl(url: String, promise: Promise?) {
+    val scheme = Uri.parse(url).scheme?.lowercase()
+    if (scheme != "http" && scheme != "https") {
+      Logger.e("HydraPushNotification.openExternalUrl", "Rejected non-http(s) URL scheme: $url")
+      promise?.reject("InvalidUrl", "Only http/https URLs are allowed")
+      return
+    }
+
+    val activity = HydraCore.curReactActivity
+    val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+    if (activity != null) {
+      activity.startActivity(intent)
+    } else {
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      HydraCore.appContext?.startActivity(intent)
+    }
+    promise?.resolve(null)
+  }
+
+  fun getFCMToken(promise: Promise?) {
+    if (fcmToken == null) {
+      Logger.d("HydraPushNotification.getFCMToken", "Token is not available, try later")
+      promise?.reject("TokenNotSet", "Token is not available, try later")
+      return
+    }
+    Logger.d("HydraPushNotification.getFCMToken", "Returning token = $fcmToken")
+    promise?.resolve(fcmToken)
+  }
+
+  private fun createNotificationChannel(context: Context) {
+    if (notificationChannelCreated) return
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val notificationManager =
+        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      val channelId = "non_hydra_notifications"
+
+      val channel = NotificationChannel(
+        channelId,
+        "Non-Hydra Notifications",
+        NotificationManager.IMPORTANCE_DEFAULT
+      ).apply {
+        description = "Notifications from non-Hydra sources"
+      }
+      notificationManager.createNotificationChannel(channel)
+      notificationChannelCreated = true
+      Logger.d("HydraPushNotification.createNotificationChannel", "Notification channel created")
+    }
+  }
+
+  @SuppressLint("WrongConstant")
+  private fun showNotificationInTray(remoteMessage: RemoteMessage) {
+    // Add immediate logging to confirm method is called
+    Logger.i(
+      "HydraPushNotification",
+      "showNotificationInTray called - app state: ${if (HydraCore.appContext != null) "CONTEXT_AVAILABLE" else "CONTEXT_NULL"}"
+    )
+
+    val context = HydraCore.appContext ?: run {
+      Logger.e("HydraPushNotification", "HydraCore.appContext is null")
+      return
+    }
+
+    Logger.i("HydraPushNotification", "Context package name: ${context.packageName}")
+    Logger.i("HydraPushNotification", "Context class: ${context.javaClass.simpleName}")
+
+    // Create notification channel once
+    createNotificationChannel(context)
+
+    val notificationManager =
+      context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    val channelId = "non_hydra_notifications"
+    val notificationId = System.currentTimeMillis().toInt()
+
+    // Extract notification data
+    val data = remoteMessage.data
+    val originalTitle = remoteMessage.notification?.title ?: data["title"] ?: "Notification"
+    val originalBody = remoteMessage.notification?.body ?: data["message"] ?: "New message received"
+
+    // Create intent for NotificationActivity to handle the notification click
+    val intent = Intent(context, NonHydraNotificationActivity::class.java).apply {
+      flags = Intent.FLAG_ACTIVITY_NEW_TASK
+      // Pass notification data to the activity
+      putExtra(EXTRA_REMOTE_MESSAGE, Gson().toJson(remoteMessage.toMap()))
+
+    }
+
+    val launchIntent =
+      context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+        addFlags(0x10200000)
+      }
+
+    val intents = if (launchIntent != null) {
+      arrayOf(launchIntent, intent)
+    } else {
+      arrayOf(intent)
+    }
+
+    val intentFlag =
+      PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+
+    val pendingIntent = PendingIntent.getActivities(context, notificationId, intents, intentFlag)
+
+    // Get notification icon
+    val iconId = getDrawableId(context, "hydra_notification_small_icon", "drawable")
+    if (iconId == 0) {
+      Logger.e("HydraPushNotification", "No notification icon found, skipping notification")
+      return
+    }
+
+    // Build the notification
+    val notification = NotificationCompat.Builder(context, channelId)
+      .setContentTitle(originalTitle)
+      .setContentText(originalBody)
+      .setSmallIcon(iconId)
+      .setAutoCancel(true)
+      .setContentIntent(pendingIntent)
+      .build()
+
+    // Show the notification
+    notificationManager.notify(notificationId, notification)
+
+    Logger.i(
+      "HydraPushNotification",
+      "Notification shown in tray: title=$originalTitle, body=$originalBody, icon=$iconId"
+    )
+  }
+}

package/android/src/main/java/com/hydralib/nativeapis/Hydra.kt

@@ -0,0 +1,28 @@
+package com.hydralib.nativeapis
+
+import android.content.Context
+
+object Hydra {
+  /**
+   * Initialize the Hydra SDK.
+   *
+   * @param appContext             The application context.
+   * @param firebaseRemoteConfigKeys  Optional. Custom Firebase Remote Config key names.
+   *                               Pass null to use default keys.
+   * @param remoteConfig           Optional. A pre-built HydraRemoteConfig object.
+   *                               When provided, Firebase Remote Config is bypassed entirely.
+   */
+  @JvmStatic
+  @JvmOverloads
+  fun initialize(
+    appContext: Context,
+    firebaseRemoteConfigKeys: HydraFirebaseRemoteConfigKeys? = null,
+    remoteConfig: HydraRemoteConfig? = null
+  ) {
+    when {
+      remoteConfig != null -> HydraInitializer.initialize(appContext, remoteConfig)
+      firebaseRemoteConfigKeys != null -> HydraInitializer.initializeUsingFirebaseRemoteConfig(appContext, firebaseRemoteConfigKeys)
+      else -> HydraInitializer.initializeUsingFirebaseRemoteConfig(appContext)
+    }
+  }
+}

package/android/src/main/java/com/hydralib/nativeapis/HydraFirebaseRemoteConfigKeys.kt

@@ -0,0 +1,76 @@
+package com.hydralib.nativeapis
+
+import androidx.annotation.RestrictTo
+
+class HydraFirebaseRemoteConfigKeys(
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForAccountId: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForBaseURL: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForSsl: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForRemoteDebugLevel: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForOrgId: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForGamificationKey: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForGamificationRegion: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var keyForGamificationBaseUrl: String? = null,
+
+  ) {
+
+  data class Builder(
+    private var keyForAccountId: String? = null,
+    private var keyForBaseURL: String? = null,
+    private var keyForSsl: String? = null,
+    private var keyForRemoteDebugLevel: String? = null,
+    private var keyForOrgId: String? = null,
+    private var keyForGamificationKey: String? = null,
+    private var keyForGamificationRegion: String? = null,
+    private var keyForGamificationBaseUrl: String? = null,
+  ) {
+    fun keyForBaseURL(keyForBaseURL: String) = apply { this.keyForBaseURL = keyForBaseURL }
+    fun keyForSsl(keyForSsl: String) = apply { this.keyForSsl = keyForSsl }
+    fun keyForRemoteDebugLevel(keyForRemoteDebugLevel: String) =
+      apply { this.keyForRemoteDebugLevel = keyForRemoteDebugLevel }
+
+    fun keyForAccountId(keyForAccountId: String) = apply { this.keyForAccountId = keyForAccountId }
+    fun keyForOrgId(keyForOrgId: String) = apply { this.keyForOrgId = keyForOrgId }
+    fun keyForGamificationKey(keyForGamificationKey: String) = apply { this.keyForGamificationKey = keyForGamificationKey }
+    fun keyForGamificationRegion(keyForGamificationRegion: String) = apply { this.keyForGamificationRegion = keyForGamificationRegion }
+    fun keyForGamificationBaseUrl(keyForGamificationBaseUrl: String) = apply { this.keyForGamificationBaseUrl = keyForGamificationBaseUrl }
+
+
+    @Throws(IllegalArgumentException::class)
+    fun build(): HydraFirebaseRemoteConfigKeys {
+      if (keyForAccountId == null || keyForAccountId!!.isEmpty()) {
+        throw IllegalArgumentException("Key for Account id is required")
+      }
+      if (keyForBaseURL == null || keyForBaseURL!!.isEmpty()) {
+        throw IllegalArgumentException("Key forBase URL is required")
+      }
+
+      if (keyForSsl == null || keyForSsl!!.isEmpty()) {
+        throw IllegalArgumentException("Key for SSL  is required")
+      }
+
+      if (keyForRemoteDebugLevel == null || keyForRemoteDebugLevel!!.isEmpty()) {
+        throw IllegalArgumentException("Key for Remote Debug Level is required")
+      }
+
+      return HydraFirebaseRemoteConfigKeys(
+        keyForAccountId!!,
+        keyForBaseURL!!,
+        keyForSsl!!,
+        keyForRemoteDebugLevel!!,
+        keyForOrgId,
+        keyForGamificationKey,
+        keyForGamificationRegion,
+        keyForGamificationBaseUrl
+      )
+    }
+  }
+}

package/android/src/main/java/com/hydralib/nativeapis/HydraInitializer.kt

@@ -0,0 +1,130 @@
+package com.hydralib.nativeapis
+
+import android.annotation.SuppressLint
+import android.app.Application
+import android.content.Context
+import android.util.Log
+import com.capillary.hydra.android.sdk.HydraAPI
+import com.capillary.hydra.android.sdk.utils.LogType
+import com.google.firebase.ktx.Firebase
+import com.google.firebase.remoteconfig.FirebaseRemoteConfig
+import com.google.firebase.remoteconfig.FirebaseRemoteConfigSettings
+import com.google.firebase.remoteconfig.ktx.remoteConfig
+import com.hydralib.delegates.HydraActivityCallbacks
+import com.hydralib.hydrasdk.HydraCore
+import com.hydralib.utils.RNHydraPreferencesManager
+
+object HydraInitializer {
+  @JvmStatic
+  fun initialize(appContext: Context, remoteConfig: HydraRemoteConfig) {
+    HydraAPI.initializeConsoleLogger(LogType.DEBUG)
+    (appContext as Application).registerActivityLifecycleCallbacks(HydraActivityCallbacks)
+
+    val isInitialized = initializeUsingPersistedData(appContext)
+
+    if (!isInitialized) {
+      Log.d("HydraInitializer.initialize", "initializing Hydra with passed remote config")
+      HydraCore.initHydra(appContext, remoteConfig)
+    }
+  }
+
+  /**
+   * Call this as early as possible in your app lifecycle (e.g., Application.onCreate)
+   */
+  @SuppressLint("MissingPermission")
+  @JvmStatic
+  fun initializeUsingFirebaseRemoteConfig(
+    appContext: Context,
+    hydraFirebaseRemoteConfigKeys: HydraFirebaseRemoteConfigKeys = HydraFirebaseRemoteConfigKeys(
+      "hydra_account_id",
+      "hydra_base_url",
+      "hydra_ssl_public_key",
+      "hydra_remote_log_level",
+      "hydra_org_id",
+      "hydra_gamification_key",
+      "hydra_gamification_region",
+      "hydra_gamification_base_url"
+    )
+  ) {
+    HydraAPI.initializeConsoleLogger(LogType.DEBUG)
+    (appContext as Application).registerActivityLifecycleCallbacks(HydraActivityCallbacks)
+
+    // Set appContext immediately before any async operations to prevent race conditions
+    HydraCore.setAppContext(appContext)
+
+    val isInitialized = initializeUsingPersistedData(appContext)
+
+    if (!isInitialized) {
+      Log.d("HydraInitializer", "initializing Hydra with passed Firebase Remote Config keys")
+      initializeFirebaseUsingKeys(appContext, hydraFirebaseRemoteConfigKeys)
+    }
+  }
+
+  private fun initializeUsingPersistedData(
+    appContext: Context
+  ): Boolean {
+    val persistedRemoteConfig = RNHydraPreferencesManager.getHydraRemoteConfig(appContext)
+    if (persistedRemoteConfig != null) {
+      Log.d("HydraInitializer", "Using persisted remote config")
+      HydraCore.initHydra(appContext, persistedRemoteConfig)
+      return true
+    }
+
+    val persistedFirebaseRemoteConfigKeys =
+      RNHydraPreferencesManager.getHydraFirebaseRemoteConfigKeys(appContext)
+    if (persistedFirebaseRemoteConfigKeys != null) {
+      Log.d("HydraInitializer", "Using persisted firebase remote config keys")
+      initializeFirebaseUsingKeys(appContext, persistedFirebaseRemoteConfigKeys)
+      return true
+    }
+
+    return false
+  }
+
+  private fun initializeFirebaseUsingKeys(
+    appContext: Context,
+    remoteConfigKeysToUse: HydraFirebaseRemoteConfigKeys
+  ) {
+    val firebaseRemoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
+
+    firebaseRemoteConfig.setConfigSettingsAsync(
+      FirebaseRemoteConfigSettings.Builder()
+        .setMinimumFetchIntervalInSeconds(0)
+        .build()
+    ).addOnCompleteListener {
+      fetchAndInitializeRemoteConfig(appContext, remoteConfigKeysToUse)
+    }
+  }
+
+  private fun fetchAndInitializeRemoteConfig(
+    appContext: Context,
+    hydraFirebaseRemoteConfigKeys: HydraFirebaseRemoteConfigKeys
+  ) {
+    Log.d("HydraInitializer", "Starting fetch and activate remote config")
+    val firebaseRemoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
+    firebaseRemoteConfig.fetchAndActivate()
+      .addOnCompleteListener { task ->
+        if (task.isSuccessful) {
+          HydraCore.firebaseRemoteConfigActivated = true
+          Log.d("HydraInitializer", "Successfully fetched and activated remote config")
+          val hydraRemoteConfig: HydraRemoteConfig? =
+            HydraCore.processFirebaseRemoteConfig(hydraFirebaseRemoteConfigKeys)
+          if (hydraRemoteConfig != null) {
+            Log.d("HydraInitializer", "Using remote config")
+            HydraCore.initHydra(appContext, hydraRemoteConfig)
+          } else {
+            val errorMessage = "Failed to process remote config"
+            Log.e("HydraInitializer", errorMessage)
+            HydraCore.sendHydraInitializationResultEvent(false, errorMessage)
+          }
+        } else {
+          val errorMessage =
+            "Failed to fetch and activate remote config: ${task.exception?.message}"
+          Log.e("HydraInitializer", errorMessage, task.exception)
+          HydraCore.sendHydraInitializationResultEvent(false, errorMessage)
+        }
+      }
+  }
+
+
+}

package/android/src/main/java/com/hydralib/nativeapis/HydraNativeMessaging.kt

@@ -0,0 +1,18 @@
+package com.hydralib.nativeapis
+
+import com.capillary.hydra.firebase.HydraFirebaseAPI
+import com.capillary.hydra.pushbase.HydraPushApi
+import com.google.firebase.messaging.RemoteMessage
+import com.hydralib.hydrasdk.HydraCore
+
+object HydraNativeMessaging {
+  fun onNewToken(token:String){
+    HydraFirebaseAPI.getInstance().passPushToken(HydraCore.appContext!!, token)
+  }
+
+  fun onMessageReceived(remoteMessage : RemoteMessage){
+    if(HydraPushApi.getInstance().isFromHydraPlatform(remoteMessage.data)){
+      HydraFirebaseAPI.getInstance().passPushPayload(HydraCore.appContext!!, remoteMessage.data)
+    }
+  }
+}

package/android/src/main/java/com/hydralib/nativeapis/HydraRemoteConfig.kt

@@ -0,0 +1,59 @@
+package com.hydralib.nativeapis
+
+import androidx.annotation.RestrictTo
+
+class HydraRemoteConfig(
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var accountId: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var baseURL: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var sslPublicKey: String,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var remoteDebugLevel: Int,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var orgId: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var gamificationKey: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var gamificationRegion: String? = null,
+  @get:RestrictTo(RestrictTo.Scope.LIBRARY)
+  var gamificationBaseUrl: String? = null,
+
+  ) {
+
+  data class Builder(
+    private var accountId: String? = null,
+    private var baseURL: String? = null,
+    private var sslPublicKey: String? = null,
+    private var remoteDebugLevel: Int? = 0,
+    private var orgId: String? = null,
+    private var gamificationKey: String? = null,
+    private var gamificationRegion: String? = null,
+    private var gamificationBaseUrl: String? = null,
+  ) {
+    fun baseURL(baseURL: String) = apply { this.baseURL = baseURL }
+    fun sslPublicKey(sslPublicKey: String) = apply { this.sslPublicKey = sslPublicKey }
+    fun remoteDebugLevel(remoteDebugLevel: Int) = apply { this.remoteDebugLevel = remoteDebugLevel }
+    fun accountId(accountId: String) = apply { this.accountId = accountId }
+    fun orgId(orgId: String) = apply { this.orgId = orgId }
+    fun gamificationKey(gamificationKey: String) = apply { this.gamificationKey = gamificationKey }
+    fun gamificationRegion(gamificationRegion: String) = apply { this.gamificationRegion = gamificationRegion }
+    fun gamificationBaseUrl(gamificationBaseUrl: String) = apply { this.gamificationBaseUrl = gamificationBaseUrl }
+
+    @Throws(IllegalArgumentException::class)
+    fun build(): HydraRemoteConfig {
+      if (accountId == null || accountId!!.isEmpty()) {
+        throw IllegalArgumentException("Account id is required")
+      }
+      if (baseURL == null || baseURL!!.isEmpty()) {
+        throw IllegalArgumentException("Base URL is required")
+      }
+
+      if (sslPublicKey == null || sslPublicKey!!.isEmpty()) {
+        throw IllegalArgumentException("SSL Public Key is required")
+      }
+      return HydraRemoteConfig(accountId!!, baseURL!!, sslPublicKey!!, remoteDebugLevel!!, orgId, gamificationKey, gamificationRegion, gamificationBaseUrl)
+    }
+  }
+}