Feature/binder request

app/src/main/kotlin/com/livetyping/activitybinder/BinderExampleApplication.kt

@@ -1,6 +1,7 @@
 package com.livetyping.activitybinder
 
 import android.app.Application
+import com.livetyping.core.NewBinder
 import com.livetyping.facebook.FacebookInitializer
 import com.livetyping.google.GoogleInitializer
 import com.livetyping.images.ImagesBinder
@@ -22,6 +23,10 @@ class BinderExampleApplication : Application() {
         ImagesBinder(applicationContext.packageName + ".provider", R.xml.file_path)
     }
 
+    val newBinder: NewBinder by lazy {
+        NewBinder()
+    }
+
     override fun onCreate() {
         super.onCreate()
         val socialsInitializers = listOf(

app/src/main/kotlin/com/livetyping/activitybinder/PermissionExampleActivity.kt

@@ -5,7 +5,9 @@ import android.content.Intent
 import android.os.Bundle
 import android.util.Log
 import androidx.appcompat.app.AppCompatActivity
+import com.livetyping.core.NewBinder
 import com.livetyping.permission.PermissionBinder
+import com.livetyping.permission.request.PassivePermissionRequest
 import kotlinx.android.synthetic.main.activity_permissions.*
 
 class PermissionExampleActivity : AppCompatActivity() {
@@ -16,11 +18,13 @@ class PermissionExampleActivity : AppCompatActivity() {
     }
 
     private lateinit var permissionBinder: PermissionBinder
+    private lateinit var newBinder: NewBinder
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_permissions)
         permissionBinder = (application as BinderExampleApplication).permissionBinder
+        newBinder = (application as BinderExampleApplication).newBinder
         handleButtonSinglePermissions()
         handleButtonMultiplyPermissions()
     }
@@ -33,7 +37,9 @@ class PermissionExampleActivity : AppCompatActivity() {
 
     private fun setOnSinglePassivePermissionClickListener() {
         single_passive.setOnClickListener {
-            permissionBinder.passivePermission(READ_EXTERNAL_STORAGE) { isGranted -> onPermissionResult(isGranted) }
+            newBinder.request(PassivePermissionRequest(READ_EXTERNAL_STORAGE)) {
+                onPermissionResult(it)
+            }
         }
     }
 
@@ -89,7 +95,11 @@ class PermissionExampleActivity : AppCompatActivity() {
     private fun setOnMultiplePassivePermissionClickListener() {
         val passivePermissions = listOf(READ_CONTACTS, ACCESS_FINE_LOCATION)
         multiply_passive.setOnClickListener {
-            permissionBinder.passivePermissions(passivePermissions) { results -> onPermissionsResults(results) }
+            permissionBinder.passivePermissions(passivePermissions) { results ->
+                onPermissionsResults(
+                    results
+                )
+            }
         }
     }
 
@@ -124,10 +134,12 @@ class PermissionExampleActivity : AppCompatActivity() {
     override fun onStart() {
         super.onStart()
         permissionBinder.attach(this)
+        newBinder.attach(this)
     }
 
     override fun onStop() {
         permissionBinder.detach(this)
+        newBinder.detach(this)
         super.onStop()
     }
 
@@ -136,8 +148,13 @@ class PermissionExampleActivity : AppCompatActivity() {
         permissionBinder.onActivityResult(requestCode, this)
     }
 
-    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
         permissionBinder.onRequestPermissionResult(requestCode)
+        newBinder.onRequestPermissionsResult(requestCode, permissions, grantResults)
     }
 }

core/src/main/kotlin/com/livetyping/core/BinderRequest.kt

@@ -0,0 +1,47 @@
+package com.livetyping.core
+
+import android.app.Activity
+import android.content.Intent
+
+
+abstract class BinderRequest<T> {
+
+    protected var requestCode: Int = 0
+    protected lateinit var block: (result: T) -> Unit
+
+    internal fun setRequestCode(requestCode: Int) {
+        this.requestCode = requestCode
+    }
+
+    internal fun setBlock(block: (result: T) -> Unit) {
+        this.block = block
+    }
+
+    internal fun internalActivityResult(resultCode: Int, data: Intent?) {
+        onActivityResult(resultCode, data)
+    }
+
+    internal fun internalPermissionResult(
+        activity: Activity,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        onRequestPermissionsResult(activity, permissions, grantResults)
+    }
+
+    internal fun internalRequest(activity: Activity) = request(activity)
+
+    protected open fun onActivityResult(resultCode: Int, data: Intent?) {
+        //for override
+    }
+
+    protected open fun onRequestPermissionsResult(
+        activity: Activity,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        //for override
+    }
+
+    protected abstract fun request(activity: Activity)
+}

core/src/main/kotlin/com/livetyping/core/NewBinder.kt

@@ -0,0 +1,43 @@
+package com.livetyping.core
+
+import android.content.Intent
+import kotlin.random.Random
+
+
+class NewBinder : Binder() {
+
+    private val requests by lazy {
+        mutableMapOf<Int, BinderRequest<*>>()
+    }
+
+    fun <T> request(request: BinderRequest<T>, resultBlock: (result: T) -> Unit) {
+        val generateRequestCode = generateRequestCode()
+        request.setRequestCode(generateRequestCode)
+        request.setBlock(resultBlock)
+        requests[generateRequestCode] = request
+        getAttachedObject()?.let { request.internalRequest(it) }
+    }
+
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        requests[requestCode]?.internalActivityResult(resultCode, data)
+    }
+
+    fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        getAttachedObject()?.let {
+            requests[requestCode]?.internalPermissionResult(it, permissions, grantResults)
+        }
+
+    }
+
+
+    //TODO need generator for request codes
+    private val random = Random(100)
+
+    private fun generateRequestCode(): Int {
+        return random.nextInt(100) + 100
+    }
+}

images/src/main/AndroidManifest.xml

@@ -1,15 +1 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.livetyping.images">
-
-    <application>
-        <provider
-            android:name=".photo.DefaultProvider"
-            android:authorities="com.livetyping.images.default_provider"
-            android:exported="false"
-            android:grantUriPermissions="true">
-            <meta-data
-                android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/default_file_paths" />
-        </provider>
-    </application>
-</manifest>
+<manifest package="com.livetyping.images" />

permission/src/main/kotlin/com/livetyping/permission/ActivePermissionRequest.kt

@@ -34,11 +34,16 @@ internal class ActivePermissionRequest(
     }
 
     override fun afterRequest(activity: Activity, @StyleRes themeResId: Int) {
-        val isAllPermissionsGrantedOrRationalShowed = rationaleShowed || areAllPermissionsGranted(activity)
+        val isAllPermissionsGrantedOrRationalShowed =
+            rationaleShowed || areAllPermissionsGranted(activity)
         if (isAllPermissionsGrantedOrRationalShowed) {
             invokeResult(activity)
         } else {
-            showOpenSettingsDialog(activity, themeResId)
+            if (!rationaleShowed && getPermissionsWithoutRationale(activity).isNotEmpty()) {
+                showOpenSettingsDialog(activity, themeResId)
+            } else {
+                invokeResult(activity)
+            }
         }
     }
 

permission/src/main/kotlin/com/livetyping/permission/PermissionRequest.kt

@@ -87,4 +87,10 @@ internal abstract class PermissionRequest(
         syncPermissionsGrantedResult(activity)
         resultListener.invoke(permissionMap)
     }
+
+    protected fun getPermissionsWithoutRationale(activity: Activity): List<String> {
+        return permissions.filter {
+            !ActivityCompat.shouldShowRequestPermissionRationale(activity, it)
+        }
+    }
 }

permission/src/main/kotlin/com/livetyping/permission/request/ActivePermissionBinderRequest.kt

@@ -0,0 +1,84 @@
+package com.livetyping.permission.request
+
+import android.app.Activity
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.Settings
+import androidx.annotation.StringRes
+import androidx.appcompat.app.AlertDialog
+import androidx.core.app.ActivityCompat
+import com.livetyping.permission.R
+
+
+class ActivePermissionBinderRequest(
+    private val permission: String,
+    @StringRes private val rationaleTextStringRes: Int,
+    @StringRes private val buttonOkTextStringRes: Int = android.R.string.ok,
+    @StringRes private val buttonSettingsStringRes: Int = R.string.permission_settings_default_button_text
+) :
+    SinglePermissionBinderRequest<Boolean>() {
+
+    private var rationaleShowed = false
+
+    override fun request(activity: Activity) {
+        if (isPermissionGranted(permission, activity)) {
+            block(true)
+        } else {
+            if (shouldShowRationale(activity)) {
+                rationaleShowed = true
+                showRationaleDialog(activity, buttonOkTextStringRes) { requestPermission(activity) }
+            } else {
+                requestPermission(activity)
+            }
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        activity: Activity,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
+            block(true)
+        } else {
+            if (rationaleShowed.not() && shouldShowRationale(activity)) {
+                block(false)
+            } else {
+                if (rationaleShowed) {
+                    block(false)
+                } else {
+                    showRationaleDialog(activity, buttonSettingsStringRes) { openAppSettings(activity) }
+                }
+            }
+        }
+    }
+
+    private fun shouldShowRationale(activity: Activity): Boolean {
+        return ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)
+    }
+
+    private fun showRationaleDialog(activity: Activity, buttonResId: Int, buttonBlock: () -> Unit) {
+        AlertDialog.Builder(activity)
+            .setMessage(rationaleTextStringRes)
+            .setPositiveButton(buttonResId) { _, _ -> buttonBlock() }
+            .show()
+    }
+
+    private fun requestPermission(activity: Activity) {
+        ActivityCompat.requestPermissions(
+            activity,
+            arrayOf(permission),
+            requestCode
+        )
+    }
+
+    private fun openAppSettings(activity: Activity) {
+        val intent = Intent(
+            Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+            Uri.parse("package:${activity.packageName}")
+        )
+        intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY)
+        activity.startActivityForResult(intent, requestCode)
+    }
+}

permission/src/main/kotlin/com/livetyping/permission/request/MultiplyGeneralPermissionBinderRequest.kt

@@ -0,0 +1,44 @@
+package com.livetyping.permission.request
+
+import android.app.Activity
+import android.content.pm.PackageManager
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import com.livetyping.core.BinderRequest
+
+
+class MultiplyGeneralPermissionBinderRequest(
+    private val permissions: Iterable<String>
+) : BinderRequest<Map<String, Boolean>>() {
+
+    private val result = mutableMapOf<String, Boolean>()
+
+    override fun request(activity: Activity) {
+        val groupedByGranted = permissions.groupBy {
+            ContextCompat.checkSelfPermission(
+                activity,
+                it
+            ) == PackageManager.PERMISSION_GRANTED
+        }
+        groupedByGranted[true]?.forEach { result[it] = true }
+        val denied = groupedByGranted[false]
+        if (denied == null) {
+            block(result)
+        } else {
+            denied.toTypedArray().let {
+                ActivityCompat.requestPermissions(activity, it, requestCode)
+            }
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        activity: Activity,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        permissions.forEachIndexed { index, permission ->
+            result[permission] = grantResults[index] == PackageManager.PERMISSION_GRANTED
+        }
+        block(result)
+    }
+}