Websocket leitet die empfangenen Websocket-Nachrichten nicht an meine NetworkManager-Klasse weiter ⇐ Android

[Guest]

Grundsätzlich habe ich NetworkManager, mit dem ich auf eingehende Websocket-Nachrichten höre und diese analysiere, aber der Websocketclient empfängt sie, leitet sie aber nicht zum Parsen an den Netzwerkmanager weiter. Das, was ich versuche, ist eine Benachrichtigung.

Code: Select all

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)

}

}

Code: Select all

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
}
}
}

Ich habe versucht, Coroutinen zu verwenden und sie auch entfernt, nur für den Fall, dass das ein Problem war. Ich habe versucht, den gesamten Netzwerkmanager zu MainActivity hinzuzufügen, habe den Benachrichtigungsnachrichtentyp jedoch immer noch nicht analysiert