Merge pull request #3 from contentpass/count-impressions

Add count impression functionality

Author: pumapaul

README.md

@@ -14,7 +14,7 @@
 Our SDK is available on Maven Central.
 
 ```groovy
-implementation 'de.contentpass:contentpass-android:1.0.1'
+implementation 'de.contentpass:contentpass-android:1.1.0'
 ```
 
 Add this to your app's `build.gradle` file's `dependencies` element.
@@ -148,6 +148,45 @@ Any registered `Observer` will be called with the final authentication and subsc
 * We refresh these tokens automatically in the background before they're invalidated.
 * The subscription information gets validated as well on every token refresh.
 
+### Counting an impression
+
+To count an impression, call either the suspending function `countImpressionSuspending(context: Context)` or the compatibility function `countImpression(context: Context, callback: CountImpressionCallback)`.
+
+In both cases you'll need to supply a `Context` (i.e. an `Activity` or `Fragment`) so the login process can be started again in case the user needs to login again.
+
+For an impression to be able to be counted, a user has to be authenticated and have an active subscription applicable to your scope.
+
+```kotlin
+try {
+  contentPass.countImpressionSuspending(context)
+  // handle success
+} catch (impressionException: ContentPass.CountImpressionException) {
+  // impressionException.message contains the http error code as a string
+  // if this is "404", this most likely means that the user has no applicable subscription
+} catch (ex: Throwable) {
+  // Handle the exception. 
+  // This might be network related but could also happen because the ContentPass object wasn't initialized properly.
+}
+```
+
+or for compatibility reasons:
+
+```kotlin
+contentPass.countImpression(context, object : ContentPass.CountImpressionCallback {
+  override fun onSuccess() {
+    // handle success
+  }
+
+  override fun onFailure(exception: Throwable) {
+    // handle the exception. 
+    // If this is a ContentPass.CountImpressionException, parse its message for the http error code.
+    // if this is "404", this most likely means that the user has no applicable subscription
+  }
+})
+```
+
+
+
 ### Logging out a user
 
 Since we persist the user's session, you need a way to log the user out. Simply call `logout` and we remove all stored token data.

app/src/main/java/de/contentpass/app/ExampleViewModel.kt

@@ -13,6 +13,11 @@ class ExampleViewModel(context: Context) : ViewModel() {
     private val _hasValidSubscription = MutableLiveData(false)
     val hasValidSubscription: LiveData<Boolean> = _hasValidSubscription
 
+    private val _impressionTries = MutableLiveData(0)
+    val impressionTries: LiveData<Int> = _impressionTries
+    private val _impressionSuccesses = MutableLiveData(0)
+    val impressionSuccesses: LiveData<Int> = _impressionSuccesses
+
     private val config = context.resources
         .openRawResource(R.raw.contentpass_configuration)
 
@@ -50,6 +55,20 @@ class ExampleViewModel(context: Context) : ViewModel() {
         onNewContentPassState(state)
     }
 
+    suspend fun countImpression(fromActivity: ComponentActivity) {
+        _impressionTries.postValue(_impressionTries.value?.plus(1) ?: 1)
+
+        try {
+            contentPass.countImpressionSuspending(fromActivity)
+            _impressionSuccesses.postValue(_impressionSuccesses.value?.plus(1) ?: 1)
+        } catch (impressionException: ContentPass.CountImpressionException) {
+            println("Counting impression error code: ${impressionException.message}")
+        } catch (ex: Throwable) {
+            println("Counting impression exception:")
+            ex.printStackTrace()
+        }
+    }
+
     fun logout() {
         contentPass.logout()
     }

app/src/main/java/de/contentpass/app/MainView.kt

@@ -26,6 +26,8 @@ import kotlinx.coroutines.launch
 fun MainView(viewModel: ExampleViewModel) {
     val isAuthenticated: Boolean by viewModel.isAuthenticated.observeAsState(false)
     val hasValidSubscription: Boolean by viewModel.hasValidSubscription.observeAsState(false)
+    val impressionTries: Int by viewModel.impressionTries.observeAsState(0)
+    val impressionSuccesses: Int by viewModel.impressionSuccesses.observeAsState(0)
 
     Column(
         horizontalAlignment = Alignment.CenterHorizontally,
@@ -34,7 +36,6 @@ fun MainView(viewModel: ExampleViewModel) {
             .fillMaxSize()
     ) {
         Text(text = "Is authenticated: $isAuthenticated")
-
         Text(text = "Has valid subscription: $hasValidSubscription")
 
         PaddingValues(Dp(8.0F))
@@ -47,6 +48,12 @@ fun MainView(viewModel: ExampleViewModel) {
                 modifier = Modifier.padding(Dp(16F))
             ) { Text("Logout") }
         }
+
+        PaddingValues(Dp(8.0F))
+
+        Text(text = "Count impression tries: $impressionTries")
+        Text(text = "Count impression successes: $impressionSuccesses")
+        ImpressionButton(viewModel)
     }
 }
 
@@ -68,6 +75,16 @@ fun LoginButton(viewModel: ExampleViewModel) {
     ) { Text("Login") }
 }
 
+@Composable
+fun ImpressionButton(viewModel: ExampleViewModel) {
+    val coroutineScope = rememberCoroutineScope()
+    val activity = LocalContext.current as ComponentActivity
+
+    return Button(
+        onClick = { coroutineScope.launch { viewModel.countImpression(activity) } }
+    ) { Text("Count impression") }
+}
+
 @Preview(
     showSystemUi = true
 )

lib/build.gradle.kts

@@ -58,7 +58,7 @@ kapt {
 extra.apply{
     set("PUBLISH_GROUP_ID", "de.contentpass")
     set("PUBLISH_ARTIFACT_ID", "contentpass-android")
-    set("PUBLISH_VERSION", "1.0.1")
+    set("PUBLISH_VERSION", "1.1.0")
 }
 
 apply("${rootProject.projectDir}/scripts/publish-module.gradle")

lib/src/main/java/de/contentpass/lib/Authorizer.kt

@@ -5,44 +5,35 @@ import android.content.Intent
 import androidx.activity.result.ActivityResultLauncher
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.launch
-import net.openid.appauth.AuthState
-import net.openid.appauth.AuthorizationException
-import net.openid.appauth.AuthorizationRequest
-import net.openid.appauth.AuthorizationResponse
-import net.openid.appauth.AuthorizationService
-import net.openid.appauth.AuthorizationServiceConfiguration
-import net.openid.appauth.ResponseTypeValues
-import net.openid.appauth.TokenRequest
-import okhttp3.Call
-import okhttp3.Callback
-import okhttp3.FormBody
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.Response
+import kotlinx.coroutines.*
+import net.openid.appauth.*
+import net.openid.appauth.AuthState.AuthStateAction
+import okhttp3.*
 import okio.IOException
+import java.util.*
 import kotlin.coroutines.Continuation
+import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
 
+
 internal interface Authorizing {
     suspend fun authenticate(
         activity: Context,
-        activityResultLauncher: ActivityResultLauncher<Intent>
+        activityResultLauncher: ActivityResultLauncher<Intent>,
     ): AuthState
 
     suspend fun validateSubscription(idToken: String): Boolean
 
     suspend fun refreshToken(authState: AuthState): AuthState
 
     fun onAuthorizationRequestResult(intent: Intent?)
+
+    suspend fun countImpression(authState: AuthState, activity: Context)
 }
 
 internal class Authorizer(
     configuration: Configuration,
-    private val context: Context
+    private val context: Context,
 ) : Authorizing {
     private val baseUrl = configuration.baseUrl
     private val redirectUri = configuration.redirectUri
@@ -89,7 +80,7 @@ internal class Authorizer(
 
     override suspend fun authenticate(
         activity: Context,
-        activityResultLauncher: ActivityResultLauncher<Intent>
+        activityResultLauncher: ActivityResultLauncher<Intent>,
     ): AuthState {
         val request = buildRequest()
         val result: AuthState = suspendCoroutine { cont ->
@@ -102,8 +93,6 @@ internal class Authorizer(
                 cont.resumeWith(Result.failure(exception))
             }
         }
-        authService?.dispose()
-        authService = null
         return result
     }
 
@@ -149,6 +138,56 @@ internal class Authorizer(
         }
     }
 
+    override suspend fun countImpression(authState: AuthState, activity: Context) {
+        val impressionId = UUID.randomUUID()
+        val path = "pass/hit?pid=$propertyId&iid=$impressionId&t=pageview"
+
+        val response = fireRequestWithFreshTokens(path, authState, activity)
+
+        if (response.code == 200) {
+            return
+        } else {
+            throw ContentPass.CountImpressionException(response.code)
+        }
+    }
+
+    private suspend fun fireRequestWithFreshTokens(
+        path: String,
+        authState: AuthState,
+        context: Context,
+    ): Response {
+        val client = OkHttpClient.Builder()
+            .build()
+
+        return suspendCoroutine { continuation ->
+            try {
+                val authService = AuthorizationService(context)
+                authState.performActionWithFreshTokens(authService) { accessToken, _, ex ->
+                    ex?.let {
+                        continuation.resumeWithException(it)
+                        return@performActionWithFreshTokens
+                    }
+
+                    accessToken?.let { strongToken ->
+                        val authorizedRequest = Request.Builder()
+                            .url("$baseUrl/$path")
+                            .header("Authorization", "Bearer $strongToken")
+                            .build()
+
+                        val response = client.newCall(authorizedRequest).execute()
+                        continuation.resumeWith(Result.success(response))
+                    } ?: run {
+                        val message =
+                            "Although no AuthenticationException was thrown, there's no accessToken - please report this via GitHub issues"
+                        continuation.resumeWithException(NullPointerException(message))
+                    }
+                }
+            } catch (error: Throwable) {
+                continuation.resumeWithException(error)
+            }
+        }
+    }
+
     private suspend fun buildRequest(): AuthorizationRequest {
         return AuthorizationRequest.Builder(
             fetchConfig(),

lib/src/main/java/de/contentpass/lib/ContentPass.kt

@@ -9,13 +9,10 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.fragment.app.Fragment
 import com.squareup.moshi.Moshi
 import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.*
 import net.openid.appauth.AuthState
 import net.openid.appauth.AuthorizationException
+import okhttp3.Request
 import java.io.InputStream
 import java.lang.NullPointerException
 import java.util.Timer
@@ -42,7 +39,7 @@ import java.util.TimerTask
  */
 class ContentPass internal constructor(
     private val authorizer: Authorizing,
-    private val tokenStore: TokenStoring
+    private val tokenStore: TokenStoring,
 ) {
     /**
      * A collection of functions that allow you to react to changes in the [ContentPass] object.
@@ -62,6 +59,13 @@ class ContentPass internal constructor(
         fun onFailure(exception: Throwable)
     }
 
+    class CountImpressionException(statusCode: Int) : Throwable("$statusCode")
+
+    interface CountImpressionCallback {
+        fun onSuccess()
+        fun onFailure(exception: Throwable)
+    }
+
     class Builder {
         private var context: Context? = null
         private var configuration: Configuration? = null
@@ -259,7 +263,6 @@ class ContentPass internal constructor(
      * @param context the context the authentication flow will be started from.
      * @param callback an object implementing the [AuthenticationCallback] interface that enables
      *                 you to react to the authentication flow's outcome.
-     * @return the resulting authentication [State]
      */
     fun authenticate(context: Context, callback: AuthenticationCallback) {
         CoroutineScope(coroutineContext).launch {
@@ -284,6 +287,51 @@ class ContentPass internal constructor(
         return state
     }
 
+    /**
+     * Count an impression by calling this function.
+     *
+     * This is the compatibility function for Java users and developers who are not yet
+     * comfortable or able to use kotlin coroutines.
+     *
+     * A user has to be authenticated and have an active subscription applicable to your
+     * scope for this to work.
+     * This function calls the callback's onSuccess on a successful impression counting.
+     * In case of an error the callback's onFailure contains an exception containing more information.
+     * If the exception is a ContentPass.CountImpressionException and the message states the http error
+     * code 404, the user most likely has no applicable subscription.
+     *
+     * @param context the context the authentication flow can be restarted from in case a login is necessary.
+     * @param callback an object implementing the [CountImpressionCallback] interface that enables
+     *                 you to react to the count impression outcome.
+     */
+    fun countImpression(context: Context, callback: CountImpressionCallback) {
+        CoroutineScope(coroutineContext).launch {
+            try {
+                countImpressionSuspending(context)
+                callback.onSuccess()
+            } catch (exception: Throwable) {
+                callback.onFailure(exception)
+            }
+        }
+    }
+
+    /**
+     * Count an impression by calling this function.
+     *
+     * A user has to be authenticated and have an active subscription applicable to your
+     * scope for this to work.
+     * This function simply returns on success or will throw an exception containing more information.
+     * If the exception is a ContentPass.CountImpressionException and the message states the http error
+     * code 404, the user most likely has no applicable subscription.
+     *
+     * @param context the context the authentication flow can be restarted from in case a login is necessary.
+     */
+    suspend fun countImpressionSuspending(context: Context) {
+        return withContext(coroutineContext) {
+            authorizer.countImpression(authState, context)
+        }
+    }
+
     private suspend fun onNewAuthState(authState: AuthState): State {
         tokenStore.storeAuthState(authState)