# 1.16 -> 1.17

## Breaking Changes

In 1.17 release, listed are the breaking changes

1. Removed **`interface Callback<T>`** in favour of Kotlin lambda functions.
2. Removed **`interface ResultCallback<T>`** in favour of Kotlin lambda functions.
3. Migrated **`interface MonitorCallbacks`** to Kotlin which changes the way to access below members while inheriting/implementing the interface.

   ```kotlin
   CONFIDENCE_LOW, CONFIDENCE_MID, CONFIDENCE_HIGH
   ```

## Migrating Your Code

### Updating Callback interface with a lambda function

1. **Remove** the following imports

   ```kotlin
   import com.intellimec.mobile.android.common.Callback
   ```
2. **Update** the code to lambda

   ```kotlin
   // SDK 1.16
   Callback<T>

   // SDK 1.17
   (T) -> Unit)
   ```

The following shows typical code from SDK `1.16`

```kotlin
// SDK 1.16
override var tripStatusCallback: Callback<Status>

tripStatusCallback.execute(Status.from(tdStatus))
```

Instead of **`Callback<Status>`** we will pass a lambda functio&#x6E;**`((Status) -> Unit)`**

The following is the migrated version of above code to SDK `1.17`

<pre class="language-kotlin"><code class="lang-kotlin"><strong>// SDK 1.17
</strong> override var tripStatusCallback: ((Status) -> Unit)

 tripStatusCallback(Status.from(tdStatus))
</code></pre>

Basically swap **`Callback<Status>`** with a lambda which takes a **`Status`** type parameter and returns **`Unit`** and remove the **`.execute`** call and directly call the lambda.

You could also call the lambda like **`tripStatusCallback?.invoke(Status.from(tdStatus))`** in case if callback is nullable. Below is the example for the same.

```kotlin
// SDK 1.17
// The callback parameter is nullable 
override var tripStatusCallback: Callback<Status>? = null

tripStatusCallback?.invoke(Status.from(tdStatus))
```

### Updating ResultCallback interface with a lambda function

1. **Remove** the following imports

   ```kotlin
   import com.intellimec.mobile.android.common.ResultCallback
   ```
2. **Update** the code to lambda

   ```kotlin
   // SDK 1.16
   ResultCallback<T>

   // SDK 1.17
   (Result<T>) -> Unit)
   ```

The following shows typical code from SDK `1.16`

```kotlin
// SDK 1.16
override fun sign(unsignedToken: String, callback: ResultCallback<String>) {
            val components = unsignedToken.split(".")
            if ((components.size != 2) || (privateKey == null)) {
                callback.execute(Result.Failure(Throwable()))
            } else {
                val signedToken = Jwts.builder()
                    .setHeaderParams(decode(components[0]))
                    .setClaims(decode(components[1]))
                    .signWith(SignatureAlgorithm.RS256, privateKey)
                    .compact()
                callback.execute(Result.Success(signedToken))
            }
        }
```

Instead of **`ResultCallback<String>`** we will pass a lambda **`(Result<T>) -> Unit)`**

The following is the migrated version of above code to SDK `1.17`

<pre class="language-kotlin"><code class="lang-kotlin"><strong>// SDK 1.17
</strong>override fun sign(unsignedToken: String, callback: ((Result&#x3C;String>) -> Unit)) {
            val components = unsignedToken.split(".")
            if ((components.size != 2) || (privateKey == null)) {
                callback(Result.Failure(Throwable()))
            } else {
                val signedToken = Jwts.builder()
                    .setHeaderParams(decode(components[0]))
                    .setClaims(decode(components[1]))
                    .signWith(SignatureAlgorithm.RS256, privateKey)
                    .compact()
                callback(Result.Success(signedToken))
            }
        }
</code></pre>

Basically swap **`ResultCallback<String>`** with a lambda which takes a **`Result<String>`** type parameter and returns **`Unit`** and remove the **`.execute`** call and directly call the lambda.

You could also call the lambda like **`callback?.invoke(Result.Success(signedToken))`** in case if callback is nullable. Below is the example for the same.

```kotlin
// SDK 1.17
// The callback parameter is nullable 
override fun sign(unsignedToken: String, callback: ((Result<String>) -> Unit)?) {
            val components = unsignedToken.split(".")
            if ((components.size != 2) || (privateKey == null)) {
                 callback?.invoke(Result.Failure(Throwable()))
            } else {
                val signedToken = Jwts.builder()
                    .setHeaderParams(decode(components[0]))
                    .setClaims(decode(components[1]))
                    .signWith(SignatureAlgorithm.RS256, privateKey)
                    .compact()
                 callback?.invoke(Result.Success(signedToken))
            }
        }
```

### Accessing members from MonitorCallbacks

This only affects you, if you’re inheriting/implementing the **`MonitorCallbacks`** interface.

If you are inheriting/implementing the **`interface MonitorCallbacks`** , you won't be able to access the following members directly in the child class.

```
CONFIDENCE_LOW, CONFIDENCE_MID, CONFIDENCE_HIGH
```

**Solution:**

* import the reference directly

  ```kotlin
  import com.intellimec.mobile.android.tripdetection.MonitorCallbacks.Companion.CONFIDENCE_HIGH
  ```

OR

* Access using

  ```
  MonitorCallbacks.CONFIDENCE_HIGH
  ```

The following shows typical code from SDK `1.16`

```kotlin
// SDK 1.16
internal class MotionMonitor : MonitorCallbacks {
....
// other overrides 
....
fun detectMotion(confidence: Int ){
  if(confidence == CONFIDENCE_HIGH){
    // do something
   }
  }
}
```

The following is the migrated version of above code to SDK `1.17`

```kotlin
// SDK 1.17
import com.intellimec.mobile.android.tripdetection.MonitorCallbacks.Companion.CONFIDENCE_HIGH

internal class MotionMonitor : MonitorCallbacks {
....
// other overrides 
....
fun detectMotion(confidence: Int ){
        // accessing using import
        if(confidence == CONFIDENCE_HIGH){
            // do something
        }
        // accessing using interface name
        else if(confidence == MonitorCallbacks.CONFIDENCE_MID){
            // do something else
        }
    }
}
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://sdk.ims.tech/migration-notes/android/older-releases/1.16-greater-than-1.17.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.