CMM-839 odie link UI with wordpress rs

WordPress/src/main/java/org/wordpress/android/networking/restapi/WpComApiClientProvider.kt

@@ -0,0 +1,29 @@
+package org.wordpress.android.networking.restapi
+
+import okhttp3.OkHttpClient
+import rs.wordpress.api.kotlin.WpComApiClient
+import rs.wordpress.api.kotlin.WpHttpClient
+import rs.wordpress.api.kotlin.WpRequestExecutor
+import uniffi.wp_api.WpAuthentication
+import uniffi.wp_api.WpAuthenticationProvider
+import java.util.concurrent.TimeUnit
+import javax.inject.Inject
+
+private const val READ_WRITE_TIMEOUT = 60L
+private const val CONNECT_TIMEOUT = 30L
+
+class WpComApiClientProvider @Inject constructor() {
+    fun getWpComApiClient(accessToken: String): WpComApiClient {
+        val okHttpClient = OkHttpClient.Builder()
+            .connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)
+            .readTimeout(READ_WRITE_TIMEOUT, TimeUnit.SECONDS)
+            .writeTimeout(READ_WRITE_TIMEOUT, TimeUnit.SECONDS)
+            .build()
+
+        return WpComApiClient(
+            requestExecutor = WpRequestExecutor(httpClient = WpHttpClient.CustomOkHttpClient(okHttpClient)),
+            authProvider = WpAuthenticationProvider.staticWithAuth(WpAuthentication.Bearer(token = accessToken!!)
+            )
+        )
+    }
+}

WordPress/src/main/java/org/wordpress/android/support/aibot/model/BotMessage.kt

@@ -6,6 +6,5 @@ data class BotMessage(
     val id: Long,
     val text: String,
     val date: Date,
-    val userWantsToTalkToHuman: Boolean,
     val isWrittenByUser: Boolean
 )

WordPress/src/main/java/org/wordpress/android/support/aibot/repository/AIBotSupportRepository.kt

@@ -0,0 +1,160 @@
+package org.wordpress.android.support.aibot.repository
+
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.withContext
+import org.wordpress.android.fluxc.utils.AppLogWrapper
+import org.wordpress.android.modules.IO_THREAD
+import org.wordpress.android.networking.restapi.WpComApiClientProvider
+import org.wordpress.android.support.aibot.model.BotConversation
+import org.wordpress.android.support.aibot.model.BotMessage
+import org.wordpress.android.util.AppLog
+import rs.wordpress.api.kotlin.WpComApiClient
+import rs.wordpress.api.kotlin.WpRequestResult
+import uniffi.wp_api.AddMessageToBotConversationParams
+import uniffi.wp_api.BotConversationSummary
+import uniffi.wp_api.CreateBotConversationParams
+import uniffi.wp_api.GetBotConversationParams
+import javax.inject.Inject
+import javax.inject.Named
+
+private const val BOT_ID = "jetpack-chat-mobile"
+
+class AIBotSupportRepository @Inject constructor(
+    private val appLogWrapper: AppLogWrapper,
+    private val wpComApiClientProvider: WpComApiClientProvider,
+    @Named(IO_THREAD) private val ioDispatcher: CoroutineDispatcher,
+) {
+    private var accessToken: String? = null
+    private var userId: Long = 0
+
+    private val wpComApiClient: WpComApiClient by lazy {
+        check(accessToken != null || userId != 0L) { "Repository not initialized" }
+        wpComApiClientProvider.getWpComApiClient(accessToken!!)
+    }
+
+    fun init(accessToken: String, userId: Long) {
+        this.accessToken = accessToken
+        this.userId = userId
+    }
+
+    suspend fun loadConversations(): List<BotConversation> = withContext(ioDispatcher) {
+        val response = wpComApiClient.request { requestBuilder ->
+            requestBuilder.supportBots().getBotConverationList(BOT_ID)
+        }
+        when (response) {
+            is WpRequestResult.Success -> {
+                val conversations = response.response.data
+                conversations.toBotConversations()
+            }
+
+            else -> {
+                appLogWrapper.e(AppLog.T.SUPPORT, "Error loading conversations: $response")
+                emptyList()
+            }
+        }
+    }
+
+    suspend fun loadConversation(chatId: Long): BotConversation? = withContext(ioDispatcher) {
+        val response = wpComApiClient.request { requestBuilder ->
+            requestBuilder.supportBots().getBotConversation(
+                botId = BOT_ID,
+                chatId = chatId.toULong(),
+                params = GetBotConversationParams()
+            )
+        }
+        when (response) {
+            is WpRequestResult.Success -> {
+                val conversation = response.response.data
+                conversation.toBotConversation()
+            }
+
+            else -> {
+                appLogWrapper.e(AppLog.T.SUPPORT, "Error loading conversation $chatId: $response")
+                null
+            }
+        }
+    }
+
+    suspend fun createNewConversation(message: String): BotConversation? = withContext(ioDispatcher) {
+        val response = wpComApiClient.request { requestBuilder ->
+            requestBuilder.supportBots().createBotConversation(
+                botId = BOT_ID,
+                CreateBotConversationParams(
+                    message = message,
+                    userId = userId
+                )
+            )
+        }
+
+        when (response) {
+            is WpRequestResult.Success -> {
+                val conversation = response.response.data
+                conversation.toBotConversation()
+            }
+
+            else -> {
+                appLogWrapper.e(AppLog.T.SUPPORT, "Error creating new conversation $response")
+                null
+            }
+        }
+    }
+
+    suspend fun sendMessageToConversation(chatId: Long, message: String): BotConversation? =
+        withContext(ioDispatcher) {
+            val response = wpComApiClient.request { requestBuilder ->
+                requestBuilder.supportBots().addMessageToBotConversation(
+                    botId = BOT_ID,
+                    chatId = chatId.toULong(),
+                    params = AddMessageToBotConversationParams(
+                        message = message,
+                        context = mapOf()
+                    )
+                )
+            }
+
+            when (response) {
+                is WpRequestResult.Success -> {
+                    val conversation = response.response.data
+                    conversation.toBotConversation()
+                }
+
+                else -> {
+                    appLogWrapper.e(
+                        AppLog.T.SUPPORT,
+                        "Error sending message to conversation $chatId: $response"
+                    )
+                    null
+                }
+            }
+        }
+
+    private fun List<BotConversationSummary>.toBotConversations(): List<BotConversation> =
+        map { it.toBotConversation() }
+
+
+    private fun BotConversationSummary.toBotConversation(): BotConversation =
+        BotConversation (
+            id = chatId.toLong(),
+            createdAt = createdAt,
+            mostRecentMessageDate = lastMessage.createdAt,
+            lastMessage = lastMessage.content,
+            messages = listOf()
+        )
+
+    private fun uniffi.wp_api.BotConversation.toBotConversation(): BotConversation =
+        BotConversation (
+            id = chatId.toLong(),
+            createdAt = createdAt,
+            mostRecentMessageDate = messages.last().createdAt,
+            lastMessage = messages.last().content,
+            messages = messages.map { it.toBotMessage() }
+        )
+
+    private fun uniffi.wp_api.BotMessage.toBotMessage(): BotMessage =
+        BotMessage(
+            id = messageId.toLong(),
+            text = content,
+            date = createdAt,
+            isWrittenByUser = role == "user"
+        )
+}

WordPress/src/main/java/org/wordpress/android/support/aibot/ui/AIBotSupportActivity.kt

@@ -4,19 +4,24 @@ import android.content.Context
 import android.content.Intent
 import android.os.Build
 import android.os.Bundle
+import android.view.Gravity
 import androidx.activity.viewModels
 import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.lifecycle.lifecycleScope
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.composable
 import androidx.navigation.compose.rememberNavController
 import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.launch
+import org.wordpress.android.R
 import org.wordpress.android.ui.compose.theme.AppThemeM3
+import org.wordpress.android.util.ToastUtils
 
 @AndroidEntryPoint
 class AIBotSupportActivity : AppCompatActivity() {
@@ -42,7 +47,24 @@ class AIBotSupportActivity : AppCompatActivity() {
                 }
             }
         )
-        viewModel.init(intent.getStringExtra(ACCESS_TOKEN_ID)!!)
+        viewModel.init(
+            accessToken = intent.getStringExtra(ACCESS_TOKEN_ID)!!,
+            userId = intent.getLongExtra(USER_ID, 0)
+        )
+
+        // Observe error messages and show them as Toast
+        lifecycleScope.launch {
+            viewModel.errorMessage.collect { errorType ->
+                val errorMessage = when (errorType) {
+                    AIBotSupportViewModel.ErrorType.GENERAL -> getString(R.string.ai_bot_generic_error)
+                    null -> null
+                }
+                errorMessage?.let {
+                    ToastUtils.showToast(this@AIBotSupportActivity, it, ToastUtils.Duration.LONG, Gravity.CENTER)
+                    viewModel.clearError()
+                }
+            }
+        }
     }
 
     private enum class ConversationScreen {
@@ -60,28 +82,39 @@ class AIBotSupportActivity : AppCompatActivity() {
                 startDestination = ConversationScreen.List.name
             ) {
                 composable(route = ConversationScreen.List.name) {
+                    val isLoadingConversations by viewModel.isLoadingConversations.collectAsState()
                     ConversationsListScreen(
                         conversations = viewModel.conversations,
+                        isLoading = isLoadingConversations,
                         onConversationClick = { conversation ->
-                            viewModel.selectConversation(conversation)
+                            viewModel.onConversationSelected(conversation)
                             navController.navigate(ConversationScreen.Detail.name)
                         },
                         onBackClick = { finish() },
                         onCreateNewConversationClick = {
-                            viewModel.createNewConversation()
+                            viewModel.onNewConversationClicked()
                             viewModel.selectedConversation.value?.let { newConversation ->
                                 navController.navigate(ConversationScreen.Detail.name)
                             }
+                        },
+                        onRefresh = {
+                            viewModel.refreshConversations()
                         }
                     )
                 }
 
                 composable(route = ConversationScreen.Detail.name) {
                     val selectedConversation by viewModel.selectedConversation.collectAsState()
+                    val isLoadingConversation by viewModel.isLoadingConversation.collectAsState()
+                    val isBotTyping by viewModel.isBotTyping.collectAsState()
+                    val canSendMessage by viewModel.canSendMessage.collectAsState()
                     selectedConversation?.let { conversation ->
                         ConversationDetailScreen(
                             userName = userName,
                             conversation = conversation,
+                            isLoading = isLoadingConversation,
+                            isBotTyping = isBotTyping,
+                            canSendMessage = canSendMessage,
                             onBackClick = { navController.navigateUp() },
                             onSendMessage = { text ->
                                 viewModel.sendMessage(text)
@@ -95,14 +128,17 @@ class AIBotSupportActivity : AppCompatActivity() {
 
     companion object {
         private const val ACCESS_TOKEN_ID = "arg_access_token_id"
+        private const val USER_ID = "arg_user_id"
         private const val USERNAME = "arg_username"
         @JvmStatic
         fun createIntent(
             context: Context,
             accessToken: String,
+            userId: Long,
             userName: String,
         ): Intent = Intent(context, AIBotSupportActivity::class.java).apply {
             putExtra(ACCESS_TOKEN_ID, accessToken)
+            putExtra(USER_ID, userId)
             putExtra(USERNAME, userName)
         }
     }