+
+## Meet Kotlin Bootstrap by Cleveroad
+
+This is tutorial about android bootstrap library.
+
+## Setup and usage
+### Installation
+by project gradle :
+```groovy
+ext {
+
+ bootstrapVersion = "2.0.0"
+
+ bootstrapDependencies = [
+ auth : "com.cleveroad.bootstrap:kotlin-auth:$bootstrapVersion",
+ core : "com.cleveroad.bootstrap:kotlin-core:$bootstrapVersion",
+ ext : "com.cleveroad.bootstrap:kotlin-ext:$bootstrapVersion"
+ thumbnails : "com.cleveroad.bootstrap:kotlin-ffmpeg-thumbnails:$bootstrapVersion"
+ video_compress: "com.cleveroad.bootstrap:kotlin-ffmpeg-video-compress:$bootstrapVersion"
+ gps : "com.cleveroad.bootstrap:kotlin-gps:$bootstrapVersion"
+ permission : "com.cleveroad.bootstrap:kotlin-permissionrequest:$bootstrapVersion"
+ phone_input : "com.cleveroad.bootstrap:kotlin-phone-input:$bootstrapVersion"
+ validators : "com.cleveroad.bootstrap:kotlin-validators:$bootstrapVersion",
+ rxBus : "com.cleveroad.bootstrap:kotlin-rx-bus:$bootstrapVersion",
+ ]
+}
+```
+
+by app gradle :
+```groovy
+
+dependencies {
+
+ // Bootstrap
+ implementation bootstrapDependencies.auth
+ implementation bootstrapDependencies.core
+ implementation bootstrapDependencies.ext
+ implementation bootstrapDependencies.thumbnails
+ implementation bootstrapDependencies.video_compress
+ implementation bootstrapDependencies.gps
+ implementation bootstrapDependencies.permission
+ implementation bootstrapDependencies.phone_input
+ implementation bootstrapDependencies.validators
+ implementation bootstrapDependencies.rxBus
+}
+```
+
+### Usage ###
+
+- [Kotlin Auth]
+- [Kotlin Core]
+- [Kotlin Extension]
+- [Kotlin FFMpeg Thumbnails]
+- [Kotlin FFMpeg Video Compress]
+- [Kotlin GPS]
+- [Kotlin Permission Request]
+- [Kotlin Phone Input]
+- [Kotlin RxBus]
+- [Kotlin Validators]
+
+### Support ###
+If you have any questions, issues or propositions, please create a new issue in this repository.
+
+If you want to hire us, send an email to sales@cleveroad.com or fill the form on contact page
+
+Follow us:
+
+[](https://www.facebook.com/cleveroadinc/) [](https://twitter.com/cleveroadinc) [](https://plus.google.com/+CleveroadInc) [](https://www.linkedin.com/company/cleveroad-inc-) [](https://www.youtube.com/channel/UCFNHnq1sEtLiy0YCRHG2Vaw)
+
+
+## Meet Kotlin Auth by Cleveroad
+
+Library for implementing authorization in the application through social networks, such as Facebook, Google, LinkedIn, Twitter.
+
+## Setup and usage
+### Installation
+by gradle :
+```groovy
+dependencies {
+ implementation 'com.cleveroad.bootstrap:kotlin-auth:2.0.0'
+}
+```
+
+### Usage ###
+
+Before use make sure you have added the following permission to your project
+
+```xml
+ This is a ripoff of Guava's {@code PercentEscaper, UnicodeEscaper, Escaper}, it represents + * the same behaviour as calling {@code UrlEscapers.urlFormParameterEscaper()}. Since the purpose + * for this class is to avoid adding Guava as a dependency, all generic structure and abstractions + * where removed. + * + *
Because, in general, escaping operates on the code points of a string and not on its + * individual {@code char} values, it is not safe to assume that {@code escape(s)} is equivalent to + * {@code escape(s.substring(0, n)) + escape(s.substing(n))} for arbitrary {@code n}. This is + * because of the possibility of splitting a surrogate pair. The only case in which it is safe to + * escape strings and concatenate the results is if you can rule out this possibility, either by + * splitting an existing long string into short strings adaptively around {@linkplain + * Character#isHighSurrogate surrogate} {@linkplain Character#isLowSurrogate pairs}, or by starting + * with short strings already known to be free of unpaired surrogates. + * + * @author David Beaumont + */ +final class UrlEscapeUtils { + /** The amount of padding (chars) to use when growing the escape buffer. */ + private static final int DEST_PAD = 32; + + /** Url form parameter safe chars. */ + private static final String SAFE_CHARS = "-_.*"; + + /** This escaper represents spaces as '+'. */ + private static final char[] PLUS_SIGN = { '+' }; + + /** Percent escapers output upper case hex digits (uri escapers require this). */ + private static final char[] UPPER_HEX_DIGITS = "0123456789ABCDEF".toCharArray(); + + /** + * An array of flags where for any {@code char c} if {@code SAFE_OCTETS[c]} is + * true then {@code c} should remain unmodified in the output. If + * {@code c > SAFE_OCTETS.length} then it should be escaped. + */ + private static final boolean[] SAFE_OCTETS = createSafeOctets( + SAFE_CHARS + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"); + + /** + * Returns the escaped form of a given literal string. + * + * @param string the literal string to be escaped + * @return the escaped form of {@code string} + * @throws NullPointerException if {@code string} is null + * @throws IllegalArgumentException if {@code string} contains badly formed UTF-16 or cannot be + * escaped for any other reason + */ + public static String escape(String string) { + checkNotNull(string, "string == null"); + int slen = string.length(); + for (int index = 0; index < slen; index++) { + char c = string.charAt(index); + if (c >= SAFE_OCTETS.length || !SAFE_OCTETS[c]) { + return escapeSlow(string, index); + } + } + return string; + } + + /** + * Returns the escaped form of a given literal string, starting at the given index. + * + *
This method is not reentrant and may only be invoked by the top level + * {@link #escape(String)} method. + * + * @param s the literal string to be escaped + * @param index the index to start escaping from + * @return the escaped form of {@code string} + * @throws NullPointerException if {@code string} is null + * @throws IllegalArgumentException if invalid surrogate characters are + * encountered + */ + private static String escapeSlow(String s, int index) { + int end = s.length(); + + // Get a destination buffer and setup some loop variables. + char[] dest = new char[1024]; + int destIndex = 0; + int unescapedChunkStart = 0; + + while (index < end) { + int cp = codePointAt(s, index, end); + if (cp < 0) { + throw new IllegalArgumentException("Trailing high surrogate at end of input"); + } + // It is possible for this to return null because nextEscapeIndex() may + // (for performance reasons) yield some false positives but it must never + // give false negatives. + char[] escaped = escape(cp); + int nextIndex = index + (Character.isSupplementaryCodePoint(cp) ? 2 : 1); + if (escaped != null) { + int charsSkipped = index - unescapedChunkStart; + + // This is the size needed to add the replacement, not the full + // size needed by the string. We only regrow when we absolutely must. + int sizeNeeded = destIndex + charsSkipped + escaped.length; + if (dest.length < sizeNeeded) { + int destLength = sizeNeeded + (end - index) + DEST_PAD; + dest = growBuffer(dest, destIndex, destLength); + } + // If we have skipped any characters, we need to copy them now. + if (charsSkipped > 0) { + s.getChars(unescapedChunkStart, index, dest, destIndex); + destIndex += charsSkipped; + } + if (escaped.length > 0) { + System.arraycopy(escaped, 0, dest, destIndex, escaped.length); + destIndex += escaped.length; + } + // If we dealt with an escaped character, reset the unescaped range. + unescapedChunkStart = nextIndex; + } + index = nextEscapeIndex(s, nextIndex, end); + } + + // Process trailing unescaped characters - no need to account for escaped + // length or padding the allocation. + int charsSkipped = end - unescapedChunkStart; + if (charsSkipped > 0) { + int endIndex = destIndex + charsSkipped; + if (dest.length < endIndex) { + dest = growBuffer(dest, destIndex, endIndex); + } + s.getChars(unescapedChunkStart, end, dest, destIndex); + destIndex = endIndex; + } + return new String(dest, 0, destIndex); + } + + /** Escapes the given Unicode code point in UTF-8. */ + static char[] escape(int cp) { + // We should never get negative values here but if we do it will throw an + // IndexOutOfBoundsException, so at least it will get spotted. + if (cp < SAFE_OCTETS.length && SAFE_OCTETS[cp]) { + return null; + } else if (cp == ' ') { + return PLUS_SIGN; + } else if (cp <= 0x7F) { + // Single byte UTF-8 characters + // Start with "%--" and fill in the blanks + char[] dest = new char[3]; + dest[0] = '%'; + dest[2] = UPPER_HEX_DIGITS[cp & 0xF]; + dest[1] = UPPER_HEX_DIGITS[cp >>> 4]; + return dest; + } else if (cp <= 0x7ff) { + // Two byte UTF-8 characters [cp >= 0x80 && cp <= 0x7ff] + // Start with "%--%--" and fill in the blanks + char[] dest = new char[6]; + dest[0] = '%'; + dest[3] = '%'; + dest[5] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[2] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[1] = UPPER_HEX_DIGITS[0xC | cp]; + return dest; + } else if (cp <= 0xffff) { + // Three byte UTF-8 characters [cp >= 0x800 && cp <= 0xffff] + // Start with "%E-%--%--" and fill in the blanks + char[] dest = new char[9]; + dest[0] = '%'; + dest[1] = 'E'; + dest[3] = '%'; + dest[6] = '%'; + dest[8] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[7] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[5] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[2] = UPPER_HEX_DIGITS[cp]; + return dest; + } else if (cp <= 0x10ffff) { + char[] dest = new char[12]; + // Four byte UTF-8 characters [cp >= 0xffff && cp <= 0x10ffff] + // Start with "%F-%--%--%--" and fill in the blanks + dest[0] = '%'; + dest[1] = 'F'; + dest[3] = '%'; + dest[6] = '%'; + dest[9] = '%'; + dest[11] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[10] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[8] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[7] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[5] = UPPER_HEX_DIGITS[cp & 0xF]; + cp >>>= 4; + dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)]; + cp >>>= 2; + dest[2] = UPPER_HEX_DIGITS[cp & 0x7]; + return dest; + } else { + // If this ever happens it is due to bug in UnicodeEscaper, not bad input. + throw new IllegalArgumentException("Invalid unicode character value " + cp); + } + } + + /** + * Creates a boolean array with entries corresponding to the character values + * specified in safeChars set to true. The array is as small as is required to + * hold the given character information. + */ + private static boolean[] createSafeOctets(String safeChars) { + int maxChar = -1; + char[] safeCharArray = safeChars.toCharArray(); + for (char c : safeCharArray) { + maxChar = Math.max(c, maxChar); + } + boolean[] octets = new boolean[maxChar + 1]; + for (char c : safeCharArray) { + octets[c] = true; + } + return octets; + } + + /** + * Scans a sub-sequence of characters from a given {@link CharSequence}, + * returning the index of the next character that requires escaping. + * + * @param csq a sequence of characters + * @param start the index of the first character to be scanned + * @param end the index immediately after the last character to be scanned + * @throws IllegalArgumentException if the scanned sub-sequence of {@code csq} + * contains invalid surrogate pairs + */ + private static int nextEscapeIndex(CharSequence csq, int start, int end) { + checkNotNull(csq, "csq == null"); + for (; start < end; start++) { + char c = csq.charAt(start); + if (c >= SAFE_OCTETS.length || !SAFE_OCTETS[c]) { + break; + } + } + return start; + } + + /** + * Returns the Unicode code point of the character at the given index. + * + *
Unlike {@link Character#codePointAt(CharSequence, int)} or + * {@link String#codePointAt(int)} this method will never fail silently when + * encountering an invalid surrogate pair. + * + *
The behaviour of this method is as follows: + *
+
+## Meet Kotlin Core by Cleveroad
+
+The library contains a set of base classes for Android applications.
+
+### Description ###
+
+Main directories of the library.
+
+- adapters
+- network
+- receivers
+- ui
+- utils
+
+#### Adapters ####
+
+- BaseArrayAdapter - Simple ArrayAdapter that propose methods to add collections on pre-Honeycomb devices.
+- BaseFilter - Base filter that can be easily integrated with BaseArrayAdapter. For iterating through adapter's data use getNonFilteredCount and getNonFilteredItem.
+- BaseRecyclerViewAdapter - Base adapter for recycler view.
+
+#### UI ####
+
+- BaseLifecycleViewModel - The is a class that is responsible for preparing and managing the data for an Activity or a Fragment.
+- BaseLifecycleActivity - Base activity that implements work with the ViewModel and the life cycle.
+- BaseLifecycleFragment - The is a class that implements work with the ViewModel and the life cycle.
+- BaseLifecycleDialogFragment - Base fragment for the implementation of the dialog with custom view.
+- BaseListFragment - Base fragment for the implementation of the screen with a list of data.
+- BaseDialogFragment - Base fragment for the implementation of the dialog with custom view.
+- BaseFragmentPagerAdapter - Base fragment for the implementation of the ViewPager.
+- BaseRecyclerViewAdapter - Base adapter for recycler view.
+
+#### Utils ####
+
+- MiscellaneousUtils - Get String with name for EXTRA parameter. Pattern packageName + class.simpleName + EXTRA + extraName.
+- ImageUtils - Provides common methods of the utility for working with image.
+- RealPathUtils - Provides common methods of the utility for working with file.
+- RXUtils - Helper class for RxJava. This class provides methods for switching between threads.
+
+## Setup and usage
+### Installation
+by gradle :
+```groovy
+dependencies {
+ implementation 'com.cleveroad.bootstrap:kotlin-core:2.0.0'
+}
+```
+
+### Usage ###
+```groovy
+
+ class SampleVM(application: Application) : BaseLifecycleViewModel(application) {
+ val loadDataVM = MutableLiveData()
+
+ fun loadData() {
+ DataProvider.loadData()
+ .doAsync(loadDataVM)
+ }
+ }
+
+ class SampleFragment : BaseLifecycleFragment Note that the {@link java.nio.file.Files} class defines the [java.nio.file.Files.delete]
+ * method to throw an [java.io.IOException]
+ * when a file cannot be deleted. This is useful for error reporting and to
+ * diagnose why a file cannot be deleted.
+ *
+ * @return true if and only if the file or directory is
+ * successfully deleted; false otherwise
+ *
+ * @throws SecurityException
+ * If a security manager exists and its [java.lang.SecurityManager.checkDelete] method denies
+ * delete access to the file
+ */
+ fun delete(file: File): Boolean =
+ file.takeIf { it.exists() }
+ ?.run { if (isDirectory) deleteRecursively() else delete() }
+ ?: false
+
+ /**
+ * See [delete]
+ */
+ fun delete(path: String): Boolean = delete(File(path))
+
+ /**
+ * Gets the extension of a file.
+ * @param file
+ * @return extension including the dot, or empty if there is no extension.
+ */
+ fun getExtension(file: File): String? =
+ file.takeIf { it.exists() }?.extension
+ ?: file.absolutePath
+ .lastIndexOf(DOT_CHAR)
+ .takeIf { it >= 0 }
+ ?.let { file.absolutePath.substring(it) }
+ }
+}
diff --git a/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/FileUtilsCommon.kt b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/FileUtilsCommon.kt
new file mode 100644
index 0000000..4692eb1
--- /dev/null
+++ b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/FileUtilsCommon.kt
@@ -0,0 +1,171 @@
+package com.cleveroad.bootstrap.kotlin_core.utils.storage
+
+import android.annotation.TargetApi
+import android.content.ContentUris
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import android.provider.OpenableColumns
+import androidx.annotation.NonNull
+import androidx.annotation.RequiresApi
+import com.cleveroad.bootstrap.kotlin_core.utils.storage.TypeMediaFile.*
+import com.cleveroad.bootstrap.kotlin_core.utils.storage.UriUtils.Companion.isContentScheme
+import java.io.File
+
+/**
+ * Get external storage provider path by uri[Uri]
+ *
+ * @param uri file's uri[Uri]
+ *
+ * @return external storage documents path
+ */
+@RequiresApi(Build.VERSION_CODES.KITKAT)
+internal fun getExternalStoragePath(uri: Uri): String? {
+ return separateColumnsOfDocument(DocumentsContract.getDocumentId(uri))
+ .takeIf { PRIMARY.equals(it[NUMBER_COLUMN_TYPE_DOCUMENT], ignoreCase = true) }
+ ?.let { "${Environment.getExternalStorageDirectory()}/${it[NUMBER_COLUMN_PATH_DOCUMENT]}" }
+}
+
+/**
+ * Get Uri path from Downloads Provider.
+ * @param context of the caller.
+ * @param uri to parse.
+ * @return uri path.
+ */
+@TargetApi(Build.VERSION_CODES.KITKAT)
+internal fun getDownloadsPath(context: Context, uri: Uri): String? =
+ getDocumentId(uri)?.let { docId ->
+ if (docId.startsWith(RAW_DATA)) {
+ return docId.replaceFirst(RAW_DATA.toRegex(), EMPTY_STRING_VALUE)
+ }
+ return try {
+ val contentUri = ContentUris.withAppendedId(Uri.parse(PUBLIC_DOWNLOADS_PATH), java.lang.Long.valueOf(docId))
+ val filePath = getDefaultPath(context, contentUri)?.takeIf { it != docId }
+ val filePathAlternative = getDisplayName(context, uri, Environment.DIRECTORY_DOWNLOADS)
+ when {
+ filePath != null && File(filePath).exists() -> filePath
+ filePathAlternative != null && File(filePathAlternative).exists() -> filePathAlternative
+ else -> null
+ }
+ } catch (e: NumberFormatException) {
+ uri.toString()
+ }
+ }
+
+/**
+ * Get Uri path from Media Provider.
+ * @param context of the caller.
+ * @param uri to parse.
+ * @return uri path.
+ */
+@TargetApi(Build.VERSION_CODES.KITKAT)
+internal fun getMediaPath(@NonNull context: Context, @NonNull uri: Uri): String? =
+ getColumnsByDocumentId(uri)?.let { split ->
+ val contentUri: Uri
+ val column: String
+ val selection: String
+ when (TypeMediaFile.byValue(split[NUMBER_COLUMN_TYPE_DOCUMENT].toLowerCase())) {
+ IMAGE -> {
+ contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI
+ column = MediaStore.Images.Media.DATA
+ selection = MediaStore.Images.Media._ID + ID_SUFFIX
+ }
+ VIDEO -> {
+ contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI
+ column = MediaStore.Video.Media.DATA
+ selection = MediaStore.Video.Media._ID + ID_SUFFIX
+ }
+ AUDIO -> {
+ contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI
+ column = MediaStore.Audio.Media.DATA
+ selection = MediaStore.Audio.Media._ID + ID_SUFFIX
+ }
+ else -> {
+ contentUri = MediaStore.Files.getContentUri(EXTERNAL_DATA)
+ column = COLUMN_DATA
+ selection = ID_FULL_SUFFIX
+ }
+ }
+ getDataColumn(context, contentUri, column, selection, arrayOf(split[NUMBER_COLUMN_PATH_DOCUMENT]))
+ }
+
+/**
+ * Get the value of the data column for this Uri. This is useful for
+ * MediaStore Uris, and other file-based ContentProviders.
+ *
+ * @param context instance of Context[Context]
+ * @param uri The Uri to query.
+ * @param selection (Optional) Filter used in the query.
+ * @param selectionArgs (Optional) Selection arguments used in the query.
+ *
+ * @return The value of the [projection] column, which is typically a file path.
+ */
+internal fun getDataColumn(context: Context,
+ uri: Uri,
+ projection: String = MediaStore.MediaColumns.DATA,
+ selection: String? = null,
+ selectionArgs: Array
Used [rotate] method
+ * @param bitmap bitmap[Bitmap]
+ * @param path absolute file path
+ *
+ * @return new bitmap [Bitmap] with normal orientation [ExifInterface.ORIENTATION_NORMAL]
+ */
+ fun rotateToNormal(bitmap: Bitmap,
+ path: String): Bitmap {
+ val ei = ExifInterface(path)
+ val orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
+ ExifInterface.ORIENTATION_NORMAL)
+ return when (orientation) {
+ ExifInterface.ORIENTATION_ROTATE_90 -> rotate(bitmap, 90F)
+ ExifInterface.ORIENTATION_ROTATE_180 -> rotate(bitmap, 180F)
+ ExifInterface.ORIENTATION_ROTATE_270 -> rotate(bitmap, 270F)
+ else -> bitmap
+ }
+ }
+
+ /**
+ * Rotates bitmap to a specific degree
+ *
+ * @param bitmap bitmap[Bitmap]
+ * @param degree degree
+ * @param mirror use mirror effect flag
+ * @param recycle recycle old bitmap flag
+ *
+ * @return new rotated bitmap [Bitmap]
+ */
+ fun rotate(bitmap: Bitmap,
+ degree: Float,
+ mirror: Boolean = false,
+ recycle: Boolean = false): Bitmap = with(Matrix()) {
+ if (mirror) preScale(1F, -1F)
+ postRotate(degree)
+ Bitmap.createBitmap(bitmap,
+ 0,
+ 0,
+ bitmap.width,
+ bitmap.height,
+ this,
+ true).apply { if (recycle) bitmap.recycle() }
+ }
+ }
+}
diff --git a/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/StorageContract.kt b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/StorageContract.kt
new file mode 100644
index 0000000..51695ab
--- /dev/null
+++ b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/StorageContract.kt
@@ -0,0 +1,43 @@
+package com.cleveroad.bootstrap.kotlin_core.utils.storage
+
+internal const val PRIMARY = "primary"
+internal const val SELECTION_BY_DOCUMENT_ID = "_id=?"
+internal const val CONTENT = "content"
+internal const val FILE = "file"
+internal const val COLUMN_DATA = "_data"
+internal const val REGEX_FOR_SEPARATING_COLUMNS_OF_DOCUMENT = ":"
+internal const val NUMBER_COLUMN_TYPE_DOCUMENT = 0
+internal const val NUMBER_COLUMN_PATH_DOCUMENT = 1
+
+/** Providers from uri. */
+internal const val EXTERNAL_STORAGE_PROVIDER = "com.android.externalstorage.documents"
+internal const val DOWNLOADS_PROVIDER = "com.android.providers.downloads.documents"
+internal const val MEDIA_PROVIDER = "com.android.providers.media.documents"
+internal const val GOOGLE_PHOTOS_PROVIDER = "com.google.android.apps.photos.content"
+internal const val GOOGLE_DRIVE_PROVIDER = "com.google.android.apps.docs.storage.legacy"
+/** Content. */
+internal const val PUBLIC_DOWNLOADS_PATH = "content://downloads/public_downloads"
+/** Uri scheme. */
+internal const val CONTENT_SCHEME = "content"
+internal const val FILE_SCHEME = "file"
+private const val FILE_PROVIDER = ".provider"
+internal const val EXTERNAL_DATA = "external"
+internal const val RAW_DATA = "raw:"
+/** Common */
+internal const val DOT_CHAR = "."
+internal const val ID_SUFFIX = "=?"
+internal const val EMPTY_STRING_VALUE = ""
+internal const val ID_FULL_SUFFIX = "_id=?"
+internal const val MIN_COLUMNS_TO_SEPARATE = 2
+internal const val TEMP_FILES_DIR = "temp_files"
+
+/** Images */
+internal const val TYPE_FILE_IMAGE = "image/*"
+internal const val MAX_IMAGE_SIZE = 1024.0 * 1024.0
+internal const val MAX_IMAGE_RESOLUTION = 1024
+internal const val COMPRESS_QUALITY = 90
+internal const val DATE_PATTERN = "yyyyMMdd_HHmmss"
+internal const val RESOLUTION_REDUCTION_COEFFICIENT = 2
+internal const val FLAG_NOT_MODIFY_DATA_RETURN = 0
+internal const val IN_SAMPLE_SIZE = 1
+internal const val IMAGE_FORMAT_JPG = ".jpg"
\ No newline at end of file
diff --git a/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeDirPath.kt b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeDirPath.kt
new file mode 100644
index 0000000..29ae550
--- /dev/null
+++ b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeDirPath.kt
@@ -0,0 +1,15 @@
+package com.cleveroad.bootstrap.kotlin_core.utils.storage
+
+import android.content.Context
+
+enum class TypeDirPath {
+ CACHE,
+ EXTERNAL_TEMP;
+
+ fun path(context: Context): String? =
+ when (this) {
+ CACHE -> context.cacheDir.absolutePath
+ EXTERNAL_TEMP -> context.getExternalFilesDir(TEMP_FILES_DIR)?.absolutePath
+ }
+
+}
\ No newline at end of file
diff --git a/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeMediaFile.kt b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeMediaFile.kt
new file mode 100644
index 0000000..99932fc
--- /dev/null
+++ b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/TypeMediaFile.kt
@@ -0,0 +1,13 @@
+package com.cleveroad.bootstrap.kotlin_core.utils.storage
+
+enum class TypeMediaFile(val value: String) {
+ IMAGE("image"),
+ VIDEO("video"),
+ AUDIO("audio"),
+ UNKNOWN("UNKNOWN");
+
+ companion object {
+ fun byValue(value: String?) =
+ values().firstOrNull { value == it.value } ?: UNKNOWN
+ }
+}
\ No newline at end of file
diff --git a/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/UriUtils.kt b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/UriUtils.kt
new file mode 100644
index 0000000..b650069
--- /dev/null
+++ b/kotlin-core/src/main/kotlin/com/cleveroad/bootstrap/kotlin_core/utils/storage/UriUtils.kt
@@ -0,0 +1,59 @@
+package com.cleveroad.bootstrap.kotlin_core.utils.storage
+
+import android.net.Uri
+
+class UriUtils private constructor() {
+
+ companion object {
+
+ /**
+ * Checks whether the Uri authority is External Storage Provider.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isExternalStorage(uri: Uri) = EXTERNAL_STORAGE_PROVIDER.equals(uri.authority, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri authority is Downloads Provider.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isDownloads(uri: Uri) = DOWNLOADS_PROVIDER.equals(uri.authority, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri authority is Media Provider.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isMedia(uri: Uri) = MEDIA_PROVIDER.equals(uri.authority, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri authority is Google Photos.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isGooglePhotos(uri: Uri) = GOOGLE_PHOTOS_PROVIDER.equals(uri.authority, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri authority is Google Drive.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isGoogleDrive(uri: Uri) = GOOGLE_DRIVE_PROVIDER.equals(uri.authority, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri scheme is Content.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isContentScheme(uri: Uri) = CONTENT_SCHEME.equals(uri.scheme, ignoreCase = true)
+
+ /**
+ * Checks whether the Uri scheme is File.
+ * @param uri to check.
+ * @return true if it is, false otherwise.
+ */
+ fun isFileScheme(uri: Uri) = FILE_SCHEME.equals(uri.scheme, ignoreCase = true)
+
+ }
+}
\ No newline at end of file
diff --git a/kotlin-core/src/main/res/anim/enter_from_left.xml b/kotlin-core/src/main/res/anim/enter_from_left.xml
new file mode 100644
index 0000000..c8af091
--- /dev/null
+++ b/kotlin-core/src/main/res/anim/enter_from_left.xml
@@ -0,0 +1,10 @@
+
+
+
+## Meet Kotlin Ext by Cleveroad
+
+Collection of most used Kotlin extensions.
+
+### Description ###
+
+List of Most commonly used Kotlin Extensions
+
+- Activity
+- Assertion
+- Bitmap
+- Common
+- Context
+- EditText
+- File
+- ImageView
+- Keyboard
+- Screen (refer to Context)
+- String
+- TextView
+- Uri
+- View
+
+## Setup and usage
+### Installation
+by gradle :
+```groovy
+dependencies {
+ implementation 'com.cleveroad.bootstrap:kotlin-ext:2.0.0'
+}
+```
+### Usage ###
+#### Activity ####
+```groovy
+fun Activity.setAdjustNothing(): Unit //To set windowSoftInputMode SOFT_INPUT_ADJUST_NOTHING at runtime
+fun Activity.setAdjustResize(): Unit //To set windowSoftInputMode SOFT_INPUT_ADJUST_RESIZE at runtime
+fun Activity.setAdjustPan(): Unit //To set windowSoftInputMode SOFT_INPUT_ADJUST_PAN at runtime
+fun Activity.setFullScreen(): Unit //To hide all screen decorations (such as the status bar) while this window is displayed
+fun Activity.setRotatable(): Unit //To set requestedOrientation SCREEN_ORIENTATION_SENSOR at runtime
+fun Activity.setOnlyPortraitMode(): Unit //To set requestedOrientation SCREEN_ORIENTATION_PORTRAIT at runtime
+fun Activity.setOnlyLandscapeMode(): Unit //To set requestedOrientation SCREEN_ORIENTATION_LANDSCAPE at runtime
+```
+#### Assertion ####
+```groovy
+fun Any?.assertNotNull(parameterName: String = ""): Any //throw AssertionError if parameter is null
+fun Boolean.assertTrue(message: String): Boolean //throw AssertionError if boolean value is not true
+fun Boolean.assertFalse(message: String): Boolean //throw AssertionError if boolean value is not false
+fun Any?.assertNotEquals(anotherValue: Any, parameterName: String = "parameter"): Boolean //throw AssertionError if value is not equals another value
+fun String?.assertNotEmpty(parameterName: String): Boolean //throw AssertionError if string is null or empty
+fun
+
+### License ###
+* * *
+ The MIT License (MIT)
+
+ Copyright (c) 2016 Cleveroad Inc.
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
diff --git a/kotlin-ext/build.gradle b/kotlin-ext/build.gradle
new file mode 100644
index 0000000..6335aca
--- /dev/null
+++ b/kotlin-ext/build.gradle
@@ -0,0 +1,55 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply from: '../main_jcenter.settings.gradle'
+
+android {
+ compileSdkVersion rootProject.ext.compileSdkVersion as Integer
+ buildToolsVersion rootProject.ext.buildToolsVersion as String
+
+ defaultConfig {
+ minSdkVersion rootProject.ext.minSdkVersion as Integer
+ targetSdkVersion rootProject.ext.compileSdkVersion as Integer
+ targetSdkVersion rootProject.ext.compileSdkVersion as Integer
+ versionCode libraryVersionCode
+ versionName libraryVersion
+
+ testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+ }
+ buildTypes {
+ debug {
+ minifyEnabled false
+ debuggable true
+ proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+ }
+ release {
+ minifyEnabled false
+ debuggable false
+ proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+ }
+ }
+
+ sourceSets {
+ main.java.srcDirs += 'src/main/kotlin'
+ }
+}
+
+dependencies {
+ implementation fileTree(dir: 'libs', include: ['*.jar'])
+ // tests
+ testImplementation testsDependencies.junit
+ testImplementation testsDependencies.runner
+
+ // common
+ implementation kotlinDependencies.jdk
+ implementation supportDependencies.appCompat
+
+ // rx
+ implementation rxjava2Dependencies.rxkotlin
+ implementation rxjava2Dependencies.rxandroid
+
+}
+
+repositories {
+ mavenCentral()
+}
diff --git a/kotlin-ext/proguard-rules.pro b/kotlin-ext/proguard-rules.pro
new file mode 100644
index 0000000..f1b4245
--- /dev/null
+++ b/kotlin-ext/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+# http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+# public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
diff --git a/kotlin-ext/src/main/AndroidManifest.xml b/kotlin-ext/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..d3ab96d
--- /dev/null
+++ b/kotlin-ext/src/main/AndroidManifest.xml
@@ -0,0 +1 @@
+