Multiplayer APIv2

android/src/com/unciv/app/AndroidLauncher.kt

@@ -6,7 +6,11 @@ import androidx.core.app.NotificationManagerCompat
 import androidx.work.WorkManager
 import com.badlogic.gdx.backends.android.AndroidApplication
 import com.badlogic.gdx.backends.android.AndroidApplicationConfiguration
+import com.unciv.app.turncheck.Common
+import com.unciv.app.turncheck.WorkerV1
+import com.unciv.app.turncheck.WorkerV2
 import com.unciv.logic.files.UncivFiles
+import com.unciv.logic.multiplayer.ApiVersion
 import com.unciv.ui.components.Fonts
 import com.unciv.utils.Display
 import com.unciv.utils.Log
@@ -33,7 +37,7 @@ open class AndroidLauncher : AndroidApplication() {
         UncivFiles.preferExternalStorage = true
 
         // Create notification channels for Multiplayer notificator
-        MultiplayerTurnCheckWorker.createNotificationChannels(applicationContext)
+        Common.createNotificationChannels(applicationContext)
 
         copyMods()
 
@@ -70,23 +74,32 @@ open class AndroidLauncher : AndroidApplication() {
 
     override fun onPause() {
         val game = this.game!!
-        if (game.isInitialized
-                && game.gameInfo != null
-                && game.settings.multiplayer.turnCheckerEnabled
-                && game.files.getMultiplayerSaves().any()
-        ) {
-            MultiplayerTurnCheckWorker.startTurnChecker(
-                applicationContext, game.files, game.gameInfo!!, game.settings.multiplayer)
+        if (game.isInitialized) {
+            if (game.onlineMultiplayer.isInitialized() && game.onlineMultiplayer.apiVersion == ApiVersion.APIv2) {
+                try {
+                    WorkerV2.start(applicationContext, game.files, game.gameInfo, game.onlineMultiplayer, game.settings.multiplayer)
+                } catch (e: Exception) {
+                    android.util.Log.e(Common.LOG_TAG, "Error during WorkverV2.start of $this: $e\nMessage: ${e.localizedMessage}\n${e.stackTraceToString()}")
+                }
+            } else if (game.gameInfo != null && game.settings.multiplayer.turnCheckerEnabled && game.files.getMultiplayerSaves().any()) {
+                WorkerV1.startTurnChecker(applicationContext, game.files, game.gameInfo!!, game.settings.multiplayer)
+            }
+        }
+        if (game.onlineMultiplayer.isInitialized() && game.onlineMultiplayer.apiVersion == ApiVersion.APIv2) {
+            game.onlineMultiplayer.api.disableReconnecting()
         }
         super.onPause()
     }
 
     override fun onResume() {
+        if (game?.onlineMultiplayer?.isInitialized() == true && game?.onlineMultiplayer?.apiVersion == ApiVersion.APIv2) {
+            game?.onlineMultiplayer?.api?.enableReconnecting()
+        }
         try {
-            WorkManager.getInstance(applicationContext).cancelAllWorkByTag(MultiplayerTurnCheckWorker.WORK_TAG)
+            WorkManager.getInstance(applicationContext).cancelAllWorkByTag(Common.WORK_TAG)
             with(NotificationManagerCompat.from(this)) {
-                cancel(MultiplayerTurnCheckWorker.NOTIFICATION_ID_INFO)
-                cancel(MultiplayerTurnCheckWorker.NOTIFICATION_ID_SERVICE)
+                cancel(Common.NOTIFICATION_ID_INFO)
+                cancel(Common.NOTIFICATION_ID_SERVICE)
             }
         } catch (ignore: Exception) {
             /* Sometimes this fails for no apparent reason - the multiplayer checker failing to

android/src/com/unciv/app/CopyToClipboardReceiver.kt

@@ -7,6 +7,7 @@ import android.content.Context
 import android.content.Intent
 import android.widget.Toast
 import com.badlogic.gdx.backends.android.AndroidApplication
+import com.unciv.app.turncheck.Common
 
 /**
  * This Receiver can be called from an Action on the error Notification shown by MultiplayerTurnCheckWorker.
@@ -16,7 +17,7 @@ import com.badlogic.gdx.backends.android.AndroidApplication
 class CopyToClipboardReceiver : BroadcastReceiver() {
     override fun onReceive(context: Context, intent: Intent) {
         val clipboard: ClipboardManager = context.getSystemService(AndroidApplication.CLIPBOARD_SERVICE) as ClipboardManager
-        val clip = ClipData.newPlainText("exception", intent.getStringExtra(MultiplayerTurnCheckWorker.CLIPBOARD_EXTRA))
+        val clip = ClipData.newPlainText("exception", intent.getStringExtra(Common.CLIPBOARD_EXTRA))
         clipboard.setPrimaryClip(clip)
         Toast.makeText(context, context.resources.getString(R.string.Notify_Error_StackTrace_Toast), Toast.LENGTH_SHORT).show()
     }

android/src/com/unciv/app/turncheck/Common.kt

@@ -0,0 +1,169 @@
+package com.unciv.app.turncheck
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.graphics.Color
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.badlogic.gdx.backends.android.AndroidApplication
+import com.unciv.app.AndroidLauncher
+import com.unciv.app.R
+import java.time.Duration
+import java.util.UUID
+
+/**
+ * Collection of common utilities for [WorkerV1] and [WorkerV2]
+ */
+object Common {
+    const val WORK_TAG = "UNCIV_MULTIPLAYER_TURN_CHECKER_WORKER"
+    const val LOG_TAG = "Unciv turn checker"
+    const val CLIPBOARD_EXTRA = "CLIPBOARD_STRING"
+    const val NOTIFICATION_ID_SERVICE = 1
+    const val NOTIFICATION_ID_INFO = 2
+
+    // Notification Channels can't be modified after creation.
+    // Therefore Unciv needs to create new ones and delete previously used ones.
+    // Add old channel names here when replacing them with new ones below.
+    private val HISTORIC_NOTIFICATION_CHANNELS = arrayOf("UNCIV_NOTIFICATION_CHANNEL_SERVICE")
+
+    internal const val NOTIFICATION_CHANNEL_ID_INFO = "UNCIV_NOTIFICATION_CHANNEL_INFO"
+    private const val NOTIFICATION_CHANNEL_ID_SERVICE = "UNCIV_NOTIFICATION_CHANNEL_SERVICE_02"
+
+    /**
+     * Notification Channel for 'It's your turn' and error notifications.
+     *
+     * This code is necessary for API level >= 26
+     * API level < 26 does not support Notification Channels
+     * For more infos: https://developer.android.com/training/notify-user/channels.html#CreateChannel
+     */
+    private fun createNotificationChannelInfo(appContext: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val name = appContext.resources.getString(R.string.Notify_ChannelInfo_Short)
+        val descriptionText = appContext.resources.getString(R.string.Notify_ChannelInfo_Long)
+        val importance = NotificationManager.IMPORTANCE_HIGH
+        val mChannel = NotificationChannel(NOTIFICATION_CHANNEL_ID_INFO, name, importance)
+        mChannel.description = descriptionText
+        mChannel.setShowBadge(true)
+        mChannel.lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+
+        val notificationManager = appContext.getSystemService(AndroidApplication.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.createNotificationChannel(mChannel)
+    }
+
+    /**
+     * Notification Channel for persistent service notification.
+     *
+     * This code is necessary for API level >= 26
+     * API level < 26 does not support Notification Channels
+     * For more infos: https://developer.android.com/training/notify-user/channels.html#CreateChannel
+     */
+    private fun createNotificationChannelService(appContext: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val name = appContext.resources.getString(R.string.Notify_ChannelService_Short)
+        val descriptionText = appContext.resources.getString(R.string.Notify_ChannelService_Long)
+        val importance = NotificationManager.IMPORTANCE_MIN
+        val mChannel = NotificationChannel(NOTIFICATION_CHANNEL_ID_SERVICE, name, importance)
+        mChannel.setShowBadge(false)
+        mChannel.lockscreenVisibility = NotificationCompat.VISIBILITY_PUBLIC
+        mChannel.description = descriptionText
+
+        val notificationManager = appContext.getSystemService(AndroidApplication.NOTIFICATION_SERVICE) as NotificationManager
+        notificationManager.createNotificationChannel(mChannel)
+    }
+
+    /**
+     * The persistent notification is purely for informational reasons.
+     * It is not technically necessary for the Worker, since it is not a Service.
+     */
+    fun showPersistentNotification(appContext: Context, lastTimeChecked: String, checkPeriod: Duration) {
+        val flags = (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) or
+                PendingIntent.FLAG_UPDATE_CURRENT
+        val pendingIntent: PendingIntent =
+                Intent(appContext, AndroidLauncher::class.java).let { notificationIntent ->
+                    PendingIntent.getActivity(appContext, 0, notificationIntent, flags)
+                }
+
+        val notification: NotificationCompat.Builder = NotificationCompat.Builder(appContext, NOTIFICATION_CHANNEL_ID_SERVICE)
+            .setPriority(NotificationManagerCompat.IMPORTANCE_MIN) // it's only a status
+            .setContentTitle(appContext.resources.getString(R.string.Notify_Persist_Short) + " " + lastTimeChecked)
+            .setStyle(
+                NotificationCompat.BigTextStyle()
+                .bigText(appContext.resources.getString(R.string.Notify_Persist_Long_P1) + " " +
+                        appContext.resources.getString(R.string.Notify_Persist_Long_P2) + " " + checkPeriod.seconds / 60f + " "
+                        + appContext.resources.getString(R.string.Notify_Persist_Long_P3)
+                        + " " + appContext.resources.getString(R.string.Notify_Persist_Long_P4)))
+            .setSmallIcon(R.drawable.uncivnotification)
+            .setContentIntent(pendingIntent)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setOnlyAlertOnce(true)
+            .setOngoing(true)
+            .setShowWhen(false)
+
+        with(NotificationManagerCompat.from(appContext)) {
+            notify(NOTIFICATION_ID_INFO, notification.build())
+        }
+    }
+
+    /**
+     * Create a new notification to inform a user that its his turn in a specfic game
+     *
+     * The [game] is a pair of game name and game ID (which is a [UUID]).
+     */
+    fun notifyUserAboutTurn(applicationContext: Context, game: Pair<String, String>) {
+        Log.i(LOG_TAG, "notifyUserAboutTurn ${game.first} (${game.second})")
+        val intent = Intent(applicationContext, AndroidLauncher::class.java).apply {
+            action = Intent.ACTION_VIEW
+            data = Uri.parse("https://unciv.app/multiplayer?id=${game.second}")
+        }
+        val flags = (if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) PendingIntent.FLAG_IMMUTABLE else 0) or
+                PendingIntent.FLAG_UPDATE_CURRENT
+        val pendingIntent = PendingIntent.getActivity(applicationContext, 0, intent, flags)
+
+        val contentTitle = applicationContext.resources.getString(R.string.Notify_YourTurn_Short)
+        val notification: NotificationCompat.Builder = NotificationCompat.Builder(applicationContext, NOTIFICATION_CHANNEL_ID_INFO)
+            .setPriority(NotificationManagerCompat.IMPORTANCE_HIGH) // people are waiting!
+            .setContentTitle(contentTitle)
+            .setContentText(applicationContext.resources.getString(R.string.Notify_YourTurn_Long).replace("[gameName]", game.first))
+            .setTicker(contentTitle)
+            // without at least vibrate, some Android versions don't show a heads-up notification
+            .setDefaults(NotificationCompat.DEFAULT_VIBRATE)
+            .setLights(Color.YELLOW, 300, 100)
+            .setSmallIcon(R.drawable.uncivnotification)
+            .setContentIntent(pendingIntent)
+            .setCategory(NotificationCompat.CATEGORY_SOCIAL)
+            .setOngoing(false)
+
+        with(NotificationManagerCompat.from(applicationContext)) {
+            notify(NOTIFICATION_ID_INFO, notification.build())
+        }
+    }
+
+    /**
+     * Necessary for Multiplayer Turner Checker, starting with Android Oreo
+     */
+    fun createNotificationChannels(appContext: Context) {
+        createNotificationChannelInfo(appContext)
+        createNotificationChannelService(appContext)
+        destroyOldChannels(appContext)
+    }
+
+    /**
+     * Notification Channels can't be modified after creation.
+     * Therefore Unciv needs to create new ones and delete legacy ones.
+     */
+    private fun destroyOldChannels(appContext: Context) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
+        val notificationManager = appContext.getSystemService(AndroidApplication.NOTIFICATION_SERVICE) as NotificationManager
+        HISTORIC_NOTIFICATION_CHANNELS.forEach {
+            if (null != notificationManager.getNotificationChannel(it)) {
+                notificationManager.deleteNotificationChannel(it)
+            }
+        }
+    }
+}