4.6.1-beta.2: Android 111, iOS 138

* terminal: autocomplete contacts, groups and commands

* autocomplete for commands and member names

* update commands

* show variants

* improve

* improve

* do not show user in contacts, better state machine for tab states

* update CI runners

.github/workflows/build.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - master
       - stable
+      - users
     tags:
       - "v*"
   pull_request:
@@ -49,50 +50,79 @@ jobs:
       matrix:
         include:
           - os: ubuntu-20.04
-            cache_path: ~/.stack
+            cache_path: ~/.cabal/store
             asset_name: simplex-chat-ubuntu-20_04-x86-64
-          - os: ubuntu-18.04
-            cache_path: ~/.stack
-            asset_name: simplex-chat-ubuntu-18_04-x86-64
+          - os: ubuntu-22.04
+            cache_path: ~/.cabal/store
+            asset_name: simplex-chat-ubuntu-22_04-x86-64
           - os: macos-latest
-            cache_path: ~/.stack
+            cache_path: ~/.cabal/store
             asset_name: simplex-chat-macos-x86-64
           - os: windows-latest
-            cache_path: C:/sr
+            cache_path: C:/cabal
             asset_name: simplex-chat-windows-x86-64
     steps:
       - name: Clone project
         uses: actions/checkout@v2
 
-      - name: Setup Stack
+      - name: Setup Haskell
         uses: haskell/actions/setup@v1
         with:
-          ghc-version: '8.10.7'
-          enable-stack: true
-          stack-version: 'latest'
+          ghc-version: "8.10.7"
+          cabal-version: "latest"
 
       - name: Cache dependencies
         uses: actions/cache@v2
         with:
-          path: ${{ matrix.cache_path }}
-          key: ${{ matrix.os }}-${{ hashFiles('stack.yaml') }}
+          path: |
+            ${{ matrix.cache_path }}
+            dist-newstyle
+          key: ${{ matrix.os }}-${{ hashFiles('cabal.project', 'simplex-chat.cabal') }}
 
       # / Unix
 
+      - name: Unix prepare cabal.project.local for Mac
+        if: matrix.os == 'macos-latest'
+        shell: bash
+        run: |
+          echo "ignore-project: False"                                      >> cabal.project.local
+          echo "package direct-sqlcipher"                                   >> cabal.project.local
+          echo "    extra-include-dirs: /usr/local/opt/openssl@1.1/include" >> cabal.project.local
+          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-22.04'
+        shell: bash
+        run: |
+          echo "ignore-project: False"    >> cabal.project.local
+          echo "package direct-sqlcipher" >> cabal.project.local
+          echo "    flags: +openssl"      >> cabal.project.local
+
       - name: Unix build
         id: unix_build
         if: matrix.os != 'windows-latest'
         shell: bash
         run: |
-          stack build --test
-          echo "::set-output name=local_install_root::$(stack path --local-install-root)"
+          cabal build --enable-tests
+          echo "::set-output name=bin_path::$(cabal list-bin simplex-chat)"
+
+      - name: Unix test
+        if: matrix.os != 'windows-latest'
+        timeout-minutes: 30
+        shell: bash
+        run: cabal test --test-show-details=direct
 
       - name: Unix upload binary to release
         if: startsWith(github.ref, 'refs/tags/v') && matrix.os != 'windows-latest'
         uses: svenstaro/upload-release-action@v2
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ${{ steps.unix_build.outputs.local_install_root }}/bin/simplex-chat
+          file: ${{ steps.unix_build.outputs.bin_path }}
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 
@@ -102,25 +132,23 @@ jobs:
 
       # * In powershell multiline commands do not fail if individual commands fail - https://github.community/t/multiline-commands-on-windows-do-not-fail-if-individual-commands-fail/16753
       # * And GitHub Actions does not support parameterizing shell in a matrix job - https://github.community/t/using-matrix-to-specify-shell-is-it-possible/17065
-      # * So we're running a separate set of actions for Windows build
 
-      # TODO run tests on Windows
       - name: Windows build
         id: windows_build
         if: matrix.os == 'windows-latest'
         shell: cmd
         run: |
-          stack build
-          stack path --local-install-root > tmp_file
-          set /p local_install_root= < tmp_file
-          echo ::set-output name=local_install_root::%local_install_root%
+          cabal build --enable-tests
+          cabal list-bin simplex-chat > tmp_bin_path
+          set /p bin_path= < tmp_bin_path
+          echo ::set-output name=bin_path::%bin_path%
 
       - name: Windows upload binary to release
         if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
         uses: svenstaro/upload-release-action@v2
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ${{ steps.windows_build.outputs.local_install_root }}\bin\simplex-chat.exe
+          file: ${{ steps.windows_build.outputs.bin_path }}
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 

.github/workflows/web.yml

@@ -0,0 +1,38 @@
+name: Build Eleventy
+
+on:
+  push:
+    branches:
+      - master
+      - stable
+    paths:
+      - website/**
+      - images/**
+      - blog/**
+      - .github/workflows/web.yml
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [12.x]
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install dependencies & build
+        run: |
+          ./website/web.sh
+
+      - name: Deploy
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          publish_dir: ./website/_site
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -42,4 +42,37 @@ 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
+website/package/generated*
+
+# Ignore build tool output, e.g. code coverage
+website/.nyc_output/
+website/coverage/
+
+# Ignore API documentation
+website/api-docs/
+
+# Ignore folders from source code editors
+website/.vscode
+website/.idea
+
+# Ignore eleventy output when doing manual tests
+website/_site/
+
+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,13 +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.
+
+## 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
 
@@ -34,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
 
@@ -71,48 +170,38 @@ 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
 
-Selected updates:
+Recent updates:
 
-[Jul 23, 2022. v3.1-beta: access via Tor SOCKS5 proxy in terminal app, join and leave chat groups in mobile apps, up to 90x reduced battery and traffic usage, docker configurations for self-hosted servers](./blog/20220723-simplex-chat-v3.1-tor-groups-efficiency.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).
 
-[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)
+[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).
 
-[May 11, 2022. v2.0 released - sending images and files in mobile apps](./blog/20220511-simplex-chat-v2-images-files.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).
 
-[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.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).
 
-[Jan 12, 2022. SimpleX v1 released: the only messaging and application platform without user identities](./20220112-simplex-chat-v1-released.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
 curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/stable/install.sh | bash
 ```
 
-or to install v3.1.0-beta.0 that supports accessing SimpleX servers via SOCKS5 proxy:
-
-```
-curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/stable/install.sh | bash -s -- v3.1.0-beta.0
-```
-
 Once the chat client is installed, simply run `simplex-chat` from your terminal.
 
 ![simplex-chat](./images/connection.gif)
@@ -129,7 +218,9 @@ Unlike federated networks, the server nodes **do not have records of the users**
 
 Only the client devices have information about users, their contacts and groups.
 
-See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information on platform objectives and technical design.
+See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/overview-tjr.md) for more information on platform objectives and technical design.
+
+See [SimpleX Chat Protocol](./docs/protocol/simplex-chat.md) for the format of messages sent between chat clients over [SimpleX Messaging Protocol](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/simplex-messaging.md).
 
 ## Privacy: technical details and limitations
 
@@ -137,31 +228,32 @@ 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 bi-directional 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.
+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).
-5. Several levels of content padding to the fixed size - server blocks inside TLS and message content inside each of 3 encrypted envelopes are padded to a constant size, to prevent any correlation by message size.
-6. Starting from v2 of SMP protocol (the current version is v4) all message metadata, including the time message was received by the server (rounded to a second) is sent to the recipients inside an encrypted envelope, so even if TLS is compromised it cannot be observed.
+5. Several levels of content padding to frustrate message size attacks.
+6. Starting from v2 of SMP protocol (the current version is v4) all message metadata, including the time when the message was received by the server (rounded to a second) is sent to the recipients inside an encrypted envelope, so even if TLS is compromised it cannot be observed.
 7. Only TLS 1.2/1.3 are allowed for client-server connections, limited to cryptographic algorithms: CHACHA20POLY1305_SHA256, Ed25519/Ed448, Curve25519/Curve448.
 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. Access to messaging servers via Tor. Currently it is supported only for [terminal CLI clients](./docs/CLI.md); mobile clients access servers via public Internet, and the servers can observe IP addresses of the clients. Depending which platform you use, you might be able to configure access via Tor independently. The servers provided by SimpleX Chat do not correlate users by or log IP addresses, and you can use your own servers, but in some scenarios that may be not a sufficient level of privacy.
-2. 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).
-3. Local database encryption. Currently the local chat database stored on your device is not encrypted.
-4. Message "mixing" - adding latency to message delivery, to protect against traffic correlation by message time.
-5. Independent implementation audit.
+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.
 
 ## For developers
 
-We plan that the SimpleX platform will grow into the platform supporting any distributed Internet application. This will allow you to build any service that people can access via chat, with custom web-based UI widgets that anybody with basic HTML/CSS/JavaScript knowledge can create in a few hours.
+You can:
 
-You already can:
-
-- use SimpleX Chat library to integrate chat functionality into your apps.
-- use SimpleX Chat bot templates in Haskell to build your own chat bot services (TypeScript SDK is coming soon).
+- 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 [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.
 
@@ -178,52 +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 groups in mobile apps (in progress).
-- 🏗 Connecting to messaging servers via Tor (in progress).
-- 🏗 Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (in progress).
-- Chat database encryption.
-- Disappearing messages, with mutual agreement.
+- ✅ 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.
+- ✅ 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.
-- SMP protocol improvements:
-  - SMP queue redundancy and rotation.
-  - Message delivery confirmation.
-  - Supporting the same profile on multiple devices.
+- 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.
+- 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](monero:8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt): 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+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
 
@@ -237,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/.gitignore

@@ -9,9 +9,12 @@
 /.idea/assetWizardSettings.xml
 /.idea/deploymentTargetDropDown.xml
 /.idea/misc.xml
+/.idea/uiDesigner.xml
+/.idea/kotlinc.xml
 .DS_Store
 /build
 /captures
 .externalNativeBuild
 .cxx
 local.properties
+app/src/main/cpp/libs/

apps/android/.idea/codeStyles/Project.xml

@@ -13,7 +13,9 @@
     <codeStyleSettings language="XML">
       <option name="FORCE_REARRANGE_MODE" value="1" />
       <indentOptions>
+        <option name="INDENT_SIZE" value="2" />
         <option name="CONTINUATION_INDENT_SIZE" value="4" />
+        <option name="TAB_SIZE" value="2" />
       </indentOptions>
       <arrangement>
         <rules>

apps/android/.idea/codeStyles/codeStyleConfig.xml

@@ -1,6 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
     <option name="USE_PER_PROJECT_SETTINGS" value="true" />
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
   </state>
 </component>

apps/android/app/build.gradle

@@ -9,15 +9,12 @@ android {
 
     defaultConfig {
         applicationId "chat.simplex.app"
-        minSdk 29
+        minSdk 26
         targetSdk 32
-        versionCode 48
-        versionName "3.1"
+        versionCode 111
+        versionName "4.6.1-beta.2"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        ndk {
-            abiFilters 'arm64-v8a'
-        }
         vectorDrawables {
             useSupportLibrary true
         }
@@ -26,9 +23,19 @@ android {
                 cppFlags ''
             }
         }
+        manifestPlaceholders.app_name = "@string/app_name"
+        manifestPlaceholders.provider_authorities = "chat.simplex.app.provider"
+        manifestPlaceholders.extract_native_libs = compression_level != "0"
     }
 
     buildTypes {
+        debug {
+            applicationIdSuffix "$application_id_suffix"
+            debuggable new Boolean("$enable_debuggable")
+            manifestPlaceholders.app_name = "$app_name"
+            // Provider can't be the same for different apps on the same device
+            manifestPlaceholders.provider_authorities = "chat.simplex.app${application_id_suffix}.provider"
+        }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
@@ -64,6 +71,29 @@ android {
         resources {
             excludes += '/META-INF/{AL2.0,LGPL2.1}'
         }
+        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
+                }
+            }
+        }
     }
 }
 
@@ -83,6 +113,7 @@ dependencies {
     implementation "androidx.navigation:navigation-compose:2.4.1"
     implementation "com.google.accompanist:accompanist-insets:0.23.0"
     implementation 'androidx.webkit:webkit:1.4.0'
+    implementation "com.godaddy.android.colorpicker:compose-color-picker:0.4.2"
 
     def work_version = "2.7.1"
     implementation "androidx.work:work-runtime-ktx:$work_version"
@@ -100,6 +131,7 @@ dependencies {
 
     //Camera Permission
     implementation "com.google.accompanist:accompanist-permissions:0.23.0"
+    implementation "com.google.accompanist:accompanist-pager:0.25.1"
 
     // Link Previews
     implementation 'org.jsoup:jsoup:1.13.1'
@@ -107,9 +139,85 @@ dependencies {
     // Biometric authentication
     implementation 'androidx.biometric:biometric:1.2.0-alpha04'
 
+    // GIFs support
+    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'
     androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_version"
     debugImplementation "androidx.compose.ui:ui-tooling:$compose_version"
 }
+
+// Don't do anything if no compression is needed
+if (compression_level != "0") {
+    tasks.whenTaskAdded { task ->
+        if (task.name == 'packageDebug') {
+            task.finalizedBy compressApk
+        } else if (task.name == 'packageRelease') {
+            task.finalizedBy compressApk
+        }
+    }
+}
+
+tasks.register("compressApk") {
+    doLast {
+        def isRelease = gradle.getStartParameter().taskNames.find({ it.toLowerCase().contains("release") }) != null
+        def buildType
+        if (isRelease) {
+            buildType = "release"
+        } else {
+            buildType = "debug"
+        }
+        def javaHome = System.properties['java.home'] ?: org.gradle.internal.jvm.Jvm.current().getJavaHome()
+        def sdkDir = android.getSdkDirectory().getAbsolutePath()
+        def keyAlias = ""
+        def keyPassword = ""
+        def storeFile = ""
+        def storePassword = ""
+        if (project.properties['android.injected.signing.key.alias'] != null) {
+            keyAlias = project.properties['android.injected.signing.key.alias']
+            keyPassword = project.properties['android.injected.signing.key.password']
+            storeFile = project.properties['android.injected.signing.store.file']
+            storePassword = project.properties['android.injected.signing.store.password']
+        } else if (android.signingConfigs.hasProperty(buildType)) {
+            def gradleConfig = android.signingConfigs[buildType]
+            keyAlias = gradleConfig.keyAlias
+            keyPassword = gradleConfig.keyPassword
+            storeFile = gradleConfig.storeFile
+            storePassword = gradleConfig.storePassword
+        } else {
+            // There is no signing config for current build type, can't sign the apk
+            println("No signing configs for this build type: $buildType")
+            return
+        }
+
+        def outputDir = tasks["package${buildType.capitalize()}"].outputs.files.last()
+
+        exec {
+            workingDir '../../../scripts/android'
+            setEnvironment(['JAVA_HOME': "$javaHome"])
+            commandLine './compress-and-sign-apk.sh',  \
+                     "$compression_level",  \
+                     "$outputDir",  \
+                     "$sdkDir",  \
+                     "$storeFile",  \
+                     "$storePassword",  \
+                     "$keyAlias",  \
+                     "$keyPassword"
+        }
+
+        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
+        // project.properties.each { k, v -> println "$k -> $v" }
+    }
+}

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

@@ -24,17 +24,21 @@
   <application
       android:name="SimplexApp"
       android:allowBackup="true"
+      android:fullBackupOnly="true"
+      android:backupAgent="BackupAgent"
       android:icon="@mipmap/icon"
-      android:label="@string/app_name"
+      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
         android:name=".MainActivity"
         android:launchMode="singleTask"
         android:exported="true"
-        android:label="@string/app_name"
+        android:label="${app_name}"
         android:windowSoftInputMode="adjustResize"
         android:theme="@style/Theme.SimpleX">
       <intent-filter>
@@ -62,13 +66,22 @@
         <data android:pathPrefix="/invitation" />
         <data android:pathPrefix="/contact" />
       </intent-filter>
+      <!-- Receive files from other apps -->
+      <intent-filter>
+        <action android:name="android.intent.action.SEND" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="*/*" />
+      </intent-filter>
+      <intent-filter>
+        <action android:name="android.intent.action.SEND_MULTIPLE" />
+        <category android:name="android.intent.category.DEFAULT" />
+        <data android:mimeType="image/*" />
+      </intent-filter>
     </activity>
 
     <activity-alias
         android:name=".MainActivity_default"
-        android:launchMode="singleTask"
         android:exported="true"
-        android:label="@string/app_name"
         android:icon="@mipmap/icon"
         android:enabled="true"
         android:targetActivity=".MainActivity">
@@ -80,9 +93,7 @@
 
     <activity-alias
         android:name=".MainActivity_dark_blue"
-        android:launchMode="singleTask"
         android:exported="true"
-        android:label="@string/app_name"
         android:icon="@mipmap/icon_dark_blue"
         android:enabled="false"
         android:targetActivity=".MainActivity">
@@ -94,11 +105,13 @@
 
 
     <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"
-        android:authorities="chat.simplex.app.provider"
+        android:authorities="${provider_authorities}"
         android:exported="false"
         android:grantUriPermissions="true">
       <meta-data
@@ -106,6 +119,12 @@
           android:resource="@xml/file_paths" />
     </provider>
 
+    <!-- NtfManager action processing (buttons in notifications) -->
+    <receiver
+        android:name=".model.NtfManager$NtfActionReceiver"
+        android:enabled="true"
+        android:exported="false" />
+
     <!-- SimplexService foreground service -->
     <service
         android:name=".SimplexService"

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:5349"] },
-        { urls: ["turn:turn.simplex.im:5349"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
+        { urls: ["stun:stun.simplex.im:443"] },
+        { 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));
@@ -495,6 +512,7 @@ function callCryptoFunction() {
     const initialPlainTextRequired = {
         key: 10,
         delta: 3,
+        empty: 1,
     };
     const IV_LENGTH = 12;
     function encryptFrame(key) {
@@ -505,7 +523,9 @@ function callCryptoFunction() {
             const initial = data.subarray(0, n);
             const plaintext = data.subarray(n, data.byteLength);
             try {
-                const ciphertext = new Uint8Array(plaintext.length ? await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext) : 0);
+                const ciphertext = plaintext.length
+                    ? new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext))
+                    : new Uint8Array(0);
                 frame.data = concatN(initial, ciphertext, iv).buffer;
                 controller.enqueue(frame);
             }
@@ -523,7 +543,9 @@ function callCryptoFunction() {
             const ciphertext = data.subarray(n, data.byteLength - IV_LENGTH);
             const iv = data.subarray(data.byteLength - IV_LENGTH, data.byteLength);
             try {
-                const plaintext = new Uint8Array(ciphertext.length ? await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext) : 0);
+                const plaintext = ciphertext.length
+                    ? new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext))
+                    : new Uint8Array(0);
                 frame.data = concatN(initial, plaintext).buffer;
                 controller.enqueue(frame);
             }

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

@@ -53,7 +53,6 @@ add_library( support SHARED IMPORTED )
 set_target_properties( support PROPERTIES IMPORTED_LOCATION
     ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libsupport.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.

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);
@@ -22,20 +33,37 @@ Java_chat_simplex_app_SimplexAppKt_initHS(__unused JNIEnv *env, __unused jclass
 }
 
 // from simplex-chat
-typedef void* chat_ctrl;
+typedef long* chat_ctrl;
 
-extern chat_ctrl chat_init(const char *path);
+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);
+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 jlong JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatInit(JNIEnv *env, __unused jclass clazz, jstring datadir) {
-    const char *_data = (*env)->GetStringUTFChars(env, datadir, JNI_FALSE);
-    jlong res = (jlong)chat_init(_data);
-    (*env)->ReleaseStringUTFChars(env, datadir, _data);
-    return res;
+JNIEXPORT jobjectArray JNICALL
+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, _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);
+    // Java's String
+    (*env)->SetObjectArrayElement(env, ret, 0, res);
+    // Java's Long
+    (*env)->SetObjectArrayElement(env, ret, 1,
+        (*env)->NewObject(env, (*env)->FindClass(env, "java/lang/Long"),
+        (*env)->GetMethodID(env, (*env)->FindClass(env, "java/lang/Long"), "<init>", "(J)V"),
+        _ctrl));
+    return ret;
 }
 
 JNIEXPORT jstring JNICALL
@@ -63,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,55 +3,83 @@ package chat.simplex.app
 import android.app.Application
 import android.content.Intent
 import android.net.Uri
-import android.os.Bundle
+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 androidx.work.*
 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
 import chat.simplex.app.views.call.ActiveCallView
 import chat.simplex.app.views.call.IncomingCallAlertView
 import chat.simplex.app.views.chat.ChatView
-import chat.simplex.app.views.chatlist.ChatListView
-import chat.simplex.app.views.chatlist.openChat
+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 java.util.concurrent.TimeUnit
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.distinctUntilChanged
 
-class MainActivity: FragmentActivity(), LifecycleEventObserver {
+class MainActivity: FragmentActivity() {
+  companion object {
+    /**
+     * We don't want these values to be bound to Activity lifecycle since activities are changed often, for example, when a user
+     * clicks on new message in notification. In this case savedInstanceState will be null (this prevents restoring the values)
+     * See [SimplexService.onTaskRemoved] for another part of the logic which nullifies the values when app closed by the user
+     * */
+    val userAuthorized = mutableStateOf<Boolean?>(null)
+    val enteredBackground = mutableStateOf<Long?>(null)
+    // Remember result and show it after orientation change
+    private val laFailed = mutableStateOf(false)
+
+    fun clearAuthState() {
+      userAuthorized.value = null
+      enteredBackground.value = null
+    }
+  }
   private val vm by viewModels<SimplexViewModel>()
-  private val chatController by lazy { (application as SimplexApp).chatController }
-  private val userAuthorized = mutableStateOf<Boolean?>(null)
-  private val enteredBackground = mutableStateOf<Long?>(null)
-  private val laFailed = mutableStateOf(false)
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
     // testJson()
     val m = vm.chatModel
-    processNotificationIntent(intent, m)
+    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) {
+      processNotificationIntent(intent, m)
+      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(
@@ -70,28 +98,58 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
         }
       }
     }
-    schedulePeriodicServiceRestartWorker()
+    SimplexApp.context.schedulePeriodicServiceRestartWorker()
+    SimplexApp.context.schedulePeriodicWakeUp()
   }
 
   override fun onNewIntent(intent: Intent?) {
     super.onNewIntent(intent)
     processIntent(intent, vm.chatModel)
+    processExternalIntent(intent, vm.chatModel)
   }
 
-  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
-    withApi {
-      when (event) {
-        Lifecycle.Event.ON_STOP -> {
-          enteredBackground.value = elapsedRealtime()
-        }
-        Lifecycle.Event.ON_START -> {
-          val enteredBackgroundVal = enteredBackground.value
-          if (enteredBackgroundVal == null || elapsedRealtime() - enteredBackgroundVal >= 30 * 1e+3) {
-            runAuthenticate()
-          }
-        }
-        else -> {}
-      }
+  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() {
+    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()
+      laFailed.value = true
+    }
+    if (!onBackPressedDispatcher.hasEnabledCallbacks()) {
+      // Drop shared content
+      SimplexApp.context.chatModel.sharedContent.value = null
     }
   }
 
@@ -102,53 +160,34 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
     } 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()
-            }
-          }
+          )
         }
-      )
+      }
     }
   }
 
-  private fun schedulePeriodicServiceRestartWorker() {
-    val workerVersion = chatController.appPrefs.autoRestartWorkerVersion.get()
-    val workPolicy = if (workerVersion == SimplexService.SERVICE_START_WORKER_VERSION) {
-      Log.d(TAG, "ServiceStartWorker version matches: choosing KEEP as existing work policy")
-      ExistingPeriodicWorkPolicy.KEEP
-    } else {
-      Log.d(TAG, "ServiceStartWorker version DOES NOT MATCH: choosing REPLACE as existing work policy")
-      chatController.appPrefs.autoRestartWorkerVersion.set(SimplexService.SERVICE_START_WORKER_VERSION)
-      ExistingPeriodicWorkPolicy.REPLACE
-    }
-    val work = PeriodicWorkRequestBuilder<SimplexService.ServiceStartWorker>(SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES, TimeUnit.MINUTES)
-      .addTag(SimplexService.TAG)
-      .addTag(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC)
-      .build()
-    Log.d(TAG, "ServiceStartWorker: Scheduling period work every ${SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES} minutes")
-    WorkManager.getInstance(this)?.enqueueUniquePeriodicWork(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC, workPolicy, work)
-  }
-
   private fun setPerformLA(on: Boolean) {
     vm.chatModel.controller.appPrefs.laNoticeShown.set(true)
     if (on) {
@@ -172,15 +211,9 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
             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
@@ -205,15 +238,9 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
             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
@@ -240,14 +267,13 @@ fun MainPage(
   setPerformLA: (Boolean) -> Unit,
   showLANotice: () -> Unit
 ) {
-  // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
-  var chatsAccessAuthorized by remember { 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)
   }
+  LaunchedEffect(chatModel.chatDbStatus.value) {
+    showChatDatabaseError = chatModel.chatDbStatus.value != DBMigrationResult.OK && chatModel.chatDbStatus.value != null
+  }
+
   var showAdvertiseLAAlert by remember { mutableStateOf(false) }
   LaunchedEffect(showAdvertiseLAAlert) {
     if (
@@ -273,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()
@@ -293,10 +319,15 @@ fun MainPage(
     val onboarding = chatModel.onboardingStage.value
     val userCreated = chatModel.userCreated.value
     when {
+      showChatDatabaseError -> {
+        chatModel.chatDbStatus.value?.let {
+          DatabaseErrorView(chatModel.chatDbStatus, chatModel.controller.appPrefs)
+        }
+      }
       onboarding == null || userCreated == null -> SplashView()
-      !chatsAccessAuthorized -> {
+      userAuthorized.value != true -> {
         if (chatModel.controller.appPrefs.performLA.get() && laFailed.value) {
-          retryAuthView()
+          authView()
         } else {
           SplashView()
         }
@@ -306,17 +337,55 @@ fun MainPage(
           if (chatModel.showCallView.value) ActiveCallView(chatModel)
           else {
             showAdvertiseLAAlert = true
-            val stopped = chatModel.chatRunning.value == false
-            if (chatModel.chatId.value == null) ChatListView(chatModel, setPerformLA, stopped)
-            else ChatView(chatModel)
+            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)
+                }
+              }
+            }
           }
         }
       }
-      onboarding == OnboardingStage.Step1_SimpleXInfo ->
-        Box(Modifier.padding(horizontal = 20.dp)) {
-          SimpleXInfo(chatModel, onboarding = true)
-        }
-      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
+      onboarding == OnboardingStage.Step1_SimpleXInfo -> SimpleXInfo(chatModel, onboarding = true)
+      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel) {}
+      onboarding == OnboardingStage.Step3_SetNotificationsMode -> SetNotificationsMode(chatModel)
     }
     ModalManager.shared.showInView()
     val invitation = chatModel.activeCallInvitation.value
@@ -326,20 +395,33 @@ 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 {
+          awaitChatStartedIfNeeded(chatModel)
+          if (userId != null && userId != chatModel.currentUser.value?.userId && chatModel.currentUser.value != null) {
+            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 {
+        awaitChatStartedIfNeeded(chatModel)
+        if (userId != null && userId != chatModel.currentUser.value?.userId && chatModel.currentUser.value != null) {
+          chatModel.controller.changeActiveUser(userId, null)
+        }
+        chatModel.chatId.value = null
+        chatModel.clearOverlays.value = true
+      }
     }
     NtfManager.AcceptCallAction -> {
       val chatId = intent.getStringExtra("chatId")
@@ -365,35 +447,80 @@ fun processIntent(intent: Intent?, chatModel: ChatModel) {
   }
 }
 
+fun processExternalIntent(intent: Intent?, chatModel: ChatModel) {
+  when (intent?.action) {
+    Intent.ACTION_SEND -> {
+      // Close active chat and show a list of chats
+      chatModel.chatId.value = null
+      chatModel.clearOverlays.value = true
+      when {
+        "text/plain" == intent.type -> intent.getStringExtra(Intent.EXTRA_TEXT)?.let {
+          chatModel.sharedContent.value = SharedContent.Text(it)
+        }
+        intent.type?.startsWith("image/") == true -> (intent.getParcelableExtra<Parcelable>(Intent.EXTRA_STREAM) as? Uri)?.let {
+          chatModel.sharedContent.value = SharedContent.Images(intent.getStringExtra(Intent.EXTRA_TEXT) ?: "", listOf(it))
+        } // All other mime types
+        else -> (intent.getParcelableExtra<Parcelable>(Intent.EXTRA_STREAM) as? Uri)?.let {
+          chatModel.sharedContent.value = SharedContent.File(intent.getStringExtra(Intent.EXTRA_TEXT) ?: "", it)
+        }
+      }
+    }
+    Intent.ACTION_SEND_MULTIPLE -> {
+      // Close active chat and show a list of chats
+      chatModel.chatId.value = null
+      chatModel.clearOverlays.value = true
+      when {
+        intent.type?.startsWith("image/") == true -> (intent.getParcelableArrayListExtra<Parcelable>(Intent.EXTRA_STREAM) as? List<Uri>)?.let {
+          chatModel.sharedContent.value = SharedContent.Images(intent.getStringExtra(Intent.EXTRA_TEXT) ?: "", it)
+        } // All other mime types
+        else -> {}
+      }
+    }
+  }
+}
+
 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)
           }
         }
       )
     }
   }
 }
+
+suspend fun awaitChatStartedIfNeeded(chatModel: ChatModel, timeout: Long = 30_000) {
+  // Still decrypting database
+  if (chatModel.chatRunning.value == null) {
+    val step = 50L
+    for (i in 0..(timeout / step)) {
+      if (chatModel.chatRunning.value == true || chatModel.onboardingStage.value == OnboardingStage.Step1_SimpleXInfo) {
+        break
+      }
+      delay(step)
+    }
+  }
+}
+
 //fun testJson() {
 //  val str: String = """
 //  """.trimIndent()

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

@@ -4,14 +4,17 @@ import android.app.Application
 import android.net.LocalServerSocket
 import android.util.Log
 import androidx.lifecycle.*
+import androidx.work.*
 import chat.simplex.app.model.*
-import chat.simplex.app.views.helpers.getFilesDirectory
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.onboarding.OnboardingStage
-import java.io.BufferedReader
-import java.io.InputStreamReader
+import chat.simplex.app.views.usersettings.NotificationsMode
+import kotlinx.coroutines.*
+import kotlinx.serialization.decodeFromString
+import java.io.*
 import java.util.*
 import java.util.concurrent.Semaphore
+import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
 
 const val TAG = "SIMPLEX"
@@ -23,21 +26,60 @@ external fun pipeStdOutToSocket(socketName: String) : Int
 
 // SimpleX API
 typealias ChatCtrl = Long
-external fun chatInit(path: String): ChatCtrl
+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 {
-  val chatController: ChatController by lazy {
-    val ctrl = chatInit(getFilesDirectory(applicationContext))
-    ChatController(ctrl, ntfManager, applicationContext, appPreferences)
+  lateinit var chatController: ChatController
+
+  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 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) }
+    val ctrl = if (res is DBMigrationResult.OK) {
+      migrated[1] as Long
+    } else null
+    if (::chatController.isInitialized) {
+      chatController.ctrl = ctrl
+    } else {
+      chatController = ChatController(ctrl, ntfManager, applicationContext, appPreferences)
+    }
+    chatModel.chatDbEncrypted.value = dbKey != ""
+    chatModel.chatDbStatus.value = res
+    if (res != DBMigrationResult.OK) {
+      Log.d(TAG, "Unable to migrate successfully: $res")
+    } else if (startChat) {
+      // If we migrated successfully means previous re-encryption process on database level finished successfully too
+      if (appPreferences.encryptionStartedAt.get() != null) appPreferences.encryptionStartedAt.set(null)
+      withApi {
+        val user = chatController.apiGetActiveUser()
+        if (user == null) {
+          chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+        } else {
+          chatController.startChat(user)
+          chatController.showBackgroundServiceNoticeIfNeeded()
+          if (appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name)
+            SimplexService.start(applicationContext)
+        }
+      }
+    }
   }
 
-  val chatModel: ChatModel by lazy {
-    chatController.chatModel
-  }
+  val chatModel: ChatModel
+    get() = chatController.chatModel
 
   private val ntfManager: NtfManager by lazy {
     NtfManager(applicationContext, appPreferences)
@@ -50,45 +92,118 @@ class SimplexApp: Application(), LifecycleEventObserver {
   override fun onCreate() {
     super.onCreate()
     context = this
+    initChatController()
     ProcessLifecycleOwner.get().lifecycle.addObserver(this)
-    withApi {
-      val user = chatController.apiGetActiveUser()
-      if (user == null) {
-        chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
-      } else {
-        chatController.startChat(user)
-        SimplexService.start(applicationContext)
-        chatController.showBackgroundServiceNoticeIfNeeded()
-      }
-    }
+    context.getDir("temp", MODE_PRIVATE).deleteRecursively()
   }
 
   override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
     Log.d(TAG, "onStateChanged: $event")
     withApi {
       when (event) {
-        Lifecycle.Event.ON_STOP ->
-          if (!appPreferences.runServiceInBackground.get()) SimplexService.stop(applicationContext)
-        Lifecycle.Event.ON_START ->
-          if (chatModel.chatRunning.value != false)  SimplexService.start(applicationContext)
-        Lifecycle.Event.ON_RESUME ->
+        Lifecycle.Event.ON_START -> {
+          isAppOnForeground = true
+          if (chatModel.chatRunning.value == true) {
+            kotlin.runCatching {
+              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()
           }
-        else -> {}
+          /**
+           * We're starting service here instead of in [Lifecycle.Event.ON_START] because
+           * 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 &&
+            chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete &&
+            appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name
+          ) {
+            SimplexService.start(applicationContext)
+          }
+        }
+        else -> isAppOnForeground = false
       }
     }
   }
 
+  fun allowToStartServiceAfterAppExit() = with(chatModel.controller) {
+    appPrefs.notificationsMode.get() == NotificationsMode.SERVICE.name &&
+        (!NotificationsMode.SERVICE.requiresIgnoringBattery || isIgnoringBatteryOptimizations(chatModel.controller.appContext))
+  }
+
+  private fun allowToStartPeriodically() = with(chatModel.controller) {
+    appPrefs.notificationsMode.get() == NotificationsMode.PERIODIC.name &&
+        (!NotificationsMode.PERIODIC.requiresIgnoringBattery || isIgnoringBatteryOptimizations(chatModel.controller.appContext))
+  }
+
+  /*
+  * It takes 1-10 milliseconds to process this function. Better to do it in a background thread
+  * */
+  fun schedulePeriodicServiceRestartWorker() = CoroutineScope(Dispatchers.Default).launch {
+    if (!allowToStartServiceAfterAppExit()) {
+      return@launch
+    }
+    val workerVersion = chatController.appPrefs.autoRestartWorkerVersion.get()
+    val workPolicy = if (workerVersion == SimplexService.SERVICE_START_WORKER_VERSION) {
+      Log.d(TAG, "ServiceStartWorker version matches: choosing KEEP as existing work policy")
+      ExistingPeriodicWorkPolicy.KEEP
+    } else {
+      Log.d(TAG, "ServiceStartWorker version DOES NOT MATCH: choosing REPLACE as existing work policy")
+      chatController.appPrefs.autoRestartWorkerVersion.set(SimplexService.SERVICE_START_WORKER_VERSION)
+      ExistingPeriodicWorkPolicy.REPLACE
+    }
+    val work = PeriodicWorkRequestBuilder<SimplexService.ServiceStartWorker>(SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES, TimeUnit.MINUTES)
+      .addTag(SimplexService.TAG)
+      .addTag(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC)
+      .build()
+    Log.d(TAG, "ServiceStartWorker: Scheduling period work every ${SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES} minutes")
+    WorkManager.getInstance(context)?.enqueueUniquePeriodicWork(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC, workPolicy, work)
+  }
+
+  fun schedulePeriodicWakeUp() = CoroutineScope(Dispatchers.Default).launch {
+    if (!allowToStartPeriodically()) {
+      return@launch
+    }
+    MessagesFetcherWorker.scheduleWork()
+  }
+
   companion object {
     lateinit var context: SimplexApp private set
 
     init {
-      val socketName = "local.socket.address.listen.native.cmd2"
+      val socketName = BuildConfig.APPLICATION_ID + ".local.socket.address.listen.native.cmd2"
       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

@@ -2,14 +2,14 @@ package chat.simplex.app
 
 import android.app.*
 import android.content.*
+import android.content.pm.PackageManager
 import android.os.*
 import android.provider.Settings
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import androidx.work.*
-import chat.simplex.app.views.helpers.withApi
-import chat.simplex.app.views.onboarding.OnboardingStage
+import chat.simplex.app.views.helpers.*
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -19,11 +19,9 @@ 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
-  private val chatController by lazy { (application as SimplexApp).chatController }
 
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     Log.d(TAG, "onStartCommand startId: $startId")
@@ -32,7 +30,6 @@ class SimplexService: Service() {
       Log.d(TAG, "intent action $action")
       when (action) {
         Action.START.name -> startService()
-        Action.STOP.name -> stopService()
         else -> Log.e(TAG, "No action in the intent")
       }
     } else {
@@ -49,34 +46,59 @@ 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()
-    sendBroadcast(Intent(this, AutoRestartReceiver::class.java)) // Restart if necessary!
+    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())
+      sendBroadcast(Intent(this, AutoRestartReceiver::class.java))
     super.onDestroy()
   }
 
   private fun startService() {
     Log.d(TAG, "SimplexService startService")
-    if (isServiceStarted || isStartingService) return
+    if (wakeLock != null || isStartingService) return
     val self = this
     isStartingService = true
     withApi {
+      val chatController = (application as SimplexApp).chatController
       try {
-        val user = chatController.apiGetActiveUser()
-        if (user == null) {
-          chatController.chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
-        } else {
-          Log.w(TAG, "Starting foreground service")
-          chatController.startChat(user)
-          isServiceStarted = true
-          saveServiceState(self, ServiceState.STARTED)
-          wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-            newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
-              acquire()
-            }
+        Log.w(TAG, "Starting foreground service")
+        val chatDbStatus = chatController.chatModel.chatDbStatus.value
+        if (chatDbStatus != DBMigrationResult.OK) {
+          Log.w(chat.simplex.app.TAG, "SimplexService: problem with the database: $chatDbStatus")
+          showPassphraseNotification(chatDbStatus)
+          safeStopService(self)
+          return@withApi
+        }
+        saveServiceState(self, ServiceState.STARTED)
+        wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
+          newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
+            acquire()
           }
         }
       } finally {
@@ -85,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
@@ -147,6 +153,14 @@ class SimplexService: Service() {
 
   // re-schedules the task when "Clear recent apps" is pressed
   override fun onTaskRemoved(rootIntent: Intent) {
+    // Just to make sure that after restart of the app the user will need to re-authenticate
+    MainActivity.clearAuthState()
+
+    // If notification service isn't enabled or battery optimization isn't disabled, we shouldn't restart the service
+    if (!SimplexApp.context.allowToStartServiceAfterAppExit()) {
+      return
+    }
+
     val restartServiceIntent = Intent(applicationContext, SimplexService::class.java).also {
       it.setPackage(packageName)
     };
@@ -162,6 +176,17 @@ class SimplexService: Service() {
       Log.d(TAG, "StartReceiver: onReceive called")
       scheduleStart(context)
     }
+    companion object {
+      fun toggleReceiver(enable: Boolean) {
+        Log.d(TAG, "StartReceiver: toggleReceiver enabled: $enable")
+        val component = ComponentName(BuildConfig.APPLICATION_ID, StartReceiver::class.java.name)
+        SimplexApp.context.packageManager.setComponentEnabledSetting(
+          component,
+          if (enable) PackageManager.COMPONENT_ENABLED_STATE_ENABLED else PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+          PackageManager.DONT_KILL_APP
+        )
+      }
+    }
   }
 
   // restart on destruction
@@ -189,7 +214,6 @@ class SimplexService: Service() {
 
   enum class Action {
     START,
-    STOP
   }
 
   enum class ServiceState {
@@ -206,11 +230,16 @@ class SimplexService: Service() {
     const val SERVICE_START_WORKER_INTERVAL_MINUTES = 3 * 60L
     const val SERVICE_START_WORKER_WORK_NAME_PERIODIC = "SimplexAutoRestartWorkerPeriodic" // Do not change!
 
+    private const val PASSPHRASE_NOTIFICATION_ID = 1535
+
     private const val WAKE_LOCK_TAG = "SimplexService::lock"
     private const val SHARED_PREFS_ID = "chat.simplex.app.SIMPLEX_SERVICE_PREFS"
     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)
@@ -220,7 +249,17 @@ class SimplexService: Service() {
 
     suspend fun start(context: Context) = serviceAction(context, Action.START)
 
-    suspend fun stop(context: Context) = serviceAction(context, Action.STOP)
+    /**
+     * 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}")
@@ -250,6 +289,41 @@ class SimplexService: Service() {
       return ServiceState.valueOf(value!!)
     }
 
+    fun showPassphraseNotification(chatDbStatus: DBMigrationResult?) {
+      val pendingIntent: PendingIntent = Intent(SimplexApp.context, MainActivity::class.java).let { notificationIntent ->
+        PendingIntent.getActivity(SimplexApp.context, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE)
+      }
+
+      val title = when(chatDbStatus) {
+        is DBMigrationResult.ErrorNotADatabase -> generalGetString(R.string.enter_passphrase_notification_title)
+        is DBMigrationResult.OK -> return
+        else -> generalGetString(R.string.database_initialization_error_title)
+      }
+
+      val description = when(chatDbStatus) {
+        is DBMigrationResult.ErrorNotADatabase -> generalGetString(R.string.enter_passphrase_notification_desc)
+        is DBMigrationResult.OK -> return
+        else -> generalGetString(R.string.database_initialization_error_desc)
+      }
+
+      val builder =  NotificationCompat.Builder(SimplexApp.context, NOTIFICATION_CHANNEL_ID)
+        .setSmallIcon(R.drawable.ntf_service_icon)
+        .setColor(0x88FFFF)
+        .setContentTitle(title)
+        .setContentText(description)
+        .setContentIntent(pendingIntent)
+        .setSilent(true)
+        .setShowWhen(false)
+
+      val notificationManager = SimplexApp.context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      notificationManager.notify(PASSPHRASE_NOTIFICATION_ID, builder.build())
+    }
+
+    fun cancelPassphraseNotification() {
+      val notificationManager = SimplexApp.context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      notificationManager.cancel(PASSPHRASE_NOTIFICATION_ID)
+    }
+
     private fun getPreferences(context: Context): SharedPreferences = context.getSharedPreferences(SHARED_PREFS_ID, Context.MODE_PRIVATE)
   }
 }

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

@@ -3,15 +3,18 @@ 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.*
 import chat.simplex.app.views.call.*
-import chat.simplex.app.views.helpers.base64ToBitmap
-import chat.simplex.app.views.helpers.generalGetString
+import chat.simplex.app.views.chatlist.acceptContactRequest
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.NotificationPreviewMode
 import kotlinx.datetime.Clock
 
 class NtfManager(val context: Context, private val appPreferences: AppPreferences) {
@@ -22,10 +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
@@ -33,21 +44,26 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
   private val msgNtfTimeoutMs = 30000L
 
   init {
-    manager.createNotificationChannel(NotificationChannel(MessageChannel, "SimpleX Chat messages", NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(NotificationChannel(LockScreenCallChannel, "SimpleX Chat calls (lock screen)", NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(callNotificationChannel())
+    if (manager.areNotificationsEnabled()) createNtfChannelsMaybeShowAlert()
   }
 
-  private fun callNotificationChannel(): NotificationChannel {
-    val callChannel = NotificationChannel(CallChannel, "SimpleX Chat calls", NotificationManager.IMPORTANCE_HIGH)
+  enum class NotificationAction {
+    ACCEPT_CONTACT_REQUEST
+  }
+
+  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
   }
 
@@ -63,28 +79,72 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     }
   }
 
-  fun notifyMessageReceived(cInfo: ChatInfo, cItem: ChatItem) {
-    notifyMessageReceived(chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
+  fun notifyContactRequestReceived(user: User, cInfo: ChatInfo.ContactRequest) {
+    displayNotification(
+      user = user,
+      chatId = cInfo.id,
+      displayName = cInfo.displayName,
+      msgText = generalGetString(R.string.notification_new_contact_request),
+      image = cInfo.image,
+      listOf(NotificationAction.ACCEPT_CONTACT_REQUEST)
+    )
   }
 
-  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String) {
+  fun notifyContactConnected(user: User, contact: Contact) {
+    displayNotification(
+      user = user,
+      chatId = contact.id,
+      displayName = contact.displayName,
+      msgText = generalGetString(R.string.notification_contact_connected)
+    )
+  }
+
+  fun notifyMessageReceived(user: User, cInfo: ChatInfo, cItem: ChatItem) {
+    if (!cInfo.ntfsEnabled) return
+    displayNotification(user = user, chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
+  }
+
+  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)
     prevNtfTime[chatId] = now
 
-    val notification = NotificationCompat.Builder(context, MessageChannel)
-      .setContentTitle(displayName)
-      .setContentText(msgText)
+    val previewMode = appPreferences.notificationPreviewMode.get()
+    val title = if (previewMode == NotificationPreviewMode.HIDDEN.name) generalGetString(R.string.notification_preview_somebody) else displayName
+    val content = if (previewMode != NotificationPreviewMode.MESSAGE.name) generalGetString(R.string.notification_preview_new_message) else msgText
+    val largeIcon = when {
+      actions.isEmpty() -> null
+      image == null || previewMode == NotificationPreviewMode.HIDDEN.name -> BitmapFactory.decodeResource(context.resources, R.drawable.icon)
+      else -> base64ToBitmap(image)
+    }
+    val builder = NotificationCompat.Builder(context, MessageChannel)
+      .setContentTitle(title)
+      .setContentText(content)
       .setPriority(NotificationCompat.PRIORITY_HIGH)
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
       .setSmallIcon(R.drawable.ntf_icon)
+      .setLargeIcon(largeIcon)
       .setColor(0x88FFFF)
       .setAutoCancel(true)
-      .setContentIntent(chatPendingIntent(OpenChatAction, chatId))
-      .setSilent(recentNotification)
-      .build()
+      .setVibrate(if (actions.isEmpty()) null else longArrayOf(0, 250, 250, 250))
+      .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) {
+        NotificationAction.ACCEPT_CONTACT_REQUEST -> generalGetString(R.string.accept)
+      }
+      builder.addAction(0, actionButton, actionPendingIntent)
+    }
 
     val summary = NotificationCompat.Builder(context, MessageChannel)
       .setSmallIcon(R.drawable.ntf_icon)
@@ -92,35 +152,45 @@ 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)) {
       // using cInfo.id only shows one notification per chat and updates it when the message arrives
-      notify(chatId.hashCode(), notification)
+      notify(chatId.hashCode(), builder.build())
       notify(0, summary)
     }
   }
 
   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(
@@ -130,17 +200,30 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
         if (invitation.sharedKey == null) R.string.audio_call_no_encryption else R.string.encrypted_audio_call
       }
     )
+    val previewMode = appPreferences.notificationPreviewMode.get()
+    val title = if (previewMode == NotificationPreviewMode.HIDDEN.name)
+      generalGetString(R.string.notification_preview_somebody)
+    else
+      invitation.contact.displayName
+    val largeIcon = if (image == null || previewMode == NotificationPreviewMode.HIDDEN.name)
+      BitmapFactory.decodeResource(context.resources, R.drawable.icon)
+    else
+      base64ToBitmap(image)
+
     ntfBuilder = ntfBuilder
-      .setContentTitle(invitation.contact.displayName)
+      .setContentTitle(title)
       .setContentText(text)
       .setPriority(NotificationCompat.PRIORITY_HIGH)
       .setCategory(NotificationCompat.CATEGORY_CALL)
       .setSmallIcon(R.drawable.ntf_icon)
-      .setLargeIcon(if (image == null) BitmapFactory.decodeResource(context.resources, R.drawable.icon) else base64ToBitmap(image))
+      .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)
     }
   }
 
@@ -148,33 +231,85 @@ 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)
-    if (chatId != null) intent = intent.putExtra("chatId", chatId)
-    return TaskStackBuilder.create(context).run {
-      addNextIntentWithParentStack(intent)
-      getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
+      .putExtra(UserIdKey, userId)
+    if (chatId != null) intent = intent.putExtra(ChatIdKey, chatId)
+    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 m = SimplexApp.context.chatModel
+      when (intent.action) {
+        NotificationAction.ACCEPT_CONTACT_REQUEST.name -> {
+          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/Color.kt

@@ -7,6 +7,7 @@ val Purple500 = Color(0xFF6200EE)
 val Purple700 = Color(0xFF3700B3)
 val Teal200 = Color(0xFF03DAC5)
 val Gray = Color(0x22222222)
+val Indigo = Color(0xFF9966FF)
 val SimplexBlue = Color(0, 136, 255, 255)  // If this value changes also need to update #0088ff in string resource files
 val SimplexGreen = Color(77, 218, 103, 255)
 val SecretColor = Color(0x40808080)
@@ -15,13 +16,14 @@ val DarkGray = Color(43, 44, 46, 255)
 val HighOrLowlight = Color(139, 135, 134, 255)
 val MessagePreviewDark = Color(179, 175, 174, 255)
 val MessagePreviewLight = Color(49, 45, 44, 255)
-val ToolbarLight = Color(220, 220, 220, 20)
-val ToolbarDark = Color(80, 80, 80, 20)
+val ToolbarLight = Color(220, 220, 220, 12)
+val ToolbarDark = Color(80, 80, 80, 12)
 val SettingsBackgroundLight = Color(220, 216, 215, 90)
 val SettingsSecondaryLight = Color(200, 196, 195, 90)
 val GroupDark = Color(80, 80, 80, 60)
 val IncomingCallLight = Color(239, 237, 236, 255)
 val IncomingCallDark = Color(34, 30, 29, 255)
 val WarningOrange = Color(255, 127, 0, 255)
+val WarningYellow = Color(255, 192, 0, 255)
 val FileLight = Color(183, 190, 199, 255)
 val FileDark = Color(101, 101, 106, 255)

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

@@ -1,11 +1,25 @@
 package chat.simplex.app.ui.theme
 
+import android.app.UiModeManager
+import android.content.Context
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material.*
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.SimplexApp
+import kotlinx.coroutines.flow.MutableStateFlow
 
-private val DarkColorPalette = darkColors(
+enum class DefaultTheme {
+  SYSTEM, DARK, LIGHT
+}
+
+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
   primaryVariant = SimplexGreen,
   secondary = DarkGray,
@@ -18,7 +32,7 @@ private val DarkColorPalette = darkColors(
   onSurface = Color(0xFFFFFBFA),
 //  onError: Color = Color.Black,
 )
-private val LightColorPalette = lightColors(
+val LightColorPalette = lightColors(
   primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = LightGray,
@@ -30,16 +44,32 @@ private val LightColorPalette = lightColors(
 //  onSurface = Color.Black,
 )
 
-@Composable
-fun SimpleXTheme(darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
-  val colors = if (darkTheme) {
-    DarkColorPalette
-  } else {
-    LightColorPalette
-  }
+val CurrentColors: MutableStateFlow<Pair<Colors, DefaultTheme>> = MutableStateFlow(ThemeManager.currentColors(isInNightMode()))
 
+// Non-@Composable implementation
+private fun isInNightMode() =
+  (SimplexApp.context.getSystemService(Context.UI_MODE_SERVICE) as UiModeManager).nightMode == UiModeManager.MODE_NIGHT_YES
+
+@Composable
+fun isInDarkTheme(): Boolean = !CurrentColors.collectAsState().value.first.isLight
+
+@Composable
+fun SimpleXTheme(darkTheme: Boolean? = null, content: @Composable () -> Unit) {
+  LaunchedEffect(darkTheme) {
+    // For preview
+    if (darkTheme != null)
+      CurrentColors.value = ThemeManager.currentColors(darkTheme)
+  }
+  val systemDark = isSystemInDarkTheme()
+  LaunchedEffect(systemDark) {
+    if (CurrentColors.value.second == DefaultTheme.SYSTEM && CurrentColors.value.first.isLight == systemDark) {
+      // Change active colors from light to dark and back based on system theme
+      ThemeManager.applyTheme(DefaultTheme.SYSTEM.name, systemDark)
+    }
+  }
+  val theme by CurrentColors.collectAsState()
   MaterialTheme(
-    colors = colors,
+    colors = theme.first,
     typography = Typography,
     shapes = Shapes,
     content = content

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

@@ -0,0 +1,64 @@
+package chat.simplex.app.ui.theme
+
+import androidx.compose.material.Colors
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import chat.simplex.app.R
+import chat.simplex.app.SimplexApp
+import chat.simplex.app.model.AppPreferences
+import chat.simplex.app.views.helpers.generalGetString
+
+object ThemeManager {
+  private val appPrefs: AppPreferences by lazy {
+    AppPreferences(SimplexApp.context)
+  }
+
+  fun currentColors(darkForSystemTheme: Boolean): Pair<Colors, DefaultTheme> {
+    val theme = appPrefs.currentTheme.get()!!
+    val systemThemeColors = if (darkForSystemTheme) DarkColorPalette else LightColorPalette
+    val res = when (theme) {
+      DefaultTheme.SYSTEM.name -> Pair(systemThemeColors, DefaultTheme.SYSTEM)
+      DefaultTheme.DARK.name -> Pair(DarkColorPalette, DefaultTheme.DARK)
+      DefaultTheme.LIGHT.name -> Pair(LightColorPalette, DefaultTheme.LIGHT)
+      else -> Pair(systemThemeColors, DefaultTheme.SYSTEM)
+    }
+    return res.copy(first = res.first.copy(primary = Color(appPrefs.primaryColor.get())))
+  }
+
+  // colors, default theme enum, localized name of theme
+  fun allThemes(darkForSystemTheme: Boolean): List<Triple<Colors, DefaultTheme, String>> {
+    val allThemes = ArrayList<Triple<Colors, DefaultTheme, String>>()
+    allThemes.add(
+      Triple(
+        if (darkForSystemTheme) DarkColorPalette else LightColorPalette,
+        DefaultTheme.SYSTEM,
+        generalGetString(R.string.theme_system)
+      )
+    )
+    allThemes.add(
+      Triple(
+        LightColorPalette,
+        DefaultTheme.LIGHT,
+        generalGetString(R.string.theme_light)
+      )
+    )
+    allThemes.add(
+      Triple(
+        DarkColorPalette,
+        DefaultTheme.DARK,
+        generalGetString(R.string.theme_dark)
+      )
+    )
+    return allThemes
+  }
+
+  fun applyTheme(name: String, darkForSystemTheme: Boolean) {
+    appPrefs.currentTheme.set(name)
+    CurrentColors.value = currentColors(darkForSystemTheme)
+  }
+
+  fun saveAndApplyPrimaryColor(color: Color) {
+    appPrefs.primaryColor.set(color.toArgb())
+    CurrentColors.value = currentColors(!CurrentColors.value.first.isLight)
+  }
+}

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

@@ -8,8 +8,8 @@ import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
 import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextOverflow
@@ -17,30 +17,43 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.app.model.*
-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
-import kotlinx.coroutines.launch
 
 @Composable
 fun TerminalView(chatModel: ChatModel, close: () -> Unit) {
   val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) }
-  BackHandler(onBack = close)
-  TerminalLayout(
-    chatModel.terminalItems,
-    composeState,
-    sendCommand = {
-      withApi {
-        // show "in progress"
-        chatModel.controller.sendCmd(CC.Console(composeState.value.message))
-        composeState.value = ComposeState(useLinkPreviews = false)
-        // hide "in progress"
-      }
-    },
-    close
-  )
+  BackHandler(onBack = {
+    close()
+  })
+    TerminalLayout(
+      remember { chatModel.terminalItems },
+      composeState,
+      sendCommand = { sendCommand(chatModel, composeState) },
+      close
+    )
+}
+
+private fun sendCommand(chatModel: ChatModel, composeState: MutableState<ComposeState>) {
+  val developerTools = chatModel.controller.appPrefs.developerTools.get()
+  val prefPerformLA = chatModel.controller.appPrefs.performLA.get()
+  val s = composeState.value.message
+  if (s.startsWith("/sql") && (!prefPerformLA || !developerTools)) {
+    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 {
+      // show "in progress"
+      chatModel.controller.sendCmd(CC.Console(s))
+      composeState.value = ComposeState(useLinkPreviews = false)
+      // hide "in progress"
+    }
+  }
 }
 
 @Composable
@@ -62,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()
@@ -79,38 +108,34 @@ fun TerminalLayout(
   }
 }
 
+private var lazyListState = 0 to 0
+
 @Composable
 fun TerminalLog(terminalItems: List<TerminalItem>) {
-  val listState = rememberLazyListState()
-  val keyboardState by getKeyboardState()
-  val ciListState = rememberSaveable(stateSaver = CIListStateSaver) {
-    mutableStateOf(CIListState(false, terminalItems.count(), keyboardState))
+  val listState = rememberLazyListState(lazyListState.first, lazyListState.second)
+  DisposableEffect(Unit) {
+    onDispose { lazyListState = listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
   }
-  val scope = rememberCoroutineScope()
-  LazyColumn(state = listState) {
-    items(terminalItems) { item ->
-      Text("${item.date.toString().subSequence(11, 19)} ${item.label}",
+  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}",
         style = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 18.sp, color = MaterialTheme.colors.primary),
         maxLines = 1,
         overflow = TextOverflow.Ellipsis,
         modifier = Modifier
-          .padding(horizontal = 8.dp, vertical = 4.dp)
+          .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)
       )
     }
-    val len = terminalItems.count()
-    if (len > 1 && (keyboardState != ciListState.value.keyboardState || !ciListState.value.scrolled || len != ciListState.value.itemCount)) {
-      scope.launch {
-        ciListState.value = CIListState(true, len, keyboardState)
-        listState.animateScrollToItem(len - 1)
-      }
-    }
   }
 }
 

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

@@ -1,7 +1,6 @@
 package chat.simplex.app.views
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
@@ -22,36 +21,33 @@ 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.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleButton
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.AppBarTitle
 import chat.simplex.app.views.helpers.withApi
 import chat.simplex.app.views.onboarding.OnboardingStage
 import chat.simplex.app.views.onboarding.ReadableText
 import com.google.accompanist.insets.navigationBarsWithImePadding
+import kotlinx.coroutines.delay
 
 fun isValidDisplayName(name: String) : Boolean {
   return (name.firstOrNull { it.isWhitespace() }) == null
 }
 
 @Composable
-fun CreateProfilePanel(chatModel: ChatModel) {
+fun CreateProfilePanel(chatModel: ChatModel, close: () -> Unit) {
   val displayName = remember { mutableStateOf("") }
   val fullName = remember { mutableStateOf("") }
   val focusRequester = remember { FocusRequester() }
 
   Surface(Modifier.background(MaterialTheme.colors.onBackground)) {
     Column(
-      modifier = Modifier.fillMaxSize()
+      modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState())
     ) {
-      Text(
-        stringResource(R.string.create_profile),
-        style = MaterialTheme.typography.h4,
-        modifier = Modifier.padding(vertical = 5.dp)
-      )
+      AppBarTitle(stringResource(R.string.create_profile), false)
       ReadableText(R.string.your_profile_is_stored_on_your_device)
       ReadableText(R.string.profile_is_only_shared_with_your_contacts)
       Spacer(Modifier.height(10.dp))
@@ -76,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))
 
@@ -87,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)
@@ -102,21 +100,30 @@ fun CreateProfilePanel(chatModel: ChatModel) {
       }
 
       LaunchedEffect(Unit) {
+        delay(300)
         focusRequester.requestFocus()
       }
     }
   }
 }
 
-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)
+        }
       }
     }
   }
@@ -51,7 +53,14 @@ class CallManager(val chatModel: ChatModel) {
       )
       showCallView.value = true
       val useRelay = controller.appPrefs.webrtcPolicyRelay.get()
-      callCommand.value = WCallCommand.Start (media = invitation.callType.media, aesKey = invitation.sharedKey, relay = useRelay)
+      val iceServers = getIceServers()
+      Log.d(TAG, "answerIncomingCall iceServers: $iceServers")
+      callCommand.value = WCallCommand.Start(
+        media = invitation.callType.media,
+        aesKey = invitation.sharedKey,
+        iceServers = iceServers,
+        relay = useRelay
+      )
       callInvitations.remove(invitation.contact.id)
       if (invitation.contact.id == activeCallInvitation.value?.contact?.id) {
         activeCallInvitation.value = null

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

@@ -1,8 +1,14 @@
 package chat.simplex.app.views.call
 
 import android.Manifest
-import android.content.Context
-import android.media.AudioManager
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.*
+import android.content.pm.ActivityInfo
+import android.media.*
+import android.os.Build
+import android.os.PowerManager
+import android.os.PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK
 import android.util.Log
 import android.view.ViewGroup
 import android.webkit.*
@@ -14,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
@@ -29,25 +36,75 @@ import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleEventObserver
 import androidx.webkit.WebViewAssetLoader
 import androidx.webkit.WebViewClientCompat
+import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.TAG
 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
 
+@SuppressLint("SourceLockedOrientationActivity")
 @Composable
 fun ActiveCallView(chatModel: ChatModel) {
   BackHandler(onBack = {
     val call = chatModel.activeCall.value
     if (call != null) withApi { chatModel.callManager.endCall(call) }
   })
-  val cxt = LocalContext.current
+  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.
+    // It's needed to prevent Android from shutting down a microphone after a minute or so when screen is off
+    if (!ntfModeService) SimplexService.start(SimplexApp.context)
+  }
+  DisposableEffect(Unit) {
+    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 scope = rememberCoroutineScope()
   Box(Modifier.fillMaxSize()) {
     WebRTCView(chatModel.callCommand) { apiMsg ->
@@ -77,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) {
@@ -85,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 -> {
@@ -120,15 +177,29 @@ 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
+    }
   }
 }
 
 @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) },
@@ -137,28 +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
+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 {
+    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.mode = AudioManager.MODE_IN_CALL
     am.isSpeakerphoneOn = false
+    am.stopBluetoothSco()
   }
 }
 
 @Composable
 private fun ActiveCallOverlayLayout(
   call: Call,
+  speakerCanBeEnabled: Boolean,
   dismiss: () -> Unit,
   toggleAudio: () -> Unit,
   toggleVideo: () -> Unit,
@@ -196,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))
@@ -207,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)
             }
           }
         }
@@ -217,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))
@@ -237,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)
   }
 }
 
@@ -253,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)
   }
 }
 
@@ -312,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(
@@ -337,6 +436,8 @@ fun WebRTCView(callCommand: MutableState<WCallCommand?>, onResponse: (WVAPIMessa
       val wv = webView.value
       if (wv != null) processCommand(wv, WCallCommand.End)
       lifecycleOwner.lifecycle.removeObserver(observer)
+      webView.value?.destroy()
+      webView.value = null
     }
   }
   LaunchedEffect(callCommand.value, webView.value) {
@@ -388,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
@@ -433,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 = {},
@@ -454,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,28 +46,36 @@ fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
 @Composable
 fun IncomingCallAlertLayout(
   invitation: RcvCallInvitation,
+  chatModel: ChatModel,
   rejectCall: () -> Unit,
   ignoreCall: () -> Unit,
   acceptCall: () -> Unit
 ) {
-  val color = if (isSystemInDarkTheme()) IncomingCallDark else IncomingCallLight
-  Column(Modifier.background(color).padding(top = 16.dp, bottom = 16.dp, start = 16.dp, end = 8.dp)) {
-    IncomingCallInfo(invitation)
+  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, chatModel)
     Spacer(Modifier.height(8.dp))
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      ProfilePreview(profileOf = invitation.contact, size = 64.dp, color = Color.White)
-      Spacer(Modifier.fillMaxWidth().weight(1f))
-      CallButton(stringResource(R.string.reject), Icons.Filled.CallEnd, Color.Red, rejectCall)
-      CallButton(stringResource(R.string.ignore), Icons.Filled.Close, MaterialTheme.colors.primary, ignoreCall)
-      CallButton(stringResource(R.string.accept), Icons.Filled.Check, SimplexGreen, acceptCall)
+    Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.SpaceBetween) {
+      Row(Modifier.fillMaxWidth().weight(1f), verticalAlignment = Alignment.CenterVertically) {
+        ProfilePreview(profileOf = invitation.contact, size = 64.dp, color = Color.White)
+      }
+      Row(verticalAlignment = Alignment.CenterVertically) {
+        CallButton(stringResource(R.string.reject), Icons.Filled.CallEnd, Color.Red, rejectCall)
+        CallButton(stringResource(R.string.ignore), Icons.Filled.Close, MaterialTheme.colors.primary, ignoreCall)
+        CallButton(stringResource(R.string.accept), Icons.Filled.Check, SimplexGreen, acceptCall)
+      }
     }
   }
 }
 
 @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))
@@ -95,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/SoundPlayer.kt

@@ -1,21 +1,33 @@
 package chat.simplex.app.views.call
 
 import android.content.Context
-import android.media.MediaPlayer
+import android.media.*
+import android.net.Uri
 import android.os.VibrationEffect
 import android.os.Vibrator
 import androidx.core.content.ContextCompat
 import chat.simplex.app.R
+import chat.simplex.app.SimplexApp
 import chat.simplex.app.views.helpers.withScope
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.delay
 
 class SoundPlayer {
-  var player: MediaPlayer? = null
+  private var player: MediaPlayer? = null
   var playing = false
 
   fun start(cxt: Context, scope: CoroutineScope, sound: Boolean) {
-    if (sound) player = MediaPlayer.create(cxt, R.raw.ring_once)
+    player?.reset()
+    player = MediaPlayer().apply {
+      setAudioAttributes(
+        AudioAttributes.Builder()
+          .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+          .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+          .build()
+      )
+      setDataSource(SimplexApp.context, Uri.parse("android.resource://" + SimplexApp.context.packageName + "/" + R.raw.ring_once))
+      prepare()
+    }
     val vibrator = ContextCompat.getSystemService(cxt, Vibrator::class.java)
     val effect = VibrationEffect.createOneShot(250, VibrationEffect.DEFAULT_AMPLITUDE)
     playing = true

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

@@ -1,13 +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 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,
@@ -59,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?, 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
@@ -101,21 +107,34 @@ 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 class RTCIceServer(val urls: List<String>, val username: String? = null, val credential: String? = null)
+@Serializable data class RTCIceServer(val urls: List<String>, val username: String? = null, val credential: String? = null)
 
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate/type
 @Serializable
@@ -148,9 +167,55 @@ enum class VideoCamera {
 }
 
 @Serializable
-class ConnectionState(
+data class ConnectionState(
   val connectionState: String,
   val iceConnectionState: String,
   val iceGatheringState: String,
   val signalingState: String
-)
+)
+
+// the servers are expected in this format:
+// 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" || 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$query"),
+        username = userInfo?.getOrNull(0),
+        credential = userInfo?.getOrNull(1)
+      )
+    }
+  }
+  return null
+}
+
+private fun replaceScheme(s: String, scheme: String): String = if (s.startsWith(scheme)) s.replace(scheme, "$scheme//") else s
+
+fun parseRTCIceServers(servers: List<String>): List<RTCIceServer>? {
+  val iceServers: ArrayList<RTCIceServer> = ArrayList()
+  for (s in servers) {
+    val server = parseRTCIceServer(s)
+    if (server != null) {
+      iceServers.add(server)
+    } else {
+      return null
+    }
+  }
+  return if (iceServers.isEmpty()) null else iceServers
+}
+
+fun getIceServers(): List<RTCIceServer>? {
+  val value = SimplexApp.context.chatController.appPrefs.webrtcIceServers.get() ?: return null
+  val servers: List<String> = value.split("\n")
+  return parseRTCIceServers(servers)
+}

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

@@ -1,43 +1,112 @@
 package chat.simplex.app.views.chat
 
 import InfoRow
+import InfoRowEllipsis
 import SectionDivider
 import SectionItemView
 import SectionSpacer
 import SectionView
+import android.widget.Toast
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.text.KeyboardActions
 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.Composable
+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.platform.ClipboardManager
+import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.TextStyle
 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.SimplexApp
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.*
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.*
+import kotlinx.datetime.Clock
 
 @Composable
-fun ChatInfoView(chatModel: ChatModel, connStats: ConnectionStats?, close: () -> Unit) {
+fun ChatInfoView(
+  chatModel: ChatModel,
+  contact: Contact,
+  connStats: ConnectionStats?,
+  customUserProfile: Profile?,
+  localAlias: String,
+  connectionCode: String?,
+  close: () -> 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)
+      },
+      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) }
+      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,
+            )
+          }
+        }
+      }
     )
   }
 }
@@ -82,10 +151,19 @@ fun clearChatDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit
 @Composable
 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
+  clearChat: () -> Unit,
+  switchContactAddress: () -> Unit,
+  verifyClicked: () -> Unit,
 ) {
   Column(
     Modifier
@@ -97,14 +175,39 @@ fun ChatInfoLayout(
       Modifier.fillMaxWidth(),
       horizontalArrangement = Arrangement.Center
     ) {
-      ChatInfoHeader(chat.chatInfo)
+      ChatInfoHeader(chat.chatInfo, contact)
     }
+
+    LocalAliasEditor(localAlias, updateValue = onLocalAliasChanged)
+
+    if (customUserProfile != null) {
+      SectionSpacer()
+      SectionView(generalGetString(R.string.incognito).uppercase()) {
+        InfoRow(generalGetString(R.string.incognito_random_profile), customUserProfile.chatViewName)
+      }
+    }
+
+    SectionSpacer()
+    SectionView {
+      if (connectionCode != null) {
+        VerifyCodeButton(contact.verified, verifyClicked)
+        SectionDivider()
+      }
+      ContactPreferencesButton(openPreferences)
+    }
+
     SectionSpacer()
 
-    if (connStats != null) {
-      SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
-        SectionItemView {
-          NetworkStatusRow(chat.serverInfo.networkStatus)
+    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),
+            contactNetworkStatus.statusExplanation
+          )}) {
+          NetworkStatusRow(contactNetworkStatus)
         }
         val rcvServers = connStats.rcvServers
         if (rcvServers != null && rcvServers.isNotEmpty()) {
@@ -117,17 +220,12 @@ fun ChatInfoLayout(
           SimplexServers(stringResource(R.string.sending_via), sndServers)
         }
       }
-      SectionSpacer()
     }
-
+    SectionSpacer()
     SectionView {
-      SectionItemView {
-        ClearChatButton(clearChat)
-      }
+      ClearChatButton(clearChat)
       SectionDivider()
-      SectionItemView {
-        DeleteContactButton(deleteContact)
-      }
+      DeleteContactButton(deleteContact)
     }
     SectionSpacer()
 
@@ -143,19 +241,24 @@ fun ChatInfoLayout(
 }
 
 @Composable
-fun ChatInfoHeader(cInfo: ChatInfo) {
+fun ChatInfoHeader(cInfo: ChatInfo, contact: Contact) {
   Column(
     Modifier.padding(horizontal = 8.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isSystemInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Text(
-      cInfo.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) {
+    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
+    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,
         color = MaterialTheme.colors.onBackground,
@@ -167,16 +270,58 @@ fun ChatInfoHeader(cInfo: ChatInfo) {
 }
 
 @Composable
-fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
-  Row(
-    Modifier
-      .fillMaxSize()
-      .clickable {
-        AlertManager.shared.showAlertMsg(
-          generalGetString(R.string.network_status),
-          networkStatus.statusExplanation
+fun LocalAliasEditor(
+  initialValue: String,
+  center: Boolean = true,
+  leadingIcon: Boolean = false,
+  focus: Boolean = false,
+  updateValue: (String) -> Unit
+) {
+  var value by rememberSaveable { mutableStateOf(initialValue) }
+  val modifier = if (center)
+    Modifier.padding(horizontal = if (!leadingIcon) DEFAULT_PADDING else 0.dp).widthIn(min = 100.dp)
+  else
+    Modifier.padding(horizontal = if (!leadingIcon) DEFAULT_PADDING else 0.dp).fillMaxWidth()
+  Row(Modifier.fillMaxWidth(), horizontalArrangement = if (center) Arrangement.Center else Arrangement.Start) {
+    DefaultBasicTextField(
+      modifier,
+      value,
+      {
+        Text(
+          generalGetString(R.string.text_field_set_contact_placeholder),
+          textAlign = if (center) TextAlign.Center else TextAlign.Start,
+          color = HighOrLowlight
         )
       },
+      leadingIcon = if (leadingIcon) {
+        { Icon(Icons.Default.Edit, null, Modifier.padding(start = 7.dp)) }
+      } else null,
+      color = HighOrLowlight,
+      focus = focus,
+      textStyle = TextStyle.Default.copy(textAlign = if (value.isEmpty() || !center) TextAlign.Start else TextAlign.Center),
+      keyboardActions = KeyboardActions(onDone = { updateValue(value) })
+    ) {
+      value = it
+    }
+  }
+  LaunchedEffect(Unit) {
+    snapshotFlow { value }
+      .onEach { delay(500) } // wait a little after every new character, don't emit until user stops typing
+      .conflate() // get the latest value
+      .filter { it == value } // don't process old ones
+      .collect {
+        updateValue(value)
+      }
+  }
+  DisposableEffect(Unit) {
+    onDispose { updateValue(value) } // just in case snapshotFlow will be canceled when user presses Back too fast
+  }
+}
+
+@Composable
+private fun NetworkStatusRow(networkStatus: NetworkStatus) {
+  Row(
+    Modifier.fillMaxSize(),
     horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
@@ -206,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)
     }
@@ -223,45 +368,82 @@ fun ServerImage(networkStatus: Chat.NetworkStatus) {
 @Composable
 fun SimplexServers(text: String, servers: List<String>) {
   val info = servers.joinToString(separator = ", ") { it.substringAfter("@") }
-  InfoRow(text, info)
-}
-
-@Composable
-fun ClearChatButton(clearChat: () -> Unit) {
-  Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { clearChat() },
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Restore,
-      stringResource(R.string.clear_chat_button),
-      tint = WarningOrange
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.clear_chat_button), color = WarningOrange)
+  val clipboardManager: ClipboardManager = LocalClipboardManager.current
+  InfoRowEllipsis(text, info) {
+    clipboardManager.setText(AnnotatedString(servers.joinToString(separator = ",")))
+    Toast.makeText(SimplexApp.context, generalGetString(R.string.copied), Toast.LENGTH_SHORT).show()
   }
 }
 
 @Composable
-fun DeleteContactButton(deleteContact: () -> Unit) {
-  Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { deleteContact() },
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Delete,
-      stringResource(R.string.button_delete_contact),
-      tint = Color.Red
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_delete_contact), color = Color.Red)
+fun SwitchAddressButton(onClick: () -> Unit) {
+  SectionItemView(onClick) {
+    Text(stringResource(R.string.switch_receiving_address), color = MaterialTheme.colors.primary)
   }
 }
 
+@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(
+    Icons.Outlined.Restore,
+    stringResource(R.string.clear_chat_button),
+    click = onClick,
+    textColor = WarningOrange,
+    iconColor = WarningOrange,
+  )
+}
+
+@Composable
+private fun DeleteContactButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.Delete,
+    stringResource(R.string.button_delete_contact),
+    click = onClick,
+    textColor = Color.Red,
+    iconColor = Color.Red,
+  )
+}
+
+private fun setContactAlias(contactApiId: Long, localAlias: String, chatModel: ChatModel) = withApi {
+  chatModel.controller.apiSetContactAlias(contactApiId, localAlias)?.let {
+    chatModel.updateContact(it)
+  }
+}
+
+private fun showSwitchContactAddressAlert(m: ChatModel, contactId: Long) {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.switch_receiving_address_question),
+    text = generalGetString(R.string.switch_receiving_address_desc),
+    confirmText = generalGetString(R.string.switch_verb),
+    onConfirm = {
+      switchContactAddress(m, contactId)
+    }
+  )
+}
+
+private fun switchContactAddress(m: ChatModel, contactId: Long) = withApi {
+  m.controller.apiSwitchContact(contactId)
+}
+
 @Preview
 @Composable
 fun PreviewChatInfoLayout() {
@@ -269,12 +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,
-      deleteContact = {}, clearChat = {}
+      contactNetworkStatus = NetworkStatus.Connected(),
+      onLocalAliasChanged = {},
+      customUserProfile = null,
+      openPreferences = {},
+      deleteContact = {},
+      clearChat = {},
+      switchContactAddress = {},
+      verifyClicked = {},
     )
   }
 }

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

@@ -1,5 +1,4 @@
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
@@ -31,7 +30,7 @@ fun ComposeFileView(fileName: String, cancelFile: () -> Unit, cancelEnabled: Boo
       Modifier
         .padding(start = 4.dp, end = 2.dp)
         .size(36.dp),
-      tint = if (isSystemInDarkTheme()) FileDark else FileLight
+      tint = if (isInDarkTheme()) FileDark else FileLight
     )
     Text(fileName)
     Spacer(Modifier.weight(1f))

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

@@ -1,45 +1,51 @@
+package chat.simplex.app.views.chat
+
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Close
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
+import chat.simplex.app.ui.theme.DEFAULT_PADDING_HALF
 import chat.simplex.app.views.chat.item.SentColorLight
 import chat.simplex.app.views.helpers.base64ToBitmap
 
 @Composable
-fun ComposeImageView(image: String, cancelImage: () -> Unit, cancelEnabled: Boolean) {
+fun ComposeImageView(images: List<String>, cancelImages: () -> Unit, cancelEnabled: Boolean) {
   Row(
     Modifier
-      .fillMaxWidth()
       .padding(top = 8.dp)
       .background(SentColorLight),
-    verticalAlignment = Alignment.CenterVertically
+    verticalAlignment = Alignment.CenterVertically,
   ) {
-    val imageBitmap = base64ToBitmap(image).asImageBitmap()
-    Image(
-      imageBitmap,
-      "preview image",
-      modifier = Modifier
-        .width(80.dp)
-        .height(60.dp)
-        .padding(end = 8.dp)
-    )
-    Spacer(Modifier.weight(1f))
+    LazyRow(
+      Modifier.weight(1f).padding(start = DEFAULT_PADDING_HALF, end = if (cancelEnabled) 0.dp else DEFAULT_PADDING_HALF),
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(DEFAULT_PADDING_HALF),
+    ) {
+      items(images.size) { index ->
+        val imageBitmap = base64ToBitmap(images[index]).asImageBitmap()
+        Image(
+          imageBitmap,
+          "preview image",
+          modifier = Modifier.widthIn(max = 80.dp).height(60.dp)
+        )
+      }
+    }
     if (cancelEnabled) {
-      IconButton(onClick = cancelImage, modifier = Modifier.padding(0.dp)) {
+      IconButton(onClick = cancelImages) {
         Icon(
           Icons.Outlined.Close,
           contentDescription = stringResource(R.string.icon_descr_cancel_image_preview),
           tint = MaterialTheme.colors.primary,
-          modifier = Modifier.padding(10.dp)
         )
       }
     }

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

@@ -1,71 +1,87 @@
+@file:UseSerializers(UriSerializer::class)
 package chat.simplex.app.views.chat
 
 import ComposeFileView
-import ComposeImageView
+import ComposeVoiceView
 import android.Manifest
 import android.app.Activity
-import android.content.Context
-import android.content.Intent
+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.coroutines.*
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.serialization.*
 import java.io.File
+import java.nio.file.Files
 
+@Serializable
 sealed class ComposePreview {
-  object NoPreview: ComposePreview()
-  class CLinkPreview(val linkPreview: LinkPreview?): ComposePreview()
-  class ImagePreview(val image: String): ComposePreview()
-  class FilePreview(val fileName: String): ComposePreview()
+  @Serializable object NoPreview: ComposePreview()
+  @Serializable class CLinkPreview(val linkPreview: LinkPreview?): 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
 sealed class ComposeContextItem {
-  object NoContextItem: ComposeContextItem()
-  class QuotedItem(val chatItem: ChatItem): ComposeContextItem()
-  class EditingItem(val chatItem: ChatItem): ComposeContextItem()
+  @Serializable object NoContextItem: ComposeContextItem()
+  @Serializable class QuotedItem(val chatItem: ChatItem): 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
@@ -81,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
       }
@@ -99,18 +122,50 @@ data class ComposeState(
         is ComposePreview.CLinkPreview -> preview.linkPreview
         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) },
+      restore = {
+        mutableStateOf(json.decodeFromString(it))
+      }
+    )
+  }
+}
+
+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(image = 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
   }
 }
 
@@ -123,96 +178,108 @@ 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 chosenImage = remember { mutableStateOf<Bitmap?>(null) }
-  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) {
-      chosenImage.value = bitmap
-      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
-      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(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()
     }
   }
-  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
-    if (uri != null) {
-      val source = ImageDecoder.createSource(context.contentResolver, uri)
-      val bitmap = ImageDecoder.decodeBitmap(source)
-      chosenImage.value = bitmap
-      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
-      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
+  val processPickedImage = { uris: List<Uri>, text: String? ->
+    val content = ArrayList<UploadContent>()
+    val imagesPreview = ArrayList<String>()
+    uris.forEach { uri ->
+      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 <= 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(maxFileSize))
+          )
+        }
+      } else {
+        content.add(UploadContent.SimpleImage(uri))
+      }
+      if (bitmap != null) {
+        imagesPreview.add(resizeImageToStrSize(bitmap, maxDataSize = 14000))
+      }
+    }
+
+    if (imagesPreview.isNotEmpty()) {
+      composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.ImagePreview(imagesPreview, content))
     }
   }
-  val filesLauncher = rememberGetContentLauncher { uri: Uri? ->
+  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(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 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)
@@ -221,7 +288,19 @@ fun ComposeView(
         attachmentOption.value = null
       }
       AttachmentOption.PickImage -> {
-        galleryLauncher.launch("image/*")
+        try {
+          galleryImageLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryImageLauncherFallback.launch("image/*")
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.PickVideo -> {
+        try {
+          galleryVideoLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryVideoLauncherFallback.launch("video/*")
+        }
         attachmentOption.value = null
       }
       AttachmentOption.PickFile -> {
@@ -250,6 +329,9 @@ fun ComposeView(
         if (lp != null && pendingLinkUrl.value == url) {
           composeState.value = composeState.value.copy(preview = ComposePreview.CLinkPreview(lp))
           pendingLinkUrl.value = null
+        } else if (pendingLinkUrl.value == url) {
+          composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+          pendingLinkUrl.value = null
         }
       }
     }
@@ -276,111 +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
-    chosenImage.value = null
-    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 -> {
-        var mc: MsgContent? = null
-        var file: String? = null
-        when (val preview = cs.preview) {
-          ComposePreview.NoPreview -> mc = MsgContent.MCText(cs.message)
-          is ComposePreview.CLinkPreview -> mc = checkLinkPreview()
-          is ComposePreview.ImagePreview -> {
-            val chosenImageVal = chosenImage.value
-            if (chosenImageVal != null) {
-              file = saveImage(context, chosenImageVal)
-              if (file != null) {
-                mc = MsgContent.MCImage(cs.message, preview.image)
-              }
-            }
-          }
-          is ComposePreview.FilePreview -> {
-            val chosenFileVal = chosenFile.value
-            if (chosenFileVal != null) {
-              file = saveFileFromUri(context, chosenFileVal)
-              if (file != null) {
-                mc = MsgContent.MCFile(cs.message)
-              }
-            }
-          }
-        }
-        val quotedItemId: Long? = when (contextItem) {
-          is ComposeContextItem.QuotedItem -> contextItem.chatItem.id
-          else -> null
-        }
-
-        if (mc != null) {
-          withApi {
-            val aChatItem = chatModel.controller.apiSendMessage(
-              type = cInfo.chatType,
-              id = cInfo.apiId,
-              file = file,
-              quotedItemId = quotedItemId,
-              mc = mc
-            )
-            if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
-            clearState()
-          }
-        } else {
-          clearState()
-        }
-      }
+    withBGApi {
+      sendMessageAsync(null, false)
     }
   }
 
@@ -397,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) {
@@ -406,14 +569,72 @@ fun ComposeView(
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
   }
 
-  fun cancelImage() {
+  fun cancelImages() {
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
-    chosenImage.value = null
+  }
+
+  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
@@ -422,10 +643,22 @@ fun ComposeView(
       ComposePreview.NoPreview -> {}
       is ComposePreview.CLinkPreview -> ComposeLinkView(preview.linkPreview, ::cancelLinkPreview)
       is ComposePreview.ImagePreview -> ComposeImageView(
-        preview.image,
-        ::cancelImage,
+        preview.images,
+        ::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,
@@ -447,42 +680,194 @@ 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)
+      is SharedContent.File -> processPickedFile(shared.uri, shared.text)
+      null -> {}
+    }
+    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, Uri?>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Images.Media.INTERNAL_CONTENT_URI).apply {
+      type = "image/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): Uri? = intent?.data
+}
+
+class PickMultipleImagesFromGallery: ActivityResultContract<Int, List<Uri>>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Images.Media.INTERNAL_CONTENT_URI).apply {
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      type = "image/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): List<Uri> =
+    if (intent?.data != null)
+      listOf(intent.data!!)
+    else if (intent?.clipData != null)
+      with(intent.clipData!!) {
+        val uris = ArrayList<Uri>()
+        for (i in 0 until kotlin.math.min(itemCount, 10)) {
+          val uri = getItemAt(i).uri
+          if (uri != null) uris.add(uri)
+        }
+        if (itemCount > 10) {
+          AlertManager.shared.showAlertMsg(R.string.images_limit_title, R.string.images_limit_desc)
+        }
+        uris
+      }
+    else
+      emptyList()
+}
+
+
+class PickMultipleVideosFromGallery: ActivityResultContract<Int, List<Uri>>() {
+  override fun createIntent(context: Context, input: Int) =
+    Intent(Intent.ACTION_PICK, MediaStore.Video.Media.INTERNAL_CONTENT_URI).apply {
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      type = "video/*"
+    }
+
+  override fun parseResult(resultCode: Int, intent: Intent?): List<Uri> =
+    if (intent?.data != null)
+      listOf(intent.data!!)
+    else if (intent?.clipData != null)
+      with(intent.clipData!!) {
+        val uris = ArrayList<Uri>()
+        for (i in 0 until kotlin.math.min(itemCount, 10)) {
+          val uri = getItemAt(i).uri
+          if (uri != null) uris.add(uri)
+        }
+        if (itemCount > 10) {
+          AlertManager.shared.showAlertMsg(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.*
@@ -52,7 +51,9 @@ fun ContextItemView(
       )
       MarkdownText(
         contextItem.text, contextItem.formattedText,
-        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3
+        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3,
+        linkMode = SimplexLinkMode.DESCRIPTION,
+        modifier = Modifier.fillMaxWidth(),
       )
     }
     IconButton(onClick = cancelContextItem) {

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,101 +1,585 @@
 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.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardOptions
 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.ui.Alignment
-import androidx.compose.ui.Modifier
+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.Color
-import androidx.compose.ui.graphics.SolidColor
+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.input.KeyboardCapitalization
+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.*
 import chat.simplex.app.R
-import chat.simplex.app.model.ChatItem
+import chat.simplex.app.SimplexApp
+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.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
-  BasicTextField(
-    value = cs.message,
-    onValueChange = onMessageChange,
-    textStyle = textStyle.value,
-    maxLines = 16,
-    keyboardOptions = KeyboardOptions.Default.copy(
-      capitalization = KeyboardCapitalization.Sentences,
-      autoCorrect = true
-    ),
-    modifier = Modifier.padding(vertical = 8.dp),
-    cursorBrush = SolidColor(HighOrLowlight),
-    decorationBox = { innerTextField ->
-      Surface(
-        shape = RoundedCornerShape(18.dp),
-        border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
-      ) {
-        Row(
-          Modifier.background(MaterialTheme.colors.background),
-          verticalAlignment = Alignment.Bottom
-        ) {
-          Box(
-            Modifier
-              .weight(1f)
-              .padding(horizontal = 12.dp)
-              .padding(top = 5.dp)
-              .padding(bottom = 7.dp)
-          ) {
-            innerTextField()
-          }
-          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()
+  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)
+        }
+      }
+      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
+    }
+  }
+
+  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)
+    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
+    )
   )
 }
 
@@ -112,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
@@ -133,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
@@ -150,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

@@ -11,11 +11,13 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 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
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
@@ -26,22 +28,36 @@ import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.ChatInfoToolbarTitle
 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.Admin) }
-
+  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 {
-        selectedContacts.forEach {
-          chatModel.controller.apiAddMember(groupInfo.groupId, it, selectedRole.value)
+        for (contactId in selectedContacts) {
+          val member = chatModel.controller.apiAddMember(groupInfo.groupId, contactId, selectedRole.value)
+          if (member != null) {
+            chatModel.upsertGroupMember(groupInfo, member)
+          } else {
+            break
+          }
         }
         close.invoke()
       }
@@ -49,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,
   )
 }
 
@@ -69,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
@@ -83,6 +104,7 @@ fun AddGroupMembersLayout(
       .verticalScroll(rememberScrollState()),
     horizontalAlignment = Alignment.Start,
   ) {
+    AppBarTitle(stringResource(R.string.button_add_members))
     Row(
       Modifier.fillMaxWidth(),
       horizontalArrangement = Arrangement.Center
@@ -90,7 +112,7 @@ fun AddGroupMembersLayout(
       ChatInfoToolbarTitle(
         ChatInfo.Group(groupInfo),
         imageSize = 60.dp,
-        iconColor = if (isSystemInDarkTheme()) GroupDark else SettingsSecondaryLight
+        iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight
       )
     }
     SectionSpacer()
@@ -108,21 +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()
-        SectionItemView {
-          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, addContact, removeContact)
+      SectionView(stringResource(R.string.select_contacts)) {
+        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, allowModifyMembers, addContact, removeContact)
       }
       SectionSpacer()
     }
@@ -130,114 +160,69 @@ fun AddGroupMembersLayout(
 }
 
 @Composable
-fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>) {
+private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>, enabled: Boolean) {
   Row(
     Modifier.fillMaxWidth(),
     verticalAlignment = Alignment.CenterVertically,
     horizontalArrangement = Arrangement.SpaceBetween
   ) {
-    Text(stringResource(R.string.new_member_role))
-    RoleDropdownMenu(groupInfo, selectedRole)
-  }
-}
-
-@Composable
-fun RoleDropdownMenu(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>) {
-  val options = GroupMemberRole.values()
-    .filter { it <= groupInfo.membership.memberRole }
-  var expanded by remember { mutableStateOf(false) }
-
-  ExposedDropdownMenuBox(
-    expanded = expanded,
-    onExpandedChange = {
-      expanded = !expanded
-    }
-  ) {
-    Row(
-      Modifier.fillMaxWidth(0.7f),
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.End
-    ) {
-      Text(
-        selectedRole.value.text,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-        color = HighOrLowlight
-      )
-      Spacer(Modifier.size(4.dp))
-      Icon(
-        if (!expanded) Icons.Outlined.ExpandMore else Icons.Outlined.ExpandLess,
-        generalGetString(R.string.invite_to_group_button),
-        modifier = Modifier.padding(start = 8.dp),
-        tint = HighOrLowlight
-      )
-    }
-    ExposedDropdownMenu(
-      expanded = expanded,
-      onDismissRequest = {
-        expanded = false
-      }
-    ) {
-      options.forEach { selectionOption ->
-        DropdownMenuItem(
-          onClick = {
-            selectedRole.value = selectionOption
-            expanded = false
-          }
-        ) {
-          Text(
-            selectionOption.text,
-            maxLines = 1,
-            overflow = TextOverflow.Ellipsis,
-          )
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun InviteMembersButton(inviteMembers: () -> Unit, disabled: Boolean) {
-  val modifier = if (disabled) Modifier else Modifier.clickable { inviteMembers() }
-  Row(
-    modifier.fillMaxSize(),
-    horizontalArrangement = Arrangement.End,
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    val color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
-    Text(stringResource(R.string.invite_to_group_button), color = color)
-    Spacer(Modifier.size(8.dp))
-    Icon(
-      Icons.Outlined.Check,
-      stringResource(R.string.invite_to_group_button),
-      tint = color
+    val values = GroupMemberRole.values().filter { it <= groupInfo.membership.memberRole }.map { it to it.text }
+    ExposedDropDownSettingRow(
+      generalGetString(R.string.new_member_role),
+      values,
+      selectedRole,
+      icon = null,
+      enabled = rememberUpdatedState(enabled),
+      onSelected = { selectedRole.value = it }
     )
   }
 }
 
 @Composable
-fun InviteSectionFooter(selectedContactsCount: Int, clearSelection: () -> Unit) {
+fun InviteMembersButton(onClick: () -> Unit, disabled: Boolean) {
+  SettingsActionItem(
+    Icons.Outlined.Check,
+    stringResource(R.string.invite_to_group_button),
+    click = onClick,
+    textColor = MaterialTheme.colors.primary,
+    iconColor = MaterialTheme.colors.primary,
+    disabled = disabled,
+  )
+}
+
+@Composable
+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 = if (selectedContactsCount >= 1) Arrangement.SpaceBetween else Arrangement.End,
+    horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
     if (selectedContactsCount >= 1) {
-      Box(
-        Modifier.clickable { clearSelection() }
-      ) {
-        Text(
-          stringResource(R.string.clear_contacts_selection_button),
-          color = MaterialTheme.colors.primary,
-          fontSize = 12.sp
-        )
-      }
-
       Text(
         String.format(generalGetString(R.string.num_contacts_selected), selectedContactsCount),
         color = HighOrLowlight,
         fontSize = 12.sp
       )
+      Box(
+        Modifier.clickable { if (enabled) clearSelection() }
+      ) {
+        Text(
+          stringResource(R.string.clear_contacts_selection_button),
+          color = if (enabled) MaterialTheme.colors.primary else HighOrLowlight,
+          fontSize = 12.sp
+        )
+      }
     } else {
       Text(
         stringResource(R.string.no_contacts_selected),
@@ -251,18 +236,19 @@ 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
 ) {
   Column {
     contacts.forEachIndexed { index, contact ->
-      SectionItemView {
-        ContactCheckRow(
-          contact, addContact, removeContact,
-          checked = selectedContacts.contains(contact.apiId)
-        )
-      }
+      ContactCheckRow(
+        contact, groupInfo, addContact, removeContact,
+        checked = selectedContacts.contains(contact.apiId),
+        enabled = enabled,
+      )
       if (index < contacts.lastIndex) {
         SectionDivider()
       }
@@ -273,45 +259,77 @@ fun ContactList(
 @Composable
 fun ContactCheckRow(
   contact: Contact,
+  groupInfo: GroupInfo,
   addContact: (Long) -> Unit,
   removeContact: (Long) -> Unit,
-  checked: Boolean
+  checked: Boolean,
+  enabled: Boolean,
 ) {
-  Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { if (!checked) addContact(contact.apiId) else removeContact(contact.apiId) },
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically
+  val prohibitedToInviteIncognito = !groupInfo.membership.memberIncognito && contact.contactConnIncognito
+  val icon: ImageVector
+  val iconColor: Color
+  if (prohibitedToInviteIncognito) {
+    icon = Icons.Filled.TheaterComedy
+    iconColor = HighOrLowlight
+  } else if (checked) {
+    icon = Icons.Filled.CheckCircle
+    iconColor = if (enabled) MaterialTheme.colors.primary else HighOrLowlight
+  } else {
+    icon = Icons.Outlined.Circle
+    iconColor = HighOrLowlight
+  }
+  SectionItemView(
+    click = if (enabled) {
+      {
+        if (prohibitedToInviteIncognito) {
+          showProhibitedToInviteIncognitoAlertDialog()
+        } else if (!checked)
+          addContact(contact.apiId)
+        else
+          removeContact(contact.apiId)
+      }
+    } else null
   ) {
-    Row(
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-      ProfileImage(size = 36.dp, contact.image)
-      Text(contact.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis)
-    }
+    ProfileImage(size = 36.dp, contact.image)
+    Spacer(Modifier.width(DEFAULT_SPACE_AFTER_ICON))
+    Text(
+      contact.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
+      color = if (prohibitedToInviteIncognito) HighOrLowlight else Color.Unspecified
+    )
+    Spacer(Modifier.fillMaxWidth().weight(1f))
     Icon(
-      if (checked) Icons.Filled.CheckCircle else Icons.Outlined.Circle,
+      icon,
       contentDescription = stringResource(R.string.icon_descr_contact_checked),
-      tint = if (checked) MaterialTheme.colors.primary else HighOrLowlight
+      tint = iconColor
     )
   }
 }
 
+fun showProhibitedToInviteIncognitoAlertDialog() {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.invite_prohibited),
+    text = generalGetString(R.string.invite_prohibited_description),
+    confirmText = generalGetString(R.string.ok),
+  )
+}
+
 @Preview
 @Composable
 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,31 +4,37 @@ 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.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 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.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.TAG
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.*
-import chat.simplex.app.views.chatlist.populateGroupMembers
+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()
@@ -41,28 +47,34 @@ fun GroupChatInfoView(chatModel: ChatModel, close: () -> Unit) {
         .filter { it.memberStatus != GroupMemberStatus.MemLeft && it.memberStatus != GroupMemberStatus.MemRemoved }
         .sortedBy { it.displayName.lowercase() },
       developerTools,
+      groupLink,
       addMembers = {
         withApi {
-          populateGroupMembers(groupInfo, chatModel)
-          ModalManager.shared.showCustomModal { close ->
-            ModalView(
-              close = close, modifier = Modifier,
-              background = if (isSystemInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
-            ) {
-              AddGroupMembersView(groupInfo, chatModel, close)
-            }
+          setGroupMembers(groupInfo, chatModel)
+          ModalManager.shared.showModalCloseable(true) { close ->
+            AddGroupMembersView(groupInfo, false, chatModel, close)
           }
         }
       },
       showMemberInfo = { member ->
         withApi {
-          val connStats = chatModel.controller.apiGroupMemberInfo(groupInfo.groupId, member.groupMemberId)
-          ModalManager.shared.showCustomModal { close ->
-            ModalView(
-              close = close, modifier = Modifier,
-              background = if (isSystemInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
-            ) {
-              GroupMemberInfoView(groupInfo, member, connStats, chatModel, close)
+          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 ->
+            remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
+              GroupMemberInfoView(groupInfo, mem, stats, code, chatModel, closeCurrent) {
+                closeCurrent()
+                close()
+              }
             }
           }
         }
@@ -70,17 +82,35 @@ fun GroupChatInfoView(chatModel: ChatModel, close: () -> Unit) {
       editGroupProfile = {
         ModalManager.shared.showCustomModal { close -> GroupProfileView(groupInfo, chatModel, close) }
       },
-      deleteGroup = { deleteGroupDialog(chat.chatInfo, 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) }
+      leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) },
+      manageGroupLink = {
+          ModalManager.shared.showModal { GroupLinkView(chatModel, groupInfo, groupLink, groupLinkMemberRole, onGroupLinkUpdated) }
+      }
     )
   }
 }
 
-fun deleteGroupDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
+fun deleteGroupDialog(chatInfo: ChatInfo, groupInfo: GroupInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
+  val alertTextKey =
+    if (groupInfo.membership.memberCurrent) R.string.delete_group_for_all_members_cannot_undo_warning
+    else R.string.delete_group_for_self_cannot_undo_warning
   AlertManager.shared.showAlertMsg(
     title = generalGetString(R.string.delete_group_question),
-    text = generalGetString(R.string.delete_group_for_all_members_cannot_undo_warning),
+    text = generalGetString(alertTextKey),
     confirmText = generalGetString(R.string.delete_verb),
     onConfirm = {
       withApi {
@@ -116,12 +146,16 @@ 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,
+  manageGroupLink: () -> Unit,
 ) {
   Column(
     Modifier
@@ -133,18 +167,40 @@ fun GroupChatInfoLayout(
       Modifier.fillMaxWidth(),
       horizontalArrangement = Arrangement.Center
     ) {
-      ChatInfoHeader(chat.chatInfo)
+      GroupChatInfoHeader(chat.chatInfo)
     }
     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 {
-          AddMembersButton(addMembers)
+        SectionItemView(manageGroupLink) {
+          if (groupLink == null) {
+            CreateGroupLinkButton()
+          } else {
+            GroupLinkButton()
+          }
+        }
+        SectionDivider()
+        val onAddMembersClick = if (chat.chatInfo.incognito) ::cantInviteIncognitoAlert else addMembers
+        SectionItemView(onAddMembersClick) {
+          val tint = if (chat.chatInfo.incognito) HighOrLowlight else MaterialTheme.colors.primary
+          AddMembersButton(tint)
         }
         SectionDivider()
       }
-      SectionItemView(height = 50.dp) {
+      SectionItemView(minHeight = 50.dp) {
         MemberRow(groupInfo.membership, user = true)
       }
       if (members.isNotEmpty()) {
@@ -153,28 +209,15 @@ fun GroupChatInfoLayout(
       MembersList(members, showMemberInfo)
     }
     SectionSpacer()
-
     SectionView {
-      if (groupInfo.canEdit) {
-        SectionItemView {
-          EditGroupProfileButton(editGroupProfile)
-        }
-        SectionDivider()
-      }
-      SectionItemView {
-        ClearChatButton(clearChat)
-      }
+      ClearChatButton(clearChat)
       if (groupInfo.canDelete) {
         SectionDivider()
-        SectionItemView {
-          DeleteGroupButton(deleteGroup)
-        }
+        SectionItemView(deleteGroup) { DeleteGroupButton() }
       }
       if (groupInfo.membership.memberCurrent) {
         SectionDivider()
-        SectionItemView {
-          LeaveGroupButton(leaveGroup)
-        }
+        SectionItemView(leaveGroup) { LeaveGroupButton() }
       }
     }
     SectionSpacer()
@@ -191,29 +234,60 @@ fun GroupChatInfoLayout(
 }
 
 @Composable
-fun AddMembersButton(addMembers: () -> Unit) {
+private fun GroupChatInfoHeader(cInfo: ChatInfo) {
+  Column(
+    Modifier.padding(horizontal = 8.dp),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
+    Text(
+      cInfo.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) {
+      Text(
+        cInfo.fullName, style = MaterialTheme.typography.h2,
+        color = MaterialTheme.colors.onBackground,
+        maxLines = 2,
+        overflow = TextOverflow.Ellipsis
+      )
+    }
+  }
+}
+
+@Composable
+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()
-      .clickable { addMembers() },
+    Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
   ) {
     Icon(
       Icons.Outlined.Add,
       stringResource(R.string.button_add_members),
-      tint = MaterialTheme.colors.primary
+      tint = tint
     )
     Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_add_members), color = MaterialTheme.colors.primary)
+    Text(stringResource(R.string.button_add_members), color = tint)
   }
 }
 
 @Composable
-fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
+private fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
   Column {
     members.forEachIndexed { index, member ->
-      SectionItemView(height = 50.dp) {
-        MemberRow(member, showMemberInfo)
+      SectionItemView({ showMemberInfo(member) }, minHeight = 50.dp) {
+        MemberRow(member)
       }
       if (index < members.lastIndex) {
         SectionDivider()
@@ -223,20 +297,28 @@ fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Uni
 }
 
 @Composable
-fun MemberRow(member: GroupMember, showMemberInfo: ((GroupMember) -> Unit)? = null, user: Boolean = false) {
-  val modifier = if (showMemberInfo != null) Modifier.clickable { showMemberInfo(member) } else Modifier
+private fun MemberRow(member: GroupMember, user: Boolean = false) {
   Row(
-    modifier.fillMaxSize(),
+    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)
+        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(
@@ -256,29 +338,87 @@ fun MemberRow(member: GroupMember, showMemberInfo: ((GroupMember) -> Unit)? = nu
 }
 
 @Composable
-fun EditGroupProfileButton(editGroupProfile: () -> Unit) {
+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()
-      .clickable { editGroupProfile() },
+      .fillMaxSize(),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Link,
+      stringResource(R.string.group_link),
+      tint = HighOrLowlight
+    )
+    Spacer(Modifier.size(8.dp))
+    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))
+  }
+}
+
+@Composable
+fun EditGroupProfileButton() {
+  Row(
+    Modifier
+      .fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
   ) {
     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(leaveGroup: () -> Unit) {
+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()
-      .clickable { leaveGroup() },
+      .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
   ) {
     Icon(
@@ -292,11 +432,9 @@ fun LeaveGroupButton(leaveGroup: () -> Unit) {
 }
 
 @Composable
-fun DeleteGroupButton(deleteGroup: () -> Unit) {
+private fun DeleteGroupButton() {
   Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { deleteGroup() },
+    Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
   ) {
     Icon(
@@ -316,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 = {}
+      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

@@ -0,0 +1,189 @@
+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
+import androidx.compose.ui.platform.LocalContext
+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.*
+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?, 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,
+    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)
+          }
+        }
+      }
+    },
+    deleteLink = {
+      AlertManager.shared.showAlertMsg(
+        title = generalGetString(R.string.delete_link_question),
+        text = generalGetString(R.string.all_group_members_will_remain_connected),
+        confirmText = generalGetString(R.string.delete_verb),
+        onConfirm = {
+          withApi {
+            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
+      .verticalScroll(rememberScrollState())
+      .padding(start = DEFAULT_PADDING, bottom = DEFAULT_BOTTOM_PADDING, end = DEFAULT_PADDING),
+    horizontalAlignment = Alignment.Start,
+    verticalArrangement = Arrangement.Top
+  ) {
+    AppBarTitle(stringResource(R.string.group_link), false)
+    Text(
+      stringResource(R.string.you_can_share_group_link_anybody_will_be_able_to_connect),
+      Modifier.padding(bottom = 12.dp),
+      lineHeight = 22.sp
+    )
+    Column(
+      Modifier.fillMaxWidth(),
+      horizontalAlignment = Alignment.CenterHorizontally,
+      verticalArrangement = Arrangement.SpaceEvenly
+    ) {
+      if (groupLink == null) {
+        SimpleButton(stringResource(R.string.button_create_group_link), icon = Icons.Outlined.AddLink, disabled = creatingLink, click = createLink)
+      } else {
+        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,
+          modifier = Modifier.padding(vertical = 10.dp)
+        ) {
+          SimpleButton(
+            stringResource(R.string.share_link),
+            icon = Icons.Outlined.Share,
+            click = share
+          )
+          SimpleButton(
+            stringResource(R.string.delete_link),
+            icon = Icons.Outlined.Delete,
+            color = Color.Red,
+            click = deleteLink
+          )
+        }
+      }
+    }
+  }
+}
+
+@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

@@ -11,7 +11,7 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 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
@@ -23,33 +23,110 @@ 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.chat.SimplexServers
+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?, chatModel: ChatModel, close: () -> Unit) {
+fun GroupMemberInfoView(
+  groupInfo: GroupInfo,
+  member: GroupMember,
+  connStats: ConnectionStats?,
+  connectionCode: String?,
+  chatModel: ChatModel,
+  close: () -> Unit,
+  closeAll: () -> Unit, // Close all open windows up to ChatView
+) {
   BackHandler(onBack = close)
   val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
   val developerTools = chatModel.controller.appPrefs.developerTools.get()
   if (chat != null) {
+    val newRole = remember { mutableStateOf(member.memberRole) }
     GroupMemberInfoLayout(
       groupInfo,
       member,
       connStats,
+      newRole,
       developerTools,
-      removeMember = { removeMemberDialog(member, chatModel, close) }
+      connectionCode,
+      getContactChat = { chatModel.getContactChat(it) },
+      openDirectChat = {
+        withApi {
+          val c = chatModel.controller.apiGetChat(ChatType.Direct, it)
+          if (c != null) {
+            if (chatModel.getContactChat(it) == null) {
+              chatModel.addChat(c)
+            }
+            chatModel.chatItems.clear()
+            chatModel.chatItems.addAll(c.chatItems)
+            chatModel.chatId.value = c.id
+            closeAll()
+          }
+        }
+      },
+      removeMember = { removeMemberDialog(groupInfo, member, chatModel, close) },
+      onRoleSelected = {
+        if (it == newRole.value) return@GroupMemberInfoLayout
+        val prevValue = newRole.value
+        newRole.value = it
+        updateMemberRoleDialog(it, member, onDismiss = {
+          newRole.value = prevValue
+        }) {
+          withApi {
+            kotlin.runCatching {
+              val mem = chatModel.controller.apiMemberRole(groupInfo.groupId, member.groupMemberId, it)
+              chatModel.upsertGroupMember(groupInfo, mem)
+            }.onFailure {
+              newRole.value = prevValue
+            }
+          }
+        }
+      },
+      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,
+            )
+          }
+        }
+      }
     )
   }
 }
 
-fun removeMemberDialog(member: GroupMember, chatModel: ChatModel, close: (() -> Unit)? = null) {
+fun removeMemberDialog(groupInfo: GroupInfo, member: GroupMember, chatModel: ChatModel, close: (() -> Unit)? = null) {
   AlertManager.shared.showAlertMsg(
     title = generalGetString(R.string.button_remove_member),
     text = generalGetString(R.string.member_will_be_removed_from_group_cannot_be_undone),
     confirmText = generalGetString(R.string.remove_member_confirmation),
     onConfirm = {
       withApi {
-        chatModel.controller.apiRemoveMember(member.groupId, member.groupMemberId)
+        val removedMember = chatModel.controller.apiRemoveMember(member.groupId, member.groupMemberId)
+        if (removedMember != null) {
+          chatModel.upsertGroupMember(groupInfo, removedMember)
+        }
         close?.invoke()
       }
     }
@@ -61,8 +138,15 @@ fun GroupMemberInfoLayout(
   groupInfo: GroupInfo,
   member: GroupMember,
   connStats: ConnectionStats?,
+  newRole: MutableState<GroupMemberRole>,
   developerTools: Boolean,
+  connectionCode: String?,
+  getContactChat: (Long) -> Chat?,
+  openDirectChat: (Long) -> Unit,
   removeMember: () -> Unit,
+  onRoleSelected: (GroupMemberRole) -> Unit,
+  switchMemberAddress: () -> Unit,
+  verifyClicked: () -> Unit,
 ) {
   Column(
     Modifier
@@ -78,8 +162,36 @@ fun GroupMemberInfoLayout(
     }
     SectionSpacer()
 
+    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) || groupInfo.fullGroupPreferences.directMessages.on) {
+            OpenChatButton(onClick = { openDirectChat(contactId) })
+            if (connectionCode != null) {
+              SectionDivider()
+            }
+          }
+          if (connectionCode != null) {
+            VerifyCodeButton(member.verified, verifyClicked)
+          }
+        }
+        SectionSpacer()
+      }
+    }
+
     SectionView(title = stringResource(R.string.member_info_section_title_member)) {
       InfoRow(stringResource(R.string.info_row_group), groupInfo.displayName)
+      SectionDivider()
+      val roles = remember { member.canChangeRoleTo(groupInfo) }
+      if (roles != null) {
+        SectionItemView {
+          RoleSelectionRow(roles, newRole, onRoleSelected)
+        }
+      } else {
+        InfoRow(stringResource(R.string.role_in_group), member.memberRole.text)
+      }
       val conn = member.activeConn
       if (conn != null) {
         SectionDivider()
@@ -90,12 +202,13 @@ fun GroupMemberInfoLayout(
       }
     }
     SectionSpacer()
-
     if (connStats != null) {
-      val rcvServers = connStats.rcvServers
-      val sndServers = connStats.sndServers
-      if ((rcvServers != null && rcvServers.isNotEmpty()) || (sndServers != null && sndServers.isNotEmpty())) {
-        SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+      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())) {
           if (rcvServers != null && rcvServers.isNotEmpty()) {
             SimplexServers(stringResource(R.string.receiving_via), rcvServers)
             if (sndServers != null && sndServers.isNotEmpty()) {
@@ -106,15 +219,13 @@ fun GroupMemberInfoLayout(
             SimplexServers(stringResource(R.string.sending_via), sndServers)
           }
         }
-        SectionSpacer()
       }
+      SectionSpacer()
     }
 
-    if (member.canBeRemoved(groupInfo.membership)) {
+    if (member.canBeRemoved(groupInfo)) {
       SectionView {
-        SectionItemView {
-          RemoveMemberButton(removeMember)
-        }
+        RemoveMemberButton(removeMember)
       }
       SectionSpacer()
     }
@@ -136,13 +247,18 @@ fun GroupMemberInfoHeader(member: GroupMember) {
     Modifier.padding(horizontal = 8.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    ProfileImage(size = 192.dp, member.image, color = if (isSystemInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Text(
-      member.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      color = MaterialTheme.colors.onBackground,
-      maxLines = 1,
-      overflow = TextOverflow.Ellipsis
-    )
+    ProfileImage(size = 192.dp, member.image, color = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
+    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,
@@ -155,23 +271,73 @@ fun GroupMemberInfoHeader(member: GroupMember) {
 }
 
 @Composable
-fun RemoveMemberButton(removeMember: () -> Unit) {
+fun RemoveMemberButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.Delete,
+    stringResource(R.string.button_remove_member),
+    click = onClick,
+    textColor = Color.Red,
+    iconColor = Color.Red,
+  )
+}
+
+@Composable
+fun OpenChatButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.Message,
+    stringResource(R.string.button_send_direct_message),
+    click = onClick,
+    textColor = MaterialTheme.colors.primary,
+    iconColor = MaterialTheme.colors.primary,
+  )
+}
+
+@Composable
+private fun RoleSelectionRow(
+  roles: List<GroupMemberRole>,
+  selectedRole: MutableState<GroupMemberRole>,
+  onSelected: (GroupMemberRole) -> Unit
+) {
   Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { removeMember() },
-    verticalAlignment = Alignment.CenterVertically
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
   ) {
-    Icon(
-      Icons.Outlined.Delete,
-      stringResource(R.string.button_remove_member),
-      tint = Color.Red
+    val values = remember { roles.map { it to it.text } }
+    ExposedDropDownSettingRow(
+      generalGetString(R.string.change_role),
+      values,
+      selectedRole,
+      icon = null,
+      enabled = remember { mutableStateOf(true) },
+      onSelected = onSelected
     )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_remove_member), color = Color.Red)
   }
 }
 
+private fun updateMemberRoleDialog(
+  newRole: GroupMemberRole,
+  member: GroupMember,
+  onDismiss: () -> Unit,
+  onConfirm: () -> Unit
+) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.change_member_role_question),
+    text = if (member.memberCurrent)
+      String.format(generalGetString(R.string.member_role_will_be_changed_with_notification), newRole.text)
+    else
+      String.format(generalGetString(R.string.member_role_will_be_changed_with_invitation), newRole.text),
+    confirmText = generalGetString(R.string.change_verb),
+    onDismiss = onDismiss,
+    onConfirm = onConfirm,
+    onDismissRequest = onDismiss
+  )
+}
+
+private fun switchMemberAddress(m: ChatModel, groupInfo: GroupInfo, member: GroupMember) = withApi {
+  m.controller.apiSwitchGroupMember(groupInfo.apiId, member.groupMemberId)
+}
+
 @Preview
 @Composable
 fun PreviewGroupMemberInfoLayout() {
@@ -180,8 +346,15 @@ fun PreviewGroupMemberInfoLayout() {
       groupInfo = GroupInfo.sampleData,
       member = GroupMember.sampleData,
       connStats = null,
+      newRole = remember { mutableStateOf(GroupMemberRole.Member) },
       developerTools = false,
-      removeMember = {}
+      connectionCode = "123",
+      getContactChat = { Chat.sampleData },
+      openDirectChat = {},
+      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
@@ -17,14 +19,14 @@ 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.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.ProfileNameField
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.isValidDisplayName
 import chat.simplex.app.views.usersettings.*
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
 @Composable
@@ -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() }
@@ -78,7 +80,7 @@ fun GroupProfileLayout(
         Column(
           Modifier
             .verticalScroll(scrollState)
-            .padding(bottom = 16.dp),
+            .padding(horizontal = DEFAULT_PADDING),
           horizontalAlignment = Alignment.Start
         ) {
           Text(
@@ -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 {
@@ -147,6 +155,7 @@ fun GroupProfileLayout(
           }
 
           LaunchedEffect(Unit) {
+            delay(300)
             focusRequester.requestFocus()
           }
         }

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

@@ -17,42 +17,48 @@ import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
-fun CIGroupEventView(ci: ChatItem) {
-  fun withGroupEventStyle(builder: AnnotatedString.Builder, text: String) {
-    return builder.withStyle(SpanStyle(fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)) { append(text) }
+fun CIEventView(ci: ChatItem) {
+  @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,
   name = "Dark Mode"
 )
 @Composable
-fun CIGroupEventViewPreview() {
+fun CIEventViewPreview() {
   SimpleXTheme {
-    CIGroupEventView(
+    CIEventView(
       ChatItem.getGroupEventSample()
     )
   }

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

@@ -2,8 +2,8 @@ package chat.simplex.app.views.chat.item
 
 import android.widget.Toast
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
 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
@@ -17,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
@@ -39,7 +40,7 @@ fun CIFileView(
   @Composable
   fun fileIcon(
     innerIcon: ImageVector? = null,
-    color: Color = if (isSystemInDarkTheme()) FileDark else FileLight
+    color: Color = if (isInDarkTheme()) FileDark else FileLight
   ) {
     Box(
       contentAlignment = Alignment.Center
@@ -65,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
   }
@@ -73,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,11 +114,25 @@ fun CIFileView(
   fun progressIndicator() {
     CircularProgressIndicator(
       Modifier.size(32.dp),
-      color = if (isSystemInDarkTheme()) FileDark else FileLight,
-      strokeWidth = 4.dp
+      color = if (isInDarkTheme()) FileDark else FileLight,
+      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(
@@ -121,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()
@@ -175,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
@@ -192,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),
@@ -206,6 +242,6 @@ class ChatItemProvider: PreviewParameterProvider<ChatItem> {
 fun PreviewCIFileFramedItemView(@PreviewParameter(ChatItemProvider::class) chatItem: ChatItem) {
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
-    FramedItemView(User.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/CIGroupInvitationView.kt

@@ -3,7 +3,6 @@ package chat.simplex.app.views.chat.item
 import android.content.res.Configuration
 import android.util.Log
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
@@ -19,7 +18,6 @@ import androidx.compose.ui.tooling.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.helpers.*
@@ -29,6 +27,7 @@ fun CIGroupInvitationView(
   ci: ChatItem,
   groupInvitation: CIGroupInvitation,
   memberRole: GroupMemberRole,
+  chatIncognito: Boolean = false,
   joinGroup: (Long) -> Unit
 ) {
   val sent = ci.chatDir.sent
@@ -38,8 +37,8 @@ fun CIGroupInvitationView(
   fun groupInfoView() {
     val p = groupInvitation.groupProfile
     val iconColor =
-      if (action) MaterialTheme.colors.primary
-      else if (isSystemInDarkTheme()) FileDark else FileLight
+      if (action) if (chatIncognito) Indigo else MaterialTheme.colors.primary
+      else if (isInDarkTheme()) FileDark else FileLight
 
     Row(
       Modifier
@@ -47,7 +46,7 @@ fun CIGroupInvitationView(
         .padding(vertical = 4.dp)
         .padding(end = 2.dp)
     ) {
-      ProfileImage(size = 60.dp, icon = Icons.Filled.SupervisedUserCircle, color = iconColor)
+      ProfileImage(size = 60.dp, image = groupInvitation.groupProfile.image, icon = Icons.Filled.SupervisedUserCircle, color = iconColor)
       Spacer(Modifier.padding(horizontal = 3.dp))
       Column(
         Modifier.defaultMinSize(minHeight = 60.dp),
@@ -72,13 +71,10 @@ fun CIGroupInvitationView(
     }
   }
 
-  fun acceptInvitation() {
-    Log.d(TAG, "CIGroupInvitationView acceptInvitation")
-    joinGroup(groupInvitation.groupId)
-  }
-
   Surface(
-    modifier = if (action) Modifier.clickable(onClick = ::acceptInvitation) else Modifier,
+    modifier = if (action) Modifier.clickable(onClick = {
+      joinGroup(groupInvitation.groupId)
+    }) else Modifier,
     shape = RoundedCornerShape(18.dp),
     color = if (sent) SentColorLight else ReceivedColorLight,
   ) {
@@ -100,7 +96,9 @@ fun CIGroupInvitationView(
           Divider(Modifier.fillMaxWidth().padding(bottom = 4.dp))
           if (action) {
             groupInvitationText()
-            Text(stringResource(R.string.group_invitation_tap_to_join), color = MaterialTheme.colors.primary)
+            Text(stringResource(
+              if (chatIncognito) R.string.group_invitation_tap_to_join_incognito else  R.string.group_invitation_tap_to_join),
+              color = if (chatIncognito) Indigo else MaterialTheme.colors.primary)
           } else {
             Box(Modifier.padding(end = 48.dp)) {
               groupInvitationText()

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

@@ -1,4 +1,8 @@
+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.*
@@ -6,29 +10,60 @@ 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.MoreHoriz
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
+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.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.platform.LocalContext
+import androidx.compose.ui.layout.layoutId
+import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.Dp
 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
+import coil.decode.GifDecoder
+import coil.decode.ImageDecoderDecoder
+import coil.request.ImageRequest
+import java.io.File
 
 @Composable
 fun CIImageView(
   image: String,
   file: CIFile?,
+  imageProvider: () -> ImageGalleryProvider,
   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) {
@@ -39,38 +74,30 @@ 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
-            )
+          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 -> {}
         }
       }
     }
   }
 
+  @Composable
+  fun imageViewFullWidth(): Dp {
+    val approximatePadding = 100.dp
+    return with(LocalDensity.current) { minOf(1000.dp, LocalView.current.width.toDp() - approximatePadding) }
+  }
+
   @Composable
   fun imageView(imageBitmap: Bitmap, onClick: () -> Unit) {
     Image(
@@ -79,7 +106,7 @@ fun CIImageView(
       // .width(1000.dp) is a hack for image to increase IntrinsicSize of FramedItemView
       // if text is short and take all available width if text is long
       modifier = Modifier
-        .width(1000.dp)
+        .width(if (imageBitmap.width * 0.97 <= imageBitmap.height) imageViewFullWidth() * 0.75f else 1000.dp)
         .combinedClickable(
           onLongClick = { showMenu.value = true },
           onClick = onClick
@@ -88,13 +115,56 @@ fun CIImageView(
     )
   }
 
-  Box(contentAlignment = Alignment.TopEnd) {
+  @Composable
+  fun imageView(painter: Painter, onClick: () -> Unit) {
+    Image(
+      painter,
+      contentDescription = stringResource(R.string.image_descr),
+      // .width(1000.dp) is a hack for image to increase IntrinsicSize of FramedItemView
+      // if text is short and take all available width if text is long
+      modifier = Modifier
+        .width(if (painter.intrinsicSize.width * 0.97 <= painter.intrinsicSize.height) imageViewFullWidth() * 0.75f else 1000.dp)
+        .combinedClickable(
+          onLongClick = { showMenu.value = true },
+          onClick = onClick
+        ),
+      contentScale = ContentScale.FillWidth,
+    )
+  }
+
+  fun fileSizeValid(): Boolean {
+    if (file != null) {
+      return file.fileSize <= getMaxFileSize(file.fileProtocol)
+    }
+    return false
+  }
+
+  fun imageAndFilePath(file: CIFile?): Pair<Bitmap?, String?> {
+    val imageBitmap: Bitmap? = getLoadedImage(SimplexApp.context, file)
+    val filePath = getLoadedFilePath(SimplexApp.context, file)
+    return imageBitmap to filePath
+  }
+
+  Box(
+    Modifier.layoutId(CHAT_IMAGE_LAYOUT_ID),
+    contentAlignment = Alignment.TopEnd
+  ) {
     val context = LocalContext.current
-    val imageBitmap: Bitmap? = getLoadedImage(context, file)
-    if (imageBitmap != null) {
-      imageView(imageBitmap, onClick = {
+    val (imageBitmap, filePath) = remember(file) { imageAndFilePath(file) }
+    if (imageBitmap != null && filePath != null) {
+      val uri = remember(filePath) { FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))  }
+      val imagePainter = rememberAsyncImagePainter(
+        ImageRequest.Builder(context).data(data = uri).size(coil.size.Size.ORIGINAL).build(),
+        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 { close -> ImageFullScreenView(imageBitmap, close) }
+          ModalManager.shared.showCustomModal(animated = false) { close ->
+            ImageFullScreenView(imageProvider, close)
+          }
         }
       })
     } else {
@@ -102,13 +172,28 @@ fun CIImageView(
         if (file != null) {
           when (file.fileStatus) {
             CIFileStatus.RcvInvitation ->
-              receiveFile(file.fileId)
+              if (fileSizeValid()) {
+                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)))
+                )
+              }
             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 -> {}
@@ -119,3 +204,13 @@ fun CIImageView(
     loadingIndicator()
   }
 }
+
+private val imageLoader = ImageLoader.Builder(SimplexApp.context)
+  .components {
+    if (SDK_INT >= 28) {
+      add(ImageDecoderDecoder.Factory())
+    } else {
+      add(GifDecoder.Factory())
+    }
+  }
+  .build()

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

@@ -1,65 +1,88 @@
 package chat.simplex.app.views.chat.item
 
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.Icon
-import androidx.compose.material.Text
+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 chat.simplex.app.ui.theme.SimplexBlue
 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 = SimplexBlue)
-    }
-    else -> {}
-  }
+private fun StatusIconText(icon: ImageVector, color: Color) {
+  Icon(icon, null, Modifier.height(12.dp), tint = color)
 }
 
 @Preview
@@ -68,7 +91,8 @@ fun PreviewCIMetaView() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-    )
+    ),
+    null
   )
 }
 
@@ -79,7 +103,8 @@ fun PreviewCIMetaViewUnread() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       status = CIStatus.RcvNew()
-    )
+    ),
+    null
   )
 }
 
@@ -89,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
   )
 }
 
@@ -100,7 +126,8 @@ fun PreviewCIMetaViewSendNoAuth() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndErrorAuth()
-    )
+    ),
+    null
   )
 }
 
@@ -110,7 +137,8 @@ fun PreviewCIMetaViewSendSent() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndSent()
-    )
+    ),
+    null
   )
 }
 
@@ -121,7 +149,8 @@ fun PreviewCIMetaViewEdited() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true
-    )
+    ),
+    null
   )
 }
 
@@ -133,7 +162,8 @@ fun PreviewCIMetaViewEditedUnread() {
       1, CIDirection.DirectRcv(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.RcvNew()
-    )
+    ),
+    null
   )
 }
 
@@ -145,7 +175,8 @@ fun PreviewCIMetaViewEditedSent() {
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.SndSent()
-    )
+    ),
+    null
   )
 }
 
@@ -153,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
@@ -18,120 +19,220 @@ import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 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,
   useLinkPreviews: Boolean,
+  linkMode: SimplexLinkMode,
   deleteMessage: (Long, CIDeleteMode) -> Unit,
   receiveFile: (Long) -> Unit,
+  cancelFile: (Long) -> Unit,
   joinGroup: (Long) -> Unit,
-  acceptCall: (Contact) -> 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(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile, onLinkLongClick)
+          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))
+          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(context, cItem.text, filePath)
+              else -> shareText(context, cItem.content.text)
             }
             showMenu.value = false
           })
-          ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
-            shareText(cxt, 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)
         }
       }
 
@@ -146,16 +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.RcvGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup)
-        is CIContent.SndGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup)
-        is CIContent.RcvGroupEventContent -> CIGroupEventView(cItem)
-        is CIContent.SndGroupEventContent -> CIGroupEventView(cItem)
+        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) {
@@ -164,7 +334,8 @@ fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Colo
         text,
         modifier = Modifier
           .fillMaxWidth()
-          .weight(1F),
+          .weight(1F)
+          .padding(end = 15.dp),
         color = color
       )
       Icon(icon, text, tint = color)
@@ -172,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
@@ -183,13 +366,13 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteM
           .padding(horizontal = 8.dp, vertical = 2.dp),
         horizontalArrangement = Arrangement.End,
       ) {
-        Button(onClick = {
+        TextButton(onClick = {
           deleteMessage(chatItem.id, CIDeleteMode.cidmInternal)
           AlertManager.shared.hideAlert()
         }) { Text(stringResource(R.string.for_me_only)) }
         if (chatItem.meta.editable) {
           Spacer(Modifier.padding(horizontal = 4.dp))
-          Button(onClick = {
+          TextButton(onClick = {
             deleteMessage(chatItem.id, CIDeleteMode.cidmBroadcast)
             AlertManager.shared.hideAlert()
           }) { Text(stringResource(R.string.for_everybody)) }
@@ -199,23 +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,
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
-      acceptCall = { _ -> }
+      acceptCall = { _ -> },
+      scrollToItem = {},
+      acceptFeature = { _, _, _ -> }
     )
   }
 }
@@ -225,16 +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,
       deleteMessage = { _, _ -> },
       receiveFile = {},
+      cancelFile = {},
       joinGroup = {},
-      acceptCall = { _ -> }
+      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)
   }
 }
 
@@ -31,12 +31,19 @@ fun EmojiText(text: String) {
   Text(s, style = if (s.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont)
 }
 
-private fun isSimpleEmoji(c: Int): Boolean = c > 0x238C
+// https://stackoverflow.com/a/46279500
+private const val emojiStr = "^(" +
+    "(?:[\\u2700-\\u27bf]|" +
+    "(?:[\\ud83c\\udde6-\\ud83c\\uddff]){2}|" +
+    "[\\ud800\\udc00-\\uDBFF\\uDFFF]|[\\u2600-\\u26FF])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]|[\\ud83c\\udffb-\\ud83c\\udfff])?" +
+    "(?:\\u200d(?:[^\\ud800-\\udfff]|" +
+    "(?:[\\ud83c\\udde6-\\ud83c\\uddff]){2}|" +
+    "[\\ud800\\udc00-\\uDBFF\\uDFFF]|[\\u2600-\\u26FF])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]|[\\ud83c\\udffb-\\ud83c\\udfff])?)*|" +
+    "[\\u0023-\\u0039]\\ufe0f?\\u20e3|\\u3299|\\u3297|\\u303d|\\u3030|\\u24c2|[\\ud83c\\udd70-\\ud83c\\udd71]|[\\ud83c\\udd7e-\\ud83c\\udd7f]|\\ud83c\\udd8e|[\\ud83c\\udd91-\\ud83c\\udd9a]|[\\ud83c\\udde6-\\ud83c\\uddff]|[\\ud83c\\ude01-\\ud83c\\ude02]|\\ud83c\\ude1a|\\ud83c\\ude2f|[\\ud83c\\ude32-\\ud83c\\ude3a]|[\\ud83c\\ude50-\\ud83c\\ude51]|\\u203c|\\u2049|[\\u25aa-\\u25ab]|\\u25b6|\\u25c0|[\\u25fb-\\u25fe]|\\u00a9|\\u00ae|\\u2122|\\u2139|\\ud83c\\udc04|[\\u2600-\\u26FF]|\\u2b05|\\u2b06|\\u2b07|\\u2b1b|\\u2b1c|\\u2b50|\\u2b55|\\u231a|\\u231b|\\u2328|\\u23cf|[\\u23e9-\\u23f3]|[\\u23f8-\\u23fa]|\\ud83c\\udccf|\\u2934|\\u2935|[\\u2190-\\u21ff]" +
+    ")+$" // Multiple matches with emojis where one follows another without interruptions from other characters
+private val emojiRegex = Regex(emojiStr)
 
-fun isEmoji(c: Int): Boolean = isSimpleEmoji(c) // || isCombinedIntoEmoji(c)
-
-// TODO count perceived emojis, possibly using icu4j
 fun isShortEmoji(str: String): Boolean {
   val s = str.trim()
-  return s.codePoints().count() in 1..5 && s.codePoints().allMatch(::isEmoji)
+  return s.codePoints().count() in 1..5 && emojiRegex.matches(str)
 }

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

@@ -1,31 +1,36 @@
 package chat.simplex.app.views.chat.item
 
-import CIImageView
 import androidx.compose.foundation.*
 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
+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.layout.ContentScale
+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.dp
-import androidx.compose.ui.unit.sp
+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)
@@ -34,15 +39,23 @@ val ReceivedQuoteColorLight = Color(0x25B1B0B5)
 
 @Composable
 fun FramedItemView(
-  user: User,
+  chatInfo: ChatInfo,
   ci: ChatItem,
   uriHandler: UriHandler? = null,
+  imageProvider: (() -> ImageGalleryProvider)? = null,
   showMember: Boolean = false,
+  linkMode: SimplexLinkMode,
   showMenu: MutableState<Boolean>,
   receiveFile: (Long) -> Unit,
-  onLinkLongClick: (link: String) -> 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
+  }
 
   @Composable
   fun ciQuotedMsgView(qi: CIQuote) {
@@ -51,8 +64,39 @@ fun FramedItemView(
       contentAlignment = Alignment.TopStart
     ) {
       MarkdownText(
-        qi.text, qi.formattedText, sender = qi.sender(user), senderBold = true, maxLines = 3,
-        style = TextStyle(fontSize = 15.sp, color = MaterialTheme.colors.onSurface)
+        qi.text, qi.formattedText, sender = qi.sender(membership()), senderBold = true, maxLines = 3,
+        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
       )
     }
   }
@@ -63,6 +107,10 @@ fun FramedItemView(
       Modifier
         .background(if (sent) SentQuoteColorLight else ReceivedQuoteColorLight)
         .fillMaxWidth()
+        .combinedClickable(
+          onLongClick = { showMenu.value = true },
+          onClick = { scrollToItem(qi.itemId?: return@combinedClickable) }
+        )
     ) {
       when (qi.content) {
         is MsgContent.MCImage -> {
@@ -77,17 +125,29 @@ 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),
-            tint = if (isSystemInDarkTheme()) FileDark else FileLight
+            tint = if (isInDarkTheme()) FileDark else FileLight
           )
         }
         else -> ciQuotedMsgView(qi)
@@ -95,57 +155,94 @@ fun FramedItemView(
     }
   }
 
-  Surface(
-    shape = RoundedCornerShape(18.dp),
-    color = if (sent) SentColorLight else ReceivedColorLight
-  ) {
+  @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(
+      when {
+        transparentBackground -> Color.Transparent
+        sent -> SentColorLight
+        else -> ReceivedColorLight
+      }
+    )) {
     var metaColor = HighOrLowlight
     Box(contentAlignment = Alignment.BottomEnd) {
       Column(Modifier.width(IntrinsicSize.Max)) {
-        val qi = ci.quotedItem
-        if (qi != null) {
-          ciQuoteView(qi)
-        }
-        if (ci.file == null && ci.formattedText == null && isShortEmoji(ci.content.text)) {
-          Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
-            Column(
-              Modifier
-                .padding(bottom = 2.dp)
-                .fillMaxWidth(),
-              horizontalAlignment = Alignment.CenterHorizontally
-            ) {
-              EmojiText(ci.content.text)
-              Text("")
+        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)
           }
-        } else {
-          Column(Modifier.fillMaxWidth()) {
+          ci.quotedItem?.let { ciQuoteView(it) }
+          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
+                  .padding(bottom = 2.dp)
+                  .fillMaxWidth(),
+                horizontalAlignment = Alignment.CenterHorizontally
+              ) {
+                EmojiText(ci.content.text)
+                Text("")
+              }
+            }
+          } else {
             when (val mc = ci.content.msgContent) {
               is MsgContent.MCImage -> {
-                CIImageView(image = mc.image, file = ci.file, showMenu, receiveFile)
-                if (mc.text == "") {
+                CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, receiveFile)
+                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)
       }
     }
   }
@@ -154,19 +251,72 @@ 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(
+  modifier: Modifier = Modifier,
+  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
+  ) { measureable, constraints ->
+    // Find important element which should tell what max width other elements can use
+    // Expecting only one such element. Can be less than one but not more
+    val imagePlaceable = measureable.firstOrNull { it.layoutId == priorityLayoutId }?.measure(constraints)
+    val placeables: List<Placeable> = measureable.fastMap {
+      if (it.layoutId == priorityLayoutId)
+        imagePlaceable!!
+      else
+        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)
+        y += it.measuredHeight
+      }
+    }
+  }
+}
+
 class EditedProvider: PreviewParameterProvider<Boolean> {
   override val values = listOf(false, true).asSequence()
 }
@@ -177,10 +327,11 @@ fun PreviewTextItemViewSnd(@PreviewParameter(EditedProvider::class) edited: Bool
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello", itemEdited = edited,
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -193,10 +344,11 @@ fun PreviewTextItemViewRcv(@PreviewParameter(EditedProvider::class) edited: Bool
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectRcv(), Clock.System.now(), "hello", itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -209,7 +361,7 @@ fun PreviewTextItemViewLong(@PreviewParameter(EditedProvider::class) edited: Boo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1,
         CIDirection.DirectSnd(),
@@ -217,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 = {}
     )
@@ -229,7 +382,7 @@ fun PreviewTextItemViewQuote(@PreviewParameter(EditedProvider::class) edited: Bo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -238,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 = {}
     )
@@ -250,7 +404,7 @@ fun PreviewTextItemViewEmoji(@PreviewParameter(EditedProvider::class) edited: Bo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -259,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 = {}
     )
@@ -278,7 +433,7 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -287,6 +442,7 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -306,7 +462,7 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -315,6 +471,7 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -333,7 +490,7 @@ fun PreviewQuoteWithLongTextAndFile(@PreviewParameter(EditedProvider::class) edi
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -342,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

@@ -1,55 +1,218 @@
+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.gestures.detectTransformGestures
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
+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.input.pointer.pointerInput
+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.*
 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
+import coil.decode.GifDecoder
+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 totalMediaSize: MutableState<Int>
+  fun getMedia(index: Int): ProviderMedia?
+  fun currentPageChanged(index: Int)
+  fun scrollToStart()
+  fun onDismiss(index: Int)
+}
+
+@OptIn(ExperimentalPagerApi::class)
 @Composable
-fun ImageFullScreenView(imageBitmap: Bitmap, close: () -> Unit) {
-  BackHandler(onBack = close)
-  Column(
-    Modifier
-      .fillMaxSize()
-      .background(Color.Black)
-      .clickable(onClick = close)
-  ) {
-    var scale by remember { mutableStateOf(1f) }
-    var translationX by remember { mutableStateOf(0f) }
-    var translationY by remember { mutableStateOf(0f) }
-    Image(
-      imageBitmap.asImageBitmap(),
-      contentDescription = stringResource(R.string.image_descr),
-      contentScale = ContentScale.Fit,
-      modifier = Modifier
-        .graphicsLayer(
-          scaleX = scale,
-          scaleY = scale,
-          translationX = translationX,
-          translationY = translationY,
-        )
-        .pointerInput(Unit) {
-          detectTransformGestures(
-            onGesture = { _, pan, gestureZoom, _ ->
-              scale = (scale * gestureZoom).coerceIn(1f, 20f)
-              if (scale > 1) {
-                translationX += pan.x * scale
-                translationY += pan.y * scale
-              } else {
-                translationX = 0f
-                translationY = 0f
+fun ImageFullScreenView(imageProvider: () -> ImageGalleryProvider, close: () -> Unit) {
+  val provider = remember { imageProvider() }
+  val pagerState = rememberPagerState(provider.initialIndex)
+  val goBack = { provider.onDismiss(pagerState.currentPage); close() }
+  BackHandler(onBack = goBack)
+  // 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.getMedia(provider.initialIndex - 1) == null) {
+      provider.scrollToStart()
+      pagerState.scrollToPage(0)
+    }
+  }
+  val scope = rememberCoroutineScope()
+  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()
+        .background(Color.Black)
+        .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null, onClick = goBack)
+    ) {
+      var settledCurrentPage by remember { mutableStateOf(pagerState.currentPage) }
+      LaunchedEffect(pagerState) {
+        snapshotFlow {
+          if (!pagerState.isScrollInProgress) pagerState.currentPage else settledCurrentPage
+        }.collect {
+          settledCurrentPage = it
+        }
+      }
+      LaunchedEffect(settledCurrentPage) {
+        // Make this pager with infinity scrolling with only 3 pages at a time when left and right pages constructs in real time
+        if (settledCurrentPage != provider.initialIndex)
+          provider.currentPageChanged(index)
+      }
+      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
+        SideEffect {
+          scope.launch {
+            when (settledCurrentPage) {
+              index - 1 -> provider.totalMediaSize.value = settledCurrentPage + 1
+              index + 1 -> {
+                provider.scrollToStart()
+                pagerState.scrollToPage(0)
               }
             }
-          )
+          }
         }
-        .fillMaxSize(),
+      } else {
+        var scale by remember { mutableStateOf(1f) }
+        var translationX by remember { mutableStateOf(0f) }
+        var translationY by remember { mutableStateOf(0f) }
+        var viewWidth by remember { mutableStateOf(0) }
+        var allowTranslate by remember { mutableStateOf(true) }
+        LaunchedEffect(settledCurrentPage) {
+          scale = 1f
+          translationX = 0f
+          translationY = 0f
+        }
+        val 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
+                }
+              }
+            )
+          }
+          .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())
+              }
+            }
+            .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,19 +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.UriHandler
+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)
@@ -35,66 +46,157 @@ 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 reserve = if (edited) "        " else "    "
-  if (formattedText == null) {
-    val annotatedText = buildAnnotatedString {
-      appendSender(this, sender, senderBold)
-      append(text)
-      if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
-    }
-    Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
+  val textLayoutDirection = remember (text) {
+    if (BidiFormatter.getInstance().isRtl(text.subSequence(0, kotlin.math.min(50, text.length)))) LayoutDirection.Rtl else LayoutDirection.Ltr
+  }
+  val reserve = if (textLayoutDirection != LocalLayoutDirection.current && meta != null) {
+    "\n"
+  } else if (meta != null) {
+    reserveSpaceForMeta(meta, chatTTL)
   } else {
-    var hasLinks = false
-    val annotatedText = buildAnnotatedString {
-      appendSender(this, sender, senderBold)
-      for (ft in formattedText) {
-        if (ft.format == null) append(ft.text)
-        else {
-          val link = ft.link
-          if (link != null) {
-            hasLinks = true
-            val ftStyle = ft.format.style
-            withAnnotation(tag = "URL", annotation = link) {
-              withStyle(ftStyle) { append(ft.text) }
-            }
-          } else {
-            withStyle(ft.format.style) { append(ft.text) }
+    "    "
+  }
+  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 (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
     }
-    if (hasLinks && uriHandler != null) {
-      ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
-        onLongClick = { offset ->
-          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
-            .firstOrNull()?.let { annotation -> onLinkLongClick(annotation.item) }
-        },
-        onClick = { offset ->
-          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
-            .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
-        },
-        shouldConsumeEvent = { offset ->
-          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset).any()
+    if (formattedText == null) {
+      val annotatedText = buildAnnotatedString {
+        appendSender(this, sender, senderBold)
+        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, inlineContent = inlineContent ?: mapOf())
     } else {
-      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
+      var hasLinks = false
+      val annotatedText = buildAnnotatedString {
+        appendSender(this, sender, senderBold)
+        for (ft in formattedText) {
+          if (ft.format == null) append(ft.text)
+          else {
+            val link = ft.link(linkMode)
+            if (link != null) {
+              hasLinks = true
+              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.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 (meta != null) withStyle(reserveTimestampStyle) { append(reserve) }
+      }
+      if (hasLinks && uriHandler != null) {
+        ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
+          onLongClick = { offset ->
+            annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
+              .firstOrNull()?.let { annotation -> onLinkLongClick(annotation.item) }
+          },
+          onClick = { offset ->
+            annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
+              .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()
+          }
+        )
+      } else {
+        Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
+      }
     }
   }
 }

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

@@ -5,48 +5,58 @@ import androidx.compose.foundation.combinedClickable
 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.*
 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.SimpleXTheme
-import chat.simplex.app.ui.theme.WarningOrange
+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
 import kotlinx.coroutines.delay
 import kotlinx.datetime.Clock
 
 @Composable
 fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
   val showMenu = remember { mutableStateOf(false) }
-  var showMarkRead by remember { mutableStateOf(false) }
+  val showMarkRead = remember(chat.chatStats.unreadCount, chat.chatStats.unreadChat) {
+    chat.chatStats.unreadCount > 0 || chat.chatStats.unreadChat
+  }
   val stopped = chatModel.chatRunning.value == false
-  LaunchedEffect(chat.id, chat.chatStats.unreadCount > 0) {
+  val linkMode by remember { chatModel.controller.appPrefs.simplexLinkMode.state }
+  LaunchedEffect(chat.id) {
     showMenu.value = false
     delay(500L)
-    showMarkRead = chat.chatStats.unreadCount > 0
   }
   when (chat.chatInfo) {
-    is ChatInfo.Direct ->
+    is ChatInfo.Direct -> {
+      val contactNetworkStatus = chatModel.contactNetworkStatus(chat.chatInfo.contact)
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, 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, 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,
@@ -54,7 +64,7 @@ fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
       )
     is ChatInfo.ContactRequest ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ContactRequestView(chat.chatInfo) },
+        chatLinkPreview = { ContactRequestView(chatModel.incognito.value, chat.chatInfo) },
         click = { contactRequestAlertDialog(chat.chatInfo, chatModel) },
         dropdownMenuItems = { ContactRequestMenuItems(chat.chatInfo, chatModel, showMenu) },
         showMenu,
@@ -63,11 +73,27 @@ fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
     is ChatInfo.ContactConnection ->
       ChatListNavLinkLayout(
         chatLinkPreview = { ContactConnectionView(chat.chatInfo.contactConnection) },
-        click = { contactConnectionAlertDialog(chat.chatInfo.contactConnection, chatModel) },
+        click = {
+          ModalManager.shared.showModalCloseable(true) { close ->
+            ContactConnectionInfoView(chatModel, chat.chatInfo.contactConnection.connReqInv, chat.chatInfo.contactConnection, false, close)
+          }
+        },
         dropdownMenuItems = { ContactConnectionMenuItems(chat.chatInfo, chatModel, showMenu) },
         showMenu,
         stopped
       )
+    is ChatInfo.InvalidJSON ->
+      ChatListNavLinkLayout(
+        chatLinkPreview = {
+          InvalidDataView()
+        },
+        click = {
+          ModalManager.shared.showModal(true) { InvalidJSONView(chat.chatInfo.json) }
+        },
+        dropdownMenuItems = null,
+        showMenu,
+        stopped
+      )
   }
 }
 
@@ -96,7 +122,19 @@ suspend fun openChat(chatInfo: ChatInfo, chatModel: ChatModel) {
   }
 }
 
-suspend fun populateGroupMembers(groupInfo: GroupInfo, chatModel: ChatModel) {
+suspend fun apiLoadPrevMessages(chatInfo: ChatInfo, chatModel: ChatModel, beforeChatItemId: Long, search: String) {
+  val pagination = ChatPagination.Before(beforeChatItemId, ChatPagination.PRELOAD_COUNT)
+  val chat = chatModel.controller.apiGetChat(chatInfo.chatType, chatInfo.apiId, pagination, search) ?: return
+  chatModel.chatItems.addAll(0, chat.chatItems)
+}
+
+suspend fun apiFindMessages(chatInfo: ChatInfo, chatModel: ChatModel, search: String) {
+  val chat = chatModel.controller.apiGetChat(chatInfo.chatType, chatInfo.apiId, search = search) ?: return
+  chatModel.chatItems.clear()
+  chatModel.chatItems.addAll(0, chat.chatItems)
+}
+
+suspend fun setGroupMembers(groupInfo: GroupInfo, chatModel: ChatModel) {
   val groupMembers = chatModel.controller.apiListMembers(groupInfo.groupId)
   chatModel.groupMembers.clear()
   chatModel.groupMembers.addAll(groupMembers)
@@ -106,7 +144,10 @@ suspend fun populateGroupMembers(groupInfo: GroupInfo, chatModel: ChatModel) {
 fun ContactMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
   if (showMarkRead) {
     MarkReadChatAction(chat, chatModel, showMenu)
+  } else {
+    MarkUnreadChatAction(chat, chatModel, showMenu)
   }
+  ToggleNotificationsChatAction(chat, chatModel, chat.chatInfo.ntfsEnabled, showMenu)
   ClearChatAction(chat, chatModel, showMenu)
   DeleteContactAction(chat, chatModel, showMenu)
 }
@@ -115,21 +156,24 @@ fun ContactMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Bo
 fun GroupMenuItems(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
   when (groupInfo.membership.memberStatus) {
     GroupMemberStatus.MemInvited -> {
-      JoinGroupAction(groupInfo, chatModel, showMenu)
+      JoinGroupAction(chat, groupInfo, chatModel, showMenu)
       if (groupInfo.canDelete) {
-        DeleteGroupAction(chat, chatModel, showMenu)
+        DeleteGroupAction(chat, groupInfo, chatModel, showMenu)
       }
     }
     else -> {
       if (showMarkRead) {
         MarkReadChatAction(chat, chatModel, showMenu)
+      } else {
+        MarkUnreadChatAction(chat, chatModel, showMenu)
       }
+      ToggleNotificationsChatAction(chat, chatModel, chat.chatInfo.ntfsEnabled, showMenu)
       ClearChatAction(chat, chatModel, showMenu)
       if (groupInfo.membership.memberCurrent) {
         LeaveGroupAction(groupInfo, chatModel, showMenu)
       }
       if (groupInfo.canDelete) {
-        DeleteGroupAction(chat, chatModel, showMenu)
+        DeleteGroupAction(chat, groupInfo, chatModel, showMenu)
       }
     }
   }
@@ -148,10 +192,46 @@ fun MarkReadChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<
   )
 }
 
+@Composable
+fun MarkUnreadChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  DropdownMenuItem({
+    markChatUnread(chat, chatModel)
+    showMenu.value = false
+  }) {
+    Row {
+      Text(
+        stringResource(R.string.mark_unread),
+        modifier = Modifier
+          .fillMaxWidth()
+          .weight(1F)
+          .padding(end = 15.dp),
+        color = MaterialTheme.colors.onBackground
+      )
+      Icon(
+        Icons.Outlined.MarkChatUnread,
+        stringResource(R.string.mark_unread),
+        tint = MaterialTheme.colors.onBackground
+      )
+    }
+  }
+}
+
+@Composable
+fun ToggleNotificationsChatAction(chat: Chat, chatModel: ChatModel, ntfsEnabled: Boolean, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    if (ntfsEnabled) stringResource(R.string.mute_chat) else stringResource(R.string.unmute_chat),
+    if (ntfsEnabled) Icons.Outlined.NotificationsOff else Icons.Outlined.Notifications,
+    onClick = {
+      changeNtfsStatePerChat(!ntfsEnabled, mutableStateOf(ntfsEnabled), chat, chatModel)
+      showMenu.value = false
+    }
+  )
+}
+
 @Composable
 fun ClearChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    stringResource(R.string.clear_verb),
+    stringResource(R.string.clear_chat_menu_action),
     Icons.Outlined.Restore,
     onClick = {
       clearChatDialog(chat.chatInfo, chatModel)
@@ -164,7 +244,7 @@ fun ClearChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boo
 @Composable
 fun DeleteContactAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    stringResource(R.string.delete_verb),
+    stringResource(R.string.delete_contact_menu_action),
     Icons.Outlined.Delete,
     onClick = {
       deleteContactDialog(chat.chatInfo, chatModel)
@@ -175,12 +255,12 @@ fun DeleteContactAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState
 }
 
 @Composable
-fun DeleteGroupAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+fun DeleteGroupAction(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    stringResource(R.string.delete_verb),
+    stringResource(R.string.delete_group_menu_action),
     Icons.Outlined.Delete,
     onClick = {
-      deleteGroupDialog(chat.chatInfo, chatModel)
+      deleteGroupDialog(chat.chatInfo, groupInfo, chatModel)
       showMenu.value = false
     },
     color = Color.Red
@@ -188,12 +268,14 @@ fun DeleteGroupAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<B
 }
 
 @Composable
-fun JoinGroupAction(groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+fun JoinGroupAction(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  val joinGroup: () -> Unit = { withApi { chatModel.controller.apiJoinGroup(groupInfo.groupId) } }
   ItemAction(
-    stringResource(R.string.join_group_button),
-    Icons.Outlined.Login,
+    if (chat.chatInfo.incognito) stringResource(R.string.join_group_incognito_button) else stringResource(R.string.join_group_button),
+    if (chat.chatInfo.incognito) Icons.Filled.TheaterComedy else Icons.Outlined.Login,
+    color = if (chat.chatInfo.incognito) Indigo else MaterialTheme.colors.onBackground,
     onClick = {
-      withApi { chatModel.controller.apiJoinGroup(groupInfo.groupId) }
+      joinGroup()
       showMenu.value = false
     }
   )
@@ -215,10 +297,11 @@ fun LeaveGroupAction(groupInfo: GroupInfo, chatModel: ChatModel, showMenu: Mutab
 @Composable
 fun ContactRequestMenuItems(chatInfo: ChatInfo.ContactRequest, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    stringResource(R.string.accept_contact_button),
-    Icons.Outlined.Check,
+    if (chatModel.incognito.value) stringResource(R.string.accept_contact_incognito_button) else stringResource(R.string.accept_contact_button),
+    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
     }
   )
@@ -235,25 +318,89 @@ fun ContactRequestMenuItems(chatInfo: ChatInfo.ContactRequest, chatModel: ChatMo
 
 @Composable
 fun ContactConnectionMenuItems(chatInfo: ChatInfo.ContactConnection, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.set_contact_name),
+    Icons.Outlined.Edit,
+    onClick = {
+      ModalManager.shared.showModalCloseable(true) { close ->
+        ContactConnectionInfoView(chatModel, chatInfo.contactConnection.connReqInv, chatInfo.contactConnection, true, close)
+      }
+      showMenu.value = false
+    },
+  )
   ItemAction(
     stringResource(R.string.delete_verb),
     Icons.Outlined.Delete,
     onClick = {
-      deleteContactConnectionAlert(chatInfo.contactConnection, chatModel)
+      deleteContactConnectionAlert(chatInfo.contactConnection, chatModel) {}
       showMenu.value = false
     },
     color = Color.Red
   )
 }
 
-fun markChatRead(chat: Chat, chatModel: ChatModel) {
-  chatModel.markChatItemsRead(chat.chatInfo)
+@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 {
-    chatModel.controller.apiChatRead(
+    if (chat.chatStats.unreadCount > 0) {
+      val minUnreadItemId = chat.chatStats.minUnreadItemId
+      chatModel.markChatItemsRead(chat.chatInfo)
+      chatModel.controller.apiChatRead(
+        chat.chatInfo.chatType,
+        chat.chatInfo.apiId,
+        CC.ItemRange(minUnreadItemId, chat.chatItems.last().id)
+      )
+      chat = chatModel.getChat(chat.id) ?: return@withApi
+    }
+    if (chat.chatStats.unreadChat) {
+      val success = chatModel.controller.apiChatUnread(
+        chat.chatInfo.chatType,
+        chat.chatInfo.apiId,
+        false
+      )
+      if (success) {
+        chatModel.replaceChat(chat.id, chat.copy(chatStats = chat.chatStats.copy(unreadChat = false)))
+      }
+    }
+  }
+}
+
+fun markChatUnread(chat: Chat, chatModel: ChatModel) {
+  // Just to be sure
+  if (chat.chatStats.unreadChat) return
+
+  withApi {
+    val success = chatModel.controller.apiChatUnread(
       chat.chatInfo.chatType,
       chat.chatInfo.apiId,
-      CC.ItemRange(chat.chatStats.minUnreadItemId, chat.chatItems.last().id)
+      true
     )
+    if (success) {
+      chatModel.replaceChat(chat.id, chat.copy(chatStats = chat.chatStats.copy(unreadChat = true)))
+    }
   }
 }
 
@@ -261,17 +408,17 @@ fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel
   AlertManager.shared.showAlertDialog(
     title = generalGetString(R.string.accept_connection_request__question),
     text = generalGetString(R.string.if_you_choose_to_reject_the_sender_will_not_be_notified),
-    confirmText = generalGetString(R.string.accept_contact_button),
-    onConfirm = { acceptContactRequest(contactRequest, chatModel) },
+    confirmText = if (chatModel.incognito.value) generalGetString(R.string.accept_contact_incognito_button) else generalGetString(R.string.accept_contact_button),
+    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)
     }
@@ -302,14 +449,14 @@ fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel
           .padding(horizontal = 8.dp, vertical = 2.dp),
         horizontalArrangement = Arrangement.End,
       ) {
-        Button(onClick = {
+        TextButton(onClick = {
           AlertManager.shared.hideAlert()
-          deleteContactConnectionAlert(connection, chatModel)
+          deleteContactConnectionAlert(connection, chatModel) {}
         }) {
           Text(stringResource(R.string.delete_verb))
         }
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Button(onClick = { AlertManager.shared.hideAlert() }) {
+        TextButton(onClick = { AlertManager.shared.hideAlert() }) {
           Text(stringResource(R.string.ok))
         }
       }
@@ -317,7 +464,7 @@ fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel
   )
 }
 
-fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel: ChatModel) {
+fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel: ChatModel, onSuccess: () -> Unit) {
   AlertManager.shared.showAlertDialog(
     title = generalGetString(R.string.delete_pending_connection__question),
     text = generalGetString(
@@ -330,6 +477,7 @@ fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel
         AlertManager.shared.hideAlert()
         if (chatModel.controller.apiDeleteChat(ChatType.ContactConnection, connection.apiId)) {
           chatModel.removeChat(connection.id)
+          onSuccess()
         }
       }
     }
@@ -358,13 +506,21 @@ fun acceptGroupInvitationAlertDialog(groupInfo: GroupInfo, chatModel: ChatModel)
   AlertManager.shared.showAlertDialog(
     title = generalGetString(R.string.join_group_question),
     text = generalGetString(R.string.you_are_invited_to_group_join_to_connect_with_group_members),
-    confirmText = generalGetString(R.string.join_group_button),
+    confirmText = if (groupInfo.membership.memberIncognito) generalGetString(R.string.join_group_incognito_button) else generalGetString(R.string.join_group_button),
     onConfirm = { withApi { chatModel.controller.apiJoinGroup(groupInfo.groupId) } },
     dismissText = generalGetString(R.string.delete_verb),
     onDismiss = { deleteGroup(groupInfo, chatModel) }
   )
 }
 
+fun cantInviteIncognitoAlert() {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.alert_title_cant_invite_contacts),
+    text = generalGetString(R.string.alert_title_cant_invite_contacts_descr),
+    confirmText = generalGetString(R.string.ok),
+  )
+}
+
 fun deleteGroup(groupInfo: GroupInfo, chatModel: ChatModel) {
   withApi {
     val r = chatModel.controller.apiDeleteChat(ChatType.Group, groupInfo.apiId)
@@ -383,6 +539,36 @@ fun groupInvitationAcceptedAlert() {
   )
 }
 
+fun changeNtfsStatePerChat(enabled: Boolean, currentState: MutableState<Boolean>, chat: Chat, chatModel: ChatModel) {
+  val newChatInfo = when(chat.chatInfo) {
+    is ChatInfo.Direct -> with (chat.chatInfo) {
+      ChatInfo.Direct(contact.copy(chatSettings = contact.chatSettings.copy(enableNtfs = enabled)))
+    }
+    is ChatInfo.Group -> with(chat.chatInfo) {
+      ChatInfo.Group(groupInfo.copy(chatSettings = groupInfo.chatSettings.copy(enableNtfs = enabled)))
+    }
+    else -> null
+  }
+  withApi {
+    val res = when (newChatInfo) {
+      is ChatInfo.Direct -> with(newChatInfo) {
+        chatModel.controller.apiSetSettings(chatType, apiId, contact.chatSettings)
+      }
+      is ChatInfo.Group -> with(newChatInfo) {
+        chatModel.controller.apiSetSettings(chatType, apiId, groupInfo.chatSettings)
+      }
+      else -> false
+    }
+    if (res && newChatInfo != null) {
+      chatModel.updateChatInfo(newChatInfo)
+      if (!enabled) {
+        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
+      }
+      currentState.value = enabled
+    }
+  }
+}
+
 @Composable
 fun ChatListNavLinkLayout(
   chatLinkPreview: @Composable () -> Unit,
@@ -391,15 +577,13 @@ fun ChatListNavLinkLayout(
   showMenu: MutableState<Boolean>,
   stopped: Boolean
 ) {
-  var modifier = Modifier.fillMaxWidth().height(88.dp)
+  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()
@@ -443,7 +627,13 @@ fun PreviewChatListNavLinkDirect() {
             ),
             chatStats = Chat.ChatStats()
           ),
-          stopped = false
+          null,
+          null,
+          false,
+          null,
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},
@@ -478,7 +668,13 @@ fun PreviewChatListNavLinkGroup() {
             ),
             chatStats = Chat.ChatStats()
           ),
-          stopped = false
+          null,
+          null,
+          false,
+          null,
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},
@@ -500,7 +696,7 @@ fun PreviewChatListNavLinkContactRequest() {
   SimpleXTheme {
     ChatListNavLinkLayout(
       chatLinkPreview = {
-        ContactRequestView(ChatInfo.ContactRequest.sampleData)
+        ContactRequestView(false, ChatInfo.ContactRequest.sampleData)
       },
       click = {},
       dropdownMenuItems = null,

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

@@ -1,162 +1,309 @@
 package chat.simplex.app.views.chatlist
 
+import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
+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
-import androidx.compose.material.icons.filled.Report
+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
+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.unit.dp
+import androidx.compose.ui.text.intl.Locale
+import androidx.compose.ui.unit.*
+import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.ToolbarDark
-import chat.simplex.app.ui.theme.ToolbarLight
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.generalGetString
+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.MakeConnection
+import chat.simplex.app.views.onboarding.WhatsNewView
+import chat.simplex.app.views.onboarding.shouldShowWhatsNew
 import chat.simplex.app.views.usersettings.SettingsView
-import kotlinx.coroutines.CoroutineScope
+import chat.simplex.app.views.usersettings.simplexTeamUri
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.launch
 
-class ScaffoldController(val scope: CoroutineScope) {
-  lateinit var state: BottomSheetScaffoldState
-  val expanded = mutableStateOf(false)
-
-  fun expand() {
-    expanded.value = true
-    scope.launch { state.bottomSheetState.expand() }
-  }
-
-  fun collapse() {
-    expanded.value = false
-    scope.launch { state.bottomSheetState.collapse() }
-  }
-
-  fun toggleSheet() {
-    if (state.bottomSheetState.isExpanded) collapse() else expand()
-  }
-
-  fun toggleDrawer() = scope.launch {
-    state.drawerState.apply { if (isClosed) open() else close() }
-  }
-}
-
-@Composable
-fun scaffoldController(): ScaffoldController {
-  val ctrl = ScaffoldController(scope = rememberCoroutineScope())
-  val bottomSheetState = rememberBottomSheetState(
-    BottomSheetValue.Collapsed,
-    confirmStateChange = {
-      ctrl.expanded.value = it == BottomSheetValue.Expanded
-      true
-    }
-  )
-  ctrl.state = rememberBottomSheetScaffoldState(bottomSheetState = bottomSheetState)
-  return ctrl
-}
-
 @Composable
 fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped: Boolean) {
-  val scaffoldCtrl = scaffoldController()
-  LaunchedEffect(chatModel.clearOverlays.value) {
-    if (chatModel.clearOverlays.value && scaffoldCtrl.expanded.value) scaffoldCtrl.collapse()
+  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 = AnimatedViewState.VISIBLE
   }
-  BottomSheetScaffold(
-    scaffoldState = scaffoldCtrl.state,
+  val hideNewChatSheet: (animated: Boolean) -> Unit = { animated ->
+    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, userPickerState, stopped) { searchInList = it.trim() } },
+    scaffoldState = scaffoldState,
     drawerContent = { SettingsView(chatModel, setPerformLA) },
-    sheetPeekHeight = 0.dp,
-    sheetContent = { NewChatSheet(chatModel, scaffoldCtrl) },
-    sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp),
+    floatingActionButton = {
+      if (searchInList.isEmpty()) {
+        FloatingActionButton(
+          onClick = {
+            if (!stopped) {
+              if (newChatSheetState.value.isVisible()) hideNewChatSheet(true) else showNewChatSheet()
+            }
+          },
+          elevation = FloatingActionButtonDefaults.elevation(
+            defaultElevation = 0.dp,
+            pressedElevation = 0.dp,
+            hoveredElevation = 0.dp,
+            focusedElevation = 0.dp,
+          ),
+          backgroundColor = if (!stopped) MaterialTheme.colors.primary else HighOrLowlight,
+          contentColor = Color.White
+        ) {
+          Icon(if (!newChatSheetState.collectAsState().value.isVisible()) Icons.Default.Edit else Icons.Default.Close, stringResource(R.string.add_contact_or_create_group))
+        }
+      }
+    }
   ) {
-    Box {
+    Box(Modifier.padding(it)) {
       Column(
         modifier = Modifier
           .fillMaxSize()
           .background(MaterialTheme.colors.background)
       ) {
-        ChatListToolbar(scaffoldCtrl, stopped)
-        Divider()
         if (chatModel.chats.isNotEmpty()) {
-          ChatList(chatModel)
-        } else {
-          MakeConnection(chatModel)
+          ChatList(chatModel, search = searchInList)
+        } else if (!switchingUsers.value) {
+          Box(Modifier.fillMaxSize()) {
+            if (!stopped && !newChatSheetState.collectAsState().value.isVisible()) {
+              OnboardingButtons(showNewChatSheet)
+            }
+            Text(stringResource(R.string.you_have_no_chats), Modifier.align(Alignment.Center), color = HighOrLowlight)
+          }
         }
       }
-      if (scaffoldCtrl.expanded.value) {
-        Surface(
-          Modifier
-            .fillMaxSize()
-            .clickable { scaffoldCtrl.collapse() },
-          color = Color.Black.copy(alpha = 0.12F)
-        ) {}
-      }
+    }
+  }
+  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
-fun ChatListToolbar(scaffoldCtrl: ScaffoldController, stopped: Boolean) {
-  Row(
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically,
-    modifier = Modifier
-      .fillMaxWidth()
-      .height(52.dp)
-      .background(if (isSystemInDarkTheme()) ToolbarDark else ToolbarLight)
-      .padding(horizontal = 8.dp)
-  ) {
-    IconButton(onClick = { scaffoldCtrl.toggleDrawer() }) {
-      Icon(
-        Icons.Outlined.Menu,
-        stringResource(R.string.icon_descr_settings),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
+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.openUriCatching(simplexTeamUri)
     }
-    Text(
-      stringResource(R.string.your_chats),
-      color = MaterialTheme.colors.onBackground,
-      fontWeight = FontWeight.SemiBold,
-      modifier = Modifier.padding(5.dp)
-    )
-    if (!stopped) {
-      IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
-        Icon(
-          Icons.Outlined.AddCircle,
-          stringResource(R.string.add_contact),
-          tint = MaterialTheme.colors.primary,
-          modifier = Modifier.padding(10.dp).size(26.dp)
-        )
+    Spacer(Modifier.height(DEFAULT_PADDING))
+    ConnectButton(generalGetString(R.string.tap_to_start_new_chat), openNewChatSheet)
+    val color = MaterialTheme.colors.primary
+    Canvas(modifier = Modifier.width(40.dp).height(10.dp), onDraw = {
+      val trianglePath = Path().apply {
+        moveTo(0.dp.toPx(), 0f)
+        lineTo(16.dp.toPx(), 0.dp.toPx())
+        lineTo(8.dp.toPx(), 10.dp.toPx())
+        lineTo(0.dp.toPx(), 0.dp.toPx())
       }
-    } else {
-      IconButton(onClick = { AlertManager.shared.showAlertMsg(generalGetString(R.string.chat_is_stopped_indication), generalGetString(R.string.you_can_start_chat_via_setting_or_by_restarting_the_app)) }) {
+      drawPath(
+        color = color,
+        path = trianglePath
+      )
+    })
+    Spacer(Modifier.height(62.dp))
+  }
+}
+
+@Composable
+private fun ConnectButton(text: String, onClick: () -> Unit) {
+  Button(
+    onClick,
+    shape = RoundedCornerShape(21.dp),
+    colors = ButtonDefaults.textButtonColors(
+      backgroundColor = MaterialTheme.colors.primary
+    ),
+    elevation = null,
+    contentPadding = PaddingValues(horizontal = DEFAULT_PADDING, vertical = DEFAULT_PADDING_HALF),
+    modifier = Modifier.height(42.dp)
+  ) {
+    Text(text, color = Color.White)
+  }
+}
+
+@Composable
+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) {
+    BackHandler(onBack = hideSearchOnBack)
+  }
+  val barButtons = arrayListOf<@Composable RowScope.() -> Unit>()
+  if (chatModel.chats.size >= 8) {
+    barButtons.add {
+      IconButton({ showSearch = true }) {
+        Icon(Icons.Outlined.Search, stringResource(android.R.string.search_go).capitalize(Locale.current), tint = MaterialTheme.colors.primary)
+      }
+    }
+  }
+  if (stopped) {
+    barButtons.add {
+      IconButton(onClick = {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.chat_is_stopped_indication),
+          generalGetString(R.string.you_can_start_chat_via_setting_or_by_restarting_the_app)
+        )
+      }) {
         Icon(
           Icons.Filled.Report,
           generalGetString(R.string.chat_is_stopped_indication),
           tint = Color.Red,
-          modifier = Modifier.padding(10.dp)
         )
       }
     }
   }
+  val scope = rememberCoroutineScope()
+  DefaultTopAppBar(
+    navigationButton = {
+      if (showSearch) {
+        NavigationButtonBack(hideSearchOnBack)
+      } 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) {
+        Text(
+          stringResource(R.string.your_chats),
+          color = MaterialTheme.colors.onBackground,
+          fontWeight = FontWeight.SemiBold,
+        )
+        if (chatModel.incognito.value) {
+          Icon(
+            Icons.Filled.TheaterComedy,
+            stringResource(R.string.incognito),
+            tint = Indigo,
+            modifier = Modifier.padding(10.dp).size(26.dp)
+          )
+        }
+      }
+    },
+    onTitleClick = null,
+    showSearch = showSearch,
+    onSearchValueChanged = onSearchValueChanged,
+    buttons = barButtons
+  )
+  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
-fun ChatList(chatModel: ChatModel) {
+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
+private fun ChatList(chatModel: ChatModel, search: String) {
+  val filter: (Chat) -> Boolean = { chat: Chat ->
+    chat.chatInfo.chatViewName.lowercase().contains(search.lowercase())
+  }
+  val listState = rememberLazyListState(lazyListState.first, lazyListState.second)
+  DisposableEffect(Unit) {
+    onDispose { lazyListState = listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
+  }
+  val chats by remember(search) { derivedStateOf { if (search.isEmpty()) chatModel.chats else chatModel.chats.filter(filter) } }
   LazyColumn(
-    modifier = Modifier.fillMaxWidth()
+    modifier = Modifier.fillMaxWidth(),
+    listState
   ) {
-    items(chatModel.chats) { chat ->
+    items(chats) { chat ->
       ChatListNavLinkView(chat, chatModel)
     }
   }

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

@@ -2,32 +2,45 @@ package chat.simplex.app.views.chatlist
 
 import android.content.res.Configuration
 import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
 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.outlined.ErrorOutline
-import androidx.compose.runtime.Composable
+import androidx.compose.material.icons.filled.*
+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.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
-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.*
 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.ChatInfoImage
-import chat.simplex.app.views.helpers.badgeLayout
+import chat.simplex.app.views.helpers.*
 
 @Composable
-fun ChatPreviewView(chat: Chat, 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
@@ -64,14 +77,61 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
     )
   }
 
+  @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(MaterialTheme.colors.primary)
+          GroupMemberStatus.MemInvited -> chatPreviewTitleText(if (chat.chatInfo.incognito) Indigo else MaterialTheme.colors.primary)
           GroupMemberStatus.MemAccepted -> chatPreviewTitleText(HighOrLowlight)
           else -> chatPreviewTitleText()
         }
@@ -80,15 +140,34 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
   }
 
   @Composable
-  fun chatPreviewText() {
+  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, ci.memberDisplayName,
-        metaText = ci.timestampText,
+        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,
         maxLines = 2,
         overflow = TextOverflow.Ellipsis,
-        style = MaterialTheme.typography.body1.copy(color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+        style = MaterialTheme.typography.body1.copy(color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+        inlineContent = inlineTextContent,
+        modifier = Modifier.fillMaxWidth(),
       )
     } else {
       when (cInfo) {
@@ -98,7 +177,7 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
           }
         is ChatInfo.Group ->
           when (cInfo.groupInfo.membership.memberStatus) {
-            GroupMemberStatus.MemInvited -> Text(stringResource(R.string.group_preview_you_are_invited))
+            GroupMemberStatus.MemInvited -> Text(groupInvitationPreviewText(chatModelIncognito, currentUserProfileDisplayName, cInfo.groupInfo))
             GroupMemberStatus.MemAccepted -> Text(stringResource(R.string.group_connection_pending), color = HighOrLowlight)
             else -> {}
           }
@@ -120,7 +199,10 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
         .weight(1F)
     ) {
       chatPreviewTitle()
-      chatPreviewText()
+      val height = with(LocalDensity.current) { 46.sp.toDp() }
+      Row(Modifier.heightIn(min = height)) {
+        chatPreviewText(chatModelIncognito)
+      }
     }
     val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.updatedAt)
 
@@ -134,29 +216,45 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
         modifier = Modifier.padding(bottom = 5.dp)
       )
       val n = chat.chatStats.unreadCount
-      if (n > 0) {
+      val showNtfsIcon = !chat.chatInfo.ntfsEnabled && (chat.chatInfo is ChatInfo.Direct || chat.chatInfo is ChatInfo.Group)
+      if (n > 0 || chat.chatStats.unreadChat) {
         Box(
           Modifier.padding(top = 24.dp),
           contentAlignment = Alignment.Center
         ) {
           Text(
-            if (n < 1000) "$n" else "${n / 1000}" + stringResource(R.string.thousand_abbreviation),
+            if (n > 0) unreadCountStr(n) else "",
             color = MaterialTheme.colors.onPrimary,
             fontSize = 11.sp,
             modifier = Modifier
-              .background(if (stopped) HighOrLowlight else MaterialTheme.colors.primary, shape = CircleShape)
+              .background(if (stopped || showNtfsIcon) HighOrLowlight else MaterialTheme.colors.primary, shape = CircleShape)
               .badgeLayout()
               .padding(horizontal = 3.dp)
               .padding(vertical = 1.dp)
           )
         }
+      } else if (showNtfsIcon) {
+        Box(
+          Modifier.padding(top = 24.dp),
+          contentAlignment = Alignment.Center
+        ) {
+          Icon(
+            Icons.Filled.NotificationsOff,
+            contentDescription = generalGetString(R.string.notifications),
+            tint = HighOrLowlight,
+            modifier = Modifier
+              .padding(horizontal = 3.dp)
+              .padding(vertical = 1.dp)
+              .size(17.dp)
+          )
+        }
       }
       if (cInfo is ChatInfo.Direct) {
         Box(
           Modifier.padding(top = 52.dp),
           contentAlignment = Alignment.Center
         ) {
-          ChatStatusImage(chat)
+          ChatStatusImage(contactNetworkStatus)
         }
       }
     }
@@ -164,10 +262,24 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
 }
 
 @Composable
-fun ChatStatusImage(chat: Chat) {
-  val s = chat.serverInfo.networkStatus
-  val descr = s.statusString
-  if (s is Chat.NetworkStatus.Error) {
+private fun groupInvitationPreviewText(chatModelIncognito: Boolean, currentUserProfileDisplayName: String?, groupInfo: GroupInfo): String {
+  return if (groupInfo.membership.memberIncognito)
+    String.format(stringResource(R.string.group_preview_join_as), groupInfo.membership.memberProfile.displayName)
+  else if (chatModelIncognito)
+    String.format(stringResource(R.string.group_preview_join_as), currentUserProfileDisplayName ?: "")
+  else
+    stringResource(R.string.group_preview_you_are_invited)
+}
+
+@Composable
+fun unreadCountStr(n: Int): String {
+  return if (n < 1000) "$n" else "${n / 1000}" + stringResource(R.string.thousand_abbreviation)
+}
+
+@Composable
+fun ChatStatusImage(s: NetworkStatus?) {
+  val descr = s?.statusString
+  if (s is NetworkStatus.Error) {
     Icon(
       Icons.Outlined.ErrorOutline,
       contentDescription = descr,
@@ -175,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)
@@ -195,6 +307,6 @@ fun ChatStatusImage(chat: Chat) {
 @Composable
 fun PreviewChatPreviewView() {
   SimpleXTheme {
-    ChatPreviewView(Chat.sampleData, 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/ContactConnectionView.kt

@@ -1,20 +1,19 @@
 package chat.simplex.app.views.chatlist
 
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.AddLink
-import androidx.compose.material.icons.outlined.Link
-import androidx.compose.runtime.Composable
+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.LocalDensity
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
-import chat.simplex.app.model.PendingContactConnection
-import chat.simplex.app.model.getTimestampText
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.ProfileImage
 
@@ -37,7 +36,8 @@ fun ContactConnectionView(contactConnection: PendingContactConnection) {
         fontWeight = FontWeight.Bold,
         color = HighOrLowlight
       )
-      Text(contactConnection.description, maxLines = 2, color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
+      val height = with(LocalDensity.current) { 46.sp.toDp() }
+      Text(contactConnection.description, Modifier.heightIn(min = height), maxLines = 2, color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
     }
     val ts = getTimestampText(contactConnection.updatedAt)
     Column(

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

@@ -1,23 +1,23 @@
 package chat.simplex.app.views.chatlist
 
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+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.unit.dp
+import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
-import chat.simplex.app.model.ChatInfo
-import chat.simplex.app.model.getTimestampText
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.ChatInfoImage
 
 @Composable
-fun ContactRequestView(contactRequest: ChatInfo.ContactRequest) {
+fun ContactRequestView(chatModelIncognito: Boolean, contactRequest: ChatInfo.ContactRequest) {
   Row {
     ChatInfoImage(contactRequest, size = 72.dp)
     Column(
@@ -31,9 +31,10 @@ fun ContactRequestView(contactRequest: ChatInfo.ContactRequest) {
         overflow = TextOverflow.Ellipsis,
         style = MaterialTheme.typography.h3,
         fontWeight = FontWeight.Bold,
-        color = MaterialTheme.colors.primary
+        color = if (chatModelIncognito) Indigo else MaterialTheme.colors.primary
       )
-      Text(stringResource(R.string.contact_wants_to_connect_with_you), maxLines = 2, color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
+      val height = with(LocalDensity.current) { 46.sp.toDp() }
+      Text(stringResource(R.string.contact_wants_to_connect_with_you), Modifier.heightIn(min = height), maxLines = 2, color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
     }
     val ts = getTimestampText(contactRequest.contactRequest.updatedAt)
     Column(

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

@@ -0,0 +1,66 @@
+package chat.simplex.app.views.chatlist
+
+import SectionItemView
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.Indigo
+import chat.simplex.app.views.helpers.ProfileImage
+
+@Composable
+fun ShareListNavLinkView(chat: Chat, chatModel: ChatModel) {
+  val stopped = chatModel.chatRunning.value == false
+  when (chat.chatInfo) {
+    is ChatInfo.Direct ->
+      ShareListNavLinkLayout(
+        chatLinkPreview = { SharePreviewView(chat) },
+        click = { directChatAction(chat.chatInfo, chatModel) },
+        stopped
+      )
+    is ChatInfo.Group ->
+      ShareListNavLinkLayout(
+        chatLinkPreview = { SharePreviewView(chat) },
+        click = { groupChatAction(chat.chatInfo.groupInfo, chatModel) },
+        stopped
+      )
+    is ChatInfo.ContactRequest, is ChatInfo.ContactConnection, is ChatInfo.InvalidJSON -> {}
+  }
+}
+
+@Composable
+private fun ShareListNavLinkLayout(
+  chatLinkPreview: @Composable () -> Unit,
+  click: () -> Unit,
+  stopped: Boolean
+) {
+  SectionItemView(minHeight = 50.dp, click = click, disabled = stopped) {
+    chatLinkPreview()
+  }
+  Divider(Modifier.padding(horizontal = 8.dp))
+}
+
+@Composable
+private fun SharePreviewView(chat: Chat) {
+  Row(
+    Modifier.fillMaxSize(),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+      ProfileImage(size = 46.dp, chat.chatInfo.image)
+      Text(
+        chat.chatInfo.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
+        color = if (chat.chatInfo.incognito) Indigo else Color.Unspecified
+      )
+    }
+  }
+}

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

@@ -0,0 +1,159 @@
+package chat.simplex.app.views.chatlist
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+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.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+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 chat.simplex.app.R
+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, userPickerState, stopped) { searchInList = it.trim() } } },
+  ) {
+    Box(Modifier.padding(it)) {
+      Column(
+        modifier = Modifier
+          .fillMaxSize()
+          .background(MaterialTheme.colors.background)
+      ) {
+        if (chatModel.chats.isNotEmpty()) {
+          ShareList(chatModel, search = searchInList)
+        } else {
+          EmptyList()
+        }
+      }
+    }
+  }
+  UserPicker(chatModel, userPickerState, switchingUsers, showSettings = false, showCancel = true, cancelClicked = {
+    chatModel.sharedContent.value = null
+  })
+}
+
+@Composable
+private fun EmptyList() {
+  Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+    Text(stringResource(R.string.you_have_no_chats), color = HighOrLowlight)
+  }
+}
+
+@Composable
+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 }) {
+        Icon(Icons.Outlined.Search, stringResource(android.R.string.search_go).capitalize(Locale.current), tint = MaterialTheme.colors.primary)
+      }
+    }
+  }
+  if (stopped) {
+    barButtons.add {
+      IconButton(onClick = {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.chat_is_stopped_indication),
+          generalGetString(R.string.you_can_start_chat_via_setting_or_by_restarting_the_app)
+        )
+      }) {
+        Icon(
+          Icons.Filled.Report,
+          generalGetString(R.string.chat_is_stopped_indication),
+          tint = Color.Red,
+        )
+      }
+    }
+  }
+
+  DefaultTopAppBar(
+    navigationButton = navButton,
+    title = {
+      Row(verticalAlignment = Alignment.CenterVertically) {
+        Text(
+          when (chatModel.sharedContent.value) {
+            is SharedContent.Text -> stringResource(R.string.share_message)
+            is SharedContent.Images -> stringResource(R.string.share_image)
+            is SharedContent.File -> stringResource(R.string.share_file)
+            else -> stringResource(R.string.share_message)
+          },
+          color = MaterialTheme.colors.onBackground,
+          fontWeight = FontWeight.SemiBold,
+        )
+        if (chatModel.incognito.value) {
+          Icon(
+            Icons.Filled.TheaterComedy,
+            stringResource(R.string.incognito),
+            tint = Indigo,
+            modifier = Modifier.padding(10.dp).size(26.dp)
+          )
+        }
+      }
+    },
+    onTitleClick = null,
+    showSearch = showSearch,
+    onSearchValueChanged = onSearchValueChanged,
+    buttons = barButtons
+  )
+  Divider()
+}
+
+@Composable
+private fun ShareList(chatModel: ChatModel, search: String) {
+  val filter: (Chat) -> Boolean = { chat: Chat ->
+    chat.chatInfo.chatViewName.lowercase().contains(search.lowercase())
+  }
+  val chats by remember(search) {
+    derivedStateOf {
+      if (search.isEmpty()) chatModel.chats.filter { it.chatInfo.ready } else chatModel.chats.filter { it.chatInfo.ready }.filter(filter)
+    }
+  }
+  LazyColumn(
+    modifier = Modifier.fillMaxWidth()
+  ) {
+    items(chats) { chat ->
+      ShareListNavLinkView(chat, chatModel)
+    }
+  }
+}

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/ChatArchiveView.kt

@@ -59,25 +59,22 @@ fun ChatArchiveLayout(
     Modifier.fillMaxWidth(),
     horizontalAlignment = Alignment.Start,
   ) {
-    Text(
-      title,
-      Modifier.padding(start = 16.dp, bottom = 24.dp),
-      style = MaterialTheme.typography.h1
-    )
-
+    AppBarTitle(title)
     SectionView(stringResource(R.string.chat_archive_section)) {
       SettingsActionItem(
         Icons.Outlined.IosShare,
         stringResource(R.string.save_archive),
         saveArchive,
-        textColor = MaterialTheme.colors.primary
+        textColor = MaterialTheme.colors.primary,
+        iconColor = MaterialTheme.colors.primary,
       )
       SectionDivider()
       SettingsActionItem(
         Icons.Outlined.Delete,
         stringResource(R.string.delete_archive),
         deleteArchiveAlert,
-        textColor = Color.Red
+        textColor = Color.Red,
+        iconColor = Color.Red,
       )
     }
     val archiveTs = SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US).format(Date.from(archiveTime.toJavaInstant()))
@@ -97,8 +94,7 @@ private fun rememberSaveArchiveLauncher(cxt: Context, chatArchivePath: String):
           val contentResolver = cxt.contentResolver
           contentResolver.openOutputStream(destination)?.let { stream ->
             val outputStream = BufferedOutputStream(stream)
-            val file = File(chatArchivePath)
-            outputStream.write(file.readBytes())
+            File(chatArchivePath).inputStream().use { it.copyTo(outputStream) }
             outputStream.close()
             Toast.makeText(cxt, generalGetString(R.string.file_saved), Toast.LENGTH_SHORT).show()
           }
@@ -137,7 +133,7 @@ private fun deleteArchiveAlert(m: ChatModel, archivePath: String) {
 fun PreviewChatArchiveLayout() {
   SimpleXTheme {
     ChatArchiveLayout(
-      title = "New database archive",
+      "New database archive",
       archiveTime = Clock.System.now(),
       saveArchive = {},
       deleteArchiveAlert = {}

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

@@ -0,0 +1,525 @@
+package chat.simplex.app.views.database
+
+import SectionDivider
+import SectionItemView
+import SectionItemViewSpaceBetween
+import SectionTextFooter
+import SectionView
+import androidx.compose.foundation.*
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.ZeroCornerSize
+import androidx.compose.foundation.text.*
+import androidx.compose.material.*
+import androidx.compose.material.TextFieldDefaults.indicatorLine
+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.SolidColor
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+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.*
+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
+
+@Composable
+fun DatabaseEncryptionView(m: ChatModel) {
+  val progressIndicator = remember { mutableStateOf(false) }
+  val prefs = m.controller.appPrefs
+  val useKeychain = remember { mutableStateOf(prefs.storeDBPassphrase.get()) }
+  val initialRandomDBPassphrase = remember { mutableStateOf(prefs.initialRandomDBPassphrase.get()) }
+  val storedKey = remember { val key = DatabaseUtils.getDatabaseKey(); mutableStateOf(key != null && key != "") }
+  // Do not do rememberSaveable on current key to prevent saving it on disk in clear text
+  val currentKey = remember { mutableStateOf(if (initialRandomDBPassphrase.value) DatabaseUtils.getDatabaseKey() ?: "" else "") }
+  val newKey = rememberSaveable { mutableStateOf("") }
+  val confirmNewKey = rememberSaveable { mutableStateOf("") }
+
+  Box(
+    Modifier.fillMaxSize(),
+  ) {
+    DatabaseEncryptionLayout(
+      useKeychain,
+      prefs,
+      m.chatDbEncrypted.value,
+      currentKey,
+      newKey,
+      confirmNewKey,
+      storedKey,
+      initialRandomDBPassphrase,
+      progressIndicator,
+      onConfirmEncrypt = {
+        progressIndicator.value = true
+        withApi {
+          try {
+            prefs.encryptionStartedAt.set(Clock.System.now())
+            val error = m.controller.apiStorageEncryption(currentKey.value, newKey.value)
+            prefs.encryptionStartedAt.set(null)
+            val sqliteError = ((error?.chatError as? ChatError.ChatErrorDatabase)?.databaseError as? DatabaseError.ErrorExport)?.sqliteError
+            when {
+              sqliteError is SQLiteError.ErrorNotADatabase -> {
+                operationEnded(m, progressIndicator) {
+                  AlertManager.shared.showAlertMsg(
+                    generalGetString(R.string.wrong_passphrase_title),
+                    generalGetString(R.string.enter_correct_current_passphrase)
+                  )
+                }
+              }
+              error != null -> {
+                operationEnded(m, progressIndicator) {
+                  AlertManager.shared.showAlertMsg(generalGetString(R.string.error_encrypting_database),
+                    "failed to set storage encryption: ${error.responseType} ${error.details}"
+                  )
+                }
+              }
+              else -> {
+                prefs.initialRandomDBPassphrase.set(false)
+                initialRandomDBPassphrase.value = false
+                if (useKeychain.value) {
+                  DatabaseUtils.setDatabaseKey(newKey.value)
+                }
+                resetFormAfterEncryption(m, initialRandomDBPassphrase, currentKey, newKey, confirmNewKey, storedKey, useKeychain.value)
+                operationEnded(m, progressIndicator) {
+                  AlertManager.shared.showAlertMsg(generalGetString(R.string.database_encrypted))
+                }
+              }
+            }
+          } catch (e: Exception) {
+            operationEnded(m, progressIndicator) {
+              AlertManager.shared.showAlertMsg(generalGetString(R.string.error_encrypting_database), e.stackTraceToString())
+            }
+          }
+        }
+      }
+    )
+    if (progressIndicator.value) {
+      Box(
+        Modifier.fillMaxSize(),
+        contentAlignment = Alignment.Center
+      ) {
+        CircularProgressIndicator(
+          Modifier
+            .padding(horizontal = 2.dp)
+            .size(30.dp),
+          color = HighOrLowlight,
+          strokeWidth = 2.5.dp
+        )
+      }
+    }
+  }
+}
+
+@Composable
+fun DatabaseEncryptionLayout(
+  useKeychain: MutableState<Boolean>,
+  prefs: AppPreferences,
+  chatDbEncrypted: Boolean?,
+  currentKey: MutableState<String>,
+  newKey: MutableState<String>,
+  confirmNewKey: MutableState<String>,
+  storedKey: MutableState<Boolean>,
+  initialRandomDBPassphrase: MutableState<Boolean>,
+  progressIndicator: MutableState<Boolean>,
+  onConfirmEncrypt: () -> Unit,
+) {
+  Column(
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    AppBarTitle(stringResource(R.string.database_passphrase))
+    SectionView(null) {
+      SavePassphraseSetting(useKeychain.value, initialRandomDBPassphrase.value, storedKey.value, progressIndicator.value) { checked ->
+        if (checked) {
+          setUseKeychain(true, useKeychain, prefs)
+        } else if (storedKey.value) {
+          AlertManager.shared.showAlertDialog(
+            title = generalGetString(R.string.remove_passphrase_from_keychain),
+            text = generalGetString(R.string.notifications_will_be_hidden) + "\n" + storeSecurelyDanger(),
+            confirmText = generalGetString(R.string.remove_passphrase),
+            onConfirm = {
+              DatabaseUtils.removeDatabaseKey()
+              setUseKeychain(false, useKeychain, prefs)
+              storedKey.value = false
+            },
+            destructive = true,
+          )
+        } else {
+          setUseKeychain(false, useKeychain, prefs)
+        }
+      }
+
+      if (!initialRandomDBPassphrase.value && chatDbEncrypted == true) {
+        SectionDivider()
+
+        PassphraseField(
+          currentKey,
+          generalGetString(R.string.current_passphrase),
+          modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+          isValid = ::validKey,
+          keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
+        )
+      }
+
+      SectionDivider()
+
+      PassphraseField(
+        newKey,
+        generalGetString(R.string.new_passphrase),
+        modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+        showStrength = true,
+        isValid = ::validKey,
+        keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
+      )
+      val onClickUpdate = {
+        // Don't do things concurrently. Shouldn't be here concurrently, just in case
+        if (!progressIndicator.value) {
+          if (currentKey.value == "") {
+            if (useKeychain.value)
+              encryptDatabaseSavedAlert(onConfirmEncrypt)
+            else
+              encryptDatabaseAlert(onConfirmEncrypt)
+          } else {
+            if (useKeychain.value)
+              changeDatabaseKeySavedAlert(onConfirmEncrypt)
+            else
+              changeDatabaseKeyAlert(onConfirmEncrypt)
+          }
+        }
+      }
+      val disabled = currentKey.value == newKey.value ||
+          newKey.value != confirmNewKey.value ||
+          newKey.value.isEmpty() ||
+          !validKey(currentKey.value) ||
+          !validKey(newKey.value) ||
+          progressIndicator.value
+
+      SectionDivider()
+
+      PassphraseField(
+        confirmNewKey,
+        generalGetString(R.string.confirm_new_passphrase),
+        modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+        isValid = { confirmNewKey.value == "" || newKey.value == confirmNewKey.value },
+        keyboardActions = KeyboardActions(onDone = {
+          if (!disabled) onClickUpdate()
+          defaultKeyboardAction(ImeAction.Done)
+        }),
+      )
+
+      SectionDivider()
+
+      SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled, minHeight = TextFieldDefaults.MinHeight) {
+        Text(generalGetString(R.string.update_database_passphrase), color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary)
+      }
+    }
+
+    Column {
+      if (chatDbEncrypted == false) {
+        SectionTextFooter(generalGetString(R.string.database_is_not_encrypted))
+      } else if (useKeychain.value) {
+        if (storedKey.value) {
+          SectionTextFooter(generalGetString(R.string.keychain_is_storing_securely))
+          if (initialRandomDBPassphrase.value) {
+            SectionTextFooter(generalGetString(R.string.encrypted_with_random_passphrase))
+          } else {
+            SectionTextFooter(generalGetString(R.string.impossible_to_recover_passphrase))
+          }
+        } else {
+          SectionTextFooter(generalGetString(R.string.keychain_allows_to_receive_ntfs))
+        }
+      } else {
+        SectionTextFooter(generalGetString(R.string.you_have_to_enter_passphrase_every_time))
+        SectionTextFooter(generalGetString(R.string.impossible_to_recover_passphrase))
+      }
+    }
+  }
+}
+
+fun encryptDatabaseSavedAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.encrypt_database_question),
+    text = generalGetString(R.string.database_will_be_encrypted_and_passphrase_stored) + "\n" + storeSecurelySaved(),
+    confirmText = generalGetString(R.string.encrypt_database),
+    onConfirm = onConfirm,
+    destructive = false,
+  )
+}
+
+fun encryptDatabaseAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.encrypt_database_question),
+    text = generalGetString(R.string.database_will_be_encrypted) +"\n" + storeSecurelyDanger(),
+    confirmText = generalGetString(R.string.encrypt_database),
+    onConfirm = onConfirm,
+    destructive = true,
+  )
+}
+
+fun changeDatabaseKeySavedAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.change_database_passphrase_question),
+    text = generalGetString(R.string.database_encryption_will_be_updated) + "\n" + storeSecurelySaved(),
+    confirmText = generalGetString(R.string.update_database),
+    onConfirm = onConfirm,
+    destructive = false,
+  )
+}
+
+fun changeDatabaseKeyAlert(onConfirm: () -> Unit) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.change_database_passphrase_question),
+    text = generalGetString(R.string.database_passphrase_will_be_updated) + "\n" + storeSecurelyDanger(),
+    confirmText = generalGetString(R.string.update_database),
+    onConfirm = onConfirm,
+    destructive = true,
+  )
+}
+
+@Composable
+fun SavePassphraseSetting(
+  useKeychain: Boolean,
+  initialRandomDBPassphrase: Boolean,
+  storedKey: Boolean,
+  progressIndicator: Boolean,
+  minHeight: Dp = TextFieldDefaults.MinHeight,
+  onCheckedChange: (Boolean) -> Unit,
+) {
+  SectionItemView(minHeight = minHeight) {
+    Row(verticalAlignment = Alignment.CenterVertically) {
+      Icon(
+        if (storedKey) Icons.Filled.VpnKey else Icons.Filled.VpnKeyOff,
+        stringResource(R.string.save_passphrase_in_keychain),
+        tint = if (storedKey) SimplexGreen else HighOrLowlight
+      )
+      Spacer(Modifier.padding(horizontal = 4.dp))
+      Text(
+        stringResource(R.string.save_passphrase_in_keychain),
+        Modifier.padding(end = 24.dp),
+        color = Color.Unspecified
+      )
+      Spacer(Modifier.fillMaxWidth().weight(1f))
+      Switch(
+        checked = useKeychain,
+        onCheckedChange = onCheckedChange,
+        colors = SwitchDefaults.colors(
+          checkedThumbColor = MaterialTheme.colors.primary,
+          uncheckedThumbColor = HighOrLowlight
+        ),
+        enabled = !initialRandomDBPassphrase && !progressIndicator
+      )
+    }
+  }
+}
+
+fun resetFormAfterEncryption(
+  m: ChatModel,
+  initialRandomDBPassphrase: MutableState<Boolean>,
+  currentKey: MutableState<String>,
+  newKey: MutableState<String>,
+  confirmNewKey: MutableState<String>,
+  storedKey: MutableState<Boolean>,
+  stored: Boolean = false,
+) {
+  m.chatDbEncrypted.value = true
+  initialRandomDBPassphrase.value = false
+  m.controller.appPrefs.initialRandomDBPassphrase.set(false)
+  currentKey.value = ""
+  newKey.value = ""
+  confirmNewKey.value = ""
+  storedKey.value = stored
+}
+
+fun setUseKeychain(value: Boolean, useKeychain: MutableState<Boolean>, prefs: AppPreferences) {
+  useKeychain.value = value
+  prefs.storeDBPassphrase.set(value)
+}
+
+fun storeSecurelySaved() = generalGetString(R.string.store_passphrase_securely)
+
+fun storeSecurelyDanger() = generalGetString(R.string.store_passphrase_securely_without_recover)
+
+private fun operationEnded(m: ChatModel, progressIndicator: MutableState<Boolean>, alert: () -> Unit) {
+  m.chatDbChanged.value = true
+  progressIndicator.value = false
+  alert.invoke()
+}
+
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+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) }
+  val icon = if (valid) {
+    if (showKey) Icons.Filled.VisibilityOff else Icons.Filled.Visibility
+  } else Icons.Outlined.Error
+  val iconColor = if (valid) {
+    if (showStrength && key.value.isNotEmpty()) PassphraseStrength.check(key.value).color else HighOrLowlight
+  } else Color.Red
+  val keyboard = LocalSoftwareKeyboardController.current
+  val keyboardOptions = KeyboardOptions(
+    imeAction = if (keyboardActions.onNext != null) ImeAction.Next else ImeAction.Done,
+    autoCorrect = false,
+    keyboardType = KeyboardType.Password
+  )
+  val state = remember {
+    mutableStateOf(TextFieldValue(key.value))
+  }
+  val enabled = true
+  val colors = TextFieldDefaults.textFieldColors(
+    backgroundColor = Color.Unspecified,
+    textColor = MaterialTheme.colors.onBackground,
+    focusedIndicatorColor = Color.Unspecified,
+    unfocusedIndicatorColor = Color.Unspecified,
+  )
+  val color = MaterialTheme.colors.onBackground
+  val shape = MaterialTheme.shapes.small.copy(bottomEnd = ZeroCornerSize, bottomStart = ZeroCornerSize)
+  val interactionSource = remember { MutableInteractionSource() }
+  BasicTextField(
+    value = state.value,
+    modifier = modifier
+      .fillMaxWidth()
+      .background(colors.backgroundColor(enabled).value, shape)
+      .indicatorLine(enabled, false, interactionSource, colors)
+      .defaultMinSize(
+        minWidth = TextFieldDefaults.MinWidth,
+        minHeight = TextFieldDefaults.MinHeight
+      ),
+    onValueChange = {
+      state.value = it
+      key.value = it.text
+      valid = isValid(it.text)
+    },
+    cursorBrush = SolidColor(colors.cursorColor(false).value),
+    visualTransformation = if (showKey)
+      VisualTransformation.None
+    else
+      VisualTransformation { TransformedText(AnnotatedString(it.text.map { "*" }.joinToString(separator = "")), OffsetMapping.Identity) },
+    keyboardOptions = keyboardOptions,
+    keyboardActions = KeyboardActions(onDone = {
+      keyboard?.hide()
+      keyboardActions.onDone?.invoke(this)
+    }),
+    singleLine = true,
+    textStyle = TextStyle.Default.copy(
+      color = color,
+      fontWeight = FontWeight.Normal,
+      fontSize = 16.sp
+    ),
+    interactionSource = interactionSource,
+    decorationBox = @Composable { innerTextField ->
+      TextFieldDefaults.TextFieldDecorationBox(
+        value = state.value.text,
+        innerTextField = innerTextField,
+        placeholder = { Text(placeholder, color = HighOrLowlight) },
+        singleLine = true,
+        enabled = enabled,
+        isError = !valid,
+        trailingIcon = {
+          IconButton({ showKey = !showKey }) {
+            Icon(icon, null, tint = iconColor)
+          }
+        },
+        interactionSource = interactionSource,
+        contentPadding = TextFieldDefaults.textFieldWithLabelPadding(start = 0.dp, end = 0.dp),
+        visualTransformation = VisualTransformation.None,
+        colors = colors
+      )
+    }
+  )
+  LaunchedEffect(Unit) {
+    snapshotFlow { dependsOn?.value }
+      .distinctUntilChanged()
+      .collect {
+        valid = isValid(state.value.text)
+      }
+  }
+}
+
+// based on https://generatepasswords.org/how-to-calculate-entropy/
+private fun passphraseEntropy(s: String): Double {
+  var hasDigits = false
+  var hasUppercase = false
+  var hasLowercase = false
+  var hasSymbols = false
+  for (c in s) {
+    if (c.isDigit()) {
+      hasDigits = true
+    } else if (c.isLetter()) {
+      if (c.isUpperCase()) {
+        hasUppercase = true
+      } else {
+        hasLowercase = true
+      }
+    } else if (c.isASCII()) {
+      hasSymbols = true
+    }
+  }
+  val poolSize = (if (hasDigits) 10 else 0) + (if (hasUppercase) 26 else 0) + (if (hasLowercase) 26 else 0) + (if (hasSymbols) 32 else 0)
+  return s.length * log2(poolSize.toDouble())
+}
+
+private enum class PassphraseStrength(val color: Color) {
+  VERY_WEAK(Color.Red), WEAK(WarningOrange), REASONABLE(WarningYellow), STRONG(SimplexGreen);
+
+  companion object {
+    fun check(s: String) = with(passphraseEntropy(s)) {
+      when {
+        this > 100 -> STRONG
+        this > 70 -> REASONABLE
+        this > 40 -> WEAK
+        else -> VERY_WEAK
+      }
+    }
+  }
+}
+
+fun validKey(s: String): Boolean {
+  for (c in s) {
+    if (c.isWhitespace() || !c.isASCII()) {
+      return false
+    }
+  }
+  return true
+}
+
+private fun Char.isASCII() = code in 32..126
+
+@Preview
+@Composable
+fun PreviewDatabaseEncryptionLayout() {
+  SimpleXTheme {
+    DatabaseEncryptionLayout(
+      useKeychain = remember { mutableStateOf(true) },
+      prefs = AppPreferences(SimplexApp.context),
+      chatDbEncrypted = true,
+      currentKey = remember { mutableStateOf("") },
+      newKey = remember { mutableStateOf("") },
+      confirmNewKey = remember { mutableStateOf("") },
+      storedKey = remember { mutableStateOf(true) },
+      initialRandomDBPassphrase = remember { mutableStateOf(true) },
+      progressIndicator = remember { mutableStateOf(false) },
+      onConfirmEncrypt = {},
+    )
+  }
+}

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

@@ -0,0 +1,304 @@
+package chat.simplex.app.views.database
+
+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
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.*
+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.*
+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
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import kotlin.io.path.Path
+
+@Composable
+fun DatabaseErrorView(
+  chatDbStatus: State<DBMigrationResult?>,
+  appPreferences: AppPreferences,
+) {
+  val progressIndicator = remember { mutableStateOf(false) }
+  val dbKey = remember { mutableStateOf("") }
+  var storedDBKey by remember { mutableStateOf(DatabaseUtils.getDatabaseKey()) }
+  var useKeychain by remember { mutableStateOf(appPreferences.storeDBPassphrase.get()) }
+  val context = LocalContext.current
+  val restoreDbFromBackup = remember { mutableStateOf(shouldShowRestoreDbButton(appPreferences, context)) }
+
+  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)
+    callRunChat()
+  }
+
+  @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(
+    Modifier.fillMaxSize().verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+    verticalArrangement = Arrangement.Center,
+  ) {
+    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)
+            SectionSpacer()
+            FileNameText(status.dbFile)
+          }
+        } else {
+          DatabaseErrorDetails(R.string.encrypted_database) {
+            Text(generalGetString(R.string.database_passphrase_is_required))
+            if (useKeychain) {
+              DatabaseKeyField(dbKey, buttonEnabled, ::saveAndRunChatOnClick)
+              SaveAndOpenButton(buttonEnabled, ::saveAndRunChatOnClick)
+            } else {
+              DatabaseKeyField(dbKey, buttonEnabled) { callRunChat() }
+              OpenChatButton(buttonEnabled) { callRunChat() }
+            }
+          }
+        }
+      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 ->
+        DatabaseErrorDetails(R.string.keychain_error) {
+          Text(generalGetString(R.string.cannot_access_keychain))
+        }
+      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,
+        )
+      }
+    }
+  }
+  if (progressIndicator.value) {
+    Box(
+      Modifier.fillMaxSize(),
+      contentAlignment = Alignment.Center
+    ) {
+      CircularProgressIndicator(
+        Modifier
+          .padding(horizontal = 2.dp)
+          .size(30.dp),
+        color = HighOrLowlight,
+        strokeWidth = 2.5.dp
+      )
+    }
+  }
+}
+
+private fun runChat(
+  dbKey: String? = null,
+  confirmMigrations: MigrationConfirmation? = null,
+  chatDbStatus: State<DBMigrationResult?>,
+  progressIndicator: MutableState<Boolean>,
+  prefs: AppPreferences
+) = CoroutineScope(Dispatchers.Default).launch {
+  // Don't do things concurrently. Shouldn't be here concurrently, just in case
+  if (progressIndicator.value) return@launch
+  progressIndicator.value = true
+  try {
+    SimplexApp.context.initChatController(dbKey, confirmMigrations)
+  } catch (e: Exception) {
+    Log.d(TAG, "initializeChat ${e.stackTraceToString()}")
+  }
+  progressIndicator.value = false
+  when (val status = chatDbStatus.value) {
+    is DBMigrationResult.OK -> {
+      SimplexService.cancelPassphraseNotification()
+      when (prefs.notificationsMode.get()) {
+        NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start(SimplexApp.context) }
+        NotificationsMode.PERIODIC.name -> SimplexApp.context.schedulePeriodicWakeUp()
+      }
+    }
+    is DBMigrationResult.ErrorNotADatabase ->
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.wrong_passphrase_title), generalGetString(R.string.enter_correct_passphrase))
+    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 ->
+      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 -> {}
+  }
+}
+
+private fun shouldShowRestoreDbButton(prefs: AppPreferences, context: Context): Boolean {
+  val startedAt = prefs.encryptionStartedAt.get() ?: return false
+  /** Just in case there is any small difference between reported Java's [Clock.System.now] and Linux's time on a file */
+  val safeDiffInTime = 10_000L
+  val filesChat = File(context.dataDir.absolutePath + File.separator + "files_chat.db.bak")
+  val filesAgent = File(context.dataDir.absolutePath + File.separator + "files_agent.db.bak")
+  return filesChat.exists() &&
+      filesAgent.exists() &&
+      startedAt.toEpochMilliseconds() - safeDiffInTime <= filesChat.lastModified() &&
+      startedAt.toEpochMilliseconds() - safeDiffInTime <= filesAgent.lastModified()
+}
+
+private fun restoreDb(restoreDbFromBackup: MutableState<Boolean>, prefs: AppPreferences, context: Context) {
+  val filesChatBase = context.dataDir.absolutePath + File.separator + "files_chat.db"
+  val filesAgentBase = context.dataDir.absolutePath + File.separator + "files_agent.db"
+  try {
+    Files.copy(Path("$filesChatBase.bak"), Path(filesChatBase), StandardCopyOption.REPLACE_EXISTING)
+    Files.copy(Path("$filesAgentBase.bak"), Path(filesAgentBase), StandardCopyOption.REPLACE_EXISTING)
+    restoreDbFromBackup.value = false
+    prefs.encryptionStartedAt.set(null)
+  } catch (e: Exception) {
+    AlertManager.shared.showAlertMsg(generalGetString(R.string.database_restore_error), e.stackTraceToString())
+  }
+}
+
+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) {
+  PassphraseField(
+    text,
+    generalGetString(R.string.enter_passphrase),
+    isValid = ::validKey,
+    keyboardActions = KeyboardActions(onDone = if (enabled) {
+      { onClick?.invoke() }
+    } else null
+    )
+  )
+}
+
+@Composable
+private fun ColumnScope.SaveAndOpenButton(enabled: Boolean, onClick: () -> Unit) {
+  TextButton(onClick, Modifier.align(Alignment.CenterHorizontally), enabled = enabled) {
+    Text(generalGetString(R.string.save_passphrase_and_open_chat))
+  }
+}
+
+@Composable
+private fun ColumnScope.OpenChatButton(enabled: Boolean, onClick: () -> Unit) {
+  TextButton(onClick, Modifier.align(Alignment.CenterHorizontally), enabled = enabled) {
+    Text(generalGetString(R.string.open_chat))
+  }
+}
+
+@Composable
+private fun ColumnScope.RestoreDbButton(onClick: () -> Unit) {
+  TextButton(onClick, Modifier.align(Alignment.CenterHorizontally)) {
+    Text(generalGetString(R.string.restore_database), color = MaterialTheme.colors.error)
+  }
+}
+
+@Preview
+@Composable
+fun PreviewChatInfoLayout() {
+  SimpleXTheme {
+    DatabaseErrorView(
+      remember { mutableStateOf(DBMigrationResult.ErrorNotADatabase("simplex_v1_chat.db")) },
+      AppPreferences(SimplexApp.context)
+    )
+  }
+}

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

@@ -8,17 +8,17 @@ 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
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.PlayArrow
-import androidx.compose.material.icons.filled.Report
+import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
@@ -26,19 +26,24 @@ 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
 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.ui.theme.*
 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.*
+import kotlin.collections.ArrayList
 
 @Composable
 fun DatabaseView(
@@ -49,19 +54,23 @@ fun DatabaseView(
   val progressIndicator = remember { mutableStateOf(false) }
   val runChat = remember { mutableStateOf(m.chatRunning.value ?: true) }
   val prefs = m.controller.appPrefs
+  val useKeychain = remember { mutableStateOf(prefs.storeDBPassphrase.get()) }
   val chatArchiveName = remember { mutableStateOf(prefs.chatArchiveName.get()) }
   val chatArchiveTime = remember { mutableStateOf(prefs.chatArchiveTime.get()) }
   val chatLastStart = remember { mutableStateOf(prefs.chatLastStart.get()) }
   val chatArchiveFile = remember { mutableStateOf<String?>(null) }
   val saveArchiveLauncher = rememberSaveArchiveLauncher(cxt = context, chatArchiveFile)
+  val appFilesCountAndSize = remember { mutableStateOf(directoryFileCountAndSize(getAppFilesDirectory(context))) }
   val importArchiveLauncher = rememberGetContentLauncher { uri: Uri? ->
     if (uri != null) {
-      importArchiveAlert(m, context, uri, progressIndicator)
+      importArchiveAlert(m, context, uri, appFilesCountAndSize, progressIndicator)
     }
   }
+  val chatDbDeleted = remember { m.chatDbDeleted }
   LaunchedEffect(m.chatRunning) {
     runChat.value = m.chatRunning.value ?: true
   }
+  val chatItemTTL = remember { mutableStateOf(m.chatItemTTL.value) }
   Box(
     Modifier.fillMaxSize(),
   ) {
@@ -69,14 +78,33 @@ fun DatabaseView(
       progressIndicator.value,
       runChat.value,
       m.chatDbChanged.value,
+      useKeychain.value,
+      m.chatDbEncrypted.value,
+      m.controller.appPrefs.initialRandomDBPassphrase,
       importArchiveLauncher,
       chatArchiveName,
       chatArchiveTime,
       chatLastStart,
-      startChat = { startChat(m, runChat, chatLastStart, context) },
+      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) },
       deleteChatAlert = { deleteChatAlert(m, progressIndicator) },
+      deleteAppFilesAndMedia = { deleteFilesAndMediaAlert(context, appFilesCountAndSize) },
+      onChatItemTTLSelected = {
+        val oldValue = chatItemTTL.value
+        chatItemTTL.value = it
+        if (it < oldValue) {
+          setChatItemTTLAlert(m, chatItemTTL, progressIndicator, appFilesCountAndSize, context)
+        } else if (it != oldValue) {
+          setCiTTL(m, chatItemTTL, progressIndicator, appFilesCountAndSize, context)
+        }
+      },
       showSettingsModal
     )
     if (progressIndicator.value) {
@@ -101,40 +129,81 @@ fun DatabaseLayout(
   progressIndicator: Boolean,
   runChat: Boolean,
   chatDbChanged: Boolean,
+  useKeyChain: Boolean,
+  chatDbEncrypted: 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,
   deleteChatAlert: () -> Unit,
+  deleteAppFilesAndMedia: () -> Unit,
+  onChatItemTTLSelected: (ChatItemTTL) -> Unit,
   showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit)
 ) {
   val stopped = !runChat
-  val operationsDisabled = !stopped || progressIndicator || chatDbChanged
+  val operationsDisabled = !stopped || progressIndicator
 
   Column(
-    Modifier.fillMaxWidth(),
+    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()).padding(bottom = DEFAULT_BOTTOM_PADDING),
     horizontalAlignment = Alignment.Start,
   ) {
-    Text(
-      stringResource(R.string.your_chat_database),
-      Modifier.padding(start = 16.dp, bottom = 24.dp),
-      style = MaterialTheme.typography.h1
+    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, chatDbChanged, startChat, stopChatAlert)
+      RunChatSetting(runChat, stopped, chatDbDeleted, startChat, stopChatAlert)
     }
     SectionSpacer()
 
     SectionView(stringResource(R.string.chat_database_section)) {
+      val unencrypted = chatDbEncrypted == false
+      SettingsActionItem(
+        if (unencrypted) Icons.Outlined.LockOpen else if (useKeyChain) Icons.Filled.VpnKey else Icons.Outlined.Lock,
+        stringResource(R.string.database_passphrase),
+        click = showSettingsModal() { DatabaseEncryptionView(it) },
+        iconColor = if (unencrypted) WarningOrange else HighOrLowlight,
+        disabled = operationsDisabled
+      )
+      SectionDivider()
+      AppDataBackupPreference(privacyFullBackup, initialRandomDBPassphrase)
+      SectionDivider()
       SettingsActionItem(
         Icons.Outlined.IosShare,
         stringResource(R.string.export_database),
-        exportArchive,
+        click = {
+          if (initialRandomDBPassphrase.get()) {
+            exportProhibitedAlert()
+          } else {
+            exportArchive()
+          }
+        },
         textColor = MaterialTheme.colors.primary,
+        iconColor = MaterialTheme.colors.primary,
         disabled = operationsDisabled
       )
       SectionDivider()
@@ -143,6 +212,7 @@ fun DatabaseLayout(
         stringResource(R.string.import_database),
         { importArchiveLauncher.launch("application/zip") },
         textColor = Color.Red,
+        iconColor = Color.Red,
         disabled = operationsDisabled
       )
       SectionDivider()
@@ -164,28 +234,119 @@ fun DatabaseLayout(
         stringResource(R.string.delete_database),
         deleteChatAlert,
         textColor = Color.Red,
+        iconColor = Color.Red,
         disabled = operationsDisabled
       )
     }
     SectionTextFooter(
-      if (chatDbChanged) {
-        stringResource(R.string.restart_the_app_to_use_new_chat_database)
+      if (stopped) {
+        stringResource(R.string.you_must_use_the_most_recent_version_of_database)
       } else {
-        if (stopped) {
-          stringResource(R.string.you_must_use_the_most_recent_version_of_database)
-        } else {
-          stringResource(R.string.stop_chat_to_enable_database_actions)
-        }
+        stringResource(R.string.stop_chat_to_enable_database_actions)
+      }
+    )
+    SectionSpacer()
+
+    SectionView(stringResource(R.string.files_and_media_section).uppercase()) {
+      val deleteFilesDisabled = operationsDisabled || appFilesCountAndSize.value.first == 0
+      SectionItemView(
+        deleteAppFilesAndMedia,
+        disabled = deleteFilesDisabled
+      ) {
+        Text(
+          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
+        )
+      }
+    }
+    val (count, size) = appFilesCountAndSize.value
+    SectionTextFooter(
+      if (count == 0) {
+        stringResource(R.string.no_received_app_files)
+      } else {
+        String.format(stringResource(R.string.total_files_count_and_size), count, formatBytes(size))
       }
     )
   }
 }
 
+@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>,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  context: Context
+) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.enable_automatic_deletion_question),
+    text = generalGetString(R.string.enable_automatic_deletion_message),
+    confirmText = generalGetString(R.string.delete_messages),
+    onConfirm = { setCiTTL(m, selectedChatItemTTL, progressIndicator, appFilesCountAndSize, context) },
+    onDismiss = { selectedChatItemTTL.value = m.chatItemTTL.value }
+  )
+}
+
+@Composable
+private fun TtlOptions(current: State<ChatItemTTL>, enabled: State<Boolean>, onSelected: (ChatItemTTL) -> Unit) {
+  val values = remember {
+    val all: ArrayList<ChatItemTTL> = arrayListOf(ChatItemTTL.None, ChatItemTTL.Month, ChatItemTTL.Week, ChatItemTTL.Day)
+    if (current.value is ChatItemTTL.Seconds) {
+      all.add(current.value)
+    }
+    all.map {
+      when (it) {
+        is ChatItemTTL.None -> it to generalGetString(R.string.chat_item_ttl_none)
+        is ChatItemTTL.Day -> it to generalGetString(R.string.chat_item_ttl_day)
+        is ChatItemTTL.Week -> it to generalGetString(R.string.chat_item_ttl_week)
+        is ChatItemTTL.Month -> it to generalGetString(R.string.chat_item_ttl_month)
+        is ChatItemTTL.Seconds -> it to String.format(generalGetString(R.string.chat_item_ttl_seconds), it.secs)
+      }
+    }
+  }
+  ExposedDropDownSettingRow(
+    generalGetString(R.string.delete_messages_after),
+    values,
+    current,
+    icon = null,
+    enabled = enabled,
+    onSelected = onSelected
+  )
+}
+
 @Composable
 fun RunChatSetting(
   runChat: Boolean,
   stopped: Boolean,
-  chatDbChanged: Boolean,
+  chatDbDeleted: Boolean,
   startChat: () -> Unit,
   stopChatAlert: () -> Unit
 ) {
@@ -195,16 +356,16 @@ fun RunChatSetting(
       Icon(
         if (stopped) Icons.Filled.Report else Icons.Filled.PlayArrow,
         chatRunningText,
-        tint = if (chatDbChanged) HighOrLowlight else if (stopped) Color.Red else MaterialTheme.colors.primary
+        tint = if (stopped) Color.Red else MaterialTheme.colors.primary
       )
       Spacer(Modifier.padding(horizontal = 4.dp))
       Text(
         chatRunningText,
-        Modifier.padding(end = 24.dp),
-        color = if (chatDbChanged) HighOrLowlight else Color.Unspecified
+        Modifier.padding(end = 24.dp)
       )
       Spacer(Modifier.fillMaxWidth().weight(1f))
       Switch(
+        enabled = !chatDbDeleted,
         checked = runChat,
         onCheckedChange = { runChatSwitch ->
           if (runChatSwitch) {
@@ -217,7 +378,6 @@ fun RunChatSetting(
           checkedThumbColor = MaterialTheme.colors.primary,
           uncheckedThumbColor = HighOrLowlight
         ),
-        enabled = !chatDbChanged
       )
     }
   }
@@ -228,16 +388,28 @@ fun chatArchiveTitle(chatArchiveTime: Instant, chatLastStart: Instant): String {
   return stringResource(if (chatArchiveTime < chatLastStart) R.string.old_database_archive else R.string.new_database_archive)
 }
 
-private fun startChat(m: ChatModel, runChat: MutableState<Boolean>, chatLastStart: MutableState<Instant?>, context: Context) {
+private fun startChat(m: ChatModel, runChat: MutableState<Boolean>, chatLastStart: MutableState<Instant?>, chatDbChanged: MutableState<Boolean>) {
   withApi {
     try {
+      if (chatDbChanged.value) {
+        SimplexApp.context.initChatController()
+        chatDbChanged.value = false
+      }
+      if (m.chatDbStatus.value !is DBMigrationResult.OK) {
+        /** Hide current view and show [DatabaseErrorView] */
+        ModalManager.shared.closeModals()
+        return@withApi
+      }
       m.controller.apiStartChat()
       runChat.value = true
       m.chatRunning.value = true
       val ts = Clock.System.now()
       m.controller.appPrefs.chatLastStart.set(ts)
       chatLastStart.value = ts
-      SimplexService.start(context)
+      when (m.controller.appPrefs.notificationsMode.get()) {
+        NotificationsMode.SERVICE.name -> CoroutineScope(Dispatchers.Default).launch { SimplexService.start(SimplexApp.context) }
+        NotificationsMode.PERIODIC.name -> SimplexApp.context.schedulePeriodicWakeUp()
+      }
     } catch (e: Error) {
       runChat.value = false
       AlertManager.shared.showAlertMsg(generalGetString(R.string.error_starting_chat), e.toString())
@@ -250,18 +422,50 @@ private fun stopChatAlert(m: ChatModel, runChat: MutableState<Boolean>, context:
     title = generalGetString(R.string.stop_chat_question),
     text = generalGetString(R.string.stop_chat_to_export_import_or_delete_chat_database),
     confirmText = generalGetString(R.string.stop_chat_confirmation),
-    onConfirm = { stopChat(m, runChat, context) },
+    onConfirm = { authStopChat(m, runChat, context) },
     onDismiss = { runChat.value = true }
   )
 }
 
+private fun exportProhibitedAlert() {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.set_password_to_export),
+    text = generalGetString(R.string.set_password_to_export_desc),
+  )
+}
+
+private fun authStopChat(m: ChatModel, runChat: MutableState<Boolean>, context: Context) {
+  if (m.controller.appPrefs.performLA.get()) {
+    authenticate(
+      generalGetString(R.string.auth_stop_chat),
+      generalGetString(R.string.auth_log_in_using_credential),
+      context as FragmentActivity,
+      completed = { laResult ->
+        when (laResult) {
+          LAResult.Success, LAResult.Unavailable -> {
+            stopChat(m, runChat, context)
+          }
+          is LAResult.Error -> {
+          }
+          LAResult.Failed -> {
+            runChat.value = true
+          }
+        }
+      }
+    )
+  } else {
+    stopChat(m, runChat, context)
+  }
+}
+
 private fun stopChat(m: ChatModel, runChat: MutableState<Boolean>, context: Context) {
   withApi {
     try {
       m.controller.apiStopChat()
       runChat.value = false
       m.chatRunning.value = false
-      SimplexService.stop(context)
+      SimplexService.safeStopService(context)
+      MessagesFetcherWorker.cancelAll()
     } catch (e: Error) {
       runChat.value = true
       AlertManager.shared.showAlertMsg(generalGetString(R.string.error_starting_chat), e.toString())
@@ -340,8 +544,7 @@ private fun rememberSaveArchiveLauncher(cxt: Context, chatArchiveFile: MutableSt
             val contentResolver = cxt.contentResolver
             contentResolver.openOutputStream(destination)?.let { stream ->
               val outputStream = BufferedOutputStream(stream)
-              val file = File(filePath)
-              outputStream.write(file.readBytes())
+              File(filePath).inputStream().use { it.copyTo(outputStream) }
               outputStream.close()
               Toast.makeText(cxt, generalGetString(R.string.file_saved), Toast.LENGTH_SHORT).show()
             }
@@ -358,16 +561,28 @@ private fun rememberSaveArchiveLauncher(cxt: Context, chatArchiveFile: MutableSt
     }
   )
 
-private fun importArchiveAlert(m: ChatModel, context: Context, importedArchiveUri: Uri, progressIndicator: MutableState<Boolean>) {
+private fun importArchiveAlert(
+  m: ChatModel,
+  context: Context,
+  importedArchiveUri: Uri,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  progressIndicator: MutableState<Boolean>
+) {
   AlertManager.shared.showAlertDialog(
     title = generalGetString(R.string.import_database_question),
     text = generalGetString(R.string.your_current_chat_database_will_be_deleted_and_replaced_with_the_imported_one),
     confirmText = generalGetString(R.string.import_database_confirmation),
-    onConfirm = { importArchive(m, context, importedArchiveUri, progressIndicator) }
+    onConfirm = { importArchive(m, context, importedArchiveUri, appFilesCountAndSize, progressIndicator) }
   )
 }
 
-private fun importArchive(m: ChatModel, context: Context, importedArchiveUri: Uri, progressIndicator: MutableState<Boolean>) {
+private fun importArchive(
+  m: ChatModel,
+  context: Context,
+  importedArchiveUri: Uri,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  progressIndicator: MutableState<Boolean>
+) {
   progressIndicator.value = true
   val archivePath = saveArchiveFromUri(context, importedArchiveUri)
   if (archivePath != null) {
@@ -377,6 +592,8 @@ private fun importArchive(m: ChatModel, context: Context, importedArchiveUri: Ur
         try {
           val config = ArchiveConfig(archivePath, parentTempDirectory = context.cacheDir.toString())
           m.controller.apiImportArchive(config)
+          DatabaseUtils.removeDatabaseKey()
+          appFilesCountAndSize.value = directoryFileCountAndSize(getAppFilesDirectory(context))
           operationEnded(m, progressIndicator) {
             AlertManager.shared.showAlertMsg(generalGetString(R.string.chat_database_imported), generalGetString(R.string.restart_the_app_to_use_imported_chat_database))
           }
@@ -403,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")
@@ -429,6 +646,9 @@ private fun deleteChat(m: ChatModel, progressIndicator: MutableState<Boolean>) {
   withApi {
     try {
       m.controller.apiDeleteStorage()
+      m.chatDbDeleted.value = true
+      DatabaseUtils.removeDatabaseKey()
+      m.controller.appPrefs.storeDBPassphrase.set(true)
       operationEnded(m, progressIndicator) {
         AlertManager.shared.showAlertMsg(generalGetString(R.string.chat_database_deleted), generalGetString(R.string.restart_the_app_to_create_a_new_chat_profile))
       }
@@ -440,6 +660,63 @@ private fun deleteChat(m: ChatModel, progressIndicator: MutableState<Boolean>) {
   }
 }
 
+private fun setCiTTL(
+  m: ChatModel,
+  chatItemTTL: MutableState<ChatItemTTL>,
+  progressIndicator: MutableState<Boolean>,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  context: Context
+) {
+  Log.d(TAG, "DatabaseView setChatItemTTL ${chatItemTTL.value.seconds ?: -1}")
+  progressIndicator.value = true
+  withApi {
+    try {
+      m.controller.setChatItemTTL(chatItemTTL.value)
+      // Update model on success
+      m.chatItemTTL.value = chatItemTTL.value
+      afterSetCiTTL(m, progressIndicator, appFilesCountAndSize, context)
+    } catch (e: Exception) {
+      // Rollback to model's value
+      chatItemTTL.value = m.chatItemTTL.value
+      afterSetCiTTL(m, progressIndicator, appFilesCountAndSize, context)
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.error_changing_message_deletion), e.stackTraceToString())
+    }
+  }
+}
+
+private fun afterSetCiTTL(
+  m: ChatModel,
+  progressIndicator: MutableState<Boolean>,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  context: Context
+) {
+  progressIndicator.value = false
+  appFilesCountAndSize.value = directoryFileCountAndSize(getAppFilesDirectory(context))
+  withApi {
+    try {
+      val chats = m.controller.apiGetChats()
+      m.updateChats(chats)
+    } catch (e: Exception) {
+      Log.e(TAG, "apiGetChats error: ${e.message}")
+    }
+  }
+}
+
+private fun deleteFilesAndMediaAlert(context: Context, appFilesCountAndSize: MutableState<Pair<Int, Long>>) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.delete_files_and_media_question),
+    text = generalGetString(R.string.delete_files_and_media_desc),
+    confirmText = generalGetString(R.string.delete_verb),
+    onConfirm = { deleteFiles(appFilesCountAndSize, context) },
+    destructive = true
+  )
+}
+
+private fun deleteFiles(appFilesCountAndSize: MutableState<Pair<Int, Long>>, context: Context) {
+  deleteAppFiles(context)
+  appFilesCountAndSize.value = directoryFileCountAndSize(getAppFilesDirectory(context))
+}
+
 private fun operationEnded(m: ChatModel, progressIndicator: MutableState<Boolean>, alert: () -> Unit) {
   m.chatDbChanged.value = true
   progressIndicator.value = false
@@ -459,15 +736,26 @@ fun PreviewDatabaseLayout() {
       progressIndicator = false,
       runChat = true,
       chatDbChanged = false,
+      useKeyChain = false,
+      chatDbEncrypted = false,
+      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 = {},
       deleteChatAlert = {},
-      showSettingsModal = { {} }
+      deleteAppFilesAndMedia = {},
+      showSettingsModal = { {} },
+      onChatItemTTLSelected = {},
     )
   }
 }

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

@@ -1,25 +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.Composable
-import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.*
+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(
@@ -38,28 +44,60 @@ 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,
     confirmText: String = generalGetString(R.string.ok),
     onConfirm: (() -> Unit)? = null,
     dismissText: String = generalGetString(R.string.cancel_verb),
-    onDismiss: (() -> Unit)? = null
+    onDismiss: (() -> Unit)? = null,
+    onDismissRequest: (() -> Unit)? = null,
+    destructive: Boolean = false
   ) {
     val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
     showAlert {
       AlertDialog(
-        onDismissRequest = this::hideAlert,
+        onDismissRequest = { onDismissRequest?.invoke(); hideAlert() },
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onConfirm?.invoke()
             hideAlert()
-          }) { Text(confirmText) }
+          }) { Text(confirmText, color = if (destructive) MaterialTheme.colors.error else Color.Unspecified) }
         },
         dismissButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onDismiss?.invoke()
             hideAlert()
           }) { Text(dismissText) }
@@ -68,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
@@ -79,7 +152,7 @@ class AlertManager {
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onConfirm?.invoke()
             hideAlert()
           }) { Text(confirmText) }
@@ -88,12 +161,19 @@ class AlertManager {
     }
   }
 
+  fun showAlertMsg(
+    title: Int,
+    text: Int? = null,
+    confirmText: Int = R.string.ok,
+    onConfirm: (() -> Unit)? = null
+  ) = showAlertMsg(generalGetString(title), if (text != null) generalGetString(text) else null, generalGetString(confirmText), onConfirm)
+
   @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

@@ -0,0 +1,9 @@
+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/ChatInfoImage.kt

@@ -6,8 +6,7 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.Icon
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.AccountCircle
-import androidx.compose.material.icons.filled.SupervisedUserCircle
+import androidx.compose.material.icons.filled.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -31,6 +30,17 @@ fun ChatInfoImage(chatInfo: ChatInfo, size: Dp, iconColor: Color = MaterialTheme
   ProfileImage(size, chatInfo.image, icon, iconColor)
 }
 
+@Composable
+fun IncognitoImage(size: Dp, iconColor: Color = MaterialTheme.colors.secondary) {
+  Box(Modifier.size(size)) {
+    Icon(
+      Icons.Filled.TheaterComedy, stringResource(R.string.incognito),
+      modifier = Modifier.size(size).padding(size / 12),
+      iconColor
+    )
+  }
+}
+
 @Composable
 fun ProfileImage(
   size: Dp,

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

@@ -3,37 +3,57 @@ package chat.simplex.app.views.helpers
 import android.content.res.Configuration
 import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Close
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
+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.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 
 @Composable
-fun CloseSheetBar(close: () -> Unit) {
-  Row (
+fun CloseSheetBar(close: () -> Unit, endButtons: @Composable RowScope.() -> Unit = {}) {
+  Column(
     Modifier
       .fillMaxWidth()
-      .height(60.dp),
-    horizontalArrangement = Arrangement.End,
-    verticalAlignment = Alignment.CenterVertically
+      .heightIn(min = AppBarHeight)
+      .padding(horizontal = AppBarHorizontalPadding),
   ) {
-    IconButton(onClick = close) {
-      Icon(
-        Icons.Outlined.Close,
-        stringResource(R.string.icon_descr_close_button),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
+    Row(
+      Modifier
+        .padding(top = 4.dp), // Like in DefaultAppBar
+      content = {
+        Row(
+          Modifier.fillMaxWidth().height(TextFieldDefaults.MinHeight),
+          horizontalArrangement = Arrangement.SpaceBetween,
+          verticalAlignment = Alignment.CenterVertically
+        ) {
+          NavigationButtonBack(close)
+          Row {
+            endButtons()
+          }
+        }
+      }
+    )
   }
 }
 
+@Composable
+fun AppBarTitle(title: String, withPadding: Boolean = true) {
+  val padding = if (withPadding)
+    PaddingValues(start = DEFAULT_PADDING, end = DEFAULT_PADDING, bottom = DEFAULT_PADDING)
+  else
+    PaddingValues(bottom = DEFAULT_PADDING)
+  Text(
+    title,
+    Modifier
+      .fillMaxWidth()
+      .padding(padding),
+    overflow = TextOverflow.Ellipsis,
+    style = MaterialTheme.typography.h1
+  )
+}
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,

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

@@ -0,0 +1,12 @@
+package chat.simplex.app.views.helpers
+
+interface ValueTitle <T> {
+  val value: T
+  val title: String
+}
+
+data class ValueTitleDesc <T> (
+  override val value: T,
+  override val title: String,
+  val description: String
+): ValueTitle<T>

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

@@ -0,0 +1,104 @@
+package chat.simplex.app.views.helpers
+
+import android.util.Log
+import chat.simplex.app.*
+import chat.simplex.app.model.AppPreferences
+import chat.simplex.app.views.usersettings.Cryptor
+import kotlinx.serialization.*
+import java.io.File
+import java.security.SecureRandom
+
+object DatabaseUtils {
+  private val cryptor = Cryptor()
+
+  private val appPreferences: AppPreferences by lazy {
+    AppPreferences(SimplexApp.context)
+  }
+
+  private const val DATABASE_PASSWORD_ALIAS: String = "databasePassword"
+
+  private fun hasDatabase(rootDir: String): Boolean =
+    File(rootDir + File.separator + "files_chat.db").exists() && File(rootDir + File.separator + "files_agent.db").exists()
+
+  fun getDatabaseKey(): String? {
+    return cryptor.decryptData(
+      appPreferences.encryptedDBPassphrase.get()?.toByteArrayFromBase64() ?: return null,
+      appPreferences.initializationVectorDBPassphrase.get()?.toByteArrayFromBase64() ?: return null,
+      DATABASE_PASSWORD_ALIAS,
+    )
+  }
+
+  fun setDatabaseKey(key: String) {
+    val data = cryptor.encryptText(key, DATABASE_PASSWORD_ALIAS)
+    appPreferences.encryptedDBPassphrase.set(data.first.toBase64String())
+    appPreferences.initializationVectorDBPassphrase.set(data.second.toBase64String())
+  }
+
+  fun removeDatabaseKey() {
+    cryptor.deleteKey(DATABASE_PASSWORD_ALIAS)
+    appPreferences.encryptedDBPassphrase.set(null)
+    appPreferences.initializationVectorDBPassphrase.set(null)
+  }
+
+  fun useDatabaseKey(): String {
+    Log.d(TAG, "useDatabaseKey ${appPreferences.storeDBPassphrase.get()}")
+    var dbKey = ""
+    val useKeychain = appPreferences.storeDBPassphrase.get()
+    if (useKeychain) {
+      if (!hasDatabase(SimplexApp.context.dataDir.absolutePath)) {
+        dbKey = randomDatabasePassword()
+        setDatabaseKey(dbKey)
+        appPreferences.initialRandomDBPassphrase.set(true)
+      } else {
+        dbKey = getDatabaseKey() ?: ""
+      }
+    }
+    return dbKey
+  }
+
+  private fun randomDatabasePassword(): String {
+    val s = ByteArray(32)
+    SecureRandom().nextBytes(s)
+    return s.toBase64String().replace("\n", "")
+  }
+}
+
+@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("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/DefaultBasicTextField.kt

@@ -0,0 +1,112 @@
+package chat.simplex.app.views.helpers
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.shape.ZeroCornerSize
+import androidx.compose.foundation.text.*
+import androidx.compose.material.*
+import androidx.compose.material.TextFieldDefaults.indicatorLine
+import androidx.compose.runtime.*
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.*
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.text.TextRange
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.*
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlinx.coroutines.delay
+
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+fun DefaultBasicTextField(
+  modifier: Modifier,
+  initialValue: String,
+  placeholder: (@Composable () -> Unit)? = null,
+  leadingIcon: (@Composable () -> Unit)? = null,
+  focus: Boolean = false,
+  color: Color = MaterialTheme.colors.onBackground,
+  textStyle: TextStyle = TextStyle.Default,
+  selectTextOnFocus: Boolean = false,
+  keyboardOptions: KeyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+  keyboardActions: KeyboardActions = KeyboardActions(),
+  onValueChange: (String) -> Unit,
+) {
+  val state = remember {
+    mutableStateOf(TextFieldValue(initialValue))
+  }
+  val focusRequester = remember { FocusRequester() }
+  val keyboard = LocalSoftwareKeyboardController.current
+
+  LaunchedEffect(Unit) {
+    if (!focus) return@LaunchedEffect
+    delay(300)
+    focusRequester.requestFocus()
+    keyboard?.show()
+  }
+  val enabled = true
+  val colors = TextFieldDefaults.textFieldColors(
+    backgroundColor = Color.Unspecified,
+    textColor = MaterialTheme.colors.onBackground,
+    focusedIndicatorColor = Color.Unspecified,
+    unfocusedIndicatorColor = Color.Unspecified,
+  )
+  val shape = MaterialTheme.shapes.small.copy(bottomEnd = ZeroCornerSize, bottomStart = ZeroCornerSize)
+  val interactionSource = remember { MutableInteractionSource() }
+  BasicTextField(
+    value = state.value,
+    modifier = modifier
+      .background(colors.backgroundColor(enabled).value, shape)
+      .indicatorLine(enabled, false, interactionSource, colors)
+      .focusRequester(focusRequester)
+      .onFocusChanged { focusState ->
+        if (focusState.isFocused && selectTextOnFocus) {
+          val text = state.value.text
+          state.value = state.value.copy(
+            selection = TextRange(0, text.length)
+          )
+        }
+      }
+      .defaultMinSize(
+        minWidth = TextFieldDefaults.MinWidth,
+        minHeight = TextFieldDefaults.MinHeight
+      ),
+    onValueChange = {
+      state.value = it
+      onValueChange(it.text)
+    },
+    cursorBrush = SolidColor(colors.cursorColor(false).value),
+    visualTransformation = VisualTransformation.None,
+    keyboardOptions = keyboardOptions,
+    keyboardActions = KeyboardActions(onDone = {
+      keyboard?.hide()
+      keyboardActions.onDone?.invoke(this)
+    }),
+    singleLine = true,
+    textStyle = textStyle.copy(
+      color = color,
+      fontWeight = FontWeight.Normal,
+      fontSize = 16.sp
+    ),
+    interactionSource = interactionSource,
+    decorationBox = @Composable { innerTextField ->
+      TextFieldDefaults.TextFieldDecorationBox(
+        value = state.value.text,
+        innerTextField = innerTextField,
+        placeholder = placeholder,
+        singleLine = true,
+        enabled = enabled,
+        leadingIcon = leadingIcon,
+        interactionSource = interactionSource,
+        contentPadding = TextFieldDefaults.textFieldWithLabelPadding(start = 0.dp, end = 0.dp),
+        visualTransformation = VisualTransformation.None,
+        colors = colors
+      )
+    }
+  )
+}

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

@@ -0,0 +1,130 @@
+package chat.simplex.app.views.helpers
+
+import chat.simplex.app.R
+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.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.ui.theme.*
+
+@Composable
+fun DefaultTopAppBar(
+  navigationButton: @Composable RowScope.() -> Unit,
+  title: (@Composable () -> Unit)?,
+  onTitleClick: (() -> Unit)? = null,
+  showSearch: Boolean,
+  onSearchValueChanged: (String) -> Unit,
+  buttons: List<@Composable RowScope.() -> Unit> = emptyList(),
+) {
+  // If I just disable clickable modifier when don't need it, it will stop passing clicks to search. Replacing the whole modifier
+  val modifier = if (!showSearch) {
+    Modifier.clickable(enabled = onTitleClick != null, onClick = onTitleClick ?: { })
+  } else Modifier
+
+  TopAppBar(
+    modifier = modifier,
+    title = {
+      if (!showSearch) {
+        title?.invoke()
+      } else {
+        SearchTextField(Modifier.fillMaxWidth(), stringResource(android.R.string.search_go), alwaysVisible = false, onSearchValueChanged)
+      }
+    },
+    backgroundColor = if (isInDarkTheme()) ToolbarDark else ToolbarLight,
+    navigationIcon = navigationButton,
+    buttons = if (!showSearch) buttons else emptyList(),
+    centered = !showSearch,
+  )
+}
+
+@Composable
+fun NavigationButtonBack(onButtonClicked: () -> Unit) {
+  IconButton(onButtonClicked) {
+    Icon(
+      Icons.Outlined.ArrowBackIos, stringResource(R.string.back), tint = MaterialTheme.colors.primary
+    )
+  }
+}
+
+@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) {
+    Icon(
+      Icons.Outlined.Menu,
+      stringResource(R.string.icon_descr_settings),
+      tint = MaterialTheme.colors.primary,
+    )
+  }
+}
+
+@Composable
+private fun TopAppBar(
+  title: @Composable () -> Unit,
+  modifier: Modifier = Modifier,
+  navigationIcon: @Composable (RowScope.() -> Unit)? = null,
+  buttons: List<@Composable RowScope.() -> Unit> = emptyList(),
+  backgroundColor: Color = MaterialTheme.colors.primarySurface,
+  centered: Boolean,
+) {
+  Box(
+    modifier
+      .fillMaxWidth()
+      .height(AppBarHeight)
+      .background(backgroundColor)
+      .padding(horizontal = 4.dp),
+    contentAlignment = Alignment.CenterStart,
+  ) {
+    if (navigationIcon != null) {
+      Row(
+        Modifier
+          .fillMaxHeight()
+          .width(TitleInsetWithIcon - AppBarHorizontalPadding),
+        verticalAlignment = Alignment.CenterVertically,
+        content = navigationIcon
+      )
+    }
+    Row(
+      Modifier
+        .fillMaxHeight()
+        .fillMaxWidth(),
+      horizontalArrangement = Arrangement.End,
+      verticalAlignment = Alignment.CenterVertically,
+    ) {
+      buttons.forEach { it() }
+    }
+    val startPadding = if (navigationIcon != null) TitleInsetWithIcon else TitleInsetWithoutIcon
+    val endPadding = (buttons.size * 50f).dp
+    Box(
+      Modifier
+        .fillMaxWidth()
+        .padding(
+          start = if (centered) kotlin.math.max(startPadding.value, endPadding.value).dp else startPadding,
+          end = if (centered) kotlin.math.max(startPadding.value, endPadding.value).dp else endPadding
+        ),
+      contentAlignment = Alignment.Center
+    ) {
+      title()
+    }
+  }
+}
+
+val AppBarHeight = 56.dp
+val AppBarHorizontalPadding = 4.dp
+private val TitleInsetWithoutIcon = DEFAULT_PADDING - AppBarHorizontalPadding
+val TitleInsetWithIcon = 72.dp

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

@@ -0,0 +1,52 @@
+@file:UseSerializers(UriSerializer::class)
+package chat.simplex.app.views.helpers
+
+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()
+  data class Images(val text: String, val uris: List<Uri>): SharedContent()
+  data class File(val text: String, val uri: Uri): SharedContent()
+}
+
+enum class AnimatedViewState {
+  VISIBLE, HIDING, GONE;
+  fun isVisible(): Boolean {
+    return this == VISIBLE
+  }
+  fun isHiding(): Boolean {
+    return this == HIDING
+  }
+  fun isGone(): Boolean {
+    return this == GONE
+  }
+  companion object {
+    fun saver(): Saver<MutableStateFlow<AnimatedViewState>, *> = Saver(
+      save = { it.value.toString() },
+      restore = {
+        MutableStateFlow(valueOf(it))
+      }
+    )
+  }
+}
+
+
+@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

@@ -0,0 +1,98 @@
+package chat.simplex.app.views.helpers
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.ExpandLess
+import androidx.compose.material.icons.outlined.ExpandMore
+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.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
+fun <T> ExposedDropDownSettingRow(
+  title: String,
+  values: List<Pair<T, String>>,
+  selection: State<T>,
+  label: String? = null,
+  icon: ImageVector? = null,
+  iconTint: Color = HighOrLowlight,
+  enabled: State<Boolean> = mutableStateOf(true),
+  onSelected: (T) -> Unit
+) {
+  Row(
+    Modifier.fillMaxWidth().padding(vertical = 10.dp),
+    verticalAlignment = Alignment.CenterVertically,
+  ) {
+    var expanded by remember { mutableStateOf(false) }
+
+    if (icon != null) {
+      Icon(
+        icon,
+        "",
+        Modifier.padding(end = 8.dp),
+        tint = iconTint
+      )
+    }
+    Text(title, Modifier.weight(1f), color = if (enabled.value) Color.Unspecified else HighOrLowlight)
+
+    ExposedDropdownMenuBox(
+      expanded = expanded,
+      onExpandedChange = {
+        expanded = !expanded && enabled.value
+      }
+    ) {
+      Row(
+        Modifier.padding(start = 10.dp),
+        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
+        )
+        Spacer(Modifier.size(12.dp))
+        Icon(
+          if (!expanded) Icons.Outlined.ExpandMore else Icons.Outlined.ExpandLess,
+          generalGetString(R.string.icon_descr_more_button),
+          tint = HighOrLowlight
+        )
+      }
+      ExposedDropdownMenu(
+        modifier = Modifier.widthIn(min = 200.dp),
+        expanded = expanded,
+        onDismissRequest = {
+          expanded = false
+        }
+      ) {
+        values.forEach { selectionOption ->
+          DropdownMenuItem(
+            onClick = {
+              onSelected(selectionOption.first)
+              expanded = false
+            }
+          ) {
+            Text(
+              selectionOption.second + (if (label != null) " $label" else ""),
+              maxLines = 1,
+              overflow = TextOverflow.Ellipsis,
+            )
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -16,34 +16,31 @@
 
 package chat.simplex.app.views.helpers
 
-import androidx.compose.foundation.gestures.forEachGesture
+import android.util.Log
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.gestures.*
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.interaction.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.input.pointer.AwaitPointerEventScope
-import androidx.compose.ui.input.pointer.PointerEventTimeoutCancellationException
-import androidx.compose.ui.input.pointer.PointerEvent
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.PointerInputChange
-import androidx.compose.ui.input.pointer.PointerInputScope
-import androidx.compose.ui.input.pointer.changedToDown
-import androidx.compose.ui.input.pointer.changedToDownIgnoreConsumed
-import androidx.compose.ui.input.pointer.changedToUp
-import androidx.compose.ui.input.pointer.consumeAllChanges
-import androidx.compose.ui.input.pointer.consumeDownChange
-import androidx.compose.ui.input.pointer.isOutOfBounds
-import androidx.compose.ui.input.pointer.positionChangeConsumed
+import androidx.compose.ui.input.pointer.*
+import androidx.compose.ui.platform.LocalViewConfiguration
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.util.fastAll
 import androidx.compose.ui.util.fastAny
 import androidx.compose.ui.util.fastForEach
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.launch
+import chat.simplex.app.TAG
+import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex
+import kotlin.math.PI
+import kotlin.math.abs
 
 /**
  * See original code here: [androidx.compose.foundation.gestures.detectTapGestures]
  * */
-
-interface PressGestureScope : Density {
+interface PressGestureScope: Density {
   suspend fun tryAwaitRelease(): Boolean
 }
 
@@ -67,7 +64,6 @@ suspend fun PointerInputScope.detectGesture(
       if (onPress !== NoPressGesture) launch {
         pressScope.onPress(down.position)
       }
-
       val longPressTimeout = onLongPress?.let {
         viewConfiguration.longPressTimeoutMillis
       } ?: (Long.MAX_VALUE / 2)
@@ -81,12 +77,7 @@ suspend fun PointerInputScope.detectGesture(
         } else {
           if (shouldConsume)
             upOrCancel.consumeDownChange()
-
-          // If onLongPress event is needed, cancel short press event
-          if (onLongPress != null)
-            pressScope.cancel()
-          else
-            pressScope.release()
+          pressScope.release()
         }
       } catch (_: PointerEventTimeoutCancellationException) {
         onLongPress?.invoke(down.position)
@@ -138,7 +129,6 @@ suspend fun AwaitPointerEventScope.waitForUpOrCancellation(): PointerInputChange
     ) {
       return null
     }
-
     val consumeCheck = awaitPointerEvent(PointerEventPass.Final)
     if (consumeCheck.changes.fastAny { it.positionChangeConsumed() }) {
       return null
@@ -148,7 +138,7 @@ suspend fun AwaitPointerEventScope.waitForUpOrCancellation(): PointerInputChange
 
 private class PressGestureScopeImpl(
   density: Density
-) : PressGestureScope, Density by density {
+): PressGestureScope, Density by density {
   private var isReleased = false
   private var isCanceled = false
   private val mutex = Mutex(locked = false)
@@ -173,6 +163,133 @@ private class PressGestureScopeImpl(
     if (!isReleased && !isCanceled) {
       mutex.lock()
     }
-    return isCanceled
+    return isReleased && !isCanceled
+  }
+}
+
+/**
+ * Captures click events and calls [onLongClick] or [onClick] when such even happens. Otherwise, does nothing.
+ * Apply [MutableInteractionSource] to any element that allows to pass it in (for example, in [Modifier.clickable]).
+ * Works in situations when using [Modifier.combinedClickable] doesn't work because external element overrides [Modifier.clickable]
+ * */
+@Composable
+fun interactionSourceWithDetection(onClick: () -> Unit, onLongClick: () -> Unit): MutableInteractionSource {
+  val interactionSource = remember { MutableInteractionSource() }
+  val longPressTimeoutMillis = LocalViewConfiguration.current.longPressTimeoutMillis
+  var topLevelInteraction: Interaction? by remember { mutableStateOf(null) }
+  LaunchedEffect(interactionSource) {
+    interactionSource.interactions.collect { interaction ->
+      topLevelInteraction = interaction
+    }
+  }
+  LaunchedEffect(topLevelInteraction is PressInteraction.Press) {
+    if (topLevelInteraction !is PressInteraction.Press) return@LaunchedEffect
+    try {
+      withTimeout(longPressTimeoutMillis) {
+        while (isActive) {
+          delay(10)
+          when (topLevelInteraction) {
+            is PressInteraction.Press -> {}
+            is PressInteraction.Release -> {
+              onClick(); break
+            }
+            is PressInteraction.Cancel -> break
+          }
+        }
+      }
+    } catch (_: TimeoutCancellationException) {
+      // Long click happened
+      onLongClick()
+    } catch (ex: CancellationException) {
+      // Canceled coroutine + PressInteraction.Release == short click
+      if (topLevelInteraction is PressInteraction.Release)
+        onClick()
+      Log.e(TAG, ex.stackTraceToString())
+    } catch (ex: Exception) {
+      // Should never be called
+      Log.e(TAG, ex.stackTraceToString())
+    }
+  }
+  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,
+  onGesture: (centroid: Offset, pan: Offset, zoom: Float, rotation: Float) -> Unit
+) {
+  var zoom = 1f
+  forEachGesture {
+    awaitPointerEventScope {
+      var rotation = 0f
+      var pan = Offset.Zero
+      var pastTouchSlop = false
+      val touchSlop = viewConfiguration.touchSlop
+      var lockedToPanZoom = false
+
+      awaitFirstDown(requireUnconsumed = false)
+      do {
+        val event = awaitPointerEvent()
+        val canceled = event.changes.fastAny { it.isConsumed }
+        if (!canceled) {
+          val zoomChange = event.calculateZoom()
+          val rotationChange = event.calculateRotation()
+          val panChange = event.calculatePan()
+
+          if (!pastTouchSlop) {
+            zoom *= zoomChange
+            rotation += rotationChange
+            pan += panChange
+
+            val centroidSize = event.calculateCentroidSize(useCurrent = false)
+            val zoomMotion = abs(1 - zoom) * centroidSize
+            val rotationMotion = abs(rotation * PI.toFloat() * centroidSize / 180f)
+            val panMotion = pan.getDistance()
+
+            if (zoomMotion > touchSlop ||
+              rotationMotion > touchSlop ||
+              panMotion > touchSlop
+            ) {
+              pastTouchSlop = true
+              lockedToPanZoom = panZoomLock && rotationMotion < touchSlop
+            }
+          }
+
+          if (pastTouchSlop) {
+            val centroid = event.calculateCentroid(useCurrent = false)
+            val effectiveRotation = if (lockedToPanZoom) 0f else rotationChange
+            if (effectiveRotation != 0f ||
+              zoomChange != 1f ||
+              panChange != Offset.Zero
+            ) {
+              onGesture(centroid, panChange, zoomChange, effectiveRotation)
+            }
+            event.changes.fastForEach {
+              if (it.positionChanged() && zoom != 1f && allowIntercept()) {
+                it.consume()
+              }
+            }
+          }
+        }
+      } while (!canceled && event.changes.fastAny { it.pressed })
+    }
   }
 }

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
@@ -65,26 +69,28 @@ fun resizeImageToStrSize(image: Bitmap, maxDataSize: Long): String {
 }
 
 private fun compressImageStr(bitmap: Bitmap): String {
-  return "data:image/jpg;base64," + Base64.encodeToString(compressImageData(bitmap).toByteArray(), Base64.NO_WRAP)
+  val usePng = bitmap.hasAlpha()
+  val ext = if (usePng) "png" else "jpg"
+  return "data:image/$ext;base64," + Base64.encodeToString(compressImageData(bitmap, usePng).toByteArray(), Base64.NO_WRAP)
 }
 
-fun resizeImageToDataSize(image: Bitmap, maxDataSize: Long): ByteArrayOutputStream {
+fun resizeImageToDataSize(image: Bitmap, usePng: Boolean, maxDataSize: Long): ByteArrayOutputStream {
   var img = image
-  var stream = compressImageData(img)
+  var stream = compressImageData(img, usePng)
   while (stream.size() > maxDataSize) {
     val ratio = sqrt(stream.size().toDouble() / maxDataSize.toDouble())
     val clippedRatio = min(ratio, 2.0)
     val width = (img.width.toDouble() / clippedRatio).toInt()
     val height = img.height * width / img.width
     img = Bitmap.createScaledBitmap(img, width, height, true)
-    stream = compressImageData(img)
+    stream = compressImageData(img, usePng)
   }
   return stream
 }
 
-private fun compressImageData(bitmap: Bitmap): ByteArrayOutputStream {
+private fun compressImageData(bitmap: Bitmap, usePng: Boolean): ByteArrayOutputStream {
   val stream = ByteArrayOutputStream()
-  bitmap.compress(Bitmap.CompressFormat.JPEG, 85, stream)
+  bitmap.compress(if (!usePng) Bitmap.CompressFormat.JPEG else Bitmap.CompressFormat.PNG, 85, stream)
   return stream
 }
 
@@ -104,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)
@@ -121,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 {
@@ -146,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> =
@@ -157,30 +172,51 @@ fun rememberPermissionLauncher(cb: (Boolean) -> Unit): ManagedActivityResultLaun
 fun rememberGetContentLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
   rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent(), cb)
 
+@Composable
+fun rememberGetMultipleContentsLauncher(cb: (List<Uri>) -> Unit): ManagedActivityResultLauncher<String, List<Uri>> =
+  rememberLauncherForActivityResult(contract = 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()
@@ -204,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 -> {
@@ -213,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/LinkPreviews.kt

@@ -26,29 +26,44 @@ import chat.simplex.app.views.chat.item.SentColorLight
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import org.jsoup.Jsoup
+import java.net.URL
 
 private const val OG_SELECT_QUERY = "meta[property^=og:]"
+private const val ICON_SELECT_QUERY = "link[rel^=icon],link[rel^=apple-touch-icon],link[rel^=shortcut icon]"
+private val IMAGE_SUFFIXES = listOf(".jpg", ".png", ".ico", ".webp", ".gif")
 
 suspend fun getLinkPreview(url: String): LinkPreview? {
   return withContext(Dispatchers.IO) {
     try {
-      val response = Jsoup.connect(url)
-        .ignoreContentType(true)
-        .timeout(10000)
-        .followRedirects(true)
-        .execute()
-      val doc = response.parse()
-      val ogTags = doc.select(OG_SELECT_QUERY)
-      val imageUri = ogTags.firstOrNull { it.attr("property") == "og:image" }?.attr("content")
+      val title: String?
+      val u = kotlin.runCatching { URL(url) }.getOrNull() ?: return@withContext null
+      var imageUri = when {
+        IMAGE_SUFFIXES.any { u.path.lowercase().endsWith(it) } -> {
+          title = u.path.substringAfterLast("/")
+          url
+        }
+        else -> {
+          val response = Jsoup.connect(url)
+            .ignoreContentType(true)
+            .timeout(10000)
+            .followRedirects(true)
+            .execute()
+          val doc = response.parse()
+          val ogTags = doc.select(OG_SELECT_QUERY)
+          title = ogTags.firstOrNull { it.attr("property") == "og:title" }?.attr("content") ?: doc.title()
+          ogTags.firstOrNull { it.attr("property") == "og:image" }?.attr("content")
+            ?: doc.select(ICON_SELECT_QUERY).firstOrNull { it.attr("rel").contains("icon") }?.attr("href")
+        }
+      }
       if (imageUri != null) {
+        imageUri = normalizeImageUri(u, imageUri)
         try {
-          val stream = java.net.URL(imageUri).openStream()
+          val stream = URL(imageUri).openStream()
           val image = resizeImageToStrSize(BitmapFactory.decodeStream(stream), maxDataSize = 14000)
 //          TODO add once supported in iOS
 //          val description = ogTags.firstOrNull {
 //            it.attr("property") == "og:description"
 //          }?.attr("content") ?: ""
-          val title = ogTags.firstOrNull { it.attr("property") == "og:title" }?.attr("content")
           if (title != null) {
             return@withContext LinkPreview(url, title, description = "", image)
           }
@@ -63,8 +78,6 @@ suspend fun getLinkPreview(url: String): LinkPreview? {
   }
 }
 
-
-
 @Composable
 fun ComposeLinkView(linkPreview: LinkPreview?, cancelPreview: () -> Unit) {
   Row(
@@ -127,6 +140,37 @@ fun ChatItemLinkView(linkPreview: LinkPreview) {
   }
 }
 
+private fun normalizeImageUri(u: URL, imageUri: String) = when {
+  !imageUri.lowercase().startsWith("http") -> {
+    "${u.protocol}://${u.host}" +
+        if (imageUri.startsWith("/"))
+          imageUri
+        else
+        // When an icon is used as an image with relative href path like: site=site.com, <link rel="icon" href="icon.png">
+          if (u.path.endsWith("/")) u.path + imageUri
+          else u.path.substringBeforeLast("/") + "/$imageUri"
+  }
+  else -> imageUri
+}
+
+/*fun normalizeImageUriTest() {
+  val expect = mapOf<Pair<URL, String>, String>(
+    URL("https://example.com") to "icon.png" to "https://example.com/icon.png",
+    URL("https://example.com/") to "icon.png" to "https://example.com/icon.png",
+    URL("https://example.com/") to "/icon.png" to "https://example.com/icon.png",
+    URL("https://example.com") to "assets/images/favicon.png" to "https://example.com/assets/images/favicon.png",
+    URL("https://example.com/") to "assets/images/favicon.png" to "https://example.com/assets/images/favicon.png",
+    URL("https://example.com/dir") to "/favicon.png" to "https://example.com/favicon.png",
+    URL("https://example.com/dir/") to "favicon.png" to "https://example.com/dir/favicon.png",
+    URL("https://example.com/dir/") to "/favicon.png" to "https://example.com/favicon.png",
+    URL("https://example.com/dir/page") to "favicon.png" to "https://example.com/dir/favicon.png",
+    URL("https://example.com/abcde.gif") to "https://example.com/abcde.gif" to "https://example.com/abcde.gif",
+    URL("https://example.com/abcde.gif?a=b") to "https://example.com/abcde.gif?a=b" to "https://example.com/abcde.gif?a=b",
+  )
+  expect.forEach {
+    Log.d(TAG, "Image URI ${normalizeImageUri(it.key.first, it.key.second)} == ${normalizeImageUri(it.key.first, it.key.second) == it.value}")
+  }
+}*/
 
 @Preview(showBackground = true)
 @Preview(

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/MessagesFetcherWorker.kt

@@ -0,0 +1,90 @@
+package chat.simplex.app.views.helpers
+
+import android.content.Context
+import android.util.Log
+import androidx.work.*
+import chat.simplex.app.*
+import chat.simplex.app.SimplexService.Companion.showPassphraseNotification
+import kotlinx.coroutines.*
+import java.util.Date
+import java.util.concurrent.TimeUnit
+
+object MessagesFetcherWorker {
+  private const val UNIQUE_WORK_TAG = BuildConfig.APPLICATION_ID + ".UNIQUE_MESSAGES_FETCHER"
+
+  fun scheduleWork(intervalSec: Int = 600, durationSec: Int = 60) {
+    val initialDelaySec = intervalSec.toLong()
+    Log.d(TAG, "Worker: scheduling work to run at ${Date(System.currentTimeMillis() + initialDelaySec * 1000)} for $durationSec sec")
+    val periodicWorkRequest = OneTimeWorkRequest.Builder(MessagesFetcherWork::class.java)
+      .setInitialDelay(initialDelaySec, TimeUnit.SECONDS)
+      .setInputData(
+        Data.Builder()
+          .putInt(MessagesFetcherWork.INPUT_DATA_INTERVAL, intervalSec)
+          .putInt(MessagesFetcherWork.INPUT_DATA_DURATION, durationSec)
+          .build()
+      )
+      .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+      .build()
+
+    WorkManager.getInstance(SimplexApp.context).enqueueUniqueWork(UNIQUE_WORK_TAG, ExistingWorkPolicy.REPLACE, periodicWorkRequest)
+  }
+
+  fun cancelAll() {
+    Log.d(TAG, "Worker: canceled all tasks")
+    WorkManager.getInstance(SimplexApp.context).cancelUniqueWork(UNIQUE_WORK_TAG)
+  }
+}
+
+class MessagesFetcherWork(
+  context: Context,
+  workerParams: WorkerParameters
+): CoroutineWorker(context, workerParams) {
+  companion object {
+    const val INPUT_DATA_INTERVAL = "interval"
+    const val INPUT_DATA_DURATION = "duration"
+    private const val WAIT_AFTER_LAST_MESSAGE: Long = 10_000
+  }
+
+  override suspend fun doWork(): Result {
+    // Skip when Simplex service is currently working
+    if (SimplexService.getServiceState(SimplexApp.context) == SimplexService.ServiceState.STARTED) {
+      reschedule()
+      return Result.success()
+    }
+    val durationSeconds = inputData.getInt(INPUT_DATA_DURATION, 60)
+    var shouldReschedule = true
+    try {
+      withTimeout(durationSeconds * 1000L) {
+        val chatController = (applicationContext as SimplexApp).chatController
+        val chatDbStatus = chatController.chatModel.chatDbStatus.value
+        if (chatDbStatus != DBMigrationResult.OK) {
+          Log.w(TAG, "Worker: problem with the database: $chatDbStatus")
+          showPassphraseNotification(chatDbStatus)
+          shouldReschedule = false
+          return@withTimeout
+        }
+        Log.w(TAG, "Worker: starting work")
+        // Give some time to start receiving messages
+        delay(10_000)
+        while (!isStopped) {
+          if (chatController.lastMsgReceivedTimestamp + WAIT_AFTER_LAST_MESSAGE < System.currentTimeMillis()) {
+            Log.d(TAG, "Worker: work is done")
+            break
+          }
+          delay(5000)
+        }
+      }
+    } catch (_: TimeoutCancellationException) { // When timeout happens
+      Log.d(TAG, "Worker: work is done (took $durationSeconds sec)")
+    } catch (_: CancellationException) { // When user opens the app while the worker is still working
+      Log.d(TAG, "Worker: interrupted")
+    } catch (e: Exception) {
+      Log.d(TAG, "Worker: unexpected exception: ${e.stackTraceToString()}")
+    }
+
+    if (shouldReschedule) reschedule()
+    return Result.success()
+  }
+
+  private fun reschedule() = MessagesFetcherWorker.scheduleWork()
+}

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

@@ -2,63 +2,139 @@ package chat.simplex.app.views.helpers
 
 import android.util.Log
 import androidx.activity.compose.BackHandler
+import androidx.compose.animation.*
+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.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
+import androidx.compose.material.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.dp
 import chat.simplex.app.TAG
+import chat.simplex.app.ui.theme.SettingsBackgroundLight
+import chat.simplex.app.ui.theme.isInDarkTheme
+import java.util.concurrent.atomic.AtomicBoolean
 
 @Composable
 fun ModalView(
   close: () -> Unit,
   background: Color = MaterialTheme.colors.background,
-  modifier: Modifier = Modifier.padding(horizontal = 16.dp),
+  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() }
     }
   }
 }
 
 class ModalManager {
-  private val modalViews = arrayListOf<(@Composable (close: () -> Unit) -> Unit)?>()
+  private val modalViews = arrayListOf<Pair<Boolean, (@Composable (close: () -> Unit) -> Unit)>>()
   private val modalCount = mutableStateOf(0)
+  private val toRemove = mutableSetOf<Int>()
+  private var oldViewChanging = AtomicBoolean(false)
 
-  fun showModal(content: @Composable () -> Unit) {
-    showCustomModal { close -> ModalView(close, content = content) }
+  fun showModal(settings: Boolean = false, endButtons: @Composable RowScope.() -> Unit = {}, content: @Composable () -> Unit) {
+    showCustomModal { close ->
+      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, endButtons = endButtons, content = content)
+    }
   }
 
-  fun showCustomModal(modal: @Composable (close: () -> Unit) -> Unit) {
+  fun showModalCloseable(settings: Boolean = false, content: @Composable (close: () -> Unit) -> Unit) {
+    showCustomModal { close ->
+      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, content = { content(close) })
+    }
+  }
+
+  fun showCustomModal(animated: Boolean = true, modal: @Composable (close: () -> Unit) -> Unit) {
     Log.d(TAG, "ModalManager.showModal")
-    modalViews.add(modal)
-    modalCount.value = modalViews.count()
+    // Means, animation is in progress or not started yet. Do not wait until animation finishes, just remove all from screen.
+    // This is useful when invoking close() and ShowCustomModal one after another without delay. Otherwise, screen will hold prev view
+    if (toRemove.isNotEmpty()) {
+      runAtomically { toRemove.removeIf { elem -> modalViews.removeAt(elem); true } }
+    }
+    modalViews.add(animated to modal)
+    modalCount.value = modalViews.size - toRemove.size
   }
 
+  fun hasModalsOpen() = modalCount.value > 0
+
   fun closeModal() {
     if (modalViews.isNotEmpty()) {
-      modalViews.removeAt(modalViews.count() - 1)
+      if (modalViews.lastOrNull()?.first == false) modalViews.removeAt(modalViews.lastIndex)
+      else runAtomically { toRemove.add(modalViews.lastIndex - toRemove.size) }
     }
-    modalCount.value = modalViews.count()
+    modalCount.value = modalViews.size - toRemove.size
   }
 
   fun closeModals() {
-    while (modalViews.isNotEmpty()) closeModal()
+    while (modalCount.value > 0) closeModal()
   }
 
+  @OptIn(ExperimentalAnimationApi::class)
   @Composable
   fun showInView() {
-    if (modalCount.value > 0) modalViews.lastOrNull()?.invoke(::closeModal)
+    // Without animation
+    if (modalCount.value > 0 && modalViews.lastOrNull()?.first == false) {
+      modalViews.lastOrNull()?.second?.invoke(::closeModal)
+      return
+    }
+    AnimatedContent(targetState = modalCount.value,
+      transitionSpec = {
+        if (targetState > initialState) {
+          fromEndToStartTransition()
+        } else {
+          fromStartToEndTransition()
+        }.using(SizeTransform(clip = false))
+      }
+    ) {
+      modalViews.getOrNull(it - 1)?.second?.invoke(::closeModal)
+      // This is needed because if we delete from modalViews immediately on request, animation will be bad
+      if (toRemove.isNotEmpty() && it == modalCount.value && transition.currentState == EnterExitState.Visible && !transition.isRunning) {
+        runAtomically { toRemove.removeIf { elem -> modalViews.removeAt(elem); true } }
+      }
+    }
   }
 
+  /**
+  * Allows to modify a list without getting [ConcurrentModificationException]
+  * */
+  private fun runAtomically(atomicBoolean: AtomicBoolean = oldViewChanging, block: () -> Unit) {
+    while (!atomicBoolean.compareAndSet(false, true)) {
+      Thread.sleep(10)
+    }
+    block()
+    atomicBoolean.set(false)
+  }
+
+  @OptIn(ExperimentalAnimationApi::class)
+  private fun fromStartToEndTransition() =
+    slideInHorizontally(
+      initialOffsetX = { fullWidth -> -fullWidth },
+      animationSpec = animationSpec()
+    ) with slideOutHorizontally(
+      targetOffsetX = { fullWidth -> fullWidth },
+      animationSpec = animationSpec()
+    )
+
+  @OptIn(ExperimentalAnimationApi::class)
+  private fun fromEndToStartTransition() =
+    slideInHorizontally(
+      initialOffsetX = { fullWidth -> fullWidth },
+      animationSpec = animationSpec()
+    ) with slideOutHorizontally(
+      targetOffsetX = { fullWidth -> -fullWidth },
+      animationSpec = animationSpec()
+    )
+
+private fun <T> animationSpec() = tween<T>(durationMillis = 250, easing = FastOutSlowInEasing)
+//  private fun <T> animationSpecFromStart() = tween<T>(durationMillis = 150, easing = FastOutLinearInEasing)
+//  private fun <T> animationSpecFromEnd() = tween<T>(durationMillis = 100, easing = FastOutSlowInEasing)
+
   companion object {
     val shared = ModalManager()
   }