native-update 1.0.0

package/android/src/main/java/com/aoneahsan/nativeupdate/AppReviewPlugin.kt

@@ -0,0 +1,153 @@
+package com.aoneahsan.nativeupdate
+
+import android.app.Activity
+import android.content.Context
+import com.getcapacitor.JSObject
+import com.getcapacitor.PluginCall
+import com.google.android.play.core.review.ReviewInfo
+import com.google.android.play.core.review.ReviewManager
+import com.google.android.play.core.review.ReviewManagerFactory
+import java.util.concurrent.TimeUnit
+
+class AppReviewPlugin(
+    private val activity: Activity,
+    private val context: Context
+) {
+    private val reviewManager: ReviewManager = ReviewManagerFactory.create(context)
+    private var config: JSObject? = null
+    private val prefs = context.getSharedPreferences("native_update_review", Context.MODE_PRIVATE)
+    
+    companion object {
+        private const val PREF_INSTALL_DATE = "install_date"
+        private const val PREF_LAST_REVIEW_REQUEST = "last_review_request"
+        private const val PREF_LAUNCH_COUNT = "launch_count"
+        private const val PREF_REVIEW_SHOWN_COUNT = "review_shown_count"
+    }
+    
+    init {
+        // Initialize install date if not set
+        if (!prefs.contains(PREF_INSTALL_DATE)) {
+            prefs.edit().putLong(PREF_INSTALL_DATE, System.currentTimeMillis()).apply()
+        }
+        
+        // Increment launch count
+        incrementLaunchCount()
+    }
+    
+    fun configure(config: JSObject) {
+        this.config = config
+    }
+    
+    fun requestReview(call: PluginCall) {
+        // First check if we can request a review
+        val canRequestResult = checkCanRequestReview()
+        
+        if (!canRequestResult.first) {
+            val result = JSObject()
+            result.put("shown", false)
+            result.put("error", canRequestResult.second)
+            call.resolve(result)
+            return
+        }
+        
+        // Request review info
+        val request = reviewManager.requestReviewFlow()
+        
+        request.addOnCompleteListener { task ->
+            if (task.isSuccessful) {
+                val reviewInfo = task.result
+                launchReviewFlow(reviewInfo, call)
+            } else {
+                val result = JSObject()
+                result.put("shown", false)
+                result.put("error", "Failed to request review flow")
+                call.resolve(result)
+            }
+        }
+    }
+    
+    fun canRequestReview(call: PluginCall) {
+        val (allowed, reason) = checkCanRequestReview()
+        
+        val result = JSObject()
+        result.put("allowed", allowed)
+        if (!allowed) {
+            result.put("reason", reason)
+        }
+        
+        call.resolve(result)
+    }
+    
+    private fun launchReviewFlow(reviewInfo: ReviewInfo, call: PluginCall) {
+        val flow = reviewManager.launchReviewFlow(activity, reviewInfo)
+        
+        flow.addOnCompleteListener { _ ->
+            // The flow has finished. The API does not indicate whether the user
+            // reviewed or not, or even whether the review dialog was shown.
+            // Update last review request time
+            prefs.edit().putLong(PREF_LAST_REVIEW_REQUEST, System.currentTimeMillis()).apply()
+            
+            // Increment shown count
+            val shownCount = prefs.getInt(PREF_REVIEW_SHOWN_COUNT, 0)
+            prefs.edit().putInt(PREF_REVIEW_SHOWN_COUNT, shownCount + 1).apply()
+            
+            val result = JSObject()
+            result.put("shown", true)
+            call.resolve(result)
+        }.addOnFailureListener { e ->
+            val result = JSObject()
+            result.put("shown", false)
+            result.put("error", e.message)
+            call.resolve(result)
+        }
+    }
+    
+    private fun checkCanRequestReview(): Pair<Boolean, String?> {
+        val now = System.currentTimeMillis()
+        val installDate = prefs.getLong(PREF_INSTALL_DATE, now)
+        val lastReviewRequest = prefs.getLong(PREF_LAST_REVIEW_REQUEST, 0)
+        val launchCount = prefs.getInt(PREF_LAUNCH_COUNT, 0)
+        val shownCount = prefs.getInt(PREF_REVIEW_SHOWN_COUNT, 0)
+        
+        // Check if debug mode is enabled
+        val debugMode = config?.getBool("debugMode") ?: false
+        if (debugMode) {
+            return Pair(true, null)
+        }
+        
+        // Check minimum days since install
+        val minDaysSinceInstall = config?.getInteger("minimumDaysSinceInstall") ?: 7
+        val daysSinceInstall = TimeUnit.MILLISECONDS.toDays(now - installDate)
+        if (daysSinceInstall < minDaysSinceInstall) {
+            return Pair(false, "Not enough days since install")
+        }
+        
+        // Check minimum days since last prompt
+        if (lastReviewRequest > 0) {
+            val minDaysSinceLastPrompt = config?.getInteger("minimumDaysSinceLastPrompt") ?: 90
+            val daysSinceLastPrompt = TimeUnit.MILLISECONDS.toDays(now - lastReviewRequest)
+            if (daysSinceLastPrompt < minDaysSinceLastPrompt) {
+                return Pair(false, "Too soon since last review request")
+            }
+        }
+        
+        // Check minimum launch count
+        val minLaunchCount = config?.getInteger("minimumLaunchCount") ?: 3
+        if (launchCount < minLaunchCount) {
+            return Pair(false, "Not enough app launches")
+        }
+        
+        // Google Play has internal quotas that we can't check directly
+        // But we can limit our own requests to be safe
+        if (shownCount >= 3) {
+            return Pair(false, "Review quota exceeded")
+        }
+        
+        return Pair(true, null)
+    }
+    
+    private fun incrementLaunchCount() {
+        val currentCount = prefs.getInt(PREF_LAUNCH_COUNT, 0)
+        prefs.edit().putInt(PREF_LAUNCH_COUNT, currentCount + 1).apply()
+    }
+}

package/android/src/main/java/com/aoneahsan/nativeupdate/AppUpdatePlugin.kt

@@ -0,0 +1,275 @@
+package com.aoneahsan.nativeupdate
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import com.getcapacitor.JSObject
+import com.getcapacitor.PluginCall
+import com.google.android.play.core.appupdate.AppUpdateInfo
+import com.google.android.play.core.appupdate.AppUpdateManager
+import com.google.android.play.core.appupdate.AppUpdateManagerFactory
+import com.google.android.play.core.appupdate.AppUpdateOptions
+import com.google.android.play.core.install.InstallState
+import com.google.android.play.core.install.InstallStateUpdatedListener
+import com.google.android.play.core.install.model.AppUpdateType
+import com.google.android.play.core.install.model.InstallStatus
+import com.google.android.play.core.install.model.UpdateAvailability
+import com.google.android.play.core.ktx.isFlexibleUpdateAllowed
+import com.google.android.play.core.ktx.isImmediateUpdateAllowed
+import kotlinx.coroutines.tasks.await
+
+class AppUpdatePlugin(
+    private val activity: Activity,
+    private val context: Context
+) {
+    private val appUpdateManager: AppUpdateManager = AppUpdateManagerFactory.create(context)
+    private var config: JSObject? = null
+    private var updateInfo: AppUpdateInfo? = null
+    
+    companion object {
+        const val REQUEST_CODE_UPDATE = 12345
+    }
+    
+    private val installStateUpdatedListener = InstallStateUpdatedListener { state ->
+        handleInstallState(state)
+    }
+    
+    init {
+        appUpdateManager.registerListener(installStateUpdatedListener)
+    }
+    
+    fun configure(config: JSObject) {
+        this.config = config
+    }
+    
+    fun getAppUpdateInfo(call: PluginCall) {
+        val appUpdateInfoTask = appUpdateManager.appUpdateInfo
+        
+        appUpdateInfoTask.addOnSuccessListener { appUpdateInfo ->
+            this.updateInfo = appUpdateInfo
+            
+            val result = JSObject()
+            result.put("updateAvailable", appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE)
+            result.put("currentVersion", getCurrentAppVersion())
+            result.put("availableVersion", appUpdateInfo.availableVersionCode().toString())
+            result.put("updatePriority", appUpdateInfo.updatePriority())
+            result.put("immediateUpdateAllowed", appUpdateInfo.isImmediateUpdateAllowed)
+            result.put("flexibleUpdateAllowed", appUpdateInfo.isFlexibleUpdateAllowed)
+            result.put("clientVersionStalenessDays", appUpdateInfo.clientVersionStalenessDays() ?: -1)
+            
+            // Add install status if update is in progress
+            if (appUpdateInfo.installStatus() != InstallStatus.UNKNOWN) {
+                result.put("installStatus", getInstallStatusString(appUpdateInfo.installStatus()))
+                result.put("bytesDownloaded", appUpdateInfo.bytesDownloaded())
+                result.put("totalBytesToDownload", appUpdateInfo.totalBytesToDownload())
+            }
+            
+            call.resolve(result)
+        }.addOnFailureListener { e ->
+            call.reject("UPDATE_CHECK_FAILED", e.message)
+        }
+    }
+    
+    fun performImmediateUpdate(call: PluginCall) {
+        val appUpdateInfo = updateInfo
+        
+        if (appUpdateInfo == null) {
+            // Need to check for updates first
+            appUpdateManager.appUpdateInfo.addOnSuccessListener { info ->
+                this.updateInfo = info
+                startImmediateUpdate(info, call)
+            }.addOnFailureListener { e ->
+                call.reject("UPDATE_CHECK_FAILED", e.message)
+            }
+        } else {
+            startImmediateUpdate(appUpdateInfo, call)
+        }
+    }
+    
+    fun startFlexibleUpdate(call: PluginCall) {
+        val appUpdateInfo = updateInfo
+        
+        if (appUpdateInfo == null) {
+            // Need to check for updates first
+            appUpdateManager.appUpdateInfo.addOnSuccessListener { info ->
+                this.updateInfo = info
+                startFlexibleUpdateFlow(info, call)
+            }.addOnFailureListener { e ->
+                call.reject("UPDATE_CHECK_FAILED", e.message)
+            }
+        } else {
+            startFlexibleUpdateFlow(appUpdateInfo, call)
+        }
+    }
+    
+    fun completeFlexibleUpdate(call: PluginCall) {
+        appUpdateManager.completeUpdate()
+        call.resolve()
+    }
+    
+    fun openAppStore(call: PluginCall) {
+        try {
+            val packageName = call.getString("appId") ?: context.packageName
+            
+            // Try to open in Play Store app first
+            try {
+                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=$packageName"))
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                context.startActivity(intent)
+            } catch (e: Exception) {
+                // Fallback to web browser
+                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=$packageName"))
+                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                context.startActivity(intent)
+            }
+            
+            call.resolve()
+        } catch (e: Exception) {
+            call.reject("OPEN_STORE_FAILED", e.message)
+        }
+    }
+    
+    private fun startImmediateUpdate(appUpdateInfo: AppUpdateInfo, call: PluginCall) {
+        if (!appUpdateInfo.isImmediateUpdateAllowed) {
+            call.reject("UPDATE_NOT_ALLOWED", "Immediate update is not allowed")
+            return
+        }
+        
+        try {
+            val updateOptions = AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build()
+            
+            appUpdateManager.startUpdateFlow(
+                appUpdateInfo,
+                activity,
+                updateOptions
+            )
+            
+            call.resolve()
+        } catch (e: Exception) {
+            call.reject("UPDATE_FAILED", e.message)
+        }
+    }
+    
+    private fun startFlexibleUpdateFlow(appUpdateInfo: AppUpdateInfo, call: PluginCall) {
+        if (!appUpdateInfo.isFlexibleUpdateAllowed) {
+            call.reject("UPDATE_NOT_ALLOWED", "Flexible update is not allowed")
+            return
+        }
+        
+        try {
+            val updateOptions = AppUpdateOptions.newBuilder(AppUpdateType.FLEXIBLE).build()
+            
+            appUpdateManager.startUpdateFlow(
+                appUpdateInfo,
+                activity,
+                updateOptions
+            )
+            
+            call.resolve()
+        } catch (e: Exception) {
+            call.reject("UPDATE_FAILED", e.message)
+        }
+    }
+    
+    private fun handleInstallState(state: InstallState) {
+        when (state.installStatus()) {
+            InstallStatus.DOWNLOADED -> {
+                // Update has been downloaded, prompt user to restart
+                popupSnackbarForCompleteUpdate()
+            }
+            InstallStatus.INSTALLED -> {
+                // Update installed, cleanup
+                appUpdateManager.unregisterListener(installStateUpdatedListener)
+            }
+            InstallStatus.FAILED -> {
+                // Update failed
+            }
+            else -> {
+                // Handle other states
+            }
+        }
+    }
+    
+    private fun popupSnackbarForCompleteUpdate() {
+        // In a real implementation, show a snackbar or notification
+        // For now, we'll just complete the update
+        appUpdateManager.completeUpdate()
+    }
+    
+    private fun getCurrentAppVersion(): String {
+        return try {
+            val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+            packageInfo.versionName ?: "Unknown"
+        } catch (e: Exception) {
+            "Unknown"
+        }
+    }
+    
+    private fun getInstallStatusString(status: Int): String {
+        return when (status) {
+            InstallStatus.PENDING -> "PENDING"
+            InstallStatus.DOWNLOADING -> "DOWNLOADING"
+            InstallStatus.DOWNLOADED -> "DOWNLOADED"
+            InstallStatus.INSTALLING -> "INSTALLING"
+            InstallStatus.INSTALLED -> "INSTALLED"
+            InstallStatus.FAILED -> "FAILED"
+            InstallStatus.CANCELED -> "CANCELED"
+            else -> "UNKNOWN"
+        }
+    }
+    
+    fun onActivityResult(requestCode: Int, resultCode: Int) {
+        if (requestCode == REQUEST_CODE_UPDATE) {
+            when (resultCode) {
+                Activity.RESULT_OK -> {
+                    // Update flow completed successfully
+                }
+                Activity.RESULT_CANCELED -> {
+                    // User cancelled the update
+                }
+                else -> {
+                    // Update flow failed
+                }
+            }
+        }
+    }
+    
+    fun onResume() {
+        // Check if update is waiting to be installed
+        appUpdateManager.appUpdateInfo.addOnSuccessListener { appUpdateInfo ->
+            if (appUpdateInfo.updateAvailability() == UpdateAvailability.DEVELOPER_TRIGGERED_UPDATE_IN_PROGRESS) {
+                // Resume the update
+                val updateOptions = AppUpdateOptions.newBuilder(AppUpdateType.IMMEDIATE).build()
+                appUpdateManager.startUpdateFlow(
+                    appUpdateInfo,
+                    activity,
+                    updateOptions
+                )
+            }
+        }
+    }
+    
+    // Async method for background update checks
+    suspend fun getAppUpdateInfoAsync(): AppUpdateInfo? {
+        return try {
+            val appUpdateInfo = appUpdateManager.appUpdateInfo.await()
+            
+            if (appUpdateInfo.updateAvailability() == UpdateAvailability.UPDATE_AVAILABLE) {
+                AppUpdateInfo(
+                    updateAvailable = true,
+                    currentVersion = getCurrentAppVersion(),
+                    availableVersion = appUpdateInfo.availableVersionCode().toString()
+                )
+            } else {
+                AppUpdateInfo(
+                    updateAvailable = false,
+                    currentVersion = getCurrentAppVersion(),
+                    availableVersion = null
+                )
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+}