Веб-сокет не передает полученные сообщения веб-сокета в мой класс NetworkManager ⇐ Android

[Anonymous]

По сути, у меня есть NetworkManager, который я использую для прослушивания входящих сообщений веб-сокета и их анализа, но клиент веб-сокета получает их, но не передает их сетевому менеджеру для анализа. Я пытаюсь сделать уведомление.

Код: Выделить всё

package com.pphltd.streamcloud

import android.content.Context
import android.content.Intent
import android.util.Log
import android.widget.Toast
import com.pphltd.streamcloud.SharedPreferencesUtil.saveShortsTimeoutExpiry
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.Job
import kotlinx.coroutines.withContext
import org.json.JSONObject

class NetworkManager(private val context: Context, private val webSocketClient: WebSocketClient) {

private val backgroundScope = CoroutineScope(Dispatchers.IO + Job())

init {

webSocketClient.setMessageListener { message ->
Log.d("network manager", "Received WebSocket message: $message")
onMessageReceived(message)
}

}

private fun onMessageReceived(message: String) {
Log.d("websocket-networkmanager", message)
try {
val json = JSONObject(message)
when (json.getString("type")) {
"premiumupdate_revoked" -> {
webSocketClient.updatePremiumStatus(false)
}
"premiumupdate_success" -> {
webSocketClient.updatePremiumStatus(true)
}
"loginBlockedUser" -> {
Toast.makeText(context, "Account blocked", Toast.LENGTH_LONG).show()
}
"blockuser_error" -> {
val errormessage = json.getString("message")
Toast.makeText(context, errormessage, Toast.LENGTH_SHORT).show()
}
"updateBlockBy_success" -> {
val messagestring = json.getString("message")
Toast.makeText(context, messagestring, Toast.LENGTH_SHORT).show()
}
"updateBlockBy_error" -> {
val errormessage = json.getString("message")
Toast.makeText(context, errormessage, Toast.LENGTH_SHORT).show()
}
"error" -> {
val errorMessage = json.getString("message")
Toast.makeText(context, errorMessage, Toast.LENGTH_SHORT).show()
}
"Auth_Failed" -> {
handleAuthFailed()
}
"profilePictureUploadSuccess" -> {
Toast.makeText(context, "Upload successful", Toast.LENGTH_LONG).show()
}
"ColourPackPurchased_success" -> {
Toast.makeText(context, "Colour Pack Purchased!", Toast.LENGTH_LONG).show()
}
"notification" -> {
Log.d("notification", "notification received")
val notificationID = json.optInt("id")
val notificationMessage = json.optString("message")
val notificationTimestamp = json.optString("timestamp")

AppNotificationManager.sendGeneralNotification(context, notificationMessage, notificationID, notificationTimestamp)

}
"updateShortsTimeout_success" ->  {
val shortsTimeout = json.optString("expiryDate")
saveShortsTimeoutExpiry(context, shortsTimeout)

}
}
} catch (e: Exception) {
Log.e("websocket", "Error processing WebSocket message: ${e.message}", e)

val log = "Network manager error: ${e.message}"
webSocketClient.updateUserLog(log)

}

}

private fun handleAuthFailed() {

SharedPreferencesUtil.clearUsername(context)
SharedPreferencesUtil.clearProfilePicture(context)
SharedPreferencesUtil.clearBackgroundColor(context)
SharedPreferencesUtil.clearUserData(context)
SharedPreferencesUtil.clearHistoryData(context)
SharedPreferencesUtil.clearChannelsData(context)
SharedPreferencesUtil.clearRecommendedContent(context)
SharedPreferencesUtil.clearSubscriptionsData(context)
EncryptedSharedPreferencesUtil.clearAuthToken(context)
EncryptedSharedPreferencesUtil.clearRefreshToken(context)

webSocketClient.setLoggedInStatus(false)

val intent = Intent(context, HomeActivity::class.java)
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK)
context.startActivity(intent)

}

}

Код: Выделить всё

package com.pphltd.streamcloud

import android.content.Context
import android.util.Log
import com.google.android.gms.maps.model.LatLng
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.WebSocket
import okhttp3.WebSocketListener
import okio.ByteString

class WebSocketClient(private val url: String, context: Context, private val statusCallback: (String) -> Unit) {
private val appContext: Context = context.applicationContext // Use applicationContext here
private val client: OkHttpClient = OkHttpClient()
private var webSocket: WebSocket? = null
private var messageListener: ((String) -> Unit)? = null

var isConnected: Boolean = false
var loggedin: Boolean = false
var reLogin: Boolean = true

var isPremiumUser: Boolean = false
var isColorPackAccess: Boolean = false
var issmsVerified: Boolean? = null
var isemailVerified: Boolean? = null
var isGodMode: Boolean = false

var isedge2edge: Boolean? = null

init {
connect()
}

fun setMessageListener(listener: ((String) -> Unit)?) {
this.messageListener = listener
}

fun close() {
webSocket?.close(1000, "Closing connection")
webSocket = null
isConnected = false
loggedin = false
reLogin = false
}

fun connect() {
val request = Request.Builder()
.url(url)
.build()
webSocket = client.newWebSocket(request, MyWebSocketListener())
}

fun registerWSID() {
if (loggedin &&  !reLogin) {
Log.d("websocket", "registerWSID called")

CoroutineScope(Dispatchers.IO).launch {
val username = SharedPreferencesUtil.getUsername(appContext)
val authToken = EncryptedSharedPreferencesUtil.getAuthToken(appContext) ?: ""

val lastLocation = SharedPreferencesUtil.getLastLocation(appContext)
val latitude = lastLocation.first ?: 53.73 // Default to Hull coordinates if null
val longitude = lastLocation.second ?: -0.34
val userLocation = LatLng(latitude, longitude)
val messageJson = """
{
"type": "registerwsid",
"username": "$username",
"authToken": "$authToken",
"location": "$userLocation"
}
""".trimIndent()

webSocket?.send(messageJson)
}
}
}

fun send(message: String) {
webSocket?.send(message)
}

fun updatePremiumStatus(isPremium: Boolean) {
isPremiumUser = isPremium
}

fun setLoggedInStatus(status: Boolean) {
loggedin = status
if (loggedin) {
Log.d("websocket", "update loggedin status")
registerWSID()
}
}

private inner class MyWebSocketListener : WebSocketListener() {
override fun onOpen(webSocket: WebSocket, response: Response) {
statusCallback("Connected")
isConnected = true
registerWSID()
}

override fun onMessage(webSocket: WebSocket, text: String) {
messageListener?.let { listener ->
CoroutineScope(Dispatchers.IO).launch {
Log.d("sharedpreferences", "websocket message received $text")
listener.invoke(text)
}
}
}

override fun onMessage(webSocket: WebSocket, bytes: ByteString) {}

override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
statusCallback("Not connected")
connect()
}

override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
statusCallback("Not connected")

}

override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
statusCallback("Failed to connect, Retrying...")
reLogin = false
isConnected = false
connect()
}
}

object WebSocketSingleton {
private var isInitialized = false
lateinit var webSocketClient: WebSocketClient

fun initialize(url: String, context: Context, statusCallback: (String) -> Unit) {
if (!isInitialized) {
val appContext = context.applicationContext  // Always use applicationContext here
webSocketClient = WebSocketClient(url, appContext, statusCallback)
isInitialized = true
}
}
}

Я пробовал использовать сопрограммы, а также удалял их на случай, если это была проблема, я пытался добавить весь сетевой менеджер в MainActivity, но все еще не анализировал тип уведомления

Подробнее здесь: https://stackoverflow.com/questions/793 ... ager-class