Kotlin SDK

1
FynoTOTP(context: Context)

1
fun init(
2
    wsid: String,
3
    distinctId: String,
4
    callback: (Result<Unit>) -> Unit
5
): Unit

1
val fynoTotp = FynoTOTP(context)
2
fynoTotp.init("workspace_123", "user_456") { result ->
3
    result.onSuccess {
4
        Log.d("TOTP", "Initialization successful")
5
    }
6
    result.onFailure { error ->
7
        Log.e("TOTP", "Initialization failed: ${error.message}")
8
    }
9
}

1
fun registerTenant(
2
    tenantId: String,
3
    tenantLabel: String,
4
    totpToken: String,
5
    callback: (Result<Unit>) -> Unit
6
): Unit

1
fynoTotp.registerTenant(
2
    tenantId = "tenant_001",
3
    tenantLabel = "My App Account",
4
    totpToken = "JBSWY3DPEBLW64TMMQQ======",
5
    callback = { result ->
6
        result.onSuccess {
7
            Toast.makeText(context, "Tenant registered", Toast.LENGTH_SHORT).show()
8
        }
9
        result.onFailure { error ->
10
            Toast.makeText(context, "Registration failed: ${error.message}", Toast.LENGTH_SHORT).show()
11
        }
12
    }
13
)

1
fun setConfig(
2
    tenantId: String,
3
    config: TotpConfig,
4
    callback: (Result<Unit>) -> Unit
5
): Unit

1
val config = TotpConfig(
2
    tenant_name = "My App Account",
3
    digits = 6,
4
    algorithm = "SHA1",
5
    period = 30
6
)
7
8
fynoTotp.setConfig(
9
    tenantId = "tenant_001",
10
    config = config,
11
    callback = { result ->
12
        result.onSuccess {
13
            Log.d("TOTP", "Config updated successfully")
14
        }
15
        result.onFailure { error ->
16
            Log.e("TOTP", "Config update failed: ${error.message}")
17
        }
18
    }
19
)

1
@RequiresApi(Build.VERSION_CODES.M)
2
fun getTotp(
3
    tenantId: String,
4
    callback: (Result<Unit>) -> Unit
5
)

1
fynoTotp.getTotp(
2
    tenantId = "tenant_001",
3
    callback = { result ->
4
        result.onSuccess { otp ->
5
            if (otp != null) {
6
                etOtpInput.setText(otp)
7
                Log.d("TOTP", "OTP: $otp")
8
            } else {
9
                Log.d("TOTP", "Tenant is inactive")
10
            }
11
        }
12
        result.onFailure { error ->
13
            Log.e("TOTP", "Failed to get OTP: ${error.message}")
14
        }
15
    }
16
)

1
@RequiresApi(Build.VERSION_CODES.M)
2
fun revokeTenant(
3
    tenantId: String,
4
    callback: (Result<Unit>) -> Unit
5
): Unit

1
fynoTotp.revokeTenant(
2
    tenantId = "tenant_001",
3
    callback = { result ->
4
        result.onSuccess {
5
            Log.d("TOTP", "Tenant revoked successfully")
6
            // Update UI to remove tenant from list
7
        }
8
        result.onFailure { error ->
9
            Log.e("TOTP", "Revocation failed: ${error.message}")
10
        }
11
    }
12
)

1
class TotpSetupActivity : AppCompatActivity() {
2
3
    private lateinit var fynoTotp: FynoTOTP
4
5
    override fun onCreate(savedInstanceState: Bundle?) {
6
        super.onCreate(savedInstanceState)
7
        
8
        // Initialize SDK
9
        fynoTotp = FynoTOTP(this)
10
        fynoTotp.init("workspace_id", "user_id") { result ->
11
            result.onSuccess {
12
                Log.d("Setup", "SDK initialized")
13
            }
14
            result.onFailure { e ->
15
                Log.e("Setup", "Init failed", e)
16
            }
17
        }
18
    }
19
20
    private fun enrollTenant() {
21
        val tenantId = "tenant_001"
22
        val totpSecret = "JBSWY3DPEBLW64TMMQQ======" // Base32 encoded
23
        
24
        fynoTotp.registerTenant(
25
            tenantId = tenantId,
26
            tenantLabel = "Primary Account",
27
            totpToken = totpSecret
28
        ) { result ->
29
            result.onSuccess {
30
                setupTotpConfig(tenantId)
31
            }
32
            result.onFailure { error ->
33
                showError("Enrollment failed: ${error.message}")
34
            }
35
        }
36
    }
37
38
    private fun setupTotpConfig(tenantId: String) {
39
        val config = TotpConfig(
40
            tenant_name = "Primary Account",
41
            digits = 6,
42
            algorithm = "SHA1",
43
            period = 30
44
        )
45
        
46
        fynoTotp.setConfig(tenantId, config) { result ->
47
            result.onSuccess {
48
                Log.d("Setup", "Config set successfully")
49
                displayTotpCode(tenantId)
50
            }
51
            result.onFailure { error ->
52
                showError("Config failed: ${error.message}")
53
            }
54
        }
55
    }
56
57
    private fun displayTotpCode(tenantId: String) {
58
        fynoTotp.getTotp(tenantId) { result ->
59
            result.onSuccess { otp ->
60
                if (otp != null) {
61
                    findViewById<TextView>(R.id.tvOtpCode).text = otp
62
                }
63
            }
64
            result.onFailure { error ->
65
                Log.e("TOTP", "Failed to get OTP", error)
66
            }
67
        }
68
    }
69
70
    private fun revokeTenant(tenantId: String) {
71
        fynoTotp.revokeTenant(tenantId) { result ->
72
            result.onSuccess {
73
                Log.d("Revoke", "Tenant revoked")
74
            }
75
            result.onFailure { error ->
76
                Log.e("Revoke", "Revocation failed", error)
77
            }
78
        }
79
    }
80
}

1
class TotpRefreshService {
2
    
3
    private lateinit var fynoTotp: FynoTOTP
4
    private val handler = Handler(Looper.getMainLooper())
5
    private val refreshInterval = 1000L // 1 second
6
    
7
    fun startPeriodicRefresh(tenantId: String, onCodeUpdate: (String?) -> Unit) {
8
        val runnable = object : Runnable {
9
            override fun run() {
10
                fynoTotp.getTotp(tenantId) { result ->
11
                    result.onSuccess { otp ->
12
                        onCodeUpdate(otp)
13
                    }
14
                }
15
                handler.postDelayed(this, refreshInterval)
16
            }
17
        }
18
        handler.post(runnable)
19
    }
20
}

1
data class TotpConfig(
2
    val tenant_name: String,      // Human-readable tenant name
3
    val digits: Int = 6,           // Number of digits in OTP (typically 6-8)
4
    val algorithm: String = "SHA1", // Hash algorithm (SHA1, SHA256, SHA512)
5
    val period: Int = 30           // Time period in seconds (typically 30)
6
)

1
// Standard Google Authenticator style
2
val standard = TotpConfig(
3
    tenant_name = "Google Account",
4
    digits = 6,
5
    algorithm = "SHA1",
6
    period = 30
7
)
8
9
// Enhanced security with SHA256
10
val enhanced = TotpConfig(
11
    tenant_name = "Banking App",
12
    digits = 8,
13
    algorithm = "SHA256",
14
    period = 30
15
)
16
17
// Custom period (60 seconds)
18
val custom = TotpConfig(
19
    tenant_name = "Custom Service",
20
    digits = 6,
21
    algorithm = "SHA1",
22
    period = 60
23
)

1
fynoTotp.getTotp(tenantId) { result ->
2
    result.onSuccess { otp ->
3
        // Handle success
4
        displayOtp(otp)
5
    }
6
    result.onFailure { error ->
7
        when (error) {
8
            is KeyPermanentlyInvalidatedException -> {
9
                // Device was unlocked and key was invalidated
10
                Toast.makeText(context, "Please re-enroll", Toast.LENGTH_SHORT).show()
11
                revokeTenant(tenantId)
12
            }
13
            is InvalidKeyException -> {
14
                Toast.makeText(context, "Security error", Toast.LENGTH_SHORT).show()
15
            }
16
            else -> {
17
                Toast.makeText(context, "Error: ${error.message}", Toast.LENGTH_SHORT).show()
18
            }
19
        }
20
    }
21
}