@capacitor/background-runner 1.0.0-rc.1

package/android/src/main/java/io/ionic/backgroundrunner/plugin/CoroutineHelper.kt

@@ -0,0 +1,21 @@
+package io.ionic.backgroundrunner.plugin
+
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.first
+
+class ConditionalAwait<T>(
+    private val stateFlow: StateFlow<T>,
+    private val condition: (T) -> Boolean
+) {
+    suspend fun await(): T {
+        val nowValue = stateFlow.value
+        return if (condition(nowValue)) {
+            nowValue
+        } else {
+            stateFlow.first { condition(it) }
+        }
+    }
+}
+
+suspend fun <T> StateFlow<T>.conditionalAwait(condition: (T) -> Boolean): T =
+    ConditionalAwait(this, condition).await()

package/android/src/main/java/io/ionic/backgroundrunner/plugin/RunnerConfig.kt

@@ -0,0 +1,33 @@
+package io.ionic.backgroundrunner.plugin;
+
+import org.json.JSONObject
+import java.lang.Exception
+
+class RunnerConfig(configObject: JSONObject) {
+    val label: String
+    val src: String
+    val autoSchedule: Boolean
+    val repeats: Boolean
+    var event: String
+    val interval: Int?
+
+    init {
+        val labelStr = configObject.getString("label")
+        if (labelStr.isNullOrEmpty()) {
+            throw Exception("runner label is missing or invalid")
+        }
+
+        val srcStr = configObject.getString("src")
+        if (srcStr.isNullOrEmpty()) {
+            throw Exception("runner source file path is missing or invalid")
+        }
+
+        label = labelStr
+        src = srcStr
+        autoSchedule = configObject.optBoolean("autoStart", false)
+        event = configObject.optString("event")
+        repeats = configObject.optBoolean("repeat")
+        interval = configObject.optInt("interval", 0)
+    }
+}
+

package/android/src/main/java/io/ionic/backgroundrunner/plugin/RunnerWorker.kt

@@ -0,0 +1,46 @@
+package io.ionic.backgroundrunner.plugin;
+
+import android.content.Context
+import androidx.work.Data
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.runBlocking
+import org.json.JSONObject
+
+class RunnerWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
+    override fun doWork(): Result {
+        try {
+            val label = this.inputData.getString("label") ?: ""
+            val src = this.inputData.getString("src") ?: ""
+            val event = this.inputData.getString("event") ?: ""
+
+            if (label.isEmpty() || src.isEmpty() || event.isEmpty()) {
+                throw Exception("label is empty")
+            }
+
+            val runnerConfigObj = JSONObject()
+            runnerConfigObj.put("label", label)
+            runnerConfigObj.put("src", src)
+            runnerConfigObj.put("event", event)
+            runnerConfigObj.put("autoStart", false)
+            runnerConfigObj.put("repeats", false)
+            runnerConfigObj.put("interval", 0)
+
+            val config = RunnerConfig(runnerConfigObj)
+
+            runBlocking {
+                val impl = BackgroundRunner.getInstance(this@RunnerWorker.applicationContext)
+                impl.execute(this@RunnerWorker.applicationContext, config, JSONObject())
+            }
+
+            return Result.success()
+        } catch (ex: Exception) {
+            val data = Data.Builder()
+                .putString("error", ex.toString())
+                .build()
+
+            return Result.failure(data)
+        }
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/Device.kt

@@ -0,0 +1,99 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.os.BatteryManager
+import android.os.Build
+import io.ionic.android_js_engine.api.DeviceAPI
+import org.json.JSONObject
+
+
+class Device (context: android.content.Context) : DeviceAPI {
+    private val context: android.content.Context
+    private val connectivityManager: ConnectivityManager
+
+    init {
+        this.context = context
+        this.connectivityManager = this.context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager;
+    }
+
+    override fun getBatteryStatus(): String {
+        val batteryInfo = JSONObject()
+        batteryInfo.put("batteryLevel", this.getBatteryLevel())
+        batteryInfo.put("isCharging", this.isCharging())
+
+        return batteryInfo.toString()
+    }
+
+    override fun getNetworkStatus(): String {
+        var status = NetworkStatus()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            val activeNetwork: Network? = this.connectivityManager.activeNetwork
+            val capabilities: NetworkCapabilities? =
+                this.connectivityManager.getNetworkCapabilities(this.connectivityManager.activeNetwork)
+            if (activeNetwork != null && capabilities != null) {
+                status.connected =
+                    capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) &&
+                            capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+                    status.connectionType = NetworkStatus.ConnectionType.WIFI
+                } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+                    status.connectionType = NetworkStatus.ConnectionType.CELLULAR
+                } else {
+                    status.connectionType = NetworkStatus.ConnectionType.UNKNOWN
+                }
+            }
+        } else {
+            status = getAndParseNetworkInfo()
+        }
+
+        val networkInfo = JSONObject()
+        networkInfo.put("connected", status.connected)
+        networkInfo.put("connectionType", status.connectionType)
+
+        return networkInfo.toString()
+    }
+
+    private fun getBatteryLevel(): Float {
+        val ifilter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
+        val batteryStatus = context.registerReceiver(null, ifilter)
+        var level = -1
+        var scale = -1
+        if (batteryStatus != null) {
+            level = batteryStatus.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
+            scale = batteryStatus.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
+        }
+        return level / scale.toFloat()
+    }
+
+    private fun isCharging(): Boolean {
+        val ifilter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
+        val batteryStatus = context.registerReceiver(null, ifilter)
+        if (batteryStatus != null) {
+            val status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1)
+            return status == BatteryManager.BATTERY_STATUS_CHARGING || status == BatteryManager.BATTERY_STATUS_FULL
+        }
+        return false
+    }
+
+    @SuppressWarnings("deprecation")
+    private fun getAndParseNetworkInfo(): NetworkStatus {
+        val networkStatus = NetworkStatus()
+        val networkInfo = connectivityManager.activeNetworkInfo
+        if (networkInfo != null) {
+            networkStatus.connected = networkInfo.isConnected
+            val typeName = networkInfo.typeName
+            if (typeName == "WIFI") {
+                networkStatus.connectionType = NetworkStatus.ConnectionType.WIFI
+            } else if (typeName == "MOBILE") {
+                networkStatus.connectionType = NetworkStatus.ConnectionType.CELLULAR
+            }
+        }
+        return networkStatus
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/Geolocation.kt

@@ -0,0 +1,55 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.content.Context
+import android.location.Location
+import android.location.LocationManager
+import androidx.core.location.LocationManagerCompat
+import io.ionic.android_js_engine.api.GeolocationAPI
+import org.json.JSONObject
+import java.lang.Exception
+
+class Geolocation(context: android.content.Context) : GeolocationAPI {
+    val manager: LocationManager
+    val context: android.content.Context
+
+    init {
+        this.context = context
+        this.manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+    }
+
+    companion object {
+        fun isEnabled(context: Context): Boolean {
+            val manager = context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
+            return LocationManagerCompat.isLocationEnabled(manager);
+        }
+    }
+
+    override fun getCurrentPosition(): String? {
+        if (!isEnabled(this.context)) {
+            throw Exception("Capacitor Geolocation location services not enabled")
+        }
+
+        var lastLocation: Location? = null
+
+        this.manager.allProviders.forEach {
+            val tempLocation = this.manager.getLastKnownLocation(it)
+            if (tempLocation != null) {
+                if (lastLocation == null || lastLocation!!.elapsedRealtimeNanos > tempLocation.elapsedRealtimeNanos) {
+                    lastLocation = tempLocation
+                }
+            }
+        }
+
+        val location = lastLocation ?: return null
+
+        val locationInfo = JSONObject();
+        locationInfo.put("latitude", location.latitude)
+        locationInfo.put("longitude", location.longitude)
+        locationInfo.put("accuracy", location.accuracy)
+        locationInfo.put("altitude", location.altitude)
+        locationInfo.put("speed", location.speed)
+        locationInfo.put("heading", location.bearing)
+
+        return locationInfo.toString()
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/KV.kt

@@ -0,0 +1,29 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.content.Context
+import android.content.SharedPreferences
+import io.ionic.android_js_engine.api.KVAPI
+
+class KV (context: android.content.Context, label: String) : KVAPI {
+    private val prefs: SharedPreferences
+
+    init {
+        this.prefs = context.getSharedPreferences(label, Context.MODE_PRIVATE)
+    }
+
+    override fun set(key: String, value: String) {
+        val editor: SharedPreferences.Editor = prefs.edit()
+        editor.putString(key, value)
+        editor.apply()
+    }
+
+    override fun get(key: String): String? {
+        return prefs.getString(key, null)
+    }
+
+    override fun remove(key: String) {
+        val editor: SharedPreferences.Editor = prefs.edit()
+        editor.remove(key)
+        editor.apply()
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/NetworkStatus.kt

@@ -0,0 +1,10 @@
+package io.ionic.backgroundrunner.plugin.api
+
+class NetworkStatus {
+    enum class ConnectionType(val connectionType: String) {
+        WIFI("wifi"), CELLULAR("cellular"), NONE("none"), UNKNOWN("unknown");
+    }
+
+    var connected = false
+    var connectionType = ConnectionType.NONE
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/Notification.kt

@@ -0,0 +1,59 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.annotation.SuppressLint
+import com.getcapacitor.plugin.util.AssetUtil
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.TimeZone
+
+@SuppressLint("SimpleDateFormat")
+class Notification(jsonObject: JSONObject) {
+    var id: Int
+    var title: String
+    var body: String
+    var ongoing: Boolean
+    var autoCancel: Boolean
+    var scheduleAt: Date
+    var largeBody: String? = null
+    var summaryText: String? = null
+    var sound: String? = null
+    var smallIcon: String? = null
+    var largeIcon: String? = null
+    var actionTypeID: String? = null
+    var extra: HashMap<String, Any>? = null
+    var group: String? = null
+    var groupSummary: String? = null
+    var channelId: String? = null
+
+    private val jsDateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
+
+    init {
+        id = jsonObject.optInt("id", -1)
+        title = jsonObject.optString("title", "")
+        body = jsonObject.optString("body", "")
+        ongoing = jsonObject.optBoolean("ongoing", false)
+        autoCancel = jsonObject.optBoolean("autoCancel", false)
+
+        val scheduleDateString = jsonObject.getString("scheduleAt")
+
+        val sdf = SimpleDateFormat(jsDateFormat)
+        val parsedDate = sdf.parse(scheduleDateString)
+
+        scheduleAt = parsedDate ?: Date()
+    }
+
+    fun smallIcon(context: android.content.Context, defaultIcon: Int): Int {
+        var resId = AssetUtil.RESOURCE_ID_ZERO_VALUE
+
+        if (smallIcon != null) {
+            resId = AssetUtil.getResourceID(context, smallIcon, "drawable")
+        }
+
+        if (resId == AssetUtil.RESOURCE_ID_ZERO_VALUE) {
+            resId = defaultIcon
+        }
+
+        return resId
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/Notifications.kt

@@ -0,0 +1,158 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.R.drawable
+import android.app.AlarmManager
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.net.Uri
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import com.getcapacitor.Logger.config
+import com.getcapacitor.plugin.util.AssetUtil
+import io.ionic.android_js_engine.api.NotificationsAPI
+import org.json.JSONArray
+
+class Notifications(context: Context) : NotificationsAPI {
+    private val manager: NotificationManagerCompat
+    private val context: Context
+
+    var defaultSmallIconID = AssetUtil.RESOURCE_ID_ZERO_VALUE
+    var defaultSoundID = AssetUtil.RESOURCE_ID_ZERO_VALUE
+
+    init {
+        this.context = context
+        this.manager = NotificationManagerCompat.from(context)
+
+        this.createNotificationChannel()
+    }
+    companion object {
+        const val notificationIntentKey = "LocalNotificationId"
+        const val defaultNotificationChannelID = "default"
+    }
+
+    override fun schedule(jsonString: String) {
+        val notifications = mutableListOf<Notification>()
+
+        try {
+            val options = JSONArray(jsonString)
+            for(i in 0 until options.length()) {
+                notifications.add(i, Notification(options.getJSONObject(i)))
+            }
+        } catch(ex: Exception) {
+            throw Exception("options must be an array: ${ex.localizedMessage}")
+        }
+
+        notifications.forEach {
+            val channelId = it.channelId ?: defaultNotificationChannelID
+
+            val builder = NotificationCompat.Builder(context, channelId)
+            builder.setContentTitle(it.title)
+            builder.setContentText(it.body)
+            builder.setAutoCancel(it.autoCancel)
+            builder.setOngoing(it.ongoing)
+            builder.priority = NotificationCompat.PRIORITY_DEFAULT
+            builder.setGroupSummary(it.groupSummary != null)
+            builder.setSmallIcon(it.smallIcon(this.context, getDefaultSmallIcon()))
+
+            val largeBody = it.largeBody
+            if (largeBody != null) {
+                val style = NotificationCompat.BigTextStyle()
+                style.bigText(largeBody)
+                style.setSummaryText(it.summaryText)
+            }
+
+            scheduleNotification(builder.build(), it)
+        }
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val name: CharSequence = "Default"
+            val description = "Default"
+            val importance = NotificationManager.IMPORTANCE_DEFAULT
+            val channel = NotificationChannel(defaultNotificationChannelID, name, importance)
+            channel.description = description
+            val audioAttributes = AudioAttributes.Builder()
+                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                .setUsage(AudioAttributes.USAGE_ALARM)
+                .build()
+            val soundUri = this.getDefaultSoundUrl(context)
+            if (soundUri != null) {
+                channel.setSound(soundUri, audioAttributes)
+            }
+
+            val notificationManager = context.getSystemService(
+                NotificationManager::class.java
+            )
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun getDefaultSoundUrl(context: Context): Uri? {
+        val soundId = getDefaultSound(context)
+        return if (soundId != AssetUtil.RESOURCE_ID_ZERO_VALUE) {
+            Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + soundId)
+        } else null
+    }
+
+    private fun getDefaultSmallIcon(): Int {
+        if (defaultSmallIconID != AssetUtil.RESOURCE_ID_ZERO_VALUE) return defaultSmallIconID
+        var resId = AssetUtil.RESOURCE_ID_ZERO_VALUE
+        var smallIconConfigResourceName = config.getString("smallIcon")
+        smallIconConfigResourceName = AssetUtil.getResourceBaseName(smallIconConfigResourceName)
+        if (smallIconConfigResourceName != null) {
+            resId = AssetUtil.getResourceID(context, smallIconConfigResourceName, "drawable")
+        }
+        if (resId == AssetUtil.RESOURCE_ID_ZERO_VALUE) {
+            resId = drawable.ic_dialog_info
+        }
+        defaultSmallIconID = resId
+        return resId
+    }
+
+    private fun getDefaultSound(context: Context): Int {
+        if (defaultSoundID != AssetUtil.RESOURCE_ID_ZERO_VALUE) return defaultSoundID
+        var resId = AssetUtil.RESOURCE_ID_ZERO_VALUE
+        var soundConfigResourceName = config.getString("sound")
+        soundConfigResourceName = AssetUtil.getResourceBaseName(soundConfigResourceName)
+        if (soundConfigResourceName != null) {
+            resId = AssetUtil.getResourceID(context, soundConfigResourceName, "raw")
+        }
+        defaultSoundID = resId
+        return resId
+    }
+
+    private fun scheduleNotification(notification: android.app.Notification, request: Notification) {
+        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val intent = Intent(context, TimedNotificationPublisher::class.java)
+        intent.putExtra(notificationIntentKey, request.id)
+        intent.putExtra(TimedNotificationPublisher.NOTIFICATION_KEY, notification)
+        var flags = PendingIntent.FLAG_CANCEL_CURRENT
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            flags = flags or PendingIntent.FLAG_MUTABLE
+        }
+
+        val pendingIntent =
+            PendingIntent.getBroadcast(context, request.id, intent, flags)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S && !alarmManager.canScheduleExactAlarms()) {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, request.scheduleAt.time, pendingIntent);
+            } else {
+                alarmManager.set(AlarmManager.RTC, request.scheduleAt.time, pendingIntent);
+            }
+        } else {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, request.scheduleAt.time, pendingIntent);
+            } else {
+                alarmManager.setExact(AlarmManager.RTC, request.scheduleAt.time, pendingIntent);
+            }
+        }
+    }
+}

package/android/src/main/java/io/ionic/backgroundrunner/plugin/api/TimedNotificationPublisher.kt

@@ -0,0 +1,40 @@
+package io.ionic.backgroundrunner.plugin.api
+
+import android.app.NotificationManager
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import com.getcapacitor.Logger
+
+class TimedNotificationPublisher : BroadcastReceiver() {
+    companion object {
+        const val NOTIFICATION_KEY = "NotificationPublisher.notification"
+    }
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        val notificationManager =
+            context!!.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+        val notification: android.app.Notification?
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            notification = intent!!.getParcelableExtra(NOTIFICATION_KEY, android.app.Notification::class.java)
+        } else {
+            notification = getParcelableExtraLegacy(intent!!)
+        }
+
+        notification?.`when` = System.currentTimeMillis()
+
+        val id =
+            intent.getIntExtra(Notifications.notificationIntentKey, Int.MIN_VALUE)
+        if (id == Int.MIN_VALUE) {
+            Logger.error(Logger.tags("LN"), "No valid id supplied", null)
+        }
+        notificationManager.notify(id, notification)
+    }
+
+    private fun getParcelableExtraLegacy(intent: Intent): android.app.Notification? {
+        return intent.getParcelableExtra(NOTIFICATION_KEY)
+    }
+}