Merge pull request #221 from mindbox-moscow/develop

umbrellait-artem-petrov · web-flow · commit b12be6bbd971 · 2022-04-21T15:43:24.000+03:00
Update master
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
@@ -93,7 +93,7 @@ jobs:
 
       - name: Publish to Jitpack
       # To create release in Jitpack we need to create Github release
-        run: ./git-release.sh "Automatically generated Pre-release" "${{secrets.GITHUBACCESSTOKEN}}" "${{secrets.GITHUBUSER}}"   
+        run: ./git-release.sh "${{secrets.GITHUBACCESSTOKEN}}" "${{secrets.GITHUBUSER}}"
 
       - name: Publish to Sonatype
         uses: eskatos/gradle-command-action@v1
diff --git a/git-release.sh b/git-release.sh
@@ -1,50 +1,64 @@
 #!/bin/bash
 set -e
-version=$(cat gradle.properties |grep SDK_VERSION_NAME | cut -f2 -d"=")
-text=$1
-token=$2
-user=$3
+version=$(cat gradle.properties | grep SDK_VERSION_NAME | cut -f2 -d"=")
+token=$1
+user=$2
 branch=${GITHUB_REF##*/}
 repo_full_name=$(git config --get remote.origin.url | sed 's/.*:\/\/github.com\///;s/.git$//' | cut -f2 -d":")
-generate_post_data()
-{
+generate_post_data() {
   cat <<EOF
 {
   "tag_name": "$version",
   "target_commitish": "$branch",
-  "name": "Pre-release-$version",
-  "body": "$text",
+  "name": "$name",
+  "body": "$body",
   "draft": false,
-  "prerelease": true
+  "prerelease": $prerelease
 }
 EOF
 }
-set-tag(){
+set-tag() {
   set-local-tag
   #set-remote-tag
 }
-set-local-tag(){
-if [ $(git tag -l | grep $version) ]; then
+prepare-release-data() {
+  if [[ $version =~ ^[0-9.]+$ ]]; then
+    name="Release-$version"
+#    release_notes_1=$(curl -s --show-error --user "$user:$token" -H "Accept: application/vnd.github.v3+json" "https://api.github.com/repos/$repo_full_name/pulls?base=$branch" | grep "\"body\":" | cut -f2- -d:)
+#    release_notes="${release_notes_1:2:${#release_notes_1}-4}"
+    release_notes=""
+    body="# What's new:\n$release_notes"
+    prerelease=false
+  else
+    name="Pre-release-$version"
+    body="Automatically generated pre-release"
+    prerelease=true
+  fi
+}
+
+set-local-tag() {
+  if [ $(git tag -l | grep $version) ]; then
     echo "Local tag cleanup"
     git tag -d $version
     git tag $version
-else
+  else
     git tag $version
-fi
+  fi
 }
-set-remote-tag(){
-if [ $(git ls-remote --tags https://$user:$token@github.com/$repo_full_name.git | cut -f3 -d"/" | grep $version) ]; then
+set-remote-tag() {
+  if [ $(git ls-remote --tags https://$user:$token@github.com/$repo_full_name.git | cut -f3 -d"/" | grep $version) ]; then
     echo "Remote tag cleanup"
     git push --delete https://$user:$token@github.com/$repo_full_name.git $version
     git push https://$user:$token@github.com/$repo_full_name.git $version
-else
+  else
     git push https://$user:$token@github.com/$repo_full_name.git $version
-fi
+  fi
 }
 echo "Create release $version for repo: $repo_full_name branch: $branch"
 echo "Release settings: $(generate_post_data)"
-post-request(){
+post-request() {
   curl -s --show-error --user "$user:$token" --data "$(generate_post_data)" "https://api.github.com/repos/$repo_full_name/releases"
 }
 set-tag
-post-request
+prepare-release-data
+post-request
diff --git a/gradle.properties b/gradle.properties
@@ -21,4 +21,4 @@ android.enableJetifier=true
 kotlin.code.style=official
 
 # SDK version property
-SDK_VERSION_NAME=2.1.0
+SDK_VERSION_NAME=2.1.1
diff --git a/modulesCommon.gradle b/modulesCommon.gradle
@@ -14,7 +14,7 @@ android {
     buildToolsVersion "29.0.3"
 
     defaultConfig {
-        minSdkVersion MIN_SDK_VERSION
+        minSdkVersion 19
         targetSdkVersion 31
         versionCode 1
         multiDexEnabled true
diff --git a/sdk/gradle.properties b/sdk/gradle.properties
@@ -1,3 +1,2 @@
 ARTIFACT_ID=mobile-sdk
-ARTIFACT_NAME=Mindbox Android SDK
-MIN_SDK_VERSION=16
+ARTIFACT_NAME=Mindbox Android SDK
diff --git a/sdk/src/main/java/cloud/mindbox/mobile_sdk/Mindbox.kt b/sdk/src/main/java/cloud/mindbox/mobile_sdk/Mindbox.kt
@@ -61,7 +61,12 @@ object Mindbox {
     private const val DELIVER_TOKEN_DELAY = 1L
 
     private val mindboxJob = SupervisorJob()
-    internal val mindboxScope = CoroutineScope(Default + mindboxJob)
+    private val coroutineExceptionHandler = CoroutineExceptionHandler { _, throwable ->
+        MindboxLoggerImpl.e(Mindbox, "Mindbox caught unhandled error", throwable)
+    }
+    internal val mindboxScope = CoroutineScope(
+        Default + mindboxJob + coroutineExceptionHandler,
+    )
     private val tokenCallbacks = ConcurrentHashMap<String, (String?) -> Unit>()
     private val deviceUuidCallbacks = ConcurrentHashMap<String, (String) -> Unit>()
 
@@ -186,7 +191,7 @@ object Mindbox {
      */
     fun updatePushToken(context: Context, token: String) = LoggingExceptionHandler.runCatching {
         if (token.trim().isNotEmpty()) {
-            initComponents(context, pushServiceHandler)
+            initComponents(context)
 
             if (!MindboxPreferences.isFirstInitialize) {
                 mindboxScope.launch {
@@ -204,7 +209,7 @@ object Mindbox {
      * @param uniqKey - unique identifier of push notification
      */
     fun onPushReceived(context: Context, uniqKey: String) = LoggingExceptionHandler.runCatching {
-        initComponents(context, pushServiceHandler)
+        initComponents(context)
         MindboxEventManager.pushDelivered(context, uniqKey)
 
         if (!MindboxPreferences.isFirstInitialize) {
@@ -227,7 +232,7 @@ object Mindbox {
         uniqKey: String,
         buttonUniqKey: String?,
     ) = LoggingExceptionHandler.runCatching {
-        initComponents(context, pushServiceHandler)
+        initComponents(context)
         MindboxEventManager.pushClicked(context, TrackClickData(uniqKey, buttonUniqKey))
 
         if (!MindboxPreferences.isFirstInitialize) {
@@ -265,22 +270,25 @@ object Mindbox {
 
     /**
      * Initializes the SDK for further work.
-     * We recommend calling it in onCreate on an application class
+     *
+     * We recommend calling it synchronously in onCreate on an application class
+     *
+     * If you must call it the other way, invoke [Mindbox.setPushServiceHandler] in [Application.onCreate] or else pushes won't be shown when application is inactive
      *
      * @param context used to initialize the main tools
      * @param configuration contains the data that is needed to connect to the Mindbox
+     * @param pushServices list, containing [MindboxPushService]s, i.e.
+     * ```
+     *     listOf(MindboxFirebase, MindboxHuawei)
+     * ```
      */
     fun init(
         context: Context,
         configuration: MindboxConfiguration,
         pushServices: List<MindboxPushService>,
     ) {
         LoggingExceptionHandler.runCatching {
-            val pushService = pushServices
-                .map { it.getServiceHandler(MindboxLoggerImpl, LoggingExceptionHandler) }
-                .firstOrNull { it.isServiceAvailable(context) }
-
-            initComponents(context, pushService)
+            initComponents(context, pushServices)
 
             mindboxScope.launch {
                 if (MindboxPreferences.isFirstInitialize) {
@@ -310,6 +318,14 @@ object Mindbox {
                             "Incorrect context type for calling init in this place",
                         )
                     }
+                    if (isApplicationResumed || context !is Application) {
+                        MindboxLoggerImpl.w(
+                            this,
+                            "We recommend to call Mindbox.init() synchronously from " +
+                                    "Application.onCreate. If you can't do so, don't forget to " +
+                                    "call Mindbox.initPushServices from Application.onCreate",
+                        )
+                    }
 
                     lifecycleManager = LifecycleManager(
                         currentActivityName = activity?.javaClass?.name,
@@ -333,6 +349,75 @@ object Mindbox {
         }
     }
 
+    /**
+     * Method to initialise push services
+     *
+     * You must call this method in onCreate in your Application class if you call [Mindbox.init] not there
+     *
+     * @param context used to initialize the main tools
+     * @param pushServices list, containing [MindboxPushService]s, i.e.
+     * ```
+     *     listOf(MindboxFirebase, MindboxHuawei)
+     * ```
+     */
+    fun initPushServices(
+        context: Context,
+        pushServices: List<MindboxPushService>,
+    ) = initComponents(context, pushServices)
+
+    private fun setPushServiceHandler(
+        context: Context,
+        pushServices: List<MindboxPushService>? = null,
+    ) = LoggingExceptionHandler.runCatching {
+        if (pushServiceHandler == null && pushServices != null) {
+            val savedProvider = MindboxPreferences.notificationProvider
+            selectPushServiceHandler(context, pushServices, savedProvider)
+                ?.let { pushServiceHandler ->
+                    this.pushServiceHandler = pushServiceHandler
+                    pushServiceHandler.notificationProvider
+                        .takeIf { it != savedProvider }
+                        ?.let { newProvider ->
+                            MindboxPreferences.notificationProvider = newProvider
+                            if (!MindboxPreferences.isFirstInitialize) {
+                                mindboxScope.launch {
+                                    updateAppInfo(context)
+                                }
+                            }
+                        }
+                    mindboxScope.launch {
+                        pushServiceHandler.initService(context)
+                    }
+                }
+        }
+    }
+
+    private fun selectPushServiceHandler(
+        context: Context,
+        pushServices: List<MindboxPushService>,
+        savedProvider: String,
+    ): PushServiceHandler? {
+        val serviceHandlers = pushServices
+            .map { it.getServiceHandler(MindboxLoggerImpl, LoggingExceptionHandler) }
+        return serviceHandlers.firstOrNull { it.notificationProvider == savedProvider }
+            ?: initAvailablePushService(context, serviceHandlers, savedProvider)
+    }
+
+    private fun initAvailablePushService(
+        context: Context,
+        serviceHandlers: List<PushServiceHandler>,
+        savedProvider: String,
+    ) = if (savedProvider.isBlank()) {
+        serviceHandlers.firstOrNull { it.isServiceAvailable(context) }
+    } else {
+        MindboxLoggerImpl.e(
+            Mindbox,
+            "Mindbox was previously initialized with $savedProvider push service but " +
+                    "Mindbox did not find it within pushServices. Check your Mindbox.init() and " +
+                    "Mindbox.initPushServices()",
+        )
+        null
+    }
+
     /**
      * Send track visit event after link or push was clicked for [Activity] with launchMode equals
      * "singleTop" or "singleTask" or if a client used the [Intent.FLAG_ACTIVITY_SINGLE_TOP] or
@@ -560,13 +645,10 @@ object Mindbox {
         }, DELIVER_TOKEN_DELAY, TimeUnit.SECONDS)
     }
 
-    internal fun initComponents(context: Context, pushServiceHandler: PushServiceHandler?) {
+    internal fun initComponents(context: Context, pushServices: List<MindboxPushService>? = null) {
         SharedPreferencesManager.with(context)
         DbManager.init(context)
-        this.pushServiceHandler = pushServiceHandler
-        mindboxScope.launch {
-            pushServiceHandler?.initService(context)
-        }
+        setPushServiceHandler(context, pushServices)
     }
 
     private fun <T> asyncOperation(
@@ -596,7 +678,7 @@ object Mindbox {
         operationSystemName: String,
     ) = LoggingExceptionHandler.runCatching(defaultValue = false) {
         if (operationSystemName.matches(OPERATION_NAME_REGEX.toRegex())) {
-            initComponents(context, pushServiceHandler)
+            initComponents(context)
         } else {
             MindboxLoggerImpl.w(
                 this,
@@ -628,6 +710,7 @@ object Mindbox {
         DbManager.saveConfigurations(Configuration(configuration))
 
         val isTokenAvailable = !pushToken.isNullOrEmpty()
+        val notificationProvider = pushServiceHandler?.notificationProvider ?: ""
         val initData = InitData(
             token = pushToken ?: "",
             isTokenAvailable = isTokenAvailable,
@@ -636,13 +719,14 @@ object Mindbox {
             isNotificationsEnabled = isNotificationEnabled,
             subscribe = configuration.subscribeCustomerIfCreated,
             instanceId = instanceId,
-            notificationProvider = pushServiceHandler?.notificationProvider ?: "",
+            notificationProvider = notificationProvider,
         )
 
         MindboxPreferences.deviceUuid = deviceUuid
         MindboxPreferences.pushToken = pushToken
         MindboxPreferences.isNotificationEnabled = isNotificationEnabled
         MindboxPreferences.instanceId = instanceId
+        MindboxPreferences.notificationProvider = notificationProvider
 
         MindboxEventManager.appInstalled(context, initData, configuration.shouldCreateCustomer)
 
diff --git a/sdk/src/main/java/cloud/mindbox/mobile_sdk/managers/WorkerDelegate.kt b/sdk/src/main/java/cloud/mindbox/mobile_sdk/managers/WorkerDelegate.kt
@@ -23,7 +23,7 @@ internal class WorkerDelegate {
         MindboxLoggerImpl.d(parent, "Start working...")
 
         try {
-            Mindbox.initComponents(context, Mindbox.pushServiceHandler)
+            Mindbox.initComponents(context)
 
             Mindbox.pushServiceHandler?.ensureVersionCompatibility(context, parent)
 
diff --git a/sdk/src/main/java/cloud/mindbox/mobile_sdk/repository/MindboxPreferences.kt b/sdk/src/main/java/cloud/mindbox/mobile_sdk/repository/MindboxPreferences.kt
@@ -15,6 +15,7 @@ internal object MindboxPreferences {
         "key_host_app_name" //need for scheduling and stopping one-time background service
     private const val KEY_INFO_UPDATED_VERSION = "key_info_updated_version"
     private const val KEY_INSTANCE_ID = "key_instance_id"
+    private const val KEY_NOTIFICATION_PROVIDER = "key_notification_provider"
     private const val DEFAULT_INFO_UPDATED_VERSION = 1
 
     var isFirstInitialize: Boolean
@@ -100,4 +101,13 @@ internal object MindboxPreferences {
             }
         }
 
+    var notificationProvider: String
+        get() = LoggingExceptionHandler.runCatching(defaultValue = "") {
+            SharedPreferencesManager.getString(KEY_NOTIFICATION_PROVIDER) ?: ""
+        }
+        set(value) {
+            LoggingExceptionHandler.runCatching {
+                SharedPreferencesManager.put(KEY_NOTIFICATION_PROVIDER, value)
+            }
+        }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ internal object MindboxPreferences {`
`15`	`15`	`"key_host_app_name" //need for scheduling and stopping one-time background service`
`16`	`16`	`private const val KEY_INFO_UPDATED_VERSION = "key_info_updated_version"`
`17`	`17`	`private const val KEY_INSTANCE_ID = "key_instance_id"`
	`18`	`+ private const val KEY_NOTIFICATION_PROVIDER = "key_notification_provider"`
`18`	`19`	`private const val DEFAULT_INFO_UPDATED_VERSION = 1`
`19`	`20`
`20`	`21`	`var isFirstInitialize: Boolean`
`@@ -100,4 +101,13 @@ internal object MindboxPreferences {`
`100`	`101`	`}`
`101`	`102`	`}`
`102`	`103`
	`104`	`+ var notificationProvider: String`
	`105`	`+ get() = LoggingExceptionHandler.runCatching(defaultValue = "") {`
	`106`	`+ SharedPreferencesManager.getString(KEY_NOTIFICATION_PROVIDER) ?: ""`
	`107`	`+ }`
	`108`	`+ set(value) {`
	`109`	`+ LoggingExceptionHandler.runCatching {`
	`110`	`+ SharedPreferencesManager.put(KEY_NOTIFICATION_PROVIDER, value)`
	`111`	`+ }`
	`112`	`+ }`
`103`	`113`	`}`