multiplatform: split common/android/desktop (#2672)

* multiplatform: relocated code to its new place * code becomes better * renamed file * fixes for BASE64 and images, and changes for appFileUri * different Base64 for both platforms * fix file saving on long click * platformCallbacks refactoring * renamed callbacks to platform * eol --------- Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>
2026-07-28 23:00:08 +00:00 · 2023-07-12 14:42:10 +01:00
parent ff7c22e114
commit 38f40fec3d
251 changed files with 4290 additions and 2469 deletions
@@ -0,0 +1,22 @@
+package chat.simplex.common.helpers
+
+import android.net.Uri
+import android.os.Build
+import chat.simplex.common.model.NotificationsMode
+import java.net.URI
+
+val NotificationsMode.requiresIgnoringBatterySinceSdk: Int get() = when(this) {
+  NotificationsMode.OFF -> Int.MAX_VALUE
+  NotificationsMode.PERIODIC -> Build.VERSION_CODES.M
+  NotificationsMode.SERVICE -> Build.VERSION_CODES.S
+  /*INSTANT -> Int.MAX_VALUE - for Firebase notifications */
+}
+
+val NotificationsMode.requiresIgnoringBattery
+  get() = requiresIgnoringBatterySinceSdk <= Build.VERSION.SDK_INT
+
+lateinit var APPLICATION_ID: String
+
+fun Uri.toURI(): URI = URI(toString())
+
+fun URI.toUri(): Uri = Uri.parse(toString())
@@ -0,0 +1,39 @@
+package chat.simplex.common.helpers
+
+import android.app.Activity
+import android.content.res.Configuration
+import chat.simplex.common.model.SharedPreference
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.platform.defaultLocale
+import java.util.*
+
+fun Activity.saveAppLocale(pref: SharedPreference<String?>, languageCode: String? = null) {
+  //  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+  //    val localeManager = SimplexApp.context.getSystemService(LocaleManager::class.java)
+  //    localeManager.applicationLocales = LocaleList(Locale.forLanguageTag(languageCode ?: return))
+  //  } else {
+  pref.set(languageCode)
+  if (languageCode == null) {
+    applyLocale(defaultLocale)
+  }
+  recreate()
+  //  }
+}
+
+fun Activity.applyAppLocale(pref: SharedPreference<String?>) {
+  //  if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+  val lang = pref.get()
+  if (lang == null || lang == Locale.getDefault().language) return
+  applyLocale(Locale.forLanguageTag(lang))
+  //  }
+}
+
+private fun Activity.applyLocale(locale: Locale) {
+  Locale.setDefault(locale)
+  val appConf = Configuration(androidAppContext.resources.configuration).apply { setLocale(locale) }
+  val activityConf = Configuration(resources.configuration).apply { setLocale(locale) }
+  @Suppress("DEPRECATION")
+  androidAppContext.resources.updateConfiguration(appConf, resources.displayMetrics)
+  @Suppress("DEPRECATION")
+  resources.updateConfiguration(activityConf, resources.displayMetrics)
+}
@@ -0,0 +1,47 @@
+package chat.simplex.common.helpers
+
+import android.media.*
+import android.net.Uri
+import android.os.VibrationEffect
+import android.os.Vibrator
+import androidx.core.content.ContextCompat
+import chat.simplex.common.R
+import chat.simplex.common.platform.SoundPlayerInterface
+import chat.simplex.common.platform.androidAppContext
+import chat.simplex.common.views.helpers.withScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+
+object SoundPlayer: SoundPlayerInterface {
+  private var player: MediaPlayer? = null
+  var playing = false
+
+  override fun start(scope: CoroutineScope, sound: Boolean) {
+    player?.reset()
+    player = MediaPlayer().apply {
+      setAudioAttributes(
+        AudioAttributes.Builder()
+          .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+          .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+          .build()
+      )
+      setDataSource(androidAppContext, Uri.parse("android.resource://" + androidAppContext.packageName + "/" + R.raw.ring_once))
+      prepare()
+    }
+    val vibrator = ContextCompat.getSystemService(androidAppContext, Vibrator::class.java)
+    val effect = VibrationEffect.createOneShot(250, VibrationEffect.DEFAULT_AMPLITUDE)
+    playing = true
+    withScope(scope) {
+      while (playing) {
+        if (sound) player?.start()
+        vibrator?.vibrate(effect)
+        delay(3500)
+      }
+    }
+  }
+
+  override fun stop() {
+    playing = false
+    player?.stop()
+  }
+}
@@ -0,0 +1,70 @@
+package chat.simplex.common.platform
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.LocalServerSocket
+import android.util.Log
+import androidx.fragment.app.FragmentActivity
+import chat.simplex.common.*
+import chat.simplex.common.platform.*
+import java.io.*
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.concurrent.Semaphore
+import kotlin.concurrent.thread
+import kotlin.random.Random
+
+actual val appPlatform = AppPlatform.ANDROID
+
+var isAppOnForeground: Boolean = false
+
+@Suppress("ConstantLocale")
+val defaultLocale: Locale = Locale.getDefault()
+
+@SuppressLint("StaticFieldLeak")
+lateinit var androidAppContext: Context
+lateinit var mainActivity: WeakReference<FragmentActivity>
+
+actual fun initHaskell() {
+  val socketName = "chat.simplex.app.local.socket.address.listen.native.cmd2" + Random.nextLong(100000)
+  val s = Semaphore(0)
+  thread(name="stdout/stderr pipe") {
+    Log.d(TAG, "starting server")
+    var server: LocalServerSocket? = null
+    for (i in 0..100) {
+      try {
+        server = LocalServerSocket(socketName + i)
+        break
+      } catch (e: IOException) {
+        Log.e(TAG, e.stackTraceToString())
+      }
+    }
+    if (server == null) {
+      throw Error("Unable to setup local server socket. Contact developers")
+    }
+    Log.d(TAG, "started server")
+    s.release()
+    val receiver = server.accept()
+    Log.d(TAG, "started receiver")
+    val logbuffer = FifoQueue<String>(500)
+    if (receiver != null) {
+      val inStream = receiver.inputStream
+      val inStreamReader = InputStreamReader(inStream)
+      val input = BufferedReader(inStreamReader)
+      Log.d(TAG, "starting receiver loop")
+      while (true) {
+        val line = input.readLine() ?: break
+        Log.w("$TAG (stdout/stderr)", line)
+        logbuffer.add(line)
+      }
+      Log.w(TAG, "exited receiver loop")
+    }
+  }
+
+  System.loadLibrary("app-lib")
+
+  s.acquire()
+  pipeStdOutToSocket(socketName)
+
+  initHS()
+}
@@ -0,0 +1,9 @@
+package chat.simplex.common.platform
+
+import androidx.compose.runtime.*
+
+@SuppressWarnings("MissingJvmstatic")
+@Composable
+actual fun BackHandler(enabled: Boolean, onBack: () -> Unit) {
+  androidx.activity.compose.BackHandler(enabled, onBack)
+}
@@ -0,0 +1,71 @@
+package chat.simplex.common.platform
+
+import android.annotation.SuppressLint
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.generalGetString
+import chat.simplex.res.MR
+import java.security.KeyStore
+import javax.crypto.*
+import javax.crypto.spec.GCMParameterSpec
+
+actual val cryptor: CryptorInterface = Cryptor()
+
+@SuppressLint("ObsoleteSdkInt")
+internal class Cryptor: CryptorInterface {
+  private var keyStore: KeyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
+  private var warningShown = false
+
+  override fun decryptData(data: ByteArray, iv: ByteArray, alias: String): String? {
+    val secretKey = getSecretKey(alias)
+    if (secretKey == null) {
+      if (!warningShown) {
+        // Repeated calls will not show the alert again
+        warningShown = true
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(MR.strings.wrong_passphrase),
+          text = generalGetString(MR.strings.restore_passphrase_not_found_desc)
+        )
+      }
+      return null
+    }
+    val cipher: Cipher = Cipher.getInstance(TRANSFORMATION)
+    val spec = GCMParameterSpec(128, iv)
+    cipher.init(Cipher.DECRYPT_MODE, secretKey, spec)
+    return runCatching { String(cipher.doFinal(data))}.onFailure { Log.e(TAG, "doFinal: ${it.stackTraceToString()}") }.getOrNull()
+  }
+
+  override fun encryptText(text: String, alias: String): Pair<ByteArray, ByteArray> {
+    val cipher: Cipher = Cipher.getInstance(TRANSFORMATION)
+    cipher.init(Cipher.ENCRYPT_MODE, createSecretKey(alias))
+    return Pair(cipher.doFinal(text.toByteArray(charset("UTF-8"))), cipher.iv)
+  }
+
+  override fun deleteKey(alias: String) {
+    if (!keyStore.containsAlias(alias)) return
+    keyStore.deleteEntry(alias)
+  }
+
+  private fun createSecretKey(alias: String): SecretKey? {
+    if (keyStore.containsAlias(alias)) return getSecretKey(alias)
+    val keyGenerator: KeyGenerator = KeyGenerator.getInstance(KEY_ALGORITHM, "AndroidKeyStore")
+    keyGenerator.init(
+      KeyGenParameterSpec.Builder(alias, KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
+        .setBlockModes(BLOCK_MODE)
+        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+        .build()
+    )
+    return keyGenerator.generateKey()
+  }
+
+  private fun getSecretKey(alias: String): SecretKey? {
+    return (keyStore.getEntry(alias, null) as? KeyStore.SecretKeyEntry)?.secretKey
+  }
+
+  companion object {
+    private val KEY_ALGORITHM = KeyProperties.KEY_ALGORITHM_AES
+    private val BLOCK_MODE = KeyProperties.BLOCK_MODE_GCM
+    private val TRANSFORMATION = "AES/GCM/NoPadding"
+  }
+}
@@ -0,0 +1,40 @@
+package chat.simplex.common.platform
+
+import android.app.Application
+import android.net.Uri
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import chat.simplex.common.helpers.toURI
+import chat.simplex.common.helpers.toUri
+import java.io.*
+import java.net.URI
+
+actual val dataDir: File = androidAppContext.dataDir
+actual val tmpDir: File = androidAppContext.getDir("temp", Application.MODE_PRIVATE)
+actual val cacheDir: File = androidAppContext.cacheDir
+
+@Composable
+actual fun rememberFileChooserLauncher(getContent: Boolean, onResult: (URI?) -> Unit): FileChooserLauncher {
+  val launcher = rememberLauncherForActivityResult(
+    contract = if (getContent) ActivityResultContracts.GetContent() else ActivityResultContracts.CreateDocument(),
+    onResult = { onResult(it?.toURI()) }
+  )
+  return FileChooserLauncher(launcher)
+}
+
+actual class FileChooserLauncher actual constructor() {
+  private lateinit var launcher: ManagedActivityResultLauncher<String, Uri?>
+
+  constructor(launcher: ManagedActivityResultLauncher<String, Uri?>): this() {
+    this.launcher = launcher
+  }
+
+  actual suspend fun launch(input: String) {
+    launcher.launch(input)
+  }
+}
+
+actual fun URI.inputStream(): InputStream? = androidAppContext.contentResolver.openInputStream(toUri())
+actual fun URI.outputStream(): OutputStream = androidAppContext.contentResolver.openOutputStream(toUri())!!
@@ -0,0 +1,116 @@
+package chat.simplex.common.platform
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.drawable.AnimatedImageDrawable
+import android.os.Build
+import android.util.Base64
+import android.webkit.MimeTypeMap
+import androidx.compose.ui.graphics.*
+import androidx.core.graphics.applyCanvas
+import androidx.core.graphics.drawable.toBitmap
+import androidx.core.graphics.scale
+import boofcv.android.ConvertBitmap
+import boofcv.struct.image.GrayU8
+import chat.simplex.common.R
+import chat.simplex.common.views.helpers.errorBitmap
+import chat.simplex.common.views.helpers.getFileName
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.net.URI
+import kotlin.math.min
+import kotlin.math.sqrt
+
+actual fun base64ToBitmap(base64ImageString: String): ImageBitmap {
+  val imageString = base64ImageString
+    .removePrefix("data:image/png;base64,")
+    .removePrefix("data:image/jpg;base64,")
+  return try {
+    val imageBytes = Base64.decode(imageString, Base64.NO_WRAP)
+    BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size).asImageBitmap()
+  } catch (e: Exception) {
+    Log.e(TAG, "base64ToBitmap error: $e")
+    errorBitmap.asImageBitmap()
+  }
+}
+
+actual fun resizeImageToStrSize(image: ImageBitmap, maxDataSize: Long): String {
+  var img = image
+  var str = compressImageStr(img)
+  while (str.length > maxDataSize) {
+    val ratio = sqrt(str.length.toDouble() / maxDataSize.toDouble())
+    val clippedRatio = min(ratio, 2.0)
+    val width = (img.width.toDouble() / clippedRatio).toInt()
+    val height = img.height * width / img.width
+    img = Bitmap.createScaledBitmap(img.asAndroidBitmap(), width, height, true).asImageBitmap()
+    str = compressImageStr(img)
+  }
+  return str
+}
+
+// Inspired by https://github.com/MakeItEasyDev/Jetpack-Compose-Capture-Image-Or-Choose-from-Gallery
+actual fun cropToSquare(image: ImageBitmap): ImageBitmap {
+  var xOffset = 0
+  var yOffset = 0
+  val side = min(image.height, image.width)
+  if (image.height < image.width) {
+    xOffset = (image.width - side) / 2
+  } else {
+    yOffset = (image.height - side) / 2
+  }
+  return Bitmap.createBitmap(image.asAndroidBitmap(), xOffset, yOffset, side, side).asImageBitmap()
+}
+
+actual fun compressImageStr(bitmap: ImageBitmap): String {
+  val usePng = bitmap.hasAlpha
+  val ext = if (usePng) "png" else "jpg"
+  return "data:image/$ext;base64," + Base64.encodeToString(compressImageData(bitmap, usePng).toByteArray(), Base64.NO_WRAP)
+}
+
+actual fun compressImageData(bitmap: ImageBitmap, usePng: Boolean): ByteArrayOutputStream {
+  val stream = ByteArrayOutputStream()
+  bitmap.asAndroidBitmap().compress(if (!usePng) Bitmap.CompressFormat.JPEG else Bitmap.CompressFormat.PNG, 85, stream)
+  return stream
+}
+
+actual fun resizeImageToDataSize(image: ImageBitmap, usePng: Boolean, maxDataSize: Long): ByteArrayOutputStream {
+  var img = image
+  var stream = compressImageData(img, usePng)
+  while (stream.size() > maxDataSize) {
+    val ratio = sqrt(stream.size().toDouble() / maxDataSize.toDouble())
+    val clippedRatio = min(ratio, 2.0)
+    val width = (img.width.toDouble() / clippedRatio).toInt()
+    val height = img.height * width / img.width
+    img = Bitmap.createScaledBitmap(img.asAndroidBitmap(), width, height, true).asImageBitmap()
+    stream = compressImageData(img, usePng)
+  }
+  return stream
+}
+
+actual fun GrayU8.toImageBitmap(): ImageBitmap = ConvertBitmap.grayToBitmap(this, Bitmap.Config.RGB_565).asImageBitmap()
+
+actual fun ImageBitmap.addLogo(): ImageBitmap = asAndroidBitmap().applyCanvas {
+  val radius = (width * 0.16f) / 2
+  val paint = android.graphics.Paint()
+  paint.color = android.graphics.Color.WHITE
+  drawCircle(width / 2f, height / 2f, radius, paint)
+  val logo = androidAppContext.resources.getDrawable(R.drawable.icon_foreground_android_common, null).toBitmap()
+  val logoSize = (width * 0.24).toInt()
+  translate((width - logoSize) / 2f, (height - logoSize) / 2f)
+  drawBitmap(logo, null, android.graphics.Rect(0, 0, logoSize, logoSize), null)
+}.asImageBitmap()
+
+actual fun ImageBitmap.scale(width: Int, height: Int): ImageBitmap = asAndroidBitmap().scale(width, height).asImageBitmap()
+
+actual fun isImage(uri: URI): Boolean =
+  MimeTypeMap.getSingleton().getMimeTypeFromExtension(getFileName(uri)?.split(".")?.last())?.contains("image/") == true
+
+actual fun isAnimImage(uri: URI, drawable: Any?): Boolean {
+  val isAnimNewApi = Build.VERSION.SDK_INT >= 28 && drawable is AnimatedImageDrawable
+  val isAnimOldApi = Build.VERSION.SDK_INT < 28 &&
+      (getFileName(uri)?.endsWith(".gif") == true || getFileName(uri)?.endsWith(".webp") == true)
+  return isAnimNewApi || isAnimOldApi
+}
+
+actual fun loadImageBitmap(inputStream: InputStream): ImageBitmap =
+  BitmapFactory.decodeStream(inputStream).asImageBitmap()
@@ -0,0 +1,10 @@
+package chat.simplex.common.platform
+
+import android.util.Log
+
+actual object Log {
+  actual fun d(tag: String, text: String) = Log.d(tag, text).run{}
+  actual fun e(tag: String, text: String) = Log.e(tag, text).run{}
+  actual fun i(tag: String, text: String) = Log.i(tag, text).run{}
+  actual fun w(tag: String, text: String) = Log.w(tag, text).run{}
+}
@@ -0,0 +1,16 @@
+package chat.simplex.common.platform
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.google.accompanist.insets.navigationBarsWithImePadding
+
+actual fun Modifier.navigationBarsWithImePadding(): Modifier = navigationBarsWithImePadding()
+
+@Composable
+actual fun ProvideWindowInsets(
+  consumeWindowInsets: Boolean,
+  windowInsetsAnimationsEnabled: Boolean,
+  content: @Composable () -> Unit
+) {
+  com.google.accompanist.insets.ProvideWindowInsets(content = content)
+}
@@ -0,0 +1,3 @@
+package chat.simplex.common.platform
+
+actual fun allowedToShowNotification(): Boolean = !isAppOnForeground
@@ -0,0 +1,160 @@
+package chat.simplex.common.platform
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.text.InputType
+import android.util.Log
+import android.view.OnReceiveContentListener
+import android.view.ViewGroup
+import android.view.inputmethod.*
+import android.widget.EditText
+import android.widget.TextView
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.graphics.drawable.DrawableCompat
+import androidx.core.view.inputmethod.EditorInfoCompat
+import androidx.core.view.inputmethod.InputConnectionCompat
+import androidx.core.widget.doAfterTextChanged
+import androidx.core.widget.doOnTextChanged
+import chat.simplex.common.*
+import chat.simplex.common.R
+import chat.simplex.common.helpers.toURI
+import chat.simplex.common.model.ChatModel
+import chat.simplex.common.ui.theme.CurrentColors
+import chat.simplex.common.views.chat.*
+import chat.simplex.common.views.helpers.SharedContent
+import chat.simplex.common.views.helpers.generalGetString
+import chat.simplex.res.MR
+import dev.icerock.moko.resources.StringResource
+import kotlinx.coroutines.delay
+import java.lang.reflect.Field
+import java.net.URI
+
+@Composable
+actual fun PlatformTextField(
+  composeState: MutableState<ComposeState>,
+  textStyle: MutableState<TextStyle>,
+  showDeleteTextButton: MutableState<Boolean>,
+  userIsObserver: Boolean,
+  onMessageChange: (String) -> Unit
+) {
+  val cs = composeState.value
+  val textColor = MaterialTheme.colors.onBackground
+  val tintColor = MaterialTheme.colors.secondaryVariant
+  val padding = PaddingValues(12.dp, 7.dp, 45.dp, 0.dp)
+  val paddingStart = with(LocalDensity.current) { 12.dp.roundToPx() }
+  val paddingTop = with(LocalDensity.current) { 7.dp.roundToPx() }
+  val paddingEnd = with(LocalDensity.current) { 45.dp.roundToPx() }
+  val paddingBottom = with(LocalDensity.current) { 7.dp.roundToPx() }
+  var showKeyboard by remember { mutableStateOf(false) }
+  LaunchedEffect(cs.contextItem) {
+    if (cs.contextItem is ComposeContextItem.QuotedItem) {
+      delay(100)
+      showKeyboard = true
+    } else if (cs.contextItem is ComposeContextItem.EditingItem) {
+      // Keyboard will not show up if we try to show it too fast
+      delay(300)
+      showKeyboard = true
+    }
+  }
+
+  AndroidView(modifier = Modifier, factory = {
+    val editText = @SuppressLint("AppCompatCustomView") object: EditText(it) {
+      override fun setOnReceiveContentListener(
+        mimeTypes: Array<out String>?,
+        listener: OnReceiveContentListener?
+      ) {
+        super.setOnReceiveContentListener(mimeTypes, listener)
+      }
+
+      override fun onCreateInputConnection(editorInfo: EditorInfo): InputConnection {
+        val connection = super.onCreateInputConnection(editorInfo)
+        EditorInfoCompat.setContentMimeTypes(editorInfo, arrayOf("image/*"))
+        val onCommit = InputConnectionCompat.OnCommitContentListener { inputContentInfo, _, _ ->
+          try {
+            inputContentInfo.requestPermission()
+          } catch (e: Exception) {
+            return@OnCommitContentListener false
+          }
+          ChatModel.sharedContent.value = SharedContent.Media("", listOf(inputContentInfo.contentUri.toURI()))
+          true
+        }
+        return InputConnectionCompat.createWrapper(connection, editorInfo, onCommit)
+      }
+    }
+    editText.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
+    editText.maxLines = 16
+    editText.inputType = InputType.TYPE_TEXT_FLAG_CAP_SENTENCES or editText.inputType
+    editText.setTextColor(textColor.toArgb())
+    editText.textSize = textStyle.value.fontSize.value
+    val drawable = androidAppContext.getDrawable(R.drawable.send_msg_view_background)!!
+    DrawableCompat.setTint(drawable, tintColor.toArgb())
+    editText.background = drawable
+    editText.setPadding(paddingStart, paddingTop, paddingEnd, paddingBottom)
+    editText.setText(cs.message)
+    if (Build.VERSION.SDK_INT >= 29) {
+      editText.textCursorDrawable?.let { DrawableCompat.setTint(it, CurrentColors.value.colors.secondary.toArgb()) }
+    } else {
+      try {
+        val f: Field = TextView::class.java.getDeclaredField("mCursorDrawableRes")
+        f.isAccessible = true
+        f.set(editText, R.drawable.edit_text_cursor)
+      } catch (e: Exception) {
+        Log.e(TAG, e.stackTraceToString())
+      }
+    }
+    editText.doOnTextChanged { text, _, _, _ ->
+      if (!composeState.value.inProgress) {
+        onMessageChange(text.toString())
+      } else if (text.toString() != composeState.value.message) {
+        editText.setText(composeState.value.message)
+      }
+    }
+    editText.doAfterTextChanged { text -> if (composeState.value.preview is ComposePreview.VoicePreview && text.toString() != "") editText.setText("") }
+    editText
+  }) {
+    it.setTextColor(textColor.toArgb())
+    it.textSize = textStyle.value.fontSize.value
+    DrawableCompat.setTint(it.background, tintColor.toArgb())
+    it.isFocusable = composeState.value.preview !is ComposePreview.VoicePreview
+    it.isFocusableInTouchMode = it.isFocusable
+    if (cs.message != it.text.toString()) {
+      it.setText(cs.message)
+      // Set cursor to the end of the text
+      it.setSelection(it.text.length)
+    }
+    if (showKeyboard) {
+      it.requestFocus()
+      val imm: InputMethodManager = androidAppContext.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+      imm.showSoftInput(it, InputMethodManager.SHOW_IMPLICIT)
+      showKeyboard = false
+    }
+    showDeleteTextButton.value = it.lineCount >= 4 && !cs.inProgress
+  }
+  if (composeState.value.preview is ComposePreview.VoicePreview) {
+    ComposeOverlay(MR.strings.voice_message_send_text, textStyle, padding)
+  } else if (userIsObserver) {
+    ComposeOverlay(MR.strings.you_are_observer, textStyle, padding)
+  }
+}
+
+@Composable
+private fun ComposeOverlay(textId: StringResource, textStyle: MutableState<TextStyle>, padding: PaddingValues) {
+  Text(
+    generalGetString(textId),
+    Modifier.padding(padding),
+    color = MaterialTheme.colors.secondary,
+    style = textStyle.value.copy(fontStyle = FontStyle.Italic)
+  )
+}
@@ -0,0 +1,285 @@
+package chat.simplex.common.platform
+
+import android.app.Application
+import android.content.Context
+import android.media.*
+import android.media.AudioManager.AudioPlaybackCallback
+import android.media.MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED
+import android.media.MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
+import android.os.Build
+import androidx.compose.runtime.*
+import chat.simplex.res.MR
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.platform.AudioPlayer.duration
+import chat.simplex.common.views.helpers.*
+import kotlinx.coroutines.*
+import java.io.*
+
+actual class RecorderNative: RecorderInterface {
+  private var recorder: MediaRecorder? = null
+  private var progressJob: Job? = null
+  private var filePath: String? = null
+  private var recStartedAt: Long? = null
+  private fun initRecorder() =
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      MediaRecorder(androidAppContext)
+    } else {
+      MediaRecorder()
+    }
+
+  override fun start(onProgressUpdate: (position: Int?, finished: Boolean) -> Unit): String {
+    VideoPlayer.stopAll()
+    AudioPlayer.stop()
+    val rec: MediaRecorder
+    recorder = initRecorder().also { rec = it }
+    rec.setAudioSource(MediaRecorder.AudioSource.MIC)
+    rec.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+    rec.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+    rec.setAudioChannels(1)
+    rec.setAudioSamplingRate(16000)
+    rec.setAudioEncodingBitRate(32000)
+    rec.setMaxDuration(MAX_VOICE_MILLIS_FOR_SENDING)
+    val fileToSave = File.createTempFile(generateNewFileName("voice", "${RecorderInterface.extension}_"), ".tmp", tmpDir)
+    fileToSave.deleteOnExit()
+    val path = fileToSave.absolutePath
+    filePath = path
+    rec.setOutputFile(path)
+    rec.prepare()
+    rec.start()
+    recStartedAt = System.currentTimeMillis()
+    progressJob = CoroutineScope(Dispatchers.Default).launch {
+      while(isActive) {
+        onProgressUpdate(progress(), false)
+        delay(50)
+      }
+    }.apply {
+      invokeOnCompletion {
+        onProgressUpdate(realDuration(path), true)
+      }
+    }
+    rec.setOnInfoListener { _, what, _ ->
+      if (what == MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED || what == MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
+        stop()
+      }
+    }
+    RecorderInterface.stopRecording = { stop() }
+    return path
+  }
+
+  override fun stop(): Int {
+    val path = filePath ?: return 0
+    RecorderInterface.stopRecording = null
+    runCatching {
+      recorder?.stop()
+    }
+    runCatching {
+      recorder?.reset()
+    }
+    runCatching {
+      recorder?.release()
+    }
+    // Await coroutine finishes in order to send real duration to it's listener
+    runBlocking {
+      progressJob?.cancelAndJoin()
+    }
+    progressJob = null
+    filePath = null
+    recorder = null
+    return (realDuration(path) ?: 0).also { recStartedAt = null }
+  }
+
+  private fun progress(): Int? = recStartedAt?.let { (System.currentTimeMillis() - it).toInt() }
+
+  /**
+  * Return real duration from [AudioPlayer] if it's possible (should always be possible).
+  * As a fallback, return internally counted duration
+  * */
+  private fun realDuration(path: String): Int? = duration(path) ?: progress()
+}
+
+actual object AudioPlayer: AudioPlayerInterface {
+  private val player = MediaPlayer().apply {
+    setAudioAttributes(
+      AudioAttributes.Builder()
+        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+        .setUsage(AudioAttributes.USAGE_MEDIA)
+        .build()
+    )
+    (androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager)
+      .registerAudioPlaybackCallback(object: AudioPlaybackCallback() {
+        override fun onPlaybackConfigChanged(configs: MutableList<AudioPlaybackConfiguration>?) {
+          if (configs?.any { it.audioAttributes.usage == AudioAttributes.USAGE_VOICE_COMMUNICATION } == true) {
+            // In a process of making a call
+            RecorderInterface.stopRecording?.invoke()
+            AudioPlayer.stop()
+          }
+          super.onPlaybackConfigChanged(configs)
+        }
+      }, null)
+  }
+  private val helperPlayer: MediaPlayer =  MediaPlayer().apply {
+        setAudioAttributes(
+          AudioAttributes.Builder()
+            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .build()
+        )
+  }
+  // Filepath: String, onProgressUpdate
+  private val currentlyPlaying: MutableState<Pair<String, (position: Int?, state: TrackState) -> Unit>?> = mutableStateOf(null)
+  private var progressJob: Job? = null
+
+  enum class TrackState {
+    PLAYING, PAUSED, REPLACED
+  }
+
+  // Returns real duration of the track
+  private fun start(filePath: String, seek: Int? = null, onProgressUpdate: (position: Int?, state: TrackState) -> Unit): Int? {
+    if (!File(filePath).exists()) {
+      Log.e(TAG, "No such file: $filePath")
+      return null
+    }
+
+    VideoPlayer.stopAll()
+    RecorderInterface.stopRecording?.invoke()
+    val current = currentlyPlaying.value
+    if (current == null || current.first != filePath) {
+      stopListener()
+      player.reset()
+      runCatching {
+        player.setDataSource(filePath)
+      }.onFailure {
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(MR.strings.unknown_error), it.message)
+        return null
+      }
+      runCatching { player.prepare() }.onFailure {
+        // Can happen when audio file is broken
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(MR.strings.unknown_error), it.message)
+        return null
+      }
+    }
+    if (seek != null) player.seekTo(seek)
+    player.start()
+    currentlyPlaying.value = filePath to onProgressUpdate
+    progressJob = CoroutineScope(Dispatchers.Default).launch {
+      onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+      while(isActive && player.isPlaying) {
+        // Even when current position is equal to duration, the player has isPlaying == true for some time,
+        // so help to make the playback stopped in UI immediately
+        if (player.currentPosition == player.duration) {
+          onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+          break
+        }
+        delay(50)
+        onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+      }
+      /*
+      * Since coroutine is still NOT canceled, means player ended (no stop/no pause). But in some cases
+      * the player can show position != duration even if they actually equal.
+      * Let's say to a listener that the position == duration in case of coroutine finished without cancel
+      * */
+      if (isActive) {
+        onProgressUpdate(player.duration, TrackState.PAUSED)
+      }
+      onProgressUpdate(null, TrackState.PAUSED)
+    }
+    return player.duration
+  }
+
+  private fun pause(): Int {
+    progressJob?.cancel()
+    progressJob = null
+    player.pause()
+    return player.currentPosition
+  }
+
+  override fun stop() {
+    if (currentlyPlaying.value == null) return
+    player.stop()
+    stopListener()
+  }
+
+  override fun stop(item: ChatItem) = stop(item.file?.fileName)
+
+  // FileName or filePath are ok
+  override fun stop(fileName: String?) {
+    if (fileName != null && currentlyPlaying.value?.first?.endsWith(fileName) == true) {
+      stop()
+    }
+  }
+
+  private fun stopListener() {
+    val afterCoroutineCancel: CompletionHandler = {
+      // Notify prev audio listener about stop
+      currentlyPlaying.value?.second?.invoke(null, TrackState.REPLACED)
+      currentlyPlaying.value = null
+    }
+    /** Preventing race by calling a code AFTER coroutine ends, so [TrackState] will be:
+     * [TrackState.PLAYING] -> [TrackState.PAUSED] -> [TrackState.REPLACED] (in this order)
+     * */
+    if (progressJob != null) {
+      progressJob?.invokeOnCompletion(afterCoroutineCancel)
+    } else {
+      afterCoroutineCancel(null)
+    }
+    progressJob?.cancel()
+    progressJob = null
+  }
+
+  override fun play(
+    filePath: String?,
+    audioPlaying: MutableState<Boolean>,
+    progress: MutableState<Int>,
+    duration: MutableState<Int>,
+    resetOnEnd: Boolean,
+  ) {
+    if (progress.value == duration.value) {
+      progress.value = 0
+    }
+    val realDuration = start(filePath ?: return, progress.value) { pro, state ->
+      if (pro != null) {
+        progress.value = pro
+      }
+      if (pro == null || pro == duration.value) {
+        audioPlaying.value = false
+        if (pro == duration.value) {
+          progress.value = if (resetOnEnd) 0 else duration.value
+        } else if (state == TrackState.REPLACED) {
+          progress.value = 0
+        }
+      }
+    }
+    audioPlaying.value = realDuration != null
+    // Update to real duration instead of what was received in ChatInfo
+    realDuration?.let { duration.value = it }
+  }
+
+  override fun pause(audioPlaying: MutableState<Boolean>, pro: MutableState<Int>) {
+    pro.value = pause()
+    audioPlaying.value = false
+  }
+
+  override fun seekTo(ms: Int, pro: MutableState<Int>, filePath: String?) {
+    pro.value = ms
+    if (currentlyPlaying.value?.first == filePath) {
+      player.seekTo(ms)
+    }
+  }
+
+  override fun duration(filePath: String): Int? {
+    var res: Int? = null
+    kotlin.runCatching {
+      helperPlayer.setDataSource(filePath)
+      helperPlayer.prepare()
+      helperPlayer.start()
+      helperPlayer.stop()
+      res = helperPlayer.duration
+      helperPlayer.reset()
+    }
+    return res
+  }
+}
+
+actual typealias SoundPlayer = chat.simplex.common.helpers.SoundPlayer
@@ -0,0 +1,51 @@
+package chat.simplex.common.platform
+
+import android.annotation.SuppressLint
+import android.app.UiModeManager
+import android.content.Context
+import android.content.SharedPreferences
+import android.content.res.Configuration
+import android.text.BidiFormatter
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.Font
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import chat.simplex.common.model.AppPreferences
+import com.russhwolf.settings.Settings
+import com.russhwolf.settings.SharedPreferencesSettings
+import dev.icerock.moko.resources.StringResource
+import dev.icerock.moko.resources.desc.desc
+
+@SuppressLint("DiscouragedApi")
+@Composable
+actual fun font(name: String, res: String, weight: FontWeight, style: FontStyle): Font {
+  val context = LocalContext.current
+  val id = context.resources.getIdentifier(res, "font", context.packageName)
+  return Font(id, weight, style)
+}
+
+actual fun StringResource.localized(): String = desc().toString(context = androidAppContext)
+
+actual fun isInNightMode() =
+  (androidAppContext.getSystemService(Context.UI_MODE_SERVICE) as UiModeManager).nightMode == UiModeManager.MODE_NIGHT_YES
+
+private val sharedPreferences: SharedPreferences by lazy { androidAppContext.getSharedPreferences(AppPreferences.SHARED_PREFS_ID, Context.MODE_PRIVATE) }
+private val sharedPreferencesThemes: SharedPreferences by lazy { androidAppContext.getSharedPreferences(AppPreferences.SHARED_PREFS_THEMES_ID, Context.MODE_PRIVATE) }
+
+actual val settings: Settings by lazy { SharedPreferencesSettings(sharedPreferences) }
+actual val settingsThemes: Settings by lazy { SharedPreferencesSettings(sharedPreferencesThemes) }
+
+actual fun screenOrientation(): ScreenOrientation = when (mainActivity.get()?.resources?.configuration?.orientation) {
+  Configuration.ORIENTATION_PORTRAIT -> ScreenOrientation.PORTRAIT
+  Configuration.ORIENTATION_LANDSCAPE -> ScreenOrientation.LANDSCAPE
+  else -> ScreenOrientation.UNDEFINED
+}
+
+@Composable
+actual fun screenWidth(): Dp = LocalConfiguration.current.screenWidthDp.dp
+
+actual fun isRtl(text: CharSequence): Boolean = BidiFormatter.getInstance().isRtl(text)
@@ -0,0 +1,95 @@
+package chat.simplex.common.platform
+
+import android.Manifest
+import android.content.*
+import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+import android.net.Uri
+import android.provider.MediaStore
+import android.webkit.MimeTypeMap
+import androidx.compose.ui.platform.ClipboardManager
+import androidx.compose.ui.platform.UriHandler
+import chat.simplex.common.helpers.toUri
+import chat.simplex.common.model.CIFile
+import chat.simplex.common.views.helpers.generalGetString
+import chat.simplex.common.views.helpers.getAppFileUri
+import java.io.BufferedOutputStream
+import java.io.File
+import chat.simplex.res.MR
+
+actual fun ClipboardManager.shareText(text: String) {
+  val sendIntent: Intent = Intent().apply {
+    action = Intent.ACTION_SEND
+    putExtra(Intent.EXTRA_TEXT, text)
+    type = "text/plain"
+    flags = FLAG_ACTIVITY_NEW_TASK
+  }
+  val shareIntent = Intent.createChooser(sendIntent, null)
+  shareIntent.addFlags(FLAG_ACTIVITY_NEW_TASK)
+  androidAppContext.startActivity(shareIntent)
+}
+
+actual fun shareFile(text: String, filePath: String) {
+  val uri = getAppFileUri(filePath.substringAfterLast(File.separator))
+  val ext = filePath.substringAfterLast(".")
+  val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) ?: return
+  val sendIntent: Intent = Intent().apply {
+    action = Intent.ACTION_SEND
+    /*if (text.isNotEmpty()) {
+      putExtra(Intent.EXTRA_TEXT, text)
+    }*/
+    putExtra(Intent.EXTRA_STREAM, uri.toUri())
+    type = mimeType
+    flags = Intent.FLAG_ACTIVITY_NEW_TASK
+  }
+  val shareIntent = Intent.createChooser(sendIntent, null)
+  shareIntent.addFlags(FLAG_ACTIVITY_NEW_TASK)
+  androidAppContext.startActivity(shareIntent)
+}
+
+actual fun UriHandler.sendEmail(subject: String, body: CharSequence) {
+  val emailIntent = Intent(Intent.ACTION_SENDTO, Uri.parse("mailto:"))
+  emailIntent.putExtra(Intent.EXTRA_SUBJECT, subject)
+  emailIntent.putExtra(Intent.EXTRA_TEXT, body)
+  emailIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+  try {
+    androidAppContext.startActivity(emailIntent)
+  } catch (e: ActivityNotFoundException) {
+    Log.e(TAG, "No activity was found for handling email intent")
+  }
+}
+
+fun imageMimeType(fileName: String): String {
+  val lowercaseName = fileName.lowercase()
+  return when {
+    lowercaseName.endsWith(".png") -> "image/png"
+    lowercaseName.endsWith(".gif") -> "image/gif"
+    lowercaseName.endsWith(".webp") -> "image/webp"
+    lowercaseName.endsWith(".avif") -> "image/avif"
+    lowercaseName.endsWith(".svg") -> "image/svg+xml"
+    else -> "image/jpeg"
+  }
+}
+
+/** Before calling, make sure the user allows to write to external storage [Manifest.permission.WRITE_EXTERNAL_STORAGE] */
+fun saveImage(ciFile: CIFile?) {
+  val filePath = getLoadedFilePath(ciFile)
+  val fileName = ciFile?.fileName
+  if (filePath != null && fileName != null) {
+    val values = ContentValues()
+    values.put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis())
+    values.put(MediaStore.Images.Media.MIME_TYPE, imageMimeType(fileName))
+    values.put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
+    values.put(MediaStore.MediaColumns.TITLE, fileName)
+    val uri = androidAppContext.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+    uri?.let {
+      androidAppContext.contentResolver.openOutputStream(uri)?.let { stream ->
+        val outputStream = BufferedOutputStream(stream)
+        File(filePath).inputStream().use { it.copyTo(outputStream) }
+        outputStream.close()
+        showToast(generalGetString(MR.strings.image_saved))
+      }
+    }
+  } else {
+    showToast(generalGetString(MR.strings.file_not_found))
+  }
+}
@@ -0,0 +1,71 @@
+package chat.simplex.common.platform
+
+import android.app.Activity
+import android.content.Context
+import android.content.pm.ActivityInfo
+import android.graphics.Rect
+import android.os.Build
+import android.view.*
+import android.view.inputmethod.InputMethodManager
+import android.widget.Toast
+import androidx.compose.runtime.*
+import androidx.compose.ui.platform.LocalView
+import chat.simplex.common.views.helpers.KeyboardState
+import androidx.compose.ui.platform.LocalContext as LocalContext1
+
+actual fun showToast(text: String, timeout: Long) = Toast.makeText(androidAppContext, text, Toast.LENGTH_SHORT).show()
+
+@Composable
+actual fun LockToCurrentOrientationUntilDispose() {
+  val context = LocalContext1.current
+  DisposableEffect(Unit) {
+    val activity = (context as Activity?) ?: return@DisposableEffect onDispose {}
+    val manager = context.getSystemService(Activity.WINDOW_SERVICE) as WindowManager
+    val rotation = if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) manager.defaultDisplay.rotation else activity.display?.rotation
+    activity.requestedOrientation = when (rotation) {
+      Surface.ROTATION_90 -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      Surface.ROTATION_180 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+      Surface.ROTATION_270 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+      else -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    }
+    // Unlock orientation
+    onDispose { activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED }
+  }
+}
+
+@Composable
+actual fun LocalMultiplatformView(): Any? = LocalView.current
+
+@Composable
+actual fun getKeyboardState(): State<KeyboardState> {
+  val keyboardState = remember { mutableStateOf(KeyboardState.Closed) }
+  val view = LocalView.current
+  DisposableEffect(view) {
+    val onGlobalListener = ViewTreeObserver.OnGlobalLayoutListener {
+      val rect = Rect()
+      view.getWindowVisibleDisplayFrame(rect)
+      val screenHeight = view.rootView.height
+      val keypadHeight = screenHeight - rect.bottom
+      keyboardState.value = if (keypadHeight > screenHeight * 0.15) {
+        KeyboardState.Opened
+      } else {
+        KeyboardState.Closed
+      }
+    }
+    view.viewTreeObserver.addOnGlobalLayoutListener(onGlobalListener)
+
+    onDispose {
+      view.viewTreeObserver.removeOnGlobalLayoutListener(onGlobalListener)
+    }
+  }
+
+  return keyboardState
+}
+
+actual fun hideKeyboard(view: Any?) {
+  // LALAL
+  //  LocalSoftwareKeyboardController.current?.hide()
+  if (view is View) {
+    (androidAppContext.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).hideSoftInputFromWindow(view.windowToken, 0)
+  }
+}
@@ -0,0 +1,241 @@
+package chat.simplex.common.platform
+
+import android.media.session.PlaybackState
+import android.net.Uri
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.ui.graphics.ImageBitmap
+import chat.simplex.common.views.helpers.*
+import chat.simplex.res.MR
+import com.google.android.exoplayer2.*
+import com.google.android.exoplayer2.C.*
+import com.google.android.exoplayer2.audio.AudioAttributes
+import com.google.android.exoplayer2.source.ProgressiveMediaSource
+import com.google.android.exoplayer2.upstream.DefaultDataSource
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource
+import kotlinx.coroutines.*
+import java.io.File
+import java.net.URI
+
+actual class VideoPlayer private constructor(
+  private val uri: URI,
+  private val gallery: Boolean,
+  private val defaultPreview: ImageBitmap,
+  defaultDuration: Long,
+  soundEnabled: Boolean
+): VideoPlayerInterface {
+  actual companion object {
+    private val players: MutableMap<Pair<URI, Boolean>, VideoPlayer> = mutableMapOf()
+    private val previewsAndDurations: MutableMap<URI, VideoPlayerInterface.PreviewAndDuration> = mutableMapOf()
+
+    actual fun getOrCreate(
+      uri: URI,
+      gallery: Boolean,
+      defaultPreview: ImageBitmap,
+      defaultDuration: Long,
+      soundEnabled: Boolean
+    ): VideoPlayer =
+      players.getOrPut(uri to gallery) { VideoPlayer(uri, gallery, defaultPreview, defaultDuration, soundEnabled) }
+
+    actual fun enableSound(enable: Boolean, fileName: String?, gallery: Boolean): Boolean =
+      player(fileName, gallery)?.enableSound(enable) == true
+
+    private fun player(fileName: String?, gallery: Boolean): VideoPlayer? {
+      fileName ?: return null
+      return players.values.firstOrNull { player -> player.uri.path?.endsWith(fileName) == true && player.gallery == gallery }
+    }
+
+    actual fun release(uri: URI, gallery: Boolean, remove: Boolean) =
+      player(uri.path, gallery)?.release(remove).run {  }
+
+    actual fun stopAll() {
+      players.values.forEach { it.stop() }
+    }
+
+    actual fun releaseAll() {
+      players.values.forEach { it.release(false) }
+      players.clear()
+      previewsAndDurations.clear()
+    }
+  }
+
+  private val currentVolume: Float
+  override val soundEnabled: MutableState<Boolean> = mutableStateOf(soundEnabled)
+  override val brokenVideo: MutableState<Boolean> = mutableStateOf(false)
+  override val videoPlaying: MutableState<Boolean> = mutableStateOf(false)
+  override val progress: MutableState<Long> = mutableStateOf(0L)
+  override val duration: MutableState<Long> = mutableStateOf(defaultDuration)
+  override val preview: MutableState<ImageBitmap> = mutableStateOf(defaultPreview)
+
+  init {
+    setPreviewAndDuration()
+  }
+
+  val player = ExoPlayer.Builder(androidAppContext,
+    DefaultRenderersFactory(androidAppContext))
+    /*.setLoadControl(DefaultLoadControl.Builder()
+      .setPrioritizeTimeOverSizeThresholds(false) // Could probably save some megabytes in memory in case it will be needed
+      .createDefaultLoadControl())*/
+    .setSeekBackIncrementMs(10_000)
+    .setSeekForwardIncrementMs(10_000)
+    .build()
+    .apply {
+      // Repeat the same track endlessly
+      repeatMode = Player.REPEAT_MODE_ONE
+      currentVolume = volume
+      if (!soundEnabled) {
+        volume = 0f
+      }
+      setAudioAttributes(
+        AudioAttributes.Builder()
+          .setContentType(CONTENT_TYPE_MUSIC)
+          .setUsage(USAGE_MEDIA)
+          .build(),
+        true // disallow to play multiple instances simultaneously
+      )
+    }
+
+  private val listener: MutableState<((position: Long?, state: TrackState) -> Unit)?> = mutableStateOf(null)
+  private var progressJob: Job? = null
+
+  enum class TrackState {
+    PLAYING, PAUSED, STOPPED
+  }
+
+  private fun start(seek: Long? = null, onProgressUpdate: (position: Long?, state: TrackState) -> Unit): Boolean {
+    val filepath = getAppFilePath(uri)
+    if (filepath == null || !File(filepath).exists()) {
+      Log.e(TAG, "No such file: $uri")
+      brokenVideo.value = true
+      return false
+    }
+
+    if (soundEnabled.value)  {
+      RecorderInterface.stopRecording?.invoke()
+    }
+    AudioPlayer.stop()
+    stopAll()
+    if (listener.value == null) {
+      runCatching {
+        val dataSourceFactory = DefaultDataSource.Factory(androidAppContext, DefaultHttpDataSource.Factory())
+        val source = ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(Uri.parse(uri.toString())))
+        player.setMediaSource(source, seek ?: 0L)
+      }.onFailure {
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(MR.strings.unknown_error), it.message)
+        brokenVideo.value = true
+        return false
+      }
+    }
+    if (player.playbackState == PlaybackState.STATE_NONE || player.playbackState == PlaybackState.STATE_STOPPED) {
+      runCatching { player.prepare() }.onFailure {
+        // Can happen when video file is broken
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(MR.strings.unknown_error), it.message)
+        brokenVideo.value = true
+        return false
+      }
+    }
+    if (seek != null) player.seekTo(seek)
+    player.play()
+    listener.value = onProgressUpdate
+    // Player can only be accessed in one specific thread
+    progressJob = CoroutineScope(Dispatchers.Main).launch {
+      onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+      while (isActive && player.playbackState != Player.STATE_IDLE && player.playWhenReady) {
+        // Even when current position is equal to duration, the player has isPlaying == true for some time,
+        // so help to make the playback stopped in UI immediately
+        if (player.currentPosition == player.duration) {
+          onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+          break
+        }
+        delay(50)
+        onProgressUpdate(player.currentPosition, TrackState.PLAYING)
+      }
+      /*
+      * Since coroutine is still NOT canceled, means player ended (no stop/no pause). But in some cases
+      * the player can show position != duration even if they actually equal.
+      * Let's say to a listener that the position == duration in case of coroutine finished without cancel
+      * */
+      if (isActive) {
+        onProgressUpdate(player.duration, TrackState.PAUSED)
+      }
+      onProgressUpdate(null, TrackState.PAUSED)
+    }
+    player.addListener(object: Player.Listener{
+      override fun onIsPlayingChanged(isPlaying: Boolean) {
+        super.onIsPlayingChanged(isPlaying)
+        // Produce non-ideal transition from stopped to playing state while showing preview image in ChatView
+        //        videoPlaying.value = isPlaying
+      }
+    })
+
+    return true
+  }
+
+  override fun stop() {
+    player.stop()
+    stopListener()
+  }
+
+  private fun stopListener() {
+    val afterCoroutineCancel: CompletionHandler = {
+      // Notify prev video listener about stop
+      listener.value?.invoke(null, TrackState.STOPPED)
+    }
+    /** Preventing race by calling a code AFTER coroutine ends, so [TrackState] will be:
+     * [TrackState.PLAYING] -> [TrackState.PAUSED] -> [TrackState.STOPPED] (in this order)
+     * */
+    if (progressJob != null) {
+      progressJob?.invokeOnCompletion(afterCoroutineCancel)
+    } else {
+      afterCoroutineCancel(null)
+    }
+    progressJob?.cancel()
+    progressJob = null
+  }
+
+  override fun play(resetOnEnd: Boolean) {
+    if (progress.value == duration.value) {
+      progress.value = 0
+    }
+    videoPlaying.value = start(progress.value) { pro, _ ->
+      if (pro != null) {
+        progress.value = pro
+      }
+      if (pro == null || pro == duration.value) {
+        videoPlaying.value = false
+        if (pro == duration.value) {
+          progress.value = if (resetOnEnd) 0 else duration.value
+        }/* else if (state == TrackState.STOPPED) {
+          progress.value = 0 //
+        }*/
+      }
+    }
+  }
+
+  override fun enableSound(enable: Boolean): Boolean {
+    if (soundEnabled.value == enable) return false
+    soundEnabled.value = enable
+    player.volume = if (enable) currentVolume else 0f
+    return true
+  }
+
+  override fun release(remove: Boolean) {
+    player.release()
+    if (remove) {
+      players.remove(uri to gallery)
+    }
+  }
+
+  private fun setPreviewAndDuration() {
+    // It freezes main thread, doing it in IO thread
+    CoroutineScope(Dispatchers.IO).launch {
+      val previewAndDuration = previewsAndDurations.getOrPut(uri) { getBitmapFromVideo(uri) }
+      withContext(Dispatchers.Main) {
+        preview.value = previewAndDuration.preview ?: defaultPreview
+        duration.value = (previewAndDuration.duration ?: 0)
+      }
+    }
+  }
+}
@@ -0,0 +1,13 @@
+package chat.simplex.common.ui.theme
+
+import androidx.compose.ui.text.font.*
+import chat.simplex.res.MR
+
+actual val Inter: FontFamily = FontFamily(
+  Font(MR.fonts.Inter.regular.fontResourceId),
+  Font(MR.fonts.Inter.italic.fontResourceId, style = FontStyle.Italic),
+  Font(MR.fonts.Inter.bold.fontResourceId, FontWeight.Bold),
+  Font(MR.fonts.Inter.semibold.fontResourceId, FontWeight.SemiBold),
+  Font(MR.fonts.Inter.medium.fontResourceId, FontWeight.Medium),
+  Font(MR.fonts.Inter.light.fontResourceId, FontWeight.Light)
+)
@@ -0,0 +1,575 @@
+package chat.simplex.common.views.call
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.*
+import android.content.pm.ActivityInfo
+import android.media.*
+import android.os.Build
+import android.os.PowerManager
+import android.os.PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK
+import android.view.ViewGroup
+import android.webkit.*
+import androidx.compose.desktop.ui.tooling.preview.Preview
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import dev.icerock.moko.resources.compose.painterResource
+import dev.icerock.moko.resources.compose.stringResource
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.webkit.WebViewAssetLoader
+import androidx.webkit.WebViewClientCompat
+import chat.simplex.common.model.*
+import chat.simplex.common.ui.theme.*
+import chat.simplex.common.views.helpers.ProfileImage
+import chat.simplex.common.views.helpers.withApi
+import chat.simplex.common.model.ChatModel
+import chat.simplex.common.model.Contact
+import chat.simplex.common.platform.*
+import chat.simplex.res.MR
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+import dev.icerock.moko.resources.StringResource
+import kotlinx.coroutines.*
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+
+@SuppressLint("SourceLockedOrientationActivity")
+@Composable
+actual fun ActiveCallView() {
+  val chatModel = ChatModel
+  BackHandler(onBack = {
+    val call = chatModel.activeCall.value
+    if (call != null) withApi { chatModel.callManager.endCall(call) }
+  })
+  val audioViaBluetooth = rememberSaveable { mutableStateOf(false) }
+  val ntfModeService = remember { chatModel.controller.appPrefs.notificationsMode.get() == NotificationsMode.SERVICE }
+  LaunchedEffect(Unit) {
+    // Start service when call happening since it's not already started.
+    // It's needed to prevent Android from shutting down a microphone after a minute or so when screen is off
+    if (!ntfModeService) platform.androidServiceStart()
+  }
+  DisposableEffect(Unit) {
+    val am = androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+    var btDeviceCount = 0
+    val audioCallback = object: AudioDeviceCallback() {
+      override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>) {
+        Log.d(TAG, "Added audio devices: ${addedDevices.map { it.type }}")
+        super.onAudioDevicesAdded(addedDevices)
+        val addedCount = addedDevices.count { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO }
+        btDeviceCount += addedCount
+        audioViaBluetooth.value = btDeviceCount > 0
+        if (addedCount > 0 && chatModel.activeCall.value?.callState == CallState.Connected) {
+          // Setting params in Connected state makes sure that Bluetooth will NOT be broken on Android < 12
+          setCallSound(chatModel.activeCall.value?.soundSpeaker ?: return, audioViaBluetooth)
+        }
+      }
+      override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
+        Log.d(TAG, "Removed audio devices: ${removedDevices.map { it.type }}")
+        super.onAudioDevicesRemoved(removedDevices)
+        val removedCount = removedDevices.count { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO }
+        btDeviceCount -= removedCount
+        audioViaBluetooth.value = btDeviceCount > 0
+        if (btDeviceCount == 0 && chatModel.activeCall.value?.callState == CallState.Connected) {
+          // Setting params in Connected state makes sure that Bluetooth will NOT be broken on Android < 12
+          setCallSound(chatModel.activeCall.value?.soundSpeaker ?: return, audioViaBluetooth)
+        }
+      }
+    }
+    am.registerAudioDeviceCallback(audioCallback, null)
+    val pm = (androidAppContext.getSystemService(Context.POWER_SERVICE) as PowerManager)
+    val proximityLock = if (pm.isWakeLockLevelSupported(PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+      pm.newWakeLock(PROXIMITY_SCREEN_OFF_WAKE_LOCK, androidAppContext.packageName + ":proximityLock")
+    } else {
+      null
+    }
+    proximityLock?.acquire()
+    onDispose {
+      // Stop it when call ended
+      if (!ntfModeService) platform.androidServiceSafeStop()
+      dropAudioManagerOverrides()
+      am.unregisterAudioDeviceCallback(audioCallback)
+      proximityLock?.release()
+    }
+  }
+  val scope = rememberCoroutineScope()
+  Box(Modifier.fillMaxSize()) {
+    WebRTCView(chatModel.callCommand) { apiMsg ->
+      Log.d(TAG, "received from WebRTCView: $apiMsg")
+      val call = chatModel.activeCall.value
+      if (call != null) {
+        Log.d(TAG, "has active call $call")
+        when (val r = apiMsg.resp) {
+          is WCallResponse.Capabilities -> withApi {
+            val callType = CallType(call.localMedia, r.capabilities)
+            chatModel.controller.apiSendCallInvitation(call.contact, callType)
+            chatModel.activeCall.value = call.copy(callState = CallState.InvitationSent, localCapabilities = r.capabilities)
+          }
+          is WCallResponse.Offer -> withApi {
+            chatModel.controller.apiSendCallOffer(call.contact, r.offer, r.iceCandidates, call.localMedia, r.capabilities)
+            chatModel.activeCall.value = call.copy(callState = CallState.OfferSent, localCapabilities = r.capabilities)
+          }
+          is WCallResponse.Answer -> withApi {
+            chatModel.controller.apiSendCallAnswer(call.contact, r.answer, r.iceCandidates)
+            chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
+          }
+          is WCallResponse.Ice -> withApi {
+            chatModel.controller.apiSendCallExtraInfo(call.contact, r.iceCandidates)
+          }
+          is WCallResponse.Connection ->
+            try {
+              val callStatus = json.decodeFromString<WebRTCCallStatus>("\"${r.state.connectionState}\"")
+              if (callStatus == WebRTCCallStatus.Connected) {
+                chatModel.activeCall.value = call.copy(callState = CallState.Connected)
+                setCallSound(call.soundSpeaker, audioViaBluetooth)
+              }
+              withApi { chatModel.controller.apiCallStatus(call.contact, callStatus) }
+            } catch (e: Error) {
+              Log.d(TAG,"call status ${r.state.connectionState} not used")
+            }
+          is WCallResponse.Connected -> {
+            chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo)
+            scope.launch {
+              setCallSound(call.soundSpeaker, audioViaBluetooth)
+            }
+          }
+          is WCallResponse.Ended -> {
+            chatModel.activeCall.value = call.copy(callState = CallState.Ended)
+            withApi { chatModel.callManager.endCall(call) }
+            chatModel.showCallView.value = false
+          }
+          is WCallResponse.Ok -> when (val cmd = apiMsg.command) {
+            is WCallCommand.Answer ->
+              chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
+            is WCallCommand.Media -> {
+              when (cmd.media) {
+                CallMediaType.Video -> chatModel.activeCall.value = call.copy(videoEnabled = cmd.enable)
+                CallMediaType.Audio -> chatModel.activeCall.value = call.copy(audioEnabled = cmd.enable)
+              }
+            }
+            is WCallCommand.Camera -> {
+              chatModel.activeCall.value = call.copy(localCamera = cmd.camera)
+              if (!call.audioEnabled) {
+                chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Audio, enable = false)
+              }
+            }
+            is WCallCommand.End ->
+              chatModel.showCallView.value = false
+            else -> {}
+          }
+          is WCallResponse.Error -> {
+            Log.e(TAG, "ActiveCallView: command error ${r.message}")
+          }
+        }
+      }
+    }
+    val call = chatModel.activeCall.value
+    if (call != null)  ActiveCallOverlay(call, chatModel, audioViaBluetooth)
+  }
+
+  val context = LocalContext.current
+  DisposableEffect(Unit) {
+    val activity = context as? Activity ?: return@DisposableEffect onDispose {}
+    val prevVolumeControlStream = activity.volumeControlStream
+    activity.volumeControlStream = AudioManager.STREAM_VOICE_CALL
+    // Lock orientation to portrait in order to have good experience with calls
+    activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    chatModel.activeCallViewIsVisible.value = true
+    onDispose {
+      activity.volumeControlStream = prevVolumeControlStream
+      // Unlock orientation
+      activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+      chatModel.activeCallViewIsVisible.value = false
+    }
+  }
+}
+
+@Composable
+private fun ActiveCallOverlay(call: Call, chatModel: ChatModel, audioViaBluetooth: MutableState<Boolean>) {
+  ActiveCallOverlayLayout(
+    call = call,
+    speakerCanBeEnabled = !audioViaBluetooth.value,
+    dismiss = { withApi { chatModel.callManager.endCall(call) } },
+    toggleAudio = { chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Audio, enable = !call.audioEnabled) },
+    toggleVideo = { chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Video, enable = !call.videoEnabled) },
+    toggleSound = {
+      var call = chatModel.activeCall.value
+      if (call != null) {
+        call = call.copy(soundSpeaker = !call.soundSpeaker)
+        chatModel.activeCall.value = call
+        setCallSound(call.soundSpeaker, audioViaBluetooth)
+      }
+    },
+    flipCamera = { chatModel.callCommand.value = WCallCommand.Camera(call.localCamera.flipped) }
+  )
+}
+
+private fun setCallSound(speaker: Boolean, audioViaBluetooth: MutableState<Boolean>) {
+  val am = androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  Log.d(TAG, "setCallSound: set audio mode, speaker enabled: $speaker")
+  am.mode = AudioManager.MODE_IN_COMMUNICATION
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    val btDevice = am.availableCommunicationDevices.lastOrNull { it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO }
+    val preferredSecondaryDevice = if (speaker) AudioDeviceInfo.TYPE_BUILTIN_SPEAKER else AudioDeviceInfo.TYPE_BUILTIN_EARPIECE
+    if (btDevice != null) {
+      am.setCommunicationDevice(btDevice)
+    } else if (am.communicationDevice?.type != preferredSecondaryDevice) {
+      am.availableCommunicationDevices.firstOrNull { it.type == preferredSecondaryDevice }?.let {
+        am.setCommunicationDevice(it)
+      }
+    }
+  } else {
+    if (audioViaBluetooth.value) {
+      am.isSpeakerphoneOn = false
+      am.startBluetoothSco()
+    } else {
+      am.stopBluetoothSco()
+      am.isSpeakerphoneOn = speaker
+    }
+    am.isBluetoothScoOn = am.isBluetoothScoAvailableOffCall && audioViaBluetooth.value
+  }
+}
+
+private fun dropAudioManagerOverrides() {
+  val am = androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  am.mode = AudioManager.MODE_NORMAL
+  // Clear selected communication device to default value after we changed it in call
+  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+    am.clearCommunicationDevice()
+  } else {
+    am.isSpeakerphoneOn = false
+    am.stopBluetoothSco()
+  }
+}
+
+@Composable
+private fun ActiveCallOverlayLayout(
+  call: Call,
+  speakerCanBeEnabled: Boolean,
+  dismiss: () -> Unit,
+  toggleAudio: () -> Unit,
+  toggleVideo: () -> Unit,
+  toggleSound: () -> Unit,
+  flipCamera: () -> Unit
+) {
+  Column(Modifier.padding(DEFAULT_PADDING)) {
+    when (call.peerMedia ?: call.localMedia) {
+      CallMediaType.Video -> {
+        CallInfoView(call, alignment = Alignment.Start)
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
+          ToggleAudioButton(call, toggleAudio)
+          Spacer(Modifier.size(40.dp))
+          IconButton(onClick = dismiss) {
+            Icon(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
+          }
+          if (call.videoEnabled) {
+            ControlButton(call, painterResource(MR.images.ic_flip_camera_android_filled), MR.strings.icon_descr_flip_camera, flipCamera)
+            ControlButton(call, painterResource(MR.images.ic_videocam_filled), MR.strings.icon_descr_video_off, toggleVideo)
+          } else {
+            Spacer(Modifier.size(48.dp))
+            ControlButton(call, painterResource(MR.images.ic_videocam_off), MR.strings.icon_descr_video_on, toggleVideo)
+          }
+        }
+      }
+      CallMediaType.Audio -> {
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Column(
+          Modifier.fillMaxWidth(),
+          horizontalAlignment = Alignment.CenterHorizontally,
+          verticalArrangement = Arrangement.Center
+        ) {
+          ProfileImage(size = 192.dp, image = call.contact.profile.image)
+          CallInfoView(call, alignment = Alignment.CenterHorizontally)
+        }
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Box(Modifier.fillMaxWidth().padding(bottom = DEFAULT_BOTTOM_PADDING), contentAlignment = Alignment.CenterStart) {
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
+            IconButton(onClick = dismiss) {
+              Icon(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
+            }
+          }
+          Box(Modifier.padding(start = 32.dp)) {
+            ToggleAudioButton(call, toggleAudio)
+          }
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
+            Box(Modifier.padding(end = 32.dp)) {
+              ToggleSoundButton(call, speakerCanBeEnabled, toggleSound)
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun ControlButton(call: Call, icon: Painter, iconText: StringResource, action: () -> Unit, enabled: Boolean = true) {
+  if (call.hasMedia) {
+    IconButton(onClick = action, enabled = enabled) {
+      Icon(icon, stringResource(iconText), tint = if (enabled) Color(0xFFFFFFD8) else MaterialTheme.colors.secondary, modifier = Modifier.size(40.dp))
+    }
+  } else {
+    Spacer(Modifier.size(40.dp))
+  }
+}
+
+@Composable
+private fun ToggleAudioButton(call: Call, toggleAudio: () -> Unit) {
+  if (call.audioEnabled) {
+    ControlButton(call, painterResource(MR.images.ic_mic), MR.strings.icon_descr_audio_off, toggleAudio)
+  } else {
+    ControlButton(call, painterResource(MR.images.ic_mic_off), MR.strings.icon_descr_audio_on, toggleAudio)
+  }
+}
+
+@Composable
+private fun ToggleSoundButton(call: Call, enabled: Boolean, toggleSound: () -> Unit) {
+  if (call.soundSpeaker) {
+    ControlButton(call, painterResource(MR.images.ic_volume_up), MR.strings.icon_descr_speaker_off, toggleSound, enabled)
+  } else {
+    ControlButton(call, painterResource(MR.images.ic_volume_down), MR.strings.icon_descr_speaker_on, toggleSound, enabled)
+  }
+}
+
+@Composable
+fun CallInfoView(call: Call, alignment: Alignment.Horizontal) {
+  @Composable fun InfoText(text: String, style: TextStyle = MaterialTheme.typography.body2) =
+    Text(text, color = Color(0xFFFFFFD8), style = style)
+  Column(horizontalAlignment = alignment) {
+    InfoText(call.contact.chatViewName, style = MaterialTheme.typography.h2)
+    InfoText(call.callState.text)
+
+    val connInfo = call.connectionInfo
+    //    val connInfoText = if (connInfo == null) ""  else " (${connInfo.text}, ${connInfo.protocolText})"
+    val connInfoText = if (connInfo == null) ""  else " (${connInfo.text})"
+    InfoText(call.encryptionStatus + connInfoText)
+  }
+}
+
+//@Composable
+//fun CallViewDebug(close: () -> Unit) {
+//  val callCommand = remember { mutableStateOf<WCallCommand?>(null)}
+//  val commandText = remember { mutableStateOf("{\"command\": {\"type\": \"start\", \"media\": \"video\", \"aesKey\": \"FwW+t6UbnwHoapYOfN4mUBUuqR7UtvYWxW16iBqM29U=\"}}") }
+//  val clipboard = ContextCompat.getSystemService(LocalContext.current, ClipboardManager::class.java)
+//
+//  BackHandler(onBack = close)
+//  Column(
+//    horizontalAlignment = Alignment.CenterHorizontally,
+//    verticalArrangement = Arrangement.spacedBy(12.dp),
+//    modifier = Modifier
+//      .themedBackground()
+//      .fillMaxSize()
+//  ) {
+//    WebRTCView(callCommand) { apiMsg ->
+//      // for debugging
+//      // commandText.value = apiMsg
+//      commandText.value = json.encodeToString(apiMsg)
+//    }
+//
+//    TextEditor(Modifier.height(180.dp), text = commandText)
+//
+//    Row(
+//      Modifier
+//        .fillMaxWidth()
+//        .padding(bottom = 6.dp),
+//      horizontalArrangement = Arrangement.SpaceBetween
+//    ) {
+//      Button(onClick = {
+//        val clip: ClipData = ClipData.newPlainText("js command", commandText.value)
+//        clipboard?.setPrimaryClip(clip)
+//      }) { Text("Copy") }
+//      Button(onClick = {
+//        try {
+//          val apiCall: WVAPICall = json.decodeFromString(commandText.value)
+//          commandText.value = ""
+//          println("sending: ${commandText.value}")
+//          callCommand.value = apiCall.command
+//        } catch(e: Error) {
+//          println("error parsing command: ${commandText.value}")
+//          println(e)
+//        }
+//      }) { Text("Send") }
+//      Button(onClick = {
+//        commandText.value = ""
+//      }) { Text("Clear") }
+//    }
+//  }
+//}
+
+@Composable
+fun WebRTCView(callCommand: MutableState<WCallCommand?>, onResponse: (WVAPIMessage) -> Unit) {
+  val scope = rememberCoroutineScope()
+  val webView = remember { mutableStateOf<WebView?>(null) }
+  val permissionsState = rememberMultiplePermissionsState(
+    permissions = listOf(
+      Manifest.permission.CAMERA,
+      Manifest.permission.RECORD_AUDIO,
+      Manifest.permission.MODIFY_AUDIO_SETTINGS,
+      Manifest.permission.INTERNET
+    )
+  )
+  fun processCommand(wv: WebView, cmd: WCallCommand) {
+    val apiCall = WVAPICall(command = cmd)
+    wv.evaluateJavascript("processCommand(${json.encodeToString(apiCall)})", null)
+  }
+  val lifecycleOwner = LocalLifecycleOwner.current
+  DisposableEffect(lifecycleOwner) {
+    val observer = LifecycleEventObserver { _, event ->
+      if (event == Lifecycle.Event.ON_RESUME || event == Lifecycle.Event.ON_START) {
+        permissionsState.launchMultiplePermissionRequest()
+      }
+    }
+    lifecycleOwner.lifecycle.addObserver(observer)
+    onDispose {
+      val wv = webView.value
+      if (wv != null) processCommand(wv, WCallCommand.End)
+      lifecycleOwner.lifecycle.removeObserver(observer)
+      webView.value?.destroy()
+      webView.value = null
+    }
+  }
+  LaunchedEffect(callCommand.value, webView.value) {
+    val cmd = callCommand.value
+    val wv = webView.value
+    if (cmd != null && wv != null) {
+      Log.d(TAG, "WebRTCView LaunchedEffect executing $cmd")
+      processCommand(wv, cmd)
+      callCommand.value = null
+    }
+  }
+  val assetLoader = WebViewAssetLoader.Builder()
+    .addPathHandler("/assets/www/", WebViewAssetLoader.AssetsPathHandler(LocalContext.current))
+    .build()
+
+  if (permissionsState.allPermissionsGranted) {
+    Box(Modifier.fillMaxSize()) {
+      AndroidView(
+        factory = { AndroidViewContext ->
+          WebView(AndroidViewContext).apply {
+            layoutParams = ViewGroup.LayoutParams(
+              ViewGroup.LayoutParams.MATCH_PARENT,
+              ViewGroup.LayoutParams.MATCH_PARENT,
+            )
+            this.webChromeClient = object: WebChromeClient() {
+              override fun onPermissionRequest(request: PermissionRequest) {
+                if (request.origin.toString().startsWith("file:/")) {
+                  request.grant(request.resources)
+                } else {
+                  Log.d(TAG, "Permission request from webview denied.")
+                  request.deny()
+                }
+              }
+            }
+            this.webViewClient = LocalContentWebViewClient(assetLoader)
+            this.clearHistory()
+            this.clearCache(true)
+            this.addJavascriptInterface(WebRTCInterface(onResponse), "WebRTCInterface")
+            val webViewSettings = this.settings
+            webViewSettings.allowFileAccess = true
+            webViewSettings.allowContentAccess = true
+            webViewSettings.javaScriptEnabled = true
+            webViewSettings.mediaPlaybackRequiresUserGesture = false
+            webViewSettings.cacheMode = WebSettings.LOAD_NO_CACHE
+            this.loadUrl("file:android_asset/www/call.html")
+          }
+        }
+      ) { wv ->
+        Log.d(TAG, "WebRTCView: webview ready")
+        // for debugging
+        // wv.evaluateJavascript("sendMessageToNative = ({resp}) => WebRTCInterface.postMessage(JSON.stringify({command: resp}))", null)
+        scope.launch {
+          delay(2000L)
+          wv.evaluateJavascript("sendMessageToNative = (msg) => WebRTCInterface.postMessage(JSON.stringify(msg))", null)
+          webView.value = wv
+        }
+      }
+    }
+  }
+}
+
+// for debugging
+// class WebRTCInterface(private val onResponse: (String) -> Unit) {
+class WebRTCInterface(private val onResponse: (WVAPIMessage) -> Unit) {
+  @JavascriptInterface
+  fun postMessage(message: String) {
+    Log.d(TAG, "WebRTCInterface.postMessage")
+    try {
+      // for debugging
+      // onResponse(message)
+      onResponse(json.decodeFromString(message))
+    } catch (e: Error) {
+      Log.e(TAG, "failed parsing WebView message: $message")
+    }
+  }
+}
+
+private class LocalContentWebViewClient(private val assetLoader: WebViewAssetLoader) : WebViewClientCompat() {
+  override fun shouldInterceptRequest(
+    view: WebView,
+    request: WebResourceRequest
+  ): WebResourceResponse? {
+    return assetLoader.shouldInterceptRequest(request.url)
+  }
+}
+
+@Preview
+@Composable
+fun PreviewActiveCallOverlayVideo() {
+  SimpleXTheme {
+    ActiveCallOverlayLayout(
+      call = Call(
+        contact = Contact.sampleData,
+        callState = CallState.Negotiated,
+        localMedia = CallMediaType.Video,
+        peerMedia = CallMediaType.Video,
+        connectionInfo = ConnectionInfo(
+          RTCIceCandidate(RTCIceCandidateType.Host, "tcp", null),
+          RTCIceCandidate(RTCIceCandidateType.Host, "tcp", null)
+        )
+      ),
+      speakerCanBeEnabled = true,
+      dismiss = {},
+      toggleAudio = {},
+      toggleVideo = {},
+      toggleSound = {},
+      flipCamera = {}
+    )
+  }
+}
+
+@Preview
+@Composable
+fun PreviewActiveCallOverlayAudio() {
+  SimpleXTheme {
+    ActiveCallOverlayLayout(
+      call = Call(
+        contact = Contact.sampleData,
+        callState = CallState.Negotiated,
+        localMedia = CallMediaType.Audio,
+        peerMedia = CallMediaType.Audio,
+        connectionInfo = ConnectionInfo(
+          RTCIceCandidate(RTCIceCandidateType.Host, "udp", null),
+          RTCIceCandidate(RTCIceCandidateType.Host, "udp", null)
+        )
+      ),
+      speakerCanBeEnabled = true,
+      dismiss = {},
+      toggleAudio = {},
+      toggleVideo = {},
+      toggleSound = {},
+      flipCamera = {}
+    )
+  }
+}
@@ -0,0 +1,81 @@
+package chat.simplex.common.views.chat
+
+import android.Manifest
+import android.content.ActivityNotFoundException
+import android.content.pm.PackageManager
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.compose.runtime.*
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.core.content.ContextCompat
+import chat.simplex.common.helpers.toURI
+import chat.simplex.common.platform.*
+import chat.simplex.common.views.helpers.*
+import chat.simplex.res.MR
+import java.net.URI
+
+@Composable
+actual fun AttachmentSelection(
+  composeState: MutableState<ComposeState>,
+  attachmentOption: MutableState<AttachmentOption?>,
+  processPickedFile: (URI?, String?) -> Unit,
+  processPickedMedia: (List<URI>, String?) -> Unit
+) {
+  val cameraLauncher = rememberCameraLauncher { uri: Uri? ->
+    if (uri != null) {
+      val bitmap: ImageBitmap? = getBitmapFromUri(uri.toURI())
+      if (bitmap != null) {
+        val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+        composeState.value = composeState.value.copy(preview = ComposePreview.MediaPreview(listOf(imagePreview), listOf(UploadContent.SimpleImage(uri.toURI()))))
+      }
+    }
+  }
+  val cameraPermissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
+    if (isGranted) {
+      cameraLauncher.launchWithFallback()
+    } else {
+      showToast(generalGetString(MR.strings.toast_permission_denied))
+    }
+  }
+  val galleryImageLauncher = rememberLauncherForActivityResult(contract = PickMultipleImagesFromGallery()) { processPickedMedia(it.map { it.toURI() }, null) }
+  val galleryImageLauncherFallback = rememberGetMultipleContentsLauncher { processPickedMedia(it.map { it.toURI() }, null) }
+  val galleryVideoLauncher = rememberLauncherForActivityResult(contract = PickMultipleVideosFromGallery()) { processPickedMedia(it.map { it.toURI() }, null) }
+  val galleryVideoLauncherFallback = rememberGetMultipleContentsLauncher { processPickedMedia(it.map { it.toURI() }, null) }
+  val filesLauncher = rememberGetContentLauncher { processPickedFile(it?.toURI(), null) }
+  LaunchedEffect(attachmentOption.value) {
+    when (attachmentOption.value) {
+      AttachmentOption.CameraPhoto -> {
+        when (PackageManager.PERMISSION_GRANTED) {
+          ContextCompat.checkSelfPermission(androidAppContext, Manifest.permission.CAMERA) -> {
+            cameraLauncher.launchWithFallback()
+          }
+          else -> {
+            cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
+          }
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.GalleryImage -> {
+        try {
+          galleryImageLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryImageLauncherFallback.launch("image/*")
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.GalleryVideo -> {
+        try {
+          galleryVideoLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryVideoLauncherFallback.launch("video/*")
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.File -> {
+        filesLauncher.launch("*/*")
+        attachmentOption.value = null
+      }
+      else -> {}
+    }
+  }
+}
@@ -0,0 +1,16 @@
+package chat.simplex.common.views.chat
+
+import android.Manifest
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import chat.simplex.common.views.chat.ScanCodeLayout
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+actual fun ScanCodeView(verifyCode: (String?, cb: (Boolean) -> Unit) -> Unit, close: () -> Unit) {
+  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+  LaunchedEffect(Unit) {
+    cameraPermissionState.launchPermissionRequest()
+  }
+  ScanCodeLayout(verifyCode, close)
+}
@@ -0,0 +1,17 @@
+package chat.simplex.common.views.chat
+
+import android.Manifest
+import androidx.compose.runtime.Composable
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+
+@Composable
+actual fun allowedToRecordVoiceByPlatform(): Boolean {
+  val permissionsState = rememberMultiplePermissionsState(listOf(Manifest.permission.RECORD_AUDIO))
+  return permissionsState.allPermissionsGranted
+}
+
+@Composable
+actual fun VoiceButtonWithoutPermissionByPlatform() {
+  val permissionsState = rememberMultiplePermissionsState(listOf(Manifest.permission.RECORD_AUDIO))
+  VoiceButtonWithoutPermission { permissionsState.launchMultiplePermissionRequest() }
+}
@@ -0,0 +1,53 @@
+package chat.simplex.common.views.chat.item
+
+import android.os.Build.VERSION.SDK_INT
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.platform.LocalContext
+import chat.simplex.common.helpers.toUri
+import chat.simplex.common.model.CIFile
+import chat.simplex.common.platform.*
+import chat.simplex.common.views.helpers.ModalManager
+import coil.ImageLoader
+import coil.compose.rememberAsyncImagePainter
+import coil.decode.GifDecoder
+import coil.decode.ImageDecoderDecoder
+import coil.request.ImageRequest
+import java.net.URI
+
+@Composable
+actual fun SimpleAndAnimatedImageView(
+  uri: URI,
+  imageBitmap: ImageBitmap,
+  file: CIFile?,
+  imageProvider: () -> ImageGalleryProvider,
+  ImageView: @Composable (painter: Painter, onClick: () -> Unit) -> Unit
+) {
+  val context = LocalContext.current
+  val imagePainter = rememberAsyncImagePainter(
+    ImageRequest.Builder(context).data(data = uri.toUri()).size(coil.size.Size.ORIGINAL).build(),
+    placeholder = BitmapPainter(imageBitmap), // show original image while it's still loading by coil
+    imageLoader = imageLoader
+  )
+  val view = LocalMultiplatformView()
+  ImageView(imagePainter) {
+    hideKeyboard(view)
+    if (getLoadedFilePath(file) != null) {
+      ModalManager.shared.showCustomModal(animated = false) { close ->
+        ImageFullScreenView(imageProvider, close)
+      }
+    }
+  }
+}
+
+private val imageLoader = ImageLoader.Builder(androidAppContext)
+  .components {
+    if (SDK_INT >= 28) {
+      add(ImageDecoderDecoder.Factory())
+    } else {
+      add(GifDecoder.Factory())
+    }
+  }
+  .build()
@@ -0,0 +1,46 @@
+package chat.simplex.common.views.chat.item
+
+import android.graphics.Rect
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import chat.simplex.common.platform.VideoPlayer
+import com.google.android.exoplayer2.ui.AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
+import com.google.android.exoplayer2.ui.StyledPlayerView
+
+@Composable
+actual fun PlayerView(player: VideoPlayer, width: Dp, onClick: () -> Unit, onLongClick: () -> Unit, stop: () -> Unit) {
+  AndroidView(
+    factory = { ctx ->
+      StyledPlayerView(ctx).apply {
+        useController = false
+        resizeMode = RESIZE_MODE_FIXED_WIDTH
+        this.player = player.player
+      }
+    },
+    Modifier
+      .width(width)
+      .combinedClickable(
+        onLongClick = onLongClick,
+        onClick = { if (player.player.playWhenReady) stop() else onClick() }
+      )
+  )
+}
+
+@Composable
+actual fun LocalWindowWidth(): Dp {
+  val view = LocalView.current
+  val density = LocalDensity.current.density
+  return remember {
+    val rect = Rect()
+    view.getWindowVisibleDisplayFrame(rect)
+    (rect.width() / density).dp
+  }
+}
@@ -0,0 +1,34 @@
+package chat.simplex.common.views.chat.item
+
+import android.Manifest
+import android.os.Build
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import chat.simplex.common.model.ChatItem
+import chat.simplex.common.model.MsgContent
+import chat.simplex.common.platform.FileChooserLauncher
+import chat.simplex.common.platform.saveImage
+import chat.simplex.common.views.helpers.withApi
+import chat.simplex.res.MR
+import com.google.accompanist.permissions.rememberPermissionState
+import dev.icerock.moko.resources.compose.painterResource
+import dev.icerock.moko.resources.compose.stringResource
+
+@Composable
+actual fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserLauncher, showMenu: MutableState<Boolean>) {
+  val writePermissionState = rememberPermissionState(permission = Manifest.permission.WRITE_EXTERNAL_STORAGE)
+  ItemAction(stringResource(MR.strings.save_verb), painterResource(MR.images.ic_download), onClick = {
+    when (cItem.content.msgContent) {
+      is MsgContent.MCImage -> {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || writePermissionState.hasPermission) {
+          saveImage(cItem.file)
+        } else {
+          writePermissionState.launchPermissionRequest()
+        }
+      }
+      is MsgContent.MCFile, is MsgContent.MCVoice, is MsgContent.MCVideo -> withApi { saveFileLauncher.launch(cItem.file?.fileName ?: "") }
+      else -> {}
+    }
+    showMenu.value = false
+  })
+}
@@ -0,0 +1,75 @@
+package chat.simplex.common.views.chat.item
+
+import android.os.Build
+import android.view.View
+import androidx.compose.foundation.Image
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.view.isVisible
+import chat.simplex.common.helpers.toUri
+import chat.simplex.common.platform.VideoPlayer
+import chat.simplex.res.MR
+import coil.ImageLoader
+import coil.compose.rememberAsyncImagePainter
+import coil.decode.GifDecoder
+import coil.decode.ImageDecoderDecoder
+import coil.request.ImageRequest
+import coil.size.Size
+import com.google.android.exoplayer2.ui.AspectRatioFrameLayout
+import com.google.android.exoplayer2.ui.StyledPlayerView
+import dev.icerock.moko.resources.compose.stringResource
+import java.net.URI
+
+@Composable
+actual fun FullScreenImageView(modifier: Modifier, uri: URI, imageBitmap: ImageBitmap) {
+  // I'm making a new instance of imageLoader here because if I use one instance in multiple places
+  // after end of composition here a GIF from the first instance will be paused automatically which isn't what I want
+  val imageLoader = ImageLoader.Builder(LocalContext.current)
+    .components {
+      if (Build.VERSION.SDK_INT >= 28) {
+        add(ImageDecoderDecoder.Factory())
+      } else {
+        add(GifDecoder.Factory())
+      }
+    }
+    .build()
+  Image(
+    rememberAsyncImagePainter(
+      ImageRequest.Builder(LocalContext.current).data(data = uri.toUri()).size(Size.ORIGINAL).build(),
+      placeholder = BitmapPainter(imageBitmap), // show original image while it's still loading by coil
+      imageLoader = imageLoader
+    ),
+    contentDescription = stringResource(MR.strings.image_descr),
+    contentScale = ContentScale.Fit,
+    modifier = modifier,
+  )
+}
+
+@Composable
+actual fun FullScreenVideoView(player: VideoPlayer, modifier: Modifier) {
+  AndroidView(
+    factory = { ctx ->
+      StyledPlayerView(ctx).apply {
+        resizeMode = if (ctx.resources.configuration.screenWidthDp > ctx.resources.configuration.screenHeightDp) {
+          AspectRatioFrameLayout.RESIZE_MODE_FIXED_HEIGHT
+        } else {
+          AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
+        }
+        setShowPreviousButton(false)
+        setShowNextButton(false)
+        setShowSubtitleButton(false)
+        setShowVrButton(false)
+        controllerAutoShow = false
+        findViewById<View>(com.google.android.exoplayer2.R.id.exo_controls_background).setBackgroundColor(Color.Black.copy(alpha = 0.3f).toArgb())
+        findViewById<View>(com.google.android.exoplayer2.R.id.exo_settings).isVisible = false
+        this.player = player.player
+      }
+    },
+    modifier
+  )
+}
@@ -0,0 +1,16 @@
+package chat.simplex.common.views.helpers
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.window.Dialog
+
+@Composable
+actual fun DefaultDialog(
+  onDismissRequest: () -> Unit,
+  content: @Composable () -> Unit
+) {
+  Dialog(
+    onDismissRequest = onDismissRequest
+  ) {
+    content()
+  }
+}
@@ -0,0 +1,46 @@
+package chat.simplex.common.views.helpers
+
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.DpOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.PopupProperties
+
+actual interface DefaultExposedDropdownMenuBoxScope {
+  @Composable
+  actual fun DefaultExposedDropdownMenu(
+    expanded: Boolean,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier,
+    content: @Composable ColumnScope.() -> Unit
+  ) {
+    DropdownMenu(expanded, onDismissRequest, modifier, content = content)
+  }
+
+  @Composable
+  fun DropdownMenu(
+    expanded: Boolean,
+    onDismissRequest: () -> Unit,
+    modifier: Modifier = Modifier,
+    offset: DpOffset = DpOffset(0.dp, 0.dp),
+    properties: PopupProperties = PopupProperties(focusable = true),
+    content: @Composable ColumnScope.() -> Unit
+  ) {
+    androidx.compose.material.DropdownMenu(expanded, onDismissRequest, modifier, offset, properties, content)
+  }
+}
+
+@Composable
+actual fun DefaultExposedDropdownMenuBox(
+  expanded: Boolean,
+  onExpandedChange: (Boolean) -> Unit,
+  modifier: Modifier,
+  content: @Composable DefaultExposedDropdownMenuBoxScope.() -> Unit
+) {
+  val scope = remember { object : DefaultExposedDropdownMenuBoxScope {} }
+  androidx.compose.material.ExposedDropdownMenuBox(expanded, onExpandedChange, modifier, content = {
+    scope.content()
+  })
+}
@@ -0,0 +1,265 @@
+package chat.simplex.common.views.helpers
+
+import android.Manifest
+import android.app.Activity
+import android.content.*
+import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+import android.content.pm.PackageManager
+import android.graphics.*
+import android.net.Uri
+import android.provider.MediaStore
+import android.util.Base64
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.CallSuper
+import androidx.compose.foundation.layout.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.platform.LocalContext
+import dev.icerock.moko.resources.compose.painterResource
+import dev.icerock.moko.resources.compose.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.core.content.FileProvider
+import chat.simplex.common.helpers.APPLICATION_ID
+import chat.simplex.common.helpers.toURI
+import chat.simplex.common.model.json
+import chat.simplex.common.platform.*
+import chat.simplex.common.views.newchat.ActionButton
+import chat.simplex.res.MR
+import kotlinx.serialization.builtins.*
+import java.io.File
+import java.net.URI
+
+val errorBitmapBytes = Base64.decode("iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAKVJREFUeF7t1kENACEUQ0FQhnVQ9lfGO+xggITQdvbMzArPey+8fa3tAfwAEdABZQspQStgBssEcgAIkSAJkiAJljtEgiRIgmUCSZAESZAESZAEyx0iQRIkwTKBJEiCv5fgvTd1wDmn7QAP4AeIgA4oW0gJWgEzWCZwbQ7gAA7ggLKFOIADOKBMIAeAEAmSIAmSYLlDJEiCJFgmkARJkARJ8N8S/ADTZUewBvnTOQAAAABJRU5ErkJggg==", Base64.NO_WRAP)
+val errorBitmap: Bitmap = BitmapFactory.decodeByteArray(errorBitmapBytes, 0, errorBitmapBytes.size)
+
+class CustomTakePicturePreview(var uri: Uri?, var tmpFile: File?): ActivityResultContract<Void?, Uri?>() {
+  @CallSuper
+  override fun createIntent(context: Context, input: Void?): Intent {
+    tmpFile = File.createTempFile("image", ".bmp", File(getAppFilesDirectory()))
+    // Since the class should return Uri, the file should be deleted somewhere else. And in order to be sure, delegate this to system
+    tmpFile?.deleteOnExit()
+    uri = FileProvider.getUriForFile(context, "$APPLICATION_ID.provider", tmpFile!!)
+    return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+      .putExtra(MediaStore.EXTRA_OUTPUT, uri)
+  }
+
+  override fun getSynchronousResult(
+    context: Context,
+    input: Void?
+  ): SynchronousResult<Uri?>? = null
+
+  override fun parseResult(resultCode: Int, intent: Intent?): Uri? {
+    return if (resultCode == Activity.RESULT_OK && uri != null) {
+      uri
+    } else {
+      Log.e(TAG, "Getting image from camera cancelled or failed.")
+      null
+    }
+  }
+
+  companion object {
+    fun saver(): Saver<CustomTakePicturePreview, *> = Saver(
+      save = { json.encodeToString(ListSerializer(String.serializer().nullable), listOf(it.uri?.toString(), it.tmpFile?.toString())) },
+      restore = {
+        val data = json.decodeFromString(ListSerializer(String.serializer().nullable), it)
+        val uri = if (data[0] != null) Uri.parse(data[0]) else null
+        val tmpFile = if (data[1] != null) File(data[1]) else null
+        CustomTakePicturePreview(uri, tmpFile)
+      }
+    )
+  }
+}
+//class GetGalleryContent: ActivityResultContracts.GetContent() {
+//  override fun createIntent(context: Context, input: String): Intent {
+//    super.createIntent(context, input)
+//    return Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
+//  }
+//}
+//@Composable
+//fun rememberGalleryLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
+//  rememberLauncherForActivityResult(contract = GetGalleryContent(), cb)
+@Composable
+fun rememberCameraLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<Void?, Uri?> {
+  val contract = rememberSaveable(stateSaver = CustomTakePicturePreview.saver()) {
+    mutableStateOf(CustomTakePicturePreview(null, null))
+  }
+  return rememberLauncherForActivityResult(contract = contract.value, cb)
+}
+
+@Composable
+fun rememberPermissionLauncher(cb: (Boolean) -> Unit): ManagedActivityResultLauncher<String, Boolean> =
+  rememberLauncherForActivityResult(contract = ActivityResultContracts.RequestPermission(), cb)
+
+@Composable
+fun rememberGetContentLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
+  rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent(), cb)
+
+@Composable
+fun rememberGetMultipleContentsLauncher(cb: (List<Uri>) -> Unit): ManagedActivityResultLauncher<String, List<Uri>> =
+  rememberLauncherForActivityResult(contract = GetMultipleContentsAndMimeTypes(), cb)
+
+class GetMultipleContentsAndMimeTypes: ActivityResultContracts.GetMultipleContents() {
+  override fun createIntent(context: Context, input: String): Intent {
+    val mimeTypes = input.split(";")
+    return super.createIntent(context, mimeTypes[0]).apply {
+      if (mimeTypes.isNotEmpty()) {
+        putExtra(Intent.EXTRA_MIME_TYPES, mimeTypes.toTypedArray())
+      }
+    }
+  }
+}
+
+fun ManagedActivityResultLauncher<Void?, Uri?>.launchWithFallback() {
+  try {
+    launch(null)
+  } catch (e: ActivityNotFoundException) {
+    // No Activity found to handle Intent android.media.action.IMAGE_CAPTURE
+    // Means, no system camera app (Android 11+ requirement)
+    // https://developer.android.com/about/versions/11/behavior-changes-11#media-capture
+    Log.e(TAG, "Camera launcher: " + e.stackTraceToString())
+
+    try {
+      // Try to open any camera just to capture an image, will not be returned like with previous intent
+      androidAppContext.startActivity(Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA).also { it.addFlags(FLAG_ACTIVITY_NEW_TASK) })
+    } catch (e: ActivityNotFoundException) {
+      // No camera apps available at all
+      Log.e(TAG, "Camera launcher2: " + e.stackTraceToString())
+    }
+  }
+}
+
+@Composable
+actual fun GetImageBottomSheet(
+  imageBitmap: MutableState<URI?>,
+  onImageChange: (ImageBitmap) -> Unit,
+  hideBottomSheet: () -> Unit
+) {
+  val context = LocalContext.current
+  val processPickedImage = { uri: Uri? ->
+    if (uri != null) {
+      val uri = uri.toURI()
+      val bitmap = getBitmapFromUri(uri)
+      if (bitmap != null) {
+        imageBitmap.value = uri
+        onImageChange(bitmap)
+      }
+    }
+  }
+  val galleryLauncher = rememberLauncherForActivityResult(contract = PickFromGallery(), processPickedImage)
+  val galleryLauncherFallback = rememberGetContentLauncher(processPickedImage)
+  val cameraLauncher = rememberCameraLauncher(processPickedImage)
+  val permissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
+    if (isGranted) {
+      cameraLauncher.launchWithFallback()
+      hideBottomSheet()
+    } else {
+      showToast(generalGetString(MR.strings.toast_permission_denied))
+    }
+  }
+
+  Box(
+    modifier = Modifier
+      .fillMaxWidth()
+      .wrapContentHeight()
+      .onFocusChanged { focusState ->
+        if (!focusState.hasFocus) hideBottomSheet()
+      }
+  ) {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(horizontal = 8.dp, vertical = 30.dp),
+      horizontalArrangement = Arrangement.SpaceEvenly
+    ) {
+      ActionButton(null, stringResource(MR.strings.use_camera_button), icon = painterResource(MR.images.ic_photo_camera)) {
+        when (PackageManager.PERMISSION_GRANTED) {
+          ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
+            cameraLauncher.launchWithFallback()
+            hideBottomSheet()
+          }
+          else -> {
+            permissionLauncher.launch(Manifest.permission.CAMERA)
+          }
+        }
+      }
+      ActionButton(null, stringResource(MR.strings.from_gallery_button), icon = painterResource(MR.images.ic_image)) {
+        try {
+          galleryLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryLauncherFallback.launch("image/*")
+        }
+        hideBottomSheet()
+      }
+    }
+  }
+}
+
+class PickFromGallery: ActivityResultContract<Int, Uri?>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Images.Media.INTERNAL_CONTENT_URI).apply {
+      type = "image/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): Uri? = intent?.data
+}
+
+class PickMultipleImagesFromGallery: ActivityResultContract<Int, List<Uri>>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Images.Media.INTERNAL_CONTENT_URI).apply {
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      type = "image/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): List<Uri> =
+    if (intent?.data != null)
+      listOf(intent.data!!)
+    else if (intent?.clipData != null)
+      with(intent.clipData!!) {
+        val uris = ArrayList<Uri>()
+        for (i in 0 until kotlin.math.min(itemCount, 10)) {
+          val uri = getItemAt(i).uri
+          if (uri != null) uris.add(uri)
+        }
+        if (itemCount > 10) {
+          AlertManager.shared.showAlertMsg(MR.strings.images_limit_title, MR.strings.images_limit_desc)
+        }
+        uris
+      }
+    else
+      emptyList()
+}
+
+
+class PickMultipleVideosFromGallery: ActivityResultContract<Int, List<Uri>>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Video.Media.INTERNAL_CONTENT_URI).apply {
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      type = "video/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): List<Uri> =
+    if (intent?.data != null)
+      listOf(intent.data!!)
+    else if (intent?.clipData != null)
+      with(intent.clipData!!) {
+        val uris = ArrayList<Uri>()
+        for (i in 0 until kotlin.math.min(itemCount, 10)) {
+          val uri = getItemAt(i).uri
+          if (uri != null) uris.add(uri)
+        }
+        if (itemCount > 10) {
+          AlertManager.shared.showAlertMsg(MR.strings.videos_limit_title, MR.strings.videos_limit_desc)
+        }
+        uris
+      }
+    else
+      emptyList()
+}
@@ -0,0 +1,81 @@
+package chat.simplex.common.views.helpers
+
+import android.os.Build.VERSION.SDK_INT
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricManager.Authenticators.*
+import androidx.biometric.BiometricPrompt
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.FragmentActivity
+import chat.simplex.common.platform.mainActivity
+import chat.simplex.common.views.usersettings.LAMode
+
+actual fun authenticate(
+  promptTitle: String,
+  promptSubtitle: String,
+  selfDestruct: Boolean,
+  usingLAMode: LAMode,
+  completed: (LAResult) -> Unit
+) {
+  val activity = mainActivity.get() ?: return completed(LAResult.Error(""))
+  when (usingLAMode) {
+    LAMode.SYSTEM -> when {
+      SDK_INT in 28..29 ->
+        // KeyguardManager.isDeviceSecure()? https://developer.android.com/training/sign-in/biometric-auth#declare-supported-authentication-types
+        authenticateWithBiometricManager(promptTitle, promptSubtitle, activity, completed, BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
+      SDK_INT > 29 ->
+        authenticateWithBiometricManager(promptTitle, promptSubtitle, activity, completed, BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
+      else -> completed(LAResult.Unavailable())
+    }
+    LAMode.PASSCODE -> {
+      authenticateWithPasscode(promptTitle, promptSubtitle, selfDestruct, completed)
+    }
+  }
+}
+
+private fun authenticateWithBiometricManager(
+  promptTitle: String,
+  promptSubtitle: String,
+  activity: FragmentActivity,
+  completed: (LAResult) -> Unit,
+  authenticators: Int
+) {
+  val biometricManager = BiometricManager.from(activity)
+  when (biometricManager.canAuthenticate(authenticators)) {
+    BiometricManager.BIOMETRIC_SUCCESS -> {
+      val executor = ContextCompat.getMainExecutor(activity)
+      val biometricPrompt = BiometricPrompt(
+        activity,
+        executor,
+        object: BiometricPrompt.AuthenticationCallback() {
+          override fun onAuthenticationError(
+            errorCode: Int,
+            errString: CharSequence
+          ) {
+            super.onAuthenticationError(errorCode, errString)
+            completed(LAResult.Error(errString))
+          }
+
+          override fun onAuthenticationSucceeded(
+            result: BiometricPrompt.AuthenticationResult
+          ) {
+            super.onAuthenticationSucceeded(result)
+            completed(LAResult.Success)
+          }
+
+          override fun onAuthenticationFailed() {
+            super.onAuthenticationFailed()
+            completed(LAResult.Failed())
+          }
+        }
+      )
+      val promptInfo = BiometricPrompt.PromptInfo.Builder()
+        .setTitle(promptTitle)
+        .setSubtitle(promptSubtitle)
+        .setAllowedAuthenticators(authenticators)
+        .setConfirmationRequired(false)
+        .build()
+      biometricPrompt.authenticate(promptInfo)
+    }
+    else -> completed(LAResult.Unavailable())
+  }
+}
@@ -0,0 +1,309 @@
+package chat.simplex.common.views.helpers
+
+import android.app.Application
+import android.content.res.Resources
+import android.graphics.*
+import android.graphics.Typeface
+import android.graphics.drawable.Drawable
+import android.media.MediaMetadataRetriever
+import android.os.*
+import android.provider.OpenableColumns
+import android.text.Spanned
+import android.text.SpannedString
+import android.text.style.*
+import android.util.Base64
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.*
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.*
+import androidx.compose.ui.text.style.BaselineShift
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.unit.*
+import androidx.core.content.FileProvider
+import androidx.core.text.HtmlCompat
+import chat.simplex.common.helpers.*
+import chat.simplex.common.model.*
+import chat.simplex.common.platform.*
+import chat.simplex.res.MR
+import dev.icerock.moko.resources.StringResource
+import java.io.*
+import java.net.URI
+
+fun Spanned.toHtmlWithoutParagraphs(): String {
+  return HtmlCompat.toHtml(this, HtmlCompat.TO_HTML_PARAGRAPH_LINES_CONSECUTIVE)
+    .substringAfter("<p dir=\"ltr\">").substringBeforeLast("</p>")
+}
+
+fun Resources.getText(id: StringResource, vararg args: Any): CharSequence {
+  val escapedArgs = args.map {
+    if (it is Spanned) it.toHtmlWithoutParagraphs() else it
+  }.toTypedArray()
+  val resource = SpannedString(getText(id))
+  val htmlResource = resource.toHtmlWithoutParagraphs()
+  val formattedHtml = String.format(htmlResource, *escapedArgs)
+  return HtmlCompat.fromHtml(formattedHtml, HtmlCompat.FROM_HTML_MODE_LEGACY)
+}
+
+actual fun escapedHtmlToAnnotatedString(text: String, density: Density): AnnotatedString {
+  return spannableStringToAnnotatedString(HtmlCompat.fromHtml(text, HtmlCompat.FROM_HTML_MODE_LEGACY), density)
+}
+
+private fun spannableStringToAnnotatedString(
+  text: CharSequence,
+  density: Density,
+): AnnotatedString {
+  return if (text is Spanned) {
+    with(density) {
+      buildAnnotatedString {
+        append((text.toString()))
+        text.getSpans(0, text.length, Any::class.java).forEach {
+          val start = text.getSpanStart(it)
+          val end = text.getSpanEnd(it)
+          when (it) {
+            is StyleSpan -> when (it.style) {
+              Typeface.NORMAL -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Normal,
+                  fontStyle = FontStyle.Normal,
+                ),
+                start,
+                end
+              )
+              Typeface.BOLD -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Bold,
+                  fontStyle = FontStyle.Normal
+                ),
+                start,
+                end
+              )
+              Typeface.ITALIC -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Normal,
+                  fontStyle = FontStyle.Italic
+                ),
+                start,
+                end
+              )
+              Typeface.BOLD_ITALIC -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Bold,
+                  fontStyle = FontStyle.Italic
+                ),
+                start,
+                end
+              )
+            }
+            is TypefaceSpan -> addStyle(
+              SpanStyle(
+                fontFamily = when (it.family) {
+                  FontFamily.SansSerif.name -> FontFamily.SansSerif
+                  FontFamily.Serif.name -> FontFamily.Serif
+                  FontFamily.Monospace.name -> FontFamily.Monospace
+                  FontFamily.Cursive.name -> FontFamily.Cursive
+                  else -> FontFamily.Default
+                }
+              ),
+              start,
+              end
+            )
+            is AbsoluteSizeSpan -> addStyle(
+              SpanStyle(fontSize = if (it.dip) it.size.dp.toSp() else it.size.toSp()),
+              start,
+              end
+            )
+            is RelativeSizeSpan -> addStyle(
+              SpanStyle(fontSize = it.sizeChange.em),
+              start,
+              end
+            )
+            is StrikethroughSpan -> addStyle(
+              SpanStyle(textDecoration = TextDecoration.LineThrough),
+              start,
+              end
+            )
+            is UnderlineSpan -> addStyle(
+              SpanStyle(textDecoration = TextDecoration.Underline),
+              start,
+              end
+            )
+            is SuperscriptSpan -> addStyle(
+              SpanStyle(baselineShift = BaselineShift.Superscript),
+              start,
+              end
+            )
+            is SubscriptSpan -> addStyle(
+              SpanStyle(baselineShift = BaselineShift.Subscript),
+              start,
+              end
+            )
+            is ForegroundColorSpan -> addStyle(
+              SpanStyle(color = Color(it.foregroundColor)),
+              start,
+              end
+            )
+            else -> addStyle(SpanStyle(color = Color.White), start, end)
+          }
+        }
+      }
+    }
+  } else {
+    AnnotatedString(text.toString())
+  }
+}
+
+actual fun getAppFileUri(fileName: String): URI =
+  FileProvider.getUriForFile(androidAppContext, "$APPLICATION_ID.provider", File(getAppFilePath(fileName))).toURI()
+
+// https://developer.android.com/training/data-storage/shared/documents-files#bitmap
+actual fun getLoadedImage(file: CIFile?): ImageBitmap? {
+  val filePath = getLoadedFilePath(file)
+  return if (filePath != null) {
+    try {
+      val uri = getAppFileUri(filePath.substringAfterLast(File.separator))
+      val parcelFileDescriptor = androidAppContext.contentResolver.openFileDescriptor(uri.toUri(), "r")
+      val fileDescriptor = parcelFileDescriptor?.fileDescriptor
+      val image = decodeSampledBitmapFromFileDescriptor(fileDescriptor, 1000, 1000)
+      parcelFileDescriptor?.close()
+      image.asImageBitmap()
+    } catch (e: Exception) {
+      null
+    }
+  } else {
+    null
+  }
+}
+
+// https://developer.android.com/topic/performance/graphics/load-bitmap#load-bitmap
+private fun decodeSampledBitmapFromFileDescriptor(fileDescriptor: FileDescriptor?, reqWidth: Int, reqHeight: Int): Bitmap {
+  // First decode with inJustDecodeBounds=true to check dimensions
+  return BitmapFactory.Options().run {
+    inJustDecodeBounds = true
+    BitmapFactory.decodeFileDescriptor(fileDescriptor, null, this)
+    // Calculate inSampleSize
+    inSampleSize = calculateInSampleSize(this, reqWidth, reqHeight)
+    // Decode bitmap with inSampleSize set
+    inJustDecodeBounds = false
+
+    BitmapFactory.decodeFileDescriptor(fileDescriptor, null, this)
+  }
+}
+
+private fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+  // Raw height and width of image
+  val (height: Int, width: Int) = options.run { outHeight to outWidth }
+  var inSampleSize = 1
+
+  if (height > reqHeight || width > reqWidth) {
+    val halfHeight: Int = height / 2
+    val halfWidth: Int = width / 2
+    // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+    // height and width larger than the requested height and width.
+    while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
+      inSampleSize *= 2
+    }
+  }
+
+  return inSampleSize
+}
+
+actual fun getFileName(uri: URI): String? {
+  return androidAppContext.contentResolver.query(uri.toUri(), null, null, null, null)?.use { cursor ->
+    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+    cursor.moveToFirst()
+    cursor.getString(nameIndex)
+  }
+}
+
+actual fun getAppFilePath(uri: URI): String? {
+  return androidAppContext.contentResolver.query(uri.toUri(), null, null, null, null)?.use { cursor ->
+    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+    cursor.moveToFirst()
+    getAppFilePath(cursor.getString(nameIndex))
+  }
+}
+
+actual fun getFileSize(uri: URI): Long? {
+  return androidAppContext.contentResolver.query(uri.toUri(), null, null, null, null)?.use { cursor ->
+    val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+    cursor.moveToFirst()
+    cursor.getLong(sizeIndex)
+  }
+}
+
+actual fun getBitmapFromUri(uri: URI, withAlertOnException: Boolean): ImageBitmap? {
+  return if (Build.VERSION.SDK_INT >= 28) {
+    val source = ImageDecoder.createSource(androidAppContext.contentResolver, uri.toUri())
+    try {
+      ImageDecoder.decodeBitmap(source)
+    } catch (e: android.graphics.ImageDecoder.DecodeException) {
+      Log.e(TAG, "Unable to decode the image: ${e.stackTraceToString()}")
+      if (withAlertOnException) {
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(MR.strings.image_decoding_exception_title),
+          text = generalGetString(MR.strings.image_decoding_exception_desc)
+        )
+      }
+      null
+    }
+  } else {
+    BitmapFactory.decodeFile(getAppFilePath(uri))
+  }?.asImageBitmap()
+}
+
+actual fun getDrawableFromUri(uri: URI, withAlertOnException: Boolean): Any? {
+  return if (Build.VERSION.SDK_INT >= 28) {
+    val source = ImageDecoder.createSource(androidAppContext.contentResolver, uri.toUri())
+    try {
+      ImageDecoder.decodeDrawable(source)
+    } catch (e: android.graphics.ImageDecoder.DecodeException) {
+      if (withAlertOnException) {
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(MR.strings.image_decoding_exception_title),
+          text = generalGetString(MR.strings.image_decoding_exception_desc)
+        )
+      }
+      Log.e(TAG, "Error while decoding drawable: ${e.stackTraceToString()}")
+      null
+    }
+  } else {
+    Drawable.createFromPath(getAppFilePath(uri))
+  }
+}
+
+actual suspend fun saveTempImageUncompressed(image: ImageBitmap, asPng: Boolean): File? {
+  return try {
+    val ext = if (asPng) "png" else "jpg"
+    return File(getTempFilesDirectory() + File.separator + generateNewFileName("IMG", ext)).apply {
+      outputStream().use { out ->
+        image.asAndroidBitmap().compress(if (asPng) Bitmap.CompressFormat.PNG else Bitmap.CompressFormat.JPEG, 85, out)
+        out.flush()
+      }
+      deleteOnExit()
+      ChatModel.filesToDelete.add(this)
+    }
+  } catch (e: Exception) {
+    Log.e(TAG, "Util.kt saveTempImageUncompressed error: ${e.message}")
+    null
+  }
+}
+
+actual fun getBitmapFromVideo(uri: URI, timestamp: Long?, random: Boolean): VideoPlayerInterface.PreviewAndDuration {
+  val mmr = MediaMetadataRetriever()
+  mmr.setDataSource(androidAppContext, uri.toUri())
+  val durationMs = mmr.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLong()
+  val image = when {
+    timestamp != null -> mmr.getFrameAtTime(timestamp * 1000, MediaMetadataRetriever.OPTION_CLOSEST)
+    random -> mmr.frameAtTime
+    else -> mmr.getFrameAtTime(0)
+  }
+  mmr.release()
+  return VideoPlayerInterface.PreviewAndDuration(image?.asImageBitmap(), durationMs, timestamp ?: 0)
+}
+
+actual fun ByteArray.toBase64StringForPassphrase(): String = Base64.encodeToString(this, Base64.DEFAULT)
+
+actual fun String.toByteArrayFromBase64ForPassphrase(): ByteArray = Base64.decode(this, Base64.DEFAULT)
@@ -0,0 +1,18 @@
+package chat.simplex.common.views.newchat
+
+import androidx.compose.ui.graphics.*
+
+actual fun ImageBitmap.replaceColor(from: Int, to: Int): ImageBitmap {
+  val pixels = IntArray(width * height)
+  val bitmap = this.asAndroidBitmap()
+  bitmap.getPixels(pixels, 0, width, 0, 0, width, height)
+  var i = 0
+  while (i < pixels.size) {
+    if (pixels[i] == from) {
+      pixels[i] = to
+    }
+    i++
+  }
+  bitmap.setPixels(pixels, 0, width, 0, 0, width, height)
+  return bitmap.asImageBitmap()
+}
@@ -0,0 +1,108 @@
+package chat.simplex.common.views.newchat
+
+import android.annotation.SuppressLint
+import android.util.Log
+import android.view.ViewGroup
+import androidx.camera.core.*
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clipToBounds
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import boofcv.abst.fiducial.QrCodeDetector
+import boofcv.alg.color.ColorFormat
+import boofcv.android.ConvertCameraImage
+import boofcv.factory.fiducial.FactoryFiducial
+import boofcv.struct.image.GrayU8
+import chat.simplex.common.platform.TAG
+import com.google.common.util.concurrent.ListenableFuture
+import java.util.concurrent.*
+
+// Adapted from learntodroid - https://gist.github.com/learntodroid/8f839be0b29d0378f843af70607bd7f5
+
+@Composable
+actual fun QRCodeScanner(onBarcode: (String) -> Unit) {
+  val context = LocalContext.current
+  val lifecycleOwner = LocalLifecycleOwner.current
+  var preview by remember { mutableStateOf<Preview?>(null) }
+  var lastAnalyzedTimeStamp = 0L
+  var contactLink = ""
+
+  val cameraProviderFuture by produceState<ListenableFuture<ProcessCameraProvider>?>(initialValue = null) {
+    value = ProcessCameraProvider.getInstance(context)
+  }
+
+  DisposableEffect(lifecycleOwner) {
+    onDispose {
+      cameraProviderFuture?.get()?.unbindAll()
+    }
+  }
+
+  AndroidView(
+    factory = { AndroidViewContext ->
+      PreviewView(AndroidViewContext).apply {
+        this.scaleType = PreviewView.ScaleType.FILL_CENTER
+        layoutParams = ViewGroup.LayoutParams(
+          ViewGroup.LayoutParams.MATCH_PARENT,
+          ViewGroup.LayoutParams.MATCH_PARENT,
+        )
+        implementationMode = PreviewView.ImplementationMode.COMPATIBLE
+      }
+    },
+    modifier = Modifier.clipToBounds()
+  ) { previewView ->
+    val cameraSelector: CameraSelector = CameraSelector.Builder()
+      .requireLensFacing(CameraSelector.LENS_FACING_BACK)
+      .build()
+    val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    cameraProviderFuture?.addListener({
+      preview = Preview.Builder().build().also {
+        it.setSurfaceProvider(previewView.surfaceProvider)
+      }
+      val detector: QrCodeDetector<GrayU8> = FactoryFiducial.qrcode(null, GrayU8::class.java)
+      fun getQR(imageProxy: ImageProxy) {
+        val currentTimeStamp = System.currentTimeMillis()
+        if (currentTimeStamp - lastAnalyzedTimeStamp >= TimeUnit.SECONDS.toMillis(1)) {
+          detector.process(imageProxyToGrayU8(imageProxy))
+          val found = detector.detections
+          val qr = found.firstOrNull()
+          if (qr != null) {
+            if (qr.message != contactLink) {
+              // Make sure link is new and not a repeat
+              contactLink = qr.message
+              onBarcode(contactLink)
+            }
+          }
+        }
+        imageProxy.close()
+      }
+      val imageAnalyzer = ImageAnalysis.Analyzer { proxy -> getQR(proxy) }
+      val imageAnalysis: ImageAnalysis = ImageAnalysis.Builder()
+        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+        .setImageQueueDepth(1)
+        .build()
+        .also { it.setAnalyzer(cameraExecutor, imageAnalyzer) }
+      try {
+        cameraProviderFuture?.get()?.unbindAll()
+        cameraProviderFuture?.get()?.bindToLifecycle(lifecycleOwner, cameraSelector, preview, imageAnalysis)
+      } catch (e: Exception) {
+        Log.d(TAG, "CameraPreview: ${e.localizedMessage}")
+      }
+    }, ContextCompat.getMainExecutor(context))
+  }
+}
+
+@SuppressLint("UnsafeOptInUsageError")
+private fun imageProxyToGrayU8(img: ImageProxy) : GrayU8? {
+  val image = img.image
+  if (image != null) {
+    val outImg = GrayU8()
+    ConvertCameraImage.imageToBoof(image, ColorFormat.GRAY, outImg, null)
+    return outImg
+  }
+  return null
+}
@@ -0,0 +1,19 @@
+package chat.simplex.common.views.newchat
+
+import android.Manifest
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import chat.simplex.common.model.ChatModel
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+actual fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
+  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+  LaunchedEffect(Unit) {
+    cameraPermissionState.launchPermissionRequest()
+  }
+  ConnectContactLayout(
+    chatModelIncognito = chatModel.incognito.value,
+    close
+  )
+}
@@ -0,0 +1,26 @@
+package chat.simplex.common.views.onboarding
+
+import android.Manifest
+import android.os.Build
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import chat.simplex.common.platform.ntfManager
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+actual fun SetNotificationsModeAdditions() {
+  if (Build.VERSION.SDK_INT >= 33) {
+    val notificationsPermissionState = rememberPermissionState(Manifest.permission.POST_NOTIFICATIONS)
+    LaunchedEffect(notificationsPermissionState.hasPermission) {
+      if (notificationsPermissionState.hasPermission) {
+        ntfManager.createNtfChannelsMaybeShowAlert()
+      } else {
+        notificationsPermissionState.launchPermissionRequest()
+      }
+    }
+  } else {
+    LaunchedEffect(Unit) {
+      ntfManager.createNtfChannelsMaybeShowAlert()
+    }
+  }
+}
@@ -0,0 +1,169 @@
+package chat.simplex.common.views.usersettings
+
+import SectionBottomSpacer
+import SectionDividerSpaced
+import SectionView
+import android.app.Activity
+import android.content.ComponentName
+import android.content.pm.PackageManager
+import android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
+import android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+import androidx.compose.desktop.ui.tooling.preview.Preview
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.material.MaterialTheme.colors
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import dev.icerock.moko.resources.compose.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.toBitmap
+import chat.simplex.common.R
+import chat.simplex.common.model.*
+import chat.simplex.common.ui.theme.*
+import chat.simplex.common.views.helpers.*
+import chat.simplex.common.model.ChatModel
+import chat.simplex.common.platform.*
+import chat.simplex.common.helpers.APPLICATION_ID
+import chat.simplex.common.helpers.saveAppLocale
+import chat.simplex.common.views.usersettings.AppearanceScope.ColorEditor
+import chat.simplex.res.MR
+import kotlinx.coroutines.delay
+
+enum class AppIcon(val resId: Int) {
+  DEFAULT(R.drawable.icon_round_common),
+  DARK_BLUE(R.drawable.icon_dark_blue_round_common),
+}
+
+@Composable
+actual fun AppearanceView(m: ChatModel, showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit)) {
+  val appIcon = remember { mutableStateOf(findEnabledIcon()) }
+
+  fun setAppIcon(newIcon: AppIcon) {
+    if (appIcon.value == newIcon) return
+    val newComponent = ComponentName(APPLICATION_ID, "chat.simplex.app.MainActivity_${newIcon.name.lowercase()}")
+    val oldComponent = ComponentName(APPLICATION_ID, "chat.simplex.app.MainActivity_${appIcon.value.name.lowercase()}")
+    androidAppContext.packageManager.setComponentEnabledSetting(
+      newComponent,
+      COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP
+    )
+
+    androidAppContext.packageManager.setComponentEnabledSetting(
+      oldComponent,
+      PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP
+    )
+
+    appIcon.value = newIcon
+  }
+
+  AppearanceScope.AppearanceLayout(
+    appIcon,
+    m.controller.appPrefs.appLanguage,
+    m.controller.appPrefs.systemDarkTheme,
+    changeIcon = ::setAppIcon,
+    showSettingsModal = showSettingsModal,
+    editColor = { name, initialColor ->
+      ModalManager.shared.showModalCloseable { close ->
+        ColorEditor(name, initialColor, close)
+      }
+    },
+  )
+}
+
+@Composable
+fun AppearanceScope.AppearanceLayout(
+  icon: MutableState<AppIcon>,
+  languagePref: SharedPreference<String?>,
+  systemDarkTheme: SharedPreference<String?>,
+  changeIcon: (AppIcon) -> Unit,
+  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
+  editColor: (ThemeColor, Color) -> Unit,
+) {
+  Column(
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
+  ) {
+    AppBarTitle(stringResource(MR.strings.appearance_settings))
+    SectionView(stringResource(MR.strings.settings_section_title_language), padding = PaddingValues()) {
+      val context = LocalContext.current
+      //      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      //        SectionItemWithValue(
+      //          generalGetString(MR.strings.settings_section_title_language).lowercase().replaceFirstChar { if (it.isLowerCase()) it.titlecase(Locale.US) else it.toString() },
+      //          remember { mutableStateOf("system") },
+      //          listOf(ValueTitleDesc("system", generalGetString(MR.strings.change_verb), "")),
+      //          onSelected = { openSystemLangPicker(context as? Activity ?: return@SectionItemWithValue) }
+      //        )
+      //      } else {
+      val state = rememberSaveable { mutableStateOf(languagePref.get() ?: "system") }
+      LangSelector(state) {
+        state.value = it
+        withApi {
+          delay(200)
+          val activity = context as? Activity
+          if (activity != null) {
+            if (it == "system") {
+              activity.saveAppLocale(languagePref)
+            } else {
+              activity.saveAppLocale(languagePref, it)
+            }
+          }
+        }
+      }
+      //      }
+    }
+    SectionDividerSpaced()
+
+    SectionView(stringResource(MR.strings.settings_section_title_icon), padding = PaddingValues(horizontal = DEFAULT_PADDING_HALF)) {
+      LazyRow {
+        items(AppIcon.values().size, { index -> AppIcon.values()[index] }) { index ->
+          val item = AppIcon.values()[index]
+          val mipmap = ContextCompat.getDrawable(LocalContext.current, item.resId)!!
+          Image(
+            bitmap = mipmap.toBitmap().asImageBitmap(),
+            contentDescription = "",
+            contentScale = ContentScale.Fit,
+            modifier = Modifier
+              .shadow(if (item == icon.value) 1.dp else 0.dp, ambientColor = colors.secondaryVariant)
+              .size(70.dp)
+              .clickable { changeIcon(item) }
+              .padding(10.dp)
+          )
+
+          if (index + 1 != AppIcon.values().size) {
+            Spacer(Modifier.padding(horizontal = 4.dp))
+          }
+        }
+      }
+    }
+
+    SectionDividerSpaced(maxTopPadding = true)
+    ThemesSection(systemDarkTheme, showSettingsModal, editColor)
+    SectionBottomSpacer()
+  }
+}
+
+private fun findEnabledIcon(): AppIcon = AppIcon.values().first { icon ->
+  androidAppContext.packageManager.getComponentEnabledSetting(
+    ComponentName(APPLICATION_ID, "chat.simplex.app.MainActivity_${icon.name.lowercase()}")
+  ).let { it == COMPONENT_ENABLED_STATE_DEFAULT || it == COMPONENT_ENABLED_STATE_ENABLED }
+}
+
+@Preview
+@Composable
+fun PreviewAppearanceSettings() {
+  SimpleXTheme {
+    AppearanceScope.AppearanceLayout(
+      icon = remember { mutableStateOf(AppIcon.DARK_BLUE) },
+      languagePref = SharedPreference({ null }, {}),
+      systemDarkTheme = SharedPreference({ null }, {}),
+      changeIcon = {},
+      showSettingsModal = { {} },
+      editColor = { _, _ -> },
+    )
+  }
+}
@@ -0,0 +1,32 @@
+package chat.simplex.common.views.usersettings
+
+import SectionView
+import android.view.WindowManager
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+import androidx.fragment.app.FragmentActivity
+import chat.simplex.common.model.ChatModel
+import chat.simplex.res.MR
+import dev.icerock.moko.resources.compose.painterResource
+import dev.icerock.moko.resources.compose.stringResource
+
+@Composable
+actual fun PrivacyDeviceSection(
+  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
+  setPerformLA: (Boolean) -> Unit,
+) {
+  SectionView(stringResource(MR.strings.settings_section_title_device)) {
+    ChatLockItem(showSettingsModal, setPerformLA)
+    val context = LocalContext.current
+    SettingsPreferenceItem(painterResource(MR.images.ic_visibility_off), stringResource(MR.strings.protect_app_screen), ChatModel.controller.appPrefs.privacyProtectScreen) { on ->
+      if (on) {
+        (context as? FragmentActivity)?.window?.setFlags(
+          WindowManager.LayoutParams.FLAG_SECURE,
+          WindowManager.LayoutParams.FLAG_SECURE
+        )
+      } else {
+        (context as? FragmentActivity)?.window?.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+      }
+    }
+  }
+}
@@ -0,0 +1,16 @@
+package chat.simplex.common.views.usersettings
+
+import android.Manifest
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import chat.simplex.common.model.ServerCfg
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+actual fun ScanProtocolServer(onNext: (ServerCfg) -> Unit) {
+  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+  LaunchedEffect(Unit) {
+    cameraPermissionState.launchPermissionRequest()
+  }
+  ScanProtocolServerLayout(onNext)
+}
@@ -0,0 +1,49 @@
+package chat.simplex.common.views.usersettings
+
+import SectionView
+import androidx.compose.runtime.Composable
+import androidx.work.WorkManager
+import chat.simplex.common.model.ChatModel
+import chat.simplex.common.platform.*
+import chat.simplex.common.views.helpers.AlertManager
+import chat.simplex.common.views.helpers.generalGetString
+import chat.simplex.res.MR
+import com.jakewharton.processphoenix.ProcessPhoenix
+import dev.icerock.moko.resources.compose.painterResource
+import dev.icerock.moko.resources.compose.stringResource
+
+@Composable
+actual fun SettingsSectionApp(
+  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
+  showCustomModal: (@Composable (ChatModel, () -> Unit) -> Unit) -> (() -> Unit),
+  showVersion: () -> Unit,
+  withAuth: (title: String, desc: String, block: () -> Unit) -> Unit
+) {
+  SectionView(stringResource(MR.strings.settings_section_title_app)) {
+    SettingsActionItem(painterResource(MR.images.ic_restart_alt), stringResource(MR.strings.settings_restart_app), ::restartApp, extraPadding = true)
+    SettingsActionItem(painterResource(MR.images.ic_power_settings_new), stringResource(MR.strings.settings_shutdown), { shutdownAppAlert(::shutdownApp) }, extraPadding = true)
+    SettingsActionItem(painterResource(MR.images.ic_code), stringResource(MR.strings.settings_developer_tools), showSettingsModal { DeveloperView(it, showCustomModal, withAuth) }, extraPadding = true)
+    AppVersionItem(showVersion)
+  }
+}
+
+
+private fun restartApp() {
+  ProcessPhoenix.triggerRebirth(androidAppContext)
+  shutdownApp()
+}
+
+private fun shutdownApp() {
+  WorkManager.getInstance(androidAppContext).cancelAllWork()
+  platform.androidServiceSafeStop()
+  Runtime.getRuntime().exit(0)
+}
+
+private fun shutdownAppAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(MR.strings.shutdown_alert_question),
+    text = generalGetString(MR.strings.shutdown_alert_desc),
+    destructive = true,
+    onConfirm = onConfirm
+  )
+}
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle" >
+  <solid android:color="@color/highOrLowLight" />
+  <size android:width="1dp" />
+</shape>