4.6.1-beta.1: Android 110, iOS 137, update library

* docs: FR update

* fix android.md

* fix rev dates

fix revision dates ; ANDROID.md & TRANSLATION.md rev dates added

* fix links

* update

---------

Co-authored-by: Evgeny Poberezkin <2769109+epoberezkin@users.noreply.github.com>

.github/workflows/build.yml

@@ -5,7 +5,7 @@ on:
     branches:
       - master
       - stable
-      - sqlcipher
+      - users
     tags:
       - "v*"
   pull_request:
@@ -91,6 +91,10 @@ jobs:
           echo "    extra-lib-dirs: /usr/local/opt/openssl@1.1/lib"         >> cabal.project.local
           echo "    flags: +openssl"                                        >> cabal.project.local
 
+      - name: Install pkg-config for Mac
+        if: matrix.os == 'macos-latest'
+        run: brew install pkg-config
+
       - name: Unix prepare cabal.project.local for Ubuntu
         if: matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-18.04'
         shell: bash
@@ -109,7 +113,7 @@ jobs:
 
       - name: Unix test
         if: matrix.os != 'windows-latest' && matrix.os != 'ubuntu-20.04'
-        timeout-minutes: 10
+        timeout-minutes: 20
         shell: bash
         run: cabal test --test-show-details=direct
 

.gitignore

@@ -42,12 +42,15 @@ stack.yaml.lock
 
 # Temporary test files
 tests/tmp
+tests/tmp*
 logs/
 
-
+*.devcontainer
 # for website
 website/node_modules/
 website/src/blog/
+website/translations.json
+website/src/_data/supported_languages.json
 website/src/img/images/
 website/src/images/
 # Generated files
@@ -72,3 +75,4 @@ website/package-lock.json
 # Ignore test files
 website/.cache
 website/test/stubs-layout-cache/_includes/*.js
+apps/android/app/release

Dockerfile

@@ -1,10 +1,32 @@
-FROM haskell:8.10.4 AS build-stage
-# if you encounter "version `GLIBC_2.28' not found" error when running
-# chat client executable, build with the following base image instead:
-# FROM haskell:8.10.4-stretch AS build-stage
+FROM ubuntu:focal AS build
+
+# Install curl and simplex-chat-related dependencies
+RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev libssl-dev
+
+# Install ghcup
+RUN a=$(arch); curl https://downloads.haskell.org/~ghcup/$a-linux-ghcup -o /usr/bin/ghcup && \
+    chmod +x /usr/bin/ghcup
+
+# Install ghc
+RUN ghcup install ghc 8.10.7
+# Install cabal
+RUN ghcup install cabal
+# Set both as default
+RUN ghcup set ghc 8.10.7 && \
+    ghcup set cabal
+
 COPY . /project
 WORKDIR /project
-RUN stack install
+
+# Adjust PATH
+ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
+
+# Adjust build
+RUN cp ./scripts/cabal.project.local.linux ./cabal.project.local
+
+# Compile simplex-chat
+RUN cabal update
+RUN cabal install
 
 FROM scratch AS export-stage
-COPY --from=build-stage /root/.local/bin/simplex-chat /
+COPY --from=build /root/.cabal/bin/simplex-chat /

PRIVACY.md

@@ -1,22 +1,26 @@
 # SimpleX Chat Terms & Privacy Policy
 
-SimpleX Chat is the first chat platform that is 100% private by design - not only it has no access to your messages (thanks to open-source double-ratchet end-to-end encryption protocol and additional encryption layers), it also has no access to your profile and contacts - we do not have access to your connections graph.
+SimpleX Chat is the first communication platform that has no user profile IDs of any kind, not even random numbers. Not only it has no access to your messages (thanks to open-source double-ratchet end-to-end encryption protocol and additional encryption layers), it also has no access to your profile and contacts - we cannot observe your connections graph.
+
+If you believe that some of the clauses in this document are not aligned with our mission or principles, please raise it with us via [email](chat@simplex.chat) or [chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion).
 
 ## Privacy Policy
 
 SimpleX Chat Ltd. ("SimpleX Chat") uses the best industry practices for security and end-to-end encryption to provide secure end-to-end encrypted messaging via private connections. SimpleX Chat is built on top of SimpleX messaging and application platform that uses a new message routing protocol that allows establishing private connection without having any kind of addresses that identify its users - we don't use emails, phone numbers, usernames, identity keys or any other user identifiers to pass messages between the users.
 
+SimpleX Chat security audit was performed in October 2022 by [Trail of Bits](https://www.trailofbits.com/about), and most fixes were released in v4.2.0 – see [the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
+
 ### Information you provide
 
 We do not store user profiles. The profile you create in the app is local to your device. When you create a user profile, no records are created on our servers, and we have no access to any part of your profile information, and even to the fact that you created a profile - it is a local record stored only on your device. That means that if you delete the app, and have no backup, you will permanently lose all the data and the private connections you create with other users.
 
-Messages. SimpleX Chat cannot decrypt or otherwise access the content or size of your messages (each message is padded to a fixed size of 16kb). SimpleX Chat temporarily stores end-to-end encrypted messages on its servers for delivery to the devices that are temporarily offline. Your message history is stored only on your own devices.
+Messages. SimpleX Chat cannot decrypt or otherwise access the content or even size of your messages (each message is padded to a fixed size of 16kb). SimpleX Chat temporarily stores end-to-end encrypted messages on its servers for delivery to the devices that are offline, these messages are permanently removed as soon as they are delivered. Your message history is stored only on your own devices.
 
-Connections with other users. When you create a connection with another user, two messaging queues are created on our servers (we use separate queues for direct and response messages, that can be on two different servers), or on the servers that you configured in the app, in case it allows such configuration. At the time of updating this document only our terminal app allows configuring the servers, our mobile apps will allow such configuration in the near future. Our servers do not store information about which queues are linked to your profile on the device, and they do not have any information in common that allow us to establish that these queues are related to your device or your profile - the access to each queue is authorized by a set of unique encryption keys, different for each queue, and separate for sender and recipient of the messages that are transmitted through the queue.
+Connections with other users. When you create a connection with another user, two messaging queues (you can think about them as about mailboxes) are created on our servers, or on the servers that you configured in the app, in case it allows such configuration (SimpleX uses separate queues for direct and response messages, that the client applications prefer to create on two different servers, in case you have more than one server configured in the app, which is the default). At the time of updating this document all our client applications allow configuring the servers. Our servers do not store information about which queues are linked to your profile on the device, and they do not collect any information that would allow us to establish that these queues are related to your device or your profile - the access to each queue is authorized by a set of anonymous unique cryptographic keys, different for each queue, and separate for sender and recipient of the messages. The exception to that is when you choose to use instant push notifications in our iOS app, because the design of push notifications requires storing the device token on notification server, and the server can observe how many messaging queues your device uses, and approximate how many messages are sent to each queue. It does not allow though to determine the actual addresses of these queues, as a separate address is used to subscibe to the notifications (unless notification and messaging servers exchange information), and who, or even how many contacts, send messages to you, as notifications are delivered to your device end-to-end encrypted by the messaging servers. It also does not allow to see message content or sizes, as the actual messages are not sent via the notification service, only the fact that the message is available and where it can be received from (the latter information is encrypted, so that the notification server cannot see it). You can read more about the design of iOS push notifications [here](https://simplex.chat/blog/20220404-simplex-chat-instant-notifications.html#our-ios-approach-has-one-trade-off).
 
 Additional technical information can be stored on our servers, including randomly generated authentication tokens, keys, push tokens, and other material that is necessary to transmit messages. SimpleX Chat limits this additional technical information to the minimum required to operate the Services.
 
-User Support. If you contact SimpleX Chat any personal data you may share with us is kept only for the purposes of researching the issue and contacting you about your case. We recommend contacting support via chat, when it is possible.
+User Support. If you contact SimpleX Chat any personal data you may share with us is kept only for the purposes of researching the issue and contacting you about your case. We recommend contacting support [via chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion), when it is possible.
 
 ### Information we may share
 
@@ -31,6 +35,8 @@ The cases when SimpleX Chat may need to share the data we temporarily store on t
 - To detect, prevent, or otherwise address fraud, security, or technical issues.
 - To protect against harm to the rights, property, or safety of SimpleX Chat, our users, or the public as required or permitted by law.
 
+At the time of updating this document, we have never provided or have been requested the access to our servers or any information from our servers by any third parties. If we are ever requested to provide such access or information, we will follow the due legal process.
+
 ### Updates
 
 We will update this privacy policy as needed so that it is current, accurate, and as clear as possible. Your continued use of our Services confirms your acceptance of our updated Privacy Policy.
@@ -47,7 +53,7 @@ You accept to our Terms of Service ("Terms") by installing or using any of our a
 
 **Accessing the servers**. For the efficiency of the network access, the apps access all queues you create on any server via the same network (TCP/IP) connection. Our servers do not collect information about which queues were accessed via the same connection, so we do cannot establish which queues belong to the same users. Whoever might observe your network traffic would know which servers you use, and how much data you send, but not to whom it is sent - the data that leaves the servers is always different from the data they receive - there are no identifiers or cyphertext in common. Please refer to our [technical design document](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information about our privacy model and known security and privacy risks.
 
-**Privacy of user data**. We do not retain any data we transmit for any longer than necessary to provide the Services. We only collect aggregate statistics across all users, not per users - we do not have information about how many people use SimpleX Chat (we only know an approximate number of app installations and the aggregate traffic through our servers). In any case, we do not and will not sell or in any way monetize user data.
+**Privacy of user data**. We do not retain any data we transmit for any longer than necessary to provide the Services. We only collect aggregate statistics across all users, not per user - we do not have information about how many people use SimpleX Chat (we only know an approximate number of app installations and the aggregate traffic through our servers). In any case, we do not and will not sell or in any way monetize user data.
 
 **Operating our services**. For the purpose of operating our Services, you agree that your end-to-end encrypted messages are transferred via our servers in the United Kingdom, the United States and other countries where we have or use facilities and service providers or partners.
 
@@ -87,4 +93,4 @@ You accept to our Terms of Service ("Terms") by installing or using any of our a
 
 **Ending these Terms**. You may end these Terms with SimpleX Chat at any time by deleting SimpleX Chat app(s) from your device and discontinuing use of our Services. The provisions related to Licenses, Disclaimers, Limitation of Liability, Resolving dispute, Availability, Changes to the terms, Enforcing the terms, and Ending these Terms will survive termination of your relationship with SimpleX Chat.
 
-Updated March 1, 2022
+Updated November 8, 2022

README.md

@@ -1,12 +1,28 @@
+[![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
+[![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
+[![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
+[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
+[![Follow on Mastodon](https://img.shields.io/mastodon/follow/108619463746856738?domain=https%3A%2F%2Fmastodon.social&style=social)](https://mastodon.social/@simplex)
+
+| 30/03/2023 | EN, [FR](/docs/lang/fr/README.md), [CZ](/docs/lang/cs/README.md) |
+
 <img src="images/simplex-chat-logo.svg" alt="SimpleX logo" width="100%">
 
 # SimpleX - the first messaging platform that has no user identifiers of any kind - 100% private by design!
 
-[![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
-[![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
-[![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
-[![Follow on Twitter](https://img.shields.io/twitter/follow/SimpleXChat?style=social)](https://twitter.com/SimpleXChat)
-[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
+[<img src="./images/trail-of-bits.jpg" height="100">](http://simplex.chat/blog/20221108-simplex-chat-v4.2-security-audit-new-website.html) &nbsp;&nbsp;&nbsp; [<img src="./images/privacy-guides.jpg" height="80">](https://www.privacyguides.org/en/real-time-communication/#simplex-chat) &nbsp;&nbsp;&nbsp; [<img src="./images/kuketz-blog.jpg" height="80">](https://www.kuketz-blog.de/simplex-eindruecke-vom-messenger-ohne-identifier/)
+
+## Welcome to SimpleX Chat!
+
+1. 📲 [Install the app](#install-the-app).
+2. ↔️ [Connect to the team](#connect-to-the-team-via-the-app) and [join user groups](#join-user-groups).
+3. 🤝 [Make a private connection](#make-a-private-connection) with a friend.
+4. 🔤 [Help translating SimpleX Chat](#help-translating-simplex-chat).
+5. ⚡️ [Contribute](#contribute) and [help us with donations](#help-us-with-donations).
+
+[Learn more about SimpleX Chat](#contents).
+
+## Install the app
 
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apple_store.svg" alt="iOS app" height="42">](https://apps.apple.com/us/app/simplex-chat/id1605771084)
 &nbsp;
@@ -16,15 +32,98 @@
 &nbsp;
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/testflight.png" alt="iOS TestFlight" height="41">](https://testflight.apple.com/join/DWuT2LQu)
 &nbsp;
-[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)
 
 - 🖲 Protects your messages and metadata - who you talk to and when.
 - 🔐 Double ratchet end-to-end encryption, with additional encryption layer.
-- 📱 Mobile apps for Android ([Google Play](https://play.google.com/store/apps/details?id=chat.simplex.app), [APK](https://github.com/simplex-chat/website/raw/master/simplex.apk)) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084).
+- 📱 Mobile apps for Android ([Google Play](https://play.google.com/store/apps/details?id=chat.simplex.app), [APK](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084).
 - 🚀 [TestFlight preview for iOS](https://testflight.apple.com/join/DWuT2LQu) with the new features 1-2 weeks earlier - **limited to 10,000 users**!
-- 🖥 Available as a terminal (console) app / CLI on Linux, MacOS, Windows.
+- 🖥 Available as a terminal (console) [app / CLI](#zap-quick-installation-of-a-terminal-app) on Linux, MacOS, Windows.
 
-**NEW**: v4.0 is released - now local chat database is encrypted with passphrase! See [the release announcement](./blog/20220928-simplex-chat-v4-encrypted-database.md).
+## Connect to the team via the app
+
+- to ask any questions
+- to suggest any improvements
+- to share anything relevant
+
+## Join user groups
+
+You can join an English-speaking users group if you want to ask any questions: [#SimpleX-Group-2](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fhpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg%3D%40smp5.simplex.im%2FQP8zaGjjmlXV-ix_Er4JgJ0lNPYGS1KX%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEApAgBkRZ3x12ayZ7sHrjHQWNMvqzZpWUgM_fFCUdLXwo%253D%26srv%3Djjbyvoemxysm7qxap7m5d5m35jzv5qq6gnlv7s4rsn7tdwwmuqciwpid.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22xWpPXEZZsQp_F7vwAcAYDw%3D%3D%22%7D)
+
+There are groups in other languages, that we have the apps interface translated into. These groups are for testing, and asking questions to other SimpleX Chat users:
+
+[\#SimpleX-DE](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FkIEl7OQzcp-J6aDmjdlQbRJwqkcZE7XR%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAR16PCu02MobRmKAsjzhDWMZcWP9hS8l5AUZi-Gs8z18%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22puYPMCQt11yPUvgmI5jCiw%3D%3D%22%7D) (German-speaking), [\#SimpleX-FR](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fhpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg%3D%40smp5.simplex.im%2FvIHQDxTor53nwnWWTy5cHNwQQAdWN5Hw%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAPdgK1eBnETmgiqEQufbUkydKBJafoRx4iRrtrC2NAGc%253D%26srv%3Djjbyvoemxysm7qxap7m5d5m35jzv5qq6gnlv7s4rsn7tdwwmuqciwpid.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%221FyUryBPza-1ZFFE80Ekbg%3D%3D%22%7D) (French-speaking), [\#SimpleX-RU](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FXZyt3hJmWsycpN7Dqve_wbrAqb6myk1R%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAMFVIoytozTEa_QXOgoZFq_oe0IwZBYKvW50trSFXzXo%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22xz05ngjA3pNIxLZ32a8Vxg%3D%3D%22%7D) (Russian-speaking), [\#SimpleX-IT](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F0weR-ZgDUl7ruOtI_8TZwEsnJP6UiImA%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAq4PSThO9Fvb5ydF48wB0yNbpzCbuQJCW3vZ9BGUfcxk%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22e-iceLA0SctC62eARgYDWg%3D%3D%22%7D) (Italian-speaking).
+
+You can join either by opening these links in the app or by opening them in a desktop browser and scanning the QR code.
+
+## Make a private connection
+
+You need to share a link with your friend or scan a QR code from their phone, in person or during a video call, to make a connection and start messaging.
+
+The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
+
+<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app1.png" alt="Make a private connection" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app2.png" alt="Conversation" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app3.png" alt="Video call" height="360">
+
+After you connect, you can [verify connection security code](./blog/20230103-simplex-chat-v4.4-disappearing-messages.md#connection-security-verification).
+
+## User guide (NEW)
+
+Read about the app features and settings in the new [User guide](./docs/guide/README.md).
+
+## Help translating SimpleX Chat
+
+Thanks to our users and [Weblate](https://hosted.weblate.org/engage/simplex-chat/), SimpleX Chat apps, website and documents are translated to many other languages.
+
+Join our translators to help SimpleX grow!
+
+|locale|language |contributor|[Android](https://play.google.com/store/apps/details?id=chat.simplex.app) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084)|[website](https://simplex.chat)|Github docs|
+|:----:|:-------:|:---------:|:---------:|:---------:|:---------:|
+|🇬🇧 en|English   | |✓|✓|✓|✓|
+|ar|العربية   |[jermanuts](https://github.com/jermanuts)||[![website](https://hosted.weblate.org/widgets/simplex-chat/ar/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/ar/)||
+|🇨🇿 cs|Čeština   |[zen0bit](https://github.com/zen0bit)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/cs/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/cs/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/cs/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/cs/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/cs/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/cs/)|[✓](https://github.com/simplex-chat/simplex-chat/tree/master/docs/lang/cs)|
+|🇩🇪 de|Deutsch   |[mlanp](https://github.com/mlanp)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/de/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/de/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/de/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/de/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/de/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/de/)||
+|🇪🇸 es|Español   |[Mateyhv](https://github.com/Mateyhv)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/es/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/es/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/es/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/es/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/es/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/es/)||
+|🇫🇷 fr|Français  |[ishi_sama](https://github.com/ishi-sama)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/fr/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/fr/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/fr/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/fr/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/fr/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/fr/)|[✓](https://github.com/simplex-chat/simplex-chat/tree/master/docs/lang/fr)|
+|🇮🇹 it|Italiano  |[unbranched](https://github.com/unbranched)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/it/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/it/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/it/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/it/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/it/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/it/)||
+|🇳🇱 nl|Nederlands|[mika-nl](https://github.com/mika-nl)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/nl/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/nl/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/nl/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/nl/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/nl/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/nl/)||
+|🇷🇺 ru|Русский   ||[![android app](https://hosted.weblate.org/widgets/simplex-chat/ru/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/ru/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/ru/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/ru/)|||
+|🇨🇳 zh-CHS|简体中文|[sith-on-mars](https://github.com/sith-on-mars)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/zh_Hans/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/zh_Hans/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/zh_Hans/)||
+
+Languages in progress: Arabic, Hindi, Japanese, Spanish and [many others](https://hosted.weblate.org/projects/simplex-chat/#languages). We will be adding more languages as some of the already added are completed – please suggest new languages, review the [translation guide](./docs/TRANSLATIONS.md) and get in touch with us!
+
+## Contribute
+
+We would love to have you join the development! You can help us with:
+
+- writing a tutorial or recipes about hosting servers, chat bot automations, etc.
+- contributing to SimpleX Chat knowledge-base.
+- developing features - please connect to us via chat so we can help you get started.
+
+## Help us with donations
+
+Huge thank you to everybody who donated to SimpleX Chat!
+
+We are prioritizing users privacy and security - it would be impossible without your support.
+
+Our pledge to our users is that SimpleX protocols are and will remain open, and in public domain, - so anybody can build the future implementations of the clients and the servers. We are building SimpleX platform based on the same principles as email and web, but much more private and secure.
+
+Your donations help us raise more funds – any amount, even the price of the cup of coffee, would make a big difference for us.
+
+It is possible to donate via:
+
+- [GitHub](https://github.com/sponsors/simplex-chat) - it is commission-free for us.
+- [OpenCollective](https://opencollective.com/simplex-chat) - it charges a commission, and also accepts donations in crypto-currencies.
+- Monero address: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+- Bitcoin address: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+- BCH address: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+- Ethereum address: 0x83fd788f7241a2be61780ea9dc72d2151e6843e2
+- Solana address: 43tWFWDczgAcn4Rzwkpqg2mqwnQETSiTwznmCgA2tf1L
+
+Thank you,
+
+Evgeny
+
+SimpleX Chat founder
 
 ## Contents
 
@@ -36,14 +135,12 @@
   - [Users own SimpleX network](#users-own-simplex-network)
 - [Frequently asked questions](#frequently-asked-questions)
 - [News and updates](#news-and-updates)
-- [Make a private connection](#make-a-private-connection)
 - [Quick installation of a terminal app](#zap-quick-installation-of-a-terminal-app)
 - [SimpleX Platform design](#simplex-platform-design)
 - [Privacy: technical details and limitations](#privacy-technical-details-and-limitations)
 - [For developers](#for-developers)
 - [Roadmap](#roadmap)
-- [Help us pay for 3rd party security audit](#help-us-pay-for-3rd-party-security-audit)
-- [Disclaimer, License](#disclaimer)
+- [Disclaimers, Security contact, License](#disclaimers)
 
 ## Why privacy matters
 
@@ -73,34 +170,32 @@ You can use SimpleX with your own servers and still communicate with people usin
 
 ## Frequently asked questions
 
-1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release annoucement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
+1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release announcement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
 
-2. _Why should I not just use Signal?_ Signal is a centralised platform that uses phone numbers to identify its users and their contacts. It means that while the content of your messages on Signal is protected with robust end-to-end encryption, there is a large amount of meta-data visible to Signal - who you talk with and when.
+2. _Why should I not just use Signal?_ Signal is a centralized platform that uses phone numbers to identify its users and their contacts. It means that while the content of your messages on Signal is protected with robust end-to-end encryption, there is a large amount of meta-data visible to Signal - who you talk with and when.
 
-3. _How is it different from Matrix, Session, Ricochet, Cwtch, etc., that also don't require user identites?_ Although these platforms do not require a _real identity_, they do rely on anonymous user identities to deliver messages – it can be, for example, an identity key or a random number. Using a persistent user identity, even anonymous, creates a risk that user's connection graph becomes known to the observers and/or service providers, and it can lead to de-anonymizing some users. If the same user profile is used to connect to two different people via any messenger other than SimpleX, these two people can confirm if they are connected to the same person - they would use the same user identifier in the messages. With SimpleX there is no meta-data in common between your conversations with different contacts - the quality that no other messaging platform has.
+3. _How is it different from Matrix, Session, Ricochet, Cwtch, etc., that also don't require user identities?_ Although these platforms do not require a _real identity_, they do rely on anonymous user identities to deliver messages – it can be, for example, an identity key or a random number. Using a persistent user identity, even anonymous, creates a risk that user's connection graph becomes known to the observers and/or service providers, and it can lead to de-anonymizing some users. If the same user profile is used to connect to two different people via any messenger other than SimpleX, these two people can confirm if they are connected to the same person - they would use the same user identifier in the messages. With SimpleX there is no meta-data in common between your conversations with different contacts - the quality that no other messaging platform has.
 
 ## News and updates
 
 Recent updates:
 
-[Sep 28, 2022. v4.0: encrypted local chat database and many other changes](./blog/20220928-simplex-chat-v4-encrypted-database.md)
+[Mar 28, 2023. v4.6 released - with Android 8+ and ARMv7a support, hidden profiles, community moderation, improved audio/video calls and reduced battery usage](./blog/20230328-simplex-chat-v4-6-hidden-profiles.md).
 
-[Sep 1, 2022. v3.2: incognito mode, support .onion server hostnames, setting contact names, changing color scheme, etc. Implementation audit is arranged for October!](./blog/20220901-simplex-chat-v3.2-incognito-mode.md)
+[Mar 1, 2023. SimpleX File Transfer Protocol – send large files efficiently, privately and securely, soon to be integrated into SimpleX Chat apps.](./blog/20230301-simplex-file-transfer-protocol.md).
 
-[Aug 8, 2022. v3.1: secret chat groups, access via Tor, reduced battery and traffic usage, advanced network settings, etc.](./blog/20220808-simplex-chat-v3.1-chat-groups.md)
+[Feb 4, 2023. v4.5 released - with multiple user profiles, message draft, transport isolation and Italian interface](./blog/20230204-simplex-chat-v4-5-user-chat-profiles.md).
 
-[Jul 11, 2022. v3.0: instant push notifications for iOS, e2e encrypted WebRTC audio/video calls, chat database export/import, privacy and performance improvements](./blog/20220711-simplex-chat-v3-released-ios-notifications-audio-video-calls-database-export-import-protocol-improvements.md)
+[Jan 3, 2023. v4.4 released - with disappearing messages, "live" messages, connection security verifications, GIFs and stickers and with French interface language](./blog/20230103-simplex-chat-v4.4-disappearing-messages.md).
+
+[Dec 6, 2022. November reviews and v4.3 released - with instant voice messages, irreversible deletion of sent messages and improved server configuration](./blog/20221206-simplex-chat-v4.3-voice-messages.md).
+
+[Nov 8, 2022. Security audit by Trail of Bits, the new website and v4.2 released](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
+
+[Sep 28, 2022. v4.0: encrypted local chat database and many other changes](./blog/20220928-simplex-chat-v4-encrypted-database.md).
 
 [All updates](./blog)
 
-## Make a private connection
-
-You need to share a link or scan a QR code (in person or during a video call) to make a connection and start messaging.
-
-The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
-
-<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/conversation.png" alt="Make a private connection" width="594" height="360">
-
 ## :zap: Quick installation of a terminal app
 
 ```sh
@@ -133,7 +228,7 @@ SimpleX Chat is a work in progress – we are releasing improvements as they are
 
 What is already implemented:
 
-1. Instead of user profile identifiers used by all other platforms, even the most private ones, SimpleX uses pairwise per-queue identifiers (2 addresses for each unidirectional message queue, with an optional 3rd address for push notificaitons on iOS, 2 queues in each connection between the users). It makes observing the network graph on the application level more difficult, as for `n` users there can be up to `n * (n-1)` message queues.
+1. Instead of user profile identifiers used by all other platforms, even the most private ones, SimpleX uses pairwise per-queue identifiers (2 addresses for each unidirectional message queue, with an optional 3rd address for push notifications on iOS, 2 queues in each connection between the users). It makes observing the network graph on the application level more difficult, as for `n` users there can be up to `n * (n-1)` message queues.
 2. End-to-end encryption in each message queue using [NaCl cryptobox](https://nacl.cr.yp.to/box.html). This is added to allow redundancy in the future (passing each message via several servers), to avoid having the same ciphertext in different queues (that would only be visible to the attacker if TLS is compromised). The encryption keys used for this encryption are not rotated, instead we are planning to rotate the queues. Curve25519 keys are used for key negotiation.
 3. [Double ratchet](https://signal.org/docs/specifications/doubleratchet/) end-to-end encryption in each conversation between two users (or group members). This is the same algorithm that is used in Signal and many other messaging apps; it provides OTR messaging with forward secrecy (each message is encrypted by its own ephemeral key), break-in recovery (the keys are frequently re-negotiated as part of the message exchange). Two pairs of Curve448 keys are used for the initial key agreement, initiating party passes these keys via the connection link, accepting side - in the header of the confirmation message.
 4. Additional layer of encryption using NaCL cryptobox for the messages delivered from the server to the recipient. This layer avoids having any ciphertext in common between sent and received traffic of the server inside TLS (and there are no identifiers in common as well).
@@ -143,13 +238,13 @@ What is already implemented:
 8. To protect against replay attacks SimpleX servers require [tlsunique channel binding](https://www.rfc-editor.org/rfc/rfc5929.html) as session ID in each client command signed with per-queue ephemeral key.
 9. To protect your IP address all SimpleX Chat clients support accessing messaging servers via Tor - see [v3.1 release announcement](./blog/20220808-simplex-chat-v3.1-chat-groups.md) for more details.
 10. Local database encryption with passphrase - your contacts, groups and all sent and received messages are stored encrypted. If you used SimpleX Chat before v4.0 you need to enable the encryption via the app settings.
+11. Transport isolation - different TCP connections and Tor circuits are used for traffic of different user profiles, optionally - for different contacts and group member connections.
 
 We plan to add soon:
 
-1. Message queue rotation. Currently the queues created between two users are used until the contact is deleted, providing a long-term pairwise identifiers of the conversation. We are planning to add queue rotation to make these identifiers termporary and rotate based on some schedule TBC (e.g., every X messages, or every X hours/days).
+1. Automatic message queue rotation. Currently the queues created between two users are used until the queue is manually changed by the user or contact is deleted. We are planning to add automatic queue rotation to make these identifiers temporary and rotate based on some schedule TBC (e.g., every X messages, or every X hours/days).
 2. Local files encryption. Currently the images and files you send and receive are stored in the app unencrypted, you can delete them via `Settings / Database passphrase & export`.
 3. Message "mixing" - adding latency to message delivery, to protect against traffic correlation by message time.
-4. Independent implementation audit.
 
 ## For developers
 
@@ -157,7 +252,7 @@ You can:
 
 - use SimpleX Chat library to integrate chat functionality into your mobile apps.
 - create chat bots and services in Haskell - see [simple](./apps/simplex-bot/) and more [advanced chat bot example](./apps/simplex-bot-advanced/).
-- create chat bots and services in any language running SimpleX Chat terminal CLI as a local WebSocket server. See [TypeScript SimpleX Chat client](./packages/simplex-chat-client/) and [JavaScipt chat bot example](./packages/simplex-chat-client/typescript/examples/squaring-bot.js).
+- create chat bots and services in any language running SimpleX Chat terminal CLI as a local WebSocket server. See [TypeScript SimpleX Chat client](./packages/simplex-chat-client/) and [JavaScript chat bot example](./packages/simplex-chat-client/typescript/examples/squaring-bot.js).
 - run [simplex-chat terminal CLI](./docs/CLI.md) to execute individual chat commands, e.g. to send messages as part of shell script execution.
 
 If you are considering developing with SimpleX platform please get in touch for any advice and support.
@@ -175,61 +270,74 @@ If you are considering developing with SimpleX platform please get in touch for
 - ✅ Manual chat history deletion.
 - ✅ End-to-end encrypted WebRTC audio and video calls via the mobile apps.
 - ✅ Privacy preserving instant notifications for iOS using Apple Push Notification service.
-- ✅ Chat database export and import
+- ✅ Chat database export and import.
 - ✅ Chat groups in mobile apps.
 - ✅ Connecting to messaging servers via Tor.
 - ✅ Dual server addresses to access messaging servers as v3 hidden services.
 - ✅ Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (ready for announcement).
 - ✅ Incognito mode to share a new random name with each contact.
 - ✅ Chat database encryption.
-- 🏗 Automatic chat history deletion.
-- 🏗 SMP queue redundancy and rotation.
-- 🏗 Links to join groups and improve groups stability.
-- Feeds/broadcasts
-- Disappearing messages, with mutual agreement.
-- Voice messages
-- Video messages
+- ✅ Automatic chat history deletion.
+- ✅ Links to join groups and improve groups stability.
+- ✅ Voice messages (with recipient opt-out per contact).
+- ✅ Basic authentication for SMP servers (to authorize creating new queues).
+- ✅ View deleted messages, full message deletion by sender (with recipient opt-in per contact).
+- ✅ Block screenshots and view in recent apps.
+- ✅ Advanced server configuration.
+- ✅ Disappearing messages (with recipient opt-in per-contact).
+- ✅ "Live" messages.
+- ✅ Contact verification via a separate out-of-band channel.
+- ✅ Multiple user profiles in the same chat database.
+- ✅ Optionally avoid re-using the same TCP session for multiple connections.
+- ✅ Preserve message drafts.
+- ✅ File server to optimize for efficient and private sending of large files.
+- ✅ Improved audio & video calls.
+- ✅ Support older Android OS and 32-bit CPUs.
+- ✅ Hidden chat profiles.
+- 🏗 Sending and receiving large files via [XFTP protocol](./blog/20230301-simplex-file-transfer-protocol.md).
+- 🏗 Video messages.
+- 🏗 SMP queue redundancy and rotation (manual is supported).
+- 🏗 Reduced battery and traffic usage in large groups.
+- Include optional message into connection request sent via contact address.
+- Ephemeral/disappearing/OTR conversations with the existing contacts.
+- Access password/pin (with optional alternative access password).
+- Local app files encryption.
+- Improved navigation and search in the conversation (expand and scroll to quoted message, scroll to search results, etc.).
+- Message delivery confirmation (with sender opt-in or opt-out per contact, TBC).
+- Privately share your location.
+- Feeds/broadcasts.
 - Web widgets for custom interactivity in the chats.
-- Message delivery confirmation.
+- Programmable chat automations / rules (automatic replies/forward/deletion/sending, reminders, etc.).
 - Supporting the same profile on multiple devices.
+- Desktop client.
 - Privacy-preserving identity server for optional DNS-based contact/group addresses to simplify connection and discovery, but not used to deliver messages:
   - keep all your contacts and groups even if you lose the domain.
   - the server doesn't have information about your contacts and groups.
-- Channels server for large groups and broadcast channels.
-- Media server to optimize sending large files to groups.
-- Desktop client.
-- Using the same profile on multiple devices.
+- Hosting server for large groups, communities and public channels.
+- Message delivery relay for senders (to conceal IP address from the recipients' servers and to reduce the traffic).
+- High capacity multi-node SMP relays.
 
-## Help us pay for 3rd party security audit
+## Disclaimers
 
-I will get straight to the point: I ask you to support SimpleX Chat with donations.
+[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed, and had many breaking changes and improvements in v1.0.0.
 
-We are prioritizing users privacy and security - it would be impossible without your support we were lucky to have so far.
+The security audit was performed in October 2022 by [Trail of Bits](https://www.trailofbits.com/about), and most fixes were released in v4.2.0 – see [the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
 
-We are planning a 3rd party security audit for the app, and it would hugely help us if some part of this $20,000+ expense could be covered with donations.
+SimpleX Chat is still a relatively early stage platform (the mobile apps were released in March 2022), so you may discover some bugs and missing features. We would really appreciate if you let us know anything that needs to be fixed or improved.
 
-Our pledge to our users is that SimpleX protocols are and will remain open, and in public domain, - so anybody can build the future implementations of the clients and the servers. We are building SimpleX platform based on the same principles as email and web, but much more private and secure.
+The default servers configured in the app are provided on the best effort basis. We are currently not guaranteeing any SLAs, although historically our servers had over 99.9% uptime each.
 
-If you are already using SimpleX Chat, or plan to use it in the future when it has more features, please consider making a donation - it will help us to raise more funds. Donating any amount, even the price of the cup of coffee, would make a huge difference for us.
+We have never provided or have been requested access to our servers or any information from our servers by any third parties. If we are ever requested to provide such access or information, we will be following due legal process.
 
-It is possible to donate via:
+We do not log IP addresses of the users and we do not perform any traffic correlation on our servers. If transport level security is critical you must use Tor or some other similar network to access messaging servers. We will be improving the client applications to reduce the opportunities for traffic correlation.
 
-- [GitHub](https://github.com/sponsors/simplex-chat) - it is commission-free for us.
-- [OpenCollective](https://opencollective.com/simplex-chat) - it charges a commission, and also accepts donations in crypto-currencies.
-- Monero wallet: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
-- Bitcoin wallet: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+Please read more in [Terms & privacy policy](./PRIVACY.md).
 
-Thank you,
+## Security contact
 
-Evgeny
+To report a security vulnerability, please send us email to chat@simplex.chat. We will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues.
 
-SimpleX Chat founder
-
-## Disclaimer
-
-[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed and had many improvements in v1.0.0; we are currently arranging for the independent implementation audit.
-
-You are likely to discover some bugs - we would really appreciate if you use it and let us know anything that needs to be fixed or improved.
+Please treat any findings of possible traffic correlation attacks allowing to correlate two different conversations to the same user, other than covered in [the threat model](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/overview-tjr.md#threat-model), as security vulnerabilities, and follow this disclosure process.
 
 ## License
 
@@ -243,4 +351,4 @@ You are likely to discover some bugs - we would really appreciate if you use it
 &nbsp;
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/testflight.png" alt="iOS TestFlight" height="41">](https://testflight.apple.com/join/DWuT2LQu)
 &nbsp;
-[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)

apps/android/app/build.gradle

@@ -9,15 +9,12 @@ android {
 
     defaultConfig {
         applicationId "chat.simplex.app"
-        minSdk 29
+        minSdk 26
         targetSdk 32
-        versionCode 67
-        versionName "4.2"
+        versionCode 110
+        versionName "4.6.1-beta.1"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        ndk {
-            abiFilters 'arm64-v8a'
-        }
         vectorDrawables {
             useSupportLibrary true
         }
@@ -76,6 +73,28 @@ android {
         }
         jniLibs.useLegacyPackaging = compression_level != "0"
     }
+    def isRelease = gradle.getStartParameter().taskNames.find({ it.toLowerCase().contains("release") }) != null
+    def isBundle = gradle.getStartParameter().taskNames.find({ it.toLowerCase().contains("bundle") }) != null
+//    if (isRelease) {
+        // Comma separated list of languages that will be included in the apk
+    android.defaultConfig.resConfigs("en", "cs", "de", "es", "fr", "it", "nl", "ru", "zh-rCN")
+//    }
+    if (isBundle) {
+        defaultConfig.ndk.abiFilters 'arm64-v8a', 'armeabi-v7a'
+    } else {
+        splits {
+            abi {
+                enable true
+                reset()
+                if (isRelease) {
+                    include 'arm64-v8a', 'armeabi-v7a'
+                } else {
+                    include 'arm64-v8a', 'armeabi-v7a'
+                    universalApk false
+                }
+            }
+        }
+    }
 }
 
 dependencies {
@@ -124,6 +143,9 @@ dependencies {
     implementation "io.coil-kt:coil-compose:2.1.0"
     implementation "io.coil-kt:coil-gif:2.1.0"
 
+    // Video support
+    implementation "com.google.android.exoplayer:exoplayer:2.17.1"
+
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
@@ -191,6 +213,8 @@ tasks.register("compressApk") {
 
         if (project.properties['android.injected.signing.key.alias'] != null && buildType == 'release') {
             new File(outputDir, "app-release.apk").renameTo(new File(outputDir, "simplex.apk"))
+            new File(outputDir, "app-armeabi-v7a-release.apk").renameTo(new File(outputDir, "simplex-armv7a.apk"))
+            new File(outputDir, "app-arm64-v8a-release.apk").renameTo(new File(outputDir, "simplex.apk"))
         }
 
         // View all gradle properties set

apps/android/app/src/main/AndroidManifest.xml

@@ -24,11 +24,14 @@
   <application
       android:name="SimplexApp"
       android:allowBackup="true"
+      android:fullBackupOnly="true"
+      android:backupAgent="BackupAgent"
       android:icon="@mipmap/icon"
       android:label="${app_name}"
       android:extractNativeLibs="${extract_native_libs}"
       android:supportsRtl="true"
       android:theme="@style/Theme.SimpleX">
+    <!--      android:localeConfig="@xml/locales_config"-->
 
     <!-- Main activity -->
     <activity
@@ -102,7 +105,9 @@
 
 
     <activity android:name=".views.call.IncomingCallActivity"
-        android:showOnLockScreen="true"/>
+        android:showOnLockScreen="true"
+        android:exported="false"
+        android:launchMode="singleTask"/>
 
     <provider
         android:name="androidx.core.content.FileProvider"

apps/android/app/src/main/assets/www/call.js

@@ -22,10 +22,12 @@ var TransformOperation;
     TransformOperation["Decrypt"] = "decrypt";
 })(TransformOperation || (TransformOperation = {}));
 let activeCall;
+let answerTimeout = 30000;
 const processCommand = (function () {
     const defaultIceServers = [
         { urls: ["stun:stun.simplex.im:443"] },
-        { urls: ["turn:turn.simplex.im:443"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
+        { urls: ["turn:turn.simplex.im:443?transport=udp"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
+        { urls: ["turn:turn.simplex.im:443?transport=tcp"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
     ];
     function getCallConfig(encodedInsertableStreams, iceServers, relay) {
         return {
@@ -100,9 +102,16 @@ const processCommand = (function () {
         const iceCandidates = getIceCandidates(pc, config);
         const call = { connection: pc, iceCandidates, localMedia: mediaType, localCamera, localStream, remoteStream, aesKey, useWorker };
         await setupMediaStreams(call);
+        let connectionTimeout = setTimeout(connectionHandler, answerTimeout);
         pc.addEventListener("connectionstatechange", connectionStateChange);
         return call;
         async function connectionStateChange() {
+            // "failed" means the second party did not answer in time (15 sec timeout in Chrome WebView)
+            // See https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/p2p/base/p2p_constants.cc;l=70)
+            if (pc.connectionState !== "failed")
+                connectionHandler();
+        }
+        async function connectionHandler() {
             sendMessageToNative({
                 resp: {
                     type: "connection",
@@ -115,6 +124,7 @@ const processCommand = (function () {
                 },
             });
             if (pc.connectionState == "disconnected" || pc.connectionState == "failed") {
+                clearConnectionTimeout();
                 pc.removeEventListener("connectionstatechange", connectionStateChange);
                 if (activeCall) {
                     setTimeout(() => sendMessageToNative({ resp: { type: "ended" } }), 0);
@@ -122,6 +132,7 @@ const processCommand = (function () {
                 endCall();
             }
             else if (pc.connectionState == "connected") {
+                clearConnectionTimeout();
                 const stats = (await pc.getStats());
                 for (const stat of stats.values()) {
                     const { type, state } = stat;
@@ -141,6 +152,12 @@ const processCommand = (function () {
                 }
             }
         }
+        function clearConnectionTimeout() {
+            if (connectionTimeout) {
+                clearTimeout(connectionTimeout);
+                connectionTimeout = undefined;
+            }
+        }
     }
     function serialize(x) {
         return LZString.compressToBase64(JSON.stringify(x));

apps/android/app/src/main/cpp/CMakeLists.txt

@@ -53,10 +53,6 @@ add_library( support SHARED IMPORTED )
 set_target_properties( support PROPERTIES IMPORTED_LOCATION
     ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libsupport.so)
 
-add_library( crypto SHARED IMPORTED )
-set_target_properties( crypto PROPERTIES IMPORTED_LOCATION
-    ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libcrypto.so)
-
 # Specifies libraries CMake should link to your target library. You
 # can link multiple libraries, such as libraries you define in this
 # build script, prebuilt third-party libraries, or system libraries.
@@ -64,7 +60,7 @@ set_target_properties( crypto PROPERTIES IMPORTED_LOCATION
 target_link_libraries( # Specifies the target library.
     app-lib
 
-    simplex support crypto
+    simplex support
 
     # Links the target library to the log library
     # included in the NDK.

apps/android/app/src/main/cpp/simplex-api.c

@@ -7,6 +7,17 @@ void hs_init(int * argc, char **argv[]);
 void setLineBuffering(void);
 int pipe_std_to_socket(const char * name);
 
+extern void __svfscanf(void){};
+extern void __vfwscanf(void){};
+extern void __memset_chk_fail(void){};
+extern void __strcpy_chk_generic(void){};
+extern void __strcat_chk_generic(void){};
+extern void __libc_globals(void){};
+extern void __rel_iplt_start(void){};
+
+// Android 9 only, not 13
+extern void reallocarray(void){};
+
 JNIEXPORT jint JNICALL
 Java_chat_simplex_app_SimplexAppKt_pipeStdOutToSocket(JNIEnv *env, __unused jclass clazz, jstring socket_name) {
     const char *name = (*env)->GetStringUTFChars(env, socket_name, JNI_FALSE);
@@ -24,20 +35,24 @@ Java_chat_simplex_app_SimplexAppKt_initHS(__unused JNIEnv *env, __unused jclass
 // from simplex-chat
 typedef long* chat_ctrl;
 
-extern char *chat_migrate_init(const char *path, const char *key, chat_ctrl *ctrl);
+extern char *chat_migrate_init(const char *path, const char *key, const char *confirm, chat_ctrl *ctrl);
 extern char *chat_send_cmd(chat_ctrl ctrl, const char *cmd);
 extern char *chat_recv_msg(chat_ctrl ctrl); // deprecated
 extern char *chat_recv_msg_wait(chat_ctrl ctrl, const int wait);
 extern char *chat_parse_markdown(const char *str);
+extern char *chat_parse_server(const char *str);
+extern char *chat_password_hash(const char *pwd, const char *salt);
 
 JNIEXPORT jobjectArray JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatMigrateInit(JNIEnv *env, __unused jclass clazz, jstring dbPath, jstring dbKey) {
+Java_chat_simplex_app_SimplexAppKt_chatMigrateInit(JNIEnv *env, __unused jclass clazz, jstring dbPath, jstring dbKey, jstring confirm) {
     const char *_dbPath = (*env)->GetStringUTFChars(env, dbPath, JNI_FALSE);
     const char *_dbKey = (*env)->GetStringUTFChars(env, dbKey, JNI_FALSE);
+    const char *_confirm = (*env)->GetStringUTFChars(env, confirm, JNI_FALSE);
     jlong _ctrl = (jlong) 0;
-    jstring res = (*env)->NewStringUTF(env, chat_migrate_init(_dbPath, _dbKey, &_ctrl));
+    jstring res = (*env)->NewStringUTF(env, chat_migrate_init(_dbPath, _dbKey, _confirm, &_ctrl));
     (*env)->ReleaseStringUTFChars(env, dbPath, _dbPath);
     (*env)->ReleaseStringUTFChars(env, dbKey, _dbKey);
+    (*env)->ReleaseStringUTFChars(env, dbKey, _confirm);
 
     // Creating array of Object's (boxed values can be passed, eg. Long instead of long)
     jobjectArray ret = (jobjectArray)(*env)->NewObjectArray(env, 2, (*env)->FindClass(env, "java/lang/Object"), NULL);
@@ -76,3 +91,21 @@ Java_chat_simplex_app_SimplexAppKt_chatParseMarkdown(JNIEnv *env, __unused jclas
     (*env)->ReleaseStringUTFChars(env, str, _str);
     return res;
 }
+
+JNIEXPORT jstring JNICALL
+Java_chat_simplex_app_SimplexAppKt_chatParseServer(JNIEnv *env, __unused jclass clazz, jstring str) {
+    const char *_str = (*env)->GetStringUTFChars(env, str, JNI_FALSE);
+    jstring res = (*env)->NewStringUTF(env, chat_parse_server(_str));
+    (*env)->ReleaseStringUTFChars(env, str, _str);
+    return res;
+}
+
+JNIEXPORT jstring JNICALL
+Java_chat_simplex_app_SimplexAppKt_chatPasswordHash(JNIEnv *env, __unused jclass clazz, jstring pwd, jstring salt) {
+    const char *_pwd = (*env)->GetStringUTFChars(env, pwd, JNI_FALSE);
+    const char *_salt = (*env)->GetStringUTFChars(env, salt, JNI_FALSE);
+    jstring res = (*env)->NewStringUTF(env, chat_password_hash(_pwd, _salt));
+    (*env)->ReleaseStringUTFChars(env, pwd, _pwd);
+    (*env)->ReleaseStringUTFChars(env, salt, _salt);
+    return res;
+}

apps/android/app/src/main/java/chat/simplex/app/BackupAgent.kt

@@ -0,0 +1,18 @@
+package chat.simplex.app
+
+import android.app.backup.BackupAgentHelper
+import android.app.backup.FullBackupDataOutput
+import android.content.Context
+import chat.simplex.app.model.AppPreferences
+import chat.simplex.app.model.AppPreferences.Companion.SHARED_PREFS_PRIVACY_FULL_BACKUP
+
+class BackupAgent: BackupAgentHelper() {
+  override fun onFullBackup(data: FullBackupDataOutput?) {
+    if (applicationContext
+        .getSharedPreferences(AppPreferences.SHARED_PREFS_ID, Context.MODE_PRIVATE)
+        .getBoolean(SHARED_PREFS_PRIVACY_FULL_BACKUP, true)
+    ) {
+      super.onFullBackup(data)
+    }
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/MainActivity.kt

@@ -3,27 +3,31 @@ package chat.simplex.app
 import android.app.Application
 import android.content.Intent
 import android.net.Uri
-import android.os.Bundle
-import android.os.Parcelable
+import android.os.*
 import android.os.SystemClock.elapsedRealtime
 import android.util.Log
+import android.view.WindowManager
 import androidx.activity.compose.setContent
 import androidx.activity.viewModels
+import androidx.compose.animation.core.*
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Surface
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Replay
+import androidx.compose.material.icons.outlined.Lock
 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.graphicsLayer
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.*
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.model.NtfManager
+import chat.simplex.app.model.NtfManager.Companion.getUserIdFromIntent
 import chat.simplex.app.ui.theme.SimpleButton
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.SplashView
@@ -33,10 +37,10 @@ import chat.simplex.app.views.chat.ChatView
 import chat.simplex.app.views.chatlist.*
 import chat.simplex.app.views.database.DatabaseErrorView
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.connectViaUri
-import chat.simplex.app.views.newchat.withUriAction
+import chat.simplex.app.views.newchat.*
 import chat.simplex.app.views.onboarding.*
-import kotlinx.coroutines.delay
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.distinctUntilChanged
 
 class MainActivity: FragmentActivity() {
   companion object {
@@ -61,6 +65,7 @@ class MainActivity: FragmentActivity() {
     super.onCreate(savedInstanceState)
     // testJson()
     val m = vm.chatModel
+    applyAppLocale(m.controller.appPrefs.appLanguage)
     // When call ended and orientation changes, it re-process old intent, it's unneeded.
     // Only needed to be processed on first creation of activity
     if (savedInstanceState == null) {
@@ -68,6 +73,13 @@ class MainActivity: FragmentActivity() {
       processIntent(intent, m)
       processExternalIntent(intent, m)
     }
+    if (m.controller.appPrefs.privacyProtectScreen.get()) {
+      Log.d(TAG, "onCreate: set FLAG_SECURE")
+      window.setFlags(
+        WindowManager.LayoutParams.FLAG_SECURE,
+        WindowManager.LayoutParams.FLAG_SECURE
+      )
+    }
     setContent {
       SimpleXTheme {
         Surface(
@@ -96,21 +108,40 @@ class MainActivity: FragmentActivity() {
     processExternalIntent(intent, vm.chatModel)
   }
 
-  override fun onStart() {
-    super.onStart()
+  override fun onResume() {
+    super.onResume()
     val enteredBackgroundVal = enteredBackground.value
     if (enteredBackgroundVal == null || elapsedRealtime() - enteredBackgroundVal >= 30_000) {
       runAuthenticate()
     }
   }
 
+  override fun onPause() {
+    super.onPause()
+    /**
+    * When new activity is created after a click on notification, the old one receives onPause before
+    * recreation but receives onStop after recreation. So using both (onPause and onStop) to prevent
+    * unwanted multiple auth dialogs from [runAuthenticate]
+    * */
+    enteredBackground.value = elapsedRealtime()
+  }
+
   override fun onStop() {
     super.onStop()
+    VideoPlayer.stopAll()
     enteredBackground.value = elapsedRealtime()
   }
 
   override fun onBackPressed() {
-    super.onBackPressed()
+    if (
+      onBackPressedDispatcher.hasEnabledCallbacks() // Has something to do in a backstack
+      || Build.VERSION.SDK_INT >= Build.VERSION_CODES.R // Android 11 or above
+      || isTaskRoot // there are still other tasks after we reach the main (home) activity
+    ) {
+      // https://medium.com/mobile-app-development-publication/the-risk-of-android-strandhogg-security-issue-and-how-it-can-be-mitigated-80d2ddb4af06
+      super.onBackPressed()
+    }
+
     if (!onBackPressedDispatcher.hasEnabledCallbacks() && vm.chatModel.controller.appPrefs.performLA.get()) {
       // When pressed Back and there is no one wants to process the back event, clear auth state to force re-auth on launch
       clearAuthState()
@@ -129,32 +160,31 @@ class MainActivity: FragmentActivity() {
     } else {
       userAuthorized.value = false
       ModalManager.shared.closeModals()
-      authenticate(
-        generalGetString(R.string.auth_unlock),
-        generalGetString(R.string.auth_log_in_using_credential),
-        this@MainActivity,
-        completed = { laResult ->
-          when (laResult) {
-            LAResult.Success -> {
-              userAuthorized.value = true
+      // To make Main thread free in order to allow to Compose to show blank view that hiding content underneath of it faster on slow devices
+      CoroutineScope(Dispatchers.Default).launch {
+        delay(50)
+        withContext(Dispatchers.Main) {
+          authenticate(
+            generalGetString(R.string.auth_unlock),
+            generalGetString(R.string.auth_log_in_using_credential),
+            this@MainActivity,
+            completed = { laResult ->
+              when (laResult) {
+                LAResult.Success ->
+                  userAuthorized.value = true
+                is LAResult.Error, LAResult.Failed ->
+                  laFailed.value = true
+                LAResult.Unavailable -> {
+                  userAuthorized.value = true
+                  m.performLA.value = false
+                  m.controller.appPrefs.performLA.set(false)
+                  laUnavailableTurningOffAlert()
+                }
+              }
             }
-            is LAResult.Error -> {
-              laFailed.value = true
-              laErrorToast(applicationContext, laResult.errString)
-            }
-            LAResult.Failed -> {
-              laFailed.value = true
-              laFailedToast(applicationContext)
-            }
-            LAResult.Unavailable -> {
-              userAuthorized.value = true
-              m.performLA.value = false
-              m.controller.appPrefs.performLA.set(false)
-              laUnavailableTurningOffAlert()
-            }
-          }
+          )
         }
-      )
+      }
     }
   }
 
@@ -181,15 +211,9 @@ class MainActivity: FragmentActivity() {
             prefPerformLA.set(true)
             laTurnedOnAlert()
           }
-          is LAResult.Error -> {
+          is LAResult.Error, LAResult.Failed -> {
             m.performLA.value = false
             prefPerformLA.set(false)
-            laErrorToast(applicationContext, laResult.errString)
-          }
-          LAResult.Failed -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-            laFailedToast(applicationContext)
           }
           LAResult.Unavailable -> {
             m.performLA.value = false
@@ -214,15 +238,9 @@ class MainActivity: FragmentActivity() {
             m.performLA.value = false
             prefPerformLA.set(false)
           }
-          is LAResult.Error -> {
+          is LAResult.Error, LAResult.Failed -> {
             m.performLA.value = true
             prefPerformLA.set(true)
-            laErrorToast(applicationContext, laResult.errString)
-          }
-          LAResult.Failed -> {
-            m.performLA.value = true
-            prefPerformLA.set(true)
-            laFailedToast(applicationContext)
           }
           LAResult.Unavailable -> {
             m.performLA.value = false
@@ -249,14 +267,6 @@ fun MainPage(
   setPerformLA: (Boolean) -> Unit,
   showLANotice: () -> Unit
 ) {
-  // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
-  var chatsAccessAuthorized by rememberSaveable { mutableStateOf(false) }
-  LaunchedEffect(userAuthorized.value) {
-    if (chatModel.controller.appPrefs.performLA.get()) {
-      delay(500L)
-    }
-    chatsAccessAuthorized = userAuthorized.value == true
-  }
   var showChatDatabaseError by rememberSaveable {
     mutableStateOf(chatModel.chatDbStatus.value != DBMigrationResult.OK && chatModel.chatDbStatus.value != null)
   }
@@ -289,14 +299,14 @@ fun MainPage(
   }
 
   @Composable
-  fun retryAuthView() {
+  fun authView() {
     Box(
       Modifier.fillMaxSize(),
       contentAlignment = Alignment.Center
     ) {
       SimpleButton(
-        stringResource(R.string.auth_retry),
-        icon = Icons.Outlined.Replay,
+        stringResource(R.string.auth_unlock),
+        icon = Icons.Outlined.Lock,
         click = {
           laFailed.value = false
           runAuthenticate()
@@ -315,9 +325,9 @@ fun MainPage(
         }
       }
       onboarding == null || userCreated == null -> SplashView()
-      !chatsAccessAuthorized -> {
+      userAuthorized.value != true -> {
         if (chatModel.controller.appPrefs.performLA.get() && laFailed.value) {
-          retryAuthView()
+          authView()
         } else {
           SplashView()
         }
@@ -327,19 +337,55 @@ fun MainPage(
           if (chatModel.showCallView.value) ActiveCallView(chatModel)
           else {
             showAdvertiseLAAlert = true
-            val stopped = chatModel.chatRunning.value == false
-            if (chatModel.chatId.value == null) {
-              if (chatModel.sharedContent.value == null)
-                ChatListView(chatModel, setPerformLA, stopped)
-              else
-                ShareListView(chatModel, stopped)
+            BoxWithConstraints {
+              var currentChatId by rememberSaveable { mutableStateOf(chatModel.chatId.value) }
+              val offset = remember { Animatable(if (chatModel.chatId.value == null) 0f else maxWidth.value) }
+              Box(
+                Modifier
+                  .graphicsLayer {
+                    translationX = -offset.value.dp.toPx()
+                  }
+              ) {
+                  val stopped = chatModel.chatRunning.value == false
+                  if (chatModel.sharedContent.value == null)
+                    ChatListView(chatModel, setPerformLA, stopped)
+                  else
+                    ShareListView(chatModel, stopped)
+              }
+              val scope = rememberCoroutineScope()
+              val onComposed: () -> Unit = {
+                scope.launch {
+                  offset.animateTo(
+                    if (chatModel.chatId.value == null) 0f else maxWidth.value,
+                    chatListAnimationSpec()
+                  )
+                  if (offset.value == 0f) {
+                    currentChatId = null
+                  }
+                }
+              }
+              LaunchedEffect(Unit) {
+                launch {
+                  snapshotFlow { chatModel.chatId.value }
+                    .distinctUntilChanged()
+                    .collect {
+                      if (it != null) currentChatId = it
+                      else onComposed()
+                    }
+                }
+              }
+              Box (Modifier.graphicsLayer { translationX = maxWidth.toPx() - offset.value.dp.toPx() }) Box2@ {
+                currentChatId?.let {
+                  ChatView(it, chatModel, onComposed)
+                }
+              }
             }
-            else ChatView(chatModel)
           }
         }
       }
       onboarding == OnboardingStage.Step1_SimpleXInfo -> SimpleXInfo(chatModel, onboarding = true)
-      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
+      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel) {}
+      onboarding == OnboardingStage.Step3_SetNotificationsMode -> SetNotificationsMode(chatModel)
     }
     ModalManager.shared.showInView()
     val invitation = chatModel.activeCallInvitation.value
@@ -349,20 +395,31 @@ fun MainPage(
 }
 
 fun processNotificationIntent(intent: Intent?, chatModel: ChatModel) {
+  val userId = getUserIdFromIntent(intent)
   when (intent?.action) {
     NtfManager.OpenChatAction -> {
       val chatId = intent.getStringExtra("chatId")
       Log.d(TAG, "processNotificationIntent: OpenChatAction $chatId")
       if (chatId != null) {
-        val cInfo = chatModel.getChat(chatId)?.chatInfo
-        chatModel.clearOverlays.value = true
-        if (cInfo != null) withApi { openChat(cInfo, chatModel) }
+        withBGApi {
+          if (userId != null && userId != chatModel.currentUser.value?.userId) {
+            chatModel.controller.changeActiveUser(userId, null)
+          }
+          val cInfo = chatModel.getChat(chatId)?.chatInfo
+          chatModel.clearOverlays.value = true
+          if (cInfo != null) openChat(cInfo, chatModel)
+        }
       }
     }
     NtfManager.ShowChatsAction -> {
       Log.d(TAG, "processNotificationIntent: ShowChatsAction")
-      chatModel.chatId.value = null
-      chatModel.clearOverlays.value = true
+      withBGApi {
+        if (userId != null && userId != chatModel.currentUser.value?.userId) {
+          chatModel.controller.changeActiveUser(userId, null)
+        }
+        chatModel.chatId.value = null
+        chatModel.clearOverlays.value = true
+      }
     }
     NtfManager.AcceptCallAction -> {
       val chatId = intent.getStringExtra("chatId")
@@ -423,26 +480,25 @@ fun processExternalIntent(intent: Intent?, chatModel: ChatModel) {
 fun connectIfOpenedViaUri(uri: Uri, chatModel: ChatModel) {
   Log.d(TAG, "connectIfOpenedViaUri: opened via link")
   if (chatModel.currentUser.value == null) {
-    // TODO open from chat list view
     chatModel.appOpenUrl.value = uri
   } else {
-    withUriAction(uri) { action ->
-      val title = when (action) {
-        "contact" -> generalGetString(R.string.connect_via_contact_link)
-        "invitation" -> generalGetString(R.string.connect_via_invitation_link)
-        else -> {
-          Log.e(TAG, "URI has unexpected action. Alert shown.")
-          action
-        }
+    withUriAction(uri) { linkType ->
+      val title = when (linkType) {
+        ConnectionLinkType.CONTACT -> generalGetString(R.string.connect_via_contact_link)
+        ConnectionLinkType.INVITATION -> generalGetString(R.string.connect_via_invitation_link)
+        ConnectionLinkType.GROUP -> generalGetString(R.string.connect_via_group_link)
       }
       AlertManager.shared.showAlertMsg(
         title = title,
-        text = generalGetString(R.string.profile_will_be_sent_to_contact_sending_link),
+        text = if (linkType == ConnectionLinkType.GROUP)
+          generalGetString(R.string.you_will_join_group)
+        else
+          generalGetString(R.string.profile_will_be_sent_to_contact_sending_link),
         confirmText = generalGetString(R.string.connect_via_link_verb),
         onConfirm = {
           withApi {
             Log.d(TAG, "connectIfOpenedViaUri: connecting")
-            connectViaUri(chatModel, action, uri)
+            connectViaUri(chatModel, linkType, uri)
           }
         }
       )

apps/android/app/src/main/java/chat/simplex/app/SimplexApp.kt

@@ -11,8 +11,7 @@ import chat.simplex.app.views.onboarding.OnboardingStage
 import chat.simplex.app.views.usersettings.NotificationsMode
 import kotlinx.coroutines.*
 import kotlinx.serialization.decodeFromString
-import java.io.BufferedReader
-import java.io.InputStreamReader
+import java.io.*
 import java.util.*
 import java.util.concurrent.Semaphore
 import java.util.concurrent.TimeUnit
@@ -27,19 +26,26 @@ external fun pipeStdOutToSocket(socketName: String) : Int
 
 // SimpleX API
 typealias ChatCtrl = Long
-external fun chatMigrateInit(dbPath: String, dbKey: String): Array<Any>
+external fun chatMigrateInit(dbPath: String, dbKey: String, confirm: String): Array<Any>
 external fun chatSendCmd(ctrl: ChatCtrl, msg: String): String
 external fun chatRecvMsg(ctrl: ChatCtrl): String
 external fun chatRecvMsgWait(ctrl: ChatCtrl, timeout: Int): String
 external fun chatParseMarkdown(str: String): String
+external fun chatParseServer(str: String): String
+external fun chatPasswordHash(pwd: String, salt: String): String
 
 class SimplexApp: Application(), LifecycleEventObserver {
   lateinit var chatController: ChatController
 
-  fun initChatController(useKey: String? = null, startChat: Boolean = true) {
-    val dbKey = useKey ?: DatabaseUtils.useDatabaseKey() ?: ""
+  var isAppOnForeground: Boolean = false
+
+  val defaultLocale: Locale = Locale.getDefault()
+
+  fun initChatController(useKey: String? = null, confirmMigrations: MigrationConfirmation? = null, startChat: Boolean = true) {
+    val dbKey = useKey ?: DatabaseUtils.useDatabaseKey()
     val dbAbsolutePathPrefix = getFilesDirectory(SimplexApp.context)
-    val migrated: Array<Any> = chatMigrateInit(dbAbsolutePathPrefix, dbKey)
+    val confirm = confirmMigrations ?: if (appPreferences.confirmDBUpgrades.get()) MigrationConfirmation.Error else MigrationConfirmation.YesUp
+    val migrated: Array<Any> = chatMigrateInit(dbAbsolutePathPrefix, dbKey, confirm.value)
     val res: DBMigrationResult = kotlin.runCatching {
       json.decodeFromString<DBMigrationResult>(migrated[0] as String)
     }.getOrElse { DBMigrationResult.Unknown(migrated[0] as String) }
@@ -88,6 +94,7 @@ class SimplexApp: Application(), LifecycleEventObserver {
     context = this
     initChatController()
     ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+    context.getDir("temp", MODE_PRIVATE).deleteRecursively()
   }
 
   override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
@@ -95,14 +102,27 @@ class SimplexApp: Application(), LifecycleEventObserver {
     withApi {
       when (event) {
         Lifecycle.Event.ON_START -> {
+          isAppOnForeground = true
           if (chatModel.chatRunning.value == true) {
             kotlin.runCatching {
-              val chats = chatController.apiGetChats()
-              chatModel.updateChats(chats)
+              val currentUserId = chatModel.currentUser.value?.userId
+              val chats = ArrayList(chatController.apiGetChats())
+              /** Active user can be changed in background while [ChatController.apiGetChats] is executing */
+              if (chatModel.currentUser.value?.userId == currentUserId) {
+                val currentChatId = chatModel.chatId.value
+                val oldStats = if (currentChatId != null) chatModel.getChat(currentChatId)?.chatStats else null
+                if (oldStats != null) {
+                  val indexOfCurrentChat = chats.indexOfFirst { it.id == currentChatId }
+                  /** Pass old chatStats because unreadCounter can be changed already while [ChatController.apiGetChats] is executing */
+                  if (indexOfCurrentChat >= 0) chats[indexOfCurrentChat] = chats[indexOfCurrentChat].copy(chatStats = oldStats)
+                }
+                chatModel.updateChats(chats)
+              }
             }.onFailure { Log.e(TAG, it.stackTraceToString()) }
           }
         }
         Lifecycle.Event.ON_RESUME -> {
+          isAppOnForeground = true
           if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) {
             chatController.showBackgroundServiceNoticeIfNeeded()
           }
@@ -111,10 +131,14 @@ class SimplexApp: Application(), LifecycleEventObserver {
            * after calling [ChatController.showBackgroundServiceNoticeIfNeeded] notification mode in prefs can be changed.
            * It can happen when app was started and a user enables battery optimization while app in background
            * */
-          if (chatModel.chatRunning.value != false && appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name)
+          if (chatModel.chatRunning.value != false &&
+            chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete &&
+            appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name
+          ) {
             SimplexService.start(applicationContext)
+          }
         }
-        else -> {}
+        else -> isAppOnForeground = false
       }
     }
   }
@@ -168,7 +192,18 @@ class SimplexApp: Application(), LifecycleEventObserver {
       val s = Semaphore(0)
       thread(name="stdout/stderr pipe") {
         Log.d(TAG, "starting server")
-        val server = LocalServerSocket(socketName)
+        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()

apps/android/app/src/main/java/chat/simplex/app/SimplexService.kt

@@ -10,7 +10,6 @@ import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import androidx.work.*
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.onboarding.OnboardingStage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -20,7 +19,6 @@ import kotlinx.coroutines.withContext
 
 class SimplexService: Service() {
   private var wakeLock: PowerManager.WakeLock? = null
-  private var isServiceStarted = false
   private var isStartingService = false
   private var notificationManager: NotificationManager? = null
   private var serviceNotification: Notification? = null
@@ -48,11 +46,32 @@ class SimplexService: Service() {
     notificationManager = createNotificationChannel()
     serviceNotification = createNotification(title, text)
     startForeground(SIMPLEX_SERVICE_ID, serviceNotification)
+    /**
+     * The reason [stopAfterStart] exists is because when the service is not called [startForeground] yet, and
+     * we call [stopSelf] on the same service, [ForegroundServiceDidNotStartInTimeException] will be thrown.
+     * To prevent that, we can call [stopSelf] only when the service made [startForeground] call
+     * */
+    if (stopAfterStart) {
+      stopForeground(true)
+      stopSelf()
+    } else {
+      isServiceStarted = true
+    }
   }
 
   override fun onDestroy() {
     Log.d(TAG, "Simplex service destroyed")
-    stopService()
+    try {
+      wakeLock?.let {
+        while (it.isHeld) it.release() // release all, in case acquired more than once
+      }
+      wakeLock = null
+    } catch (e: Exception) {
+      Log.d(TAG, "Exception while releasing wakelock: ${e.message}")
+    }
+    isServiceStarted = false
+    stopAfterStart = false
+    saveServiceState(this, ServiceState.STOPPED)
 
     // If notification service is enabled and battery optimization is disabled, restart the service
     if (SimplexApp.context.allowToStartServiceAfterAppExit())
@@ -62,7 +81,7 @@ class SimplexService: Service() {
 
   private fun startService() {
     Log.d(TAG, "SimplexService startService")
-    if (isServiceStarted || isStartingService) return
+    if (wakeLock != null || isStartingService) return
     val self = this
     isStartingService = true
     withApi {
@@ -73,10 +92,9 @@ class SimplexService: Service() {
         if (chatDbStatus != DBMigrationResult.OK) {
           Log.w(chat.simplex.app.TAG, "SimplexService: problem with the database: $chatDbStatus")
           showPassphraseNotification(chatDbStatus)
-          stopService()
+          safeStopService(self)
           return@withApi
         }
-        isServiceStarted = true
         saveServiceState(self, ServiceState.STARTED)
         wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
           newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
@@ -89,22 +107,6 @@ class SimplexService: Service() {
     }
   }
 
-  private fun stopService() {
-    Log.d(TAG, "Stopping foreground service")
-    try {
-      wakeLock?.let {
-        while (it.isHeld) it.release() // release all, in case acquired more than once
-      }
-      wakeLock = null
-      stopForeground(true)
-      stopSelf()
-    } catch (e: Exception) {
-      Log.d(TAG, "Service stopped without being started: ${e.message}")
-    }
-    isServiceStarted = false
-    saveServiceState(this, ServiceState.STOPPED)
-  }
-
   private fun createNotificationChannel(): NotificationManager? {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -235,6 +237,9 @@ class SimplexService: Service() {
     private const val SHARED_PREFS_SERVICE_STATE = "SIMPLEX_SERVICE_STATE"
     private const val WORK_NAME_ONCE = "ServiceStartWorkerOnce"
 
+    private var isServiceStarted = false
+    private var stopAfterStart = false
+
     fun scheduleStart(context: Context) {
       Log.d(TAG, "Enqueuing work to start subscriber service")
       val workManager = WorkManager.getInstance(context)
@@ -244,7 +249,17 @@ class SimplexService: Service() {
 
     suspend fun start(context: Context) = serviceAction(context, Action.START)
 
-    fun stop(context: Context) = context.stopService(Intent(context, SimplexService::class.java))
+    /**
+     * If there is a need to stop the service, use this function only. It makes sure that the service will be stopped without an
+     * exception related to foreground services lifecycle
+     * */
+    fun safeStopService(context: Context) {
+      if (isServiceStarted) {
+        context.stopService(Intent(context, SimplexService::class.java))
+      } else {
+        stopAfterStart = true
+      }
+    }
 
     private suspend fun serviceAction(context: Context, action: Action) {
       Log.d(TAG, "SimplexService serviceAction: ${action.name}")

apps/android/app/src/main/java/chat/simplex/app/model/NtfManager.kt

@@ -3,9 +3,11 @@ package chat.simplex.app.model
 import android.app.*
 import android.content.*
 import android.graphics.BitmapFactory
+import android.hardware.display.DisplayManager
 import android.media.AudioAttributes
 import android.net.Uri
 import android.util.Log
+import android.view.Display
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import chat.simplex.app.*
@@ -23,12 +25,18 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     const val ShowChatsAction: String = "chat.simplex.app.SHOW_CHATS"
 
     // DO NOT change notification channel settings / names
-    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION"
-    const val LockScreenCallChannel: String = "chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION"
+    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION_1"
     const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
+    const val RejectCallAction: String = "chat.simplex.app.REJECT_CALL"
     const val CallNotificationId: Int = -1
 
+    private const val UserIdKey: String = "userId"
     private const val ChatIdKey: String = "chatId"
+
+    fun getUserIdFromIntent(intent: Intent?): Long? {
+      val userId = intent?.getLongExtra(UserIdKey, -1L)
+      return if (userId == -1L || userId == null) null else userId
+    }
   }
 
   private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -36,25 +44,26 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
   private val msgNtfTimeoutMs = 30000L
 
   init {
-    manager.createNotificationChannel(NotificationChannel(MessageChannel, generalGetString(R.string.ntf_channel_messages), NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(NotificationChannel(LockScreenCallChannel, generalGetString(R.string.ntf_channel_calls_lockscreen), NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(callNotificationChannel())
+    if (manager.areNotificationsEnabled()) createNtfChannelsMaybeShowAlert()
   }
 
   enum class NotificationAction {
     ACCEPT_CONTACT_REQUEST
   }
 
-  private fun callNotificationChannel(): NotificationChannel {
-    val callChannel = NotificationChannel(CallChannel, generalGetString(R.string.ntf_channel_calls), NotificationManager.IMPORTANCE_HIGH)
+  private fun callNotificationChannel(channelId: String, channelName: String): NotificationChannel {
+    val callChannel = NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_HIGH)
     val attrs = AudioAttributes.Builder()
       .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-      .setUsage(AudioAttributes.USAGE_NOTIFICATION)
+      .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
       .build()
     val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
     Log.d(TAG,"callNotificationChannel sound: $soundUri")
     callChannel.setSound(soundUri, attrs)
     callChannel.enableVibration(true)
+    // the numbers below are explained here: https://developer.android.com/reference/android/os/Vibrator
+    // (wait, vibration duration, wait till off, wait till on again = ringtone mp3 duration - vibration duration - ~50ms lost somewhere)
+    callChannel.vibrationPattern = longArrayOf(250, 250, 0, 2600)
     return callChannel
   }
 
@@ -70,8 +79,9 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     }
   }
 
-  fun notifyContactRequestReceived(cInfo: ChatInfo.ContactRequest) {
-    notifyMessageReceived(
+  fun notifyContactRequestReceived(user: User, cInfo: ChatInfo.ContactRequest) {
+    displayNotification(
+      user = user,
       chatId = cInfo.id,
       displayName = cInfo.displayName,
       msgText = generalGetString(R.string.notification_new_contact_request),
@@ -80,21 +90,22 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     )
   }
 
-  fun notifyContactConnected(contact: Contact) {
-    notifyMessageReceived(
+  fun notifyContactConnected(user: User, contact: Contact) {
+    displayNotification(
+      user = user,
       chatId = contact.id,
       displayName = contact.displayName,
       msgText = generalGetString(R.string.notification_contact_connected)
     )
   }
 
-  fun notifyMessageReceived(cInfo: ChatInfo, cItem: ChatItem) {
+  fun notifyMessageReceived(user: User, cInfo: ChatInfo, cItem: ChatItem) {
     if (!cInfo.ntfsEnabled) return
-
-    notifyMessageReceived(chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
+    displayNotification(user = user, chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
   }
 
-  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String, image: String? = null, actions: List<NotificationAction> = emptyList()) {
+  fun displayNotification(user: User, chatId: String, displayName: String, msgText: String, image: String? = null, actions: List<NotificationAction> = emptyList()) {
+    if (!user.showNotifications) return
     Log.d(TAG, "notifyMessageReceived $chatId")
     val now = Clock.System.now().toEpochMilliseconds()
     val recentNotification = (now - prevNtfTime.getOrDefault(chatId, 0) < msgNtfTimeoutMs)
@@ -119,13 +130,14 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
       .setColor(0x88FFFF)
       .setAutoCancel(true)
       .setVibrate(if (actions.isEmpty()) null else longArrayOf(0, 250, 250, 250))
-      .setContentIntent(chatPendingIntent(OpenChatAction, chatId))
+      .setContentIntent(chatPendingIntent(OpenChatAction, user.userId, chatId))
       .setSilent(if (actions.isEmpty()) recentNotification else false)
 
     for (action in actions) {
       val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
       val actionIntent = Intent(SimplexApp.context, NtfActionReceiver::class.java)
       actionIntent.action = action.name
+      actionIntent.putExtra(UserIdKey, user.userId)
       actionIntent.putExtra(ChatIdKey, chatId)
       val actionPendingIntent: PendingIntent = PendingIntent.getBroadcast(SimplexApp.context, 0, actionIntent, flags)
       val actionButton = when (action) {
@@ -140,7 +152,7 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
       .setGroupSummary(true)
-      .setContentIntent(chatPendingIntent(ShowChatsAction))
+      .setContentIntent(chatPendingIntent(ShowChatsAction, null))
       .build()
 
     with(NotificationManagerCompat.from(context)) {
@@ -151,24 +163,34 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
   }
 
   fun notifyCallInvitation(invitation: RcvCallInvitation) {
-    if (isAppOnForeground(context)) return
+    val keyguardManager = getKeyguardManager(context)
+    Log.d(TAG,
+      "notifyCallInvitation pre-requests: " +
+          "keyguard locked ${keyguardManager.isKeyguardLocked}, " +
+          "callOnLockScreen ${appPreferences.callOnLockScreen.get()}, " +
+          "onForeground ${SimplexApp.context.isAppOnForeground}"
+    )
+    if (SimplexApp.context.isAppOnForeground) return
     val contactId = invitation.contact.id
     Log.d(TAG, "notifyCallInvitation $contactId")
-    val keyguardManager = getKeyguardManager(context)
     val image = invitation.contact.image
+    val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+    val screenOff = displayManager.displays.all { it.state != Display.STATE_ON }
     var ntfBuilder =
-      if (keyguardManager.isDeviceLocked && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
+      if ((keyguardManager.isKeyguardLocked || screenOff) && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
         val fullScreenIntent = Intent(context, IncomingCallActivity::class.java)
         val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        NotificationCompat.Builder(context, LockScreenCallChannel)
+        NotificationCompat.Builder(context, CallChannel)
           .setFullScreenIntent(fullScreenPendingIntent, true)
           .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-          .setSilent(true)
       } else {
         val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
+        val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, Intent(), PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
         NotificationCompat.Builder(context, CallChannel)
-          .setContentIntent(chatPendingIntent(OpenChatAction, invitation.contact.id))
-          .addAction(R.drawable.ntf_icon, generalGetString(R.string.accept), chatPendingIntent(AcceptCallAction, contactId))
+          .setContentIntent(chatPendingIntent(OpenChatAction, invitation.user.userId, invitation.contact.id))
+          .addAction(R.drawable.ntf_icon, generalGetString(R.string.accept), chatPendingIntent(AcceptCallAction, invitation.user.userId, contactId))
+          .addAction(R.drawable.ntf_icon, generalGetString(R.string.reject), chatPendingIntent(RejectCallAction, invitation.user.userId, contactId, true))
+          .setFullScreenIntent(fullScreenPendingIntent, true)
           .setSound(soundUri)
       }
     val text = generalGetString(
@@ -197,8 +219,11 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
       .setLargeIcon(largeIcon)
       .setColor(0x88FFFF)
       .setAutoCancel(true)
+    val notification = ntfBuilder.build()
+    // This makes notification sound and vibration repeat endlessly
+    notification.flags = notification.flags or NotificationCompat.FLAG_INSISTENT
     with(NotificationManagerCompat.from(context)) {
-      notify(CallNotificationId, ntfBuilder.build())
+      notify(CallNotificationId, notification)
     }
   }
 
@@ -206,49 +231,80 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     manager.cancel(CallNotificationId)
   }
 
+  fun hasNotificationsForChat(chatId: String): Boolean = manager.activeNotifications.any { it.id == chatId.hashCode() }
+
   private fun hideSecrets(cItem: ChatItem) : String {
     val md = cItem.formattedText
-    return if (md == null) {
-      if (cItem.content.text != "") {
-        cItem.content.text
-      } else {
-        cItem.file?.fileName ?: ""
-      }
-    } else {
+    return if (md != null) {
       var res = ""
       for (ft in md) {
         res += if (ft.format is Format.Secret) "..." else ft.text
       }
       res
+    } else {
+      cItem.text
     }
   }
 
-  private fun chatPendingIntent(intentAction: String, chatId: String? = null): PendingIntent {
+  private fun chatPendingIntent(intentAction: String, userId: Long?, chatId: String? = null, broadcast: Boolean = false): PendingIntent {
     Log.d(TAG, "chatPendingIntent for $intentAction")
     val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
-    var intent = Intent(context, MainActivity::class.java)
+    var intent = Intent(context, if (!broadcast) MainActivity::class.java else NtfActionReceiver::class.java)
       .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
       .setAction(intentAction)
+      .putExtra(UserIdKey, userId)
     if (chatId != null) intent = intent.putExtra(ChatIdKey, chatId)
-    return TaskStackBuilder.create(context).run {
-      addNextIntentWithParentStack(intent)
-      getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
+    return if (!broadcast) {
+      TaskStackBuilder.create(context).run {
+        addNextIntentWithParentStack(intent)
+        getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
+      }
+    } else {
+      PendingIntent.getBroadcast(SimplexApp.context, uniqueInt, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
     }
   }
 
+  /**
+   * This function creates notifications channels. On Android 13+ calling it for the first time will trigger system alert,
+   * The alert asks a user to allow or disallow to show notifications for the app. That's why it should be called only when the user
+   * already saw such alert or when you want to trigger showing the alert.
+   * On the first app launch the channels will be created after user profile is created. Subsequent calls will create new channels and delete
+   * old ones if needed
+   * */
+  fun createNtfChannelsMaybeShowAlert() {
+    manager.createNotificationChannel(NotificationChannel(MessageChannel, generalGetString(R.string.ntf_channel_messages), NotificationManager.IMPORTANCE_HIGH))
+    manager.createNotificationChannel(callNotificationChannel(CallChannel, generalGetString(R.string.ntf_channel_calls)))
+    // Remove old channels since they can't be edited
+    manager.deleteNotificationChannel("chat.simplex.app.CALL_NOTIFICATION")
+    manager.deleteNotificationChannel("chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION")
+  }
+
   /**
    * Processes every action specified by [NotificationCompat.Builder.addAction] that comes with [NotificationAction]
    * and [ChatInfo.id] as [ChatIdKey] in extra
    * */
   class NtfActionReceiver: BroadcastReceiver() {
     override fun onReceive(context: Context?, intent: Intent?) {
+      val userId = getUserIdFromIntent(intent)
       val chatId = intent?.getStringExtra(ChatIdKey) ?: return
-      val cInfo = SimplexApp.context.chatModel.getChat(chatId)?.chatInfo
+      val m = SimplexApp.context.chatModel
       when (intent.action) {
         NotificationAction.ACCEPT_CONTACT_REQUEST.name -> {
-          if (cInfo !is ChatInfo.ContactRequest) return
-          acceptContactRequest(cInfo, SimplexApp.context.chatModel)
-          SimplexApp.context.chatModel.controller.ntfManager.cancelNotificationsForChat(chatId)
+          val isCurrentUser = m.currentUser.value?.userId == userId
+          val cInfo: ChatInfo.ContactRequest? = if (isCurrentUser) {
+            (m.getChat(chatId)?.chatInfo as? ChatInfo.ContactRequest) ?: return
+          } else {
+            null
+          }
+          val apiId = chatId.replace("<@", "").toLongOrNull() ?: return
+          acceptContactRequest(apiId, cInfo, isCurrentUser, m)
+          m.controller.ntfManager.cancelNotificationsForChat(chatId)
+        }
+        RejectCallAction -> {
+          val invitation = m.callInvitations[chatId]
+          if (invitation != null) {
+            m.callManager.endCall(invitation = invitation)
+          }
         }
         else -> {
           Log.e(TAG, "Unknown action. Make sure you provide action from NotificationAction enum")

apps/android/app/src/main/java/chat/simplex/app/ui/theme/Theme.kt

@@ -17,6 +17,7 @@ enum class DefaultTheme {
 val DEFAULT_PADDING = 16.dp
 val DEFAULT_SPACE_AFTER_ICON = 4.dp
 val DEFAULT_PADDING_HALF = DEFAULT_PADDING / 2
+val DEFAULT_BOTTOM_PADDING = 48.dp
 
 val DarkColorPalette = darkColors(
   primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files

apps/android/app/src/main/java/chat/simplex/app/views/TerminalView.kt

@@ -1,101 +1,40 @@
 package chat.simplex.app.views
 
-import android.content.Context
 import android.content.res.Configuration
-import android.os.SystemClock
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Lock
 import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.fragment.app.FragmentActivity
-import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.*
 import chat.simplex.app.views.helpers.*
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
 
-private val lastSuccessfulAuth: MutableState<Long?> = mutableStateOf(null)
-
 @Composable
 fun TerminalView(chatModel: ChatModel, close: () -> Unit) {
   val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) }
-  val lastSuccessfulAuth = remember { lastSuccessfulAuth }
   BackHandler(onBack = {
-    lastSuccessfulAuth.value = null
     close()
   })
-  val authorized = remember { !chatModel.controller.appPrefs.performLA.get() }
-  val context = LocalContext.current
-  LaunchedEffect(lastSuccessfulAuth.value) {
-    if (!authorized && !authorizedPreviously(lastSuccessfulAuth)) {
-      runAuth(lastSuccessfulAuth, context)
-    }
-  }
-  if (authorized || authorizedPreviously(lastSuccessfulAuth)) {
-    LaunchedEffect(Unit) {
-      // Update auth each time user visits this screen in authenticated state just to prolong authorized time
-      lastSuccessfulAuth.value = SystemClock.elapsedRealtime()
-    }
     TerminalLayout(
-      chatModel.terminalItems,
+      remember { chatModel.terminalItems },
       composeState,
       sendCommand = { sendCommand(chatModel, composeState) },
       close
     )
-  } else {
-    Surface(Modifier.fillMaxSize()) {
-      Column(Modifier.background(MaterialTheme.colors.background)) {
-        CloseSheetBar(close)
-        Box(
-          Modifier.fillMaxSize(),
-          contentAlignment = Alignment.Center
-        ) {
-          SimpleButton(
-            stringResource(R.string.auth_unlock),
-            icon = Icons.Outlined.Lock,
-            click = {
-              runAuth(lastSuccessfulAuth, context)
-            }
-          )
-        }
-      }
-    }
-  }
-}
-
-private fun authorizedPreviously(lastSuccessfulAuth: State<Long?>): Boolean =
-  lastSuccessfulAuth.value?.let { SystemClock.elapsedRealtime() - it < 30_000 } ?: false
-
-private fun runAuth(lastSuccessfulAuth: MutableState<Long?>, context: Context) {
-  authenticate(
-    generalGetString(R.string.auth_open_chat_console),
-    generalGetString(R.string.auth_log_in_using_credential),
-    context as FragmentActivity,
-    completed = { laResult ->
-      lastSuccessfulAuth.value = when (laResult) {
-        LAResult.Success, LAResult.Unavailable -> SystemClock.elapsedRealtime()
-        is LAResult.Error, LAResult.Failed -> null
-      }
-    }
-  )
 }
 
 private fun sendCommand(chatModel: ChatModel, composeState: MutableState<ComposeState>) {
@@ -103,9 +42,9 @@ private fun sendCommand(chatModel: ChatModel, composeState: MutableState<Compose
   val prefPerformLA = chatModel.controller.appPrefs.performLA.get()
   val s = composeState.value.message
   if (s.startsWith("/sql") && (!prefPerformLA || !developerTools)) {
-    val resp = CR.ChatCmdError(ChatError.ChatErrorChat(ChatErrorType.СommandError("Failed reading: empty")))
-    chatModel.terminalItems.add(TerminalItem.cmd(CC.Console(s)))
-    chatModel.terminalItems.add(TerminalItem.resp(resp))
+    val resp = CR.ChatCmdError(null, ChatError.ChatErrorChat(ChatErrorType.СommandError("Failed reading: empty")))
+    chatModel.addTerminalItem(TerminalItem.cmd(CC.Console(s)))
+    chatModel.addTerminalItem(TerminalItem.resp(resp))
     composeState.value = ComposeState(useLinkPreviews = false)
   } else {
     withApi {
@@ -136,7 +75,23 @@ fun TerminalLayout(
       topBar = { CloseSheetBar(close) },
       bottomBar = {
         Box(Modifier.padding(horizontal = 8.dp)) {
-          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
+          SendMsgView(
+            composeState = composeState,
+            showVoiceRecordIcon = false,
+            recState = remember { mutableStateOf(RecordingState.NotStarted) },
+            isDirectChat = false,
+            liveMessageAlertShown = SharedPreference(get = { false }, set = {}),
+            needToAllowVoiceToContact = false,
+            allowedVoiceByPrefs = false,
+            userIsObserver = false,
+            userCanSend = true,
+            allowVoiceToContact = {},
+            sendMessage = sendCommand,
+            sendLiveMessage = null,
+            updateLiveMessage = null,
+            onMessageChange = ::onMessageChange,
+            textStyle = textStyle
+          )
         }
       },
       modifier = Modifier.navigationBarsWithImePadding()
@@ -161,19 +116,21 @@ fun TerminalLog(terminalItems: List<TerminalItem>) {
   DisposableEffect(Unit) {
     onDispose { lazyListState = listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
   }
-  val reversedTerminalItems by remember { derivedStateOf { terminalItems.reversed() } }
+  val reversedTerminalItems by remember { derivedStateOf { terminalItems.reversed().toList() } }
+  val context = LocalContext.current
   LazyColumn(state = listState, reverseLayout = true) {
     items(reversedTerminalItems) { item ->
-      Text("${item.date.toString().subSequence(11, 19)} ${item.label}",
+      Text(
+        "${item.date.toString().subSequence(11, 19)} ${item.label}",
         style = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 18.sp, color = MaterialTheme.colors.primary),
         maxLines = 1,
         overflow = TextOverflow.Ellipsis,
         modifier = Modifier
           .fillMaxWidth()
           .clickable {
-            ModalManager.shared.showModal {
+            ModalManager.shared.showModal(endButtons = { ShareButton { shareText(context, item.details) } }) {
               SelectionContainer(modifier = Modifier.verticalScroll(rememberScrollState())) {
-                Text(item.details)
+                Text(item.details, modifier = Modifier.padding(horizontal = DEFAULT_PADDING).padding(bottom = DEFAULT_PADDING))
               }
             }
           }.padding(horizontal = 8.dp, vertical = 4.dp)

apps/android/app/src/main/java/chat/simplex/app/views/WelcomeView.kt

@@ -21,8 +21,8 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.SimplexService
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.model.Profile
 import chat.simplex.app.ui.theme.*
@@ -38,7 +38,7 @@ fun isValidDisplayName(name: String) : Boolean {
 }
 
 @Composable
-fun CreateProfilePanel(chatModel: ChatModel) {
+fun CreateProfilePanel(chatModel: ChatModel, close: () -> Unit) {
   val displayName = remember { mutableStateOf("") }
   val fullName = remember { mutableStateOf("") }
   val focusRequester = remember { FocusRequester() }
@@ -72,10 +72,12 @@ fun CreateProfilePanel(chatModel: ChatModel) {
       ProfileNameField(fullName)
       Spacer(Modifier.fillMaxHeight().weight(1f))
       Row {
-        SimpleButton(
-          text = stringResource(R.string.about_simplex),
-          icon = Icons.Outlined.ArrowBackIosNew
-        ) { chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo }
+        if (chatModel.users.isEmpty()) {
+          SimpleButton(
+            text = stringResource(R.string.about_simplex),
+            icon = Icons.Outlined.ArrowBackIosNew
+          ) { chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo }
+        }
 
         Spacer(Modifier.fillMaxWidth().weight(1f))
 
@@ -83,7 +85,7 @@ fun CreateProfilePanel(chatModel: ChatModel) {
         val createModifier: Modifier
         val createColor: Color
         if (enabled) {
-          createModifier = Modifier.clickable { createProfile(chatModel, displayName.value, fullName.value) }.padding(8.dp)
+          createModifier = Modifier.clickable { createProfile(chatModel, displayName.value, fullName.value, close) }.padding(8.dp)
           createColor = MaterialTheme.colors.primary
         } else {
           createModifier = Modifier.padding(8.dp)
@@ -105,15 +107,23 @@ fun CreateProfilePanel(chatModel: ChatModel) {
   }
 }
 
-fun createProfile(chatModel: ChatModel, displayName: String, fullName: String) {
+fun createProfile(chatModel: ChatModel, displayName: String, fullName: String, close: () -> Unit) {
   withApi {
     val user = chatModel.controller.apiCreateActiveUser(
       Profile(displayName, fullName, null)
-    )
-    chatModel.controller.startChat(user)
-    chatModel.controller.showBackgroundServiceNoticeIfNeeded()
-    SimplexService.start(chatModel.controller.appContext)
-    chatModel.onboardingStage.value = OnboardingStage.OnboardingComplete
+    ) ?: return@withApi
+    chatModel.currentUser.value = user
+    if (chatModel.users.isEmpty()) {
+      chatModel.controller.startChat(user)
+      chatModel.onboardingStage.value = OnboardingStage.Step3_SetNotificationsMode
+      SimplexApp.context.chatModel.controller.ntfManager.createNtfChannelsMaybeShowAlert()
+    } else {
+      val users = chatModel.controller.listUsers()
+      chatModel.users.clear()
+      chatModel.users.addAll(users)
+      chatModel.controller.getUserChatData()
+      close()
+    }
   }
 }
 

apps/android/app/src/main/java/chat/simplex/app/views/call/CallManager.kt

@@ -13,12 +13,14 @@ class CallManager(val chatModel: ChatModel) {
     Log.d(TAG, "CallManager.reportNewIncomingCall")
     with (chatModel) {
       callInvitations[invitation.contact.id] = invitation
-      if (Clock.System.now() - invitation.callTs <= 3.minutes) {
-        activeCallInvitation.value = invitation
-        controller.ntfManager.notifyCallInvitation(invitation)
-      } else {
-        val contact = invitation.contact
-        controller.ntfManager.notifyMessageReceived(chatId = contact.id, displayName = contact.displayName, msgText = invitation.callTypeText)
+      if (invitation.user.showNotifications) {
+        if (Clock.System.now() - invitation.callTs <= 3.minutes) {
+          activeCallInvitation.value = invitation
+          controller.ntfManager.notifyCallInvitation(invitation)
+        } else {
+          val contact = invitation.contact
+          controller.ntfManager.displayNotification(user = invitation.user, chatId = contact.id, displayName = contact.displayName, msgText = invitation.callTypeText)
+        }
       }
     }
   }

apps/android/app/src/main/java/chat/simplex/app/views/call/CallView.kt

@@ -3,11 +3,12 @@ package chat.simplex.app.views.call
 import android.Manifest
 import android.annotation.SuppressLint
 import android.app.Activity
-import android.content.Context
+import android.content.*
 import android.content.pm.ActivityInfo
-import android.media.AudioDeviceInfo
-import android.media.AudioManager
+import android.media.*
 import android.os.Build
+import android.os.PowerManager
+import android.os.PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK
 import android.util.Log
 import android.view.ViewGroup
 import android.webkit.*
@@ -19,6 +20,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
 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
@@ -37,13 +39,12 @@ import androidx.webkit.WebViewClientCompat
 import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.ProfileImage
 import chat.simplex.app.views.helpers.withApi
 import chat.simplex.app.views.usersettings.NotificationsMode
 import com.google.accompanist.permissions.rememberMultiplePermissionsState
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.*
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 
@@ -54,6 +55,7 @@ fun ActiveCallView(chatModel: ChatModel) {
     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.name }
   LaunchedEffect(Unit) {
     // Start service when call happening since it's not already started.
@@ -61,17 +63,48 @@ fun ActiveCallView(chatModel: ChatModel) {
     if (!ntfModeService) SimplexService.start(SimplexApp.context)
   }
   DisposableEffect(Unit) {
-    onDispose {
-      // Stop it when call ended
-      if (!ntfModeService) SimplexService.stop(SimplexApp.context)
-      // Clear selected communication device to default value after we changed it in call
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-        val am = SimplexApp.context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-        am.clearCommunicationDevice()
+    val am = SimplexApp.context.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 = (SimplexApp.context.getSystemService(Context.POWER_SERVICE) as PowerManager)
+    val proximityLock = if (pm.isWakeLockLevelSupported(PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+      pm.newWakeLock(PROXIMITY_SCREEN_OFF_WAKE_LOCK, SimplexApp.context.packageName + ":proximityLock")
+    } else {
+      null
+    }
+    proximityLock?.acquire()
+    onDispose {
+      // Stop it when call ended
+      if (!ntfModeService) SimplexService.safeStopService(SimplexApp.context)
+      dropAudioManagerOverrides()
+      am.unregisterAudioDeviceCallback(audioCallback)
+      proximityLock?.release()
+    }
   }
-  val cxt = LocalContext.current
   val scope = rememberCoroutineScope()
   Box(Modifier.fillMaxSize()) {
     WebRTCView(chatModel.callCommand) { apiMsg ->
@@ -101,6 +134,7 @@ fun ActiveCallView(chatModel: ChatModel) {
               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) {
@@ -109,8 +143,7 @@ fun ActiveCallView(chatModel: ChatModel) {
           is WCallResponse.Connected -> {
             chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo)
             scope.launch {
-              delay(2000L)
-              setCallSound(cxt, call)
+              setCallSound(call.soundSpeaker, audioViaBluetooth)
             }
           }
           is WCallResponse.Ended -> {
@@ -144,15 +177,18 @@ fun ActiveCallView(chatModel: ChatModel) {
       }
     }
     val call = chatModel.activeCall.value
-    if (call != null)  ActiveCallOverlay(call, chatModel)
+    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
     onDispose {
+      activity.volumeControlStream = prevVolumeControlStream
       // Unlock orientation
       activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
     }
@@ -160,10 +196,10 @@ fun ActiveCallView(chatModel: ChatModel) {
 }
 
 @Composable
-private fun ActiveCallOverlay(call: Call, chatModel: ChatModel) {
-  var cxt = LocalContext.current
+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) },
@@ -172,38 +208,55 @@ private fun ActiveCallOverlay(call: Call, chatModel: ChatModel) {
       if (call != null) {
         call = call.copy(soundSpeaker = !call.soundSpeaker)
         chatModel.activeCall.value = call
-        setCallSound(cxt, call)
+        setCallSound(call.soundSpeaker, audioViaBluetooth)
       }
     },
     flipCamera = { chatModel.callCommand.value = WCallCommand.Camera(call.localCamera.flipped) }
   )
 }
 
-private fun setCallSound(cxt: Context, call: Call) {
-  Log.d(TAG, "setCallSound: set audio mode")
-  val am = cxt.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-  if (call.soundSpeaker) {
-    am.mode = AudioManager.MODE_NORMAL
-    am.isSpeakerphoneOn = true
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      am.availableCommunicationDevices.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_SPEAKER }?.let {
+private fun setCallSound(speaker: Boolean, audioViaBluetooth: MutableState<Boolean>) {
+  val am = SimplexApp.context.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 {
-    am.mode = AudioManager.MODE_IN_CALL
-    am.isSpeakerphoneOn = false
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      am.availableCommunicationDevices.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_EARPIECE }?.let {
-        am.setCommunicationDevice(it)
-      }
+    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 = SimplexApp.context.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,
@@ -241,7 +294,7 @@ private fun ActiveCallOverlayLayout(
           CallInfoView(call, alignment = Alignment.CenterHorizontally)
         }
         Spacer(Modifier.fillMaxHeight().weight(1f))
-        Box(Modifier.fillMaxWidth().padding(bottom = 48.dp), contentAlignment = Alignment.CenterStart) {
+        Box(Modifier.fillMaxWidth().padding(bottom = DEFAULT_BOTTOM_PADDING), contentAlignment = Alignment.CenterStart) {
           Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
             IconButton(onClick = dismiss) {
               Icon(Icons.Filled.CallEnd, stringResource(R.string.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
@@ -252,7 +305,7 @@ private fun ActiveCallOverlayLayout(
           }
           Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
             Box(Modifier.padding(end = 32.dp)) {
-              ToggleSoundButton(call, toggleSound)
+              ToggleSoundButton(call, speakerCanBeEnabled, toggleSound)
             }
           }
         }
@@ -262,10 +315,10 @@ private fun ActiveCallOverlayLayout(
 }
 
 @Composable
-private fun ControlButton(call: Call, icon: ImageVector, @StringRes iconText: Int, action: () -> Unit) {
+private fun ControlButton(call: Call, icon: ImageVector, @StringRes iconText: Int, action: () -> Unit, enabled: Boolean = true) {
   if (call.hasMedia) {
-    IconButton(onClick = action) {
-      Icon(icon, stringResource(iconText), tint = Color(0xFFFFFFD8), modifier = Modifier.size(40.dp))
+    IconButton(onClick = action, enabled = enabled) {
+      Icon(icon, stringResource(iconText), tint = if (enabled) Color(0xFFFFFFD8) else HighOrLowlight, modifier = Modifier.size(40.dp))
     }
   } else {
     Spacer(Modifier.size(40.dp))
@@ -282,11 +335,11 @@ private fun ToggleAudioButton(call: Call, toggleAudio: () -> Unit) {
 }
 
 @Composable
-private fun ToggleSoundButton(call: Call, toggleSound: () -> Unit) {
+private fun ToggleSoundButton(call: Call, enabled: Boolean, toggleSound: () -> Unit) {
   if (call.soundSpeaker) {
-    ControlButton(call, Icons.Outlined.VolumeUp, R.string.icon_descr_speaker_off, toggleSound)
+    ControlButton(call, Icons.Outlined.VolumeUp, R.string.icon_descr_speaker_off, toggleSound, enabled)
   } else {
-    ControlButton(call, Icons.Outlined.VolumeDown, R.string.icon_descr_speaker_on, toggleSound)
+    ControlButton(call, Icons.Outlined.VolumeDown, R.string.icon_descr_speaker_on, toggleSound, enabled)
   }
 }
 
@@ -298,10 +351,10 @@ fun CallInfoView(call: Call, alignment: Alignment.Horizontal) {
     InfoText(call.contact.chatViewName, style = MaterialTheme.typography.h2)
     InfoText(call.callState.text)
 
-    val connInfo =
-      if (call.connectionInfo == null) ""
-      else " (${call.connectionInfo.text})"
-    InfoText(call.encryptionStatus + connInfo)
+    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)
   }
 }
 
@@ -357,6 +410,7 @@ fun CallInfoView(call: Call, alignment: Alignment.Horizontal) {
 
 @Composable
 fun WebRTCView(callCommand: MutableState<WCallCommand?>, onResponse: (WVAPIMessage) -> Unit) {
+  val scope = rememberCoroutineScope()
   val webView = remember { mutableStateOf<WebView?>(null) }
   val permissionsState = rememberMultiplePermissionsState(
     permissions = listOf(
@@ -435,7 +489,7 @@ fun WebRTCView(callCommand: MutableState<WCallCommand?>, onResponse: (WVAPIMessa
         Log.d(TAG, "WebRTCView: webview ready")
         // for debugging
         // wv.evaluateJavascript("sendMessageToNative = ({resp}) => WebRTCInterface.postMessage(JSON.stringify({command: resp}))", null)
-        withApi {
+        scope.launch {
           delay(2000L)
           wv.evaluateJavascript("sendMessageToNative = (msg) => WebRTCInterface.postMessage(JSON.stringify(msg))", null)
           webView.value = wv
@@ -480,8 +534,12 @@ fun PreviewActiveCallOverlayVideo() {
         callState = CallState.Negotiated,
         localMedia = CallMediaType.Video,
         peerMedia = CallMediaType.Video,
-        connectionInfo = ConnectionInfo(RTCIceCandidate(RTCIceCandidateType.Host), RTCIceCandidate(RTCIceCandidateType.Host))
+        connectionInfo = ConnectionInfo(
+          RTCIceCandidate(RTCIceCandidateType.Host, "tcp", null),
+          RTCIceCandidate(RTCIceCandidateType.Host, "tcp", null)
+        )
       ),
+      speakerCanBeEnabled = true,
       dismiss = {},
       toggleAudio = {},
       toggleVideo = {},
@@ -501,8 +559,12 @@ fun PreviewActiveCallOverlayAudio() {
         callState = CallState.Negotiated,
         localMedia = CallMediaType.Audio,
         peerMedia = CallMediaType.Audio,
-        connectionInfo = ConnectionInfo(RTCIceCandidate(RTCIceCandidateType.Host), RTCIceCandidate(RTCIceCandidateType.Host))
+        connectionInfo = ConnectionInfo(
+          RTCIceCandidate(RTCIceCandidateType.Host, "udp", null),
+          RTCIceCandidate(RTCIceCandidateType.Host, "udp", null)
+        )
       ),
+      speakerCanBeEnabled = true,
       dismiss = {},
       toggleAudio = {},
       toggleVideo = {},

apps/android/app/src/main/java/chat/simplex/app/views/call/IncomingCallActivity.kt

@@ -1,5 +1,6 @@
 package chat.simplex.app.views.call
 
+import android.app.Activity
 import android.app.KeyguardManager
 import android.content.Context
 import android.content.Intent
@@ -43,8 +44,7 @@ class IncomingCallActivity: ComponentActivity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    val activity = this
-    setContent { IncomingCallActivityView(vm.chatModel, activity) }
+    setContent { IncomingCallActivityView(vm.chatModel) }
     unlockForIncomingCall()
   }
 
@@ -83,11 +83,12 @@ fun getKeyguardManager(context: Context): KeyguardManager =
   context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
 
 @Composable
-fun IncomingCallActivityView(m: ChatModel, activity: IncomingCallActivity) {
+fun IncomingCallActivityView(m: ChatModel) {
   val switchingCall = m.switchingCall.value
   val invitation = m.activeCallInvitation.value
   val call = m.activeCall.value
   val showCallView = m.showCallView.value
+  val activity = LocalContext.current as Activity
   LaunchedEffect(invitation, call, switchingCall, showCallView) {
     if (!switchingCall && invitation == null && (!showCallView || call == null)) {
       Log.d(TAG, "IncomingCallActivityView: finishing activity")
@@ -105,36 +106,43 @@ fun IncomingCallActivityView(m: ChatModel, activity: IncomingCallActivity) {
           if (invitation != null) IncomingCallAlertView(invitation, m)
         }
       } else if (invitation != null) {
-        IncomingCallLockScreenAlert(invitation, m, activity)
+        IncomingCallLockScreenAlert(invitation, m)
       }
     }
   }
 }
 
 @Composable
-fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatModel, activity: IncomingCallActivity) {
+fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatModel) {
   val cm = chatModel.callManager
-  val cxt = LocalContext.current
-  val scope = rememberCoroutineScope()
-  var callOnLockScreen by remember { mutableStateOf(chatModel.controller.appPrefs.callOnLockScreen.get()) }
-  LaunchedEffect(true) { SoundPlayer.shared.start(cxt, scope, sound = true) }
-  DisposableEffect(true) { onDispose { SoundPlayer.shared.stop() } }
+  val callOnLockScreen by remember { mutableStateOf(chatModel.controller.appPrefs.callOnLockScreen.get()) }
+  val context = LocalContext.current
+  DisposableEffect(Unit) {
+    onDispose {
+      // Cancel notification whatever happens next since otherwise sound from notification and from inside the app can co-exist
+      chatModel.controller.ntfManager.cancelCallNotification()
+    }
+  }
   IncomingCallLockScreenAlertLayout(
     invitation,
     callOnLockScreen,
+    chatModel,
     rejectCall = { cm.endCall(invitation = invitation) },
-    ignoreCall = { chatModel.activeCallInvitation.value = null },
+    ignoreCall = {
+      chatModel.activeCallInvitation.value = null
+      chatModel.controller.ntfManager.cancelCallNotification()
+    },
     acceptCall = { cm.acceptIncomingCall(invitation = invitation) },
     openApp = {
-      SoundPlayer.shared.stop()
-      var intent = Intent(activity, MainActivity::class.java)
+      val intent = Intent(context, MainActivity::class.java)
         .setAction(OpenChatAction)
+        .putExtra("userId", invitation.user.userId)
         .putExtra("chatId", invitation.contact.id)
-      activity.startActivity(intent)
-      activity.finish()
+      context.startActivity(intent)
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-        getKeyguardManager(activity).requestDismissKeyguard(activity, null)
+        getKeyguardManager(context).requestDismissKeyguard((context as Activity), null)
       }
+      (context as Activity).finish()
     }
   )
 }
@@ -143,6 +151,7 @@ fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatMo
 fun IncomingCallLockScreenAlertLayout(
   invitation: RcvCallInvitation,
   callOnLockScreen: CallOnLockScreen?,
+  chatModel: ChatModel,
   rejectCall: () -> Unit,
   ignoreCall: () -> Unit,
   acceptCall: () -> Unit,
@@ -154,7 +163,7 @@ fun IncomingCallLockScreenAlertLayout(
       .fillMaxSize(),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    IncomingCallInfo(invitation)
+    IncomingCallInfo(invitation, chatModel)
     Spacer(Modifier.fillMaxHeight().weight(1f))
     if (callOnLockScreen == CallOnLockScreen.ACCEPT) {
       ProfileImage(size = 192.dp, image = invitation.contact.profile.image)
@@ -211,12 +220,14 @@ fun PreviewIncomingCallLockScreenAlert() {
         .fillMaxSize()) {
       IncomingCallLockScreenAlertLayout(
         invitation = RcvCallInvitation(
+          user = User.sampleData,
           contact = Contact.sampleData,
           callType = CallType(media = CallMediaType.Audio, capabilities = CallCapabilities(encryption = false)),
           sharedKey = null,
           callTs = Clock.System.now()
         ),
         callOnLockScreen = null,
+        chatModel = SimplexApp.context.chatModel,
         rejectCall = {},
         ignoreCall = {},
         acceptCall = {},

apps/android/app/src/main/java/chat/simplex/app/views/call/IncomingCallAlertView.kt

@@ -17,9 +17,10 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.model.Contact
+import chat.simplex.app.SimplexApp
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.ProfileImage
 import chat.simplex.app.views.usersettings.ProfilePreview
 import kotlinx.datetime.Clock
 
@@ -32,8 +33,12 @@ fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
   DisposableEffect(true) { onDispose { SoundPlayer.shared.stop() } }
   IncomingCallAlertLayout(
     invitation,
+    chatModel,
     rejectCall = { cm.endCall(invitation = invitation) },
-    ignoreCall = { chatModel.activeCallInvitation.value = null },
+    ignoreCall = {
+      chatModel.activeCallInvitation.value = null
+      chatModel.controller.ntfManager.cancelCallNotification()
+    },
     acceptCall = { cm.acceptIncomingCall(invitation = invitation) }
   )
 }
@@ -41,13 +46,14 @@ fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
 @Composable
 fun IncomingCallAlertLayout(
   invitation: RcvCallInvitation,
+  chatModel: ChatModel,
   rejectCall: () -> Unit,
   ignoreCall: () -> Unit,
   acceptCall: () -> Unit
 ) {
   val color = if (isInDarkTheme()) IncomingCallDark else IncomingCallLight
   Column(Modifier.fillMaxWidth().background(color).padding(top = 16.dp, bottom = 16.dp, start = 16.dp, end = 8.dp)) {
-    IncomingCallInfo(invitation)
+    IncomingCallInfo(invitation, chatModel)
     Spacer(Modifier.height(8.dp))
     Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.SpaceBetween) {
       Row(Modifier.fillMaxWidth().weight(1f), verticalAlignment = Alignment.CenterVertically) {
@@ -63,9 +69,13 @@ fun IncomingCallAlertLayout(
 }
 
 @Composable
-fun IncomingCallInfo(invitation: RcvCallInvitation) {
+fun IncomingCallInfo(invitation: RcvCallInvitation, chatModel: ChatModel) {
   @Composable fun CallIcon(icon: ImageVector, descr: String) = Icon(icon, descr, tint = SimplexGreen)
-  Row {
+  Row(verticalAlignment = Alignment.CenterVertically) {
+    if (chatModel.users.size > 1) {
+      ProfileImage(size = 32.dp, image = invitation.user.profile.image, color = MaterialTheme.colors.secondary)
+      Spacer(Modifier.width(4.dp))
+    }
     if (invitation.callType.media == CallMediaType.Video) CallIcon(Icons.Filled.Videocam, stringResource(R.string.icon_descr_video_call))
     else CallIcon(Icons.Filled.Phone, stringResource(R.string.icon_descr_audio_call))
     Spacer(Modifier.width(4.dp))
@@ -98,11 +108,13 @@ fun PreviewIncomingCallAlertLayout() {
   SimpleXTheme {
     IncomingCallAlertLayout(
       invitation = RcvCallInvitation(
+        user = User.sampleData,
         contact = Contact.sampleData,
         callType = CallType(media = CallMediaType.Audio, capabilities = CallCapabilities(encryption = false)),
         sharedKey = null,
         callTs = Clock.System.now()
       ),
+      chatModel = SimplexApp.context.chatModel,
       rejectCall = {},
       ignoreCall = {},
       acceptCall = {}

apps/android/app/src/main/java/chat/simplex/app/views/call/WebRTC.kt

@@ -1,15 +1,19 @@
 package chat.simplex.app.views.call
 
+import android.util.Log
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
-import chat.simplex.app.R
-import chat.simplex.app.SimplexApp
+import androidx.compose.ui.text.toUpperCase
+import chat.simplex.app.*
 import chat.simplex.app.model.Contact
+import chat.simplex.app.model.User
 import chat.simplex.app.views.helpers.generalGetString
 import kotlinx.datetime.Instant
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import java.net.URI
+import java.util.*
+import kotlin.collections.ArrayList
 
 data class Call(
   val contact: Contact,
@@ -61,39 +65,39 @@ enum class CallState {
   }
 }
 
-@Serializable class WVAPICall(val corrId: Int? = null, val command: WCallCommand)
-@Serializable class WVAPIMessage(val corrId: Int? = null, val resp: WCallResponse, val command: WCallCommand? = null)
+@Serializable data class WVAPICall(val corrId: Int? = null, val command: WCallCommand)
+@Serializable data class WVAPIMessage(val corrId: Int? = null, val resp: WCallResponse, val command: WCallCommand? = null)
 
 @Serializable
 sealed class WCallCommand {
   @Serializable @SerialName("capabilities") object Capabilities: WCallCommand()
-  @Serializable @SerialName("start") class Start(val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
-  @Serializable @SerialName("offer") class Offer(val offer: String, val iceCandidates: String, val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
-  @Serializable @SerialName("answer") class Answer (val answer: String, val iceCandidates: String): WCallCommand()
-  @Serializable @SerialName("ice") class Ice(val iceCandidates: String): WCallCommand()
-  @Serializable @SerialName("media") class Media(val media: CallMediaType, val enable: Boolean): WCallCommand()
-  @Serializable @SerialName("camera") class Camera(val camera: VideoCamera): WCallCommand()
+  @Serializable @SerialName("start") data class Start(val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
+  @Serializable @SerialName("offer") data class Offer(val offer: String, val iceCandidates: String, val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
+  @Serializable @SerialName("answer") data class Answer (val answer: String, val iceCandidates: String): WCallCommand()
+  @Serializable @SerialName("ice") data class Ice(val iceCandidates: String): WCallCommand()
+  @Serializable @SerialName("media") data class Media(val media: CallMediaType, val enable: Boolean): WCallCommand()
+  @Serializable @SerialName("camera") data class Camera(val camera: VideoCamera): WCallCommand()
   @Serializable @SerialName("end") object End: WCallCommand()
 }
 
 @Serializable
 sealed class WCallResponse {
-  @Serializable @SerialName("capabilities") class Capabilities(val capabilities: CallCapabilities): WCallResponse()
-  @Serializable @SerialName("offer") class Offer(val offer: String, val iceCandidates: String, val capabilities: CallCapabilities): WCallResponse()
-  @Serializable @SerialName("answer") class Answer(val answer: String, val iceCandidates: String): WCallResponse()
-  @Serializable @SerialName("ice") class Ice(val iceCandidates: String): WCallResponse()
-  @Serializable @SerialName("connection") class Connection(val state: ConnectionState): WCallResponse()
-  @Serializable @SerialName("connected") class Connected(val connectionInfo: ConnectionInfo): WCallResponse()
+  @Serializable @SerialName("capabilities") data class Capabilities(val capabilities: CallCapabilities): WCallResponse()
+  @Serializable @SerialName("offer") data class Offer(val offer: String, val iceCandidates: String, val capabilities: CallCapabilities): WCallResponse()
+  @Serializable @SerialName("answer") data class Answer(val answer: String, val iceCandidates: String): WCallResponse()
+  @Serializable @SerialName("ice") data class Ice(val iceCandidates: String): WCallResponse()
+  @Serializable @SerialName("connection") data class Connection(val state: ConnectionState): WCallResponse()
+  @Serializable @SerialName("connected") data class Connected(val connectionInfo: ConnectionInfo): WCallResponse()
   @Serializable @SerialName("ended") object Ended: WCallResponse()
   @Serializable @SerialName("ok") object Ok: WCallResponse()
-  @Serializable @SerialName("error") class Error(val message: String): WCallResponse()
+  @Serializable @SerialName("error") data class Error(val message: String): WCallResponse()
 }
 
-@Serializable class WebRTCCallOffer(val callType: CallType, val rtcSession: WebRTCSession)
-@Serializable class WebRTCSession(val rtcSession: String, val rtcIceCandidates: String)
-@Serializable class WebRTCExtraInfo(val rtcIceCandidates: String)
-@Serializable class CallType(val media: CallMediaType, val capabilities: CallCapabilities)
-@Serializable class RcvCallInvitation(val contact: Contact, val callType: CallType, val sharedKey: String? = null, val callTs: Instant) {
+@Serializable data class WebRTCCallOffer(val callType: CallType, val rtcSession: WebRTCSession)
+@Serializable data class WebRTCSession(val rtcSession: String, val rtcIceCandidates: String)
+@Serializable data class WebRTCExtraInfo(val rtcIceCandidates: String)
+@Serializable data class CallType(val media: CallMediaType, val capabilities: CallCapabilities)
+@Serializable data class RcvCallInvitation(val user: User, val contact: Contact, val callType: CallType, val sharedKey: String? = null, val callTs: Instant) {
   val callTypeText: String get() = generalGetString(when(callType.media) {
     CallMediaType.Video -> if (sharedKey == null) R.string.video_call_no_encryption else R.string.encrypted_video_call
     CallMediaType.Audio -> if (sharedKey == null) R.string.audio_call_no_encryption else R.string.encrypted_audio_call
@@ -103,19 +107,32 @@ sealed class WCallResponse {
     CallMediaType.Audio -> R.string.incoming_audio_call
   })
 }
-@Serializable class CallCapabilities(val encryption: Boolean)
-@Serializable class ConnectionInfo(private val localCandidate: RTCIceCandidate?, private val remoteCandidate: RTCIceCandidate?) {
-  val text: String @Composable get() = when {
-    localCandidate?.candidateType == RTCIceCandidateType.Host && remoteCandidate?.candidateType == RTCIceCandidateType.Host ->
-      stringResource(R.string.call_connection_peer_to_peer)
-    localCandidate?.candidateType == RTCIceCandidateType.Relay && remoteCandidate?.candidateType == RTCIceCandidateType.Relay ->
-      stringResource(R.string.call_connection_via_relay)
-    else ->
-      "${localCandidate?.candidateType?.value ?: "unknown"} / ${remoteCandidate?.candidateType?.value ?: "unknown"}"
+@Serializable data class CallCapabilities(val encryption: Boolean)
+@Serializable data class ConnectionInfo(private val localCandidate: RTCIceCandidate?, private val remoteCandidate: RTCIceCandidate?) {
+  val text: String @Composable get() {
+    val local = localCandidate?.candidateType
+    val remote = remoteCandidate?.candidateType
+    return when {
+      local == RTCIceCandidateType.Host && remote == RTCIceCandidateType.Host ->
+        stringResource(R.string.call_connection_peer_to_peer)
+      local == RTCIceCandidateType.Relay && remote == RTCIceCandidateType.Relay ->
+        stringResource(R.string.call_connection_via_relay)
+      else ->
+        "${local?.value ?: "unknown"} / ${remote?.value ?: "unknown"}"
+    }
+  }
+
+  val protocolText: String get() {
+    val local = localCandidate?.protocol?.uppercase(Locale.ROOT) ?: "unknown"
+    val localRelay = localCandidate?.relayProtocol?.uppercase(Locale.ROOT) ?: "unknown"
+    val remote = remoteCandidate?.protocol?.uppercase(Locale.ROOT) ?: "unknown"
+    val localText = if (localRelay == local || localCandidate?.relayProtocol == null) local else "$local ($localRelay)"
+    return if (local == remote) localText else "$localText / $remote"
   }
 }
+
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate
-@Serializable class RTCIceCandidate(val candidateType: RTCIceCandidateType?)
+@Serializable data class RTCIceCandidate(val candidateType: RTCIceCandidateType?, val protocol: String?, val relayProtocol: String?)
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer
 @Serializable data class RTCIceServer(val urls: List<String>, val username: String? = null, val credential: String? = null)
 
@@ -150,7 +167,7 @@ enum class VideoCamera {
 }
 
 @Serializable
-class ConnectionState(
+data class ConnectionState(
   val connectionState: String,
   val iceConnectionState: String,
   val iceGatheringState: String,
@@ -158,20 +175,22 @@ class ConnectionState(
 )
 
 // the servers are expected in this format:
-// stun:stun.simplex.im:443
-// turn:private:yleob6AVkiNI87hpR94Z@turn.simplex.im:443
+// stun:stun.simplex.im:443?transport=tcp
+// turn:private:yleob6AVkiNI87hpR94Z@turn.simplex.im:443?transport=tcp
 fun parseRTCIceServer(str: String): RTCIceServer? {
   var s = replaceScheme(str, "stun:")
   s = replaceScheme(s, "turn:")
+  s = replaceScheme(s, "turns:")
   val u = runCatching { URI(s) }.getOrNull()
   if (u != null) {
     val scheme = u.scheme
     val host = u.host
     val port = u.port
-    if (u.path == "" && (scheme == "stun" || scheme == "turn")) {
+    if (u.path == "" && (scheme == "stun" || scheme == "turn" || scheme == "turns")) {
       val userInfo = u.userInfo?.split(":")
+      val query = if (u.query == null || u.query == "") "" else "?${u.query}"
       return RTCIceServer(
-        urls = listOf("$scheme:$host:$port"),
+        urls = listOf("$scheme:$host:$port$query"),
         username = userInfo?.getOrNull(0),
         credential = userInfo?.getOrNull(1)
       )

apps/android/app/src/main/java/chat/simplex/app/views/chat/ChatInfoView.kt

@@ -35,9 +35,10 @@ import chat.simplex.app.SimplexApp
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.SettingsActionItem
+import chat.simplex.app.views.usersettings.*
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.*
+import kotlinx.datetime.Clock
 
 @Composable
 fun ChatInfoView(
@@ -46,27 +47,65 @@ fun ChatInfoView(
   connStats: ConnectionStats?,
   customUserProfile: Profile?,
   localAlias: String,
+  connectionCode: String?,
   close: () -> Unit,
-  onChatUpdated: (Chat) -> Unit,
 ) {
   BackHandler(onBack = close)
   val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
   val developerTools = chatModel.controller.appPrefs.developerTools.get()
   if (chat != null) {
+    val contactNetworkStatus = remember(chatModel.networkStatuses.toMap()) {
+      mutableStateOf(chatModel.contactNetworkStatus(contact))
+    }
     ChatInfoLayout(
       chat,
       contact,
       connStats,
+      contactNetworkStatus.value,
       customUserProfile,
       localAlias,
+      connectionCode,
       developerTools,
       onLocalAliasChanged = {
-        setContactAlias(chat.chatInfo.apiId, it, chatModel, onChatUpdated)
+        setContactAlias(chat.chatInfo.apiId, it, chatModel)
+      },
+      openPreferences = {
+        ModalManager.shared.showCustomModal { close ->
+          val user = chatModel.currentUser.value
+          if (user != null) {
+            ContactPreferencesView(chatModel, user, contact.contactId, close)
+          }
+        }
       },
       deleteContact = { deleteContactDialog(chat.chatInfo, chatModel, close) },
       clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
       switchContactAddress = {
         showSwitchContactAddressAlert(chatModel, contact.contactId)
+      },
+      verifyClicked = {
+        ModalManager.shared.showModalCloseable { close ->
+          remember { derivedStateOf { (chatModel.getContactChat(contact.contactId)?.chatInfo as? ChatInfo.Direct)?.contact } }.value?.let { ct ->
+            VerifyCodeView(
+              ct.displayName,
+              connectionCode,
+              ct.verified,
+              verify = { code ->
+                chatModel.controller.apiVerifyContact(ct.contactId, code)?.let { r ->
+                  val (verified, existingCode) = r
+                  chatModel.updateContact(
+                    ct.copy(
+                      activeConn = ct.activeConn.copy(
+                        connectionCode = if (verified) SecurityCode(existingCode, Clock.System.now()) else null
+                      )
+                    )
+                  )
+                  r
+                }
+              },
+              close,
+            )
+          }
+        }
       }
     )
   }
@@ -114,13 +153,17 @@ fun ChatInfoLayout(
   chat: Chat,
   contact: Contact,
   connStats: ConnectionStats?,
+  contactNetworkStatus: NetworkStatus,
   customUserProfile: Profile?,
   localAlias: String,
+  connectionCode: String?,
   developerTools: Boolean,
   onLocalAliasChanged: (String) -> Unit,
+  openPreferences: () -> Unit,
   deleteContact: () -> Unit,
   clearChat: () -> Unit,
   switchContactAddress: () -> Unit,
+  verifyClicked: () -> Unit,
 ) {
   Column(
     Modifier
@@ -145,19 +188,26 @@ fun ChatInfoLayout(
     }
 
     SectionSpacer()
-
-    SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
-      if (developerTools) {
-        SwitchAddressButton(switchContactAddress)
+    SectionView {
+      if (connectionCode != null) {
+        VerifyCodeButton(contact.verified, verifyClicked)
         SectionDivider()
       }
+      ContactPreferencesButton(openPreferences)
+    }
+
+    SectionSpacer()
+
+    SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+      SwitchAddressButton(switchContactAddress)
+      SectionDivider()
       if (connStats != null) {
         SectionItemView({
           AlertManager.shared.showAlertMsg(
             generalGetString(R.string.network_status),
-            chat.serverInfo.networkStatus.statusExplanation
+            contactNetworkStatus.statusExplanation
           )}) {
-          NetworkStatusRow(chat.serverInfo.networkStatus)
+          NetworkStatusRow(contactNetworkStatus)
         }
         val rcvServers = connStats.rcvServers
         if (rcvServers != null && rcvServers.isNotEmpty()) {
@@ -197,13 +247,17 @@ fun ChatInfoHeader(cInfo: ChatInfo, contact: Contact) {
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
     ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Text(
-      contact.profile.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      color = MaterialTheme.colors.onBackground,
-      maxLines = 1,
-      overflow = TextOverflow.Ellipsis,
-      modifier = Modifier.padding(bottom = 8.dp)
-    )
+    Row(Modifier.padding(bottom = 8.dp), verticalAlignment = Alignment.CenterVertically) {
+      if (contact.verified) {
+        Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 6.dp, top = 4.dp).size(24.dp), tint = HighOrLowlight)
+      }
+      Text(
+        contact.profile.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        color = MaterialTheme.colors.onBackground,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+      )
+    }
     if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName && cInfo.fullName != contact.profile.displayName) {
       Text(
         cInfo.fullName, style = MaterialTheme.typography.h2,
@@ -265,7 +319,7 @@ fun LocalAliasEditor(
 }
 
 @Composable
-fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
+private fun NetworkStatusRow(networkStatus: NetworkStatus) {
   Row(
     Modifier.fillMaxSize(),
     horizontalArrangement = Arrangement.SpaceBetween,
@@ -297,14 +351,14 @@ fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
 }
 
 @Composable
-fun ServerImage(networkStatus: Chat.NetworkStatus) {
+private fun ServerImage(networkStatus: NetworkStatus) {
   Box(Modifier.size(18.dp)) {
     when (networkStatus) {
-      is Chat.NetworkStatus.Connected ->
+      is NetworkStatus.Connected ->
         Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_server_status_connected), tint = MaterialTheme.colors.primaryVariant)
-      is Chat.NetworkStatus.Disconnected ->
+      is NetworkStatus.Disconnected ->
         Icon(Icons.Filled.Pending, stringResource(R.string.icon_descr_server_status_disconnected), tint = HighOrLowlight)
-      is Chat.NetworkStatus.Error ->
+      is NetworkStatus.Error ->
         Icon(Icons.Filled.Error, stringResource(R.string.icon_descr_server_status_error), tint = HighOrLowlight)
       else -> Icon(Icons.Outlined.Circle, stringResource(R.string.icon_descr_server_status_pending), tint = HighOrLowlight)
     }
@@ -328,6 +382,25 @@ fun SwitchAddressButton(onClick: () -> Unit) {
   }
 }
 
+@Composable
+fun VerifyCodeButton(contactVerified: Boolean, onClick: () -> Unit) {
+  SettingsActionItem(
+    if (contactVerified) Icons.Outlined.VerifiedUser else Icons.Outlined.Shield,
+    stringResource(if (contactVerified) R.string.view_security_code else R.string.verify_security_code),
+    click = onClick,
+    iconColor = HighOrLowlight,
+  )
+}
+
+@Composable
+private fun ContactPreferencesButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.ToggleOn,
+    stringResource(R.string.contact_preferences),
+    click = onClick
+  )
+}
+
 @Composable
 fun ClearChatButton(onClick: () -> Unit) {
   SettingsActionItem(
@@ -340,7 +413,7 @@ fun ClearChatButton(onClick: () -> Unit) {
 }
 
 @Composable
-fun DeleteContactButton(onClick: () -> Unit) {
+private fun DeleteContactButton(onClick: () -> Unit) {
   SettingsActionItem(
     Icons.Outlined.Delete,
     stringResource(R.string.button_delete_contact),
@@ -350,10 +423,9 @@ fun DeleteContactButton(onClick: () -> Unit) {
   )
 }
 
-private fun setContactAlias(contactApiId: Long, localAlias: String, chatModel: ChatModel, onChatUpdated: (Chat) -> Unit) = withApi {
+private fun setContactAlias(contactApiId: Long, localAlias: String, chatModel: ChatModel) = withApi {
   chatModel.controller.apiSetContactAlias(contactApiId, localAlias)?.let {
     chatModel.updateContact(it)
-    onChatUpdated(chatModel.getChat(chatModel.chatId.value ?: return@withApi) ?: return@withApi)
   }
 }
 
@@ -379,18 +451,21 @@ fun PreviewChatInfoLayout() {
     ChatInfoLayout(
       chat = Chat(
         chatInfo = ChatInfo.Direct.sampleData,
-        chatItems = arrayListOf(),
-        serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
+        chatItems = arrayListOf()
       ),
       Contact.sampleData,
       localAlias = "",
+      connectionCode = "123",
       developerTools = false,
       connStats = null,
+      contactNetworkStatus = NetworkStatus.Connected(),
       onLocalAliasChanged = {},
       customUserProfile = null,
+      openPreferences = {},
       deleteContact = {},
       clearChat = {},
       switchContactAddress = {},
+      verifyClicked = {},
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/ChatView.kt

@@ -1,8 +1,10 @@
 package chat.simplex.app.views.chat
 
+import android.app.Activity
 import android.content.res.Configuration
 import android.graphics.Bitmap
 import android.net.Uri
+import android.util.Log
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.gestures.*
@@ -12,8 +14,7 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.KeyboardArrowDown
-import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.mapSaver
@@ -50,52 +51,72 @@ import java.io.File
 import kotlin.math.sign
 
 @Composable
-fun ChatView(chatModel: ChatModel) {
-  val activeChat = remember { mutableStateOf(chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatModel.chatId.value }) }
+fun ChatView(chatId: String, chatModel: ChatModel, onComposed: () -> Unit) {
+  val activeChat = remember { mutableStateOf(chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatId }) }
   val searchText = rememberSaveable { mutableStateOf("") }
   val user = chatModel.currentUser.value
   val useLinkPreviews = chatModel.controller.appPrefs.privacyLinkPreviews.get()
   val composeState = rememberSaveable(saver = ComposeState.saver()) {
-    mutableStateOf(ComposeState(useLinkPreviews = useLinkPreviews))
+    mutableStateOf(
+      if (chatModel.draftChatId.value == chatId && chatModel.draft.value != null) {
+        chatModel.draft.value ?: ComposeState(useLinkPreviews = useLinkPreviews)
+      } else {
+        ComposeState(useLinkPreviews = useLinkPreviews)
+      }
+    )
   }
   val attachmentOption = rememberSaveable { mutableStateOf<AttachmentOption?>(null) }
   val attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
   val scope = rememberCoroutineScope()
-
   LaunchedEffect(Unit) {
     // snapshotFlow here is because it reacts much faster on changes in chatModel.chatId.value.
     // With LaunchedEffect(chatModel.chatId.value) there is a noticeable delay before reconstruction of the view
-    snapshotFlow { chatModel.chatId.value }
-      .distinctUntilChanged()
-      .collect {
-        if (activeChat.value?.id != chatModel.chatId.value) {
-          activeChat.value = if (chatModel.chatId.value == null) {
-            null
-          } else {
+    launch {
+      snapshotFlow { chatModel.chatId.value }
+        .distinctUntilChanged()
+        .collect {
+          if (activeChat.value?.id != chatModel.chatId.value && chatModel.chatId.value != null) {
             // Redisplay the whole hierarchy if the chat is different to make going from groups to direct chat working correctly
             // Also for situation when chatId changes after clicking in notification, etc
-            chatModel.getChat(chatModel.chatId.value!!)
+            activeChat.value = chatModel.getChat(chatModel.chatId.value!!)
           }
+          markUnreadChatAsRead(activeChat, chatModel)
+        }
+    }
+    launch {
+      snapshotFlow {
+        /**
+         * It's possible that in some cases concurrent modification can happen on [ChatModel.chats] list.
+         * In this case only error log will be printed here (no crash).
+         * TODO: Re-write [ChatModel.chats] logic to a new list assignment instead of changing content of mutableList to prevent that
+         * */
+        try {
+          chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatModel.chatId.value }
+        } catch (e: ConcurrentModificationException) {
+          Log.e(TAG, e.stackTraceToString())
+          null
         }
-        markUnreadChatAsRead(activeChat, chatModel)
       }
+        .distinctUntilChanged()
+        // Only changed chatInfo is important thing. Other properties can be skipped for reducing recompositions
+        .filter { it?.chatInfo != activeChat.value?.chatInfo && it != null }
+        .collect { activeChat.value = it }
+    }
   }
-
+  val view = LocalView.current
   if (activeChat.value == null || user == null) {
     chatModel.chatId.value = null
   } else {
     val chat = activeChat.value!!
-    BackHandler { chatModel.chatId.value = null }
     // We need to have real unreadCount value for displaying it inside top right button
     // Having activeChat reloaded on every change in it is inefficient (UI lags)
     val unreadCount = remember {
       derivedStateOf {
-        chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatModel.chatId.value }?.chatStats?.unreadCount ?: 0
+        chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatId }?.chatStats?.unreadCount ?: 0
       }
     }
 
     ChatLayout(
-      user,
       chat,
       unreadCount,
       composeState,
@@ -108,36 +129,62 @@ fun ChatView(chatModel: ChatModel) {
         }
       },
       attachmentOption,
-      scope,
       attachmentBottomSheetState,
       chatModel.chatItems,
       searchText,
       useLinkPreviews = useLinkPreviews,
+      linkMode = chatModel.simplexLinkMode.value,
+      allowVideoAttachment = chatModel.controller.appPrefs.xftpSendEnabled.get(),
       chatModelIncognito = chatModel.incognito.value,
-      back = { chatModel.chatId.value = null },
+      back = {
+        hideKeyboard(view)
+        AudioPlayer.stop()
+        chatModel.chatId.value = null
+      },
       info = {
+        hideKeyboard(view)
         withApi {
-          val cInfo = chat.chatInfo
-          if (cInfo is ChatInfo.Direct) {
-            val contactInfo = chatModel.controller.apiContactInfo(cInfo.apiId)
+          if (chat.chatInfo is ChatInfo.Direct) {
+            val contactInfo = chatModel.controller.apiContactInfo(chat.chatInfo.apiId)
+            val (_, code) = chatModel.controller.apiGetContactCode(chat.chatInfo.apiId)
             ModalManager.shared.showModalCloseable(true) { close ->
-              ChatInfoView(chatModel, cInfo.contact, contactInfo?.first, contactInfo?.second, chat.chatInfo.localAlias, close) {
-                activeChat.value = it
+              remember { derivedStateOf { (chatModel.getContactChat(chat.chatInfo.apiId)?.chatInfo as? ChatInfo.Direct)?.contact } }.value?.let { ct ->
+                ChatInfoView(chatModel, ct, contactInfo?.first, contactInfo?.second, chat.chatInfo.localAlias, code, close)
               }
             }
-          } else if (cInfo is ChatInfo.Group) {
-            setGroupMembers(cInfo.groupInfo, chatModel)
+          } else if (chat.chatInfo is ChatInfo.Group) {
+            setGroupMembers(chat.chatInfo.groupInfo, chatModel)
+            val link = chatModel.controller.apiGetGroupLink(chat.chatInfo.groupInfo.groupId)
+            var groupLink = link?.first
+            var groupLinkMemberRole = link?.second
             ModalManager.shared.showModalCloseable(true) { close ->
-              GroupChatInfoView(chatModel, close)
+              GroupChatInfoView(chatModel, groupLink, groupLinkMemberRole, {
+                groupLink = it.first;
+                groupLinkMemberRole = it.second
+              }, close)
             }
           }
         }
       },
       showMemberInfo = { groupInfo: GroupInfo, member: GroupMember ->
+        hideKeyboard(view)
         withApi {
           val stats = chatModel.controller.apiGroupMemberInfo(groupInfo.groupId, member.groupMemberId)
+          val (_, code) = if (member.memberActive) {
+            try {
+              chatModel.controller.apiGetGroupMemberCode(groupInfo.apiId, member.groupMemberId)
+            } catch (e: Exception) {
+              Log.e(TAG, e.stackTraceToString())
+              member to null
+            }
+          } else {
+            member to null
+          }
+          setGroupMembers(groupInfo, chatModel)
           ModalManager.shared.showModalCloseable(true) { close ->
-            GroupMemberInfoView(groupInfo, member, stats, chatModel, close, close)
+            remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
+              GroupMemberInfoView(groupInfo, mem, stats, code, chatModel, close, close)
+            }
           }
         }
       },
@@ -153,17 +200,42 @@ fun ChatView(chatModel: ChatModel) {
       deleteMessage = { itemId, mode ->
         withApi {
           val cInfo = chat.chatInfo
-          val toItem = chatModel.controller.apiDeleteChatItem(
-            type = cInfo.chatType,
-            id = cInfo.apiId,
-            itemId = itemId,
-            mode = mode
-          )
-          if (toItem != null) chatModel.removeChatItem(cInfo, toItem.chatItem)
+          val toDeleteItem = chatModel.chatItems.firstOrNull { it.id == itemId }
+          val toModerate = toDeleteItem?.memberToModerate(chat.chatInfo)
+          val groupInfo = toModerate?.first
+          val groupMember = toModerate?.second
+          val deletedChatItem: ChatItem?
+          val toChatItem: ChatItem?
+          if (mode == CIDeleteMode.cidmBroadcast && groupInfo != null && groupMember != null) {
+            val r = chatModel.controller.apiDeleteMemberChatItem(
+              groupId = groupInfo.groupId,
+              groupMemberId = groupMember.groupMemberId,
+              itemId = itemId
+            )
+            deletedChatItem = r?.first
+            toChatItem = r?.second
+          } else {
+            val r = chatModel.controller.apiDeleteChatItem(
+              type = cInfo.chatType,
+              id = cInfo.apiId,
+              itemId = itemId,
+              mode = mode
+            )
+            deletedChatItem = r?.deletedChatItem?.chatItem
+            toChatItem = r?.toChatItem?.chatItem
+          }
+          if (toChatItem == null && deletedChatItem != null) {
+            chatModel.removeChatItem(cInfo, deletedChatItem)
+          } else if (toChatItem != null) {
+            chatModel.upsertChatItem(cInfo, toChatItem)
+          }
         }
       },
       receiveFile = { fileId ->
-        withApi { chatModel.controller.receiveFile(fileId) }
+        withApi { chatModel.controller.receiveFile(user, fileId) }
+      },
+      cancelFile = { fileId ->
+        withApi { chatModel.controller.cancelFile(user, fileId) }
       },
       joinGroup = { groupId ->
         withApi { chatModel.controller.apiJoinGroup(groupId) }
@@ -177,6 +249,7 @@ fun ChatView(chatModel: ChatModel) {
         }
       },
       acceptCall = { contact ->
+        hideKeyboard(view)
         val invitation = chatModel.callInvitations.remove(contact.id)
         if (invitation == null) {
           AlertManager.shared.showAlertMsg("Call already ended!")
@@ -184,18 +257,24 @@ fun ChatView(chatModel: ChatModel) {
           chatModel.callManager.acceptIncomingCall(invitation = invitation)
         }
       },
+      acceptFeature = { contact, feature, param ->
+        withApi {
+          chatModel.controller.allowFeatureToContact(contact, feature, param)
+        }
+      },
       addMembers = { groupInfo ->
+        hideKeyboard(view)
         withApi {
           setGroupMembers(groupInfo, chatModel)
           ModalManager.shared.showModalCloseable(true) { close ->
-              AddGroupMembersView(groupInfo, chatModel, close)
+              AddGroupMembersView(groupInfo, false, chatModel, close)
           }
         }
       },
       markRead = { range, unreadCountAfter ->
         chatModel.markChatItemsRead(chat.chatInfo, range, unreadCountAfter)
         chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
-        withApi {
+        withBGApi {
           chatModel.controller.apiChatRead(
             chat.chatInfo.chatType,
             chat.chatInfo.apiId,
@@ -211,24 +290,25 @@ fun ChatView(chatModel: ChatModel) {
           apiFindMessages(c.chatInfo, chatModel, value)
           searchText.value = value
         }
-      }
+      },
+      onComposed,
     )
   }
 }
 
 @Composable
 fun ChatLayout(
-  user: User,
   chat: Chat,
   unreadCount: State<Int>,
   composeState: MutableState<ComposeState>,
   composeView: (@Composable () -> Unit),
   attachmentOption: MutableState<AttachmentOption?>,
-  scope: CoroutineScope,
   attachmentBottomSheetState: ModalBottomSheetState,
   chatItems: List<ChatItem>,
   searchValue: State<String>,
   useLinkPreviews: Boolean,
+  linkMode: SimplexLinkMode,
+  allowVideoAttachment: Boolean,
   chatModelIncognito: Boolean,
   back: () -> Unit,
   info: () -> Unit,
@@ -236,15 +316,19 @@ fun ChatLayout(
   loadPrevMessages: (ChatInfo) -> Unit,
   deleteMessage: (Long, CIDeleteMode) -> Unit,
   receiveFile: (Long) -> Unit,
+  cancelFile: (Long) -> Unit,
   joinGroup: (Long) -> Unit,
   startCall: (CallMediaType) -> Unit,
   acceptCall: (Contact) -> Unit,
+  acceptFeature: (Contact, ChatFeature, Int?) -> Unit,
   addMembers: (GroupInfo) -> Unit,
   markRead: (CC.ItemRange, unreadCountAfter: Int?) -> Unit,
   changeNtfsState: (Boolean, currentValue: MutableState<Boolean>) -> Unit,
   onSearchValueChanged: (String) -> Unit,
+  onComposed: () -> Unit,
 ) {
-  Surface(
+  val scope = rememberCoroutineScope()
+  Box(
     Modifier
       .fillMaxWidth()
       .background(MaterialTheme.colors.background)
@@ -256,6 +340,7 @@ fun ChatLayout(
         sheetContent = {
           ChooseAttachmentView(
             attachmentOption,
+            allowVideoAttachment,
             hide = { scope.launch { attachmentBottomSheetState.hide() } }
           )
         },
@@ -275,9 +360,9 @@ fun ChatLayout(
         ) { contentPadding ->
           BoxWithConstraints(Modifier.fillMaxHeight().padding(contentPadding)) {
             ChatItemsList(
-              user, chat, unreadCount, composeState, chatItems, searchValue,
-              useLinkPreviews, chatModelIncognito, showMemberInfo, loadPrevMessages, deleteMessage,
-              receiveFile, joinGroup, acceptCall, markRead, setFloatingButton
+              chat, unreadCount, composeState, chatItems, searchValue,
+              useLinkPreviews, linkMode, chatModelIncognito, showMemberInfo, loadPrevMessages, deleteMessage,
+              receiveFile, cancelFile, joinGroup, acceptCall, acceptFeature, markRead, setFloatingButton, onComposed,
             )
           }
         }
@@ -400,10 +485,15 @@ fun ChatInfoToolbarTitle(cInfo: ChatInfo, imageSize: Dp = 40.dp, iconColor: Colo
       Modifier.padding(start = 8.dp),
       horizontalAlignment = Alignment.CenterHorizontally
     ) {
-      Text(
-        cInfo.displayName, fontWeight = FontWeight.SemiBold,
-        maxLines = 1, overflow = TextOverflow.Ellipsis
-      )
+      Row(verticalAlignment = Alignment.CenterVertically) {
+        if ((cInfo as? ChatInfo.Direct)?.contact?.verified == true) {
+          ContactVerifiedShield()
+        }
+        Text(
+          cInfo.displayName, fontWeight = FontWeight.SemiBold,
+          maxLines = 1, overflow = TextOverflow.Ellipsis
+        )
+      }
       if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName && cInfo.localAlias.isEmpty()) {
         Text(
           cInfo.fullName,
@@ -414,6 +504,11 @@ fun ChatInfoToolbarTitle(cInfo: ChatInfo, imageSize: Dp = 40.dp, iconColor: Colo
   }
 }
 
+@Composable
+private fun ContactVerifiedShield() {
+  Icon(Icons.Outlined.VerifiedUser, null, Modifier.size(18.dp).padding(end = 3.dp, top = 1.dp), tint = HighOrLowlight)
+}
+
 data class CIListState(val scrolled: Boolean, val itemCount: Int, val keyboardState: KeyboardState)
 
 val CIListStateSaver = run {
@@ -428,28 +523,29 @@ val CIListStateSaver = run {
 
 @Composable
 fun BoxWithConstraintsScope.ChatItemsList(
-  user: User,
   chat: Chat,
   unreadCount: State<Int>,
   composeState: MutableState<ComposeState>,
   chatItems: List<ChatItem>,
   searchValue: State<String>,
   useLinkPreviews: Boolean,
+  linkMode: SimplexLinkMode,
   chatModelIncognito: Boolean,
   showMemberInfo: (GroupInfo, GroupMember) -> Unit,
   loadPrevMessages: (ChatInfo) -> Unit,
   deleteMessage: (Long, CIDeleteMode) -> Unit,
   receiveFile: (Long) -> Unit,
+  cancelFile: (Long) -> Unit,
   joinGroup: (Long) -> Unit,
   acceptCall: (Contact) -> Unit,
+  acceptFeature: (Contact, ChatFeature, Int?) -> Unit,
   markRead: (CC.ItemRange, unreadCountAfter: Int?) -> Unit,
   setFloatingButton: (@Composable () -> Unit) -> Unit,
+  onComposed: () -> Unit,
 ) {
   val listState = rememberLazyListState()
   val scope = rememberCoroutineScope()
-  val uriHandler = LocalUriHandler.current
-  val cxt = LocalContext.current
-  ScrollToBottom(chat.id, listState)
+  ScrollToBottom(chat.id, listState, chatItems)
   var prevSearchEmptiness by rememberSaveable { mutableStateOf(searchValue.value.isEmpty()) }
   // Scroll to bottom when search value changes from something to nothing and back
   LaunchedEffect(searchValue.value.isEmpty()) {
@@ -468,7 +564,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
   }
 
   Spacer(Modifier.size(8.dp))
-  val reversedChatItems by remember { derivedStateOf { chatItems.reversed() } }
+  val reversedChatItems by remember { derivedStateOf { chatItems.reversed().toList() } }
   val maxHeightRounded = with(LocalDensity.current) { maxHeight.roundToPx() }
   val scrollToItem: (Long) -> Unit = { itemId: Long ->
     val index = reversedChatItems.indexOfFirst { it.id == itemId }
@@ -476,8 +572,23 @@ fun BoxWithConstraintsScope.ChatItemsList(
       scope.launch { listState.animateScrollToItem(kotlin.math.min(reversedChatItems.lastIndex, index + 1), -maxHeightRounded) }
     }
   }
+  LaunchedEffect(Unit) {
+    var stopListening = false
+    snapshotFlow { listState.layoutInfo.visibleItemsInfo.lastIndex }
+      .distinctUntilChanged()
+      .filter { !stopListening }
+      .collect {
+          onComposed()
+          stopListening = true
+      }
+  }
+  DisposableEffectOnGone(
+    whenGone = {
+      VideoPlayer.releaseAll()
+    }
+  )
   LazyColumn(Modifier.align(Alignment.BottomCenter), state = listState, reverseLayout = true) {
-    itemsIndexed(reversedChatItems) { i, cItem ->
+    itemsIndexed(reversedChatItems, key = { _, item -> item.id}) { i, cItem ->
       CompositionLocalProvider(
         // Makes horizontal and vertical scrolling to coexist nicely.
         // With default touchSlop when you scroll LazyColumn, you can unintentionally open reply view
@@ -497,7 +608,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
             scope.launch {
               if (composeState.value.editing) {
                 composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
-              } else {
+              } else if (cItem.id != ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
                 composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
               }
             }
@@ -538,11 +649,11 @@ fun BoxWithConstraintsScope.ChatItemsList(
               } else {
                 Spacer(Modifier.size(42.dp))
               }
-              ChatItemView(user, chat.chatInfo, cItem, composeState, cxt, uriHandler, provider, showMember = showMember, chatModelIncognito = chatModelIncognito, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, joinGroup = {}, acceptCall = acceptCall, scrollToItem = scrollToItem)
+              ChatItemView(chat.chatInfo, cItem, composeState, provider, showMember = showMember, useLinkPreviews = useLinkPreviews, linkMode = linkMode, deleteMessage = deleteMessage, receiveFile = receiveFile, cancelFile = cancelFile, joinGroup = {}, acceptCall = acceptCall, acceptFeature = acceptFeature, scrollToItem = scrollToItem)
             }
           } else {
             Box(Modifier.padding(start = 104.dp, end = 12.dp).then(swipeableModifier)) {
-              ChatItemView(user, chat.chatInfo, cItem, composeState, cxt, uriHandler, provider, chatModelIncognito = chatModelIncognito, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, joinGroup = {}, acceptCall = acceptCall, scrollToItem = scrollToItem)
+              ChatItemView(chat.chatInfo, cItem, composeState, provider, useLinkPreviews = useLinkPreviews, linkMode = linkMode, deleteMessage = deleteMessage, receiveFile = receiveFile, cancelFile = cancelFile, joinGroup = {}, acceptCall = acceptCall, acceptFeature = acceptFeature, scrollToItem = scrollToItem)
             }
           }
         } else { // direct message
@@ -553,7 +664,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
               end = if (sent) 12.dp else 76.dp,
             ).then(swipeableModifier)
           ) {
-            ChatItemView(user, chat.chatInfo, cItem, composeState, cxt, uriHandler, provider, chatModelIncognito = chatModelIncognito, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, joinGroup = joinGroup, acceptCall = acceptCall, scrollToItem = scrollToItem)
+            ChatItemView(chat.chatInfo, cItem, composeState, provider, useLinkPreviews = useLinkPreviews, linkMode = linkMode, deleteMessage = deleteMessage, receiveFile = receiveFile, cancelFile = cancelFile, joinGroup = joinGroup, acceptCall = acceptCall, acceptFeature = acceptFeature, scrollToItem = scrollToItem)
           }
         }
 
@@ -572,7 +683,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
 }
 
 @Composable
-private fun ScrollToBottom(chatId: ChatId, listState: LazyListState) {
+private fun ScrollToBottom(chatId: ChatId, listState: LazyListState, chatItems: List<ChatItem>) {
   val scope = rememberCoroutineScope()
   // Helps to scroll to bottom after moving from Group to Direct chat
   // and prevents scrolling to bottom on orientation change
@@ -584,6 +695,31 @@ private fun ScrollToBottom(chatId: ChatId, listState: LazyListState) {
     // Don't autoscroll next time until it will be needed
     shouldAutoScroll = false to chatId
   }
+  val scrollDistance = with(LocalDensity.current) { -39.dp.toPx() }
+  /*
+  * Since we use key with each item in LazyColumn, LazyColumn will not autoscroll to bottom item. We need to do it ourselves.
+  * When the first visible item (from bottom) is visible (even partially) we can autoscroll to 0 item. Or just scrollBy small distance otherwise
+  * */
+  LaunchedEffect(Unit) {
+    snapshotFlow { chatItems.lastOrNull()?.id }
+      .distinctUntilChanged()
+      .filter { listState.layoutInfo.visibleItemsInfo.firstOrNull()?.key != it }
+      .collect {
+        try {
+          if (listState.firstVisibleItemIndex == 0) {
+            listState.animateScrollToItem(0)
+          } else {
+            listState.animateScrollBy(scrollDistance)
+          }
+        } catch (e: CancellationException) {
+          /**
+           * When you tap and hold a finger on a lazy column with chatItems, and then you receive a message,
+           * this coroutine will be canceled with the message "Current mutation had a higher priority" because of animatedScroll.
+           * Which breaks auto-scrolling to bottom. So just ignoring the exception
+           * */
+        }
+      }
+  }
 }
 
 @Composable
@@ -700,7 +836,7 @@ fun PreloadItems(
       .map {
         val totalItemsNumber = it.totalItemsCount
         val lastVisibleItemIndex = (it.visibleItemsInfo.lastOrNull()?.index ?: 0) + 1
-        if (lastVisibleItemIndex > (totalItemsNumber - remaining))
+        if (lastVisibleItemIndex > (totalItemsNumber - remaining) && totalItemsNumber >= ChatPagination.INITIAL_COUNT)
           totalItemsNumber
         else
           0
@@ -808,21 +944,26 @@ private fun markUnreadChatAsRead(activeChat: MutableState<Chat?>, chatModel: Cha
   }
 }
 
+sealed class ProviderMedia {
+  data class Image(val uri: Uri, val image: Bitmap): ProviderMedia()
+  data class Video(val uri: Uri, val preview: String): ProviderMedia()
+}
+
 private fun providerForGallery(
   listStateIndex: Int,
   chatItems: List<ChatItem>,
   cItemId: Long,
   scrollTo: (Int) -> Unit
 ): ImageGalleryProvider {
-  fun canShowImage(item: ChatItem): Boolean =
-    item.content.msgContent is MsgContent.MCImage && item.file?.loaded == true && getLoadedFilePath(SimplexApp.context, item.file) != null
+  fun canShowMedia(item: ChatItem): Boolean =
+    (item.content.msgContent is MsgContent.MCImage || item.content.msgContent is MsgContent.MCVideo) && (item.file?.loaded == true && getLoadedFilePath(SimplexApp.context, item.file) != null)
 
   fun item(skipInternalIndex: Int, initialChatId: Long): Pair<Int, ChatItem>? {
     var processedInternalIndex = -skipInternalIndex.sign
     val indexOfFirst = chatItems.indexOfFirst { it.id == initialChatId }
     for (chatItemsIndex in if (skipInternalIndex >= 0) indexOfFirst downTo 0 else indexOfFirst..chatItems.lastIndex) {
       val item = chatItems[chatItemsIndex]
-      if (canShowImage(item)) {
+      if (canShowMedia(item)) {
         processedInternalIndex += skipInternalIndex.sign
       }
       if (processedInternalIndex == skipInternalIndex) {
@@ -836,16 +977,28 @@ private fun providerForGallery(
   var initialChatId = cItemId
   return object: ImageGalleryProvider {
     override val initialIndex: Int = initialIndex
-    override val totalImagesSize = mutableStateOf(Int.MAX_VALUE)
-    override fun getImage(index: Int): Pair<Bitmap, Uri>? {
+    override val totalMediaSize = mutableStateOf(Int.MAX_VALUE)
+    override fun getMedia(index: Int): ProviderMedia? {
       val internalIndex = initialIndex - index
-      val file = item(internalIndex, initialChatId)?.second?.file
-      val imageBitmap: Bitmap? = getLoadedImage(SimplexApp.context, file)
-      val filePath = getLoadedFilePath(SimplexApp.context, file)
-      return if (imageBitmap != null && filePath != null) {
-        val uri = FileProvider.getUriForFile(SimplexApp.context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))
-        imageBitmap to uri
-      } else null
+      val item = item(internalIndex, initialChatId)?.second ?: return null
+      return when (item.content.msgContent) {
+        is MsgContent.MCImage -> {
+          val imageBitmap: Bitmap? = getLoadedImage(SimplexApp.context, item.file)
+          val filePath = getLoadedFilePath(SimplexApp.context, item.file)
+          if (imageBitmap != null && filePath != null) {
+            val uri = FileProvider.getUriForFile(SimplexApp.context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))
+            ProviderMedia.Image(uri, imageBitmap)
+          } else null
+        }
+        is MsgContent.MCVideo -> {
+          val filePath = getLoadedFilePath(SimplexApp.context, item.file)
+          if (filePath != null) {
+            val uri = FileProvider.getUriForFile(SimplexApp.context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))
+            ProviderMedia.Video(uri, (item.content.msgContent as MsgContent.MCVideo).image)
+          } else null
+        }
+        else -> null
+      }
     }
 
     override fun currentPageChanged(index: Int) {
@@ -857,7 +1010,7 @@ private fun providerForGallery(
 
     override fun scrollToStart() {
       initialIndex = 0
-      initialChatId = chatItems.first { canShowImage(it) }.id
+      initialChatId = chatItems.first { canShowMedia(it) }.id
     }
 
     override fun onDismiss(index: Int) {
@@ -914,7 +1067,6 @@ fun PreviewChatLayout() {
     val unreadCount = remember { mutableStateOf(chatItems.count { it.isRcvNew }) }
     val searchValue = remember { mutableStateOf("") }
     ChatLayout(
-      user = User.sampleData,
       chat = Chat(
         chatInfo = ChatInfo.Direct.sampleData,
         chatItems = chatItems,
@@ -924,11 +1076,12 @@ fun PreviewChatLayout() {
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
       composeView = {},
       attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
-      scope = rememberCoroutineScope(),
       attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
       chatItems = chatItems,
       searchValue,
       useLinkPreviews = true,
+      linkMode = SimplexLinkMode.DESCRIPTION,
+      allowVideoAttachment = true,
       chatModelIncognito = false,
       back = {},
       info = {},
@@ -936,13 +1089,16 @@ fun PreviewChatLayout() {
       loadPrevMessages = { _ -> },
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
       startCall = {},
       acceptCall = { _ -> },
+      acceptFeature = { _, _, _ -> },
       addMembers = { _ -> },
       markRead = { _, _ -> },
       changeNtfsState = { _, _ -> },
       onSearchValueChanged = {},
+      onComposed = {},
     )
   }
 }
@@ -972,7 +1128,6 @@ fun PreviewGroupChatLayout() {
     val unreadCount = remember { mutableStateOf(chatItems.count { it.isRcvNew }) }
     val searchValue = remember { mutableStateOf("") }
     ChatLayout(
-      user = User.sampleData,
       chat = Chat(
         chatInfo = ChatInfo.Group.sampleData,
         chatItems = chatItems,
@@ -982,11 +1137,12 @@ fun PreviewGroupChatLayout() {
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
       composeView = {},
       attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
-      scope = rememberCoroutineScope(),
       attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
       chatItems = chatItems,
       searchValue,
       useLinkPreviews = true,
+      linkMode = SimplexLinkMode.DESCRIPTION,
+      allowVideoAttachment = true,
       chatModelIncognito = false,
       back = {},
       info = {},
@@ -994,13 +1150,16 @@ fun PreviewGroupChatLayout() {
       loadPrevMessages = { _ -> },
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
       startCall = {},
       acceptCall = { _ -> },
+      acceptFeature = { _, _, _ -> },
       addMembers = { _ -> },
       markRead = { _, _ -> },
       changeNtfsState = { _, _ -> },
       onSearchValueChanged = {},
+      onComposed = {},
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/ComposeView.kt

@@ -1,57 +1,58 @@
+@file:UseSerializers(UriSerializer::class)
 package chat.simplex.app.views.chat
 
 import ComposeFileView
+import ComposeVoiceView
 import android.Manifest
 import android.app.Activity
 import android.content.*
 import android.content.pm.PackageManager
-import android.graphics.Bitmap
-import android.graphics.ImageDecoder
+import android.graphics.*
 import android.graphics.drawable.AnimatedImageDrawable
+import android.media.MediaMetadataRetriever
 import android.net.Uri
+import android.os.Build
 import android.provider.MediaStore
-import android.util.Log
 import android.widget.Toast
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContract
-import androidx.annotation.CallSuper
-import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.Icon
-import androidx.compose.material.MaterialTheme
+import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.AttachFile
 import androidx.compose.material.icons.filled.Edit
 import androidx.compose.material.icons.outlined.Reply
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
-import androidx.core.content.FileProvider
 import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.views.chat.item.*
 import chat.simplex.app.views.helpers.*
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.decodeFromString
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.serialization.*
 import java.io.File
+import java.nio.file.Files
 
 @Serializable
 sealed class ComposePreview {
   @Serializable object NoPreview: ComposePreview()
   @Serializable class CLinkPreview(val linkPreview: LinkPreview?): ComposePreview()
-  @Serializable class ImagePreview(val images: List<String>): ComposePreview()
-  @Serializable class FilePreview(val fileName: String): ComposePreview()
+  @Serializable class ImagePreview(val images: List<String>, val content: List<UploadContent>): ComposePreview()
+  @Serializable class VideoPreview(val images: List<String>, val content: List<UploadContent>): ComposePreview()
+  @Serializable data class VoicePreview(val voice: String, val durationMs: Int, val finished: Boolean): ComposePreview()
+  @Serializable class FilePreview(val fileName: String, val uri: Uri): ComposePreview()
 }
 
 @Serializable
@@ -61,16 +62,26 @@ sealed class ComposeContextItem {
   @Serializable class EditingItem(val chatItem: ChatItem): ComposeContextItem()
 }
 
+@Serializable
+data class LiveMessage(
+  val chatItem: ChatItem,
+  val typedMsg: String,
+  val sentMsg: String,
+  val sent: Boolean
+)
+
 @Serializable
 data class ComposeState(
   val message: String = "",
+  val liveMessage: LiveMessage? = null,
   val preview: ComposePreview = ComposePreview.NoPreview,
   val contextItem: ComposeContextItem = ComposeContextItem.NoContextItem,
   val inProgress: Boolean = false,
   val useLinkPreviews: Boolean
 ) {
-  constructor(editingItem: ChatItem, useLinkPreviews: Boolean): this (
+  constructor(editingItem: ChatItem, liveMessage: LiveMessage? = null, useLinkPreviews: Boolean): this(
     editingItem.content.text,
+    liveMessage,
     chatItemPreview(editingItem),
     ComposeContextItem.EditingItem(editingItem),
     useLinkPreviews = useLinkPreviews
@@ -86,15 +97,22 @@ data class ComposeState(
     get() = {
       val hasContent = when (preview) {
         is ComposePreview.ImagePreview -> true
+        is ComposePreview.VideoPreview -> true
+        is ComposePreview.VoicePreview -> true
         is ComposePreview.FilePreview -> true
-        else -> message.isNotEmpty()
+        else -> message.isNotEmpty() || liveMessage != null
       }
       hasContent && !inProgress
     }
+  val endLiveDisabled: Boolean
+    get() = liveMessage != null && message.isEmpty() && preview is ComposePreview.NoPreview && contextItem is ComposeContextItem.NoContextItem
+
   val linkPreviewAllowed: Boolean
     get() =
       when (preview) {
         is ComposePreview.ImagePreview -> false
+        is ComposePreview.VideoPreview -> false
+        is ComposePreview.VoicePreview -> false
         is ComposePreview.FilePreview -> false
         else -> useLinkPreviews
       }
@@ -105,6 +123,19 @@ data class ComposeState(
         else -> null
       }
 
+  val attachmentDisabled: Boolean
+    get() {
+      if (editing || liveMessage != null) return true
+      return when (preview) {
+        ComposePreview.NoPreview -> false
+        is ComposePreview.CLinkPreview -> false
+        else -> true
+      }
+    }
+
+  val empty: Boolean
+    get() = message.isEmpty() && preview is ComposePreview.NoPreview
+
   companion object {
     fun saver(): Saver<MutableState<ComposeState>, *> = Saver(
       save = { json.encodeToString(serializer(), it.value) },
@@ -115,16 +146,26 @@ data class ComposeState(
   }
 }
 
+sealed class RecordingState {
+  object NotStarted: RecordingState()
+  class Started(val filePath: String, val progressMs: Int = 0): RecordingState()
+  class Finished(val filePath: String, val durationMs: Int): RecordingState()
+
+  val filePathNullable: String?
+    get() = (this as? Started)?.filePath
+}
+
 fun chatItemPreview(chatItem: ChatItem): ComposePreview {
+  val fileName = chatItem.file?.fileName ?: ""
   return when (val mc = chatItem.content.msgContent) {
     is MsgContent.MCText -> ComposePreview.NoPreview
     is MsgContent.MCLink -> ComposePreview.CLinkPreview(linkPreview = mc.preview)
-    is MsgContent.MCImage -> ComposePreview.ImagePreview(images = listOf(mc.image))
-    is MsgContent.MCFile -> {
-      val fileName = chatItem.file?.fileName ?: ""
-      ComposePreview.FilePreview(fileName)
-    }
-    else -> ComposePreview.NoPreview
+    // TODO: include correct type
+    is MsgContent.MCImage -> ComposePreview.ImagePreview(images = listOf(mc.image), listOf(UploadContent.SimpleImage(getAppFileUri(fileName))))
+    is MsgContent.MCVideo -> ComposePreview.VideoPreview(images = listOf(mc.image), listOf(UploadContent.SimpleImage(getAppFileUri(fileName))))
+    is MsgContent.MCVoice -> ComposePreview.VoicePreview(voice = fileName, mc.duration / 1000, true)
+    is MsgContent.MCFile -> ComposePreview.FilePreview(fileName, getAppFileUri(fileName))
+    is MsgContent.MCUnknown, null -> ComposePreview.NoPreview
   }
 }
 
@@ -137,59 +178,27 @@ fun ComposeView(
   showChooseAttachment: () -> Unit
 ) {
   val context = LocalContext.current
-  val linkUrl = remember { mutableStateOf<String?>(null) }
-  val prevLinkUrl = remember { mutableStateOf<String?>(null) }
-  val pendingLinkUrl = remember { mutableStateOf<String?>(null) }
-  val cancelledLinks = remember { mutableSetOf<String>() }
+  val linkUrl = rememberSaveable { mutableStateOf<String?>(null) }
+  val prevLinkUrl = rememberSaveable { mutableStateOf<String?>(null) }
+  val pendingLinkUrl = rememberSaveable { mutableStateOf<String?>(null) }
+  val cancelledLinks = rememberSaveable { mutableSetOf<String>() }
   val useLinkPreviews = chatModel.controller.appPrefs.privacyLinkPreviews.get()
+  val xftpSendEnabled = chatModel.controller.appPrefs.xftpSendEnabled.get()
+  val maxFileSize = getMaxFileSize(fileProtocol = if (xftpSendEnabled) FileProtocol.XFTP else FileProtocol.SMP)
   val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
   val textStyle = remember { mutableStateOf(smallFont) }
-  // attachments
-  val chosenContent = remember { mutableStateOf<List<UploadContent>>(emptyList()) }
-  val chosenFile = remember { mutableStateOf<Uri?>(null) }
-  val photoUri = remember { mutableStateOf<Uri?>(null) }
-  val photoTmpFile = remember { mutableStateOf<File?>(null) }
-
-  class ComposeTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
-    @CallSuper
-    override fun createIntent(context: Context, input: Void?): Intent {
-      photoTmpFile.value = File.createTempFile("image", ".bmp", SimplexApp.context.filesDir)
-      photoUri.value = FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", photoTmpFile.value!!)
-      return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
-        .putExtra(MediaStore.EXTRA_OUTPUT, photoUri.value)
-    }
-
-    override fun getSynchronousResult(
-      context: Context,
-      input: Void?
-    ): SynchronousResult<Bitmap?>? = null
-
-    override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
-      val photoUriVal = photoUri.value
-      val photoTmpFileVal = photoTmpFile.value
-      return if (resultCode == Activity.RESULT_OK && photoUriVal != null && photoTmpFileVal != null) {
-        val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, photoUriVal)
-        val bitmap = ImageDecoder.decodeBitmap(source)
-        photoTmpFileVal.delete()
-        bitmap
-      } else {
-        Log.e(TAG, "Getting image from camera cancelled or failed.")
-        photoTmpFile.value?.delete()
-        null
+  val cameraLauncher = rememberCameraLauncher { uri: Uri? ->
+    if (uri != null) {
+      val bitmap: Bitmap? = getBitmapFromUri(uri)
+      if (bitmap != null) {
+        val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+        composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(listOf(imagePreview), listOf(UploadContent.SimpleImage(uri))))
       }
     }
   }
-
-  val cameraLauncher = rememberLauncherForActivityResult(contract = ComposeTakePicturePreview()) { bitmap: Bitmap? ->
-    if (bitmap != null) {
-      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
-      chosenContent.value = listOf(UploadContent.SimpleImage(bitmap))
-      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(listOf(imagePreview)))
-    }
-  }
   val cameraPermissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
     if (isGranted) {
-      cameraLauncher.launch(null)
+      cameraLauncher.launchWithFallback()
     } else {
       Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
     }
@@ -198,23 +207,25 @@ fun ComposeView(
     val content = ArrayList<UploadContent>()
     val imagesPreview = ArrayList<String>()
     uris.forEach { uri ->
-      val source = ImageDecoder.createSource(context.contentResolver, uri)
-      val drawable = ImageDecoder.decodeDrawable(source)
-      var bitmap: Bitmap? = ImageDecoder.decodeBitmap(source)
-      if (drawable is AnimatedImageDrawable) {
+      val drawable = getDrawableFromUri(uri)
+      var bitmap: Bitmap? = if (drawable != null) getBitmapFromUri(uri) else null
+      val isAnimNewApi = Build.VERSION.SDK_INT >= 28 && drawable is AnimatedImageDrawable
+      val isAnimOldApi = Build.VERSION.SDK_INT < 28 &&
+          (getFileName(SimplexApp.context, uri)?.endsWith(".gif") == true || getFileName(SimplexApp.context, uri)?.endsWith(".webp") == true)
+      if (isAnimNewApi || isAnimOldApi) {
         // It's a gif or webp
         val fileSize = getFileSize(context, uri)
-        if (fileSize != null && fileSize <= MAX_FILE_SIZE) {
+        if (fileSize != null && fileSize <= maxFileSize) {
           content.add(UploadContent.AnimatedImage(uri))
         } else {
           bitmap = null
           AlertManager.shared.showAlertMsg(
             generalGetString(R.string.large_file),
-            String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(MAX_FILE_SIZE))
+            String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(maxFileSize))
           )
         }
       } else {
-        if (bitmap != null) content.add(UploadContent.SimpleImage(bitmap))
+        content.add(UploadContent.SimpleImage(uri))
       }
       if (bitmap != null) {
         imagesPreview.add(resizeImageToStrSize(bitmap, maxDataSize = 14000))
@@ -222,37 +233,53 @@ fun ComposeView(
     }
 
     if (imagesPreview.isNotEmpty()) {
-      chosenContent.value = content
-      composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.ImagePreview(imagesPreview))
+      composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.ImagePreview(imagesPreview, content))
+    }
+  }
+  val processPickedVideo = { uris: List<Uri>, text: String? ->
+    val content = ArrayList<UploadContent>()
+    val imagesPreview = ArrayList<String>()
+    uris.forEach { uri ->
+      val (bitmap: Bitmap?, durationMs: Long?) = getBitmapFromVideo(uri)
+      content.add(UploadContent.Video(uri, durationMs?.div(1000)?.toInt() ?: 0))
+      if (bitmap != null) {
+        imagesPreview.add(resizeImageToStrSize(bitmap, maxDataSize = 14000))
+      }
+    }
+
+    if (imagesPreview.isNotEmpty()) {
+      composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.VideoPreview(imagesPreview, content))
     }
   }
   val processPickedFile = { uri: Uri?, text: String? ->
     if (uri != null) {
       val fileSize = getFileSize(context, uri)
-      if (fileSize != null && fileSize <= MAX_FILE_SIZE) {
+      if (fileSize != null && fileSize <= maxFileSize) {
         val fileName = getFileName(SimplexApp.context, uri)
         if (fileName != null) {
-          chosenFile.value = uri
-          composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.FilePreview(fileName))
+          composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.FilePreview(fileName, uri))
         }
       } else {
         AlertManager.shared.showAlertMsg(
           generalGetString(R.string.large_file),
-          String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(MAX_FILE_SIZE))
+          String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(maxFileSize))
         )
       }
     }
   }
-  val galleryLauncher = rememberLauncherForActivityResult(contract = PickFromGallery()) { processPickedImage(it, null) }
-  val galleryLauncherFallback = rememberGetMultipleContentsLauncher { processPickedImage(it, null) }
+  val galleryImageLauncher = rememberLauncherForActivityResult(contract = PickMultipleImagesFromGallery()) { processPickedImage(it, null) }
+  val galleryImageLauncherFallback = rememberGetMultipleContentsLauncher { processPickedImage(it, null) }
+  val galleryVideoLauncher = rememberLauncherForActivityResult(contract = PickMultipleVideosFromGallery()) { processPickedVideo(it, null) }
+  val galleryVideoLauncherFallback = rememberGetMultipleContentsLauncher { processPickedVideo(it, null) }
   val filesLauncher = rememberGetContentLauncher { processPickedFile(it, null) }
+  val recState: MutableState<RecordingState> = remember { mutableStateOf(RecordingState.NotStarted) }
 
   LaunchedEffect(attachmentOption.value) {
     when (attachmentOption.value) {
       AttachmentOption.TakePhoto -> {
         when (PackageManager.PERMISSION_GRANTED) {
           ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
-            cameraLauncher.launch(null)
+            cameraLauncher.launchWithFallback()
           }
           else -> {
             cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
@@ -262,9 +289,17 @@ fun ComposeView(
       }
       AttachmentOption.PickImage -> {
         try {
-          galleryLauncher.launch(0)
+          galleryImageLauncher.launch(0)
         } catch (e: ActivityNotFoundException) {
-          galleryLauncherFallback.launch("image/*")
+          galleryImageLauncherFallback.launch("image/*")
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.PickVideo -> {
+        try {
+          galleryVideoLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryVideoLauncherFallback.launch("video/*")
         }
         attachmentOption.value = null
       }
@@ -323,117 +358,179 @@ fun ComposeView(
     cancelledLinks.clear()
   }
 
-  fun checkLinkPreview(): MsgContent {
+  fun clearState(live: Boolean = false) {
+    if (live) {
+      composeState.value = composeState.value.copy(inProgress = false)
+    } else {
+      composeState.value = ComposeState(useLinkPreviews = useLinkPreviews)
+      resetLinkPreview()
+    }
+    recState.value = RecordingState.NotStarted
+    textStyle.value = smallFont
+    chatModel.removeLiveDummy()
+  }
+
+  fun deleteUnusedFiles() {
+    chatModel.filesToDelete.forEach { it.delete() }
+    chatModel.filesToDelete.clear()
+  }
+
+  suspend fun send(cInfo: ChatInfo, mc: MsgContent, quoted: Long?, file: String? = null, live: Boolean = false): ChatItem? {
+    val aChatItem = chatModel.controller.apiSendMessage(
+      type = cInfo.chatType,
+      id = cInfo.apiId,
+      file = file,
+      quotedItemId = quoted,
+      mc = mc,
+      live = live
+    )
+    if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
+    return aChatItem?.chatItem
+  }
+
+
+
+  suspend fun sendMessageAsync(text: String?, live: Boolean): ChatItem? {
+    val cInfo = chat.chatInfo
     val cs = composeState.value
-    return when (val composePreview = cs.preview) {
-      is ComposePreview.CLinkPreview -> {
-        val url = parseMessage(cs.message)
-        val lp = composePreview.linkPreview
-        if (lp != null && url == lp.uri) {
-          MsgContent.MCLink(cs.message, preview = lp)
-        } else {
-          MsgContent.MCText(cs.message)
+    var sent: ChatItem?
+    val msgText = text ?: cs.message
+
+    fun sending() {
+      composeState.value = composeState.value.copy(inProgress = true)
+    }
+
+    fun checkLinkPreview(): MsgContent {
+      return when (val composePreview = cs.preview) {
+        is ComposePreview.CLinkPreview -> {
+          val url = parseMessage(msgText)
+          val lp = composePreview.linkPreview
+          if (lp != null && url == lp.uri) {
+            MsgContent.MCLink(msgText, preview = lp)
+          } else {
+            MsgContent.MCText(msgText)
+          }
+        }
+        else -> MsgContent.MCText(msgText)
+      }
+    }
+
+    fun updateMsgContent(msgContent: MsgContent): MsgContent {
+      return when (msgContent) {
+        is MsgContent.MCText -> checkLinkPreview()
+        is MsgContent.MCLink -> checkLinkPreview()
+        is MsgContent.MCImage -> MsgContent.MCImage(msgText, image = msgContent.image)
+        is MsgContent.MCVideo -> MsgContent.MCVideo(msgText, image = msgContent.image, duration = msgContent.duration)
+        is MsgContent.MCVoice -> MsgContent.MCVoice(msgText, duration = msgContent.duration)
+        is MsgContent.MCFile -> MsgContent.MCFile(msgText)
+        is MsgContent.MCUnknown -> MsgContent.MCUnknown(type = msgContent.type, text = msgText, json = msgContent.json)
+      }
+    }
+
+    suspend fun updateMessage(ei: ChatItem, cInfo: ChatInfo, live: Boolean): ChatItem? {
+      val oldMsgContent = ei.content.msgContent
+      if (oldMsgContent != null) {
+        val updatedItem = chatModel.controller.apiUpdateChatItem(
+          type = cInfo.chatType,
+          id = cInfo.apiId,
+          itemId = ei.meta.itemId,
+          mc = updateMsgContent(oldMsgContent),
+          live = live
+        )
+        if (updatedItem != null) chatModel.upsertChatItem(cInfo, updatedItem.chatItem)
+        return updatedItem?.chatItem
+      }
+      return null
+    }
+
+    val liveMessage = cs.liveMessage
+    if (!live) {
+      if (liveMessage != null) composeState.value = cs.copy(liveMessage = null)
+      sending()
+    }
+
+    if (cs.contextItem is ComposeContextItem.EditingItem) {
+      val ei = cs.contextItem.chatItem
+      sent = updateMessage(ei, cInfo, live)
+    } else if (liveMessage != null && liveMessage.sent) {
+      sent = updateMessage(liveMessage.chatItem, cInfo, live)
+    } else {
+      val msgs: ArrayList<MsgContent> = ArrayList()
+      val files: ArrayList<String> = ArrayList()
+      when (val preview = cs.preview) {
+        ComposePreview.NoPreview -> msgs.add(MsgContent.MCText(msgText))
+        is ComposePreview.CLinkPreview -> msgs.add(checkLinkPreview())
+        is ComposePreview.ImagePreview -> {
+          preview.content.forEachIndexed { index, it ->
+            val file = when (it) {
+              is UploadContent.SimpleImage -> saveImage(context, it.uri)
+              is UploadContent.AnimatedImage -> saveAnimImage(context, it.uri)
+              else -> return@forEachIndexed
+            }
+            if (file != null) {
+              files.add(file)
+              msgs.add(MsgContent.MCImage(if (preview.content.lastIndex == index) msgText else "", preview.images[index]))
+            }
+          }
+        }
+        is ComposePreview.VideoPreview -> {
+          preview.content.forEachIndexed { index, it ->
+            val file = when (it) {
+              is UploadContent.Video -> saveFileFromUri(context, it.uri)
+              else -> return@forEachIndexed
+            }
+            if (file != null) {
+              files.add(file)
+              msgs.add(MsgContent.MCVideo(if (preview.content.lastIndex == index) msgText else "", preview.images[index], it.duration))
+            }
+          }
+        }
+        is ComposePreview.VoicePreview -> {
+          val tmpFile = File(preview.voice)
+          AudioPlayer.stop(tmpFile.absolutePath)
+          val actualFile = File(getAppFilePath(SimplexApp.context, tmpFile.name.replaceAfter(RecorderNative.extension, "")))
+          withContext(Dispatchers.IO) {
+            Files.move(tmpFile.toPath(), actualFile.toPath())
+          }
+          files.add(actualFile.name)
+          deleteUnusedFiles()
+          msgs.add(MsgContent.MCVoice(if (msgs.isEmpty()) msgText else "", preview.durationMs / 1000))
+        }
+        is ComposePreview.FilePreview -> {
+          val file = saveFileFromUri(context, preview.uri)
+          if (file != null) {
+            files.add((file))
+            msgs.add(MsgContent.MCFile(if (msgs.isEmpty()) msgText else ""))
+          }
         }
       }
-      else -> MsgContent.MCText(cs.message)
+      val quotedItemId: Long? = when (cs.contextItem) {
+        is ComposeContextItem.QuotedItem -> cs.contextItem.chatItem.id
+        else -> null
+      }
+      sent = null
+      msgs.forEachIndexed { index, content ->
+        if (index > 0) delay(100)
+        sent = send(cInfo, content, if (index == 0) quotedItemId else null, files.getOrNull(index),
+          if (content !is MsgContent.MCVoice && index == msgs.lastIndex) live else false
+        )
+      }
+      if (sent == null &&
+        (cs.preview is ComposePreview.ImagePreview ||
+            cs.preview is ComposePreview.VideoPreview ||
+            cs.preview is ComposePreview.FilePreview ||
+            cs.preview is ComposePreview.VoicePreview)
+        ) {
+        sent = send(cInfo, MsgContent.MCText(msgText), quotedItemId, null, live)
+      }
     }
-  }
-
-  fun updateMsgContent(msgContent: MsgContent): MsgContent {
-    val cs = composeState.value
-    return when (msgContent) {
-      is MsgContent.MCText -> checkLinkPreview()
-      is MsgContent.MCLink -> checkLinkPreview()
-      is MsgContent.MCImage -> MsgContent.MCImage(cs.message, image = msgContent.image)
-      is MsgContent.MCFile -> MsgContent.MCFile(cs.message)
-      is MsgContent.MCUnknown -> MsgContent.MCUnknown(type = msgContent.type, text = cs.message, json = msgContent.json)
-    }
-  }
-
-  fun clearState() {
-    composeState.value = ComposeState(useLinkPreviews = useLinkPreviews)
-    textStyle.value = smallFont
-    chosenContent.value = emptyList()
-    chosenFile.value = null
-    linkUrl.value = null
-    prevLinkUrl.value = null
-    pendingLinkUrl.value = null
-    cancelledLinks.clear()
+    clearState(live)
+    return sent
   }
 
   fun sendMessage() {
-    composeState.value = composeState.value.copy(inProgress = true)
-    val cInfo = chat.chatInfo
-    val cs = composeState.value
-    when (val contextItem = cs.contextItem) {
-      is ComposeContextItem.EditingItem -> {
-        val ei = contextItem.chatItem
-        val oldMsgContent = ei.content.msgContent
-        if (oldMsgContent != null) {
-          withApi {
-            val updatedItem = chatModel.controller.apiUpdateChatItem(
-              type = cInfo.chatType,
-              id = cInfo.apiId,
-              itemId = ei.meta.itemId,
-              mc = updateMsgContent(oldMsgContent)
-            )
-            if (updatedItem != null) chatModel.upsertChatItem(cInfo, updatedItem.chatItem)
-            clearState()
-          }
-        }
-      }
-      else -> {
-        val msgs: ArrayList<MsgContent> = ArrayList()
-        val files: ArrayList<String> = ArrayList()
-        when (val preview = cs.preview) {
-          ComposePreview.NoPreview -> msgs.add(MsgContent.MCText(cs.message))
-          is ComposePreview.CLinkPreview -> msgs.add(checkLinkPreview())
-          is ComposePreview.ImagePreview -> {
-            chosenContent.value.forEachIndexed { index, it ->
-              val file = when (it) {
-                is UploadContent.SimpleImage -> saveImage(context, it.bitmap)
-                is UploadContent.AnimatedImage -> saveAnimImage(context, it.uri)
-              }
-              if (file != null) {
-                files.add(file)
-                msgs.add(MsgContent.MCImage(if (msgs.isEmpty()) cs.message else "", preview.images[index]))
-              }
-            }
-          }
-          is ComposePreview.FilePreview -> {
-            val chosenFileVal = chosenFile.value
-            if (chosenFileVal != null) {
-              val file = saveFileFromUri(context, chosenFileVal)
-              if (file != null) {
-                files.add((file))
-                msgs.add(MsgContent.MCFile(if (msgs.isEmpty()) cs.message else ""))
-              }
-            }
-          }
-        }
-        val quotedItemId: Long? = when (contextItem) {
-          is ComposeContextItem.QuotedItem -> contextItem.chatItem.id
-          else -> null
-        }
-        if (msgs.isNotEmpty()) {
-          withApi {
-            msgs.forEachIndexed { index, content ->
-              if (index > 0) delay(100)
-              val aChatItem = chatModel.controller.apiSendMessage(
-                type = cInfo.chatType,
-                id = cInfo.apiId,
-                file = files.getOrNull(index),
-                quotedItemId = if (index == 0) quotedItemId else null,
-                mc = content
-              )
-              if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
-            }
-            clearState()
-          }
-        } else {
-          clearState()
-        }
-      }
+    withBGApi {
+      sendMessageAsync(null, false)
     }
   }
 
@@ -450,6 +547,19 @@ fun ComposeView(
     }
   }
 
+  fun onAudioAdded(filePath: String, durationMs: Int, finished: Boolean) {
+    val file = File(filePath)
+    chatModel.filesToDelete.add(file)
+    composeState.value = composeState.value.copy(preview = ComposePreview.VoicePreview(filePath, durationMs, finished))
+  }
+
+  fun allowVoiceToContact() {
+    val contact = (chat.chatInfo as ChatInfo.Direct?)?.contact ?: return
+    withApi {
+      chatModel.controller.allowFeatureToContact(contact, ChatFeature.Voice)
+    }
+  }
+
   fun cancelLinkPreview() {
     val uri = composeState.value.linkPreview?.uri
     if (uri != null) {
@@ -461,12 +571,70 @@ fun ComposeView(
 
   fun cancelImages() {
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
-    chosenContent.value = emptyList()
+  }
+
+  fun cancelVoice() {
+    val filePath = recState.value.filePathNullable
+    recState.value = RecordingState.NotStarted
+    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+    withBGApi {
+      RecorderNative.stopRecording?.invoke()
+      AudioPlayer.stop(filePath)
+      filePath?.let { File(it).delete() }
+    }
   }
 
   fun cancelFile() {
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
-    chosenFile.value = null
+  }
+
+  fun truncateToWords(s: String): String {
+    var acc = ""
+    val word = StringBuilder()
+    for (c in s) {
+      if (c.isLetter() || c.isDigit()) {
+        word.append(c)
+      } else {
+        acc = acc + word.toString() + c
+        word.clear()
+      }
+    }
+    return acc
+  }
+
+  suspend fun sendLiveMessage() {
+    val cs = composeState.value
+    val typedMsg = cs.message
+    if ((cs.sendEnabled() || cs.contextItem is ComposeContextItem.QuotedItem) && (cs.liveMessage == null || !cs.liveMessage?.sent)) {
+      val ci = sendMessageAsync(typedMsg, live = true)
+      if (ci != null) {
+        composeState.value = composeState.value.copy(liveMessage = LiveMessage(ci, typedMsg = typedMsg, sentMsg = typedMsg, sent = true))
+      }
+    } else if (cs.liveMessage == null) {
+      val cItem = chatModel.addLiveDummy(chat.chatInfo)
+      composeState.value = composeState.value.copy(liveMessage = LiveMessage(cItem, typedMsg = typedMsg, sentMsg = typedMsg, sent = false))
+    }
+  }
+
+  fun liveMessageToSend(lm: LiveMessage, t: String): String? {
+    val s = if (t != lm.typedMsg) truncateToWords(t) else t
+    return if (s != lm.sentMsg) s else null
+  }
+
+  suspend fun updateLiveMessage() {
+    val typedMsg = composeState.value.message
+    val liveMessage = composeState.value.liveMessage
+    if (liveMessage != null) {
+      val sentMsg = liveMessageToSend(liveMessage, typedMsg)
+      if (sentMsg != null) {
+        val ci = sendMessageAsync(sentMsg, live = true)
+        if (ci != null) {
+          composeState.value = composeState.value.copy(liveMessage = LiveMessage(ci, typedMsg = typedMsg, sentMsg = sentMsg, sent = true))
+        }
+      } else if (liveMessage.typedMsg != typedMsg) {
+        composeState.value = composeState.value.copy(liveMessage = liveMessage.copy(typedMsg = typedMsg))
+      }
+    }
   }
 
   @Composable
@@ -479,6 +647,18 @@ fun ComposeView(
         ::cancelImages,
         cancelEnabled = !composeState.value.editing
       )
+      is ComposePreview.VideoPreview -> ComposeImageView(
+        preview.images,
+        ::cancelImages,
+        cancelEnabled = !composeState.value.editing
+      )
+      is ComposePreview.VoicePreview -> ComposeVoiceView(
+        preview.voice,
+        preview.durationMs,
+        preview.finished,
+        cancelEnabled = !composeState.value.editing,
+        ::cancelVoice
+      )
       is ComposePreview.FilePreview -> ComposeFileView(
         preview.fileName,
         ::cancelFile,
@@ -501,6 +681,9 @@ fun ComposeView(
   }
 
   LaunchedEffect(chatModel.sharedContent.value) {
+    // Important. If it's null, don't do anything, chat is not closed yet but will be after a moment
+    if (chatModel.chatId.value == null) return@LaunchedEffect
+
     when (val shared = chatModel.sharedContent.value) {
       is SharedContent.Text -> onMessageChange(shared.text)
       is SharedContent.Images -> processPickedImage(shared.uris, shared.text)
@@ -510,47 +693,133 @@ fun ComposeView(
     chatModel.sharedContent.value = null
   }
 
+  val userCanSend = rememberUpdatedState(chat.userCanSend)
+  val userIsObserver = rememberUpdatedState(chat.userIsObserver)
+
   Column {
     contextItemView()
     when {
+      composeState.value.editing && composeState.value.preview is ComposePreview.VoicePreview -> {}
       composeState.value.editing && composeState.value.preview is ComposePreview.FilePreview -> {}
       else -> previewView()
     }
     Row(
-      modifier = Modifier.padding(start = 4.dp, end = 8.dp),
+      modifier = Modifier.padding(end = 8.dp),
       verticalAlignment = Alignment.Bottom,
-      horizontalArrangement = Arrangement.spacedBy(2.dp)
     ) {
-      val attachEnabled = !composeState.value.editing
-      Box(Modifier.padding(bottom = 12.dp)) {
+      IconButton(showChooseAttachment, enabled = !composeState.value.attachmentDisabled && rememberUpdatedState(chat.userCanSend).value) {
         Icon(
           Icons.Filled.AttachFile,
           contentDescription = stringResource(R.string.attach),
-          tint = if (attachEnabled) MaterialTheme.colors.primary else Color.Gray,
+          tint = if (!composeState.value.attachmentDisabled && userCanSend.value) MaterialTheme.colors.primary else HighOrLowlight,
           modifier = Modifier
             .size(28.dp)
             .clip(CircleShape)
-            .clickable {
-              if (attachEnabled) {
-                showChooseAttachment()
-              }
-            }
         )
       }
+      val allowedVoiceByPrefs = remember(chat.chatInfo) { chat.chatInfo.featureEnabled(ChatFeature.Voice) }
+      LaunchedEffect(allowedVoiceByPrefs) {
+        if (!allowedVoiceByPrefs && composeState.value.preview is ComposePreview.VoicePreview) {
+          // Voice was disabled right when this user records it, just cancel it
+          cancelVoice()
+        }
+      }
+      val needToAllowVoiceToContact = remember(chat.chatInfo) {
+        chat.chatInfo is ChatInfo.Direct && with(chat.chatInfo.contact.mergedPreferences.voice) {
+          ((userPreference as? ContactUserPref.User)?.preference?.allow == FeatureAllowed.NO || (userPreference as? ContactUserPref.Contact)?.preference?.allow == FeatureAllowed.NO) &&
+              contactPreference.allow == FeatureAllowed.YES
+        }
+      }
+      LaunchedEffect(Unit) {
+        snapshotFlow { recState.value }
+          .distinctUntilChanged()
+          .collect {
+            when(it) {
+              is RecordingState.Started -> onAudioAdded(it.filePath, it.progressMs, false)
+              is RecordingState.Finished -> onAudioAdded(it.filePath, it.durationMs, true)
+              is RecordingState.NotStarted -> {}
+            }
+          }
+      }
+
+      fun clearCurrentDraft() {
+        if (chatModel.draftChatId.value == chat.id) {
+          chatModel.draft.value = null
+          chatModel.draftChatId.value = null
+        }
+      }
+
+      LaunchedEffect(rememberUpdatedState(chat.userCanSend).value) {
+        if (!chat.userCanSend) {
+          clearCurrentDraft()
+          clearState()
+        }
+      }
+
+      val activity = LocalContext.current as Activity
+      DisposableEffect(Unit) {
+        val orientation = activity.resources.configuration.orientation
+        onDispose {
+          if (orientation == activity.resources.configuration.orientation) {
+            val cs = composeState.value
+            if (cs.liveMessage != null && (cs.message.isNotEmpty() || cs.liveMessage.sent)) {
+              sendMessage()
+              resetLinkPreview()
+              clearCurrentDraft()
+              deleteUnusedFiles()
+            } else if (!composeState.value.empty) {
+              if (cs.preview is ComposePreview.VoicePreview && !cs.preview.finished) {
+                composeState.value = cs.copy(preview = cs.preview.copy(finished = true))
+              }
+              chatModel.draft.value = composeState.value
+              chatModel.draftChatId.value = chat.id
+            } else {
+              clearCurrentDraft()
+              deleteUnusedFiles()
+            }
+            chatModel.removeLiveDummy()
+          }
+        }
+      }
+
       SendMsgView(
         composeState,
+        showVoiceRecordIcon = true,
+        recState,
+        chat.chatInfo is ChatInfo.Direct,
+        liveMessageAlertShown = chatModel.controller.appPrefs.liveMessageAlertShown,
+        needToAllowVoiceToContact,
+        allowedVoiceByPrefs,
+        allowVoiceToContact = ::allowVoiceToContact,
+        userIsObserver = userIsObserver.value,
+        userCanSend = userCanSend.value,
         sendMessage = {
           sendMessage()
           resetLinkPreview()
         },
-        ::onMessageChange,
-        textStyle
+        sendLiveMessage = ::sendLiveMessage,
+        updateLiveMessage = ::updateLiveMessage,
+        cancelLiveMessage = {
+          composeState.value = composeState.value.copy(liveMessage = null)
+          chatModel.removeLiveDummy()
+        },
+        onMessageChange = ::onMessageChange,
+        textStyle = textStyle
       )
     }
   }
 }
 
-class PickFromGallery: ActivityResultContract<Int, List<Uri>>() {
+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)
@@ -575,3 +844,30 @@ class PickFromGallery: ActivityResultContract<Int, List<Uri>>() {
     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(R.string.videos_limit_title, R.string.videos_limit_desc)
+        }
+        uris
+      }
+    else
+      emptyList()
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/ComposeVoiceView.kt

@@ -0,0 +1,133 @@
+import androidx.compose.animation.core.Animatable
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.Close
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.durationText
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.item.SentColorLight
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.flow.distinctUntilChanged
+
+@Composable
+fun ComposeVoiceView(
+  filePath: String,
+  recordedDurationMs: Int,
+  finishedRecording: Boolean,
+  cancelEnabled: Boolean,
+  cancelVoice: () -> Unit
+) {
+  BoxWithConstraints(Modifier
+    .fillMaxWidth()
+  ) {
+    val audioPlaying = rememberSaveable { mutableStateOf(false) }
+    val progress = rememberSaveable { mutableStateOf(0) }
+    val duration = rememberSaveable(recordedDurationMs) { mutableStateOf(recordedDurationMs) }
+    val progressBarWidth = remember { Animatable(0f) }
+    LaunchedEffect(recordedDurationMs, finishedRecording) {
+      snapshotFlow { progress.value }
+        .distinctUntilChanged()
+        .collect {
+          val startTime = when {
+            finishedRecording -> progress.value
+            else -> recordedDurationMs
+          }
+          val endTime = when {
+            finishedRecording -> duration.value
+            audioPlaying.value -> recordedDurationMs
+            else -> MAX_VOICE_MILLIS_FOR_SENDING
+          }
+          val to = ((startTime.toDouble() / endTime) * maxWidth.value).dp
+          progressBarWidth.animateTo(to.value, audioProgressBarAnimationSpec())
+        }
+    }
+    Spacer(
+      Modifier
+        .requiredWidth(progressBarWidth.value.dp)
+        .padding(top = 58.dp)
+        .height(3.dp)
+        .background(MaterialTheme.colors.primary)
+    )
+    Row(
+      Modifier
+        .height(60.dp)
+        .fillMaxWidth()
+        .padding(top = 8.dp)
+        .background(SentColorLight),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      IconButton(
+        onClick = {
+          if (!audioPlaying.value) {
+            AudioPlayer.play(filePath, audioPlaying, progress, duration, false)
+          } else {
+            AudioPlayer.pause(audioPlaying, progress)
+          }
+        },
+        enabled = finishedRecording) {
+        Icon(
+          if (audioPlaying.value) Icons.Filled.Pause else Icons.Filled.PlayArrow,
+          stringResource(R.string.icon_descr_file),
+          Modifier
+            .padding(start = 4.dp, end = 2.dp)
+            .size(36.dp),
+          tint = if (finishedRecording) MaterialTheme.colors.primary else HighOrLowlight
+        )
+      }
+      val numberInText = remember(recordedDurationMs, progress.value) {
+        derivedStateOf {
+          when {
+            finishedRecording && progress.value == 0 && !audioPlaying.value -> duration.value / 1000
+            finishedRecording -> progress.value / 1000
+            else -> recordedDurationMs / 1000
+          }
+        }
+      }
+      Text(
+        durationText(numberInText.value),
+        fontSize = 18.sp,
+        color = HighOrLowlight,
+      )
+      Spacer(Modifier.weight(1f))
+      if (cancelEnabled) {
+        IconButton(
+          onClick = {
+            AudioPlayer.stop(filePath)
+            cancelVoice()
+          },
+          modifier = Modifier.padding(0.dp)
+        ) {
+          Icon(
+            Icons.Outlined.Close,
+            contentDescription = stringResource(R.string.icon_descr_cancel_file_preview),
+            tint = MaterialTheme.colors.primary,
+            modifier = Modifier.padding(10.dp)
+          )
+        }
+      }
+    }
+  }
+}
+
+@Preview
+@Composable
+fun PreviewComposeAudioView() {
+  SimpleXTheme {
+    ComposeFileView(
+      "test.txt",
+      cancelFile = {},
+      cancelEnabled = true
+    )
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/ContactPreferences.kt

@@ -0,0 +1,232 @@
+package chat.simplex.app.views.chat
+
+import InfoRow
+import SectionDivider
+import SectionItemView
+import SectionSpacer
+import SectionTextFooter
+import SectionView
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+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.res.stringResource
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.PreferenceToggle
+
+@Composable
+fun ContactPreferencesView(
+  m: ChatModel,
+  user: User,
+  contactId: Long,
+  close: () -> Unit,
+) {
+  val contact = remember { derivedStateOf { (m.getContactChat(contactId)?.chatInfo as? ChatInfo.Direct)?.contact } }
+  val ct = contact.value ?: return
+  var featuresAllowed by rememberSaveable(ct, stateSaver = serializableSaver()) { mutableStateOf(contactUserPrefsToFeaturesAllowed(ct.mergedPreferences)) }
+  var currentFeaturesAllowed by rememberSaveable(ct, stateSaver = serializableSaver()) { mutableStateOf(featuresAllowed) }
+
+  fun savePrefs(afterSave: () -> Unit = {}) {
+    withApi {
+      val prefs = contactFeaturesAllowedToPrefs(featuresAllowed)
+      val toContact = m.controller.apiSetContactPrefs(ct.contactId, prefs)
+      if (toContact != null) {
+        m.updateContact(toContact)
+        currentFeaturesAllowed = featuresAllowed
+      }
+      afterSave()
+    }
+  }
+  ModalView(
+    close = {
+      if (featuresAllowed == currentFeaturesAllowed) close()
+      else showUnsavedChangesAlert({ savePrefs(close) }, close)
+    },
+    background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+  ) {
+    ContactPreferencesLayout(
+      featuresAllowed,
+      currentFeaturesAllowed,
+      user,
+      ct,
+      applyPrefs = { prefs ->
+        featuresAllowed = prefs
+      },
+      reset = {
+        featuresAllowed = currentFeaturesAllowed
+      },
+      savePrefs = ::savePrefs,
+    )
+  }
+}
+
+@Composable
+private fun ContactPreferencesLayout(
+  featuresAllowed: ContactFeaturesAllowed,
+  currentFeaturesAllowed: ContactFeaturesAllowed,
+  user: User,
+  contact: Contact,
+  applyPrefs: (ContactFeaturesAllowed) -> Unit,
+  reset: () -> Unit,
+  savePrefs: () -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxWidth()
+      .verticalScroll(rememberScrollState())
+      .padding(bottom = DEFAULT_PADDING),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    AppBarTitle(stringResource(R.string.contact_preferences))
+    val timedMessages: MutableState<Boolean> = remember(featuresAllowed) { mutableStateOf(featuresAllowed.timedMessagesAllowed) }
+    val onTTLUpdated = { ttl: Int? ->
+      applyPrefs(featuresAllowed.copy(timedMessagesTTL = ttl ?: 86400))
+    }
+    TimedMessagesFeatureSection(featuresAllowed, contact.mergedPreferences.timedMessages, timedMessages, onTTLUpdated) { allowed, ttl ->
+      applyPrefs(featuresAllowed.copy(timedMessagesAllowed = allowed, timedMessagesTTL = ttl ?: currentFeaturesAllowed.timedMessagesTTL))
+    }
+    SectionSpacer()
+    val allowFullDeletion: MutableState<ContactFeatureAllowed> = remember(featuresAllowed) { mutableStateOf(featuresAllowed.fullDelete) }
+    FeatureSection(ChatFeature.FullDelete, user.fullPreferences.fullDelete.allow, contact.mergedPreferences.fullDelete, allowFullDeletion) {
+      applyPrefs(featuresAllowed.copy(fullDelete = it))
+    }
+    SectionSpacer()
+    val allowVoice: MutableState<ContactFeatureAllowed> = remember(featuresAllowed) { mutableStateOf(featuresAllowed.voice) }
+    FeatureSection(ChatFeature.Voice, user.fullPreferences.voice.allow, contact.mergedPreferences.voice, allowVoice) {
+      applyPrefs(featuresAllowed.copy(voice = it))
+    }
+    SectionSpacer()
+    ResetSaveButtons(
+      reset = reset,
+      save = savePrefs,
+      disabled = featuresAllowed == currentFeaturesAllowed
+    )
+  }
+}
+
+@Composable
+private fun FeatureSection(
+  feature: ChatFeature,
+  userDefault: FeatureAllowed,
+  pref: ContactUserPreference,
+  allowFeature: State<ContactFeatureAllowed>,
+  onSelected: (ContactFeatureAllowed) -> Unit
+) {
+  val enabled = FeatureEnabled.enabled(
+    feature.asymmetric,
+    user = SimpleChatPreference(allow = allowFeature.value.allowed),
+    contact = pref.contactPreference
+  )
+
+  SectionView(
+    feature.text.uppercase(),
+    icon = feature.iconFilled,
+    iconTint = if (enabled.forUser) SimplexGreen else if (enabled.forContact) WarningYellow else Color.Red,
+    leadingIcon = true,
+  ) {
+    SectionItemView {
+      ExposedDropDownSettingRow(
+        generalGetString(R.string.chat_preferences_you_allow),
+        ContactFeatureAllowed.values(userDefault).map { it to it.text },
+        allowFeature,
+        icon = null,
+        onSelected = onSelected
+      )
+    }
+    SectionDivider()
+    InfoRow(
+      generalGetString(R.string.chat_preferences_contact_allows),
+      pref.contactPreference.allow.text
+    )
+  }
+  SectionTextFooter(feature.enabledDescription(enabled))
+}
+
+@Composable
+private fun TimedMessagesFeatureSection(
+  featuresAllowed: ContactFeaturesAllowed,
+  pref: ContactUserPreferenceTimed,
+  allowFeature: State<Boolean>,
+  onTTLUpdated: (Int?) -> Unit,
+  onSelected: (Boolean, Int?) -> Unit
+) {
+  val enabled = FeatureEnabled.enabled(
+    ChatFeature.TimedMessages.asymmetric,
+    user = TimedMessagesPreference(allow = if (allowFeature.value) FeatureAllowed.YES else FeatureAllowed.NO),
+    contact = pref.contactPreference
+  )
+
+  SectionView(
+    ChatFeature.TimedMessages.text.uppercase(),
+    icon = ChatFeature.TimedMessages.iconFilled,
+    iconTint = if (enabled.forUser) SimplexGreen else if (enabled.forContact) WarningYellow else Color.Red,
+    leadingIcon = true,
+  ) {
+    SectionItemView {
+      PreferenceToggle(
+        generalGetString(R.string.chat_preferences_you_allow),
+        checked = allowFeature.value,
+      ) { allow ->
+        onSelected(allow, if (allow) featuresAllowed.timedMessagesTTL ?: 86400 else null)
+      }
+    }
+    SectionDivider()
+    InfoRow(
+      generalGetString(R.string.chat_preferences_contact_allows),
+      pref.contactPreference.allow.text
+    )
+    SectionDivider()
+    if (featuresAllowed.timedMessagesAllowed) {
+      val ttl = rememberSaveable(featuresAllowed.timedMessagesTTL) { mutableStateOf(featuresAllowed.timedMessagesTTL) }
+      TimedMessagesTTLPicker(ttl, onTTLUpdated)
+    } else if (pref.contactPreference.allow == FeatureAllowed.YES || pref.contactPreference.allow == FeatureAllowed.ALWAYS) {
+      InfoRow(generalGetString(R.string.delete_after), TimedMessagesPreference.ttlText(pref.contactPreference.ttl))
+    }
+  }
+  SectionTextFooter(ChatFeature.TimedMessages.enabledDescription(enabled))
+}
+
+@Composable
+private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Boolean) {
+  SectionView {
+    SectionItemView(reset, disabled = disabled) {
+      Text(stringResource(R.string.reset_verb), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+    }
+    SectionDivider()
+    SectionItemView(save, disabled = disabled) {
+      Text(stringResource(R.string.save_and_notify_contact), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+    }
+  }
+}
+
+@Composable
+fun TimedMessagesTTLPicker(selection: MutableState<Int?>, onSelected: (Int?) -> Unit) {
+  val ttlValues = TimedMessagesPreference.ttlValues
+  val values = ttlValues + if (ttlValues.contains(selection.value)) listOf() else listOf(selection.value)
+  SectionItemView {
+    ExposedDropDownSettingRow(
+      generalGetString(R.string.delete_after),
+      values.map { it to TimedMessagesPreference.ttlText(it) },
+      selection,
+      onSelected = onSelected
+    )
+  }
+}
+
+private fun showUnsavedChangesAlert(save: () -> Unit, revert: () -> Unit) {
+  AlertManager.shared.showAlertDialogStacked(
+    title = generalGetString(R.string.save_preferences_question),
+    confirmText = generalGetString(R.string.save_and_notify_contact),
+    dismissText = generalGetString(R.string.exit_without_saving),
+    onConfirm = save,
+    onDismiss = revert,
+  )
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/ContextItemView.kt

@@ -14,8 +14,7 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
-import chat.simplex.app.model.CIDirection
-import chat.simplex.app.model.ChatItem
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.chat.item.*
@@ -53,6 +52,7 @@ fun ContextItemView(
       MarkdownText(
         contextItem.text, contextItem.formattedText,
         sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3,
+        linkMode = SimplexLinkMode.DESCRIPTION,
         modifier = Modifier.fillMaxWidth(),
       )
     }

apps/android/app/src/main/java/chat/simplex/app/views/chat/ScanCodeView.kt

@@ -0,0 +1,53 @@
+package chat.simplex.app.views.chat
+
+import android.Manifest
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import chat.simplex.app.R
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.newchat.QRCodeScanner
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+fun ScanCodeView(verifyCode: (String?, cb: (Boolean) -> Unit) -> Unit, close: () -> Unit) {
+  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+  LaunchedEffect(Unit) {
+    cameraPermissionState.launchPermissionRequest()
+  }
+  ScanCodeLayout(verifyCode, close)
+}
+
+@Composable
+private fun ScanCodeLayout(verifyCode: (String?, cb: (Boolean) -> Unit) -> Unit, close: () -> Unit) {
+  Column(
+    Modifier
+      .fillMaxSize()
+      .padding(horizontal = DEFAULT_PADDING)
+  ) {
+    AppBarTitle(stringResource(R.string.scan_code), false)
+    Box(
+      Modifier
+        .fillMaxWidth()
+        .aspectRatio(ratio = 1F)
+        .padding(bottom = DEFAULT_PADDING)
+    ) {
+      QRCodeScanner { text ->
+        verifyCode(text) {
+          if (it) {
+            close()
+          } else {
+            AlertManager.shared.showAlertMsg(
+              title = generalGetString(R.string.incorrect_code)
+            )
+          }
+        }
+      }
+    }
+    Text(stringResource(R.string.scan_code_from_contacts_app))
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/SendMsgView.kt

@@ -1,157 +1,586 @@
 package chat.simplex.app.views.chat
 
+import android.Manifest
 import android.annotation.SuppressLint
+import android.app.Activity
 import android.content.Context
+import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.os.Build
 import android.text.InputType
+import android.util.Log
 import android.view.ViewGroup
+import android.view.WindowManager
 import android.view.inputmethod.*
 import android.widget.EditText
+import android.widget.TextView
+import androidx.compose.animation.core.*
 import androidx.compose.foundation.*
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Check
-import androidx.compose.material.icons.outlined.ArrowUpward
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.material.ripple.rememberRipple
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.*
+import androidx.compose.ui.draw.alpha
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.*
 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.doOnTextChanged
+import androidx.core.widget.*
 import chat.simplex.app.R
 import chat.simplex.app.SimplexApp
-import chat.simplex.app.model.ChatItem
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.SharedContent
-import kotlinx.coroutines.delay
+import chat.simplex.app.views.chat.item.ItemAction
+import chat.simplex.app.views.helpers.*
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+import kotlinx.coroutines.*
+import java.lang.reflect.Field
 
 @Composable
 fun SendMsgView(
   composeState: MutableState<ComposeState>,
+  showVoiceRecordIcon: Boolean,
+  recState: MutableState<RecordingState>,
+  isDirectChat: Boolean,
+  liveMessageAlertShown: SharedPreference<Boolean>,
+  needToAllowVoiceToContact: Boolean,
+  allowedVoiceByPrefs: Boolean,
+  userIsObserver: Boolean,
+  userCanSend: Boolean,
+  allowVoiceToContact: () -> Unit,
   sendMessage: () -> Unit,
+  sendLiveMessage: (suspend () -> Unit)? = null,
+  updateLiveMessage: (suspend () -> Unit)? = null,
+  cancelLiveMessage: (() -> Unit)? = null,
   onMessageChange: (String) -> Unit,
   textStyle: MutableState<TextStyle>
 ) {
-  val cs = composeState.value
-  var showKeyboard by remember { mutableStateOf(false) }
-  LaunchedEffect(cs.contextItem) {
-    when (cs.contextItem) {
-      is ComposeContextItem.QuotedItem -> {
-        delay(100)
-        showKeyboard = true
+  Box(Modifier.padding(vertical = 8.dp)) {
+    val cs = composeState.value
+    val showProgress = cs.inProgress && (cs.preview is ComposePreview.ImagePreview || cs.preview is ComposePreview.VideoPreview || cs.preview is ComposePreview.FilePreview)
+    val showVoiceButton = cs.message.isEmpty() && showVoiceRecordIcon && !composeState.value.editing &&
+        cs.liveMessage == null && (cs.preview is ComposePreview.NoPreview || recState.value is RecordingState.Started)
+    val showDeleteTextButton = rememberSaveable { mutableStateOf(false) }
+    NativeKeyboard(composeState, textStyle, showDeleteTextButton, userIsObserver, onMessageChange)
+    // Disable clicks on text field
+    if (cs.preview is ComposePreview.VoicePreview || !userCanSend) {
+      Box(Modifier
+        .matchParentSize()
+        .clickable(enabled = !userCanSend, indication = null, interactionSource = remember { MutableInteractionSource() }, onClick = {
+          AlertManager.shared.showAlertMsg(
+            title = generalGetString(R.string.observer_cant_send_message_title),
+            text = generalGetString(R.string.observer_cant_send_message_desc)
+          )
+        })
+      )
+    }
+    if (showDeleteTextButton.value) {
+      DeleteTextButton(composeState)
+    }
+    Box(Modifier.align(Alignment.BottomEnd)) {
+      val sendButtonSize = remember { Animatable(36f) }
+      val sendButtonAlpha = remember { Animatable(1f) }
+      val permissionsState = rememberMultiplePermissionsState(listOf(Manifest.permission.RECORD_AUDIO))
+      val scope = rememberCoroutineScope()
+      LaunchedEffect(Unit) {
+        // Making LiveMessage alive when screen orientation was changed
+        if (cs.liveMessage != null && sendLiveMessage != null && updateLiveMessage != null) {
+          startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
+        }
       }
-      is ComposeContextItem.EditingItem -> {
-        // Keyboard will not show up if we try to show it too fast
-        delay(300)
-        showKeyboard = true
+      when {
+        showProgress -> ProgressIndicator()
+        showVoiceButton -> {
+          Row(verticalAlignment = Alignment.CenterVertically) {
+            val stopRecOnNextClick = remember { mutableStateOf(false) }
+            when {
+              needToAllowVoiceToContact || !allowedVoiceByPrefs || !userCanSend -> {
+                DisallowedVoiceButton(userCanSend) {
+                  if (needToAllowVoiceToContact) {
+                    showNeedToAllowVoiceAlert(allowVoiceToContact)
+                  } else if (!allowedVoiceByPrefs) {
+                    showDisabledVoiceAlert(isDirectChat)
+                  }
+                }
+              }
+              !permissionsState.allPermissionsGranted ->
+                VoiceButtonWithoutPermission { permissionsState.launchMultiplePermissionRequest() }
+              else ->
+                RecordVoiceView(recState, stopRecOnNextClick)
+            }
+            if (sendLiveMessage != null 
+                && updateLiveMessage != null
+                && (cs.preview !is ComposePreview.VoicePreview || !stopRecOnNextClick.value)
+                && cs.contextItem is ComposeContextItem.NoContextItem) {
+              Spacer(Modifier.width(10.dp))
+              StartLiveMessageButton(userCanSend) {
+                if (composeState.value.preview is ComposePreview.NoPreview) {
+                  startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
+                }
+              }
+            }
+          }
+        }
+        cs.liveMessage?.sent == false && cs.message.isEmpty() -> {
+          CancelLiveMessageButton {
+            cancelLiveMessage?.invoke()
+          }
+        }
+        else -> {
+          val cs = composeState.value
+          val icon = if (cs.editing || cs.liveMessage != null) Icons.Filled.Check else Icons.Outlined.ArrowUpward
+          val disabled = !cs.sendEnabled() ||
+                        (!allowedVoiceByPrefs && cs.preview is ComposePreview.VoicePreview) ||
+                        cs.endLiveDisabled
+          if (cs.liveMessage == null &&
+            cs.preview !is ComposePreview.VoicePreview && !cs.editing &&
+            cs.contextItem is ComposeContextItem.NoContextItem &&
+            sendLiveMessage != null && updateLiveMessage != null
+          ) {
+            var showDropdown by rememberSaveable { mutableStateOf(false) }
+            SendMsgButton(icon, sendButtonSize, sendButtonAlpha, !disabled, sendMessage) { showDropdown = true }
+
+            DropdownMenu(
+              expanded = showDropdown,
+              onDismissRequest = { showDropdown = false },
+              Modifier.width(220.dp),
+            ) {
+              ItemAction(
+                generalGetString(R.string.send_live_message),
+                Icons.Filled.Bolt,
+                onClick = {
+                  startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
+                  showDropdown = false
+                }
+              )
+            }
+          } else {
+            SendMsgButton(icon, sendButtonSize, sendButtonAlpha, !disabled, sendMessage)
+          }
+        }
       }
     }
   }
+}
+
+@Composable
+private fun NativeKeyboard(
+  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.secondary
+  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
+    }
+  }
 
-  Column(Modifier.padding(vertical = 8.dp)) {
-    Box {
-      AndroidView(modifier = Modifier, factory = {
-        val editText = @SuppressLint("AppCompatCustomView") object: EditText(it) {
-          override fun setOnReceiveContentListener(
-            mimeTypes: Array<out String>?,
-            listener: android.view.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
-                }
-                SimplexApp.context.chatModel.sharedContent.value = SharedContent.Images("", listOf(inputContentInfo.contentUri))
-                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 = it.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)
-        editText.textCursorDrawable?.let { DrawableCompat.setTint(it, HighOrLowlight.toArgb()) }
-        editText.doOnTextChanged { text, _, _, _ -> onMessageChange(text.toString()) }
-        editText
-      }) {
-        it.setTextColor(textColor.toArgb())
-        it.textSize = textStyle.value.fontSize.value
-        DrawableCompat.setTint(it.background, tintColor.toArgb())
-        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 = SimplexApp.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-          imm.showSoftInput(it, InputMethodManager.SHOW_IMPLICIT)
-          showKeyboard = false
-        }
+  AndroidView(modifier = Modifier, factory = {
+    val editText = @SuppressLint("AppCompatCustomView") object: EditText(it) {
+      override fun setOnReceiveContentListener(
+        mimeTypes: Array<out String>?,
+        listener: android.view.OnReceiveContentListener?
+      ) {
+        super.setOnReceiveContentListener(mimeTypes, listener)
       }
-      Box(Modifier.align(Alignment.BottomEnd)) {
-        val icon = if (cs.editing) Icons.Filled.Check else Icons.Outlined.ArrowUpward
-        val color = if (cs.sendEnabled()) MaterialTheme.colors.primary else HighOrLowlight
-        if (cs.inProgress
-          && (cs.preview is ComposePreview.ImagePreview || cs.preview is ComposePreview.FilePreview)
-        ) {
-          CircularProgressIndicator(
-            Modifier
-              .size(36.dp)
-              .padding(4.dp),
-            color = HighOrLowlight,
-            strokeWidth = 3.dp
-          )
-        } else {
-          Icon(
-            icon,
-            stringResource(R.string.icon_descr_send_message),
-            tint = Color.White,
-            modifier = Modifier
-              .size(36.dp)
-              .padding(4.dp)
-              .clip(CircleShape)
-              .background(color)
-              .clickable {
-                if (cs.sendEnabled()) {
-                  sendMessage()
-                }
-              }
-          )
+
+      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
+          }
+          SimplexApp.context.chatModel.sharedContent.value = SharedContent.Images("", listOf(inputContentInfo.contentUri))
+          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 = it.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, HighOrLowlight.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(chat.simplex.app.TAG, e.stackTraceToString())
+      }
+    }
+    editText.doOnTextChanged { text, _, _, _ -> onMessageChange(text.toString()) }
+    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 = SimplexApp.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+      imm.showSoftInput(it, InputMethodManager.SHOW_IMPLICIT)
+      showKeyboard = false
+    }
+    showDeleteTextButton.value = it.lineCount >= 4
+  }
+  if (composeState.value.preview is ComposePreview.VoicePreview) {
+    ComposeOverlay(R.string.voice_message_send_text, textStyle, padding)
+  } else if (userIsObserver) {
+    ComposeOverlay(R.string.you_are_observer, textStyle, padding)
+  }
+}
+
+@Composable
+private fun ComposeOverlay(textId: Int, textStyle: MutableState<TextStyle>, padding: PaddingValues) {
+  Text(
+    generalGetString(textId),
+    Modifier.padding(padding),
+    color = HighOrLowlight,
+    style = textStyle.value.copy(fontStyle = FontStyle.Italic)
+  )
+}
+
+@Composable
+private fun BoxScope.DeleteTextButton(composeState: MutableState<ComposeState>) {
+  IconButton(
+    { composeState.value = composeState.value.copy(message = "") },
+    Modifier.align(Alignment.TopEnd).size(36.dp)
+  ) {
+    Icon(Icons.Filled.Close, null, Modifier.padding(7.dp).size(36.dp), tint = HighOrLowlight)
+  }
+}
+
+@Composable
+private fun RecordVoiceView(recState: MutableState<RecordingState>, stopRecOnNextClick: MutableState<Boolean>) {
+  val rec: Recorder = remember { RecorderNative(MAX_VOICE_SIZE_FOR_SENDING) }
+  DisposableEffect(Unit) { onDispose { rec.stop() } }
+  val stopRecordingAndAddAudio: () -> Unit = {
+    recState.value.filePathNullable?.let {
+      recState.value = RecordingState.Finished(it, rec.stop())
+    }
+  }
+  if (stopRecOnNextClick.value) {
+    LaunchedEffect(recState.value) {
+      if (recState.value is RecordingState.NotStarted) {
+        stopRecOnNextClick.value = false
+      }
+    }
+    // Lock orientation to current orientation because screen rotation will break the recording
+    LockToCurrentOrientationUntilDispose()
+    StopRecordButton(stopRecordingAndAddAudio)
+  } else {
+    val startRecording: () -> Unit = {
+      recState.value = RecordingState.Started(
+        filePath = rec.start { progress: Int?, finished: Boolean ->
+          val state = recState.value
+          if (state is RecordingState.Started && progress != null) {
+            recState.value = if (!finished)
+              RecordingState.Started(state.filePath, progress)
+            else
+              RecordingState.Finished(state.filePath, progress)
+          }
+        },
+      )
+    }
+    val interactionSource = interactionSourceWithTapDetection(
+      onPress = { if (recState.value is RecordingState.NotStarted) startRecording() },
+      onClick = {
+        if (stopRecOnNextClick.value) {
+          stopRecordingAndAddAudio()
+        } else {
+          // tapped and didn't hold a finger
+          stopRecOnNextClick.value = true
+        }
+      },
+      onCancel = stopRecordingAndAddAudio,
+      onRelease = stopRecordingAndAddAudio
+    )
+    RecordVoiceButton(interactionSource)
+  }
+}
+
+@Composable
+private fun DisallowedVoiceButton(enabled: Boolean, onClick: () -> Unit) {
+  IconButton(onClick, Modifier.size(36.dp), enabled = enabled) {
+    Icon(
+      Icons.Outlined.KeyboardVoice,
+      stringResource(R.string.icon_descr_record_voice_message),
+      tint = HighOrLowlight,
+      modifier = Modifier
+        .size(36.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+@Composable
+private fun VoiceButtonWithoutPermission(onClick: () -> Unit) {
+  IconButton(onClick, Modifier.size(36.dp)) {
+    Icon(
+      Icons.Filled.KeyboardVoice,
+      stringResource(R.string.icon_descr_record_voice_message),
+      tint = MaterialTheme.colors.primary,
+      modifier = Modifier
+        .size(34.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+@Composable
+private fun LockToCurrentOrientationUntilDispose() {
+  val context = LocalContext.current
+  DisposableEffect(Unit) {
+    val activity = context as Activity
+    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) {
+      android.view.Surface.ROTATION_90 -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+      android.view.Surface.ROTATION_180 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
+      android.view.Surface.ROTATION_270 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
+      else -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    }
+    // Unlock orientation
+    onDispose { activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED }
+  }
+}
+
+@Composable
+private fun StopRecordButton(onClick: () -> Unit) {
+  IconButton(onClick, Modifier.size(36.dp)) {
+    Icon(
+      Icons.Filled.Stop,
+      stringResource(R.string.icon_descr_record_voice_message),
+      tint = MaterialTheme.colors.primary,
+      modifier = Modifier
+        .size(36.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+@Composable
+private fun RecordVoiceButton(interactionSource: MutableInteractionSource) {
+  IconButton({}, Modifier.size(36.dp), interactionSource = interactionSource) {
+    Icon(
+      Icons.Filled.KeyboardVoice,
+      stringResource(R.string.icon_descr_record_voice_message),
+      tint = MaterialTheme.colors.primary,
+      modifier = Modifier
+        .size(34.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+@Composable
+private fun ProgressIndicator() {
+  CircularProgressIndicator(Modifier.size(36.dp).padding(4.dp), color = HighOrLowlight, strokeWidth = 3.dp)
+}
+
+@Composable
+private fun CancelLiveMessageButton(
+  onClick: () -> Unit
+) {
+  IconButton(onClick, Modifier.size(36.dp)) {
+    Icon(
+      Icons.Filled.Close,
+      stringResource(R.string.icon_descr_cancel_live_message),
+      tint = MaterialTheme.colors.primary,
+      modifier = Modifier
+        .size(36.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+@Composable
+private fun SendMsgButton(
+  icon: ImageVector,
+  sizeDp: Animatable<Float, AnimationVector1D>,
+  alpha: Animatable<Float, AnimationVector1D>,
+  enabled: Boolean,
+  sendMessage: () -> Unit,
+  onLongClick: (() -> Unit)? = null
+) {
+  val interactionSource = remember { MutableInteractionSource() }
+  Box(
+    modifier = Modifier.requiredSize(36.dp)
+      .combinedClickable(
+        onClick = sendMessage,
+        onLongClick = onLongClick,
+        enabled = enabled,
+        role = Role.Button,
+        interactionSource = interactionSource,
+        indication = rememberRipple(bounded = false, radius = 24.dp)
+      ),
+    contentAlignment = Alignment.Center
+  ) {
+    Icon(
+      icon,
+      stringResource(R.string.icon_descr_send_message),
+      tint = Color.White,
+      modifier = Modifier
+        .size(sizeDp.value.dp)
+        .padding(4.dp)
+        .alpha(alpha.value)
+        .clip(CircleShape)
+        .background(if (enabled) MaterialTheme.colors.primary else HighOrLowlight)
+        .padding(3.dp)
+    )
+  }
+}
+
+@Composable
+private fun StartLiveMessageButton(enabled: Boolean, onClick: () -> Unit) {
+  val interactionSource = remember { MutableInteractionSource() }
+  Box(
+    modifier = Modifier.requiredSize(36.dp)
+      .clickable(
+        onClick = onClick,
+        enabled = enabled,
+        role = Role.Button,
+        interactionSource = interactionSource,
+        indication = rememberRipple(bounded = false, radius = 24.dp)
+      ),
+    contentAlignment = Alignment.Center
+  ) {
+    Icon(
+      Icons.Filled.Bolt,
+      stringResource(R.string.icon_descr_send_message),
+      tint = if (enabled) MaterialTheme.colors.primary else HighOrLowlight,
+      modifier = Modifier
+        .size(36.dp)
+        .padding(4.dp)
+    )
+  }
+}
+
+private fun startLiveMessage(
+  scope: CoroutineScope,
+  send: suspend () -> Unit,
+  update: suspend () -> Unit,
+  sendButtonSize: Animatable<Float, AnimationVector1D>,
+  sendButtonAlpha: Animatable<Float, AnimationVector1D>,
+  composeState: MutableState<ComposeState>,
+  liveMessageAlertShown: SharedPreference<Boolean>
+) {
+  fun run() {
+    scope.launch {
+      while (composeState.value.liveMessage != null) {
+        sendButtonSize.animateTo(if (sendButtonSize.value == 36f) 32f else 36f, tween(700, 50))
+      }
+      sendButtonSize.snapTo(36f)
+    }
+    scope.launch {
+      while (composeState.value.liveMessage != null) {
+        sendButtonAlpha.animateTo(if (sendButtonAlpha.value == 1f) 0.75f else 1f, tween(700, 50))
+      }
+      sendButtonAlpha.snapTo(1f)
+    }
+    scope.launch {
+      delay(3000)
+      while (composeState.value.liveMessage != null) {
+        update()
+        delay(3000)
       }
     }
   }
+
+  fun start() = withBGApi {
+    if (composeState.value.liveMessage == null) {
+      send()
+    }
+    run()
+  }
+
+  if (liveMessageAlertShown.state.value) {
+    start()
+  } else {
+    AlertManager.shared.showAlertDialog(
+      title = generalGetString(R.string.live_message),
+      text = generalGetString(R.string.send_live_message_desc),
+      confirmText = generalGetString(R.string.send_verb),
+      onConfirm = {
+        liveMessageAlertShown.set(true)
+        start()
+      })
+  }
+}
+
+private fun showNeedToAllowVoiceAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.allow_voice_messages_question),
+    text = generalGetString(R.string.you_need_to_allow_to_send_voice),
+    confirmText = generalGetString(R.string.allow_verb),
+    dismissText = generalGetString(R.string.cancel_verb),
+    onConfirm = onConfirm,
+  )
+}
+
+private fun showDisabledVoiceAlert(isDirectChat: Boolean) {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.voice_messages_prohibited),
+    text = generalGetString(
+      if (isDirectChat)
+        R.string.ask_your_contact_to_enable_voice
+      else
+        R.string.only_group_owners_can_enable_voice
+    )
+  )
 }
 
 @Preview(showBackground = true)
@@ -167,6 +596,15 @@ fun PreviewSendMsgView() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
+      showVoiceRecordIcon = false,
+      recState = remember { mutableStateOf(RecordingState.NotStarted) },
+      isDirectChat = true,
+      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
+      needToAllowVoiceToContact = false,
+      allowedVoiceByPrefs = true,
+      userIsObserver = false,
+      userCanSend = true,
+      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle
@@ -188,6 +626,15 @@ fun PreviewSendMsgViewEditing() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateEditing) },
+      showVoiceRecordIcon = false,
+      recState = remember { mutableStateOf(RecordingState.NotStarted) },
+      isDirectChat = true,
+      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
+      needToAllowVoiceToContact = false,
+      allowedVoiceByPrefs = true,
+      userIsObserver = false,
+      userCanSend = true,
+      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle
@@ -205,10 +652,19 @@ fun PreviewSendMsgViewEditing() {
 fun PreviewSendMsgViewInProgress() {
   val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
   val textStyle = remember { mutableStateOf(smallFont) }
-  val composeStateInProgress = ComposeState(preview = ComposePreview.FilePreview("test.txt"), inProgress = true, useLinkPreviews = true)
+  val composeStateInProgress = ComposeState(preview = ComposePreview.FilePreview("test.txt", getAppFileUri("test.txt")), inProgress = true, useLinkPreviews = true)
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateInProgress) },
+      showVoiceRecordIcon = false,
+      recState = remember { mutableStateOf(RecordingState.NotStarted) },
+      isDirectChat = true,
+      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
+      needToAllowVoiceToContact = false,
+      allowedVoiceByPrefs = true,
+      userIsObserver = false,
+      userCanSend = true,
+      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle

apps/android/app/src/main/java/chat/simplex/app/views/chat/VerifyCodeView.kt

@@ -0,0 +1,137 @@
+package chat.simplex.app.views.chat
+
+import SectionView
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Share
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.newchat.QRCode
+
+@Composable
+fun VerifyCodeView(
+  displayName: String,
+  connectionCode: String?,
+  connectionVerified: Boolean,
+  verify: suspend (String?) -> Pair<Boolean, String>?,
+  close: () -> Unit,
+) {
+  if (connectionCode != null) {
+    VerifyCodeLayout(
+      displayName,
+      connectionCode,
+      connectionVerified,
+      verifyCode = { newCode, cb ->
+        withBGApi {
+          val res = verify(newCode)
+          if (res != null) {
+            val (verified) = res
+            cb(verified)
+            if (verified) close()
+          }
+        }
+      }
+    )
+  }
+}
+
+@Composable
+private fun VerifyCodeLayout(
+  displayName: String,
+  connectionCode: String,
+  connectionVerified: Boolean,
+  verifyCode: (String?, cb: (Boolean) -> Unit) -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxSize()
+      .verticalScroll(rememberScrollState())
+      .padding(horizontal = DEFAULT_PADDING)
+  ) {
+    AppBarTitle(stringResource(R.string.security_code), false)
+    val splitCode = splitToParts(connectionCode, 24)
+    Row(Modifier.fillMaxWidth().padding(bottom = DEFAULT_PADDING_HALF), horizontalArrangement = Arrangement.Center) {
+      if (connectionVerified) {
+        Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 4.dp).size(22.dp), tint = HighOrLowlight)
+        Text(String.format(stringResource(R.string.is_verified), displayName))
+      } else {
+        Text(String.format(stringResource(R.string.is_not_verified), displayName))
+      }
+    }
+
+    SectionView {
+      QRCode(connectionCode, Modifier.aspectRatio(1f))
+    }
+
+    Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+      Spacer(Modifier.weight(2f))
+      SelectionContainer(Modifier.padding(vertical = DEFAULT_PADDING_HALF, horizontal = DEFAULT_PADDING_HALF)) {
+        Text(
+          splitCode,
+          fontFamily = FontFamily.Monospace,
+          fontSize = 18.sp,
+          maxLines = 20
+        )
+      }
+      val context = LocalContext.current
+      Box(Modifier.weight(1f)) {
+        IconButton({ shareText(context, connectionCode) }, Modifier.size(20.dp).align(Alignment.CenterStart)) {
+          Icon(Icons.Filled.Share, null, tint = MaterialTheme.colors.primary)
+        }
+      }
+      Spacer(Modifier.weight(1f))
+    }
+
+    Text(
+      generalGetString(R.string.to_verify_compare),
+      Modifier.padding(bottom = DEFAULT_PADDING)
+    )
+
+    Row(
+      Modifier.padding(bottom = DEFAULT_PADDING).align(Alignment.CenterHorizontally),
+      horizontalArrangement = Arrangement.spacedBy(10.dp)
+    ) {
+      if (connectionVerified) {
+        SimpleButton(generalGetString(R.string.clear_verification), Icons.Outlined.Shield) {
+          verifyCode(null) {}
+        }
+      } else {
+        SimpleButton(generalGetString(R.string.scan_code), Icons.Outlined.QrCode) {
+          ModalManager.shared.showModal {
+            ScanCodeView(verifyCode) { }
+          }
+        }
+        SimpleButton(generalGetString(R.string.mark_code_verified), Icons.Outlined.VerifiedUser) {
+          verifyCode(connectionCode) { verified ->
+            if (!verified) {
+              AlertManager.shared.showAlertMsg(
+                title = generalGetString(R.string.incorrect_code)
+              )
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+private fun splitToParts(s: String, length: Int): String {
+  if (length >= s.length) return s
+  return (0..(s.length - 1) / length)
+    .map { s.drop(it * length).take(length) }
+    .joinToString(separator = "\n")
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/AddGroupMembersView.kt

@@ -14,7 +14,6 @@ import androidx.compose.material.icons.filled.CheckCircle
 import androidx.compose.material.icons.filled.TheaterComedy
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
-import androidx.compose.runtime.snapshots.SnapshotStateList
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -32,17 +31,25 @@ import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.usersettings.SettingsActionItem
 
 @Composable
-fun AddGroupMembersView(groupInfo: GroupInfo, chatModel: ChatModel, close: () -> Unit) {
+fun AddGroupMembersView(groupInfo: GroupInfo, creatingGroup: Boolean = false, chatModel: ChatModel, close: () -> Unit) {
   val selectedContacts = remember { mutableStateListOf<Long>() }
   val selectedRole = remember { mutableStateOf(GroupMemberRole.Member) }
-
+  var allowModifyMembers by remember { mutableStateOf(true) }
   BackHandler(onBack = close)
   AddGroupMembersLayout(
     groupInfo = groupInfo,
+    creatingGroup = creatingGroup,
     contactsToAdd = getContactsToAdd(chatModel),
     selectedContacts = selectedContacts,
     selectedRole = selectedRole,
+    allowModifyMembers = allowModifyMembers,
+    openPreferences = {
+      ModalManager.shared.showCustomModal { close ->
+        GroupPreferencesView(chatModel, groupInfo.id, close)
+      }
+    },
     inviteMembers = {
+      allowModifyMembers = false
       withApi {
         for (contactId in selectedContacts) {
           val member = chatModel.controller.apiAddMember(groupInfo.groupId, contactId, selectedRole.value)
@@ -58,6 +65,7 @@ fun AddGroupMembersView(groupInfo: GroupInfo, chatModel: ChatModel, close: () ->
     clearSelection = { selectedContacts.clear() },
     addContact = { contactId -> if (contactId !in selectedContacts) selectedContacts.add(contactId) },
     removeContact = { contactId -> selectedContacts.removeIf { it == contactId } },
+    close = close,
   )
 }
 
@@ -78,13 +86,17 @@ fun getContactsToAdd(chatModel: ChatModel): List<Contact> {
 @Composable
 fun AddGroupMembersLayout(
   groupInfo: GroupInfo,
+  creatingGroup: Boolean,
   contactsToAdd: List<Contact>,
-  selectedContacts: SnapshotStateList<Long>,
+  selectedContacts: List<Long>,
   selectedRole: MutableState<GroupMemberRole>,
+  allowModifyMembers: Boolean,
+  openPreferences: () -> Unit,
   inviteMembers: () -> Unit,
   clearSelection: () -> Unit,
   addContact: (Long) -> Unit,
   removeContact: (Long) -> Unit,
+  close: () -> Unit,
 ) {
   Column(
     Modifier
@@ -118,19 +130,29 @@ fun AddGroupMembersLayout(
       }
     } else {
       SectionView {
+        if (creatingGroup) {
+          SectionItemView(openPreferences) {
+            Text(stringResource(R.string.set_group_preferences))
+          }
+          SectionDivider()
+        }
         SectionItemView {
-          RoleSelectionRow(groupInfo, selectedRole)
+          RoleSelectionRow(groupInfo, selectedRole, allowModifyMembers)
         }
         SectionDivider()
-        InviteMembersButton(inviteMembers, disabled = selectedContacts.isEmpty())
+        if (creatingGroup && selectedContacts.isEmpty()) {
+          SkipInvitingButton(close)
+        } else {
+          InviteMembersButton(inviteMembers, disabled = selectedContacts.isEmpty() || !allowModifyMembers)
+        }
       }
       SectionCustomFooter {
-        InviteSectionFooter(selectedContactsCount = selectedContacts.count(), clearSelection)
+        InviteSectionFooter(selectedContactsCount = selectedContacts.size, allowModifyMembers, clearSelection)
       }
       SectionSpacer()
 
-      SectionView {
-        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, addContact, removeContact)
+      SectionView(stringResource(R.string.select_contacts)) {
+        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, allowModifyMembers, addContact, removeContact)
       }
       SectionSpacer()
     }
@@ -138,7 +160,7 @@ fun AddGroupMembersLayout(
 }
 
 @Composable
-private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>) {
+private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>, enabled: Boolean) {
   Row(
     Modifier.fillMaxWidth(),
     verticalAlignment = Alignment.CenterVertically,
@@ -150,7 +172,7 @@ private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<Gr
       values,
       selectedRole,
       icon = null,
-      enabled = remember { mutableStateOf(true) },
+      enabled = rememberUpdatedState(enabled),
       onSelected = { selectedRole.value = it }
     )
   }
@@ -169,7 +191,18 @@ fun InviteMembersButton(onClick: () -> Unit, disabled: Boolean) {
 }
 
 @Composable
-fun InviteSectionFooter(selectedContactsCount: Int, clearSelection: () -> Unit) {
+fun SkipInvitingButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.Check,
+    stringResource(R.string.skip_inviting_button),
+    click = onClick,
+    textColor = MaterialTheme.colors.primary,
+    iconColor = MaterialTheme.colors.primary,
+  )
+}
+
+@Composable
+fun InviteSectionFooter(selectedContactsCount: Int, enabled: Boolean, clearSelection: () -> Unit) {
   Row(
     Modifier.fillMaxWidth(),
     horizontalArrangement = Arrangement.SpaceBetween,
@@ -182,11 +215,11 @@ fun InviteSectionFooter(selectedContactsCount: Int, clearSelection: () -> Unit)
         fontSize = 12.sp
       )
       Box(
-        Modifier.clickable { clearSelection() }
+        Modifier.clickable { if (enabled) clearSelection() }
       ) {
         Text(
           stringResource(R.string.clear_contacts_selection_button),
-          color = MaterialTheme.colors.primary,
+          color = if (enabled) MaterialTheme.colors.primary else HighOrLowlight,
           fontSize = 12.sp
         )
       }
@@ -203,8 +236,9 @@ fun InviteSectionFooter(selectedContactsCount: Int, clearSelection: () -> Unit)
 @Composable
 fun ContactList(
   contacts: List<Contact>,
-  selectedContacts: SnapshotStateList<Long>,
+  selectedContacts: List<Long>,
   groupInfo: GroupInfo,
+  enabled: Boolean,
   addContact: (Long) -> Unit,
   removeContact: (Long) -> Unit
 ) {
@@ -212,7 +246,8 @@ fun ContactList(
     contacts.forEachIndexed { index, contact ->
       ContactCheckRow(
         contact, groupInfo, addContact, removeContact,
-        checked = selectedContacts.contains(contact.apiId)
+        checked = selectedContacts.contains(contact.apiId),
+        enabled = enabled,
       )
       if (index < contacts.lastIndex) {
         SectionDivider()
@@ -227,7 +262,8 @@ fun ContactCheckRow(
   groupInfo: GroupInfo,
   addContact: (Long) -> Unit,
   removeContact: (Long) -> Unit,
-  checked: Boolean
+  checked: Boolean,
+  enabled: Boolean,
 ) {
   val prohibitedToInviteIncognito = !groupInfo.membership.memberIncognito && contact.contactConnIncognito
   val icon: ImageVector
@@ -237,19 +273,23 @@ fun ContactCheckRow(
     iconColor = HighOrLowlight
   } else if (checked) {
     icon = Icons.Filled.CheckCircle
-    iconColor = MaterialTheme.colors.primary
+    iconColor = if (enabled) MaterialTheme.colors.primary else HighOrLowlight
   } else {
     icon = Icons.Outlined.Circle
     iconColor = HighOrLowlight
   }
-  SectionItemView(click = {
-    if (prohibitedToInviteIncognito) {
-      showProhibitedToInviteIncognitoAlertDialog()
-    } else if (!checked)
-      addContact(contact.apiId)
-    else
-      removeContact(contact.apiId)
-  }) {
+  SectionItemView(
+    click = if (enabled) {
+      {
+        if (prohibitedToInviteIncognito) {
+          showProhibitedToInviteIncognitoAlertDialog()
+        } else if (!checked)
+          addContact(contact.apiId)
+        else
+          removeContact(contact.apiId)
+      }
+    } else null
+  ) {
     ProfileImage(size = 36.dp, contact.image)
     Spacer(Modifier.width(DEFAULT_SPACE_AFTER_ICON))
     Text(
@@ -279,13 +319,17 @@ fun PreviewAddGroupMembersLayout() {
   SimpleXTheme {
     AddGroupMembersLayout(
       groupInfo = GroupInfo.sampleData,
+      creatingGroup = false,
       contactsToAdd = listOf(Contact.sampleData, Contact.sampleData, Contact.sampleData),
       selectedContacts = remember { mutableStateListOf() },
       selectedRole = remember { mutableStateOf(GroupMemberRole.Admin) },
+      allowModifyMembers = true,
+      openPreferences = {},
       inviteMembers = {},
       clearSelection = {},
       addContact = {},
-      removeContact = {}
+      removeContact = {},
+      close = {},
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/GroupChatInfoView.kt

@@ -4,7 +4,9 @@ import InfoRow
 import SectionDivider
 import SectionItemView
 import SectionSpacer
+import SectionTextFooter
 import SectionView
+import android.util.Log
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
@@ -22,15 +24,17 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
+import chat.simplex.app.TAG
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.*
 import chat.simplex.app.views.chatlist.cantInviteIncognitoAlert
 import chat.simplex.app.views.chatlist.setGroupMembers
 import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.*
 
 @Composable
-fun GroupChatInfoView(chatModel: ChatModel, close: () -> Unit) {
+fun GroupChatInfoView(chatModel: ChatModel, groupLink: String?, groupLinkMemberRole: GroupMemberRole?, onGroupLinkUpdated: (Pair<String?, GroupMemberRole?>) -> Unit, close: () -> Unit) {
   BackHandler(onBack = close)
   val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
   val developerTools = chatModel.controller.appPrefs.developerTools.get()
@@ -43,33 +47,58 @@ fun GroupChatInfoView(chatModel: ChatModel, close: () -> Unit) {
         .filter { it.memberStatus != GroupMemberStatus.MemLeft && it.memberStatus != GroupMemberStatus.MemRemoved }
         .sortedBy { it.displayName.lowercase() },
       developerTools,
+      groupLink,
       addMembers = {
         withApi {
           setGroupMembers(groupInfo, chatModel)
           ModalManager.shared.showModalCloseable(true) { close ->
-            AddGroupMembersView(groupInfo, chatModel, close)
+            AddGroupMembersView(groupInfo, false, chatModel, close)
           }
         }
       },
       showMemberInfo = { member ->
         withApi {
           val stats = chatModel.controller.apiGroupMemberInfo(groupInfo.groupId, member.groupMemberId)
+          val (_, code) = if (member.memberActive) {
+            try {
+              chatModel.controller.apiGetGroupMemberCode(groupInfo.apiId, member.groupMemberId)
+            } catch (e: Exception) {
+              Log.e(TAG, e.stackTraceToString())
+              member to null
+            }
+          } else {
+            member to null
+          }
           ModalManager.shared.showModalCloseable(true) { closeCurrent ->
-            GroupMemberInfoView(groupInfo, member, stats, chatModel, closeCurrent) { closeCurrent(); close() }
+            remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
+              GroupMemberInfoView(groupInfo, mem, stats, code, chatModel, closeCurrent) {
+                closeCurrent()
+                close()
+              }
+            }
           }
         }
       },
       editGroupProfile = {
         ModalManager.shared.showCustomModal { close -> GroupProfileView(groupInfo, chatModel, close) }
       },
+      addOrEditWelcomeMessage = {
+        ModalManager.shared.showCustomModal { close -> GroupWelcomeView(chatModel, groupInfo, close) }
+      },
+      openPreferences = {
+        ModalManager.shared.showCustomModal { close ->
+          GroupPreferencesView(
+            chatModel,
+            chat.id,
+            close
+          )
+        }
+      },
       deleteGroup = { deleteGroupDialog(chat.chatInfo, groupInfo, chatModel, close) },
       clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
       leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) },
       manageGroupLink = {
-        withApi {
-          val groupLink = chatModel.controller.apiGetGroupLink(groupInfo.groupId)
-          ModalManager.shared.showModal { GroupLinkView(chatModel, groupInfo, groupLink) }
-        }
+          ModalManager.shared.showModal { GroupLinkView(chatModel, groupInfo, groupLink, groupLinkMemberRole, onGroupLinkUpdated) }
       }
     )
   }
@@ -117,9 +146,12 @@ fun GroupChatInfoLayout(
   groupInfo: GroupInfo,
   members: List<GroupMember>,
   developerTools: Boolean,
+  groupLink: String?,
   addMembers: () -> Unit,
   showMemberInfo: (GroupMember) -> Unit,
   editGroupProfile: () -> Unit,
+  addOrEditWelcomeMessage: () -> Unit,
+  openPreferences: () -> Unit,
   deleteGroup: () -> Unit,
   clearChat: () -> Unit,
   leaveGroup: () -> Unit,
@@ -139,9 +171,27 @@ fun GroupChatInfoLayout(
     }
     SectionSpacer()
 
+    SectionView {
+      if (groupInfo.canEdit) {
+        SectionItemView(editGroupProfile) { EditGroupProfileButton() }
+        SectionDivider()
+        SectionItemView(addOrEditWelcomeMessage) { AddOrEditWelcomeMessage(groupInfo.groupProfile.description) }
+        SectionDivider()
+      }
+      GroupPreferencesButton(openPreferences)
+    }
+    SectionTextFooter(stringResource(R.string.only_group_owners_can_change_prefs))
+    SectionSpacer()
+
     SectionView(title = String.format(generalGetString(R.string.group_info_section_title_num_members), members.count() + 1)) {
       if (groupInfo.canAddMembers) {
-        SectionItemView(manageGroupLink) { GroupLinkButton() }
+        SectionItemView(manageGroupLink) {
+          if (groupLink == null) {
+            CreateGroupLinkButton()
+          } else {
+            GroupLinkButton()
+          }
+        }
         SectionDivider()
         val onAddMembersClick = if (chat.chatInfo.incognito) ::cantInviteIncognitoAlert else addMembers
         SectionItemView(onAddMembersClick) {
@@ -160,10 +210,6 @@ fun GroupChatInfoLayout(
     }
     SectionSpacer()
     SectionView {
-      if (groupInfo.canEdit) {
-        SectionItemView(editGroupProfile) { EditGroupProfileButton() }
-        SectionDivider()
-      }
       ClearChatButton(clearChat)
       if (groupInfo.canDelete) {
         SectionDivider()
@@ -188,7 +234,7 @@ fun GroupChatInfoLayout(
 }
 
 @Composable
-fun GroupChatInfoHeader(cInfo: ChatInfo) {
+private fun GroupChatInfoHeader(cInfo: ChatInfo) {
   Column(
     Modifier.padding(horizontal = 8.dp),
     horizontalAlignment = Alignment.CenterHorizontally
@@ -212,7 +258,16 @@ fun GroupChatInfoHeader(cInfo: ChatInfo) {
 }
 
 @Composable
-fun AddMembersButton(tint: Color = MaterialTheme.colors.primary) {
+private fun GroupPreferencesButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.ToggleOn,
+    stringResource(R.string.group_preferences),
+    click = onClick
+  )
+}
+
+@Composable
+private fun AddMembersButton(tint: Color = MaterialTheme.colors.primary) {
   Row(
     Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
@@ -228,7 +283,7 @@ fun AddMembersButton(tint: Color = MaterialTheme.colors.primary) {
 }
 
 @Composable
-fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
+private fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
   Column {
     members.forEachIndexed { index, member ->
       SectionItemView({ showMemberInfo(member) }, minHeight = 50.dp) {
@@ -242,22 +297,28 @@ fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Uni
 }
 
 @Composable
-fun MemberRow(member: GroupMember, user: Boolean = false) {
+private fun MemberRow(member: GroupMember, user: Boolean = false) {
   Row(
     Modifier.fillMaxWidth(),
     horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
     Row(
+      Modifier.weight(1f).padding(end = DEFAULT_PADDING),
       verticalAlignment = Alignment.CenterVertically,
       horizontalArrangement = Arrangement.spacedBy(4.dp)
     ) {
       ProfileImage(size = 46.dp, member.image)
       Column {
-        Text(
-          member.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
-          color = if (member.memberIncognito) Indigo else Color.Unspecified
-        )
+        Row(verticalAlignment = Alignment.CenterVertically) {
+          if (member.verified) {
+            MemberVerifiedShield()
+          }
+          Text(
+            member.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
+            color = if (member.memberIncognito) Indigo else Color.Unspecified
+          )
+        }
         val s = member.memberStatus.shortText
         val statusDescr = if (user) String.format(generalGetString(R.string.group_info_member_you), s) else s
         Text(
@@ -277,7 +338,12 @@ fun MemberRow(member: GroupMember, user: Boolean = false) {
 }
 
 @Composable
-fun GroupLinkButton() {
+private fun MemberVerifiedShield() {
+  Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 3.dp).size(16.dp), tint = HighOrLowlight)
+}
+
+@Composable
+private fun GroupLinkButton() {
   Row(
     Modifier
       .fillMaxSize(),
@@ -286,10 +352,27 @@ fun GroupLinkButton() {
     Icon(
       Icons.Outlined.Link,
       stringResource(R.string.group_link),
-      tint = MaterialTheme.colors.primary
+      tint = HighOrLowlight
     )
     Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.group_link), color = MaterialTheme.colors.primary)
+    Text(stringResource(R.string.group_link))
+  }
+}
+
+@Composable
+private fun CreateGroupLinkButton() {
+  Row(
+    Modifier
+      .fillMaxSize(),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.AddLink,
+      stringResource(R.string.create_group_link),
+      tint = HighOrLowlight
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.create_group_link))
   }
 }
 
@@ -303,15 +386,37 @@ fun EditGroupProfileButton() {
     Icon(
       Icons.Outlined.Edit,
       stringResource(R.string.button_edit_group_profile),
-      tint = MaterialTheme.colors.primary
+      tint = HighOrLowlight
     )
     Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_edit_group_profile), color = MaterialTheme.colors.primary)
+    Text(stringResource(R.string.button_edit_group_profile))
   }
 }
 
 @Composable
-fun LeaveGroupButton() {
+private fun AddOrEditWelcomeMessage(welcomeMessage: String?) {
+  val text = if (welcomeMessage == null) {
+    stringResource(R.string.button_add_welcome_message)
+  } else {
+    stringResource(R.string.button_welcome_message)
+  }
+  Row(
+    Modifier
+      .fillMaxSize(),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.MapsUgc,
+      text,
+      tint = HighOrLowlight
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(text)
+  }
+}
+
+@Composable
+private fun LeaveGroupButton() {
   Row(
     Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
@@ -327,7 +432,7 @@ fun LeaveGroupButton() {
 }
 
 @Composable
-fun DeleteGroupButton() {
+private fun DeleteGroupButton() {
   Row(
     Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
@@ -349,13 +454,13 @@ fun PreviewGroupChatInfoLayout() {
     GroupChatInfoLayout(
       chat = Chat(
         chatInfo = ChatInfo.Direct.sampleData,
-        chatItems = arrayListOf(),
-        serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
+        chatItems = arrayListOf()
       ),
       groupInfo = GroupInfo.sampleData,
       members = listOf(GroupMember.sampleData, GroupMember.sampleData, GroupMember.sampleData),
       developerTools = false,
-      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {}, manageGroupLink = {},
+      groupLink = null,
+      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, addOrEditWelcomeMessage = {}, openPreferences = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {}, manageGroupLink = {},
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/GroupLinkView.kt

@@ -1,10 +1,15 @@
 package chat.simplex.app.views.chat.group
 
+import SectionItemView
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.CircularProgressIndicator
 import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
 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
@@ -13,25 +18,54 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.model.GroupInfo
-import chat.simplex.app.ui.theme.DEFAULT_PADDING
-import chat.simplex.app.ui.theme.SimpleButton
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.newchat.QRCode
 
 @Composable
-fun GroupLinkView(chatModel: ChatModel, groupInfo: GroupInfo, connReqContact: String?) {
-  var groupLink by remember { mutableStateOf(connReqContact) }
+fun GroupLinkView(chatModel: ChatModel, groupInfo: GroupInfo, connReqContact: String?, memberRole: GroupMemberRole?, onGroupLinkUpdated: (Pair<String?, GroupMemberRole?>) -> Unit) {
+  var groupLink by rememberSaveable { mutableStateOf(connReqContact) }
+  val groupLinkMemberRole = rememberSaveable { mutableStateOf(memberRole) }
+  var creatingLink by rememberSaveable { mutableStateOf(false) }
   val cxt = LocalContext.current
+  fun createLink() {
+    creatingLink = true
+    withApi {
+      val link = chatModel.controller.apiCreateGroupLink(groupInfo.groupId)
+      if (link != null) {
+        groupLink = link.first
+        groupLinkMemberRole.value = link.second
+        onGroupLinkUpdated(groupLink to groupLinkMemberRole.value)
+      }
+      creatingLink = false
+    }
+  }
+  LaunchedEffect(Unit) {
+    if (groupLink == null && !creatingLink) {
+      createLink()
+    }
+  }
   GroupLinkLayout(
     groupLink = groupLink,
-    createLink = {
-      withApi {
-        groupLink = chatModel.controller.apiCreateGroupLink(groupInfo.groupId)
+    groupInfo,
+    groupLinkMemberRole,
+    creatingLink,
+    createLink = ::createLink,
+    share = { shareText(cxt, groupLink ?: return@GroupLinkLayout) },
+    updateLink = {
+      val role = groupLinkMemberRole.value
+      if (role != null) {
+        withBGApi {
+          val link = chatModel.controller.apiGroupLinkMemberRole(groupInfo.groupId, role)
+          if (link != null) {
+            groupLink = link.first
+            groupLinkMemberRole.value = link.second
+            onGroupLinkUpdated(groupLink to groupLinkMemberRole.value)
+          }
+        }
       }
     },
-    share = { shareText(cxt, groupLink ?: return@GroupLinkLayout) },
     deleteLink = {
       AlertManager.shared.showAlertMsg(
         title = generalGetString(R.string.delete_link_question),
@@ -42,23 +76,33 @@ fun GroupLinkView(chatModel: ChatModel, groupInfo: GroupInfo, connReqContact: St
             val r = chatModel.controller.apiDeleteGroupLink(groupInfo.groupId)
             if (r) {
               groupLink = null
+              onGroupLinkUpdated(null to null)
             }
           }
         }
       )
     }
   )
+  if (creatingLink) {
+    ProgressIndicator()
+  }
 }
 
 @Composable
 fun GroupLinkLayout(
   groupLink: String?,
+  groupInfo: GroupInfo,
+  groupLinkMemberRole: MutableState<GroupMemberRole?>,
+  creatingLink: Boolean,
   createLink: () -> Unit,
   share: () -> Unit,
+  updateLink: () -> Unit,
   deleteLink: () -> Unit
 ) {
   Column(
-    Modifier.padding(horizontal = DEFAULT_PADDING),
+    Modifier
+      .verticalScroll(rememberScrollState())
+      .padding(start = DEFAULT_PADDING, bottom = DEFAULT_BOTTOM_PADDING, end = DEFAULT_PADDING),
     horizontalAlignment = Alignment.Start,
     verticalArrangement = Arrangement.Top
   ) {
@@ -74,9 +118,19 @@ fun GroupLinkLayout(
       verticalArrangement = Arrangement.SpaceEvenly
     ) {
       if (groupLink == null) {
-        SimpleButton(stringResource(R.string.button_create_group_link), icon = Icons.Outlined.AddLink, click = createLink)
+        SimpleButton(stringResource(R.string.button_create_group_link), icon = Icons.Outlined.AddLink, disabled = creatingLink, click = createLink)
       } else {
-        QRCode(groupLink, Modifier.weight(1f, fill = false).aspectRatio(1f))
+        SectionItemView(padding = PaddingValues(bottom = DEFAULT_PADDING)) {
+          RoleSelectionRow(groupInfo, groupLinkMemberRole)
+        }
+        var initialLaunch by remember { mutableStateOf(true) }
+        LaunchedEffect(groupLinkMemberRole.value) {
+          if (!initialLaunch) {
+            updateLink()
+          }
+          initialLaunch = false
+        }
+        QRCode(groupLink, Modifier.aspectRatio(1f))
         Row(
           horizontalArrangement = Arrangement.spacedBy(10.dp),
           verticalAlignment = Alignment.CenterVertically,
@@ -99,3 +153,37 @@ fun GroupLinkLayout(
   }
 }
 
+@Composable
+private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole?>, enabled: Boolean = true) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    val values = listOf(GroupMemberRole.Member, GroupMemberRole.Observer).map { it to it.text }
+    ExposedDropDownSettingRow(
+      generalGetString(R.string.initial_member_role),
+      values,
+      selectedRole,
+      icon = null,
+      enabled = rememberUpdatedState(enabled),
+      onSelected = { selectedRole.value = it }
+    )
+  }
+}
+
+@Composable
+fun ProgressIndicator() {
+  Box(
+    Modifier.fillMaxSize(),
+    contentAlignment = Alignment.Center
+  ) {
+    CircularProgressIndicator(
+      Modifier
+        .padding(horizontal = 2.dp)
+        .size(30.dp),
+      color = HighOrLowlight,
+      strokeWidth = 2.5.dp
+    )
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/GroupMemberInfoView.kt

@@ -5,6 +5,7 @@ import SectionDivider
 import SectionItemView
 import SectionSpacer
 import SectionView
+import android.util.Log
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
@@ -12,6 +13,7 @@ import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
 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
@@ -21,19 +23,20 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
+import chat.simplex.app.TAG
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.SimplexServers
-import chat.simplex.app.views.chat.SwitchAddressButton
-import chat.simplex.app.views.chatlist.openChat
+import chat.simplex.app.views.chat.*
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.usersettings.SettingsActionItem
+import kotlinx.datetime.Clock
 
 @Composable
 fun GroupMemberInfoView(
   groupInfo: GroupInfo,
   member: GroupMember,
   connStats: ConnectionStats?,
+  connectionCode: String?,
   chatModel: ChatModel,
   close: () -> Unit,
   closeAll: () -> Unit, // Close all open windows up to ChatView
@@ -49,22 +52,27 @@ fun GroupMemberInfoView(
       connStats,
       newRole,
       developerTools,
-      openDirectChat = {
+      connectionCode,
+      getContactChat = { chatModel.getContactChat(it) },
+      knownDirectChat = {
         withApi {
-          val oldChat = chatModel.getContactChat(member.memberContactId ?: return@withApi)
-          if (oldChat != null) {
-            openChat(oldChat.chatInfo, chatModel)
-          } else {
-            var newChat = chatModel.controller.apiGetChat(ChatType.Direct, member.memberContactId) ?: return@withApi
-            // TODO it's not correct to blindly set network status to connected - we should manage network status in model / backend
-            newChat = newChat.copy(serverInfo = Chat.ServerInfo(networkStatus = Chat.NetworkStatus.Connected()))
-            chatModel.addChat(newChat)
-            chatModel.chatItems.clear()
-            chatModel.chatId.value = newChat.id
-          }
+          chatModel.chatItems.clear()
+          chatModel.chatItems.addAll(it.chatItems)
+          chatModel.chatId.value = it.chatInfo.id
           closeAll()
         }
       },
+      newDirectChat = {
+        withApi {
+          val c = chatModel.controller.apiGetChat(ChatType.Direct, it)
+          if (c != null) {
+            chatModel.addChat(c)
+            chatModel.chatItems.clear()
+            chatModel.chatId.value = c.id
+            closeAll()
+          }
+        }
+      },
       removeMember = { removeMemberDialog(groupInfo, member, chatModel, close) },
       onRoleSelected = {
         if (it == newRole.value) return@GroupMemberInfoLayout
@@ -85,6 +93,32 @@ fun GroupMemberInfoView(
       },
       switchMemberAddress = {
         switchMemberAddress(chatModel, groupInfo, member)
+      },
+      verifyClicked = {
+        ModalManager.shared.showModalCloseable { close ->
+          remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
+            VerifyCodeView(
+              mem.displayName,
+              connectionCode,
+              mem.verified,
+              verify = { code ->
+                chatModel.controller.apiVerifyGroupMember(mem.groupId, mem.groupMemberId, code)?.let { r ->
+                  val (verified, existingCode) = r
+                  chatModel.upsertGroupMember(
+                    groupInfo,
+                    mem.copy(
+                      activeConn = mem.activeConn?.copy(
+                        connectionCode = if (verified) SecurityCode(existingCode, Clock.System.now()) else null
+                      )
+                    )
+                  )
+                  r
+                }
+              },
+              close,
+            )
+          }
+        }
       }
     )
   }
@@ -114,10 +148,14 @@ fun GroupMemberInfoLayout(
   connStats: ConnectionStats?,
   newRole: MutableState<GroupMemberRole>,
   developerTools: Boolean,
-  openDirectChat: () -> Unit,
+  connectionCode: String?,
+  getContactChat: (Long) -> Chat?,
+  knownDirectChat: (Chat) -> Unit,
+  newDirectChat: (Long) -> Unit,
   removeMember: () -> Unit,
   onRoleSelected: (GroupMemberRole) -> Unit,
   switchMemberAddress: () -> Unit,
+  verifyClicked: () -> Unit,
 ) {
   Column(
     Modifier
@@ -133,10 +171,29 @@ fun GroupMemberInfoLayout(
     }
     SectionSpacer()
 
-    SectionView {
-      OpenChatButton(openDirectChat)
+    if (member.memberActive) {
+      val contactId = member.memberContactId
+      if (contactId != null) {
+        SectionView {
+          val chat = getContactChat(contactId)
+          if (chat != null && chat.chatInfo is ChatInfo.Direct && chat.chatInfo.contact.directOrUsed) {
+            OpenChatButton(onClick = { knownDirectChat(chat) })
+            if (connectionCode != null) {
+              SectionDivider()
+            }
+          } else if (groupInfo.fullGroupPreferences.directMessages.on) {
+            OpenChatButton(onClick = { newDirectChat(contactId) })
+            if (connectionCode != null) {
+              SectionDivider()
+            }
+          }
+          if (connectionCode != null) {
+            VerifyCodeButton(member.verified, verifyClicked)
+          }
+        }
+        SectionSpacer()
+      }
     }
-    SectionSpacer()
 
     SectionView(title = stringResource(R.string.member_info_section_title_member)) {
       InfoRow(stringResource(R.string.info_row_group), groupInfo.displayName)
@@ -159,12 +216,10 @@ fun GroupMemberInfoLayout(
       }
     }
     SectionSpacer()
-    SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
-      if (developerTools) {
-        SwitchAddressButton(switchMemberAddress)
-        SectionDivider()
-      }
-      if (connStats != null) {
+    if (connStats != null) {
+      SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+      SwitchAddressButton(switchMemberAddress)
+      SectionDivider()
         val rcvServers = connStats.rcvServers
         val sndServers = connStats.sndServers
         if ((rcvServers != null && rcvServers.isNotEmpty()) || (sndServers != null && sndServers.isNotEmpty())) {
@@ -179,8 +234,8 @@ fun GroupMemberInfoLayout(
           }
         }
       }
+      SectionSpacer()
     }
-    SectionSpacer()
 
     if (member.canBeRemoved(groupInfo)) {
       SectionView {
@@ -207,12 +262,17 @@ fun GroupMemberInfoHeader(member: GroupMember) {
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
     ProfileImage(size = 192.dp, member.image, color = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Text(
-      member.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      color = MaterialTheme.colors.onBackground,
-      maxLines = 1,
-      overflow = TextOverflow.Ellipsis
-    )
+    Row(verticalAlignment = Alignment.CenterVertically) {
+      if (member.verified) {
+        Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 6.dp, top = 4.dp).size(24.dp), tint = HighOrLowlight)
+      }
+      Text(
+        member.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        color = MaterialTheme.colors.onBackground,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis
+      )
+    }
     if (member.fullName != "" && member.fullName != member.displayName) {
       Text(
         member.fullName, style = MaterialTheme.typography.h2,
@@ -302,10 +362,14 @@ fun PreviewGroupMemberInfoLayout() {
       connStats = null,
       newRole = remember { mutableStateOf(GroupMemberRole.Member) },
       developerTools = false,
-      openDirectChat = {},
+      connectionCode = "123",
+      getContactChat = { Chat.sampleData },
+      knownDirectChat = {},
+      newDirectChat = {},
       removeMember = {},
       onRoleSelected = {},
       switchMemberAddress = {},
+      verifyClicked = {},
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/GroupPreferences.kt

@@ -0,0 +1,183 @@
+package chat.simplex.app.views.chat.group
+
+import InfoRow
+import SectionDivider
+import SectionItemView
+import SectionSpacer
+import SectionTextFooter
+import SectionView
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.TimedMessagesTTLPicker
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.PreferenceToggleWithIcon
+
+@Composable
+fun GroupPreferencesView(m: ChatModel, chatId: String, close: () -> Unit,) {
+  val groupInfo = remember { derivedStateOf { (m.getChat(chatId)?.chatInfo as? ChatInfo.Group)?.groupInfo } }
+  val gInfo = groupInfo.value ?: return
+  var preferences by rememberSaveable(gInfo, stateSaver = serializableSaver()) { mutableStateOf(gInfo.fullGroupPreferences) }
+  var currentPreferences by rememberSaveable(gInfo, stateSaver = serializableSaver()) { mutableStateOf(preferences) }
+
+  fun savePrefs(afterSave: () -> Unit = {}) {
+    withApi {
+      val gp = gInfo.groupProfile.copy(groupPreferences = preferences.toGroupPreferences())
+      val gInfo = m.controller.apiUpdateGroup(gInfo.groupId, gp)
+      if (gInfo != null) {
+        m.updateGroup(gInfo)
+        currentPreferences = preferences
+      }
+      afterSave()
+    }
+  }
+  ModalView(
+    close = {
+      if (preferences == currentPreferences) close()
+      else showUnsavedChangesAlert({ savePrefs(close) }, close)
+    },
+    background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+  ) {
+    GroupPreferencesLayout(
+      preferences,
+      currentPreferences,
+      gInfo,
+      applyPrefs = { prefs ->
+        preferences = prefs
+      },
+      reset = {
+        preferences = currentPreferences
+      },
+      savePrefs = ::savePrefs,
+    )
+  }
+}
+
+@Composable
+private fun GroupPreferencesLayout(
+  preferences: FullGroupPreferences,
+  currentPreferences: FullGroupPreferences,
+  groupInfo: GroupInfo,
+  applyPrefs: (FullGroupPreferences) -> Unit,
+  reset: () -> Unit,
+  savePrefs: () -> Unit,
+) {
+  Column(
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    AppBarTitle(stringResource(R.string.group_preferences))
+    val timedMessages = remember(preferences) { mutableStateOf(preferences.timedMessages.enable) }
+    val onTTLUpdated = { ttl: Int? ->
+      applyPrefs(preferences.copy(timedMessages = preferences.timedMessages.copy(ttl = ttl ?: 86400)))
+    }
+    FeatureSection(GroupFeature.TimedMessages, timedMessages, groupInfo, preferences, onTTLUpdated) { enable ->
+      if (enable == GroupFeatureEnabled.ON) {
+         applyPrefs(preferences.copy(timedMessages = TimedMessagesGroupPreference(enable = enable, ttl = preferences.timedMessages.ttl ?: 86400)))
+      } else {
+        applyPrefs(preferences.copy(timedMessages = TimedMessagesGroupPreference(enable = enable, ttl = currentPreferences.timedMessages.ttl)))
+      }
+    }
+    SectionSpacer()
+    val allowDirectMessages = remember(preferences) { mutableStateOf(preferences.directMessages.enable) }
+    FeatureSection(GroupFeature.DirectMessages, allowDirectMessages, groupInfo, preferences, onTTLUpdated) {
+      applyPrefs(preferences.copy(directMessages = GroupPreference(enable = it)))
+    }
+    SectionSpacer()
+    val allowFullDeletion = remember(preferences) { mutableStateOf(preferences.fullDelete.enable) }
+    FeatureSection(GroupFeature.FullDelete, allowFullDeletion, groupInfo, preferences, onTTLUpdated) {
+      applyPrefs(preferences.copy(fullDelete = GroupPreference(enable = it)))
+    }
+    SectionSpacer()
+    val allowVoice = remember(preferences) { mutableStateOf(preferences.voice.enable) }
+    FeatureSection(GroupFeature.Voice, allowVoice, groupInfo, preferences, onTTLUpdated) {
+      applyPrefs(preferences.copy(voice = GroupPreference(enable = it)))
+    }
+    if (groupInfo.canEdit) {
+      SectionSpacer()
+      ResetSaveButtons(
+        reset = reset,
+        save = savePrefs,
+        disabled = preferences == currentPreferences
+      )
+    }
+  }
+}
+
+@Composable
+private fun FeatureSection(
+  feature: GroupFeature,
+  enableFeature: State<GroupFeatureEnabled>,
+  groupInfo: GroupInfo,
+  preferences: FullGroupPreferences,
+  onTTLUpdated: (Int?) -> Unit,
+  onSelected: (GroupFeatureEnabled) -> Unit
+) {
+  SectionView {
+    val on = enableFeature.value == GroupFeatureEnabled.ON
+    val icon = if (on) feature.iconFilled else feature.icon
+    val iconTint = if (on) SimplexGreen else HighOrLowlight
+    val timedOn = feature == GroupFeature.TimedMessages && enableFeature.value == GroupFeatureEnabled.ON
+    if (groupInfo.canEdit) {
+      SectionItemView {
+        PreferenceToggleWithIcon(
+          feature.text,
+          icon,
+          iconTint,
+          enableFeature.value == GroupFeatureEnabled.ON,
+        ) { checked ->
+          onSelected(if (checked) GroupFeatureEnabled.ON else GroupFeatureEnabled.OFF)
+        }
+      }
+      if (timedOn) {
+        SectionDivider()
+        val ttl = rememberSaveable(preferences.timedMessages) { mutableStateOf(preferences.timedMessages.ttl) }
+        TimedMessagesTTLPicker(ttl, onTTLUpdated)
+      }
+    } else {
+      InfoRow(
+        feature.text,
+        enableFeature.value.text,
+        icon = icon,
+        iconTint = iconTint,
+      )
+      if (timedOn) {
+        SectionDivider()
+        InfoRow(generalGetString(R.string.delete_after), TimedMessagesPreference.ttlText(preferences.timedMessages.ttl))
+      }
+    }
+  }
+  SectionTextFooter(feature.enableDescription(enableFeature.value, groupInfo.canEdit))
+}
+
+@Composable
+private fun ResetSaveButtons(reset: () -> Unit, save: () -> Unit, disabled: Boolean) {
+  SectionView {
+    SectionItemView(reset, disabled = disabled) {
+      Text(stringResource(R.string.reset_verb), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+    }
+    SectionDivider()
+    SectionItemView(save, disabled = disabled) {
+      Text(stringResource(R.string.save_and_notify_group_members), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+    }
+  }
+}
+
+private fun showUnsavedChangesAlert(save: () -> Unit, revert: () -> Unit) {
+  AlertManager.shared.showAlertDialogStacked(
+    title = generalGetString(R.string.save_preferences_question),
+    confirmText = generalGetString(R.string.save_and_notify_group_members),
+    dismissText = generalGetString(R.string.exit_without_saving),
+    onConfirm = save,
+    onDismiss = revert,
+  )
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/GroupProfileView.kt

@@ -2,11 +2,13 @@ package chat.simplex.app.views.chat.group
 
 import android.content.res.Configuration
 import android.graphics.Bitmap
+import android.net.Uri
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 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.focus.FocusRequester
@@ -53,8 +55,8 @@ fun GroupProfileLayout(
   val bottomSheetModalState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
   val displayName = remember { mutableStateOf(groupProfile.displayName) }
   val fullName = remember { mutableStateOf(groupProfile.fullName) }
-  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
-  val profileImage = remember { mutableStateOf(groupProfile.image) }
+  val chosenImage = rememberSaveable { mutableStateOf<Uri?>(null) }
+  val profileImage = rememberSaveable { mutableStateOf(groupProfile.image) }
   val scope = rememberCoroutineScope()
   val scrollState = rememberScrollState()
   val focusRequester = remember { FocusRequester() }
@@ -134,7 +136,13 @@ fun GroupProfileLayout(
               if (enabled) {
                 Text(
                   stringResource(R.string.save_group_profile),
-                  modifier = Modifier.clickable { saveProfile(GroupProfile(displayName.value, fullName.value, profileImage.value)) },
+                  modifier = Modifier.clickable {
+                    saveProfile(groupProfile.copy(
+                      displayName = displayName.value,
+                      fullName = fullName.value,
+                      image = profileImage.value
+                    ))
+                  },
                   color = MaterialTheme.colors.primary
                 )
               } else {

apps/android/app/src/main/java/chat/simplex/app/views/chat/group/WelcomeMessageView.kt

@@ -0,0 +1,94 @@
+package chat.simplex.app.views.chat.group
+
+import SectionItemView
+import SectionSpacer
+import SectionView
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun GroupWelcomeView(m: ChatModel, groupInfo: GroupInfo, close: () -> Unit) {
+  var groupInfo by remember { mutableStateOf(groupInfo) }
+  val welcomeText = remember { mutableStateOf(groupInfo.groupProfile.description ?: "") }
+
+  fun save(afterSave: () -> Unit = {}) {
+    withApi {
+      var welcome: String? = welcomeText.value.trim('\n', ' ')
+      if (welcome?.length == 0) {
+        welcome = null
+      }
+      val groupProfileUpdated = groupInfo.groupProfile.copy(description = welcome)
+      val res = m.controller.apiUpdateGroup(groupInfo.groupId, groupProfileUpdated)
+      if (res != null) {
+        groupInfo = res
+        m.updateGroup(res)
+        welcomeText.value = welcome ?: ""
+      }
+      afterSave()
+    }
+  }
+
+  ModalView(
+    close = {
+      if (welcomeText.value == groupInfo.groupProfile.description || (welcomeText.value == "" && groupInfo.groupProfile.description == null)) close()
+      else showUnsavedChangesAlert({ save(close) }, close)
+    },
+    background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+  ) {
+    GroupWelcomeLayout(
+      welcomeText,
+      groupInfo,
+      save = ::save
+    )
+  }
+}
+
+@Composable
+private fun GroupWelcomeLayout(
+  welcomeText: MutableState<String>,
+  groupInfo: GroupInfo,
+  save: () -> Unit,
+) {
+  Column(
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
+  ) {
+    AppBarTitle(stringResource(R.string.group_welcome_title))
+    val welcomeText = remember { welcomeText }
+    TextEditor(Modifier.padding(horizontal = DEFAULT_PADDING).height(160.dp), text = welcomeText)
+    SectionSpacer()
+    SaveButton(
+      save = save,
+      disabled = welcomeText.value == groupInfo.groupProfile.description || (welcomeText.value == "" && groupInfo.groupProfile.description == null)
+    )
+  }
+}
+
+@Composable
+private fun SaveButton(save: () -> Unit, disabled: Boolean) {
+  SectionView {
+    SectionItemView(save, disabled = disabled) {
+      Text(stringResource(R.string.save_and_update_group_profile), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+    }
+  }
+}
+
+private fun showUnsavedChangesAlert(save: () -> Unit, revert: () -> Unit) {
+  AlertManager.shared.showAlertDialogStacked(
+    title = generalGetString(R.string.save_welcome_message_question),
+    confirmText = generalGetString(R.string.save_and_update_group_profile),
+    dismissText = generalGetString(R.string.exit_without_saving),
+    onConfirm = save,
+    onDismiss = revert,
+  )
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CICallItemView.kt

@@ -24,7 +24,7 @@ fun CICallItemView(cInfo: ChatInfo, cItem: ChatItem, status: CICallStatus, durat
     Modifier
       .padding(horizontal = 4.dp)
       .padding(bottom = 8.dp), horizontalAlignment = Alignment.CenterHorizontally) {
-    @Composable fun ConnectingCallIcon() = Icon(Icons.Outlined.SettingsPhone, stringResource(R.string.icon_descr_call_connecting), tint = Color.Green)
+    @Composable fun ConnectingCallIcon() = Icon(Icons.Outlined.SettingsPhone, stringResource(R.string.icon_descr_call_connecting), tint = SimplexGreen)
     when (status) {
       CICallStatus.Pending -> if (sent) {
         Icon(Icons.Outlined.Call, stringResource(R.string.icon_descr_call_pending_sent))
@@ -38,7 +38,7 @@ fun CICallItemView(cInfo: ChatInfo, cItem: ChatItem, status: CICallStatus, durat
       CICallStatus.Progress -> Icon(Icons.Filled.PhoneInTalk, stringResource(R.string.icon_descr_call_progress), tint = SimplexGreen)
       CICallStatus.Ended -> Row {
         Icon(Icons.Outlined.CallEnd, stringResource(R.string.icon_descr_call_ended), tint = HighOrLowlight, modifier = Modifier.padding(end = 4.dp))
-        Text(status.duration(duration), color = HighOrLowlight)
+        Text(durationText(duration), color = HighOrLowlight)
       }
       CICallStatus.Error -> {}
     }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIChatFeatureView.kt

@@ -0,0 +1,34 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.model.*
+
+@Composable
+fun CIChatFeatureView(
+  chatItem: ChatItem,
+  feature: Feature,
+  iconColor: Color,
+  icon: ImageVector? = null
+) {
+  Row(
+    Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.spacedBy(4.dp)
+  ) {
+    Icon(icon ?: feature.iconFilled, feature.text, Modifier.size(18.dp), tint = iconColor)
+    Text(
+      chatEventText(chatItem),
+      Modifier,
+      // this is important. Otherwise, aligning will be bad because annotated string has a Span with size 12.sp
+      fontSize = 12.sp
+    )
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIEventView.kt

@@ -18,32 +18,38 @@ import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
 fun CIEventView(ci: ChatItem) {
-  fun withGroupEventStyle(builder: AnnotatedString.Builder, text: String) {
-    return builder.withStyle(SpanStyle(fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)) { append(text) }
+  @Composable
+  fun chatEventTextView(text: AnnotatedString) {
+    Text(text, style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp))
   }
 
   Surface {
     Row(
       Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
-      verticalAlignment = Alignment.Bottom
+      verticalAlignment = Alignment.CenterVertically
     ) {
-      Text(
-        buildAnnotatedString {
-          val memberDisplayName = ci.memberDisplayName
-          if (memberDisplayName != null) {
-            withGroupEventStyle(this, memberDisplayName)
+      val memberDisplayName = ci.memberDisplayName
+      if (memberDisplayName != null) {
+        chatEventTextView(
+          buildAnnotatedString {
+            withStyle(chatEventStyle) { append(memberDisplayName) }
             append(" ")
-          }
-          withGroupEventStyle(this, ci.content.text)
-          append(" ")
-          withGroupEventStyle(this, ci.timestampText)
-        },
-        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp)
-      )
+          }.plus(chatEventText(ci))
+        )
+      } else {
+        chatEventTextView(chatEventText(ci))
+      }
     }
   }
 }
 
+val chatEventStyle = SpanStyle(fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)
+
+fun chatEventText(ci: ChatItem): AnnotatedString =
+  buildAnnotatedString {
+    withStyle(chatEventStyle) { append(ci.content.text + "  " + ci.timestampText) }
+  }
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIFeaturePreferenceView.kt

@@ -0,0 +1,54 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.views.helpers.generalGetString
+
+@Composable
+fun CIFeaturePreferenceView(
+  chatItem: ChatItem,
+  contact: Contact?,
+  feature: ChatFeature,
+  allowed: FeatureAllowed,
+  acceptFeature: (Contact, ChatFeature, Int?) -> Unit
+) {
+  Row(
+    Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.spacedBy(4.dp)
+  ) {
+    Icon(feature.icon, feature.text, Modifier.size(18.dp), tint = HighOrLowlight)
+    if (contact != null && allowed != FeatureAllowed.NO && contact.allowsFeature(feature) && !contact.userAllowsFeature(feature)) {
+      val acceptStyle = SpanStyle(color = MaterialTheme.colors.primary, fontSize = 12.sp)
+      val setParam = feature == ChatFeature.TimedMessages && contact.mergedPreferences.timedMessages.userPreference.pref.ttl == null
+      val acceptTextId = if (setParam) R.string.accept_feature_set_1_day else R.string.accept_feature
+      val param = if (setParam) 86400 else null
+      val annotatedText = buildAnnotatedString {
+        withStyle(chatEventStyle) { append(chatItem.content.text + "  ") }
+        withAnnotation(tag = "Accept", annotation = "Accept") {
+          withStyle(acceptStyle) { append(generalGetString(acceptTextId) + "  ") }
+        }
+        withStyle(chatEventStyle) { append(chatItem.timestampText) }
+      }
+      fun accept(offset: Int): Boolean = annotatedText.getStringAnnotations(tag = "Accept", start = offset, end = offset).isNotEmpty()
+      ClickableText(
+        annotatedText,
+        onClick = { if (accept(it)) { acceptFeature(contact, feature, param) } },
+        shouldConsumeEvent = ::accept
+      )
+    } else {
+      Text(chatItem.content.text + "  " + chatItem.timestampText,
+        fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)
+    }
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIFileView.kt

@@ -3,6 +3,7 @@ package chat.simplex.app.views.chat.item
 import android.widget.Toast
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CornerSize
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
@@ -16,6 +17,7 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.*
 import androidx.compose.ui.unit.dp
@@ -64,7 +66,7 @@ fun CIFileView(
 
   fun fileSizeValid(): Boolean {
     if (file != null) {
-      return file.fileSize <= MAX_FILE_SIZE
+      return file.fileSize <= getMaxFileSize(file.fileProtocol)
     }
     return false
   }
@@ -72,22 +74,30 @@ fun CIFileView(
   fun fileAction() {
     if (file != null) {
       when (file.fileStatus) {
-        CIFileStatus.RcvInvitation -> {
+        is CIFileStatus.RcvInvitation -> {
           if (fileSizeValid()) {
             receiveFile(file.fileId)
           } else {
             AlertManager.shared.showAlertMsg(
               generalGetString(R.string.large_file),
-              String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(MAX_FILE_SIZE))
+              String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(getMaxFileSize(file.fileProtocol)))
             )
           }
         }
-        CIFileStatus.RcvAccepted ->
-          AlertManager.shared.showAlertMsg(
-            generalGetString(R.string.waiting_for_file),
-            String.format(generalGetString(R.string.file_will_be_received_when_contact_is_online), MAX_FILE_SIZE)
-          )
-        CIFileStatus.RcvComplete -> {
+        is CIFileStatus.RcvAccepted ->
+          when (file.fileProtocol) {
+            FileProtocol.XFTP ->
+              AlertManager.shared.showAlertMsg(
+                generalGetString(R.string.waiting_for_file),
+                generalGetString(R.string.file_will_be_received_when_contact_completes_uploading)
+              )
+            FileProtocol.SMP ->
+              AlertManager.shared.showAlertMsg(
+                generalGetString(R.string.waiting_for_file),
+                generalGetString(R.string.file_will_be_received_when_contact_is_online)
+              )
+          }
+        is CIFileStatus.RcvComplete -> {
           val filePath = getLoadedFilePath(context, file)
           if (filePath != null) {
             saveFileLauncher.launch(file.fileName)
@@ -105,10 +115,24 @@ fun CIFileView(
     CircularProgressIndicator(
       Modifier.size(32.dp),
       color = if (isInDarkTheme()) FileDark else FileLight,
-      strokeWidth = 4.dp
+      strokeWidth = 3.dp
     )
   }
 
+  @Composable
+  fun progressCircle(progress: Long, total: Long) {
+    val angle = 360f * (progress.toDouble() / total.toDouble()).toFloat()
+    val strokeWidth = with(LocalDensity.current) { 3.dp.toPx() }
+    val strokeColor = if (isInDarkTheme()) FileDark else FileLight
+    Surface(
+      Modifier.drawRingModifier(angle, strokeColor, strokeWidth),
+      color = Color.Transparent,
+      shape = MaterialTheme.shapes.small.copy(CornerSize(percent = 50))
+    ) {
+      Box(Modifier.size(32.dp))
+    }
+  }
+
   @Composable
   fun fileIndicator() {
     Box(
@@ -120,19 +144,32 @@ fun CIFileView(
     ) {
       if (file != null) {
         when (file.fileStatus) {
-          CIFileStatus.SndStored -> fileIcon()
-          CIFileStatus.SndTransfer -> progressIndicator()
-          CIFileStatus.SndComplete -> fileIcon(innerIcon = Icons.Filled.Check)
-          CIFileStatus.SndCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
-          CIFileStatus.RcvInvitation ->
+          is CIFileStatus.SndStored ->
+            when (file.fileProtocol) {
+              FileProtocol.XFTP -> progressIndicator()
+              FileProtocol.SMP -> fileIcon()
+            }
+          is CIFileStatus.SndTransfer ->
+            when (file.fileProtocol) {
+              FileProtocol.XFTP -> progressCircle(file.fileStatus.sndProgress, file.fileStatus.sndTotal)
+              FileProtocol.SMP -> progressIndicator()
+            }
+          is CIFileStatus.SndComplete -> fileIcon(innerIcon = Icons.Filled.Check)
+          is CIFileStatus.SndCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
+          is CIFileStatus.RcvInvitation ->
             if (fileSizeValid())
               fileIcon(innerIcon = Icons.Outlined.ArrowDownward, color = MaterialTheme.colors.primary)
             else
               fileIcon(innerIcon = Icons.Outlined.PriorityHigh, color = WarningOrange)
-          CIFileStatus.RcvAccepted -> fileIcon(innerIcon = Icons.Outlined.MoreHoriz)
-          CIFileStatus.RcvTransfer -> progressIndicator()
-          CIFileStatus.RcvComplete -> fileIcon()
-          CIFileStatus.RcvCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
+          is CIFileStatus.RcvAccepted -> fileIcon(innerIcon = Icons.Outlined.MoreHoriz)
+          is CIFileStatus.RcvTransfer ->
+            if (file.fileProtocol == FileProtocol.XFTP && file.fileStatus.rcvProgress < file.fileStatus.rcvTotal) {
+              progressCircle(file.fileStatus.rcvProgress, file.fileStatus.rcvTotal)
+            } else {
+              progressIndicator()
+            }
+          is CIFileStatus.RcvComplete -> fileIcon()
+          is CIFileStatus.RcvCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
         }
       } else {
         fileIcon()
@@ -174,14 +211,14 @@ fun CIFileView(
 class ChatItemProvider: PreviewParameterProvider<ChatItem> {
   private val sentFile = ChatItem(
     chatDir = CIDirection.DirectSnd(),
-    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.SndSent(), itemDeleted = false, itemEdited = true, editable = false),
+    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.SndSent(), itemEdited = true),
     content = CIContent.SndMsgContent(msgContent = MsgContent.MCFile("")),
     quotedItem = null,
     file = CIFile.getSample(fileStatus = CIFileStatus.SndComplete)
   )
   private val fileChatItemWtFile = ChatItem(
     chatDir = CIDirection.DirectRcv(),
-    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.RcvRead(), itemDeleted = false, itemEdited = false, editable = false),
+    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.RcvRead(), ),
     content = CIContent.RcvMsgContent(msgContent = MsgContent.MCFile("")),
     quotedItem = null,
     file = null
@@ -191,7 +228,7 @@ class ChatItemProvider: PreviewParameterProvider<ChatItem> {
     ChatItem.getFileMsgContentSample(),
     ChatItem.getFileMsgContentSample(fileName = "some_long_file_name_here", fileStatus = CIFileStatus.RcvInvitation),
     ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvAccepted),
-    ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvTransfer),
+    ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvTransfer(rcvProgress = 7, rcvTotal = 10)),
     ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvCancelled),
     ChatItem.getFileMsgContentSample(fileSize = 1_000_000_000, fileStatus = CIFileStatus.RcvInvitation),
     ChatItem.getFileMsgContentSample(text = "Hello there", fileStatus = CIFileStatus.RcvInvitation),
@@ -205,6 +242,6 @@ class ChatItemProvider: PreviewParameterProvider<ChatItem> {
 fun PreviewCIFileFramedItemView(@PreviewParameter(ChatItemProvider::class) chatItem: ChatItem) {
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
-    FramedItemView(ChatInfo.Direct.sampleData, chatItem, showMenu = showMenu, receiveFile = {})
+    FramedItemView(ChatInfo.Direct.sampleData, chatItem, linkMode = SimplexLinkMode.DESCRIPTION, showMenu = showMenu, receiveFile = {})
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIImageView.kt

@@ -2,6 +2,7 @@ package chat.simplex.app.views.chat.item
 
 import android.graphics.Bitmap
 import android.os.Build.VERSION.SDK_INT
+import androidx.annotation.StringRes
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
@@ -9,8 +10,7 @@ import androidx.compose.material.CircularProgressIndicator
 import androidx.compose.material.Icon
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
-import androidx.compose.material.icons.outlined.ArrowDownward
-import androidx.compose.material.icons.outlined.MoreHoriz
+import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -18,6 +18,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.graphics.painter.BitmapPainter
 import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.layout.layoutId
 import androidx.compose.ui.platform.*
@@ -27,8 +28,7 @@ import androidx.compose.ui.unit.dp
 import androidx.core.content.FileProvider
 import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.model.CIFile
-import chat.simplex.app.model.CIFileStatus
+import chat.simplex.app.model.*
 import chat.simplex.app.views.helpers.*
 import coil.ImageLoader
 import coil.compose.rememberAsyncImagePainter
@@ -45,6 +45,25 @@ fun CIImageView(
   showMenu: MutableState<Boolean>,
   receiveFile: (Long) -> Unit
 ) {
+  @Composable
+  fun progressIndicator() {
+    CircularProgressIndicator(
+      Modifier.size(16.dp),
+      color = Color.White,
+      strokeWidth = 2.dp
+    )
+  }
+
+  @Composable
+  fun fileIcon(icon: ImageVector, @StringRes stringId: Int) {
+    Icon(
+      icon,
+      stringResource(stringId),
+      Modifier.fillMaxSize(),
+      tint = Color.White
+    )
+  }
+
   @Composable
   fun loadingIndicator() {
     if (file != null) {
@@ -55,39 +74,18 @@ fun CIImageView(
         contentAlignment = Alignment.Center
       ) {
         when (file.fileStatus) {
-          CIFileStatus.SndTransfer ->
-            CircularProgressIndicator(
-              Modifier.size(16.dp),
-              color = Color.White,
-              strokeWidth = 2.dp
-            )
-          CIFileStatus.SndComplete ->
-            Icon(
-              Icons.Filled.Check,
-              stringResource(R.string.icon_descr_image_snd_complete),
-              Modifier.fillMaxSize(),
-              tint = Color.White
-            )
-          CIFileStatus.RcvAccepted ->
-            Icon(
-              Icons.Outlined.MoreHoriz,
-              stringResource(R.string.icon_descr_waiting_for_image),
-              Modifier.fillMaxSize(),
-              tint = Color.White
-            )
-          CIFileStatus.RcvTransfer ->
-            CircularProgressIndicator(
-              Modifier.size(16.dp),
-              color = Color.White,
-              strokeWidth = 2.dp
-            )
-          CIFileStatus.RcvInvitation ->
-            Icon(
-              Icons.Outlined.ArrowDownward,
-              stringResource(R.string.icon_descr_asked_to_receive),
-              Modifier.fillMaxSize(),
-              tint = Color.White
-            )
+          is CIFileStatus.SndStored ->
+            when (file.fileProtocol) {
+              FileProtocol.XFTP -> progressIndicator()
+              FileProtocol.SMP -> {}
+            }
+          is CIFileStatus.SndTransfer -> progressIndicator()
+          is CIFileStatus.SndComplete -> fileIcon(Icons.Filled.Check, R.string.icon_descr_image_snd_complete)
+          is CIFileStatus.SndCancelled -> fileIcon(Icons.Outlined.Close, R.string.icon_descr_file)
+          is CIFileStatus.RcvInvitation -> fileIcon(Icons.Outlined.ArrowDownward, R.string.icon_descr_asked_to_receive)
+          is CIFileStatus.RcvAccepted -> fileIcon(Icons.Outlined.MoreHoriz, R.string.icon_descr_waiting_for_image)
+          is CIFileStatus.RcvTransfer -> progressIndicator()
+          is CIFileStatus.RcvCancelled -> fileIcon(Icons.Outlined.Close, R.string.icon_descr_file)
           else -> {}
         }
       }
@@ -136,7 +134,7 @@ fun CIImageView(
 
   fun fileSizeValid(): Boolean {
     if (file != null) {
-      return file.fileSize <= MAX_FILE_SIZE
+      return file.fileSize <= getMaxFileSize(file.fileProtocol)
     }
     return false
   }
@@ -160,7 +158,9 @@ fun CIImageView(
         placeholder = BitmapPainter(imageBitmap.asImageBitmap()), // show original image while it's still loading by coil
         imageLoader = imageLoader
       )
+      val view = LocalView.current
       imageView(imagePainter, onClick = {
+        hideKeyboard(view)
         if (getLoadedFilePath(context, file) != null) {
           ModalManager.shared.showCustomModal(animated = false) { close ->
             ImageFullScreenView(imageProvider, close)
@@ -177,15 +177,23 @@ fun CIImageView(
               } else {
                 AlertManager.shared.showAlertMsg(
                   generalGetString(R.string.large_file),
-                  String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(MAX_FILE_SIZE))
+                  String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(getMaxFileSize(file.fileProtocol)))
                 )
               }
             CIFileStatus.RcvAccepted ->
-              AlertManager.shared.showAlertMsg(
-                generalGetString(R.string.waiting_for_image),
-                generalGetString(R.string.image_will_be_received_when_contact_is_online)
-              )
-            CIFileStatus.RcvTransfer -> {} // ?
+              when (file.fileProtocol) {
+                FileProtocol.XFTP ->
+                  AlertManager.shared.showAlertMsg(
+                    generalGetString(R.string.waiting_for_image),
+                    generalGetString(R.string.image_will_be_received_when_contact_completes_uploading)
+                  )
+                FileProtocol.SMP ->
+                  AlertManager.shared.showAlertMsg(
+                    generalGetString(R.string.waiting_for_image),
+                    generalGetString(R.string.image_will_be_received_when_contact_is_online)
+                  )
+              }
+            CIFileStatus.RcvTransfer(rcvProgress = 7, rcvTotal = 10) -> {} // ?
             CIFileStatus.RcvComplete -> {} // ?
             CIFileStatus.RcvCancelled -> {} // TODO
             else -> {}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIInvalidJSONView.kt

@@ -0,0 +1,46 @@
+package chat.simplex.app.views.chat.item
+
+import SectionSpacer
+import SectionView
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Share
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.SettingsActionItem
+
+@Composable
+fun CIInvalidJSONView(json: String) {
+  Row(Modifier
+    .clickable { ModalManager.shared.showModal(true) { InvalidJSONView(json) } }
+    .padding(horizontal = 10.dp, vertical = 6.dp)
+  ) {
+    Text(stringResource(R.string.invalid_data), color = Color.Red, fontStyle = FontStyle.Italic)
+  }
+}
+
+@Composable
+fun InvalidJSONView(json: String) {
+  Column {
+    Spacer(Modifier.height(DEFAULT_PADDING))
+    SectionView {
+      val context = LocalContext.current
+      SettingsActionItem(Icons.Outlined.Share, generalGetString(R.string.share_verb), click = {
+        shareText(context, json)
+      })
+    }
+    Column(Modifier.padding(DEFAULT_PADDING).fillMaxWidth().verticalScroll(rememberScrollState())) {
+      Text(json)
+    }
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIMetaView.kt

@@ -3,61 +3,86 @@ package chat.simplex.app.views.chat.item
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.filled.Circle
+import androidx.compose.material.icons.outlined.Edit
+import androidx.compose.material.icons.outlined.Timer
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
 import kotlinx.datetime.Clock
 
 @Composable
-fun CIMetaView(chatItem: ChatItem, metaColor: Color = HighOrLowlight) {
-  Row(verticalAlignment = Alignment.CenterVertically) {
-    if (!chatItem.isDeletedContent) {
-      if (chatItem.meta.itemEdited) {
-        Icon(
-          Icons.Filled.Edit,
-          modifier = Modifier.height(12.dp).padding(end = 1.dp),
-          contentDescription = stringResource(R.string.icon_descr_edited),
-          tint = metaColor,
-        )
-      }
-      CIStatusView(chatItem.meta.itemStatus, metaColor)
+fun CIMetaView(chatItem: ChatItem, timedMessagesTTL: Int?, metaColor: Color = HighOrLowlight) {
+  Row(Modifier.padding(start = 3.dp), verticalAlignment = Alignment.CenterVertically) {
+    if (chatItem.isDeletedContent) {
+      Text(
+        chatItem.timestampText,
+        color = metaColor,
+        fontSize = 14.sp,
+        modifier = Modifier.padding(start = 3.dp)
+      )
+    } else {
+      CIMetaText(chatItem.meta, timedMessagesTTL, metaColor)
     }
-    Text(
-      chatItem.timestampText,
-      color = metaColor,
-      fontSize = 14.sp,
-      modifier = Modifier.padding(start = 3.dp)
-    )
   }
 }
 
+@Composable
+// changing this function requires updating reserveSpaceForMeta
+private fun CIMetaText(meta: CIMeta, chatTTL: Int?, color: Color) {
+  if (meta.itemEdited) {
+    StatusIconText(Icons.Outlined.Edit, color)
+    Spacer(Modifier.width(3.dp))
+  }
+  if (meta.disappearing) {
+    StatusIconText(Icons.Outlined.Timer, color)
+    val ttl = meta.itemTimed?.ttl
+    if (ttl != chatTTL) {
+      Text(TimedMessagesPreference.shortTtlText(ttl), color = color, fontSize = 13.sp)
+    }
+    Spacer(Modifier.width(4.dp))
+  }
+  val statusIcon = meta.statusIcon(MaterialTheme.colors.primary, color)
+  if (statusIcon != null) {
+    val (icon, statusColor) = statusIcon
+    StatusIconText(icon, statusColor)
+    Spacer(Modifier.width(4.dp))
+  } else if (!meta.disappearing) {
+    StatusIconText(Icons.Filled.Circle, Color.Transparent)
+    Spacer(Modifier.width(4.dp))
+  }
+  Text(meta.timestampText, color = color, fontSize = 13.sp, maxLines = 1, overflow = TextOverflow.Ellipsis)
+}
+
+// the conditions in this function should match CIMetaText
+fun reserveSpaceForMeta(meta: CIMeta, chatTTL: Int?): String {
+  val iconSpace = "    "
+  var res = ""
+  if (meta.itemEdited) res += iconSpace
+  if (meta.itemTimed != null) {
+    res += iconSpace
+    val ttl = meta.itemTimed.ttl
+    if (ttl != chatTTL) {
+      res += TimedMessagesPreference.shortTtlText(ttl)
+    }
+  }
+  if (meta.statusIcon(HighOrLowlight) != null || !meta.disappearing) {
+    res += iconSpace
+  }
+  return res + meta.timestampText
+}
 
 @Composable
-fun CIStatusView(status: CIStatus, metaColor: Color = HighOrLowlight) {
-  when (status) {
-    is CIStatus.SndSent -> {
-      Icon(Icons.Filled.Check, stringResource(R.string.icon_descr_sent_msg_status_sent), Modifier.height(12.dp), tint = metaColor)
-    }
-    is CIStatus.SndErrorAuth -> {
-      Icon(Icons.Filled.Close,  stringResource(R.string.icon_descr_sent_msg_status_unauthorized_send), Modifier.height(12.dp), tint = Color.Red)
-    }
-    is CIStatus.SndError -> {
-      Icon(Icons.Filled.WarningAmber, stringResource(R.string.icon_descr_sent_msg_status_send_failed), Modifier.height(12.dp), tint = Color.Yellow)
-    }
-    is CIStatus.RcvNew -> {
-      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = MaterialTheme.colors.primary)
-    }
-    else -> {}
-  }
+private fun StatusIconText(icon: ImageVector, color: Color) {
+  Icon(icon, null, Modifier.height(12.dp), tint = color)
 }
 
 @Preview
@@ -66,7 +91,8 @@ fun PreviewCIMetaView() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-    )
+    ),
+    null
   )
 }
 
@@ -77,7 +103,8 @@ fun PreviewCIMetaViewUnread() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       status = CIStatus.RcvNew()
-    )
+    ),
+    null
   )
 }
 
@@ -87,8 +114,9 @@ fun PreviewCIMetaViewSendFailed() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
-      status = CIStatus.SndError(AgentErrorType.CMD(CommandErrorType.SYNTAX()))
-    )
+      status = CIStatus.SndError("CMD SYNTAX")
+    ),
+    null
   )
 }
 
@@ -98,7 +126,8 @@ fun PreviewCIMetaViewSendNoAuth() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndErrorAuth()
-    )
+    ),
+    null
   )
 }
 
@@ -108,7 +137,8 @@ fun PreviewCIMetaViewSendSent() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndSent()
-    )
+    ),
+    null
   )
 }
 
@@ -119,7 +149,8 @@ fun PreviewCIMetaViewEdited() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true
-    )
+    ),
+    null
   )
 }
 
@@ -131,7 +162,8 @@ fun PreviewCIMetaViewEditedUnread() {
       1, CIDirection.DirectRcv(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.RcvNew()
-    )
+    ),
+    null
   )
 }
 
@@ -143,7 +175,8 @@ fun PreviewCIMetaViewEditedSent() {
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.SndSent()
-    )
+    ),
+    null
   )
 }
 
@@ -151,6 +184,7 @@ fun PreviewCIMetaViewEditedSent() {
 @Composable
 fun PreviewCIMetaViewDeletedContent() {
   CIMetaView(
-    chatItem = ChatItem.getDeletedContentSampleData()
+    chatItem = ChatItem.getDeletedContentSampleData(),
+    null
   )
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIVideoView.kt

@@ -0,0 +1,339 @@
+package chat.simplex.app.views.chat.item
+
+import android.graphics.Bitmap
+import android.graphics.Rect
+import android.net.Uri
+import androidx.annotation.StringRes
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CornerSize
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.*
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.*
+import androidx.compose.ui.platform.*
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.*
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.FileProvider
+import androidx.core.graphics.drawable.toDrawable
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import com.google.android.exoplayer2.ui.AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
+import com.google.android.exoplayer2.ui.StyledPlayerView
+import java.io.File
+
+@Composable
+fun CIVideoView(
+  image: String,
+  duration: Int,
+  file: CIFile?,
+  imageProvider: () -> ImageGalleryProvider,
+  showMenu: MutableState<Boolean>,
+  receiveFile: (Long) -> Unit
+) {
+  Box(
+    Modifier.layoutId(CHAT_IMAGE_LAYOUT_ID),
+    contentAlignment = Alignment.TopEnd
+  ) {
+    val context = LocalContext.current
+    val filePath = remember(file) { getLoadedFilePath(SimplexApp.context, file) }
+    val preview = remember(image) { base64ToBitmap(image) }
+    if (file != null && filePath != null) {
+      val uri = remember(filePath) { FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))  }
+      val view = LocalView.current
+      VideoView(uri, file, preview, duration * 1000L, showMenu, onClick = {
+        hideKeyboard(view)
+        ModalManager.shared.showCustomModal(animated = false) { close ->
+          ImageFullScreenView(imageProvider, close)
+        }
+      })
+    } else {
+      Box {
+        ImageView(preview, showMenu, onClick = {
+          if (file != null) {
+            when (file.fileStatus) {
+              CIFileStatus.RcvInvitation ->
+                receiveFileIfValidSize(file, receiveFile)
+              CIFileStatus.RcvAccepted ->
+                when (file.fileProtocol) {
+                  FileProtocol.XFTP ->
+                    AlertManager.shared.showAlertMsg(
+                      generalGetString(R.string.waiting_for_video),
+                      generalGetString(R.string.video_will_be_received_when_contact_completes_uploading)
+                    )
+
+                  FileProtocol.SMP ->
+                    AlertManager.shared.showAlertMsg(
+                      generalGetString(R.string.waiting_for_video),
+                      generalGetString(R.string.video_will_be_received_when_contact_is_online)
+                    )
+                }
+              CIFileStatus.RcvTransfer(rcvProgress = 7, rcvTotal = 10) -> {} // ?
+              CIFileStatus.RcvComplete -> {} // ?
+              CIFileStatus.RcvCancelled -> {} // TODO
+              else -> {}
+            }
+          }
+        })
+        if (file != null) {
+          DurationProgress(file, remember { mutableStateOf(false) }, remember { mutableStateOf(duration * 1000L) }, remember { mutableStateOf(0L) }/*, soundEnabled*/)
+        }
+        if (file?.fileStatus is CIFileStatus.RcvInvitation) {
+          PlayButton(error = false, { showMenu.value = true }) { receiveFileIfValidSize(file, receiveFile) }
+        }
+      }
+    }
+    loadingIndicator(file)
+  }
+}
+
+@Composable
+private fun VideoView(uri: Uri, file: CIFile, defaultPreview: Bitmap, defaultDuration: Long, showMenu: MutableState<Boolean>, onClick: () -> Unit) {
+  val context = LocalContext.current
+  val player = remember(uri) { VideoPlayer.getOrCreate(uri, false, defaultPreview, defaultDuration, true, context) }
+  val videoPlaying = remember(uri.path) { player.videoPlaying }
+  val progress = remember(uri.path) { player.progress }
+  val duration = remember(uri.path) { player.duration }
+  val preview by remember { player.preview }
+//  val soundEnabled by rememberSaveable(uri.path) { player.soundEnabled }
+  val brokenVideo by rememberSaveable(uri.path) { player.brokenVideo }
+  val play = {
+    player.enableSound(true)
+    player.play(true)
+  }
+  val stop = {
+    player.enableSound(false)
+    player.stop()
+  }
+  val showPreview = remember { derivedStateOf { !videoPlaying.value || progress.value == 0L } }
+  DisposableEffect(Unit) {
+    onDispose {
+      stop()
+    }
+  }
+  Box {
+    val windowWidth = LocalWindowWidth()
+    val width = remember(preview) { if (preview.width * 0.97 <= preview.height) videoViewFullWidth(windowWidth) * 0.75f else 1000.dp }
+    AndroidView(
+      factory = { ctx ->
+        StyledPlayerView(ctx).apply {
+          useController = false
+          resizeMode = RESIZE_MODE_FIXED_WIDTH
+          this.player = player.player
+        }
+      },
+      Modifier
+        .width(width)
+        .combinedClickable(
+          onLongClick = { showMenu.value = true },
+          onClick = { if (player.player.playWhenReady) stop() else onClick() }
+        )
+    )
+    if (showPreview.value) {
+      ImageView(preview, showMenu, onClick)
+      PlayButton(brokenVideo, onLongClick =  { showMenu.value = true }, play)
+    }
+    DurationProgress(file, videoPlaying, duration, progress/*, soundEnabled*/)
+  }
+}
+
+@Composable
+private fun BoxScope.PlayButton(error: Boolean = false, onLongClick: () -> Unit, onClick: () -> Unit) {
+  Surface(
+    Modifier.align(Alignment.Center),
+    color = Color.Black.copy(alpha = 0.25f),
+    shape = RoundedCornerShape(percent = 50)
+  ) {
+    Box(
+      Modifier
+        .defaultMinSize(minWidth = 40.dp, minHeight = 40.dp)
+        .combinedClickable(onClick = onClick, onLongClick = onLongClick),
+      contentAlignment = Alignment.Center
+    ) {
+      Icon(
+        imageVector = Icons.Filled.PlayArrow,
+        contentDescription = null,
+        Modifier.size(25.dp),
+        tint = if (error) WarningOrange else Color.White
+      )
+    }
+  }
+}
+
+@Composable
+private fun DurationProgress(file: CIFile, playing: MutableState<Boolean>, duration: MutableState<Long>, progress: MutableState<Long>/*, soundEnabled: MutableState<Boolean>*/) {
+  if (duration.value > 0L || progress.value > 0) {
+    Row {
+      Box(
+        Modifier
+          .padding(DEFAULT_PADDING_HALF)
+          .background(Color.Black.copy(alpha = 0.35f), RoundedCornerShape(percent = 50))
+          .padding(vertical = 2.dp, horizontal = 4.dp)
+      ) {
+        val time = if (progress.value > 0) progress.value else duration.value
+        val timeStr = durationText((time / 1000).toInt())
+        val width = if (timeStr.length <= 5) 44 else 50
+        Text(
+          timeStr,
+          Modifier.widthIn(min = with(LocalDensity.current) { width.sp.toDp() }).padding(horizontal = 4.dp),
+          fontSize = 13.sp,
+          color = Color.White
+        )
+        /*if (!soundEnabled.value) {
+        Icon(Icons.Outlined.VolumeOff, null,
+          Modifier.padding(start = 5.dp).size(10.dp),
+          tint = Color.White
+        )
+      }*/
+      }
+      if (!playing.value) {
+        Box(
+          Modifier
+            .padding(top = DEFAULT_PADDING_HALF)
+            .background(Color.Black.copy(alpha = 0.35f), RoundedCornerShape(percent = 50))
+            .padding(vertical = 2.dp, horizontal = 4.dp)
+        ) {
+          Text(
+            formatBytes(file.fileSize),
+            Modifier.padding(horizontal = 4.dp),
+            fontSize = 13.sp,
+            color = Color.White
+          )
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun ImageView(preview: Bitmap, showMenu: MutableState<Boolean>, onClick: () -> Unit) {
+  val windowWidth = LocalWindowWidth()
+  val width = remember(preview) { if (preview.width * 0.97 <= preview.height) videoViewFullWidth(windowWidth) * 0.75f else 1000.dp }
+  Image(
+    preview.asImageBitmap(),
+    contentDescription = stringResource(R.string.video_descr),
+    modifier = Modifier
+      .width(width)
+      .combinedClickable(
+        onLongClick = { showMenu.value = true },
+        onClick = onClick
+      ),
+    contentScale = ContentScale.FillWidth,
+  )
+}
+
+@Composable
+private fun LocalWindowWidth(): Dp {
+  val view = LocalView.current
+  val density = LocalDensity.current.density
+  return remember {
+    val rect = Rect()
+    view.getWindowVisibleDisplayFrame(rect)
+    (rect.width() / density).dp
+  }
+}
+
+@Composable
+private fun progressIndicator() {
+  CircularProgressIndicator(
+    Modifier.size(16.dp),
+    color = Color.White,
+    strokeWidth = 2.dp
+  )
+}
+
+@Composable
+private fun fileIcon(icon: ImageVector, @StringRes stringId: Int) {
+  Icon(
+    icon,
+    stringResource(stringId),
+    Modifier.fillMaxSize(),
+    tint = Color.White
+  )
+}
+
+@Composable
+private fun progressCircle(progress: Long, total: Long) {
+  val angle = 360f * (progress.toDouble() / total.toDouble()).toFloat()
+  val strokeWidth = with(LocalDensity.current) { 2.dp.toPx() }
+  val strokeColor = Color.White
+  Surface(
+    Modifier.drawRingModifier(angle, strokeColor, strokeWidth),
+    color = Color.Transparent,
+    shape = MaterialTheme.shapes.small.copy(CornerSize(percent = 50))
+  ) {
+    Box(Modifier.size(16.dp))
+  }
+}
+
+@Composable
+private fun loadingIndicator(file: CIFile?) {
+  if (file != null) {
+    Box(
+      Modifier
+        .padding(8.dp)
+        .size(20.dp),
+      contentAlignment = Alignment.Center
+    ) {
+      when (file.fileStatus) {
+        is CIFileStatus.SndStored ->
+          when (file.fileProtocol) {
+            FileProtocol.XFTP -> progressIndicator()
+            FileProtocol.SMP -> {}
+          }
+        is CIFileStatus.SndTransfer ->
+          when (file.fileProtocol) {
+            FileProtocol.XFTP -> progressCircle(file.fileStatus.sndProgress, file.fileStatus.sndTotal)
+            FileProtocol.SMP -> progressIndicator()
+          }
+        is CIFileStatus.SndComplete -> fileIcon(Icons.Filled.Check, R.string.icon_descr_video_snd_complete)
+        is CIFileStatus.SndCancelled -> fileIcon(Icons.Outlined.Close, R.string.icon_descr_file)
+        is CIFileStatus.RcvInvitation -> fileIcon(Icons.Outlined.ArrowDownward, R.string.icon_descr_video_asked_to_receive)
+        is CIFileStatus.RcvAccepted -> fileIcon(Icons.Outlined.MoreHoriz, R.string.icon_descr_waiting_for_video)
+        is CIFileStatus.RcvTransfer ->
+          if (file.fileProtocol == FileProtocol.XFTP && file.fileStatus.rcvProgress < file.fileStatus.rcvTotal) {
+            progressCircle(file.fileStatus.rcvProgress, file.fileStatus.rcvTotal)
+          } else {
+            progressIndicator()
+          }
+        is CIFileStatus.RcvCancelled -> fileIcon(Icons.Outlined.Close, R.string.icon_descr_file)
+        else -> {}
+      }
+    }
+  }
+}
+
+private fun fileSizeValid(file: CIFile?): Boolean {
+  if (file != null) {
+    return file.fileSize <= getMaxFileSize(file.fileProtocol)
+  }
+  return false
+}
+
+private fun receiveFileIfValidSize(file: CIFile, receiveFile: (Long) -> Unit) {
+  if (fileSizeValid(file)) {
+    receiveFile(file.fileId)
+  } else {
+    AlertManager.shared.showAlertMsg(
+      generalGetString(R.string.large_file),
+      String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(getMaxFileSize(file.fileProtocol)))
+    )
+  }
+}
+
+private fun videoViewFullWidth(windowWidth: Dp): Dp {
+  val approximatePadding = 100.dp
+  return minOf(1000.dp, windowWidth - approximatePadding)
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/CIVoiceView.kt

@@ -0,0 +1,260 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CornerSize
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.drawWithCache
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.*
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+
+// TODO refactor https://github.com/simplex-chat/simplex-chat/pull/1451#discussion_r1033429901
+
+@Composable
+fun CIVoiceView(
+  providedDurationSec: Int,
+  file: CIFile?,
+  edited: Boolean,
+  sent: Boolean,
+  hasText: Boolean,
+  ci: ChatItem,
+  timedMessagesTTL: Int?,
+  longClick: () -> Unit,
+) {
+  Row(
+    Modifier.padding(top = if (hasText) 14.dp else 4.dp, bottom = if (hasText) 14.dp else 6.dp, start = 6.dp, end = 6.dp),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    if (file != null) {
+      val context = LocalContext.current
+      val filePath = remember(file.filePath, file.fileStatus) { getLoadedFilePath(context, file) }
+      var brokenAudio by rememberSaveable(file.filePath) { mutableStateOf(false) }
+      val audioPlaying = rememberSaveable(file.filePath) { mutableStateOf(false) }
+      val progress = rememberSaveable(file.filePath) { mutableStateOf(0) }
+      val duration = rememberSaveable(file.filePath) { mutableStateOf(providedDurationSec * 1000) }
+      val play = {
+        AudioPlayer.play(filePath, audioPlaying, progress, duration, true)
+        brokenAudio = !audioPlaying.value
+      }
+      val pause = {
+        AudioPlayer.pause(audioPlaying, progress)
+      }
+      val text = remember {
+        derivedStateOf {
+          val time = when {
+            audioPlaying.value || progress.value != 0 -> progress.value
+            else -> duration.value
+          }
+          durationText(time / 1000)
+        }
+      }
+      VoiceLayout(file, ci, text, audioPlaying, progress, duration, brokenAudio, sent, hasText, timedMessagesTTL, play, pause, longClick)
+    } else {
+      VoiceMsgIndicator(null, false, sent, hasText, null, null, false, {}, {}, longClick)
+      val metaReserve = if (edited)
+        "                     "
+      else
+        "                 "
+      Text(metaReserve)
+    }
+  }
+}
+
+@Composable
+private fun VoiceLayout(
+  file: CIFile,
+  ci: ChatItem,
+  text: State<String>,
+  audioPlaying: State<Boolean>,
+  progress: State<Int>,
+  duration: State<Int>,
+  brokenAudio: Boolean,
+  sent: Boolean,
+  hasText: Boolean,
+  timedMessagesTTL: Int?,
+  play: () -> Unit,
+  pause: () -> Unit,
+  longClick: () -> Unit
+) {
+  when {
+    hasText -> {
+      Spacer(Modifier.width(6.dp))
+      VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
+      DurationText(text, PaddingValues(start = 12.dp))
+    }
+    sent -> {
+      Row {
+        Row(verticalAlignment = Alignment.CenterVertically) {
+          Spacer(Modifier.height(56.dp))
+          DurationText(text, PaddingValues(end = 12.dp))
+        }
+        Column {
+          VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
+          Box(Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp)) {
+            CIMetaView(ci, timedMessagesTTL)
+          }
+        }
+      }
+    }
+    else -> {
+      Row {
+        Column {
+          VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
+          Box(Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp)) {
+            CIMetaView(ci, timedMessagesTTL)
+          }
+        }
+        Row(verticalAlignment = Alignment.CenterVertically) {
+          DurationText(text, PaddingValues(start = 12.dp))
+          Spacer(Modifier.height(56.dp))
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun DurationText(text: State<String>, padding: PaddingValues) {
+  val minWidth = with(LocalDensity.current) { 45.sp.toDp() }
+  Text(
+    text.value,
+    Modifier
+      .padding(padding)
+      .widthIn(min = minWidth),
+    color = HighOrLowlight,
+    fontSize = 16.sp,
+    maxLines = 1
+  )
+}
+
+@Composable
+private fun PlayPauseButton(
+  audioPlaying: Boolean,
+  sent: Boolean,
+  angle: Float,
+  strokeWidth: Float,
+  strokeColor: Color,
+  enabled: Boolean,
+  error: Boolean,
+  play: () -> Unit,
+  pause: () -> Unit,
+  longClick: () -> Unit
+) {
+  Surface(
+    Modifier.drawRingModifier(angle, strokeColor, strokeWidth),
+    color = if (sent) SentColorLight else ReceivedColorLight,
+    shape = MaterialTheme.shapes.small.copy(CornerSize(percent = 50))
+  ) {
+    Box(
+      Modifier
+        .defaultMinSize(minWidth = 56.dp, minHeight = 56.dp)
+        .combinedClickable(
+          onClick = { if (!audioPlaying) play() else pause() },
+          onLongClick = longClick
+        ),
+      contentAlignment = Alignment.Center
+    ) {
+      Icon(
+        imageVector = if (audioPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
+        contentDescription = null,
+        Modifier.size(36.dp),
+        tint = if (error) WarningOrange else if (!enabled) HighOrLowlight else MaterialTheme.colors.primary
+      )
+    }
+  }
+}
+
+@Composable
+private fun VoiceMsgIndicator(
+  file: CIFile?,
+  audioPlaying: Boolean,
+  sent: Boolean,
+  hasText: Boolean,
+  progress: State<Int>?,
+  duration: State<Int>?,
+  error: Boolean,
+  play: () -> Unit,
+  pause: () -> Unit,
+  longClick: () -> Unit
+) {
+  val strokeWidth = with(LocalDensity.current) { 3.dp.toPx() }
+  val strokeColor = MaterialTheme.colors.primary
+  if (file != null && file.loaded && progress != null && duration != null) {
+    val angle = 360f * (progress.value.toDouble() / duration.value).toFloat()
+    if (hasText) {
+      IconButton({ if (!audioPlaying) play() else pause() }, Modifier.size(56.dp).drawRingModifier(angle, strokeColor, strokeWidth)) {
+        Icon(
+          imageVector = if (audioPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
+          contentDescription = null,
+          Modifier.size(36.dp),
+          tint = MaterialTheme.colors.primary
+        )
+      }
+    } else {
+      PlayPauseButton(audioPlaying, sent, angle, strokeWidth, strokeColor, true, error, play, pause, longClick = longClick)
+    }
+  } else {
+    if (file?.fileStatus is CIFileStatus.RcvInvitation
+      || file?.fileStatus is CIFileStatus.RcvTransfer
+      || file?.fileStatus is CIFileStatus.RcvAccepted
+    ) {
+      Box(
+        Modifier
+          .size(56.dp)
+          .clip(RoundedCornerShape(4.dp)),
+        contentAlignment = Alignment.Center
+      ) {
+        ProgressIndicator()
+      }
+    } else {
+      PlayPauseButton(audioPlaying, sent, 0f, strokeWidth, strokeColor, false, false, {}, {}, longClick)
+    }
+  }
+}
+
+fun Modifier.drawRingModifier(angle: Float, color: Color, strokeWidth: Float) = drawWithCache {
+  val brush = Brush.linearGradient(
+    0f to Color.Transparent,
+    0f to color,
+    start = Offset(0f, 0f),
+    end = Offset(strokeWidth, strokeWidth),
+    tileMode = TileMode.Clamp
+  )
+  onDrawWithContent {
+    drawContent()
+    drawArc(
+      brush = brush,
+      startAngle = -90f,
+      sweepAngle = angle,
+      useCenter = false,
+      topLeft = Offset(strokeWidth / 2, strokeWidth / 2),
+      size = Size(size.width - strokeWidth, size.height - strokeWidth),
+      style = Stroke(width = strokeWidth, cap = StrokeCap.Square)
+    )
+  }
+}
+
+@Composable
+private fun ProgressIndicator() {
+  CircularProgressIndicator(
+    Modifier.size(32.dp),
+    color = if (isInDarkTheme()) FileDark else FileLight,
+    strokeWidth = 4.dp
+  )
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/ChatItemView.kt

@@ -1,6 +1,7 @@
 package chat.simplex.app.views.chat.item
 
-import android.content.*
+import android.Manifest
+import android.os.Build
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -21,125 +22,217 @@ import androidx.compose.ui.unit.dp
 import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.chat.ComposeContextItem
 import chat.simplex.app.views.chat.ComposeState
 import chat.simplex.app.views.helpers.*
+import com.google.accompanist.permissions.rememberPermissionState
 import kotlinx.datetime.Clock
 
+// TODO refactor so that FramedItemView can show all CIContent items if they're deleted (see Swift code)
+
 @Composable
 fun ChatItemView(
-  user: User,
   cInfo: ChatInfo,
   cItem: ChatItem,
   composeState: MutableState<ComposeState>,
-  cxt: Context,
-  uriHandler: UriHandler? = null,
   imageProvider: (() -> ImageGalleryProvider)? = null,
   showMember: Boolean = false,
-  chatModelIncognito: Boolean,
   useLinkPreviews: Boolean,
+  linkMode: SimplexLinkMode,
   deleteMessage: (Long, CIDeleteMode) -> Unit,
   receiveFile: (Long) -> Unit,
+  cancelFile: (Long) -> Unit,
   joinGroup: (Long) -> Unit,
   acceptCall: (Contact) -> Unit,
   scrollToItem: (Long) -> Unit,
+  acceptFeature: (Contact, ChatFeature, Int?) -> Unit
 ) {
   val context = LocalContext.current
+  val uriHandler = LocalUriHandler.current
   val sent = cItem.chatDir.sent
   val alignment = if (sent) Alignment.CenterEnd else Alignment.CenterStart
   val showMenu = remember { mutableStateOf(false) }
+  val revealed = remember { mutableStateOf(false) }
+  val fullDeleteAllowed = remember(cInfo) { cInfo.featureEnabled(ChatFeature.FullDelete) }
   val saveFileLauncher = rememberSaveFileLauncher(cxt = context, ciFile = cItem.file)
+  val onLinkLongClick = { _: String -> showMenu.value = true }
+  val live = composeState.value.liveMessage != null
+
   Box(
     modifier = Modifier
       .padding(bottom = 4.dp)
       .fillMaxWidth(),
     contentAlignment = alignment,
   ) {
+    val onClick = {
+      when (cItem.meta.itemStatus) {
+        is CIStatus.SndErrorAuth -> {
+          showMsgDeliveryErrorAlert(generalGetString(R.string.message_delivery_error_desc))
+        }
+        is CIStatus.SndError -> {
+          showMsgDeliveryErrorAlert(generalGetString(R.string.unknown_error) + ": ${cItem.meta.itemStatus.agentError}")
+        }
+        else -> {}
+      }
+    }
     Column(
       Modifier
         .clip(RoundedCornerShape(18.dp))
-        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
+        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = onClick),
     ) {
-      @Composable fun ContentItem() {
-        if (cItem.file == null && cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
-          EmojiItemView(cItem)
+      @Composable
+      fun framedItemView() {
+        FramedItemView(cInfo, cItem, uriHandler, imageProvider, showMember = showMember, linkMode = linkMode, showMenu, receiveFile, onLinkLongClick, scrollToItem)
+      }
+
+      fun deleteMessageQuestionText(): String {
+        return if (fullDeleteAllowed) {
+          generalGetString(R.string.delete_message_cannot_be_undone_warning)
         } else {
-          val onLinkLongClick = { _: String -> showMenu.value = true }
-          FramedItemView(cInfo, cItem, uriHandler, imageProvider, showMember = showMember, showMenu, receiveFile, onLinkLongClick, scrollToItem)
+          generalGetString(R.string.delete_message_mark_deleted_warning)
         }
+      }
+
+      fun moderateMessageQuestionText(): String {
+        return if (fullDeleteAllowed) {
+          generalGetString(R.string.moderate_message_will_be_deleted_warning)
+        } else {
+          generalGetString(R.string.moderate_message_will_be_marked_warning)
+        }
+      }
+
+      @Composable
+      fun MsgContentItemDropdownMenu() {
         DropdownMenu(
           expanded = showMenu.value,
           onDismissRequest = { showMenu.value = false },
           Modifier.width(220.dp)
         ) {
-          ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
-            if (composeState.value.editing) {
-              composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
-            } else {
-              composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
-            }
-            showMenu.value = false
-          })
+          if (cItem.meta.itemDeleted == null && !live) {
+            ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
+              if (composeState.value.editing) {
+                composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
+              } else {
+                composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
+              }
+              showMenu.value = false
+            })
+          }
           ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
             val filePath = getLoadedFilePath(SimplexApp.context, cItem.file)
             when {
-              filePath != null -> shareFile(cxt, cItem.text, filePath)
-              else -> shareText(cxt, cItem.content.text)
+              filePath != null -> shareFile(context, cItem.text, filePath)
+              else -> shareText(context, cItem.content.text)
             }
             showMenu.value = false
           })
           ItemAction(stringResource(R.string.copy_verb), Icons.Outlined.ContentCopy, onClick = {
-            copyText(cxt, cItem.content.text)
+            copyText(context, cItem.content.text)
             showMenu.value = false
           })
-          if (cItem.content.msgContent is MsgContent.MCImage || cItem.content.msgContent is MsgContent.MCFile) {
+          if (cItem.content.msgContent is MsgContent.MCImage || cItem.content.msgContent is MsgContent.MCVideo || cItem.content.msgContent is MsgContent.MCFile || cItem.content.msgContent is MsgContent.MCVoice) {
             val filePath = getLoadedFilePath(context, cItem.file)
             if (filePath != null) {
+              val writePermissionState = rememberPermissionState(permission = Manifest.permission.WRITE_EXTERNAL_STORAGE)
               ItemAction(stringResource(R.string.save_verb), Icons.Outlined.SaveAlt, onClick = {
                 when (cItem.content.msgContent) {
-                  is MsgContent.MCImage -> saveImage(context, cItem.file)
-                  is MsgContent.MCFile -> saveFileLauncher.launch(cItem.file?.fileName)
+                  is MsgContent.MCImage -> {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R || writePermissionState.hasPermission) {
+                      saveImage(context, cItem.file)
+                    } else {
+                      writePermissionState.launchPermissionRequest()
+                    }
+                  }
+                  is MsgContent.MCFile, is MsgContent.MCVoice, is MsgContent.MCVideo -> saveFileLauncher.launch(cItem.file?.fileName)
                   else -> {}
                 }
                 showMenu.value = false
               })
             }
           }
-          if (cItem.meta.editable) {
+          if (cItem.meta.editable && cItem.content.msgContent !is MsgContent.MCVoice && !live) {
             ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
               composeState.value = ComposeState(editingItem = cItem, useLinkPreviews = useLinkPreviews)
               showMenu.value = false
             })
           }
-          ItemAction(
-            stringResource(R.string.delete_verb),
-            Icons.Outlined.Delete,
-            onClick = {
-              showMenu.value = false
-              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
-            },
-            color = Color.Red
-          )
+          if (cItem.meta.itemDeleted != null && revealed.value) {
+            ItemAction(
+              stringResource(R.string.hide_verb),
+              Icons.Outlined.VisibilityOff,
+              onClick = {
+                revealed.value = false
+                showMenu.value = false
+              }
+            )
+          }
+          if (cItem.meta.itemDeleted == null && cItem.file != null && cItem.file.cancellable) {
+            CancelFileItemAction(cItem.file.fileId, showMenu, cancelFile = cancelFile)
+          }
+          if (!(live && cItem.meta.isLive)) {
+            DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
+          }
+          val groupInfo = cItem.memberToModerate(cInfo)?.first
+          if (groupInfo != null) {
+            ModerateItemAction(cItem, questionText = moderateMessageQuestionText(), showMenu, deleteMessage)
+          }
         }
       }
 
-      @Composable fun DeletedItem() {
-        DeletedItemView(cItem, showMember = showMember)
+      @Composable
+      fun MarkedDeletedItemDropdownMenu() {
         DropdownMenu(
           expanded = showMenu.value,
           onDismissRequest = { showMenu.value = false },
           Modifier.width(220.dp)
         ) {
-          ItemAction(
-            stringResource(R.string.delete_verb),
-            Icons.Outlined.Delete,
-            onClick = {
-              showMenu.value = false
-              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
-            },
-            color = Color.Red
-          )
+          if (!cItem.isDeletedContent) {
+            ItemAction(
+              stringResource(R.string.reveal_verb),
+              Icons.Outlined.Visibility,
+              onClick = {
+                revealed.value = true
+                showMenu.value = false
+              }
+            )
+          }
+          DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
+        }
+      }
+
+      @Composable
+      fun ContentItem() {
+        val mc = cItem.content.msgContent
+        if (cItem.meta.itemDeleted != null && !revealed.value) {
+          MarkedDeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
+          MarkedDeletedItemDropdownMenu()
+        } else if (cItem.quotedItem == null && cItem.meta.itemDeleted == null && !cItem.meta.isLive) {
+          if (mc is MsgContent.MCText && isShortEmoji(cItem.content.text)) {
+            EmojiItemView(cItem, cInfo.timedMessagesTTL)
+            MsgContentItemDropdownMenu()
+          } else if (mc is MsgContent.MCVoice && cItem.content.text.isEmpty()) {
+            CIVoiceView(mc.duration, cItem.file, cItem.meta.itemEdited, cItem.chatDir.sent, hasText = false, cItem, cInfo.timedMessagesTTL, longClick = { onLinkLongClick("") })
+            MsgContentItemDropdownMenu()
+          } else {
+            framedItemView()
+            MsgContentItemDropdownMenu()
+          }
+        } else {
+          framedItemView()
+          MsgContentItemDropdownMenu()
+        }
+      }
+
+      @Composable fun DeletedItem() {
+        DeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
+        DropdownMenu(
+          expanded = showMenu.value,
+          onDismissRequest = { showMenu.value = false },
+          Modifier.width(220.dp)
+        ) {
+          DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
         }
       }
 
@@ -154,18 +247,85 @@ fun ChatItemView(
         is CIContent.RcvDeleted -> DeletedItem()
         is CIContent.SndCall -> CallItem(c.status, c.duration)
         is CIContent.RcvCall -> CallItem(c.status, c.duration)
-        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, showMember = showMember)
+        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
         is CIContent.RcvGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
         is CIContent.SndGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
         is CIContent.RcvGroupEventContent -> CIEventView(cItem)
         is CIContent.SndGroupEventContent -> CIEventView(cItem)
         is CIContent.RcvConnEventContent -> CIEventView(cItem)
         is CIContent.SndConnEventContent -> CIEventView(cItem)
+        is CIContent.RcvChatFeature -> CIChatFeatureView(cItem, c.feature, c.enabled.iconColor)
+        is CIContent.SndChatFeature -> CIChatFeatureView(cItem, c.feature, c.enabled.iconColor)
+        is CIContent.RcvChatPreference -> {
+          val ct = if (cInfo is ChatInfo.Direct) cInfo.contact else null
+          CIFeaturePreferenceView(cItem, ct, c.feature, c.allowed, acceptFeature)
+        }
+        is CIContent.SndChatPreference -> CIChatFeatureView(cItem, c.feature, HighOrLowlight, icon = c.feature.icon,)
+        is CIContent.RcvGroupFeature -> CIChatFeatureView(cItem, c.groupFeature, c.preference.enable.iconColor)
+        is CIContent.SndGroupFeature -> CIChatFeatureView(cItem, c.groupFeature, c.preference.enable.iconColor)
+        is CIContent.RcvChatFeatureRejected -> CIChatFeatureView(cItem, c.feature, Color.Red)
+        is CIContent.RcvGroupFeatureRejected -> CIChatFeatureView(cItem, c.groupFeature, Color.Red)
+        is CIContent.SndModerated -> MarkedDeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
+        is CIContent.RcvModerated -> MarkedDeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
+        is CIContent.InvalidJSON -> CIInvalidJSONView(c.json)
       }
     }
   }
 }
 
+@Composable
+fun CancelFileItemAction(
+  fileId: Long,
+  showMenu: MutableState<Boolean>,
+  cancelFile: (Long) -> Unit
+) {
+  ItemAction(
+    stringResource(R.string.cancel_verb),
+    Icons.Outlined.Close,
+    onClick = {
+      showMenu.value = false
+      cancelFileAlertDialog(fileId, cancelFile = cancelFile)
+    },
+    color = Color.Red
+  )
+}
+
+@Composable
+fun DeleteItemAction(
+  cItem: ChatItem,
+  showMenu: MutableState<Boolean>,
+  questionText: String,
+  deleteMessage: (Long, CIDeleteMode) -> Unit
+) {
+  ItemAction(
+    stringResource(R.string.delete_verb),
+    Icons.Outlined.Delete,
+    onClick = {
+      showMenu.value = false
+      deleteMessageAlertDialog(cItem, questionText, deleteMessage = deleteMessage)
+    },
+    color = Color.Red
+  )
+}
+
+@Composable
+fun ModerateItemAction(
+  cItem: ChatItem,
+  questionText: String,
+  showMenu: MutableState<Boolean>,
+  deleteMessage: (Long, CIDeleteMode) -> Unit
+) {
+  ItemAction(
+    stringResource(R.string.moderate_verb),
+    Icons.Outlined.Flag,
+    onClick = {
+      showMenu.value = false
+      moderateMessageAlertDialog(cItem, questionText, deleteMessage = deleteMessage)
+    },
+    color = Color.Red
+  )
+}
+
 @Composable
 fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Color = MaterialTheme.colors.onBackground) {
   DropdownMenuItem(onClick) {
@@ -183,10 +343,22 @@ fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Colo
   }
 }
 
-fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteMode) -> Unit) {
+fun cancelFileAlertDialog(fileId: Long, cancelFile: (Long) -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.cancel_file__question),
+    text = generalGetString(R.string.file_transfer_will_be_cancelled_warning),
+    confirmText = generalGetString(R.string.confirm_verb),
+    destructive = true,
+    onConfirm = {
+      cancelFile(fileId)
+    }
+  )
+}
+
+fun deleteMessageAlertDialog(chatItem: ChatItem, questionText: String, deleteMessage: (Long, CIDeleteMode) -> Unit) {
   AlertManager.shared.showAlertDialogButtons(
     title = generalGetString(R.string.delete_message__question),
-    text = generalGetString(R.string.delete_message_cannot_be_undone_warning),
+    text = questionText,
     buttons = {
       Row(
         Modifier
@@ -210,25 +382,44 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteM
   )
 }
 
+fun moderateMessageAlertDialog(chatItem: ChatItem, questionText: String, deleteMessage: (Long, CIDeleteMode) -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.delete_member_message__question),
+    text = questionText,
+    confirmText = generalGetString(R.string.delete_verb),
+    destructive = true,
+    onConfirm = {
+      deleteMessage(chatItem.id, CIDeleteMode.cidmBroadcast)
+    }
+  )
+}
+
+private fun showMsgDeliveryErrorAlert(description: String) {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.message_delivery_error_title),
+    text = description,
+  )
+}
+
 @Preview
 @Composable
 fun PreviewChatItemView() {
   SimpleXTheme {
     ChatItemView(
-      User.sampleData,
       ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
       ),
       useLinkPreviews = true,
+      linkMode = SimplexLinkMode.DESCRIPTION,
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      cxt = LocalContext.current,
-      chatModelIncognito = false,
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
       acceptCall = { _ -> },
       scrollToItem = {},
+      acceptFeature = { _, _, _ -> }
     )
   }
 }
@@ -238,18 +429,18 @@ fun PreviewChatItemView() {
 fun PreviewChatItemViewDeletedContent() {
   SimpleXTheme {
     ChatItemView(
-      User.sampleData,
       ChatInfo.Direct.sampleData,
       ChatItem.getDeletedContentSampleData(),
       useLinkPreviews = true,
+      linkMode = SimplexLinkMode.DESCRIPTION,
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      cxt = LocalContext.current,
-      chatModelIncognito = false,
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
       acceptCall = { _ -> },
       scrollToItem = {},
+      acceptFeature = { _, _, _ -> }
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/DeletedItemView.kt

@@ -1,8 +1,7 @@
 package chat.simplex.app.views.chat.item
 
 import android.content.res.Configuration
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.runtime.Composable
@@ -18,10 +17,11 @@ import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
-fun DeletedItemView(ci: ChatItem, showMember: Boolean = false) {
+fun DeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean = false) {
+  val sent = ci.chatDir.sent
   Surface(
     shape = RoundedCornerShape(18.dp),
-    color = ReceivedColorLight,
+    color = if (sent) SentColorLight else ReceivedColorLight,
   ) {
     Row(
       Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
@@ -35,7 +35,7 @@ fun DeletedItemView(ci: ChatItem, showMember: Boolean = false) {
         style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
         modifier = Modifier.padding(end = 8.dp)
       )
-      CIMetaView(ci)
+      CIMetaView(ci, timedMessagesTTL)
     }
   }
 }
@@ -49,7 +49,8 @@ fun DeletedItemView(ci: ChatItem, showMember: Boolean = false) {
 fun PreviewDeletedItemView() {
   SimpleXTheme {
     DeletedItemView(
-      ChatItem.getDeletedContentSampleData()
+      ChatItem.getDeletedContentSampleData(),
+      null
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/EmojiItemView.kt

@@ -15,13 +15,13 @@ val largeEmojiFont: TextStyle = TextStyle(fontSize = 48.sp)
 val mediumEmojiFont: TextStyle = TextStyle(fontSize = 36.sp)
 
 @Composable
-fun EmojiItemView(chatItem: ChatItem) {
+fun EmojiItemView(chatItem: ChatItem, timedMessagesTTL: Int?) {
   Column(
     Modifier.padding(vertical = 8.dp, horizontal = 12.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
     EmojiText(chatItem.content.text)
-    CIMetaView(chatItem)
+    CIMetaView(chatItem, timedMessagesTTL)
   }
 }
 

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/FramedItemView.kt

@@ -5,7 +5,9 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.InsertDriveFile
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.Delete
+import androidx.compose.material.icons.outlined.Flag
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
@@ -13,19 +15,22 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.*
 import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.*
 import androidx.compose.ui.unit.*
 import androidx.compose.ui.util.fastMap
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.ChatItemLinkView
-import chat.simplex.app.views.helpers.base64ToBitmap
+import chat.simplex.app.views.helpers.*
 import kotlinx.datetime.Clock
+import kotlin.math.min
 
 val SentColorLight = Color(0x1E45B8FF)
 val ReceivedColorLight = Color(0x20B1B0B5)
@@ -39,12 +44,14 @@ fun FramedItemView(
   uriHandler: UriHandler? = null,
   imageProvider: (() -> ImageGalleryProvider)? = null,
   showMember: Boolean = false,
+  linkMode: SimplexLinkMode,
   showMenu: MutableState<Boolean>,
   receiveFile: (Long) -> Unit,
   onLinkLongClick: (link: String) -> Unit = {},
   scrollToItem: (Long) -> Unit = {},
 ) {
   val sent = ci.chatDir.sent
+  val chatTTL = chatInfo.timedMessagesTTL
 
   fun membership(): GroupMember? {
     return if (chatInfo is ChatInfo.Group) chatInfo.groupInfo.membership else null
@@ -58,7 +65,38 @@ fun FramedItemView(
     ) {
       MarkdownText(
         qi.text, qi.formattedText, sender = qi.sender(membership()), senderBold = true, maxLines = 3,
-        style = TextStyle(fontSize = 15.sp, color = MaterialTheme.colors.onSurface)
+        style = TextStyle(fontSize = 15.sp, color = MaterialTheme.colors.onSurface),
+        linkMode = linkMode
+      )
+    }
+  }
+
+  @Composable
+  fun FramedItemHeader(caption: String, italic: Boolean, icon: ImageVector? = null) {
+    Row(
+      Modifier
+        .background(if (sent) SentQuoteColorLight else ReceivedQuoteColorLight)
+        .fillMaxWidth()
+        .padding(start = 8.dp, top = 6.dp, end = 12.dp, bottom = if (ci.quotedItem == null) 6.dp else 0.dp),
+      horizontalArrangement = Arrangement.spacedBy(4.dp),
+    ) {
+      if (icon != null) {
+        Icon(
+          icon,
+          caption,
+          Modifier.size(18.dp),
+          tint = if (isInDarkTheme()) FileDark else FileLight
+        )
+      }
+      Text(
+        buildAnnotatedString {
+          withStyle(SpanStyle(fontSize = 12.sp, fontStyle = if (italic) FontStyle.Italic else FontStyle.Normal, color = HighOrLowlight)) {
+            append(caption)
+          }
+        },
+        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis
       )
     }
   }
@@ -87,13 +125,25 @@ fun FramedItemView(
             modifier = Modifier.size(68.dp).clipToBounds()
           )
         }
-        is MsgContent.MCFile -> {
+        is MsgContent.MCVideo -> {
+          Box(Modifier.fillMaxWidth().weight(1f)) {
+            ciQuotedMsgView(qi)
+          }
+          val imageBitmap = base64ToBitmap(qi.content.image).asImageBitmap()
+          Image(
+            imageBitmap,
+            contentDescription = stringResource(R.string.video_descr),
+            contentScale = ContentScale.Crop,
+            modifier = Modifier.size(68.dp).clipToBounds()
+          )
+        }
+        is MsgContent.MCFile, is MsgContent.MCVoice -> {
           Box(Modifier.fillMaxWidth().weight(1f)) {
             ciQuotedMsgView(qi)
           }
           Icon(
-            Icons.Filled.InsertDriveFile,
-            stringResource(R.string.icon_descr_file),
+            if (qi.content is MsgContent.MCFile) Icons.Filled.InsertDriveFile else Icons.Filled.Mic,
+            if (qi.content is MsgContent.MCFile) stringResource(R.string.icon_descr_file) else stringResource(R.string.voice_message),
             Modifier
               .padding(top = 6.dp, end = 4.dp)
               .size(22.dp),
@@ -105,7 +155,17 @@ fun FramedItemView(
     }
   }
 
-  val transparentBackground = ci.content.msgContent is MsgContent.MCImage && ci.content.text.isEmpty() && ci.quotedItem == null
+  @Composable
+  fun ciFileView(ci: ChatItem, text: String) {
+    CIFileView(ci.file, ci.meta.itemEdited, receiveFile)
+    if (text != "" || ci.meta.isLive) {
+      CIMarkdownText(ci, chatTTL, showMember, linkMode = linkMode, uriHandler)
+    }
+  }
+
+  val transparentBackground = (ci.content.msgContent is MsgContent.MCImage || ci.content.msgContent is MsgContent.MCVideo) &&
+      !ci.meta.isLive && ci.content.text.isEmpty() && ci.quotedItem == null
+
   Box(Modifier
     .clip(RoundedCornerShape(18.dp))
     .background(
@@ -119,8 +179,17 @@ fun FramedItemView(
     Box(contentAlignment = Alignment.BottomEnd) {
       Column(Modifier.width(IntrinsicSize.Max)) {
         PriorityLayout(Modifier, CHAT_IMAGE_LAYOUT_ID) {
+          if (ci.meta.itemDeleted != null) {
+            if (ci.meta.itemDeleted is CIDeleted.Moderated) {
+              FramedItemHeader(String.format(stringResource(R.string.moderated_item_description), ci.meta.itemDeleted.byGroupMember.chatViewName), true, Icons.Outlined.Flag)
+            } else {
+              FramedItemHeader(stringResource(R.string.marked_deleted_description), true, Icons.Outlined.Delete)
+            }
+          } else if (ci.meta.isLive) {
+            FramedItemHeader(stringResource(R.string.live), false)
+          }
           ci.quotedItem?.let { ciQuoteView(it) }
-          if (ci.file == null && ci.formattedText == null && isShortEmoji(ci.content.text)) {
+          if (ci.file == null && ci.formattedText == null && !ci.meta.isLive && isShortEmoji(ci.content.text)) {
             Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
               Column(
                 Modifier
@@ -136,29 +205,44 @@ fun FramedItemView(
             when (val mc = ci.content.msgContent) {
               is MsgContent.MCImage -> {
                 CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, receiveFile)
-                if (mc.text == "") {
+                if (mc.text == "" && !ci.meta.isLive) {
                   metaColor = Color.White
                 } else {
-                  CIMarkdownText(ci, showMember, uriHandler)
+                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler)
                 }
               }
-              is MsgContent.MCFile -> {
-                CIFileView(ci.file, ci.meta.itemEdited, receiveFile)
+              is MsgContent.MCVideo -> {
+                CIVideoView(image = mc.image, mc.duration, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, receiveFile)
+                if (mc.text == "" && !ci.meta.isLive) {
+                  metaColor = Color.White
+                } else {
+                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler)
+                }
+              }
+              is MsgContent.MCVoice -> {
+                CIVoiceView(mc.duration, ci.file, ci.meta.itemEdited, ci.chatDir.sent, hasText = true, ci, timedMessagesTTL = chatTTL, longClick = { onLinkLongClick("") })
                 if (mc.text != "") {
-                  CIMarkdownText(ci, showMember, uriHandler)
+                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler)
                 }
               }
+              is MsgContent.MCFile -> ciFileView(ci, mc.text)
+              is MsgContent.MCUnknown ->
+                if (ci.file == null) {
+                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
+                } else {
+                  ciFileView(ci, mc.text)
+                }
               is MsgContent.MCLink -> {
                 ChatItemLinkView(mc.preview)
-                CIMarkdownText(ci, showMember, uriHandler, onLinkLongClick)
+                CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
               }
-              else -> CIMarkdownText(ci, showMember, uriHandler, onLinkLongClick)
+              else -> CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
             }
           }
         }
       }
       Box(Modifier.padding(bottom = 6.dp, end = 12.dp)) {
-        CIMetaView(ci, metaColor)
+        CIMetaView(ci, chatTTL, metaColor)
       }
     }
   }
@@ -167,20 +251,29 @@ fun FramedItemView(
 @Composable
 fun CIMarkdownText(
   ci: ChatItem,
+  chatTTL: Int?,
   showMember: Boolean,
+  linkMode: SimplexLinkMode,
   uriHandler: UriHandler?,
   onLinkLongClick: (link: String) -> Unit = {}
 ) {
   Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
+    val text = if (ci.meta.isLive) ci.content.msgContent?.text ?: ci.text else ci.text
     MarkdownText(
-      ci.content.text, ci.formattedText, if (showMember) ci.memberDisplayName else null,
-      metaText = ci.timestampText, edited = ci.meta.itemEdited,
+      text, if (text.isEmpty()) emptyList() else ci.formattedText, if (showMember) ci.memberDisplayName else null,
+      meta = ci.meta, chatTTL = chatTTL, linkMode = linkMode,
       uriHandler = uriHandler, senderBold = true, onLinkLongClick = onLinkLongClick
     )
   }
 }
 
 const val CHAT_IMAGE_LAYOUT_ID = "chatImage"
+/**
+ * Equal to [androidx.compose.ui.unit.Constraints.MaxFocusMask], which is 0x3FFFF - 1
+ * Other values make a crash `java.lang.IllegalArgumentException: Can't represent a width of 123456 and height of 9909 in Constraints`
+ * See [androidx.compose.ui.unit.Constraints.createConstraints]
+ * */
+const val MAX_SAFE_WIDTH = 0x3FFFF - 1
 
 @Composable
 fun PriorityLayout(
@@ -188,6 +281,17 @@ fun PriorityLayout(
   priorityLayoutId: String,
   content: @Composable () -> Unit
 ) {
+  /**
+  * Limiting max value for height + width in order to not crash the app, see [androidx.compose.ui.unit.Constraints.createConstraints]
+  * */
+  fun maxSafeHeight(width: Int) = when { // width bits + height bits should be <= 31
+    width < 0x1FFF /*MaxNonFocusMask*/ -> 0x3FFFF - 1 /* MaxFocusMask */ // 13 bits width + 18 bits height
+    width < 0x7FFF /*MinNonFocusMask*/ -> 0xFFFF - 1 /* MinFocusMask */ // 15 bits width + 16 bits height
+    width < 0xFFFF /*MinFocusMask*/ -> 0x7FFF - 1 /* MinFocusMask */ // 16 bits width + 15 bits height
+    width < 0x3FFFF /*MaxFocusMask*/ -> 0x1FFF - 1 /* MaxNonFocusMask */ // 18 bits width + 13 bits height
+    else -> 0x1FFF // shouldn't happen since width is limited already
+  }
+
   Layout(
     content = content,
     modifier = modifier
@@ -199,9 +303,11 @@ fun PriorityLayout(
       if (it.layoutId == priorityLayoutId)
         imagePlaceable!!
       else
-        it.measure(constraints.copy(maxWidth = imagePlaceable?.width ?: constraints.maxWidth)) }
-    // Limit width for every other element to width of important element and height for a sum of all elements
-    layout(imagePlaceable?.measuredWidth ?: placeables.maxOf { it.width }, placeables.sumOf { it.height }) {
+        it.measure(constraints.copy(maxWidth = imagePlaceable?.width ?: min(MAX_SAFE_WIDTH, constraints.maxWidth))) }
+    // Limit width for every other element to width of important element and height for a sum of all elements.
+    val width = imagePlaceable?.measuredWidth ?: min(MAX_SAFE_WIDTH, placeables.maxOf { it.width })
+    val height = minOf(maxSafeHeight(width), placeables.sumOf { it.height })
+    layout(width, height) {
       var y = 0
       placeables.forEach {
         it.place(0, y)
@@ -225,6 +331,7 @@ fun PreviewTextItemViewSnd(@PreviewParameter(EditedProvider::class) edited: Bool
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello", itemEdited = edited,
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -241,6 +348,7 @@ fun PreviewTextItemViewRcv(@PreviewParameter(EditedProvider::class) edited: Bool
       ChatItem.getSampleData(
         1, CIDirection.DirectRcv(), Clock.System.now(), "hello", itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -261,6 +369,7 @@ fun PreviewTextItemViewLong(@PreviewParameter(EditedProvider::class) edited: Boo
         "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -282,6 +391,7 @@ fun PreviewTextItemViewQuote(@PreviewParameter(EditedProvider::class) edited: Bo
         quotedItem = CIQuote.getSample(1, Clock.System.now(), "hi", chatDir = CIDirection.DirectRcv()),
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -303,6 +413,7 @@ fun PreviewTextItemViewEmoji(@PreviewParameter(EditedProvider::class) edited: Bo
         quotedItem = CIQuote.getSample(1, Clock.System.now(), "Lorem ipsum dolor sit amet", chatDir = CIDirection.DirectRcv()),
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -331,6 +442,7 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -359,6 +471,7 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -386,6 +499,7 @@ fun PreviewQuoteWithLongTextAndFile(@PreviewParameter(EditedProvider::class) edi
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/ImageFullScreenView.kt

@@ -3,20 +3,28 @@ package chat.simplex.app.views.chat.item
 import android.graphics.Bitmap
 import android.net.Uri
 import android.os.Build
+import android.view.View
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.interaction.MutableInteractionSource
 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.*
 import androidx.compose.ui.graphics.painter.BitmapPainter
 import androidx.compose.ui.input.pointer.*
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.*
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.view.isVisible
 import chat.simplex.app.R
+import chat.simplex.app.views.chat.ProviderMedia
 import chat.simplex.app.views.helpers.*
 import coil.ImageLoader
 import coil.compose.rememberAsyncImagePainter
@@ -25,13 +33,16 @@ import coil.decode.ImageDecoderDecoder
 import coil.request.ImageRequest
 import coil.size.Size
 import com.google.accompanist.pager.*
+import com.google.android.exoplayer2.ui.AspectRatioFrameLayout
+import com.google.android.exoplayer2.ui.StyledPlayerView
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
 import kotlin.math.absoluteValue
 
 interface ImageGalleryProvider {
   val initialIndex: Int
-  val totalImagesSize: MutableState<Int>
-  fun getImage(index: Int): Pair<Bitmap, Uri>?
+  val totalMediaSize: MutableState<Int>
+  fun getMedia(index: Int): ProviderMedia?
   fun currentPageChanged(index: Int)
   fun scrollToStart()
   fun onDismiss(index: Int)
@@ -47,13 +58,17 @@ fun ImageFullScreenView(imageProvider: () -> ImageGalleryProvider, close: () ->
   // Pager doesn't ask previous page at initialization step who knows why. By not doing this, prev page is not checked and can be blank,
   // which makes this blank page visible for a moment. Prevent it by doing the check ourselves
   LaunchedEffect(Unit) {
-    if (provider.getImage(provider.initialIndex - 1) == null) {
+    if (provider.getMedia(provider.initialIndex - 1) == null) {
       provider.scrollToStart()
       pagerState.scrollToPage(0)
     }
   }
   val scope = rememberCoroutineScope()
-  HorizontalPager(count = remember { provider.totalImagesSize }.value, state = pagerState) { index ->
+  val playersToRelease = rememberSaveable { mutableSetOf<Uri>() }
+  DisposableEffectOnGone(
+    whenGone = { playersToRelease.forEach { VideoPlayer.release(it, true, true) } }
+  )
+  HorizontalPager(count = remember { provider.totalMediaSize }.value, state = pagerState) { index ->
     Column(
       Modifier
         .fillMaxSize()
@@ -73,20 +88,21 @@ fun ImageFullScreenView(imageProvider: () -> ImageGalleryProvider, close: () ->
         if (settledCurrentPage != provider.initialIndex)
           provider.currentPageChanged(index)
       }
-      val image = provider.getImage(index)
-      if (image == null) {
+      val media = provider.getMedia(index)
+      if (media == null) {
         // No such image. Let's shrink total pages size or scroll to start of the list of pages to remove blank page automatically
-        scope.launch {
-          when (settledCurrentPage) {
-            index - 1 -> provider.totalImagesSize.value = settledCurrentPage + 1
-            index + 1 -> {
-              provider.scrollToStart()
-              pagerState.scrollToPage(0)
+        SideEffect {
+          scope.launch {
+            when (settledCurrentPage) {
+              index - 1 -> provider.totalMediaSize.value = settledCurrentPage + 1
+              index + 1 -> {
+                provider.scrollToStart()
+                pagerState.scrollToPage(0)
+              }
             }
           }
         }
       } else {
-        val (imageBitmap: Bitmap, uri: Uri) = image
         var scale by remember { mutableStateOf(1f) }
         var translationX by remember { mutableStateOf(0f) }
         var translationY by remember { mutableStateOf(0f) }
@@ -97,54 +113,106 @@ fun ImageFullScreenView(imageProvider: () -> ImageGalleryProvider, close: () ->
           translationX = 0f
           translationY = 0f
         }
-        // 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())
-            }
+        val modifier = Modifier
+          .onGloballyPositioned {
+            viewWidth = it.size.width
           }
-          .build()
-        Image(
-          rememberAsyncImagePainter(
-            ImageRequest.Builder(LocalContext.current).data(data = uri).size(Size.ORIGINAL).build(),
-            placeholder = BitmapPainter(imageBitmap.asImageBitmap()), // show original image while it's still loading by coil
-            imageLoader = imageLoader
-          ),
-          contentDescription = stringResource(R.string.image_descr),
-          contentScale = ContentScale.Fit,
-          modifier = Modifier
-            .onGloballyPositioned {
-              viewWidth = it.size.width
-            }
-            .graphicsLayer(
-              scaleX = scale,
-              scaleY = scale,
-              translationX = translationX,
-              translationY = translationY,
-            )
-            .pointerInput(Unit) {
-              detectTransformGestures(
-                { allowTranslate },
-                onGesture = { _, pan, gestureZoom, _ ->
-                  scale = (scale * gestureZoom).coerceIn(1f, 20f)
-                  allowTranslate = viewWidth * (scale - 1f) - ((translationX + pan.x * scale).absoluteValue * 2) > 0
-                  if (scale > 1 && allowTranslate) {
-                    translationX += pan.x * scale
-                    translationY += pan.y * scale
-                  } else if (allowTranslate) {
-                    translationX = 0f
-                    translationY = 0f
-                  }
+          .graphicsLayer(
+            scaleX = scale,
+            scaleY = scale,
+            translationX = translationX,
+            translationY = translationY,
+          )
+          .pointerInput(Unit) {
+            detectTransformGestures(
+              { allowTranslate },
+              onGesture = { _, pan, gestureZoom, _ ->
+                scale = (scale * gestureZoom).coerceIn(1f, 20f)
+                allowTranslate = viewWidth * (scale - 1f) - ((translationX + pan.x * scale).absoluteValue * 2) > 0
+                if (scale > 1 && allowTranslate) {
+                  translationX += pan.x * scale
+                  translationY += pan.y * scale
+                } else if (allowTranslate) {
+                  translationX = 0f
+                  translationY = 0f
                 }
-              )
+              }
+            )
+          }
+          .fillMaxSize()
+        if (media is ProviderMedia.Image) {
+          val (uri: Uri, imageBitmap: Bitmap) = media
+          // 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())
+              }
             }
-            .fillMaxSize(),
-        )
+            .build()
+          Image(
+            rememberAsyncImagePainter(
+              ImageRequest.Builder(LocalContext.current).data(data = uri).size(Size.ORIGINAL).build(),
+              placeholder = BitmapPainter(imageBitmap.asImageBitmap()), // show original image while it's still loading by coil
+              imageLoader = imageLoader
+            ),
+            contentDescription = stringResource(R.string.image_descr),
+            contentScale = ContentScale.Fit,
+            modifier = modifier,
+          )
+        } else if (media is ProviderMedia.Video) {
+          val preview = remember(media.uri.path) { base64ToBitmap(media.preview) }
+          VideoView(modifier, media.uri, preview, index == settledCurrentPage)
+          DisposableEffect(Unit) {
+            onDispose { playersToRelease.add(media.uri) }
+          }
+        }
       }
     }
   }
 }
+
+@Composable
+private fun VideoView(modifier: Modifier, uri: Uri, defaultPreview: Bitmap, currentPage: Boolean) {
+  val context = LocalContext.current
+  val player = remember(uri) { VideoPlayer.getOrCreate(uri, true, defaultPreview, 0L, true, context) }
+  val isCurrentPage = rememberUpdatedState(currentPage)
+  val play = {
+    player.play(true)
+  }
+  val stop = {
+    player.stop()
+  }
+  LaunchedEffect(Unit) {
+    player.enableSound(true)
+    snapshotFlow { isCurrentPage.value }
+      .distinctUntilChanged()
+      .collect { if (it) play() else stop() }
+  }
+
+  Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+    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
+    )
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/IntegrityErrorItemView.kt

@@ -22,7 +22,7 @@ import chat.simplex.app.views.helpers.AlertManager
 import chat.simplex.app.views.helpers.generalGetString
 
 @Composable
-fun IntegrityErrorItemView(ci: ChatItem, showMember: Boolean = false) {
+fun IntegrityErrorItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean = false) {
   Surface(
     Modifier.clickable(onClick = {
       AlertManager.shared.showAlertMsg(
@@ -45,7 +45,7 @@ fun IntegrityErrorItemView(ci: ChatItem, showMember: Boolean = false) {
         style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
         modifier = Modifier.padding(end = 8.dp)
       )
-      CIMetaView(ci)
+      CIMetaView(ci, timedMessagesTTL)
     }
   }
 }
@@ -59,7 +59,8 @@ fun IntegrityErrorItemView(ci: ChatItem, showMember: Boolean = false) {
 fun IntegrityErrorItemViewPreview() {
   SimpleXTheme {
     IntegrityErrorItemView(
-      ChatItem.getDeletedContentSampleData()
+      ChatItem.getDeletedContentSampleData(),
+      null
     )
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/MarkedDeletedItemView.kt

@@ -0,0 +1,72 @@
+package chat.simplex.app.views.chat.item
+
+import android.content.res.Configuration
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.CIDeleted
+import chat.simplex.app.model.ChatItem
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.generalGetString
+
+@Composable
+fun MarkedDeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean = false) {
+  Surface(
+    shape = RoundedCornerShape(18.dp),
+    color = if (ci.chatDir.sent) SentColorLight else ReceivedColorLight,
+  ) {
+    Row(
+      Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Box(Modifier.weight(1f, false)) {
+        if (ci.meta.itemDeleted is CIDeleted.Moderated) {
+          MarkedDeletedText(String.format(generalGetString(R.string.moderated_item_description), ci.meta.itemDeleted.byGroupMember.chatViewName))
+        } else {
+          MarkedDeletedText(generalGetString(R.string.marked_deleted_description))
+        }
+      }
+      CIMetaView(ci, timedMessagesTTL)
+    }
+  }
+}
+
+@Composable
+private fun MarkedDeletedText(text: String) {
+  Text(
+    buildAnnotatedString {
+      // appendSender(this, if (showMember) ci.memberDisplayName else null, true) // TODO font size
+      withStyle(SpanStyle(fontSize = 12.sp, fontStyle = FontStyle.Italic, color = HighOrLowlight)) { append(text) }
+    },
+    style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
+    modifier = Modifier.padding(end = 8.dp),
+    maxLines = 1,
+    overflow = TextOverflow.Ellipsis,
+  )
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewMarkedDeletedItemView() {
+  SimpleXTheme {
+    DeletedItemView(
+      ChatItem.getSampleData(itemDeleted = CIDeleted.Deleted()),
+      null
+    )
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/chat/item/TextItemView.kt

@@ -1,20 +1,30 @@
 package chat.simplex.app.views.chat.item
 
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.util.Log
+import androidx.annotation.IntRange
 import androidx.compose.foundation.text.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.*
 import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.*
 import androidx.core.text.BidiFormatter
+import chat.simplex.app.TAG
 import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.views.helpers.detectGesture
+import kotlinx.coroutines.*
 
 val reserveTimestampStyle = SpanStyle(color = Color.Transparent)
 val boldFont = SpanStyle(fontWeight = FontWeight.Medium)
@@ -36,42 +46,101 @@ fun appendSender(b: AnnotatedString.Builder, sender: String?, senderBold: Boolea
   }
 }
 
+private val noTyping: AnnotatedString = AnnotatedString("   ")
+
+private val typingIndicators: List<AnnotatedString> = listOf(
+  typing(FontWeight.Black) + typing() + typing(),
+  typing(FontWeight.Bold) + typing(FontWeight.Black) + typing(),
+  typing() + typing(FontWeight.Bold) + typing(FontWeight.Black),
+  typing() + typing() + typing(FontWeight.Bold)
+)
+
+
+private fun typingIndicator(recent: Boolean, @IntRange (from = 0, to = 4) typingIdx: Int): AnnotatedString = buildAnnotatedString {
+  pushStyle(SpanStyle(color = HighOrLowlight, fontFamily = FontFamily.Monospace, letterSpacing = (-1).sp))
+  append(if (recent) typingIndicators[typingIdx] else noTyping)
+}
+
+private fun typing(w: FontWeight = FontWeight.Light): AnnotatedString =
+  AnnotatedString(".", SpanStyle(fontWeight = w))
+
 @Composable
 fun MarkdownText (
-  text: String,
+  text: CharSequence,
   formattedText: List<FormattedText>? = null,
   sender: String? = null,
-  metaText: String? = null,
-  edited: Boolean = false,
+  meta: CIMeta? = null,
+  chatTTL: Int? = null,
   style: TextStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onSurface, lineHeight = 22.sp),
   maxLines: Int = Int.MAX_VALUE,
   overflow: TextOverflow = TextOverflow.Clip,
   uriHandler: UriHandler? = null,
   senderBold: Boolean = false,
   modifier: Modifier = Modifier,
+  linkMode: SimplexLinkMode,
+  inlineContent: Map<String, InlineTextContent>? = null,
   onLinkLongClick: (link: String) -> Unit = {}
 ) {
   val textLayoutDirection = remember (text) {
     if (BidiFormatter.getInstance().isRtl(text.subSequence(0, kotlin.math.min(50, text.length)))) LayoutDirection.Rtl else LayoutDirection.Ltr
   }
-  val reserve = when {
-    textLayoutDirection != LocalLayoutDirection.current && metaText != null -> "\n"
-    edited -> "        "
-    else -> "    "
+  val reserve = if (textLayoutDirection != LocalLayoutDirection.current && meta != null) {
+    "\n"
+  } else if (meta != null) {
+    reserveSpaceForMeta(meta, chatTTL)
+  } else {
+    "    "
   }
+  val scope = rememberCoroutineScope()
   CompositionLocalProvider(
     LocalLayoutDirection provides if (textLayoutDirection != LocalLayoutDirection.current)
       if (LocalLayoutDirection.current == LayoutDirection.Ltr) LayoutDirection.Rtl else LayoutDirection.Ltr
     else
       LocalLayoutDirection.current
   ) {
+    var timer: Job? by remember { mutableStateOf(null) }
+    var typingIdx by rememberSaveable { mutableStateOf(0) }
+    fun stopTyping() {
+      timer?.cancel()
+      timer = null
+    }
+    fun switchTyping() {
+      if (meta != null && meta.isLive && meta.recent) {
+        timer = timer ?: scope.launch {
+          while (isActive) {
+            typingIdx = (typingIdx + 1) % typingIndicators.size
+            delay(250)
+          }
+        }
+      } else {
+        stopTyping()
+      }
+    }
+    if (meta?.isLive == true) {
+      val activity = LocalContext.current as Activity
+      LaunchedEffect(meta.recent, meta.isLive) {
+        switchTyping()
+      }
+      DisposableEffect(Unit) {
+        val orientation = activity.resources.configuration.orientation
+        onDispose {
+          if (orientation == activity.resources.configuration.orientation) {
+            stopTyping()
+          }
+        }
+      }
+    }
     if (formattedText == null) {
       val annotatedText = buildAnnotatedString {
         appendSender(this, sender, senderBold)
-        append(text)
-        if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
+        if (text is String) append(text)
+        else if (text is AnnotatedString) append(text)
+        if (meta?.isLive == true) {
+          append(typingIndicator(meta.recent, typingIdx))
+        }
+        if (meta != null) withStyle(reserveTimestampStyle) { append(reserve) }
       }
-      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
+      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow, inlineContent = inlineContent ?: mapOf())
     } else {
       var hasLinks = false
       val annotatedText = buildAnnotatedString {
@@ -79,22 +148,29 @@ fun MarkdownText (
         for (ft in formattedText) {
           if (ft.format == null) append(ft.text)
           else {
-            val link = ft.link
+            val link = ft.link(linkMode)
             if (link != null) {
               hasLinks = true
-              val ftStyle = ft.format.style
+              val ftStyle = if (ft.format is Format.SimplexLink && !ft.format.trustedUri && linkMode == SimplexLinkMode.BROWSER) {
+                SpanStyle(color = Color.Red, textDecoration = TextDecoration.Underline)
+              } else {
+                ft.format.style
+              }
               withAnnotation(tag = "URL", annotation = link) {
-                withStyle(ftStyle) { append(ft.text) }
+                withStyle(ftStyle) { append(ft.viewText(linkMode)) }
               }
             } else {
               withStyle(ft.format.style) { append(ft.text) }
             }
           }
         }
+        if (meta?.isLive == true) {
+          append(typingIndicator(meta.recent, typingIdx))
+        }
         // With RTL language set globally links looks bad sometimes, better to add a new line to bo sure everything looks good
         /*if (metaText != null && hasLinks && LocalLayoutDirection.current == LayoutDirection.Rtl)
           withStyle(reserveTimestampStyle) { append("\n" + metaText) }
-        else */if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
+        else */if (meta != null) withStyle(reserveTimestampStyle) { append(reserve) }
       }
       if (hasLinks && uriHandler != null) {
         ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
@@ -104,7 +180,15 @@ fun MarkdownText (
           },
           onClick = { offset ->
             annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
-              .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
+              .firstOrNull()?.let { annotation ->
+                try {
+                  uriHandler.openUri(annotation.item)
+                } catch (e: ActivityNotFoundException) {
+                  // It can happen, for example, when you click on a text 0.00001 but don't have any app that can catch
+                  // `tel:` scheme in url installed on a device (no phone app or contacts, maybe)
+                  Log.e(TAG, "Open url: ${e.stackTraceToString()}")
+                }
+              }
           },
           shouldConsumeEvent = { offset ->
             annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset).any()

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ChatHelpView.kt

@@ -19,6 +19,8 @@ import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.helpers.annotatedStringResource
+import chat.simplex.app.views.helpers.openUriCatching
+import chat.simplex.app.views.usersettings.MarkdownHelpView
 import chat.simplex.app.views.usersettings.simplexTeamUri
 
 val bold = SpanStyle(fontWeight = FontWeight.Bold)
@@ -35,7 +37,7 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
     Text(
       annotatedStringResource(R.string.you_can_connect_to_simplex_chat_founder),
       modifier = Modifier.clickable(onClick = {
-        uriHandler.openUri(simplexTeamUri)
+        uriHandler.openUriCatching(simplexTeamUri)
       }),
       lineHeight = 22.sp
     )
@@ -76,6 +78,15 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
       Text(annotatedStringResource(R.string.desktop_scan_QR_code_from_app_via_scan_QR_code), lineHeight = 22.sp)
       Text(annotatedStringResource(R.string.mobile_tap_open_in_mobile_app_then_tap_connect_in_app), lineHeight = 22.sp)
     }
+
+    Column(
+      Modifier.padding(vertical = 24.dp),
+      horizontalAlignment = Alignment.Start,
+      verticalArrangement = Arrangement.spacedBy(10.dp)
+    ) {
+      Text(stringResource(R.string.markdown_in_messages), style = MaterialTheme.typography.h2)
+      MarkdownHelpView()
+    }
   }
 }
 

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ChatListNavLinkView.kt

@@ -11,15 +11,20 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.*
 import chat.simplex.app.views.chat.group.deleteGroupDialog
 import chat.simplex.app.views.chat.group.leaveGroupDialog
+import chat.simplex.app.views.chat.item.InvalidJSONView
 import chat.simplex.app.views.chat.item.ItemAction
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.newchat.ContactConnectionInfoView
@@ -33,22 +38,25 @@ fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
     chat.chatStats.unreadCount > 0 || chat.chatStats.unreadChat
   }
   val stopped = chatModel.chatRunning.value == false
+  val linkMode by remember { chatModel.controller.appPrefs.simplexLinkMode.state }
   LaunchedEffect(chat.id) {
     showMenu.value = false
     delay(500L)
   }
   when (chat.chatInfo) {
-    is ChatInfo.Direct ->
+    is ChatInfo.Direct -> {
+      val contactNetworkStatus = chatModel.contactNetworkStatus(chat.chatInfo.contact)
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped) },
+        chatLinkPreview = { ChatPreviewView(chat, chatModel.draft.value, chatModel.draftChatId.value, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, contactNetworkStatus, stopped, linkMode) },
         click = { directChatAction(chat.chatInfo, chatModel) },
         dropdownMenuItems = { ContactMenuItems(chat, chatModel, showMenu, showMarkRead) },
         showMenu,
         stopped
       )
+    }
     is ChatInfo.Group ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped) },
+        chatLinkPreview = { ChatPreviewView(chat, chatModel.draft.value, chatModel.draftChatId.value, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, null, stopped, linkMode) },
         click = { groupChatAction(chat.chatInfo.groupInfo, chatModel) },
         dropdownMenuItems = { GroupMenuItems(chat, chat.chatInfo.groupInfo, chatModel, showMenu, showMarkRead) },
         showMenu,
@@ -74,6 +82,18 @@ fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
         showMenu,
         stopped
       )
+    is ChatInfo.InvalidJSON ->
+      ChatListNavLinkLayout(
+        chatLinkPreview = {
+          InvalidDataView()
+        },
+        click = {
+          ModalManager.shared.showModal(true) { InvalidJSONView(chat.chatInfo.json) }
+        },
+        dropdownMenuItems = null,
+        showMenu,
+        stopped
+      )
   }
 }
 
@@ -281,7 +301,7 @@ fun ContactRequestMenuItems(chatInfo: ChatInfo.ContactRequest, chatModel: ChatMo
     if (chatModel.incognito.value) Icons.Filled.TheaterComedy else Icons.Outlined.Check,
     color = if (chatModel.incognito.value) Indigo else MaterialTheme.colors.onBackground,
     onClick = {
-      acceptContactRequest(chatInfo, chatModel)
+      acceptContactRequest(chatInfo.apiId, chatInfo, true, chatModel)
       showMenu.value = false
     }
   )
@@ -319,6 +339,29 @@ fun ContactConnectionMenuItems(chatInfo: ChatInfo.ContactConnection, chatModel:
   )
 }
 
+@Composable
+private fun InvalidDataView() {
+  Row {
+    ProfileImage(72.dp, null, Icons.Filled.AccountCircle, HighOrLowlight)
+    Column(
+      modifier = Modifier
+        .padding(horizontal = 8.dp)
+        .weight(1F)
+    ) {
+      Text(
+        stringResource(R.string.invalid_data),
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        style = MaterialTheme.typography.h3,
+        fontWeight = FontWeight.Bold,
+        color = Color.Red
+      )
+      val height = with(LocalDensity.current) { 46.sp.toDp() }
+      Spacer(Modifier.height(height))
+    }
+  }
+}
+
 fun markChatRead(c: Chat, chatModel: ChatModel) {
   var chat = c
   withApi {
@@ -366,16 +409,16 @@ fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel
     title = generalGetString(R.string.accept_connection_request__question),
     text = generalGetString(R.string.if_you_choose_to_reject_the_sender_will_not_be_notified),
     confirmText = if (chatModel.incognito.value) generalGetString(R.string.accept_contact_incognito_button) else generalGetString(R.string.accept_contact_button),
-    onConfirm = { acceptContactRequest(contactRequest, chatModel) },
+    onConfirm = { acceptContactRequest(contactRequest.apiId, contactRequest, true, chatModel) },
     dismissText = generalGetString(R.string.reject_contact_button),
     onDismiss = { rejectContactRequest(contactRequest, chatModel) }
   )
 }
 
-fun acceptContactRequest(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
+fun acceptContactRequest(apiId: Long, contactRequest: ChatInfo.ContactRequest?, isCurrentUser: Boolean, chatModel: ChatModel) {
   withApi {
-    val contact = chatModel.controller.apiAcceptContactRequest(contactRequest.apiId)
-    if (contact != null) {
+    val contact = chatModel.controller.apiAcceptContactRequest(apiId)
+    if (contact != null && isCurrentUser && contactRequest != null) {
       val chat = Chat(ChatInfo.Direct(contact), listOf())
       chatModel.replaceChat(contactRequest.id, chat)
     }
@@ -536,13 +579,11 @@ fun ChatListNavLinkLayout(
 ) {
   var modifier = Modifier.fillMaxWidth()
   if (!stopped) modifier = modifier.combinedClickable(onClick = click, onLongClick = { showMenu.value = true })
-  Surface(modifier) {
+  Box(modifier) {
     Row(
       modifier = Modifier
         .fillMaxWidth()
-        .padding(vertical = 8.dp)
-        .padding(start = 8.dp)
-        .padding(end = 12.dp),
+        .padding(start = 8.dp, top = 8.dp, end = 12.dp, bottom = 8.dp),
       verticalAlignment = Alignment.Top
     ) {
       chatLinkPreview()
@@ -586,9 +627,13 @@ fun PreviewChatListNavLinkDirect() {
             ),
             chatStats = Chat.ChatStats()
           ),
+          null,
+          null,
           false,
           null,
-          stopped = false
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},
@@ -623,9 +668,13 @@ fun PreviewChatListNavLinkGroup() {
             ),
             chatStats = Chat.ChatStats()
           ),
+          null,
+          null,
           false,
           null,
-          stopped = false
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ChatListView.kt

@@ -4,6 +4,7 @@ import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
+import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
@@ -13,41 +14,60 @@ 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.Path
+import androidx.compose.ui.graphics.*
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.capitalize
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.intl.Locale
-import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.*
+import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.newchat.NewChatSheet
+import chat.simplex.app.views.onboarding.WhatsNewView
+import chat.simplex.app.views.onboarding.shouldShowWhatsNew
 import chat.simplex.app.views.usersettings.SettingsView
 import chat.simplex.app.views.usersettings.simplexTeamUri
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 
 @Composable
 fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped: Boolean) {
-  val newChatSheetState by rememberSaveable(stateSaver = NewChatSheetState.saver()) { mutableStateOf(MutableStateFlow(NewChatSheetState.GONE)) }
+  val newChatSheetState by rememberSaveable(stateSaver = AnimatedViewState.saver()) { mutableStateOf(MutableStateFlow(AnimatedViewState.GONE)) }
+  val userPickerState by rememberSaveable(stateSaver = AnimatedViewState.saver()) { mutableStateOf(MutableStateFlow(AnimatedViewState.GONE)) }
   val showNewChatSheet = {
-    newChatSheetState.value = NewChatSheetState.VISIBLE
+    newChatSheetState.value = AnimatedViewState.VISIBLE
   }
   val hideNewChatSheet: (animated: Boolean) -> Unit = { animated ->
-    if (animated) newChatSheetState.value = NewChatSheetState.HIDING
-    else newChatSheetState.value = NewChatSheetState.GONE
+    if (animated) newChatSheetState.value = AnimatedViewState.HIDING
+    else newChatSheetState.value = AnimatedViewState.GONE
+  }
+  LaunchedEffect(Unit) {
+    if (shouldShowWhatsNew(chatModel)) {
+      delay(1000L)
+      ModalManager.shared.showCustomModal { close -> WhatsNewView(close = close) }
+    }
   }
   LaunchedEffect(chatModel.clearOverlays.value) {
     if (chatModel.clearOverlays.value && newChatSheetState.value.isVisible()) hideNewChatSheet(false)
   }
+  LaunchedEffect(chatModel.appOpenUrl.value) {
+    val url = chatModel.appOpenUrl.value
+    if (url != null) {
+      chatModel.appOpenUrl.value = null
+      connectIfOpenedViaUri(url, chatModel)
+    }
+  }
   var searchInList by rememberSaveable { mutableStateOf("") }
   val scaffoldState = rememberScaffoldState()
+  val scope = rememberCoroutineScope()
+  val switchingUsers = rememberSaveable { mutableStateOf(false) }
   Scaffold(
-    topBar = { ChatListToolbar(chatModel, scaffoldState.drawerState, stopped) { searchInList = it.trim() } },
+    topBar = { ChatListToolbar(chatModel, scaffoldState.drawerState, userPickerState, stopped) { searchInList = it.trim() } },
     scaffoldState = scaffoldState,
     drawerContent = { SettingsView(chatModel, setPerformLA) },
     floatingActionButton = {
@@ -80,7 +100,7 @@ fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped:
       ) {
         if (chatModel.chats.isNotEmpty()) {
           ChatList(chatModel, search = searchInList)
-        } else {
+        } else if (!switchingUsers.value) {
           Box(Modifier.fillMaxSize()) {
             if (!stopped && !newChatSheetState.collectAsState().value.isVisible()) {
               OnboardingButtons(showNewChatSheet)
@@ -94,6 +114,17 @@ fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped:
   if (searchInList.isEmpty()) {
     NewChatSheet(chatModel, newChatSheetState, stopped, hideNewChatSheet)
   }
+  UserPicker(chatModel, userPickerState, switchingUsers) {
+    scope.launch { if (scaffoldState.drawerState.isOpen) scaffoldState.drawerState.close() else scaffoldState.drawerState.open() }
+  }
+  if (switchingUsers.value) {
+    Box(
+      Modifier.fillMaxSize().clickable(enabled = false, onClick = {}),
+      contentAlignment = Alignment.Center
+    ) {
+      ProgressIndicator()
+    }
+  }
 }
 
 @Composable
@@ -101,7 +132,7 @@ private fun OnboardingButtons(openNewChatSheet: () -> Unit) {
   Column(Modifier.fillMaxSize().padding(DEFAULT_PADDING), horizontalAlignment = Alignment.End, verticalArrangement = Arrangement.Bottom) {
     val uriHandler = LocalUriHandler.current
     ConnectButton(generalGetString(R.string.chat_with_developers)) {
-      uriHandler.openUri(simplexTeamUri)
+      uriHandler.openUriCatching(simplexTeamUri)
     }
     Spacer(Modifier.height(DEFAULT_PADDING))
     ConnectButton(generalGetString(R.string.tap_to_start_new_chat), openNewChatSheet)
@@ -139,7 +170,7 @@ private fun ConnectButton(text: String, onClick: () -> Unit) {
 }
 
 @Composable
-private fun ChatListToolbar(chatModel: ChatModel, drawerState: DrawerState, stopped: Boolean, onSearchValueChanged: (String) -> Unit) {
+private fun ChatListToolbar(chatModel: ChatModel, drawerState: DrawerState, userPickerState: MutableStateFlow<AnimatedViewState>, stopped: Boolean, onSearchValueChanged: (String) -> Unit) {
   var showSearch by rememberSaveable { mutableStateOf(false) }
   val hideSearchOnBack = { onSearchValueChanged(""); showSearch = false }
   if (showSearch) {
@@ -172,10 +203,23 @@ private fun ChatListToolbar(chatModel: ChatModel, drawerState: DrawerState, stop
   val scope = rememberCoroutineScope()
   DefaultTopAppBar(
     navigationButton = {
-      if (showSearch)
+      if (showSearch) {
         NavigationButtonBack(hideSearchOnBack)
-      else
+      } else if (chatModel.users.isEmpty()) {
         NavigationButtonMenu { scope.launch { if (drawerState.isOpen) drawerState.close() else drawerState.open() } }
+      } else {
+        val users by remember { derivedStateOf { chatModel.users.filter { u -> u.user.activeUser || !u.user.hidden } } }
+        val allRead = users
+          .filter { u -> !u.user.activeUser && !u.user.hidden }
+          .all { u -> u.unreadCount == 0 }
+        UserProfileButton(chatModel.currentUser.value?.profile?.image, allRead) {
+          if (users.size == 1) {
+            scope.launch { drawerState.open() }
+          } else {
+            userPickerState.value = AnimatedViewState.VISIBLE
+          }
+        }
+      }
     },
     title = {
       Row(verticalAlignment = Alignment.CenterVertically) {
@@ -202,6 +246,47 @@ private fun ChatListToolbar(chatModel: ChatModel, drawerState: DrawerState, stop
   Divider(Modifier.padding(top = AppBarHeight))
 }
 
+@Composable
+fun UserProfileButton(image: String?, allRead: Boolean, onButtonClicked: () -> Unit) {
+  IconButton(onClick = onButtonClicked) {
+    Box {
+      ProfileImage(
+        image = image,
+        size = 37.dp
+      )
+      if (!allRead) {
+        unreadBadge()
+      }
+    }
+  }
+}
+
+@Composable
+private fun BoxScope.unreadBadge(text: String? = "") {
+  Text(
+    text ?: "",
+    color = MaterialTheme.colors.onPrimary,
+    fontSize = 6.sp,
+    modifier = Modifier
+      .background(MaterialTheme.colors.primary, shape = CircleShape)
+      .badgeLayout()
+      .padding(horizontal = 3.dp)
+      .padding(vertical = 1.dp)
+      .align(Alignment.TopEnd)
+  )
+}
+
+@Composable
+private fun ProgressIndicator() {
+  CircularProgressIndicator(
+    Modifier
+      .padding(horizontal = 2.dp)
+      .size(30.dp),
+    color = HighOrLowlight,
+    strokeWidth = 2.5.dp
+  )
+}
+
 private var lazyListState = 0 to 0
 
 @Composable

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ChatPreviewView.kt

@@ -4,17 +4,20 @@ import android.content.res.Configuration
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.text.InlineTextContent
+import androidx.compose.foundation.text.appendInlineContent
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Cancel
-import androidx.compose.material.icons.filled.NotificationsOff
+import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.*
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
@@ -22,11 +25,22 @@ import androidx.compose.ui.unit.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.ComposePreview
+import chat.simplex.app.views.chat.ComposeState
 import chat.simplex.app.views.chat.item.MarkdownText
 import chat.simplex.app.views.helpers.*
 
 @Composable
-fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileDisplayName: String?, stopped: Boolean) {
+fun ChatPreviewView(
+  chat: Chat,
+  chatModelDraft: ComposeState?,
+  chatModelDraftChatId: ChatId?,
+  chatModelIncognito: Boolean,
+  currentUserProfileDisplayName: String?,
+  contactNetworkStatus: NetworkStatus?,
+  stopped: Boolean,
+  linkMode: SimplexLinkMode
+) {
   val cInfo = chat.chatInfo
 
   @Composable
@@ -63,11 +77,58 @@ fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileD
     )
   }
 
+  @Composable
+  fun VerifiedIcon() {
+    Icon(Icons.Outlined.VerifiedUser, null, Modifier.size(19.dp).padding(end = 3.dp, top = 1.dp), tint = HighOrLowlight)
+  }
+
+  fun messageDraft(draft: ComposeState): Pair<AnnotatedString, Map<String, InlineTextContent>> {
+    fun attachment(): Pair<ImageVector, String?>? =
+      when (draft.preview) {
+        is ComposePreview.FilePreview -> Icons.Filled.InsertDriveFile to draft.preview.fileName
+        is ComposePreview.ImagePreview -> Icons.Outlined.Image to null
+        is ComposePreview.VoicePreview -> Icons.Filled.PlayArrow to durationText(draft.preview.durationMs / 1000)
+        else -> null
+      }
+
+    val attachment = attachment()
+    val text = buildAnnotatedString {
+      appendInlineContent(id = "editIcon")
+      append(" ")
+      if (attachment != null) {
+        appendInlineContent(id = "attachmentIcon")
+        if (attachment.second != null) {
+          append(attachment.second as String)
+        }
+        append(" ")
+      }
+      append(draft.message)
+    }
+    val inlineContent: Map<String, InlineTextContent> = mapOf(
+      "editIcon" to InlineTextContent(
+        Placeholder(20.sp, 20.sp, PlaceholderVerticalAlign.TextCenter)
+      ) {
+        Icon(Icons.Outlined.EditNote, null, tint = MaterialTheme.colors.primary)
+      },
+      "attachmentIcon" to InlineTextContent(
+        Placeholder(20.sp, 20.sp, PlaceholderVerticalAlign.TextCenter)
+      ) {
+        Icon(attachment?.first ?: Icons.Outlined.EditNote, null, tint = HighOrLowlight)
+      }
+    )
+    return text to inlineContent
+  }
+
   @Composable
   fun chatPreviewTitle() {
     when (cInfo) {
       is ChatInfo.Direct ->
-        chatPreviewTitleText(if (cInfo.ready) Color.Unspecified else HighOrLowlight)
+        Row(verticalAlignment = Alignment.CenterVertically) {
+          if (cInfo.contact.verified) {
+            VerifiedIcon()
+          }
+          chatPreviewTitleText(if (cInfo.ready) Color.Unspecified else HighOrLowlight)
+        }
       is ChatInfo.Group ->
         when (cInfo.groupInfo.membership.memberStatus) {
           GroupMemberStatus.MemInvited -> chatPreviewTitleText(if (chat.chatInfo.incognito) Indigo else MaterialTheme.colors.primary)
@@ -82,15 +143,30 @@ fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileD
   fun chatPreviewText(chatModelIncognito: Boolean) {
     val ci = chat.chatItems.lastOrNull()
     if (ci != null) {
+      val (text: CharSequence, inlineTextContent) = when {
+        chatModelDraftChatId == chat.id && chatModelDraft != null -> remember(chatModelDraft) { messageDraft(chatModelDraft) }
+        ci.meta.itemDeleted == null -> ci.text to null
+        else -> generalGetString(R.string.marked_deleted_description) to null
+      }
+      val formattedText = when {
+        chatModelDraftChatId == chat.id && chatModelDraft != null -> null
+        ci.meta.itemDeleted == null -> ci.formattedText
+        else -> null
+      }
       MarkdownText(
-        ci.text,
-        ci.formattedText,
-        sender = if (cInfo is ChatInfo.Group && !ci.chatDir.sent) ci.memberDisplayName else null,
+        text,
+        formattedText,
+        sender = when {
+          chatModelDraftChatId == chat.id && chatModelDraft != null -> null
+          cInfo is ChatInfo.Group && !ci.chatDir.sent -> ci.memberDisplayName
+          else -> null
+        },
+        linkMode = linkMode,
         senderBold = true,
-        metaText = null,
         maxLines = 2,
         overflow = TextOverflow.Ellipsis,
         style = MaterialTheme.typography.body1.copy(color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+        inlineContent = inlineTextContent,
         modifier = Modifier.fillMaxWidth(),
       )
     } else {
@@ -178,7 +254,7 @@ fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileD
           Modifier.padding(top = 52.dp),
           contentAlignment = Alignment.Center
         ) {
-          ChatStatusImage(chat)
+          ChatStatusImage(contactNetworkStatus)
         }
       }
     }
@@ -201,10 +277,9 @@ fun unreadCountStr(n: Int): String {
 }
 
 @Composable
-fun ChatStatusImage(chat: Chat) {
-  val s = chat.serverInfo.networkStatus
-  val descr = s.statusString
-  if (s is Chat.NetworkStatus.Error) {
+fun ChatStatusImage(s: NetworkStatus?) {
+  val descr = s?.statusString
+  if (s is NetworkStatus.Error) {
     Icon(
       Icons.Outlined.ErrorOutline,
       contentDescription = descr,
@@ -212,7 +287,7 @@ fun ChatStatusImage(chat: Chat) {
       modifier = Modifier
         .size(19.dp)
     )
-  } else if (s !is Chat.NetworkStatus.Connected) {
+  } else if (s !is NetworkStatus.Connected) {
     CircularProgressIndicator(
       Modifier
         .padding(horizontal = 2.dp)
@@ -232,6 +307,6 @@ fun ChatStatusImage(chat: Chat) {
 @Composable
 fun PreviewChatPreviewView() {
   SimpleXTheme {
-    ChatPreviewView(Chat.sampleData, false, "", stopped = false)
+    ChatPreviewView(Chat.sampleData, null, null, false, "", contactNetworkStatus = NetworkStatus.Connected(), stopped = false, linkMode = SimplexLinkMode.DESCRIPTION)
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ShareListNavLinkView.kt

@@ -29,7 +29,7 @@ fun ShareListNavLinkView(chat: Chat, chatModel: ChatModel) {
         click = { groupChatAction(chat.chatInfo.groupInfo, chatModel) },
         stopped
       )
-    is ChatInfo.ContactRequest, is ChatInfo.ContactConnection -> {}
+    is ChatInfo.ContactRequest, is ChatInfo.ContactConnection, is ChatInfo.InvalidJSON -> {}
   }
 }
 

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/ShareListView.kt

@@ -24,12 +24,15 @@ import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.Indigo
 import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.flow.MutableStateFlow
 
 @Composable
 fun ShareListView(chatModel: ChatModel, stopped: Boolean) {
   var searchInList by rememberSaveable { mutableStateOf("") }
+  val userPickerState by rememberSaveable(stateSaver = AnimatedViewState.saver()) { mutableStateOf(MutableStateFlow(AnimatedViewState.GONE)) }
+  val switchingUsers = rememberSaveable { mutableStateOf(false) }
   Scaffold(
-    topBar = { Column { ShareListToolbar(chatModel, stopped) { searchInList = it.trim() } } },
+    topBar = { Column { ShareListToolbar(chatModel, userPickerState, stopped) { searchInList = it.trim() } } },
   ) {
     Box(Modifier.padding(it)) {
       Column(
@@ -45,23 +48,41 @@ fun ShareListView(chatModel: ChatModel, stopped: Boolean) {
       }
     }
   }
+  UserPicker(chatModel, userPickerState, switchingUsers, showSettings = false, showCancel = true, cancelClicked = {
+    chatModel.sharedContent.value = null
+  })
 }
 
 @Composable
 private fun EmptyList() {
-  Box {
-    Text(stringResource(R.string.you_have_no_chats), Modifier.align(Alignment.Center), color = HighOrLowlight)
+  Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+    Text(stringResource(R.string.you_have_no_chats), color = HighOrLowlight)
   }
 }
 
 @Composable
-private fun ShareListToolbar(chatModel: ChatModel, stopped: Boolean, onSearchValueChanged: (String) -> Unit) {
+private fun ShareListToolbar(chatModel: ChatModel, userPickerState: MutableStateFlow<AnimatedViewState>, stopped: Boolean, onSearchValueChanged: (String) -> Unit) {
   var showSearch by rememberSaveable { mutableStateOf(false) }
   val hideSearchOnBack = { onSearchValueChanged(""); showSearch = false }
   if (showSearch) {
     BackHandler(onBack = hideSearchOnBack)
   }
   val barButtons = arrayListOf<@Composable RowScope.() -> Unit>()
+  val users by remember { derivedStateOf { chatModel.users.filter { u -> u.user.activeUser || !u.user.hidden } } }
+  val navButton: @Composable RowScope.() -> Unit = {
+    when {
+      showSearch -> NavigationButtonBack(hideSearchOnBack)
+      users.size > 1 -> {
+        val allRead = users
+          .filter { u -> !u.user.activeUser && !u.user.hidden }
+          .all { u -> u.unreadCount == 0 }
+        UserProfileButton(chatModel.currentUser.value?.profile?.image, allRead) {
+          userPickerState.value = AnimatedViewState.VISIBLE
+        }
+      }
+      else -> NavigationButtonBack { chatModel.sharedContent.value = null }
+    }
+  }
   if (chatModel.chats.size >= 8) {
     barButtons.add {
       IconButton({ showSearch = true }) {
@@ -87,7 +108,7 @@ private fun ShareListToolbar(chatModel: ChatModel, stopped: Boolean, onSearchVal
   }
 
   DefaultTopAppBar(
-    navigationButton = { if (showSearch) NavigationButtonBack(hideSearchOnBack) else NavigationButtonBack { chatModel.sharedContent.value = null } },
+    navigationButton = navButton,
     title = {
       Row(verticalAlignment = Alignment.CenterVertically) {
         Text(

apps/android/app/src/main/java/chat/simplex/app/views/chatlist/UserPicker.kt

@@ -0,0 +1,241 @@
+package chat.simplex.app.views.chatlist
+
+import SectionItemViewSpaceBetween
+import android.util.Log
+import androidx.compose.animation.core.*
+import androidx.compose.foundation.*
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.*
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.capitalize
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.intl.Locale
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.*
+import chat.simplex.app.R
+import chat.simplex.app.TAG
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
+
+@Composable
+fun UserPicker(
+  chatModel: ChatModel,
+  userPickerState: MutableStateFlow<AnimatedViewState>,
+  switchingUsers: MutableState<Boolean>,
+  showSettings: Boolean = true,
+  showCancel: Boolean = false,
+  cancelClicked: () -> Unit = {},
+  settingsClicked: () -> Unit = {},
+) {
+  val scope = rememberCoroutineScope()
+  var newChat by remember { mutableStateOf(userPickerState.value) }
+  val users by remember {
+    derivedStateOf {
+      chatModel.users
+        .filter { u -> u.user.activeUser || !u.user.hidden }
+        .sortedByDescending { it.user.activeUser }
+    }
+  }
+  val animatedFloat = remember { Animatable(if (newChat.isVisible()) 0f else 1f) }
+  LaunchedEffect(Unit) {
+    launch {
+      userPickerState.collect {
+        newChat = it
+        launch {
+          animatedFloat.animateTo(if (newChat.isVisible()) 1f else 0f, newChatSheetAnimSpec())
+          if (newChat.isHiding()) userPickerState.value = AnimatedViewState.GONE
+        }
+      }
+    }
+  }
+  LaunchedEffect(Unit) {
+    snapshotFlow { newChat.isVisible() }
+      .distinctUntilChanged()
+      .filter { it }
+      .collect {
+        try {
+          val updatedUsers = chatModel.controller.listUsers().sortedByDescending { it.user.activeUser }
+          var same = users.size == updatedUsers.size
+          if (same) {
+            for (i in 0 until minOf(users.size, updatedUsers.size)) {
+              val prev = updatedUsers[i].user
+              val next = users[i].user
+              if (prev.userId != next.userId || prev.activeUser != next.activeUser || prev.chatViewName != next.chatViewName || prev.image != next.image) {
+                same = false
+                break
+              }
+            }
+          }
+          if (!same) {
+            chatModel.users.clear()
+            chatModel.users.addAll(updatedUsers)
+          }
+        } catch (e: Exception) {
+          Log.e(TAG, "Error updating users ${e.stackTraceToString()}")
+        }
+      }
+  }
+  val xOffset = with(LocalDensity.current) { 10.dp.roundToPx() }
+  val maxWidth = with(LocalDensity.current) { LocalConfiguration.current.screenWidthDp * density }
+  Box(Modifier
+    .fillMaxSize()
+    .offset { IntOffset(if (newChat.isGone()) -maxWidth.roundToInt() else xOffset, 0) }
+    .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = { userPickerState.value = AnimatedViewState.HIDING })
+    .padding(bottom = 10.dp, top = 10.dp)
+    .graphicsLayer {
+      alpha = animatedFloat.value
+      translationY = (animatedFloat.value - 1) * xOffset
+    }
+  ) {
+    Column(
+      Modifier
+        .widthIn(min = 220.dp)
+        .width(IntrinsicSize.Min)
+        .height(IntrinsicSize.Min)
+        .shadow(8.dp, MaterialTheme.shapes.medium, clip = false)
+        .background(if (isInDarkTheme()) MaterialTheme.colors.background.darker(-0.7f) else MaterialTheme.colors.background, MaterialTheme.shapes.medium)
+    ) {
+      Column(Modifier.weight(1f).verticalScroll(rememberScrollState())) {
+        users.forEach { u ->
+          UserProfilePickerItem(u.user, u.unreadCount, openSettings = {
+            settingsClicked()
+            userPickerState.value = AnimatedViewState.GONE
+          }) {
+            userPickerState.value = AnimatedViewState.HIDING
+            if (!u.user.activeUser) {
+              scope.launch {
+                val job = launch {
+                  delay(500)
+                  switchingUsers.value = true
+                }
+                chatModel.controller.changeActiveUser(u.user.userId, null)
+                job.cancel()
+                switchingUsers.value = false
+              }
+            }
+          }
+          Divider(Modifier.requiredHeight(1.dp))
+          if (u.user.activeUser) Divider(Modifier.requiredHeight(0.5.dp))
+        }
+      }
+      if (showSettings) {
+        SettingsPickerItem {
+          settingsClicked()
+          userPickerState.value = AnimatedViewState.GONE
+        }
+      }
+      if (showCancel) {
+        CancelPickerItem {
+          cancelClicked()
+          userPickerState.value = AnimatedViewState.GONE
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun UserProfilePickerItem(u: User, unreadCount: Int = 0, onLongClick: () -> Unit = {}, openSettings: () -> Unit = {}, onClick: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxWidth()
+      .sizeIn(minHeight = 46.dp)
+      .combinedClickable(
+        onClick = if (u.activeUser) openSettings else onClick,
+        onLongClick = onLongClick,
+        interactionSource = remember { MutableInteractionSource() },
+        indication = if (!u.activeUser) LocalIndication.current else null
+      )
+      .padding(PaddingValues(start = 8.dp, end = DEFAULT_PADDING)),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    UserProfileRow(u)
+    if (u.activeUser) {
+        Icon(Icons.Filled.Done, null, Modifier.size(20.dp), tint = MaterialTheme.colors.onBackground)
+    } else if (u.hidden) {
+        Icon(Icons.Outlined.Lock, null, Modifier.size(20.dp), tint = HighOrLowlight)
+    } else if (unreadCount > 0) {
+      Row {
+        Text(
+          unreadCountStr(unreadCount),
+          color = Color.White,
+          fontSize = 11.sp,
+          modifier = Modifier
+            .background(if (u.showNtfs) MaterialTheme.colors.primary else HighOrLowlight, shape = CircleShape)
+            .sizeIn(minWidth = 20.dp, minHeight = 20.dp)
+            .padding(horizontal = 3.dp)
+            .padding(vertical = 1.dp),
+          textAlign = TextAlign.Center,
+          maxLines = 1
+        )
+        Spacer(Modifier.width(2.dp))
+      }
+    } else if (!u.showNtfs) {
+      Icon(Icons.Outlined.NotificationsOff, null, Modifier.size(20.dp), tint = HighOrLowlight)
+    }  else {
+      Box(Modifier.size(20.dp))
+    }
+  }
+}
+
+@Composable
+fun UserProfileRow(u: User) {
+  Row(
+    Modifier
+      .widthIn(max = LocalConfiguration.current.screenWidthDp.dp * 0.7f)
+      .padding(vertical = 8.dp),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    ProfileImage(
+      image = u.image,
+      size = 54.dp
+    )
+    Text(
+      u.displayName,
+      modifier = Modifier
+        .padding(start = 8.dp, end = 8.dp),
+      fontWeight = if (u.activeUser) FontWeight.Medium else FontWeight.Normal
+    )
+  }
+}
+
+@Composable
+private fun SettingsPickerItem(onClick: () -> Unit) {
+  SectionItemViewSpaceBetween(onClick, minHeight = 68.dp) {
+    val text = generalGetString(R.string.settings_section_title_settings).lowercase().capitalize(Locale.current)
+    Text(
+      text,
+      color = MaterialTheme.colors.onBackground,
+    )
+    Icon(Icons.Outlined.Settings, text, Modifier.size(20.dp), tint = MaterialTheme.colors.onBackground)
+  }
+}
+
+@Composable
+private fun CancelPickerItem(onClick: () -> Unit) {
+  SectionItemViewSpaceBetween(onClick, minHeight = 68.dp) {
+    val text = generalGetString(R.string.cancel_verb)
+    Text(
+      text,
+      color = MaterialTheme.colors.onBackground,
+    )
+    Icon(Icons.Outlined.Close, text, Modifier.size(20.dp), tint = MaterialTheme.colors.onBackground)
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/database/DatabaseEncryptionView.kt

@@ -1,5 +1,6 @@
 package chat.simplex.app.views.database
 
+import SectionDivider
 import SectionItemView
 import SectionItemViewSpaceBetween
 import SectionTextFooter
@@ -25,13 +26,13 @@ import androidx.compose.ui.text.*
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.input.*
 import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
+import androidx.compose.ui.unit.*
 import chat.simplex.app.R
 import chat.simplex.app.SimplexApp
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.datetime.Clock
 import kotlin.math.log2
 
@@ -161,7 +162,9 @@ fun DatabaseEncryptionLayout(
       }
 
       if (!initialRandomDBPassphrase.value && chatDbEncrypted == true) {
-        DatabaseKeyField(
+        SectionDivider()
+
+        PassphraseField(
           currentKey,
           generalGetString(R.string.current_passphrase),
           modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
@@ -170,7 +173,9 @@ fun DatabaseEncryptionLayout(
         )
       }
 
-      DatabaseKeyField(
+      SectionDivider()
+
+      PassphraseField(
         newKey,
         generalGetString(R.string.new_passphrase),
         modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
@@ -201,7 +206,9 @@ fun DatabaseEncryptionLayout(
           !validKey(newKey.value) ||
           progressIndicator.value
 
-      DatabaseKeyField(
+      SectionDivider()
+
+      PassphraseField(
         confirmNewKey,
         generalGetString(R.string.confirm_new_passphrase),
         modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
@@ -212,7 +219,9 @@ fun DatabaseEncryptionLayout(
         }),
       )
 
-      SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled) {
+      SectionDivider()
+
+      SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled, minHeight = TextFieldDefaults.MinHeight) {
         Text(generalGetString(R.string.update_database_passphrase), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
       }
     }
@@ -285,9 +294,10 @@ fun SavePassphraseSetting(
   initialRandomDBPassphrase: Boolean,
   storedKey: Boolean,
   progressIndicator: Boolean,
+  minHeight: Dp = TextFieldDefaults.MinHeight,
   onCheckedChange: (Boolean) -> Unit,
 ) {
-  SectionItemView {
+  SectionItemView(minHeight = minHeight) {
     Row(verticalAlignment = Alignment.CenterVertically) {
       Icon(
         if (storedKey) Icons.Filled.VpnKey else Icons.Filled.VpnKeyOff,
@@ -349,13 +359,14 @@ private fun operationEnded(m: ChatModel, progressIndicator: MutableState<Boolean
 
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
-fun DatabaseKeyField(
+fun PassphraseField(
   key: MutableState<String>,
   placeholder: String,
   modifier: Modifier = Modifier,
   showStrength: Boolean = false,
   isValid: (String) -> Boolean,
   keyboardActions: KeyboardActions = KeyboardActions(),
+  dependsOn: MutableState<String>? = null,
 ) {
   var valid by remember { mutableStateOf(validKey(key.value)) }
   var showKey by remember { mutableStateOf(false) }
@@ -436,6 +447,13 @@ fun DatabaseKeyField(
       )
     }
   )
+  LaunchedEffect(Unit) {
+    snapshotFlow { dependsOn?.value }
+      .distinctUntilChanged()
+      .collect {
+        valid = isValid(state.value.text)
+      }
+  }
 }
 
 // based on https://generatepasswords.org/how-to-calculate-entropy/

apps/android/app/src/main/java/chat/simplex/app/views/database/DatabaseErrorView.kt

@@ -4,6 +4,7 @@ import SectionSpacer
 import SectionView
 import android.content.Context
 import android.util.Log
+import androidx.annotation.StringRes
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardActions
@@ -13,6 +14,7 @@ import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.*
@@ -20,6 +22,7 @@ import chat.simplex.app.R
 import chat.simplex.app.model.AppPreferences
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.AppVersionText
 import chat.simplex.app.views.usersettings.NotificationsMode
 import kotlinx.coroutines.*
 import kotlinx.datetime.Clock
@@ -39,24 +42,39 @@ fun DatabaseErrorView(
   var useKeychain by remember { mutableStateOf(appPreferences.storeDBPassphrase.get()) }
   val context = LocalContext.current
   val restoreDbFromBackup = remember { mutableStateOf(shouldShowRestoreDbButton(appPreferences, context)) }
-  val saveAndRunChatOnClick: () -> Unit = {
+
+  fun callRunChat(confirmMigrations: MigrationConfirmation? = null) {
+    val useKey = if (useKeychain) null else dbKey.value
+    runChat(useKey, confirmMigrations, chatDbStatus, progressIndicator, appPreferences)
+  }
+
+  fun saveAndRunChatOnClick() {
     DatabaseUtils.setDatabaseKey(dbKey.value)
     storedDBKey = dbKey.value
     appPreferences.storeDBPassphrase.set(true)
     useKeychain = true
     appPreferences.initialRandomDBPassphrase.set(false)
-    runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences)
+    callRunChat()
   }
-  val title = when (chatDbStatus.value) {
-    is DBMigrationResult.OK -> ""
-    is DBMigrationResult.ErrorNotADatabase -> if (useKeychain && !storedDBKey.isNullOrEmpty())
-      generalGetString(R.string.wrong_passphrase)
-    else
-      generalGetString(R.string.encrypted_database)
-    is DBMigrationResult.Error -> generalGetString(R.string.database_error)
-    is DBMigrationResult.ErrorKeychain -> generalGetString(R.string.keychain_error)
-    is DBMigrationResult.Unknown -> generalGetString(R.string.database_error)
-    null -> "" // should never be here
+
+  @Composable
+  fun DatabaseErrorDetails(@StringRes title: Int, content: @Composable ColumnScope.() -> Unit) {
+    Text(
+      generalGetString(title),
+      Modifier.padding(start = 16.dp, top = 16.dp, bottom = 16.dp),
+      style = MaterialTheme.typography.h1
+    )
+    SectionView(null, padding = PaddingValues(horizontal = DEFAULT_PADDING, vertical = DEFAULT_PADDING_HALF), content)
+  }
+
+  @Composable
+  fun FileNameText(dbFile: String) {
+    Text(String.format(generalGetString(R.string.file_with_path), dbFile.split("/").lastOrNull() ?: dbFile))
+  }
+
+  @Composable
+  fun MigrationsText(ms: List<String>) {
+    Text(String.format(generalGetString(R.string.database_migrations), ms.joinToString(", ")))
   }
 
   Column(
@@ -64,63 +82,91 @@ fun DatabaseErrorView(
     horizontalAlignment = Alignment.Start,
     verticalArrangement = Arrangement.Center,
   ) {
-    Text(
-      title,
-      Modifier.padding(start = 16.dp, top = 16.dp, bottom = 24.dp),
-      style = MaterialTheme.typography.h1
-    )
-    SectionView(null, padding = PaddingValues(horizontal = DEFAULT_PADDING, vertical = DEFAULT_PADDING_HALF)) {
-      val buttonEnabled = validKey(dbKey.value) && !progressIndicator.value
-      when (val status = chatDbStatus.value) {
-        is DBMigrationResult.ErrorNotADatabase -> {
-          if (useKeychain && !storedDBKey.isNullOrEmpty()) {
+    val buttonEnabled = validKey(dbKey.value) && !progressIndicator.value
+    when (val status = chatDbStatus.value) {
+      is DBMigrationResult.ErrorNotADatabase ->
+        if (useKeychain && !storedDBKey.isNullOrEmpty()) {
+          DatabaseErrorDetails(R.string.wrong_passphrase) {
             Text(generalGetString(R.string.passphrase_is_different))
             DatabaseKeyField(dbKey, buttonEnabled) {
               saveAndRunChatOnClick()
             }
-            SaveAndOpenButton(buttonEnabled, saveAndRunChatOnClick)
+            SaveAndOpenButton(buttonEnabled, ::saveAndRunChatOnClick)
             SectionSpacer()
-            Text(String.format(generalGetString(R.string.file_with_path), status.dbFile))
-          } else {
+            FileNameText(status.dbFile)
+          }
+        } else {
+          DatabaseErrorDetails(R.string.encrypted_database) {
             Text(generalGetString(R.string.database_passphrase_is_required))
-            DatabaseKeyField(dbKey, buttonEnabled) {
-              if (useKeychain) saveAndRunChatOnClick() else runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences)
-            }
             if (useKeychain) {
-              SaveAndOpenButton(buttonEnabled, saveAndRunChatOnClick)
+              DatabaseKeyField(dbKey, buttonEnabled, ::saveAndRunChatOnClick)
+              SaveAndOpenButton(buttonEnabled, ::saveAndRunChatOnClick)
             } else {
-              OpenChatButton(buttonEnabled) { runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences) }
+              DatabaseKeyField(dbKey, buttonEnabled) { callRunChat() }
+              OpenChatButton(buttonEnabled) { callRunChat() }
             }
           }
         }
-        is DBMigrationResult.Error -> {
-          Text(String.format(generalGetString(R.string.file_with_path), status.dbFile))
-          Text(String.format(generalGetString(R.string.error_with_info), status.migrationError))
+      is DBMigrationResult.ErrorMigration -> when (val err = status.migrationError) {
+        is MigrationError.Upgrade ->
+          DatabaseErrorDetails(R.string.database_upgrade) {
+            TextButton({ callRunChat(confirmMigrations = MigrationConfirmation.YesUp) }, Modifier.align(Alignment.CenterHorizontally), enabled = !progressIndicator.value) {
+              Text(generalGetString(R.string.upgrade_and_open_chat))
+            }
+            Spacer(Modifier.height(20.dp))
+            FileNameText(status.dbFile)
+            MigrationsText(err.upMigrations.map { it.upName })
+            AppVersionText()
+          }
+        is MigrationError.Downgrade ->
+          DatabaseErrorDetails(R.string.database_downgrade) {
+            TextButton({ callRunChat(confirmMigrations = MigrationConfirmation.YesUpDown) }, Modifier.align(Alignment.CenterHorizontally), enabled = !progressIndicator.value) {
+              Text(generalGetString(R.string.downgrade_and_open_chat))
+            }
+            Spacer(Modifier.height(20.dp))
+            Text(generalGetString(R.string.database_downgrade_warning), fontWeight = FontWeight.Bold)
+            FileNameText(status.dbFile)
+            MigrationsText(err.downMigrations)
+            AppVersionText()
+          }
+        is MigrationError.Error ->
+          DatabaseErrorDetails(R.string.incompatible_database_version) {
+            FileNameText(status.dbFile)
+            Text(String.format(generalGetString(R.string.error_with_info), mtrErrorDescription(err.mtrError)))
+          }
+      }
+      is DBMigrationResult.ErrorSQL ->
+        DatabaseErrorDetails(R.string.database_error) {
+          FileNameText(status.dbFile)
+          Text(String.format(generalGetString(R.string.error_with_info), status.migrationSQLError))
         }
-        is DBMigrationResult.ErrorKeychain -> {
+      is DBMigrationResult.ErrorKeychain ->
+        DatabaseErrorDetails(R.string.keychain_error) {
           Text(generalGetString(R.string.cannot_access_keychain))
         }
-        is DBMigrationResult.Unknown -> {
+      is DBMigrationResult.InvalidConfirmation ->
+        DatabaseErrorDetails(R.string.invalid_migration_confirmation) {
+          // this can only happen if incorrect parameter is passed
+        }
+      is DBMigrationResult.Unknown ->
+        DatabaseErrorDetails(R.string.database_error) {
           Text(String.format(generalGetString(R.string.unknown_database_error_with_info), status.json))
         }
-        is DBMigrationResult.OK -> {
-        }
-        null -> {
-        }
-      }
-      if (restoreDbFromBackup.value) {
-        SectionSpacer()
-        Text(generalGetString(R.string.database_backup_can_be_restored))
-        Spacer(Modifier.size(16.dp))
-        RestoreDbButton {
-          AlertManager.shared.showAlertDialog(
-            title = generalGetString(R.string.restore_database_alert_title),
-            text = generalGetString(R.string.restore_database_alert_desc),
-            confirmText = generalGetString(R.string.restore_database_alert_confirm),
-            onConfirm = { restoreDb(restoreDbFromBackup, appPreferences, context) },
-            destructive = true,
-          )
-        }
+      is DBMigrationResult.OK -> {}
+      null -> {}
+    }
+    if (restoreDbFromBackup.value) {
+      SectionSpacer()
+      Text(generalGetString(R.string.database_backup_can_be_restored))
+      Spacer(Modifier.size(16.dp))
+      RestoreDbButton {
+        AlertManager.shared.showAlertDialog(
+          title = generalGetString(R.string.restore_database_alert_title),
+          text = generalGetString(R.string.restore_database_alert_desc),
+          confirmText = generalGetString(R.string.restore_database_alert_confirm),
+          onConfirm = { restoreDb(restoreDbFromBackup, appPreferences, context) },
+          destructive = true,
+        )
       }
     }
   }
@@ -141,7 +187,8 @@ fun DatabaseErrorView(
 }
 
 private fun runChat(
-  dbKey: String,
+  dbKey: String? = null,
+  confirmMigrations: MigrationConfirmation? = null,
   chatDbStatus: State<DBMigrationResult?>,
   progressIndicator: MutableState<Boolean>,
   prefs: AppPreferences
@@ -150,7 +197,7 @@ private fun runChat(
   if (progressIndicator.value) return@launch
   progressIndicator.value = true
   try {
-    SimplexApp.context.initChatController(dbKey)
+    SimplexApp.context.initChatController(dbKey, confirmMigrations)
   } catch (e: Exception) {
     Log.d(TAG, "initializeChat ${e.stackTraceToString()}")
   }
@@ -163,18 +210,17 @@ private fun runChat(
         NotificationsMode.PERIODIC.name -> SimplexApp.context.schedulePeriodicWakeUp()
       }
     }
-    is DBMigrationResult.ErrorNotADatabase -> {
+    is DBMigrationResult.ErrorNotADatabase ->
       AlertManager.shared.showAlertMsg(generalGetString(R.string.wrong_passphrase_title), generalGetString(R.string.enter_correct_passphrase))
-    }
-    is DBMigrationResult.Error -> {
-      AlertManager.shared.showAlertMsg(generalGetString(R.string.database_error), status.migrationError)
-    }
-    is DBMigrationResult.ErrorKeychain -> {
+    is DBMigrationResult.ErrorSQL ->
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.database_error), status.migrationSQLError)
+    is DBMigrationResult.ErrorKeychain ->
       AlertManager.shared.showAlertMsg(generalGetString(R.string.keychain_error))
-    }
-    is DBMigrationResult.Unknown -> {
+    is DBMigrationResult.Unknown ->
       AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), status.json)
-    }
+    is DBMigrationResult.InvalidConfirmation ->
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.invalid_migration_confirmation))
+    is DBMigrationResult.ErrorMigration -> {}
     null -> {}
   }
 }
@@ -204,9 +250,17 @@ private fun restoreDb(restoreDbFromBackup: MutableState<Boolean>, prefs: AppPref
   }
 }
 
+private fun mtrErrorDescription(err: MTRError): String =
+  when (err) {
+    is MTRError.NoDown ->
+      String.format(generalGetString(R.string.mtr_error_no_down_migration), err.dbMigrations.joinToString(", "))
+    is MTRError.Different ->
+      String.format(generalGetString(R.string.mtr_error_different), err.appMigration, err.dbMigration)
+  }
+
 @Composable
 private fun DatabaseKeyField(text: MutableState<String>, enabled: Boolean, onClick: (() -> Unit)? = null) {
-  DatabaseKeyField(
+  PassphraseField(
     text,
     generalGetString(R.string.enter_passphrase),
     isValid = ::validKey,

apps/android/app/src/main/java/chat/simplex/app/views/database/DatabaseView.kt

@@ -8,7 +8,6 @@ import SectionView
 import android.content.Context
 import android.content.res.Configuration
 import android.net.Uri
-import android.os.FileUtils
 import android.util.Log
 import android.widget.Toast
 import androidx.activity.compose.ManagedActivityResultLauncher
@@ -27,6 +26,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.fragment.app.FragmentActivity
@@ -38,6 +39,7 @@ import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.usersettings.*
 import kotlinx.coroutines.*
 import kotlinx.datetime.*
+import org.apache.commons.io.IOUtils
 import java.io.*
 import java.text.SimpleDateFormat
 import java.util.*
@@ -84,8 +86,11 @@ fun DatabaseView(
       chatArchiveTime,
       chatLastStart,
       chatDbDeleted.value,
+      m.controller.appPrefs.privacyFullBackup,
       appFilesCountAndSize,
       chatItemTTL,
+      m.currentUser.value,
+      m.users,
       startChat = { startChat(m, runChat, chatLastStart, m.chatDbChanged) },
       stopChatAlert = { stopChatAlert(m, runChat, context) },
       exportArchive = { exportArchive(context, m, progressIndicator, chatArchiveName, chatArchiveTime, chatArchiveFile, saveArchiveLauncher) },
@@ -126,14 +131,17 @@ fun DatabaseLayout(
   chatDbChanged: Boolean,
   useKeyChain: Boolean,
   chatDbEncrypted: Boolean?,
-  initialRandomDBPassphrase: Preference<Boolean>,
+  initialRandomDBPassphrase: SharedPreference<Boolean>,
   importArchiveLauncher: ManagedActivityResultLauncher<String, Uri?>,
   chatArchiveName: MutableState<String?>,
   chatArchiveTime: MutableState<Instant?>,
   chatLastStart: MutableState<Instant?>,
   chatDbDeleted: Boolean,
+  privacyFullBackup: SharedPreference<Boolean>,
   appFilesCountAndSize: MutableState<Pair<Int, Long>>,
   chatItemTTL: MutableState<ChatItemTTL>,
+  currentUser: User?,
+  users: List<UserInfo>,
   startChat: () -> Unit,
   stopChatAlert: () -> Unit,
   exportArchive: () -> Unit,
@@ -146,10 +154,27 @@ fun DatabaseLayout(
   val operationsDisabled = !stopped || progressIndicator
 
   Column(
-    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()).padding(bottom = DEFAULT_BOTTOM_PADDING),
     horizontalAlignment = Alignment.Start,
   ) {
     AppBarTitle(stringResource(R.string.your_chat_database))
+
+    SectionView(stringResource(R.string.messages_section_title).uppercase()) {
+      SectionItemView { TtlOptions(chatItemTTL, enabled = rememberUpdatedState(!progressIndicator && !chatDbChanged), onChatItemTTLSelected) }
+    }
+    SectionTextFooter(
+      remember(currentUser?.displayName) {
+        buildAnnotatedString {
+          append(generalGetString(R.string.messages_section_description) + " ")
+          withStyle(SpanStyle(fontWeight = FontWeight.Bold)) {
+            append(currentUser?.displayName ?: "")
+          }
+          append(".")
+        }
+      }
+    )
+    SectionSpacer()
+
     SectionView(stringResource(R.string.run_chat_section)) {
       RunChatSetting(runChat, stopped, chatDbDeleted, startChat, stopChatAlert)
     }
@@ -165,6 +190,8 @@ fun DatabaseLayout(
         disabled = operationsDisabled
       )
       SectionDivider()
+      AppDataBackupPreference(privacyFullBackup, initialRandomDBPassphrase)
+      SectionDivider()
       SettingsActionItem(
         Icons.Outlined.IosShare,
         stringResource(R.string.export_database),
@@ -220,16 +247,14 @@ fun DatabaseLayout(
     )
     SectionSpacer()
 
-    SectionView(stringResource(R.string.data_section)) {
-      SectionItemView { TtlOptions(chatItemTTL, enabled = rememberUpdatedState(!progressIndicator && !chatDbChanged), onChatItemTTLSelected) }
-      SectionDivider()
+    SectionView(stringResource(R.string.files_and_media_section).uppercase()) {
       val deleteFilesDisabled = operationsDisabled || appFilesCountAndSize.value.first == 0
       SectionItemView(
         deleteAppFilesAndMedia,
         disabled = deleteFilesDisabled
       ) {
         Text(
-          stringResource(R.string.delete_files_and_media),
+          stringResource(if (users.size > 1) R.string.delete_files_and_media_for_all_users else R.string.delete_files_and_media_all),
           color = if (deleteFilesDisabled) HighOrLowlight else Color.Red
         )
       }
@@ -245,6 +270,36 @@ fun DatabaseLayout(
   }
 }
 
+@Composable
+private fun AppDataBackupPreference(privacyFullBackup: SharedPreference<Boolean>, initialRandomDBPassphrase: SharedPreference<Boolean>) {
+  SectionItemView {
+    Row(verticalAlignment = Alignment.CenterVertically) {
+      Icon(Icons.Outlined.Backup, stringResource(R.string.full_backup), tint = HighOrLowlight)
+      Spacer(Modifier.padding(horizontal = 4.dp))
+      val prefState = remember { mutableStateOf(privacyFullBackup.get()) }
+      Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+        Text(stringResource(R.string.full_backup), Modifier.padding(end = 24.dp))
+        Spacer(Modifier.fillMaxWidth().weight(1f))
+        Switch(
+          checked = prefState.value,
+          onCheckedChange = {
+            if (initialRandomDBPassphrase.get()) {
+              exportProhibitedAlert()
+            } else {
+              privacyFullBackup.set(it)
+              prefState.value = it
+            }
+          },
+          colors = SwitchDefaults.colors(
+            checkedThumbColor = MaterialTheme.colors.primary,
+            uncheckedThumbColor = HighOrLowlight
+          )
+        )
+      }
+    }
+  }
+}
+
 private fun setChatItemTTLAlert(
   m: ChatModel, selectedChatItemTTL: MutableState<ChatItemTTL>,
   progressIndicator: MutableState<Boolean>,
@@ -409,7 +464,7 @@ private fun stopChat(m: ChatModel, runChat: MutableState<Boolean>, context: Cont
       m.controller.apiStopChat()
       runChat.value = false
       m.chatRunning.value = false
-      SimplexService.stop(context)
+      SimplexService.safeStopService(context)
       MessagesFetcherWorker.cancelAll()
     } catch (e: Error) {
       runChat.value = true
@@ -565,7 +620,7 @@ private fun saveArchiveFromUri(context: Context, importedArchiveUri: Uri): Strin
     if (inputStream != null && archiveName != null) {
       val archivePath = "${context.cacheDir}/$archiveName"
       val destFile = File(archivePath)
-      FileUtils.copy(inputStream, FileOutputStream(destFile))
+      IOUtils.copy(inputStream, FileOutputStream(destFile))
       archivePath
     } else {
       Log.e(TAG, "saveArchiveFromUri null inputStream")
@@ -683,14 +738,17 @@ fun PreviewDatabaseLayout() {
       chatDbChanged = false,
       useKeyChain = false,
       chatDbEncrypted = false,
-      initialRandomDBPassphrase = Preference({ true }, {}),
+      initialRandomDBPassphrase = SharedPreference({ true }, {}),
       importArchiveLauncher = rememberGetContentLauncher {},
       chatArchiveName = remember { mutableStateOf("dummy_archive") },
       chatArchiveTime = remember { mutableStateOf(Clock.System.now()) },
       chatLastStart = remember { mutableStateOf(Clock.System.now()) },
       chatDbDeleted = false,
+      privacyFullBackup = SharedPreference({ true }, {}),
       appFilesCountAndSize = remember { mutableStateOf(0 to 0L) },
       chatItemTTL = remember { mutableStateOf(ChatItemTTL.None) },
+      currentUser = User.sampleData,
+      users = listOf(UserInfo.sampleData),
       startChat = {},
       stopChatAlert = {},
       exportArchive = {},

apps/android/app/src/main/java/chat/simplex/app/views/helpers/AlertManager.kt

@@ -1,27 +1,31 @@
 package chat.simplex.app.views.helpers
 
 import android.util.Log
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.runtime.*
-import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.*
+import androidx.compose.ui.window.Dialog
 import chat.simplex.app.R
 import chat.simplex.app.TAG
+import chat.simplex.app.ui.theme.*
 
 class AlertManager {
-  var alertView = mutableStateOf<(@Composable () -> Unit)?>(null)
-  var presentAlert = mutableStateOf<Boolean>(false)
+  var alertViews = mutableStateListOf<(@Composable () -> Unit)>()
 
   fun showAlert(alert: @Composable () -> Unit) {
     Log.d(TAG, "AlertManager.showAlert")
-    alertView.value = alert
-    presentAlert.value = true
+    alertViews.add(alert)
   }
 
   fun hideAlert() {
-    presentAlert.value = false
-    alertView.value = null
+    alertViews.removeLastOrNull()
   }
 
   fun showAlertDialogButtons(
@@ -40,6 +44,36 @@ class AlertManager {
     }
   }
 
+  fun showAlertDialogButtonsColumn(
+    title: String,
+    text: AnnotatedString? = null,
+    buttons: @Composable () -> Unit,
+  ) {
+    showAlert {
+      Dialog(onDismissRequest = this::hideAlert) {
+        Column(Modifier.background(MaterialTheme.colors.background, MaterialTheme.shapes.medium)) {
+          Text(title,
+            Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = DEFAULT_PADDING, bottom = if (text == null) DEFAULT_PADDING else DEFAULT_PADDING_HALF),
+            fontSize = 15.sp,
+            fontWeight = FontWeight.SemiBold
+          )
+          if (text != null) {
+            CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.high) {
+              Text(
+                text,
+                Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, bottom = DEFAULT_PADDING),
+                fontSize = 14.sp,
+              )
+            }
+          }
+          CompositionLocalProvider(LocalContentAlpha provides ContentAlpha.high) {
+            buttons()
+          }
+        }
+      }
+    }
+  }
+
   fun showAlertDialog(
     title: String,
     text: String? = null,
@@ -72,6 +106,41 @@ class AlertManager {
     }
   }
 
+  fun showAlertDialogStacked(
+    title: String,
+    text: String? = null,
+    confirmText: String = generalGetString(R.string.ok),
+    onConfirm: (() -> Unit)? = null,
+    dismissText: String = generalGetString(R.string.cancel_verb),
+    onDismiss: (() -> Unit)? = null,
+    onDismissRequest: (() -> Unit)? = null,
+    destructive: Boolean = false
+  ) {
+    val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
+    showAlert {
+      AlertDialog(
+        onDismissRequest = { onDismissRequest?.invoke(); hideAlert() },
+        title = { Text(title) },
+        text = alertText,
+        buttons = {
+          Column(
+            Modifier.fillMaxWidth().padding(horizontal = 8.dp).padding(top = 16.dp, bottom = 2.dp),
+            horizontalAlignment = Alignment.End
+          ) {
+            TextButton(onClick = {
+              onDismiss?.invoke()
+              hideAlert()
+            }) { Text(dismissText) }
+            TextButton(onClick = {
+              onConfirm?.invoke()
+              hideAlert()
+            }) { Text(confirmText, color = if (destructive) MaterialTheme.colors.error else Color.Unspecified) }
+          }
+        },
+      )
+    }
+  }
+
   fun showAlertMsg(
     title: String, text: String? = null,
     confirmText: String = generalGetString(R.string.ok), onConfirm: (() -> Unit)? = null
@@ -101,10 +170,10 @@ class AlertManager {
 
   @Composable
   fun showInView() {
-    if (presentAlert.value) alertView.value?.invoke()
+    remember { alertViews }.lastOrNull()?.invoke()
   }
 
   companion object {
     val shared = AlertManager()
   }
-}
+}

apps/android/app/src/main/java/chat/simplex/app/views/helpers/AnimationUtils.kt

@@ -2,4 +2,8 @@ package chat.simplex.app.views.helpers
 
 import androidx.compose.animation.core.*
 
+fun <T> chatListAnimationSpec() = tween<T>(durationMillis = 250, easing = FastOutSlowInEasing)
+
 fun <T> newChatSheetAnimSpec() = tween<T>(256, 0, LinearEasing)
+
+fun <T> audioProgressBarAnimationSpec() = tween<T>(durationMillis = 30, easing = LinearEasing)

apps/android/app/src/main/java/chat/simplex/app/views/helpers/ChooseAttachmentView.kt

@@ -15,12 +15,14 @@ import chat.simplex.app.views.newchat.ActionButton
 sealed class AttachmentOption {
   object TakePhoto: AttachmentOption()
   object PickImage: AttachmentOption()
+  object PickVideo: AttachmentOption()
   object PickFile: AttachmentOption()
 }
 
 @Composable
 fun ChooseAttachmentView(
   attachmentOption: MutableState<AttachmentOption?>,
+  allowVideoAttachment: Boolean,
   hide: () -> Unit
 ) {
   Box(
@@ -45,6 +47,12 @@ fun ChooseAttachmentView(
         attachmentOption.value = AttachmentOption.PickImage
         hide()
       }
+      if (allowVideoAttachment) {
+        ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Videocam) {
+          attachmentOption.value = AttachmentOption.PickVideo
+          hide()
+        }
+      }
       ActionButton(null, stringResource(R.string.choose_file), icon = Icons.Outlined.InsertDriveFile) {
         attachmentOption.value = AttachmentOption.PickFile
         hide()

apps/android/app/src/main/java/chat/simplex/app/views/helpers/CloseSheetBar.kt

@@ -4,6 +4,7 @@ import android.content.res.Configuration
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
@@ -11,7 +12,7 @@ import androidx.compose.ui.unit.dp
 import chat.simplex.app.ui.theme.*
 
 @Composable
-fun CloseSheetBar(close: () -> Unit) {
+fun CloseSheetBar(close: () -> Unit, endButtons: @Composable RowScope.() -> Unit = {}) {
   Column(
     Modifier
       .fillMaxWidth()
@@ -20,9 +21,19 @@ fun CloseSheetBar(close: () -> Unit) {
   ) {
     Row(
       Modifier
-        .width(TitleInsetWithIcon - AppBarHorizontalPadding)
         .padding(top = 4.dp), // Like in DefaultAppBar
-      content = { NavigationButtonBack(close) }
+      content = {
+        Row(
+          Modifier.fillMaxWidth().height(TextFieldDefaults.MinHeight),
+          horizontalArrangement = Arrangement.SpaceBetween,
+          verticalAlignment = Alignment.CenterVertically
+        ) {
+          NavigationButtonBack(close)
+          Row {
+            endButtons()
+          }
+        }
+      }
     )
   }
 }
@@ -30,7 +41,7 @@ fun CloseSheetBar(close: () -> Unit) {
 @Composable
 fun AppBarTitle(title: String, withPadding: Boolean = true) {
   val padding = if (withPadding)
-    PaddingValues(start = DEFAULT_PADDING, end = DEFAULT_PADDING, bottom = DEFAULT_PADDING )
+    PaddingValues(start = DEFAULT_PADDING, end = DEFAULT_PADDING, bottom = DEFAULT_PADDING)
   else
     PaddingValues(bottom = DEFAULT_PADDING)
   Text(

apps/android/app/src/main/java/chat/simplex/app/views/helpers/DatabaseUtils.kt

@@ -66,8 +66,39 @@ object DatabaseUtils {
 @Serializable
 sealed class DBMigrationResult {
   @Serializable @SerialName("ok") object OK: DBMigrationResult()
+  @Serializable @SerialName("invalidConfirmation") object InvalidConfirmation: DBMigrationResult()
   @Serializable @SerialName("errorNotADatabase") class ErrorNotADatabase(val dbFile: String): DBMigrationResult()
-  @Serializable @SerialName("error") class Error(val dbFile: String, val migrationError: String): DBMigrationResult()
+  @Serializable @SerialName("errorMigration") class ErrorMigration(val dbFile: String, val migrationError: MigrationError): DBMigrationResult()
+  @Serializable @SerialName("errorSQL") class ErrorSQL(val dbFile: String, val migrationSQLError: String): DBMigrationResult()
   @Serializable @SerialName("errorKeychain") object ErrorKeychain: DBMigrationResult()
   @Serializable @SerialName("unknown") class Unknown(val json: String): DBMigrationResult()
+}
+
+
+enum class MigrationConfirmation(val value: String) {
+  YesUp("yesUp"),
+  YesUpDown ("yesUpDown"),
+  Error("error")
+}
+
+fun defaultMigrationConfirmation(appPrefs: AppPreferences): MigrationConfirmation =
+  if (appPrefs.confirmDBUpgrades.get()) MigrationConfirmation.Error else MigrationConfirmation.YesUp
+
+@Serializable
+sealed class MigrationError {
+  @Serializable @SerialName("upgrade") class Upgrade(val upMigrations: List<UpMigration>): MigrationError()
+  @Serializable @SerialName("downgrade") class Downgrade(val downMigrations: List<String>): MigrationError()
+  @Serializable @SerialName("migrationError") class Error(val mtrError: MTRError): MigrationError()
+}
+
+@Serializable
+data class UpMigration(
+  val upName: String,
+  // val withDown: Boolean
+)
+
+@Serializable
+sealed class MTRError {
+  @Serializable @SerialName("noDown") class NoDown(val dbMigrations: List<String>): MTRError()
+  @Serializable @SerialName("different") class Different(val appMigration: String, val dbMigration: String): MTRError()
 }

apps/android/app/src/main/java/chat/simplex/app/views/helpers/DefaultTopAppBar.kt

@@ -34,7 +34,7 @@ fun DefaultTopAppBar(
       if (!showSearch) {
         title?.invoke()
       } else {
-        SearchTextField(Modifier.fillMaxWidth(), stringResource(android.R.string.search_go), onSearchValueChanged)
+        SearchTextField(Modifier.fillMaxWidth(), stringResource(android.R.string.search_go), alwaysVisible = false, onSearchValueChanged)
       }
     },
     backgroundColor = if (isInDarkTheme()) ToolbarDark else ToolbarLight,
@@ -53,6 +53,15 @@ fun NavigationButtonBack(onButtonClicked: () -> Unit) {
   }
 }
 
+@Composable
+fun ShareButton(onButtonClicked: () -> Unit) {
+  IconButton(onButtonClicked) {
+    Icon(
+      Icons.Outlined.Share, stringResource(R.string.share_verb), tint = MaterialTheme.colors.primary
+    )
+  }
+}
+
 @Composable
 fun NavigationButtonMenu(onButtonClicked: () -> Unit) {
   IconButton(onClick = onButtonClicked) {

apps/android/app/src/main/java/chat/simplex/app/views/helpers/Enums.kt

@@ -1,9 +1,13 @@
+@file:UseSerializers(UriSerializer::class)
 package chat.simplex.app.views.helpers
 
-import android.graphics.Bitmap
 import android.net.Uri
 import androidx.compose.runtime.saveable.Saver
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
 
 sealed class SharedContent {
   data class Text(val text: String): SharedContent()
@@ -11,7 +15,7 @@ sealed class SharedContent {
   data class File(val text: String, val uri: Uri): SharedContent()
 }
 
-enum class NewChatSheetState {
+enum class AnimatedViewState {
   VISIBLE, HIDING, GONE;
   fun isVisible(): Boolean {
     return this == VISIBLE
@@ -23,7 +27,7 @@ enum class NewChatSheetState {
     return this == GONE
   }
   companion object {
-    fun saver(): Saver<MutableStateFlow<NewChatSheetState>, *> = Saver(
+    fun saver(): Saver<MutableStateFlow<AnimatedViewState>, *> = Saver(
       save = { it.value.toString() },
       restore = {
         MutableStateFlow(valueOf(it))
@@ -32,7 +36,17 @@ enum class NewChatSheetState {
   }
 }
 
-sealed class UploadContent {
-  data class SimpleImage(val bitmap: Bitmap): UploadContent()
-  data class AnimatedImage(val uri: Uri): UploadContent()
+
+@Serializer(forClass = Uri::class)
+object UriSerializer : KSerializer<Uri> {
+  override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("Uri", PrimitiveKind.STRING)
+  override fun serialize(encoder: Encoder, value: Uri) = encoder.encodeString(value.toString())
+  override fun deserialize(decoder: Decoder): Uri = Uri.parse(decoder.decodeString())
+}
+
+@Serializable
+sealed class UploadContent {
+  @Serializable data class SimpleImage(val uri: Uri): UploadContent()
+  @Serializable data class AnimatedImage(val uri: Uri): UploadContent()
+  @Serializable data class Video(val uri: Uri, val duration: Int): UploadContent()
 }

apps/android/app/src/main/java/chat/simplex/app/views/helpers/ExposedDropDownSettingRow.kt

@@ -10,9 +10,12 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
 import chat.simplex.app.ui.theme.HighOrLowlight
 
 @Composable
@@ -27,7 +30,7 @@ fun <T> ExposedDropDownSettingRow(
   onSelected: (T) -> Unit
 ) {
   Row(
-    Modifier.fillMaxWidth(),
+    Modifier.fillMaxWidth().padding(vertical = 10.dp),
     verticalAlignment = Alignment.CenterVertically,
   ) {
     var expanded by remember { mutableStateOf(false) }
@@ -40,9 +43,7 @@ fun <T> ExposedDropDownSettingRow(
         tint = iconTint
       )
     }
-    Text(title, color = if (enabled.value) Color.Unspecified else HighOrLowlight)
-
-    Spacer(Modifier.fillMaxWidth().weight(1f))
+    Text(title, Modifier.weight(1f), color = if (enabled.value) Color.Unspecified else HighOrLowlight)
 
     ExposedDropdownMenuBox(
       expanded = expanded,
@@ -55,8 +56,10 @@ fun <T> ExposedDropDownSettingRow(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.End
       ) {
+        val maxWidth = with(LocalDensity.current){ 180.sp.toDp() }
         Text(
           values.first { it.first == selection.value }.second + (if (label != null) " $label" else ""),
+          Modifier.widthIn(max = maxWidth),
           maxLines = 1,
           overflow = TextOverflow.Ellipsis,
           color = HighOrLowlight

apps/android/app/src/main/java/chat/simplex/app/views/helpers/GestureDetector.kt

@@ -213,6 +213,24 @@ fun interactionSourceWithDetection(onClick: () -> Unit, onLongClick: () -> Unit)
   return interactionSource
 }
 
+@Composable
+fun interactionSourceWithTapDetection(onPress: () -> Unit, onClick: () -> Unit, onCancel: () -> Unit, onRelease: ()-> Unit): MutableInteractionSource {
+  val interactionSource = remember { MutableInteractionSource() }
+  LaunchedEffect(interactionSource) {
+    var firstTapTime = 0L
+    interactionSource.interactions.collect { interaction ->
+      when (interaction) {
+        is PressInteraction.Press -> {
+          firstTapTime = System.currentTimeMillis(); onPress()
+        }
+        is PressInteraction.Release -> if (firstTapTime + 1000L < System.currentTimeMillis()) onRelease() else onClick()
+        is PressInteraction.Cancel -> onCancel()
+      }
+    }
+  }
+  return interactionSource
+}
+
 suspend fun PointerInputScope.detectTransformGestures(
   allowIntercept: () -> Boolean,
   panZoomLock: Boolean = false,

apps/android/app/src/main/java/chat/simplex/app/views/helpers/GetImageView.kt

@@ -2,8 +2,8 @@ package chat.simplex.app.views.helpers
 
 import android.Manifest
 import android.app.Activity
-import android.content.Context
-import android.content.Intent
+import android.content.*
+import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
 import android.content.pm.PackageManager
 import android.graphics.*
 import android.net.Uri
@@ -20,8 +20,9 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Collections
 import androidx.compose.material.icons.outlined.PhotoCamera
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
+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.platform.LocalContext
@@ -31,7 +32,10 @@ import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
 import chat.simplex.app.*
 import chat.simplex.app.R
+import chat.simplex.app.model.json
+import chat.simplex.app.views.chat.PickFromGallery
 import chat.simplex.app.views.newchat.ActionButton
+import kotlinx.serialization.builtins.*
 import java.io.ByteArrayOutputStream
 import java.io.File
 import kotlin.math.min
@@ -106,15 +110,12 @@ fun base64ToBitmap(base64ImageString: String): Bitmap {
   }
 }
 
-class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
-  private var uri: Uri? = null
-  private var tmpFile: File? = null
-  lateinit var externalContext: Context
-
+class CustomTakePicturePreview(var uri: Uri?, var tmpFile: File?): ActivityResultContract<Void?, Uri?>() {
   @CallSuper
   override fun createIntent(context: Context, input: Void?): Intent {
-    externalContext = context
-    tmpFile = File.createTempFile("image", ".bmp", context.filesDir)
+    tmpFile = File.createTempFile("image", ".bmp", File(getAppFilesDirectory(SimplexApp.context)))
+    // 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, "${BuildConfig.APPLICATION_ID}.provider", tmpFile!!)
     return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
       .putExtra(MediaStore.EXTRA_OUTPUT, uri)
@@ -123,20 +124,28 @@ class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
   override fun getSynchronousResult(
     context: Context,
     input: Void?
-  ): SynchronousResult<Bitmap?>? = null
+  ): SynchronousResult<Uri?>? = null
 
-  override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
+  override fun parseResult(resultCode: Int, intent: Intent?): Uri? {
     return if (resultCode == Activity.RESULT_OK && uri != null) {
-      val source = ImageDecoder.createSource(externalContext.contentResolver, uri!!)
-      val bitmap = ImageDecoder.decodeBitmap(source)
-      tmpFile?.delete()
-      bitmap
+      uri
     } else {
       Log.e(TAG, "Getting image from camera cancelled or failed.")
-      tmpFile?.delete()
       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 {
@@ -148,8 +157,12 @@ class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
 //fun rememberGalleryLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
 //  rememberLauncherForActivityResult(contract = GetGalleryContent(), cb)
 @Composable
-fun rememberCameraLauncher(cb: (Bitmap?) -> Unit): ManagedActivityResultLauncher<Void?, Bitmap?> =
-  rememberLauncherForActivityResult(contract = CustomTakePicturePreview(), cb)
+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> =
@@ -163,30 +176,47 @@ fun rememberGetContentLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLaunche
 fun rememberGetMultipleContentsLauncher(cb: (List<Uri>) -> Unit): ManagedActivityResultLauncher<String, List<Uri>> =
   rememberLauncherForActivityResult(contract = ActivityResultContracts.GetMultipleContents(), cb)
 
+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
+      SimplexApp.context.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
 fun GetImageBottomSheet(
-  imageBitmap: MutableState<Bitmap?>,
+  imageBitmap: MutableState<Uri?>,
   onImageChange: (Bitmap) -> Unit,
   hideBottomSheet: () -> Unit
 ) {
   val context = LocalContext.current
-  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
+  val processPickedImage = { uri: Uri? ->
     if (uri != null) {
-      val source = ImageDecoder.createSource(context.contentResolver, uri)
-      val bitmap = ImageDecoder.decodeBitmap(source)
-      imageBitmap.value = bitmap
-      onImageChange(bitmap)
-    }
-  }
-  val cameraLauncher = rememberCameraLauncher { bitmap: Bitmap? ->
-    if (bitmap != null) {
-      imageBitmap.value = bitmap
-      onImageChange(bitmap)
+      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.launch(null)
+      cameraLauncher.launchWithFallback()
       hideBottomSheet()
     } else {
       Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
@@ -210,7 +240,7 @@ fun GetImageBottomSheet(
       ActionButton(null, stringResource(R.string.use_camera_button), icon = Icons.Outlined.PhotoCamera) {
         when (PackageManager.PERMISSION_GRANTED) {
           ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
-            cameraLauncher.launch(null)
+            cameraLauncher.launchWithFallback()
             hideBottomSheet()
           }
           else -> {
@@ -219,7 +249,11 @@ fun GetImageBottomSheet(
         }
       }
       ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Collections) {
-        galleryLauncher.launch("image/*")
+        try {
+          galleryLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryLauncherFallback.launch("image/*")
+        }
         hideBottomSheet()
       }
     }

apps/android/app/src/main/java/chat/simplex/app/views/helpers/LocalAuthentication.kt

@@ -89,18 +89,6 @@ fun laTurnedOnAlert() = AlertManager.shared.showAlertMsg(
   generalGetString(R.string.auth_you_will_be_required_to_authenticate_when_you_start_or_resume)
 )
 
-fun laErrorToast(context: Context, errString: CharSequence) = Toast.makeText(
-  context,
-  if (errString.isNotEmpty()) String.format(generalGetString(R.string.auth_error_w_desc), errString) else generalGetString(R.string.auth_error),
-  Toast.LENGTH_SHORT
-).show()
-
-fun laFailedToast(context: Context) = Toast.makeText(
-  context,
-  generalGetString(R.string.auth_failed),
-  Toast.LENGTH_SHORT
-).show()
-
 fun laUnavailableInstructionAlert() = AlertManager.shared.showAlertMsg(
   generalGetString(R.string.auth_unavailable),
   generalGetString(R.string.auth_device_authentication_is_not_enabled_you_can_turn_on_in_settings_once_enabled)

apps/android/app/src/main/java/chat/simplex/app/views/helpers/ModalView.kt

@@ -20,12 +20,13 @@ fun ModalView(
   close: () -> Unit,
   background: Color = MaterialTheme.colors.background,
   modifier: Modifier = Modifier,
+  endButtons: @Composable RowScope.() -> Unit = {},
   content: @Composable () -> Unit,
 ) {
   BackHandler(onBack = close)
   Surface(Modifier.fillMaxSize()) {
     Column(Modifier.background(background)) {
-      CloseSheetBar(close)
+      CloseSheetBar(close, endButtons)
       Box(modifier) { content() }
     }
   }
@@ -37,9 +38,9 @@ class ModalManager {
   private val toRemove = mutableSetOf<Int>()
   private var oldViewChanging = AtomicBoolean(false)
 
-  fun showModal(settings: Boolean = false, content: @Composable () -> Unit) {
+  fun showModal(settings: Boolean = false, endButtons: @Composable RowScope.() -> Unit = {}, content: @Composable () -> Unit) {
     showCustomModal { close ->
-      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, content = content)
+      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, endButtons = endButtons, content = content)
     }
   }
 

apps/android/app/src/main/java/chat/simplex/app/views/helpers/RecAndPlay.kt

@@ -0,0 +1,289 @@
+package chat.simplex.app.views.helpers
+
+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 android.util.Log
+import androidx.compose.runtime.*
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatItem
+import chat.simplex.app.views.helpers.AudioPlayer.duration
+import kotlinx.coroutines.*
+import java.io.*
+
+interface Recorder {
+  fun start(onProgressUpdate: (position: Int?, finished: Boolean) -> Unit): String
+  fun stop(): Int
+}
+
+class RecorderNative(private val recordedBytesLimit: Long): Recorder {
+  companion object {
+    // Allows to stop the recorder from outside without having the recorder in a variable
+    var stopRecording: (() -> Unit)? = null
+    const val extension = "m4a"
+  }
+  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(SimplexApp.context)
+    } 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(16000)
+    rec.setMaxDuration(MAX_VOICE_MILLIS_FOR_SENDING)
+    rec.setMaxFileSize(recordedBytesLimit)
+    val tmpDir = SimplexApp.context.getDir("temp", Application.MODE_PRIVATE)
+    val fileToSave = File.createTempFile(generateNewFileName(SimplexApp.context, "voice", "${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()
+      }
+    }
+    stopRecording = { stop() }
+    return path
+  }
+
+  override fun stop(): Int {
+    val path = filePath ?: return 0
+    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()
+}
+
+object AudioPlayer {
+  private val player = MediaPlayer().apply {
+    setAudioAttributes(
+      AudioAttributes.Builder()
+        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+        .setUsage(AudioAttributes.USAGE_MEDIA)
+        .build()
+    )
+    (SimplexApp.context.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
+            RecorderNative.stopRecording?.invoke()
+            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()
+    RecorderNative.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(R.string.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(R.string.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
+  }
+
+  fun stop() {
+    if (currentlyPlaying.value == null) return
+    player.stop()
+    stopListener()
+  }
+
+  fun stop(item: ChatItem) = stop(item.file?.fileName)
+
+  // FileName or filePath are ok
+  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
+  }
+
+  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 }
+  }
+
+  fun pause(audioPlaying: MutableState<Boolean>, pro: MutableState<Int>) {
+    pro.value = pause()
+    audioPlaying.value = false
+  }
+
+  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
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/helpers/SearchTextField.kt

@@ -17,6 +17,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
 import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.graphics.*
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
@@ -29,15 +30,24 @@ import kotlinx.coroutines.delay
 
 @OptIn(ExperimentalComposeUiApi::class)
 @Composable
-fun SearchTextField(modifier: Modifier, placeholder: String, onValueChange: (String) -> Unit) {
+fun SearchTextField(modifier: Modifier, placeholder: String, alwaysVisible: Boolean, onValueChange: (String) -> Unit) {
   var searchText by rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue("")) }
   val focusRequester = remember { FocusRequester() }
+  val focusManager = LocalFocusManager.current
   val keyboard = LocalSoftwareKeyboardController.current
 
-  LaunchedEffect(Unit) {
-    focusRequester.requestFocus()
-    delay(200)
-    keyboard?.show()
+  if (!alwaysVisible) {
+    LaunchedEffect(Unit) {
+      focusRequester.requestFocus()
+      delay(200)
+      keyboard?.show()
+    }
+  }
+
+  DisposableEffect(Unit) {
+    onDispose {
+      if (searchText.text.isNotEmpty()) onValueChange("")
+    }
   }
 
   val enabled = true
@@ -81,7 +91,14 @@ fun SearchTextField(modifier: Modifier, placeholder: String, onValueChange: (Str
           Text(placeholder)
         },
         trailingIcon = if (searchText.text.isNotEmpty()) {{
-          IconButton({ searchText = TextFieldValue(""); onValueChange("") }) {
+          IconButton({
+            if (alwaysVisible) {
+              keyboard?.hide()
+              focusManager.clearFocus()
+            }
+            searchText = TextFieldValue("");
+            onValueChange("")
+          }) {
             Icon(Icons.Default.Close, stringResource(R.string.icon_descr_close_button), tint = MaterialTheme.colors.primary,)
           }
         }} else null,

apps/android/app/src/main/java/chat/simplex/app/views/helpers/Section.kt

@@ -1,4 +1,5 @@
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.material.*
@@ -10,6 +11,8 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.*
 import chat.simplex.app.ui.theme.*
@@ -31,6 +34,28 @@ fun SectionView(title: String? = null, padding: PaddingValues = PaddingValues(),
   }
 }
 
+@Composable
+fun SectionView(
+  title: String,
+  icon: ImageVector,
+  iconTint: Color = HighOrLowlight,
+  leadingIcon: Boolean = false,
+  padding: PaddingValues = PaddingValues(),
+  content: (@Composable ColumnScope.() -> Unit)
+) {
+  Column {
+    val iconSize = with(LocalDensity.current) { 21.sp.toDp() }
+    Row(Modifier.padding(start = DEFAULT_PADDING, bottom = 5.dp), verticalAlignment = Alignment.CenterVertically) {
+      if (leadingIcon) Icon(icon, null, Modifier.padding(end = 4.dp).size(iconSize), tint = iconTint)
+      Text(title, color = HighOrLowlight, style = MaterialTheme.typography.body2, fontSize = 12.sp)
+      if (!leadingIcon) Icon(icon, null, Modifier.padding(start = 4.dp).size(iconSize), tint = iconTint)
+    }
+    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
+      Column(Modifier.padding(padding).fillMaxWidth()) { content() }
+    }
+  }
+}
+
 @Composable
 fun <T> SectionViewSelectable(
   title: String?,
@@ -56,12 +81,18 @@ fun <T> SectionViewSelectable(
 }
 
 @Composable
-fun SectionItemView(click: (() -> Unit)? = null, minHeight: Dp = 46.dp, disabled: Boolean = false, content: (@Composable RowScope.() -> Unit)) {
+fun SectionItemView(
+  click: (() -> Unit)? = null,
+  minHeight: Dp = 46.dp,
+  disabled: Boolean = false,
+  padding: PaddingValues = PaddingValues(horizontal = DEFAULT_PADDING),
+  content: (@Composable RowScope.() -> Unit)
+) {
   val modifier = Modifier
     .fillMaxWidth()
     .sizeIn(minHeight = minHeight)
   Row(
-    if (click == null || disabled) modifier.padding(horizontal = DEFAULT_PADDING) else modifier.clickable(onClick = click).padding(horizontal = DEFAULT_PADDING),
+    if (click == null || disabled) modifier.padding(padding) else modifier.clickable(onClick = click).padding(padding),
     verticalAlignment = Alignment.CenterVertically
   ) {
     content()
@@ -71,6 +102,7 @@ fun SectionItemView(click: (() -> Unit)? = null, minHeight: Dp = 46.dp, disabled
 @Composable
 fun SectionItemViewSpaceBetween(
   click: (() -> Unit)? = null,
+  onLongClick: (() -> Unit)? = null,
   minHeight: Dp = 46.dp,
   padding: PaddingValues = PaddingValues(horizontal = DEFAULT_PADDING),
   disabled: Boolean = false,
@@ -80,7 +112,7 @@ fun SectionItemViewSpaceBetween(
     .fillMaxWidth()
     .sizeIn(minHeight = minHeight)
   Row(
-    if (click == null || disabled) modifier.padding(padding) else modifier.clickable(onClick = click).padding(padding),
+    if (click == null || disabled) modifier.padding(padding) else modifier.combinedClickable(onClick = click, onLongClick = onLongClick).padding(padding),
     horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
@@ -129,6 +161,11 @@ fun <T> SectionItemWithValue(
 
 @Composable
 fun SectionTextFooter(text: String) {
+  SectionTextFooter(AnnotatedString(text))
+}
+
+@Composable
+fun SectionTextFooter(text: AnnotatedString) {
   Text(
     text,
     Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = DEFAULT_PADDING_HALF).fillMaxWidth(0.9F),
@@ -158,9 +195,13 @@ fun SectionSpacer() {
 }
 
 @Composable
-fun InfoRow(title: String, value: String) {
+fun InfoRow(title: String, value: String, icon: ImageVector? = null, iconTint: Color? = null) {
   SectionItemViewSpaceBetween {
-    Text(title)
+    Row {
+      val iconSize = with(LocalDensity.current) { 21.sp.toDp() }
+      if (icon != null) Icon(icon, title, Modifier.padding(end = 8.dp).size(iconSize), tint = iconTint ?: HighOrLowlight)
+      Text(title)
+    }
     Text(value, color = HighOrLowlight)
   }
 }

apps/android/app/src/main/java/chat/simplex/app/views/helpers/Share.kt

@@ -1,5 +1,6 @@
 package chat.simplex.app.views.helpers
 
+import android.Manifest
 import android.content.*
 import android.net.Uri
 import android.provider.MediaStore
@@ -81,6 +82,7 @@ fun imageMimeType(fileName: String): String {
   }
 }
 
+/** Before calling, make sure the user allows to write to external storage [Manifest.permission.WRITE_EXTERNAL_STORAGE] */
 fun saveImage(cxt: Context, ciFile: CIFile?) {
   val filePath = getLoadedFilePath(cxt, ciFile)
   val fileName = ciFile?.fileName

apps/android/app/src/main/java/chat/simplex/app/views/helpers/SimpleButton.kt

@@ -28,6 +28,22 @@ fun SimpleButton(text: String, icon: ImageVector,
   }
 }
 
+@Composable
+fun SimpleButton(
+  text: String, icon: ImageVector,
+  color: Color = MaterialTheme.colors.primary,
+  disabled: Boolean,
+  click: () -> Unit
+) {
+  SimpleButtonFrame(click, disabled = disabled) {
+    Icon(
+      icon, text, tint = if (disabled) HighOrLowlight else color,
+      modifier = Modifier.padding(end = 8.dp)
+    )
+    Text(text, style = MaterialTheme.typography.caption, color = if (disabled) HighOrLowlight else color)
+  }
+}
+
 @Composable
 fun SimpleButtonIconEnded(
   text: String,

apps/android/app/src/main/java/chat/simplex/app/views/helpers/TextEditor.kt

@@ -12,21 +12,28 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.MutableState
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.*
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.input.KeyboardCapitalization
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
+import androidx.compose.ui.unit.*
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
 import chat.simplex.app.ui.theme.HighOrLowlight
 
 @Composable
-fun TextEditor(modifier: Modifier, text: MutableState<String>) {
+fun TextEditor(
+  modifier: Modifier,
+  text: MutableState<String>,
+  border: Boolean = true,
+  fontSize: TextUnit = 14.sp,
+  background: Color = MaterialTheme.colors.background,
+  onChange: ((String) -> Unit)? = null
+) {
   BasicTextField(
     value = text.value,
-    onValueChange = { text.value = it },
+    onValueChange = { text.value = it; onChange?.invoke(it) },
     textStyle = TextStyle(
-      fontFamily = FontFamily.Monospace, fontSize = 14.sp,
+      fontFamily = FontFamily.Monospace, fontSize = fontSize,
       color = MaterialTheme.colors.onBackground
     ),
     keyboardOptions = KeyboardOptions.Default.copy(
@@ -37,17 +44,17 @@ fun TextEditor(modifier: Modifier, text: MutableState<String>) {
     cursorBrush = SolidColor(HighOrLowlight),
     decorationBox = { innerTextField ->
       Surface(
-        shape = RoundedCornerShape(10.dp),
-        border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
+        shape = if (border) RoundedCornerShape(10.dp) else RectangleShape,
+        border = if (border) BorderStroke(1.dp, MaterialTheme.colors.secondary) else null
       ) {
         Row(
-          Modifier.background(MaterialTheme.colors.background),
+          Modifier.background(background),
           verticalAlignment = Alignment.Top
         ) {
           Box(
             Modifier
               .weight(1f)
-              .padding(vertical = 5.dp, horizontal = 7.dp)
+              .padding(vertical = 5.dp, horizontal = if (border) 7.dp else DEFAULT_PADDING)
           ) {
             innerTextField()
           }

apps/android/app/src/main/java/chat/simplex/app/views/helpers/Util.kt

@@ -1,22 +1,30 @@
 package chat.simplex.app.views.helpers
 
-import android.R.attr.factor
-import android.R.color
+import android.app.Activity
+import android.app.Application
+//import android.app.LocaleManager
+import android.content.ActivityNotFoundException
 import android.content.Context
+import android.content.res.Configuration
 import android.content.res.Resources
 import android.graphics.*
 import android.graphics.Typeface
+import android.graphics.drawable.Drawable
+import android.media.MediaMetadataRetriever
 import android.net.Uri
-import android.os.FileUtils
+import android.os.*
 import android.provider.OpenableColumns
 import android.text.Spanned
 import android.text.SpannedString
 import android.text.style.*
 import android.util.Base64
 import android.util.Log
+import android.view.View
 import android.view.ViewTreeObserver
+import android.view.inputmethod.InputMethodManager
 import androidx.annotation.StringRes
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.Saver
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.*
 import androidx.compose.ui.text.*
@@ -27,8 +35,12 @@ import androidx.compose.ui.unit.*
 import androidx.core.content.FileProvider
 import androidx.core.text.HtmlCompat
 import chat.simplex.app.*
-import chat.simplex.app.model.CIFile
+import chat.simplex.app.R
+import chat.simplex.app.model.*
 import kotlinx.coroutines.*
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import org.apache.commons.io.IOUtils
 import java.io.*
 import java.text.SimpleDateFormat
 import java.util.*
@@ -39,6 +51,9 @@ fun withApi(action: suspend CoroutineScope.() -> Unit): Job = withScope(GlobalSc
 fun withScope(scope: CoroutineScope, action: suspend CoroutineScope.() -> Unit): Job =
   scope.launch { withContext(Dispatchers.Main, action) }
 
+fun withBGApi(action: suspend CoroutineScope.() -> Unit): Job =
+  CoroutineScope(Dispatchers.Default).launch(block = action)
+
 enum class KeyboardState {
   Opened, Closed
 }
@@ -69,6 +84,9 @@ fun getKeyboardState(): State<KeyboardState> {
   return keyboardState
 }
 
+fun hideKeyboard(view: View) =
+  (SimplexApp.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).hideSoftInputFromWindow(view.windowToken, 0)
+
 // Resource to annotated string from
 // https://stackoverflow.com/questions/68549248/android-jetpack-compose-how-to-show-styled-text-from-string-resources
 fun generalGetString(id: Int): String {
@@ -215,12 +233,23 @@ private fun spannableStringToAnnotatedString(
 // maximum image file size to be auto-accepted
 const val MAX_IMAGE_SIZE: Long = 236700
 const val MAX_IMAGE_SIZE_AUTO_RCV: Long = MAX_IMAGE_SIZE * 2
-const val MAX_FILE_SIZE: Long = 8000000
+const val MAX_VOICE_SIZE_AUTO_RCV: Long = MAX_IMAGE_SIZE
+
+const val MAX_VOICE_SIZE_FOR_SENDING: Long = 94680 // 6 chunks * 15780 bytes per chunk
+const val MAX_VOICE_MILLIS_FOR_SENDING: Int = 43_000
+
+const val MAX_FILE_SIZE_SMP: Long = 8000000
+
+const val MAX_FILE_SIZE_XFTP: Long = 1_073_741_824
 
 fun getFilesDirectory(context: Context): String {
   return context.filesDir.toString()
 }
 
+fun getTempFilesDirectory(context: Context): String {
+  return "${getFilesDirectory(context)}/temp_files"
+}
+
 fun getAppFilesDirectory(context: Context): String {
   return "${getFilesDirectory(context)}/app_files"
 }
@@ -229,6 +258,11 @@ fun getAppFilePath(context: Context, fileName: String): String {
   return "${getAppFilesDirectory(context)}/$fileName"
 }
 
+fun getAppFileUri(fileName: String): Uri {
+  return Uri.parse("${getAppFilesDirectory(SimplexApp.context)}/$fileName")
+}
+
+
 fun getLoadedFilePath(context: Context, file: CIFile?): String? {
   return if (file?.filePath != null && file.loaded) {
     val filePath = getAppFilePath(context, file.filePath)
@@ -298,6 +332,14 @@ fun getFileName(context: Context, uri: Uri): String? {
   }
 }
 
+fun getAppFilePath(context: Context, uri: Uri): String? {
+  return context.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+    cursor.moveToFirst()
+    getAppFilePath(context, cursor.getString(nameIndex))
+  }
+}
+
 fun getFileSize(context: Context, uri: Uri): Long? {
   return context.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
     val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
@@ -306,12 +348,56 @@ fun getFileSize(context: Context, uri: Uri): Long? {
   }
 }
 
+fun getBitmapFromUri(uri: Uri, withAlertOnException: Boolean = true): Bitmap? {
+  return if (Build.VERSION.SDK_INT >= 28) {
+    val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, uri)
+    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(R.string.image_decoding_exception_title),
+          text = generalGetString(R.string.image_decoding_exception_desc)
+        )
+      }
+      null
+    }
+  } else {
+    BitmapFactory.decodeFile(getAppFilePath(SimplexApp.context, uri))
+  }
+}
+
+fun getDrawableFromUri(uri: Uri, withAlertOnException: Boolean = true): Drawable? {
+  return if (Build.VERSION.SDK_INT >= 28) {
+    val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, uri)
+    try {
+      ImageDecoder.decodeDrawable(source)
+    } catch (e: android.graphics.ImageDecoder.DecodeException) {
+      if (withAlertOnException) {
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(R.string.image_decoding_exception_title),
+          text = generalGetString(R.string.image_decoding_exception_desc)
+        )
+      }
+      Log.e(TAG, "Error while decoding drawable: ${e.stackTraceToString()}")
+      null
+    }
+  } else {
+    Drawable.createFromPath(getAppFilePath(SimplexApp.context, uri))
+  }
+}
+
+fun saveImage(context: Context, uri: Uri): String? {
+  val bitmap = getBitmapFromUri(uri) ?: return null
+  return saveImage(context, bitmap)
+}
+
 fun saveImage(context: Context, image: Bitmap): String? {
   return try {
     val ext = if (image.hasAlpha()) "png" else "jpg"
     val dataResized = resizeImageToDataSize(image, ext == "png", maxDataSize = MAX_IMAGE_SIZE)
-    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
-    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.$ext")
+    val fileToSave = generateNewFileName(context, "IMG", ext)
     val file = File(getAppFilePath(context, fileToSave))
     val output = FileOutputStream(file)
     dataResized.writeTo(output)
@@ -334,8 +420,7 @@ fun saveAnimImage(context: Context, uri: Uri): String? {
     }
     // Just in case the image has a strange extension
     if (ext.length < 3 || ext.length > 4) ext = "gif"
-    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
-    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.$ext")
+    val fileToSave = generateNewFileName(context, "IMG", ext)
     val file = File(getAppFilePath(context, fileToSave))
     val output = FileOutputStream(file)
     context.contentResolver.openInputStream(uri)!!.use { input ->
@@ -350,6 +435,24 @@ fun saveAnimImage(context: Context, uri: Uri): String? {
   }
 }
 
+fun saveTempImageUncompressed(image: Bitmap, asPng: Boolean): File? {
+  return try {
+    val ext = if (asPng) "png" else "jpg"
+    val tmpDir = SimplexApp.context.getDir("temp", Application.MODE_PRIVATE)
+    return File(tmpDir.absolutePath + File.separator + generateNewFileName(SimplexApp.context, "IMG", ext)).apply {
+      outputStream().use { out ->
+        image.compress(if (asPng) Bitmap.CompressFormat.PNG else Bitmap.CompressFormat.JPEG, 85, out)
+        out.flush()
+      }
+      deleteOnExit()
+      SimplexApp.context.chatModel.filesToDelete.add(this)
+    }
+  } catch (e: Exception) {
+    Log.e(TAG, "Util.kt saveTempImageUncompressed error: ${e.message}")
+    null
+  }
+}
+
 fun saveFileFromUri(context: Context, uri: Uri): String? {
   return try {
     val inputStream = context.contentResolver.openInputStream(uri)
@@ -357,7 +460,7 @@ fun saveFileFromUri(context: Context, uri: Uri): String? {
     if (inputStream != null && fileToSave != null) {
       val destFileName = uniqueCombine(context, fileToSave)
       val destFile = File(getAppFilePath(context, destFileName))
-      FileUtils.copy(inputStream, FileOutputStream(destFile))
+      IOUtils.copy(inputStream, FileOutputStream(destFile))
       destFileName
     } else {
       Log.e(chat.simplex.app.TAG, "Util.kt saveFileFromUri null inputStream")
@@ -369,15 +472,23 @@ fun saveFileFromUri(context: Context, uri: Uri): String? {
   }
 }
 
+fun generateNewFileName(context: Context, prefix: String, ext: String): String {
+  val sdf = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US)
+  sdf.timeZone = TimeZone.getTimeZone("GMT")
+  val timestamp = sdf.format(Date())
+  return uniqueCombine(context, "${prefix}_$timestamp.$ext")
+}
+
 fun uniqueCombine(context: Context, fileName: String): String {
-  fun tryCombine(fileName: String, n: Int): String {
-    val name = File(fileName).nameWithoutExtension
-    val ext = File(fileName).extension
+  val orig = File(fileName)
+  val name = orig.nameWithoutExtension
+  val ext = orig.extension
+  fun tryCombine(n: Int): String {
     val suffix = if (n == 0) "" else "_$n"
     val f = "$name$suffix.$ext"
-    return if (File(getAppFilePath(context, f)).exists()) tryCombine(fileName, n + 1) else f
+    return if (File(getAppFilePath(context, f)).exists()) tryCombine(n + 1) else f
   }
-  return tryCombine(fileName, 0)
+  return tryCombine(0)
 }
 
 fun formatBytes(bytes: Long): String {
@@ -385,9 +496,9 @@ fun formatBytes(bytes: Long): String {
     return "0 bytes"
   }
   val bytesDouble = bytes.toDouble()
-  val k = 1000.toDouble()
+  val k = 1024.toDouble()
   val units = arrayOf("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
-  val i = kotlin.math.floor(log2(bytesDouble) / log2(k))
+  val i = floor(log2(bytesDouble) / log2(k))
   val size = bytesDouble / k.pow(i)
   val unit = units[i.toInt()]
 
@@ -432,9 +543,101 @@ fun directoryFileCountAndSize(dir: String): Pair<Int, Long> { // count, size in
   return fileCount to bytes
 }
 
+fun getMaxFileSize(fileProtocol: FileProtocol): Long {
+  return when (fileProtocol) {
+    FileProtocol.XFTP -> MAX_FILE_SIZE_XFTP
+    FileProtocol.SMP -> MAX_FILE_SIZE_SMP
+  }
+}
+
+fun getBitmapFromVideo(uri: Uri, timestamp: Long? = null, random: Boolean = true): VideoPlayer.PreviewAndDuration {
+  val mmr = MediaMetadataRetriever()
+  mmr.setDataSource(SimplexApp.context, uri)
+  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.getFrameAtIndex(0)
+  }
+  mmr.release()
+  return VideoPlayer.PreviewAndDuration(image, durationMs, timestamp ?: 0)
+}
+
 fun Color.darker(factor: Float = 0.1f): Color =
   Color(max(red * (1 - factor), 0f), max(green * (1 - factor), 0f), max(blue * (1 - factor), 0f), alpha)
 
 fun ByteArray.toBase64String() = Base64.encodeToString(this, Base64.DEFAULT)
 
 fun String.toByteArrayFromBase64() = Base64.decode(this, Base64.DEFAULT)
+
+val LongRange.Companion.saver
+  get() = Saver<MutableState<LongRange>, Pair<Long, Long>>(
+    save = { it.value.first to it.value.last },
+    restore = { mutableStateOf(it.first..it.second) }
+    )
+
+/* Make sure that T class has @Serializable annotation */
+inline fun <reified T> serializableSaver(): Saver<T, *> = Saver(
+    save = { json.encodeToString(it) },
+    restore = { json.decodeFromString(it) }
+  )
+
+fun saveAppLocale(pref: SharedPreference<String?>, activity: Activity, 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) {
+      activity.applyLocale(SimplexApp.context.defaultLocale)
+    }
+    activity.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(SimplexApp.context.resources.configuration).apply { setLocale(locale) }
+  val activityConf = Configuration(resources.configuration).apply { setLocale(locale) }
+  @Suppress("DEPRECATION")
+  SimplexApp.context.resources.updateConfiguration(appConf, resources.displayMetrics)
+  @Suppress("DEPRECATION")
+  resources.updateConfiguration(activityConf, resources.displayMetrics)
+}
+
+fun UriHandler.openUriCatching(uri: String) {
+  try {
+    openUri(uri)
+  } catch (e: ActivityNotFoundException) {
+    Log.e(TAG, e.stackTraceToString())
+  }
+}
+
+fun IntSize.Companion.Saver(): Saver<IntSize, *> = Saver(
+  save = { it.width to it.height },
+  restore = { IntSize(it.first, it.second) }
+)
+
+@Composable
+fun DisposableEffectOnGone(always: () -> Unit = {}, whenDispose: () -> Unit = {}, whenGone: () -> Unit) {
+  val context = LocalContext.current
+  DisposableEffect(Unit) {
+    always()
+    val activity = context as? Activity ?: return@DisposableEffect onDispose {}
+    val orientation = activity.resources.configuration.orientation
+    onDispose {
+      whenDispose()
+      if (orientation == activity.resources.configuration.orientation) {
+        whenGone()
+      }
+    }
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/helpers/VideoPlayer.kt

@@ -0,0 +1,246 @@
+package chat.simplex.app.views.helpers
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.media.session.PlaybackState
+import android.net.Uri
+import android.util.Log
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import chat.simplex.app.*
+import chat.simplex.app.R
+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
+
+class VideoPlayer private constructor(
+  private val uri: Uri,
+  private val gallery: Boolean,
+  private val defaultPreview: Bitmap,
+  defaultDuration: Long,
+  soundEnabled: Boolean,
+  context: Context
+) {
+  companion object {
+    private val players: MutableMap<Pair<Uri, Boolean>, VideoPlayer> = mutableMapOf()
+    private val previewsAndDurations: MutableMap<Uri, PreviewAndDuration> = mutableMapOf()
+
+    fun getOrCreate(
+      uri: Uri,
+      gallery: Boolean,
+      defaultPreview: Bitmap,
+      defaultDuration: Long,
+      soundEnabled: Boolean,
+      context: Context
+    ): VideoPlayer =
+      players.getOrPut(uri to gallery) { VideoPlayer(uri, gallery, defaultPreview, defaultDuration, soundEnabled, context) }
+
+    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 }
+    }
+
+    fun release(uri: Uri, gallery: Boolean, remove: Boolean) =
+      player(uri.path, gallery)?.release(remove)
+
+    fun stopAll() {
+      players.values.forEach { it.stop() }
+    }
+
+    fun releaseAll() {
+      players.values.forEach { it.release(false) }
+      players.clear()
+      previewsAndDurations.clear()
+    }
+  }
+
+  data class PreviewAndDuration(val preview: Bitmap?, val duration: Long?, val timestamp: Long)
+
+  private val currentVolume: Float
+  val soundEnabled: MutableState<Boolean> = mutableStateOf(soundEnabled)
+  val brokenVideo: MutableState<Boolean> = mutableStateOf(false)
+  val videoPlaying: MutableState<Boolean> = mutableStateOf(false)
+  val progress: MutableState<Long> = mutableStateOf(0L)
+  val duration: MutableState<Long> = mutableStateOf(defaultDuration)
+  val preview: MutableState<Bitmap> = mutableStateOf(defaultPreview)
+
+  init {
+    setPreviewAndDuration()
+  }
+
+  val player = ExoPlayer.Builder(context,
+    DefaultRenderersFactory(context))
+    /*.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 = 1
+    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(SimplexApp.context, uri)
+    if (filepath == null || !File(filepath).exists()) {
+      Log.e(TAG, "No such file: $uri")
+      brokenVideo.value = true
+      return false
+    }
+
+    if (soundEnabled.value)  {
+      RecorderNative.stopRecording?.invoke()
+    }
+    AudioPlayer.stop()
+    stopAll()
+    if (listener.value == null) {
+      runCatching {
+        val dataSourceFactory = DefaultDataSource.Factory(SimplexApp.context, DefaultHttpDataSource.Factory())
+        val source = ProgressiveMediaSource.Factory(dataSourceFactory).createMediaSource(MediaItem.fromUri(uri))
+        player.setMediaSource(source, seek ?: 0L)
+      }.onFailure {
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(R.string.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(R.string.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
+  }
+
+  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
+  }
+
+  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 //
+        }*/
+      }
+    }
+  }
+
+  fun enableSound(enable: Boolean): Boolean {
+    if (soundEnabled.value == enable) return false
+    soundEnabled.value = enable
+    player.volume = if (enable) currentVolume else 0f
+    return true
+  }
+
+  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)
+      }
+    }
+  }
+}

apps/android/app/src/main/java/chat/simplex/app/views/newchat/AddGroupView.kt

@@ -1,6 +1,7 @@
 package chat.simplex.app.views.newchat
 
 import android.graphics.Bitmap
+import android.net.Uri
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -8,6 +9,7 @@ import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.ArrowForwardIos
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
@@ -45,7 +47,7 @@ fun AddGroupView(chatModel: ChatModel, close: () -> Unit) {
           setGroupMembers(groupInfo, chatModel)
           close.invoke()
           ModalManager.shared.showModalCloseable(true) { close ->
-            AddGroupMembersView(groupInfo, chatModel, close)
+            AddGroupMembersView(groupInfo, true, chatModel, close)
           }
         }
       }
@@ -60,8 +62,8 @@ fun AddGroupLayout(chatModelIncognito: Boolean, createGroup: (GroupProfile) -> U
   val scope = rememberCoroutineScope()
   val displayName = remember { mutableStateOf("") }
   val fullName = remember { mutableStateOf("") }
-  val profileImage = remember { mutableStateOf<String?>(null) }
-  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val chosenImage = rememberSaveable { mutableStateOf<Uri?>(null) }
+  val profileImage = rememberSaveable { mutableStateOf<String?>(null) }
   val focusRequester = remember { FocusRequester() }
 
   ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
@@ -132,7 +134,13 @@ fun AddGroupLayout(chatModelIncognito: Boolean, createGroup: (GroupProfile) -> U
           val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
           if (enabled) {
             CreateGroupButton(MaterialTheme.colors.primary, Modifier
-              .clickable { createGroup(GroupProfile(displayName.value, fullName.value, profileImage.value)) }
+              .clickable {
+                createGroup(GroupProfile(
+                  displayName = displayName.value,
+                  fullName = fullName.value,
+                  image = profileImage.value
+                ))
+              }
               .padding(8.dp))
           } else {
             CreateGroupButton(HighOrLowlight, Modifier.padding(8.dp))

apps/android/app/src/main/java/chat/simplex/app/views/newchat/NewChatSheet.kt

@@ -37,7 +37,7 @@ import kotlinx.coroutines.launch
 import kotlin.math.roundToInt
 
 @Composable
-fun NewChatSheet(chatModel: ChatModel, newChatSheetState: StateFlow<NewChatSheetState>, stopped: Boolean, closeNewChatSheet: (animated: Boolean) -> Unit) {
+fun NewChatSheet(chatModel: ChatModel, newChatSheetState: StateFlow<AnimatedViewState>, stopped: Boolean, closeNewChatSheet: (animated: Boolean) -> Unit) {
   if (newChatSheetState.collectAsState().value.isVisible()) BackHandler { closeNewChatSheet(true) }
   NewChatSheetLayout(
     newChatSheetState,
@@ -63,7 +63,7 @@ private val icons = listOf(Icons.Outlined.AddLink, Icons.Outlined.QrCode, Icons.
 
 @Composable
 private fun NewChatSheetLayout(
-  newChatSheetState: StateFlow<NewChatSheetState>,
+  newChatSheetState: StateFlow<AnimatedViewState>,
   stopped: Boolean,
   addContact: () -> Unit,
   connectViaLink: () -> Unit,
@@ -216,7 +216,7 @@ fun ActionButton(
 private fun PreviewNewChatSheet() {
   SimpleXTheme {
     NewChatSheetLayout(
-      MutableStateFlow(NewChatSheetState.VISIBLE),
+      MutableStateFlow(AnimatedViewState.VISIBLE),
       stopped = false,
       addContact = {},
       connectViaLink = {},

apps/android/app/src/main/java/chat/simplex/app/views/newchat/PasteToConnect.kt

@@ -3,6 +3,7 @@ package chat.simplex.app.views.newchat
 import android.content.ClipboardManager
 import android.content.res.Configuration
 import android.net.Uri
+import android.util.Log
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
@@ -17,6 +18,7 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat.getSystemService
 import chat.simplex.app.R
+import chat.simplex.app.TAG
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
@@ -35,10 +37,21 @@ fun PasteToConnectView(chatModel: ChatModel, close: () -> Unit) {
     connectViaLink = { connReqUri ->
       try {
         val uri = Uri.parse(connReqUri)
-        withUriAction(uri) { action ->
-          if (connectViaUri(chatModel, action, uri)) {
-            close()
+        withUriAction(uri) { linkType ->
+          val action = suspend {
+            Log.d(TAG, "connectViaUri: connecting")
+            if (connectViaUri(chatModel, linkType, uri)) {
+              close()
+            }
           }
+          if (linkType == ConnectionLinkType.GROUP) {
+            AlertManager.shared.showAlertMsg(
+              title = generalGetString(R.string.connect_via_group_link),
+              text = generalGetString(R.string.you_will_join_group),
+              confirmText = generalGetString(R.string.connect_via_link_verb),
+              onConfirm = { withApi { action() } }
+            )
+          } else action()
         }
       } catch (e: RuntimeException) {
         AlertManager.shared.showAlertMsg(

apps/android/app/src/main/java/chat/simplex/app/views/newchat/QRCode.kt

@@ -1,32 +1,100 @@
 package chat.simplex.app.views.newchat
 
 import android.graphics.Bitmap
-import androidx.compose.foundation.Image
-import androidx.compose.runtime.Composable
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
-import boofcv.alg.fiducial.qrcode.QrCodeEncoder
-import boofcv.alg.fiducial.qrcode.QrCodeGeneratorImage
+import androidx.core.graphics.*
+import androidx.core.graphics.drawable.toBitmap
+import boofcv.alg.drawing.FiducialImageEngine
+import boofcv.alg.fiducial.qrcode.*
 import boofcv.android.ConvertBitmap
 import chat.simplex.app.R
+import chat.simplex.app.SimplexApp
 import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.launch
 
 @Composable
-fun QRCode(connReq: String, modifier: Modifier = Modifier) {
-  Image(
-    bitmap = qrCodeBitmap(connReq, 1024).asImageBitmap(),
-    contentDescription = stringResource(R.string.image_descr_qr_code),
-    modifier = modifier
-  )
+fun QRCode(
+  connReq: String,
+  modifier: Modifier = Modifier,
+  tintColor: Color = Color(0xff062d56),
+  withLogo: Boolean = true
+) {
+  val context = LocalContext.current
+  val scope = rememberCoroutineScope()
+
+  BoxWithConstraints {
+    val maxWidthInPx = with(LocalDensity.current) { maxWidth.roundToPx() }
+    val qr = remember(maxWidthInPx, connReq, tintColor, withLogo) {
+      qrCodeBitmap(connReq, maxWidthInPx).replaceColor(Color.Black.toArgb(), tintColor.toArgb())
+        .let { if (withLogo) it.addLogo() else it }
+        .asImageBitmap()
+    }
+    Image(
+      bitmap = qr,
+      contentDescription = stringResource(R.string.image_descr_qr_code),
+      modifier
+        .clickable {
+          scope.launch {
+            val image = qrCodeBitmap(connReq, 1024).replaceColor(Color.Black.toArgb(), tintColor.toArgb())
+              .let { if (withLogo) it.addLogo() else it }
+            val file = saveTempImageUncompressed(image, false)
+            if (file != null) {
+              shareFile(context, "", file.absolutePath)
+            }
+          }
+        }
+    )
+  }
 }
 
-fun qrCodeBitmap(content: String, size: Int): Bitmap {
-  val qrCode = QrCodeEncoder().addAutomatic(content).fixate()
-  val renderer = QrCodeGeneratorImage(5)
+fun qrCodeBitmap(content: String, size: Int = 1024): Bitmap {
+  val qrCode = QrCodeEncoder().addAutomatic(content).setError(QrCode.ErrorLevel.L).fixate()
+  /** See [QrCodeGeneratorImage.initialize] and [FiducialImageEngine.configure] for size calculation */
+  val numModules = QrCode.totalModules(qrCode.version)
+  val borderModule = 1
+  // val calculatedFinalWidth = (pixelsPerModule * numModules) + 2 * (borderModule * pixelsPerModule)
+  // size = (x * numModules) + 2 * (borderModule * x)
+  // size / x = numModules + 2 * borderModule
+  // x = size / (numModules + 2 * borderModule)
+  val pixelsPerModule = size / (numModules + 2 * borderModule)
+  // + 1 to make it with better quality
+  val renderer = QrCodeGeneratorImage(pixelsPerModule + 1)
+  renderer.borderModule = borderModule
   renderer.render(qrCode)
-  return ConvertBitmap.grayToBitmap(renderer.gray, Bitmap.Config.RGB_565)
+  return ConvertBitmap.grayToBitmap(renderer.gray, Bitmap.Config.RGB_565).scale(size, size)
+}
+
+fun Bitmap.replaceColor(from: Int, to: Int): Bitmap {
+  val pixels = IntArray(width * height)
+  getPixels(pixels, 0, width, 0, 0, width, height)
+  var i = 0
+  while (i < pixels.size) {
+    if (pixels[i] == from) {
+      pixels[i] = to
+    }
+    i++
+  }
+  setPixels(pixels, 0, width, 0, 0, width, height)
+  return this
+}
+
+fun Bitmap.addLogo(): Bitmap = 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 = SimplexApp.context.resources.getDrawable(R.mipmap.icon_foreground, 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)
 }
 
 @Preview

apps/android/app/src/main/java/chat/simplex/app/views/newchat/ScanToConnectView.kt

@@ -3,6 +3,7 @@ package chat.simplex.app.views.newchat
 import android.Manifest
 import android.content.res.Configuration
 import android.net.Uri
+import android.util.Log
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
@@ -14,12 +15,17 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.core.net.toUri
 import chat.simplex.app.R
+import chat.simplex.app.TAG
 import chat.simplex.app.model.ChatModel
+import chat.simplex.app.model.json
 import chat.simplex.app.ui.theme.DEFAULT_PADDING
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.helpers.*
 import com.google.accompanist.permissions.rememberPermissionState
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
 
 @Composable
 fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
@@ -33,10 +39,21 @@ fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
       QRCodeScanner { connReqUri ->
         try {
           val uri = Uri.parse(connReqUri)
-          withUriAction(uri) { action ->
-            if (connectViaUri(chatModel, action, uri)) {
-              close()
+          withUriAction(uri) { linkType ->
+            val action = suspend {
+              Log.d(TAG, "connectViaUri: connecting")
+              if (connectViaUri(chatModel, linkType, uri)) {
+                close()
+              }
             }
+            if (linkType == ConnectionLinkType.GROUP) {
+              AlertManager.shared.showAlertMsg(
+                title = generalGetString(R.string.connect_via_group_link),
+                text = generalGetString(R.string.you_will_join_group),
+                confirmText = generalGetString(R.string.connect_via_link_verb),
+                onConfirm = { withApi { action() } }
+              )
+            } else action()
           }
         } catch (e: RuntimeException) {
           AlertManager.shared.showAlertMsg(
@@ -49,10 +66,34 @@ fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
   )
 }
 
-fun withUriAction(uri: Uri, run: suspend (String) -> Unit) {
+enum class ConnectionLinkType {
+  CONTACT, INVITATION, GROUP
+}
+
+@Serializable
+sealed class CReqClientData {
+  @Serializable @SerialName("group") data class Group(val groupLinkId: String): CReqClientData()
+}
+
+fun withUriAction(uri: Uri, run: suspend (ConnectionLinkType) -> Unit) {
   val action = uri.path?.drop(1)?.replace("/", "")
-  if (action == "contact" || action == "invitation") {
-    withApi { run(action) }
+  val data = uri.toString().replaceFirst("#/", "/").toUri().getQueryParameter("data")
+  val type = when {
+    data != null -> {
+      val parsed = runCatching {
+        json.decodeFromString(CReqClientData.serializer(), data)
+      }
+      when {
+        parsed.getOrNull() is CReqClientData.Group -> ConnectionLinkType.GROUP
+        else -> null
+      }
+    }
+    action == "contact" -> ConnectionLinkType.CONTACT
+    action == "invitation" -> ConnectionLinkType.INVITATION
+    else -> null
+  }
+  if (type != null) {
+    withApi { run(type) }
   } else {
     AlertManager.shared.showAlertMsg(
       title = generalGetString(R.string.invalid_contact_link),
@@ -61,14 +102,17 @@ fun withUriAction(uri: Uri, run: suspend (String) -> Unit) {
   }
 }
 
-suspend fun connectViaUri(chatModel: ChatModel, action: String, uri: Uri): Boolean {
+suspend fun connectViaUri(chatModel: ChatModel, action: ConnectionLinkType, uri: Uri): Boolean {
   val r = chatModel.controller.apiConnect(uri.toString())
   if (r) {
     AlertManager.shared.showAlertMsg(
       title = generalGetString(R.string.connection_request_sent),
       text =
-        if (action == "contact") generalGetString(R.string.you_will_be_connected_when_your_connection_request_is_accepted)
-        else generalGetString(R.string.you_will_be_connected_when_your_contacts_device_is_online)
+      when (action) {
+        ConnectionLinkType.CONTACT -> generalGetString(R.string.you_will_be_connected_when_your_connection_request_is_accepted)
+        ConnectionLinkType.INVITATION -> generalGetString(R.string.you_will_be_connected_when_your_contacts_device_is_online)
+        ConnectionLinkType.GROUP -> generalGetString(R.string.you_will_be_connected_when_group_host_device_is_online)
+      }
     )
   }
   return r

apps/android/app/src/main/java/chat/simplex/app/views/onboarding/HowItWorks.kt

@@ -36,7 +36,7 @@ fun HowItWorks(user: User?, onboardingStage: MutableState<OnboardingStage?>? = n
       val uriHandler = LocalUriHandler.current
       Text(
         annotatedStringResource(R.string.read_more_in_github_with_link),
-        modifier = Modifier.padding(bottom = 12.dp).clickable { uriHandler.openUri("https://github.com/simplex-chat/simplex-chat#readme") },
+        modifier = Modifier.padding(bottom = 12.dp).clickable { uriHandler.openUriCatching("https://github.com/simplex-chat/simplex-chat#readme") },
         lineHeight = 22.sp
       )
     } else {

apps/android/app/src/main/java/chat/simplex/app/views/onboarding/OnboardingView.kt

@@ -16,11 +16,12 @@ import kotlinx.coroutines.launch
 enum class OnboardingStage {
   Step1_SimpleXInfo,
   Step2_CreateProfile,
+  Step3_SetNotificationsMode,
   OnboardingComplete
 }
 
 @Composable
-fun CreateProfile(chatModel: ChatModel) {
+fun CreateProfile(chatModel: ChatModel, close: () -> Unit) {
   val scope = rememberCoroutineScope()
   val scrollState = rememberScrollState()
   val keyboardState by getKeyboardState()
@@ -33,7 +34,10 @@ fun CreateProfile(chatModel: ChatModel) {
         .background(color = MaterialTheme.colors.background)
         .padding(20.dp)
     ) {
-      CreateProfilePanel(chatModel)
+      CreateProfilePanel(chatModel, close)
+      LaunchedEffect(Unit) {
+        setLastVersionDefault(chatModel)
+      }
       if (savedKeyboardState != keyboardState) {
         LaunchedEffect(keyboardState) {
           scope.launch {

apps/android/app/src/main/java/chat/simplex/app/views/onboarding/SetNotificationsMode.kt

@@ -0,0 +1,68 @@
+package chat.simplex.app.views.onboarding
+
+import androidx.annotation.StringRes
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.NotificationsMode
+import chat.simplex.app.views.usersettings.changeNotificationsMode
+
+@Composable
+fun SetNotificationsMode(m: ChatModel) {
+    Column(
+      Modifier
+        .fillMaxSize()
+        .verticalScroll(rememberScrollState())
+        .padding(20.dp)
+    ) {
+      AppBarTitle(stringResource(R.string.onboarding_notifications_mode_title), false)
+      val currentMode = rememberSaveable { mutableStateOf(NotificationsMode.default) }
+      Text(stringResource(R.string.onboarding_notifications_mode_subtitle))
+      Spacer(Modifier.padding(DEFAULT_PADDING_HALF))
+      NotificationButton(currentMode, NotificationsMode.OFF, R.string.onboarding_notifications_mode_off, R.string.onboarding_notifications_mode_off_desc)
+      NotificationButton(currentMode, NotificationsMode.PERIODIC, R.string.onboarding_notifications_mode_periodic, R.string.onboarding_notifications_mode_periodic_desc)
+      NotificationButton(currentMode, NotificationsMode.SERVICE, R.string.onboarding_notifications_mode_service, R.string.onboarding_notifications_mode_service_desc)
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+      Box(Modifier.fillMaxWidth().padding(bottom = 16.dp), contentAlignment = Alignment.Center) {
+        OnboardingActionButton(R.string.use_chat, OnboardingStage.OnboardingComplete, m.onboardingStage) {
+          changeNotificationsMode(currentMode.value, m)
+        }
+      }
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+    }
+}
+
+@Composable
+private fun NotificationButton(currentMode: MutableState<NotificationsMode>, mode: NotificationsMode, @StringRes title: Int, @StringRes description: Int) {
+  TextButton(
+    onClick = { currentMode.value = mode },
+    border = BorderStroke(1.dp, color = if (currentMode.value == mode) MaterialTheme.colors.primary else HighOrLowlight.copy(alpha = 0.5f)),
+    shape = RoundedCornerShape(15.dp),
+  ) {
+    Column(Modifier.padding(bottom = 6.dp).padding(horizontal = 8.dp)) {
+      Text(
+        stringResource(title),
+        style = MaterialTheme.typography.h2,
+        fontWeight = FontWeight.Medium,
+        color = if (currentMode.value == mode) MaterialTheme.colors.primary else HighOrLowlight,
+        modifier = Modifier.padding(bottom = 4.dp)
+      )
+      Text(annotatedStringResource(description), color = MaterialTheme.colors.onBackground, lineHeight = 24.sp)
+    }
+  }
+  Spacer(Modifier.height(DEFAULT_PADDING))
+}

apps/android/app/src/main/java/chat/simplex/app/views/onboarding/SimpleXInfo.kt

@@ -18,14 +18,12 @@ import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
+import androidx.compose.ui.unit.*
 import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.model.User
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.ModalManager
-import chat.simplex.app.views.helpers.generalGetString
 
 @Composable
 fun SimpleXInfo(chatModel: ChatModel, onboarding: Boolean = true) {
@@ -48,15 +46,15 @@ fun SimpleXInfoLayout(
       .verticalScroll(rememberScrollState())
       .padding(horizontal = DEFAULT_PADDING),
   ) {
-    Box(Modifier.fillMaxWidth().padding(top = 24.dp, bottom = 8.dp), contentAlignment = Alignment.Center) {
+    Box(Modifier.fillMaxWidth().padding(top = 8.dp), contentAlignment = Alignment.Center) {
       SimpleXLogo()
     }
 
-    Text(stringResource(R.string.next_generation_of_private_messaging), style = MaterialTheme.typography.h2, modifier = Modifier.padding(bottom = 24.dp), textAlign = TextAlign.Center)
+    Text(stringResource(R.string.next_generation_of_private_messaging), style = MaterialTheme.typography.h2, modifier = Modifier.padding(bottom = 36.dp).padding(horizontal = 48.dp), textAlign = TextAlign.Center)
 
-    InfoRow(painterResource(R.drawable.privacy), R.string.privacy_redefined, R.string.first_platform_without_user_ids)
+    InfoRow(painterResource(R.drawable.privacy), R.string.privacy_redefined, R.string.first_platform_without_user_ids, width = 80.dp)
     InfoRow(painterResource(R.drawable.shield), R.string.immune_to_spam_and_abuse, R.string.people_can_connect_only_via_links_you_share)
-    InfoRow(painterResource(R.drawable.decentralized), R.string.decentralized, R.string.opensource_protocol_and_code_anybody_can_run_servers)
+    InfoRow(painterResource(if (isInDarkTheme()) R.drawable.decentralized_light else R.drawable.decentralized), R.string.decentralized, R.string.opensource_protocol_and_code_anybody_can_run_servers)
 
     Spacer(Modifier.fillMaxHeight().weight(1f))
 
@@ -90,14 +88,14 @@ fun SimpleXLogo() {
 }
 
 @Composable
-private fun InfoRow(icon: Painter, @StringRes titleId: Int, @StringRes textId: Int) {
-  Row(Modifier.padding(bottom = 20.dp), verticalAlignment = Alignment.Top) {
+private fun InfoRow(icon: Painter, @StringRes titleId: Int, @StringRes textId: Int, width: Dp = 76.dp) {
+  Row(Modifier.padding(bottom = 27.dp), verticalAlignment = Alignment.Top) {
     Image(icon, contentDescription = null, modifier = Modifier
-      .width(60.dp)
-      .padding(top = 8.dp, end = 16.dp))
+      .width(width)
+      .padding(top = 8.dp, start = 8.dp, end = 24.dp))
     Column(horizontalAlignment = Alignment.Start) {
       Text(stringResource(titleId), fontWeight = FontWeight.Bold, style = MaterialTheme.typography.h3, lineHeight = 24.sp)
-      Text(stringResource(textId), lineHeight = 24.sp, style = MaterialTheme.typography.caption)
+      Text(stringResource(textId), lineHeight = 24.sp, style = MaterialTheme.typography.body1)
     }
   }
 }
@@ -105,14 +103,14 @@ private fun InfoRow(icon: Painter, @StringRes titleId: Int, @StringRes textId: I
 @Composable
 fun OnboardingActionButton(user: User?, onboardingStage: MutableState<OnboardingStage?>, onclick: (() -> Unit)? = null) {
   if (user == null) {
-    ActionButton(R.string.create_your_profile, onboarding = OnboardingStage.Step2_CreateProfile, onboardingStage, onclick)
+    OnboardingActionButton(R.string.create_your_profile, onboarding = OnboardingStage.Step2_CreateProfile, onboardingStage, onclick)
   } else {
-    ActionButton(R.string.make_private_connection, onboarding = OnboardingStage.OnboardingComplete, onboardingStage, onclick)
+    OnboardingActionButton(R.string.make_private_connection, onboarding = OnboardingStage.OnboardingComplete, onboardingStage, onclick)
   }
 }
 
 @Composable
-private fun ActionButton(
+fun OnboardingActionButton(
   @StringRes labelId: Int,
   onboarding: OnboardingStage?,
   onboardingStage: MutableState<OnboardingStage?>,

apps/android/app/src/main/java/chat/simplex/app/views/onboarding/WhatsNewView.kt

@@ -0,0 +1,338 @@
+package chat.simplex.app.views.onboarding
+
+import android.content.res.Configuration
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun WhatsNewView(viaSettings: Boolean = false, close: () -> Unit) {
+  val currentVersion = remember { mutableStateOf(versionDescriptions.lastIndex) }
+
+  @Composable
+  fun featureDescription(icon: ImageVector, titleId: Int, descrId: Int, link: String?) {
+    @Composable
+    fun linkButton(link: String) {
+      val uriHandler = LocalUriHandler.current
+      Icon(
+        Icons.Outlined.OpenInNew, stringResource(titleId), tint = MaterialTheme.colors.primary,
+        modifier = Modifier
+          .clickable { uriHandler.openUriCatching(link) }
+      )
+    }
+
+    Column(
+      horizontalAlignment = Alignment.Start
+    ) {
+      Row(
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(8.dp)
+      ) {
+        Icon(icon, stringResource(titleId), tint = HighOrLowlight)
+        Text(
+          generalGetString(titleId),
+          maxLines = 1,
+          overflow = TextOverflow.Ellipsis,
+          style = MaterialTheme.typography.h3,
+          fontWeight = FontWeight.Medium
+        )
+        if (link != null) {
+          linkButton(link)
+        }
+      }
+      Text(generalGetString(descrId))
+    }
+  }
+
+  @Composable
+  fun pagination() {
+    Row(
+      Modifier
+        .padding(bottom = 16.dp)
+    ) {
+      if (currentVersion.value > 0) {
+        val prev = currentVersion.value - 1
+        Surface(shape = RoundedCornerShape(20.dp)) {
+          Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier
+              .clickable { currentVersion.value = prev }
+              .padding(8.dp)
+          ) {
+            Icon(Icons.Outlined.ArrowBackIosNew, "previous", tint = MaterialTheme.colors.primary)
+            Text(versionDescriptions[prev].version, color = MaterialTheme.colors.primary)
+          }
+        }
+      }
+      Spacer(Modifier.fillMaxWidth().weight(1f))
+      if (currentVersion.value < versionDescriptions.lastIndex) {
+        val next = currentVersion.value + 1
+        Surface(shape = RoundedCornerShape(20.dp)) {
+          Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(8.dp),
+            modifier = Modifier
+              .clickable { currentVersion.value = next }
+              .padding(8.dp)
+          ) {
+            Text(versionDescriptions[next].version, color = MaterialTheme.colors.primary)
+            Icon(Icons.Outlined.ArrowForwardIos, "next", tint = MaterialTheme.colors.primary)
+          }
+        }
+      }
+    }
+  }
+
+  val v = versionDescriptions[currentVersion.value]
+
+  ModalView(close = close) {
+    Column(
+      Modifier
+        .fillMaxWidth()
+        .padding(horizontal = DEFAULT_PADDING),
+      horizontalAlignment = Alignment.Start,
+      verticalArrangement = Arrangement.spacedBy(16.dp)
+    ) {
+      Text(
+        String.format(generalGetString(R.string.new_in_version), v.version),
+        Modifier
+          .fillMaxWidth()
+          .padding(DEFAULT_PADDING),
+        textAlign = TextAlign.Center,
+        overflow = TextOverflow.Ellipsis,
+        style = MaterialTheme.typography.h1,
+        fontWeight = FontWeight.Normal,
+        color = HighOrLowlight
+      )
+
+      v.features.forEach { feature ->
+        featureDescription(feature.icon, feature.titleId, feature.descrId, feature.link)
+      }
+
+      if (!viaSettings) {
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Box(
+          Modifier.fillMaxWidth(), contentAlignment = Alignment.Center
+        ) {
+          Text(
+            generalGetString(R.string.ok),
+            modifier = Modifier.clickable(onClick = close),
+            style = MaterialTheme.typography.h3,
+            color = MaterialTheme.colors.primary
+          )
+        }
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+      }
+
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+
+      pagination()
+    }
+  }
+}
+
+private data class FeatureDescription(
+  val icon: ImageVector,
+  val titleId: Int,
+  val descrId: Int,
+  val link: String? = null
+)
+
+private data class VersionDescription(
+  val version: String,
+  val features: List<FeatureDescription>
+)
+
+private val versionDescriptions: List<VersionDescription> = listOf(
+  VersionDescription(
+    version = "v4.2",
+    features = listOf(
+      FeatureDescription(
+        icon = Icons.Outlined.VerifiedUser,
+        titleId = R.string.v4_2_security_assessment,
+        descrId = R.string.v4_2_security_assessment_desc,
+        link = "https://simplex.chat/blog/20221108-simplex-chat-v4.2-security-audit-new-website.html"
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Group,
+        titleId = R.string.v4_2_group_links,
+        descrId = R.string.v4_2_group_links_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Check,
+        titleId = R.string.v4_2_auto_accept_contact_requests,
+        descrId = R.string.v4_2_auto_accept_contact_requests_desc
+      ),
+    )
+  ),
+  VersionDescription(
+    version = "v4.3",
+    features = listOf(
+      FeatureDescription(
+        icon = Icons.Outlined.Mic,
+        titleId = R.string.v4_3_voice_messages,
+        descrId = R.string.v4_3_voice_messages_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.DeleteForever,
+        titleId = R.string.v4_3_irreversible_message_deletion,
+        descrId = R.string.v4_3_irreversible_message_deletion_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.WifiTethering,
+        titleId = R.string.v4_3_improved_server_configuration,
+        descrId = R.string.v4_3_improved_server_configuration_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.VisibilityOff,
+        titleId = R.string.v4_3_improved_privacy_and_security,
+        descrId = R.string.v4_3_improved_privacy_and_security_desc
+      ),
+    )
+  ),
+  VersionDescription(
+    version = "v4.4",
+    features = listOf(
+      FeatureDescription(
+        icon = Icons.Outlined.Timer,
+        titleId = R.string.v4_4_disappearing_messages,
+        descrId = R.string.v4_4_disappearing_messages_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Pending,
+        titleId = R.string.v4_4_live_messages,
+        descrId = R.string.v4_4_live_messages_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.VerifiedUser,
+        titleId = R.string.v4_4_verify_connection_security,
+        descrId = R.string.v4_4_verify_connection_security_desc
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Translate,
+        titleId = R.string.v4_4_french_interface,
+        descrId = R.string.v4_4_french_interface_descr
+      )
+    )
+  ),
+  VersionDescription(
+    version = "v4.5",
+    features = listOf(
+      FeatureDescription(
+        icon = Icons.Outlined.ManageAccounts,
+        titleId = R.string.v4_5_multiple_chat_profiles,
+        descrId = R.string.v4_5_multiple_chat_profiles_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.EditNote,
+        titleId = R.string.v4_5_message_draft,
+        descrId = R.string.v4_5_message_draft_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.SafetyDivider,
+        titleId = R.string.v4_5_transport_isolation,
+        descrId = R.string.v4_5_transport_isolation_descr,
+        link = "https://simplex.chat/blog/20230204-simplex-chat-v4-5-user-chat-profiles.html#transport-isolation"
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Task,
+        titleId = R.string.v4_5_private_filenames,
+        descrId = R.string.v4_5_private_filenames_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Battery2Bar,
+        titleId = R.string.v4_5_reduced_battery_usage,
+        descrId = R.string.v4_5_reduced_battery_usage_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Translate,
+        titleId = R.string.v4_5_italian_interface,
+        descrId = R.string.v4_5_italian_interface_descr,
+        link = "https://github.com/simplex-chat/simplex-chat/tree/stable#translate-the-apps"
+      )
+    )
+  ),
+  VersionDescription(
+    version = "v4.6",
+    features = listOf(
+      FeatureDescription(
+        icon = Icons.Outlined.Lock,
+        titleId = R.string.v4_6_hidden_chat_profiles,
+        descrId = R.string.v4_6_hidden_chat_profiles_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Flag,
+        titleId = R.string.v4_6_group_moderation,
+        descrId = R.string.v4_6_group_moderation_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.MapsUgc,
+        titleId = R.string.v4_6_group_welcome_message,
+        descrId = R.string.v4_6_group_welcome_message_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Call,
+        titleId = R.string.v4_6_audio_video_calls,
+        descrId = R.string.v4_6_audio_video_calls_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Battery3Bar,
+        titleId = R.string.v4_6_reduced_battery_usage,
+        descrId = R.string.v4_6_reduced_battery_usage_descr
+      ),
+      FeatureDescription(
+        icon = Icons.Outlined.Translate,
+        titleId = R.string.v4_6_chinese_spanish_interface,
+        descrId = R.string.v4_6_chinese_spanish_interface_descr,
+        link = "https://github.com/simplex-chat/simplex-chat/tree/stable#translate-the-apps"
+      )
+    )
+  ),
+)
+
+private val lastVersion = versionDescriptions.last().version
+
+fun setLastVersionDefault(m: ChatModel) {
+  m.controller.appPrefs.whatsNewVersion.set(lastVersion)
+}
+
+fun shouldShowWhatsNew(m: ChatModel): Boolean {
+  val v = m.controller.appPrefs.whatsNewVersion.get()
+  setLastVersionDefault(m)
+  return v != lastVersion
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewWhatsNewView() {
+  SimpleXTheme {
+    WhatsNewView(
+      viaSettings = true,
+      close = {}
+    )
+  }
+}