mobile: suppress fileAlreadyReceiving error (#1441)

* android/iOS: added and fixed german translations for v4.3

* import localization

Co-authored-by: JRoberts <8711996+jr-simplex@users.noreply.github.com>

.github/workflows/build.yml

@@ -5,6 +5,7 @@ on:
     branches:
       - master
       - stable
+      - sqlcipher
     tags:
       - "v*"
   pull_request:
@@ -49,50 +50,75 @@ 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
+            cache_path: ~/.cabal/store
             asset_name: simplex-chat-ubuntu-18_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: Unix prepare cabal.project.local for Ubuntu
+        if: matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-18.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' && matrix.os != 'ubuntu-20.04'
+        timeout-minutes: 10
+        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 +128,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

@@ -43,3 +43,32 @@ stack.yaml.lock
 # Temporary test files
 tests/tmp
 logs/
+
+
+# for website
+website/node_modules/
+website/src/blog/
+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

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

@@ -16,14 +16,16 @@
  
 [<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.
 
+**NEW**: Security audit by [Trail of Bits](https://www.trailofbits.com/about), the [new website](https://simplex.chat) and v4.2 released! [See the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md)
+
 ## Contents
 
 - [Why privacy matters](#why-privacy-matters)
@@ -40,8 +42,10 @@
 - [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)
+- [Join a user group](#join-a-user-group)
+- [Contribute](#contribute)
+- [Help us with donations](#help-us-with-donations)
+- [Disclaimers, Security contact, License](#disclaimers)
 
 ## Why privacy matters
 
@@ -79,18 +83,18 @@ You can use SimpleX with your own servers and still communicate with people usin
 
 ## 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)
+[Nov 08, 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)
+
+[Sep 1, 2022. v3.2: incognito mode, support .onion server hostnames, setting contact names, changing color scheme, etc. Implementation audit is arranged for October!](./blog/20220901-simplex-chat-v3.2-incognito-mode.md)
+
+[Aug 8, 2022. v3.1: secret chat groups, access via Tor, reduced battery and traffic usage, advanced network settings, etc.](./blog/20220808-simplex-chat-v3.1-chat-groups.md)
 
 [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)
 
-[May 11, 2022. v2.0 released - sending images and files in mobile apps](./blog/20220511-simplex-chat-v2-images-files.md)
-
-[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.md)
-
-[Jan 12, 2022. SimpleX v1 released: the only messaging and application platform without user identities](./20220112-simplex-chat-v1-released.md)
-
 [All updates](./blog)
 
 ## Make a private connection
@@ -107,12 +111,6 @@ The channel through which you share the link does not have to be secure - it is
 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 +127,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
 
@@ -139,29 +139,29 @@ 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.
 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.
 
 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. 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).
+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 [JavaScipt 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,40 +178,77 @@ 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.
+- 🏗 SMP queue redundancy and rotation (manual is supported).
+- 🏗 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.
+- Optionally avoid re-using the same TCP session for multiple connections.
+- Access password/pin (with optional alternative access password).
+- Ephemeral/disappearing/OTR conversations with the existing contacts.
+- Media server to optimize sending large files to groups.
+- Video messages.
+- Message delivery confirmation (with sender opt-in or opt-out per contact, TBC).
+- Multiple user profiles in the same chat database.
+- Advanced server configuration.
+- Feeds/broadcasts.
+- Unconfirmed: disappearing messages (with recipient opt-in per-contact).
 - 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.
 
-## Help us pay for 3rd party security audit
+## Join a user group
 
-I will get straight to the point: I ask you to support SimpleX Chat with donations.
+You can join a general group with more than 100 members: [#SimpleX-Group](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2FWHV0YU1sYlU7NqiEHkHDB6gxO1ofTync%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAWbebOqVYuBXaiqHcXYjEHCpYi6VzDlu6CVaijDTmsQU%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22mL-7Divb94GGmGmRBef5Dg%3D%3D%22%7D).
 
-We are prioritizing users privacy and security - it would be impossible without your support we were lucky to have so far.
+You can also join smaller groups by countries/languages: [\#SimpleX-DE](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fhpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg%3D%40smp5.simplex.im%2FmIorjTDPG24jdLKXwutS6o9hdQQRZwfQ%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA9N0BZaECrAw3we3S1Wq4QO7NERBuPt9447immrB50wo%253D%26srv%3Djjbyvoemxysm7qxap7m5d5m35jzv5qq6gnlv7s4rsn7tdwwmuqciwpid.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22S8aISlOgkTMytSox9gAM2Q%3D%3D%22%7D) (German), [\#SimpleX-US](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2FlTWmQplLEaoJyHnEL1-B3f2PtDsikcTs%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA-hMBlsQjNxK2vaVhqW_UyAVtuoYqgYTigK4B9dJ9CGc%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22G0UtRHIn0TmPoo08h_cbTA%3D%3D%22%7D) (US/English), [\#SimpleX-France](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F11r6XyjwVMj0WDIUMbmNDXO996M_EN_1%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAXDmc2Lrj9WQOjEcWa0DeQHF3HcYOp9b68s8M_BJ7gEk%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22EZCeSYpeIBkaQwCcpcF00w%3D%3D%22%7D), [\#SimpleX-RU](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fhpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg%3D%40smp5.simplex.im%2FZSYM278L5WoZiApx3925EAjSXcsAVNVu%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA7RJ2wfT8zdfOLyE5OtWLEAPowj-q6F2HB0ExbATw8Gk%253D%26srv%3Djjbyvoemxysm7qxap7m5d5m35jzv5qq6gnlv7s4rsn7tdwwmuqciwpid.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22fsVoklNGptt7n-droqJYUQ%3D%3D%22%7D) (Russian), [#SimpleX-NL](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FmP0LbswSbfxoVkkxiWE2NYnBCgZ9Snvj%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAVwZuSsw4Mf52EaBNdNI3RebsLm0jg65ZIkcmH9E5uy8%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22M9xIULUNZx51Wsa5Kdb0Sg%3D%3D%22%7D) (Netherlands/Dutch), [#SimpleX-IT](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FaZ_wjh6QAYHB-LjyGtp8bllkzoq880u-%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA-_Wulzc3j16i7t77XJ5wgwxeW8_Ea8GxetMo7K4MgjI%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22QWmXdrFzIeMd2OoEPMFkBQ%3D%3D%22%7D) (Italian).
 
-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.
+You can join these groups either by opening these links in the app or by opening them in a desktop browser and scanning QR code.
+
+Let us know if you'd like to add some other countries to the list.
+
+Join via the app to share what's going on and ask any questions!
+
+## Contribute
+
+We would love to have you join the development! You can contribute to SimpleX Chat with:
+
+- developing features - please connect to us via chat so we can help you get started.
+- writing a tutorial or recipes about hosting servers, chat bot automations, etc.
+- translate UI to some language - we are currently setting up the UI to simplify it, please get in touch and let us know if you would be able to support and update the translations.
+- translate website homepage - there is a lot of content we would like to share, it would help to bring the new users.
+
+## 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.
 
-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.
+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 wallet](monero:8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt): 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+- Monero wallet: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+- Bitcoin wallet: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+- please let us know, via GitHub issue or chat, if you want to create a donation in some other cryptocurrency - we will add the address to the list.
 
 Thank you,
 
@@ -219,11 +256,27 @@ Evgeny
 
 SimpleX Chat founder
 
-## Disclaimer
+## Disclaimers
 
-[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.
+[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.
 
-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.
+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).
+
+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.
+
+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.
+
+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.
+
+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.
+
+Please read more in [Terms & privacy policy](./PRIVACY.md).
+
+## Security contact
+
+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.
+
+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 +290,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

@@ -11,8 +11,8 @@ android {
         applicationId "chat.simplex.app"
         minSdk 29
         targetSdk 32
-        versionCode 48
-        versionName "3.1"
+        versionCode 71
+        versionName "4.3"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         ndk {
@@ -26,9 +26,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 +74,7 @@ android {
         resources {
             excludes += '/META-INF/{AL2.0,LGPL2.1}'
         }
+        jniLibs.useLegacyPackaging = compression_level != "0"
     }
 }
 
@@ -83,6 +94,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 +112,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 +120,80 @@ 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"
+
     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"
 }
+
+def buildType = "unknown"
+// Don't do anything if no compression is needed
+if (compression_level != "0") {
+    tasks.whenTaskAdded { task ->
+        if (task.name == 'packageDebug') {
+            task.doLast {
+                buildType = "debug"
+            }
+            task.finalizedBy compressApk
+        } else if (task.name == 'packageRelease') {
+            task.doLast {
+                buildType = "release"
+            }
+            task.finalizedBy compressApk
+        }
+    }
+}
+
+tasks.register("compressApk") {
+    doLast {
+        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"))
+        }
+
+        // View all gradle properties set
+        // project.properties.each { k, v -> println "$k -> $v" }
+    }
+}

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

@@ -25,7 +25,8 @@
       android:name="SimplexApp"
       android:allowBackup="true"
       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">
 
@@ -34,7 +35,7 @@
         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 +63,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 +90,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">
@@ -98,7 +106,7 @@
 
     <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 +114,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

@@ -24,8 +24,8 @@ var TransformOperation;
 let activeCall;
 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"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
     ];
     function getCallConfig(encodedInsertableStreams, iceServers, relay) {
         return {
@@ -495,6 +495,7 @@ function callCryptoFunction() {
     const initialPlainTextRequired = {
         key: 10,
         delta: 3,
+        empty: 1,
     };
     const IV_LENGTH = 12;
     function encryptFrame(key) {
@@ -505,7 +506,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 +526,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,6 +53,9 @@ add_library( support SHARED IMPORTED )
 set_target_properties( support PROPERTIES IMPORTED_LOCATION
     ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libsupport.so)
 
+add_library( crypto SHARED IMPORTED )
+set_target_properties( crypto PROPERTIES IMPORTED_LOCATION
+    ${CMAKE_SOURCE_DIR}/libs/${ANDROID_ABI}/libcrypto.so)
 
 # Specifies libraries CMake should link to your target library. You
 # can link multiple libraries, such as libraries you define in this
@@ -61,7 +64,7 @@ set_target_properties( support PROPERTIES IMPORTED_LOCATION
 target_link_libraries( # Specifies the target library.
     app-lib
 
-    simplex support
+    simplex support crypto
 
     # Links the target library to the log library
     # included in the NDK.

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

@@ -22,20 +22,34 @@ 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, 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);
 
-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) {
+    const char *_dbPath = (*env)->GetStringUTFChars(env, dbPath, JNI_FALSE);
+    const char *_dbKey = (*env)->GetStringUTFChars(env, dbKey, JNI_FALSE);
+    jlong _ctrl = (jlong) 0;
+    jstring res = (*env)->NewStringUTF(env, chat_migrate_init(_dbPath, _dbKey, &_ctrl));
+    (*env)->ReleaseStringUTFChars(env, dbPath, _dbPath);
+    (*env)->ReleaseStringUTFChars(env, dbKey, _dbKey);
+
+    // 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 +77,11 @@ 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;
+}

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

@@ -4,24 +4,28 @@ import android.app.Application
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
+import android.os.Parcelable
 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.ui.theme.SimpleButton
@@ -30,28 +34,53 @@ 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.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.launch
 
-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)
+    // 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 +99,49 @@ 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 onStart() {
+    super.onStart()
+    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()
+    enteredBackground.value = elapsedRealtime()
+  }
+
+  override fun onBackPressed() {
+    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
     }
   }
 
@@ -108,17 +158,10 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
         this@MainActivity,
         completed = { laResult ->
           when (laResult) {
-            LAResult.Success -> {
+            LAResult.Success ->
               userAuthorized.value = true
-            }
-            is LAResult.Error -> {
+            is LAResult.Error, LAResult.Failed ->
               laFailed.value = true
-              laErrorToast(applicationContext, laResult.errString)
-            }
-            LAResult.Failed -> {
-              laFailed.value = true
-              laFailedToast(applicationContext)
-            }
             LAResult.Unavailable -> {
               userAuthorized.value = true
               m.performLA.value = false
@@ -131,24 +174,6 @@ class MainActivity: FragmentActivity(), LifecycleEventObserver {
     }
   }
 
-  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 +197,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 +224,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
@@ -241,13 +254,20 @@ fun MainPage(
   showLANotice: () -> Unit
 ) {
   // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
-  var chatsAccessAuthorized by remember { mutableStateOf(false) }
+  var chatsAccessAuthorized by rememberSaveable { mutableStateOf(false) }
   LaunchedEffect(userAuthorized.value) {
     if (chatModel.controller.appPrefs.performLA.get()) {
       delay(500L)
     }
     chatsAccessAuthorized = userAuthorized.value == true
   }
+  var showChatDatabaseError by rememberSaveable {
+    mutableStateOf(chatModel.chatDbStatus.value != DBMigrationResult.OK && chatModel.chatDbStatus.value != null)
+  }
+  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 +293,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 +313,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 -> {
         if (chatModel.controller.appPrefs.performLA.get() && laFailed.value) {
-          retryAuthView()
+          authView()
         } else {
           SplashView()
         }
@@ -306,16 +331,69 @@ 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()
+
+                      // Deletes files that were not sent but already stored in files directory.
+                      // Currently, it's voice records only
+                      if (it == null && chatModel.filesToDelete.isNotEmpty()) {
+                        chatModel.filesToDelete.forEach { it.delete() }
+                        chatModel.filesToDelete.clear()
+                      }
+                    }
+                }
+                launch {
+                  snapshotFlow { chatModel.sharedContent.value }
+                    .distinctUntilChanged()
+                    .filter { it != null }
+                    .collect {
+                      chatModel.chatId.value = null
+                      currentChatId = null
+                    }
+                }
+              }
+              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.Step1_SimpleXInfo -> SimpleXInfo(chatModel, onboarding = true)
       onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
     }
     ModalManager.shared.showInView()
@@ -365,29 +443,61 @@ 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)
           }
         }
       )

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

@@ -4,14 +4,18 @@ 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 chat.simplex.app.views.usersettings.NotificationsMode
+import kotlinx.coroutines.*
+import kotlinx.serialization.decodeFromString
 import java.io.BufferedReader
 import java.io.InputStreamReader
 import java.util.*
 import java.util.concurrent.Semaphore
+import java.util.concurrent.TimeUnit
 import kotlin.concurrent.thread
 
 const val TAG = "SIMPLEX"
@@ -23,21 +27,54 @@ external fun pipeStdOutToSocket(socketName: String) : Int
 
 // SimpleX API
 typealias ChatCtrl = Long
-external fun chatInit(path: String): ChatCtrl
+external fun chatMigrateInit(dbPath: String, dbKey: 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
 
 class SimplexApp: Application(), LifecycleEventObserver {
-  val chatController: ChatController by lazy {
-    val ctrl = chatInit(getFilesDirectory(applicationContext))
-    ChatController(ctrl, ntfManager, applicationContext, appPreferences)
+  lateinit var chatController: ChatController
+
+  fun initChatController(useKey: String? = null, startChat: Boolean = true) {
+    val dbKey = useKey ?: DatabaseUtils.useDatabaseKey() ?: ""
+    val dbAbsolutePathPrefix = getFilesDirectory(SimplexApp.context)
+    val migrated: Array<Any> = chatMigrateInit(dbAbsolutePathPrefix, dbKey)
+    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,41 +87,85 @@ 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()
-      }
-    }
   }
 
   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 -> {
+          if (chatModel.chatRunning.value == true) {
+            kotlin.runCatching {
+              val chats = chatController.apiGetChats()
+              chatModel.updateChats(chats)
+            }.onFailure { Log.e(TAG, it.stackTraceToString()) }
+          }
+        }
+        Lifecycle.Event.ON_RESUME -> {
           if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) {
             chatController.showBackgroundServiceNoticeIfNeeded()
           }
+          /**
+           * 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 && appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name)
+            SimplexService.start(applicationContext)
+        }
         else -> {}
       }
     }
   }
 
+  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")

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

@@ -10,8 +10,9 @@ 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) {
@@ -26,6 +27,8 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     const val LockScreenCallChannel: String = "chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION"
     const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
     const val CallNotificationId: Int = -1
+
+    private const val ChatIdKey: String = "chatId"
   }
 
   private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -33,13 +36,17 @@ 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(NotificationChannel(MessageChannel, generalGetString(R.string.ntf_channel_messages), NotificationManager.IMPORTANCE_HIGH))
+    manager.createNotificationChannel(NotificationChannel(LockScreenCallChannel, generalGetString(R.string.ntf_channel_calls_lockscreen), NotificationManager.IMPORTANCE_HIGH))
     manager.createNotificationChannel(callNotificationChannel())
   }
 
+  enum class NotificationAction {
+    ACCEPT_CONTACT_REQUEST
+  }
+
   private fun callNotificationChannel(): NotificationChannel {
-    val callChannel = NotificationChannel(CallChannel, "SimpleX Chat calls", NotificationManager.IMPORTANCE_HIGH)
+    val callChannel = NotificationChannel(CallChannel, generalGetString(R.string.ntf_channel_calls), NotificationManager.IMPORTANCE_HIGH)
     val attrs = AudioAttributes.Builder()
       .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
       .setUsage(AudioAttributes.USAGE_NOTIFICATION)
@@ -63,28 +70,69 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     }
   }
 
+  fun notifyContactRequestReceived(cInfo: ChatInfo.ContactRequest) {
+    notifyMessageReceived(
+      chatId = cInfo.id,
+      displayName = cInfo.displayName,
+      msgText = generalGetString(R.string.notification_new_contact_request),
+      image = cInfo.image,
+      listOf(NotificationAction.ACCEPT_CONTACT_REQUEST)
+    )
+  }
+
+  fun notifyContactConnected(contact: Contact) {
+    notifyMessageReceived(
+      chatId = contact.id,
+      displayName = contact.displayName,
+      msgText = generalGetString(R.string.notification_contact_connected)
+    )
+  }
+
   fun notifyMessageReceived(cInfo: ChatInfo, cItem: ChatItem) {
+    if (!cInfo.ntfsEnabled) return
+
     notifyMessageReceived(chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
   }
 
-  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String) {
+  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String, image: String? = null, actions: List<NotificationAction> = emptyList()) {
     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)
+      .setVibrate(if (actions.isEmpty()) null else longArrayOf(0, 250, 250, 250))
       .setContentIntent(chatPendingIntent(OpenChatAction, chatId))
-      .setSilent(recentNotification)
-      .build()
+      .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(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)
@@ -97,7 +145,7 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
 
     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)
     }
   }
@@ -130,13 +178,23 @@ 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)
     with(NotificationManagerCompat.from(context)) {
@@ -154,7 +212,7 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
       if (cItem.content.text != "") {
         cItem.content.text
       } else {
-        cItem.file?.fileName ?: ""
+        if (cItem.content.msgContent is MsgContent.MCVoice) generalGetString(R.string.voice_message) else cItem.file?.fileName ?: ""
       }
     } else {
       var res = ""
@@ -171,10 +229,31 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     var intent = Intent(context, MainActivity::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)
+    if (chatId != null) intent = intent.putExtra(ChatIdKey, chatId)
     return TaskStackBuilder.create(context).run {
       addNextIntentWithParentStack(intent)
       getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
     }
   }
+
+  /**
+   * 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 chatId = intent?.getStringExtra(ChatIdKey) ?: return
+      val cInfo = SimplexApp.context.chatModel.getChat(chatId)?.chatInfo
+      when (intent.action) {
+        NotificationAction.ACCEPT_CONTACT_REQUEST.name -> {
+          if (cInfo !is ChatInfo.ContactRequest) return
+          acceptContactRequest(cInfo, SimplexApp.context.chatModel)
+          SimplexApp.context.chatModel.controller.ntfManager.cancelNotificationsForChat(chatId)
+        }
+        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,24 @@
 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 DarkColorPalette = darkColors(
   primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = DarkGray,
@@ -18,7 +31,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 +43,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

@@ -1,48 +1,121 @@
 package chat.simplex.app.views
 
+import android.content.Context
 import android.content.res.Configuration
+import android.os.SystemClock
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Lock
 import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import androidx.fragment.app.FragmentActivity
+import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.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
+
+private val lastSuccessfulAuth: MutableState<Long?> = mutableStateOf(null)
 
 @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"
+  val lastSuccessfulAuth = remember { lastSuccessfulAuth }
+  BackHandler(onBack = {
+    lastSuccessfulAuth.value = null
+    close()
+  })
+  val authorized = remember { !chatModel.controller.appPrefs.performLA.get() }
+  val context = LocalContext.current
+  LaunchedEffect(lastSuccessfulAuth.value) {
+    if (!authorized && !authorizedPreviously(lastSuccessfulAuth)) {
+      runAuth(lastSuccessfulAuth, context)
+    }
+  }
+  if (authorized || authorizedPreviously(lastSuccessfulAuth)) {
+    LaunchedEffect(Unit) {
+      // Update auth each time user visits this screen in authenticated state just to prolong authorized time
+      lastSuccessfulAuth.value = SystemClock.elapsedRealtime()
+    }
+    TerminalLayout(
+      chatModel.terminalItems,
+      composeState,
+      sendCommand = { sendCommand(chatModel, composeState) },
+      close
+    )
+  } else {
+    Surface(Modifier.fillMaxSize()) {
+      Column(Modifier.background(MaterialTheme.colors.background)) {
+        CloseSheetBar(close)
+        Box(
+          Modifier.fillMaxSize(),
+          contentAlignment = Alignment.Center
+        ) {
+          SimpleButton(
+            stringResource(R.string.auth_unlock),
+            icon = Icons.Outlined.Lock,
+            click = {
+              runAuth(lastSuccessfulAuth, context)
+            }
+          )
+        }
       }
-    },
-    close
+    }
+  }
+}
+
+private fun authorizedPreviously(lastSuccessfulAuth: State<Long?>): Boolean =
+  lastSuccessfulAuth.value?.let { SystemClock.elapsedRealtime() - it < 30_000 } ?: false
+
+private fun runAuth(lastSuccessfulAuth: MutableState<Long?>, context: Context) {
+  authenticate(
+    generalGetString(R.string.auth_open_chat_console),
+    generalGetString(R.string.auth_log_in_using_credential),
+    context as FragmentActivity,
+    completed = { laResult ->
+      lastSuccessfulAuth.value = when (laResult) {
+        LAResult.Success, LAResult.Unavailable -> SystemClock.elapsedRealtime()
+        is LAResult.Error, LAResult.Failed -> null
+      }
+    }
   )
 }
 
+private fun sendCommand(chatModel: ChatModel, composeState: MutableState<ComposeState>) {
+  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(ChatError.ChatErrorChat(ChatErrorType.СommandError("Failed reading: empty")))
+    chatModel.terminalItems.add(TerminalItem.cmd(CC.Console(s)))
+    chatModel.terminalItems.add(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
 fun TerminalLayout(
   terminalItems: List<TerminalItem>,
@@ -62,7 +135,7 @@ fun TerminalLayout(
       topBar = { CloseSheetBar(close) },
       bottomBar = {
         Box(Modifier.padding(horizontal = 8.dp)) {
-          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
+          SendMsgView(composeState, false, false, false, sendCommand, ::onMessageChange, { _, _, _ -> }, {}, {}, textStyle)
         }
       },
       modifier = Modifier.navigationBarsWithImePadding()
@@ -79,38 +152,33 @@ 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() } }
+  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 {
               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
@@ -26,12 +25,13 @@ 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
@@ -45,13 +45,9 @@ fun CreateProfilePanel(chatModel: ChatModel) {
 
   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))
@@ -102,6 +98,7 @@ fun CreateProfilePanel(chatModel: ChatModel) {
       }
 
       LaunchedEffect(Unit) {
+        delay(300)
         focusRequester.requestFocus()
       }
     }

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

@@ -51,7 +51,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,13 @@
 package chat.simplex.app.views.call
 
 import android.Manifest
+import android.annotation.SuppressLint
+import android.app.Activity
 import android.content.Context
+import android.content.pm.ActivityInfo
+import android.media.AudioDeviceInfo
 import android.media.AudioManager
+import android.os.Build
 import android.util.Log
 import android.view.ViewGroup
 import android.webkit.*
@@ -29,24 +34,42 @@ 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.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 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) {
+    onDispose {
+      // Stop it when call ended
+      if (!ntfModeService) SimplexService.safeStopService(SimplexApp.context)
+      // Clear selected communication device to default value after we changed it in call
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        val am = SimplexApp.context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+        am.clearCommunicationDevice()
+      }
+    }
+  }
   val cxt = LocalContext.current
   val scope = rememberCoroutineScope()
   Box(Modifier.fillMaxSize()) {
@@ -122,6 +145,17 @@ fun ActiveCallView(chatModel: ChatModel) {
     val call = chatModel.activeCall.value
     if (call != null)  ActiveCallOverlay(call, chatModel)
   }
+
+  val context = LocalContext.current
+  DisposableEffect(Unit) {
+    val activity = context as? Activity ?: return@DisposableEffect onDispose {}
+    // Lock orientation to portrait in order to have good experience with calls
+    activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+    onDispose {
+      // Unlock orientation
+      activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
+    }
+  }
 }
 
 @Composable
@@ -150,9 +184,19 @@ private fun setCallSound(cxt: Context, call: Call) {
   if (call.soundSpeaker) {
     am.mode = AudioManager.MODE_NORMAL
     am.isSpeakerphoneOn = true
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      am.availableCommunicationDevices.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_SPEAKER }?.let {
+        am.setCommunicationDevice(it)
+      }
+    }
   } else {
     am.mode = AudioManager.MODE_IN_CALL
     am.isSpeakerphoneOn = false
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      am.availableCommunicationDevices.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_EARPIECE }?.let {
+        am.setCommunicationDevice(it)
+      }
+    }
   }
 }
 
@@ -312,6 +356,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 +382,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 +435,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

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

@@ -45,16 +45,19 @@ fun IncomingCallAlertLayout(
   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)) {
+  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)
     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)
+      }
     }
   }
 }

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

@@ -3,11 +3,13 @@ package chat.simplex.app.views.call
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
 import chat.simplex.app.R
+import chat.simplex.app.SimplexApp
 import chat.simplex.app.model.Contact
 import chat.simplex.app.views.helpers.generalGetString
 import kotlinx.datetime.Instant
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import java.net.URI
 
 data class Call(
   val contact: Contact,
@@ -91,7 +93,7 @@ sealed class WCallResponse {
 @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 class RcvCallInvitation(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
@@ -115,7 +117,7 @@ sealed class WCallResponse {
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate
 @Serializable class RTCIceCandidate(val candidateType: RTCIceCandidateType?)
 // 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
@@ -153,4 +155,48 @@ class ConnectionState(
   val iceConnectionState: String,
   val iceGatheringState: String,
   val signalingState: String
-)
+)
+
+// the servers are expected in this format:
+// stun:stun.simplex.im:443
+// turn:private:yleob6AVkiNI87hpR94Z@turn.simplex.im:443
+fun parseRTCIceServer(str: String): RTCIceServer? {
+  var s = replaceScheme(str, "stun:")
+  s = replaceScheme(s, "turn:")
+  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")) {
+      val userInfo = u.userInfo?.split(":")
+      return RTCIceServer(
+        urls = listOf("$scheme:$host:$port"),
+        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,77 @@
 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.*
 
 @Composable
-fun ChatInfoView(chatModel: ChatModel, connStats: ConnectionStats?, close: () -> Unit) {
+fun ChatInfoView(
+  chatModel: ChatModel,
+  contact: Contact,
+  connStats: ConnectionStats?,
+  customUserProfile: Profile?,
+  localAlias: 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) {
     ChatInfoLayout(
       chat,
+      contact,
       connStats,
+      customUserProfile,
+      localAlias,
       developerTools,
+      onLocalAliasChanged = {
+        setContactAlias(chat.chatInfo.apiId, it, chatModel)
+      },
+      openPreferences = {
+        ModalManager.shared.showModal(true) {
+          ContactPreferencesView(chatModel, chatModel.currentUser.value ?: return@showModal, contact.contactId)
+        }
+      },
       deleteContact = { deleteContactDialog(chat.chatInfo, chatModel, close) },
-      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) }
+      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
+      switchContactAddress = {
+        showSwitchContactAddressAlert(chatModel, contact.contactId)
+      }
     )
   }
 }
@@ -82,10 +116,16 @@ fun clearChatDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit
 @Composable
 fun ChatInfoLayout(
   chat: Chat,
+  contact: Contact,
   connStats: ConnectionStats?,
+  customUserProfile: Profile?,
+  localAlias: String,
   developerTools: Boolean,
+  onLocalAliasChanged: (String) -> Unit,
+  openPreferences: () -> Unit,
   deleteContact: () -> Unit,
-  clearChat: () -> Unit
+  clearChat: () -> Unit,
+  switchContactAddress: () -> Unit,
 ) {
   Column(
     Modifier
@@ -97,13 +137,34 @@ 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 {
+      ContactPreferencesButton(openPreferences)
+    }
+
     SectionSpacer()
 
-    if (connStats != null) {
-      SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
-        SectionItemView {
+    SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+      SwitchAddressButton(switchContactAddress)
+      SectionDivider()
+      if (connStats != null) {
+        SectionItemView({
+          AlertManager.shared.showAlertMsg(
+            generalGetString(R.string.network_status),
+            chat.serverInfo.networkStatus.statusExplanation
+          )}) {
           NetworkStatusRow(chat.serverInfo.networkStatus)
         }
         val rcvServers = connStats.rcvServers
@@ -117,17 +178,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 +199,20 @@ 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)
+    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
     Text(
-      cInfo.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+      contact.profile.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
       color = MaterialTheme.colors.onBackground,
       maxLines = 1,
-      overflow = TextOverflow.Ellipsis
+      overflow = TextOverflow.Ellipsis,
+      modifier = Modifier.padding(bottom = 8.dp)
     )
-    if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName) {
+    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 +224,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
+fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
+  Row(
+    Modifier.fillMaxSize(),
     horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
@@ -223,45 +322,72 @@ 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
+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
+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() {
@@ -272,9 +398,16 @@ fun PreviewChatInfoLayout() {
         chatItems = arrayListOf(),
         serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
       ),
+      Contact.sampleData,
+      localAlias = "",
       developerTools = false,
       connStats = null,
-      deleteContact = {}, clearChat = {}
+      onLocalAliasChanged = {},
+      customUserProfile = null,
+      openPreferences = {},
+      deleteContact = {},
+      clearChat = {},
+      switchContactAddress = {},
     )
   }
 }

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,62 +1,68 @@
 package chat.simplex.app.views.chat
 
+import ComposeVoiceView
 import ComposeFileView
-import ComposeImageView
 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.ImageDecoder.DecodeException
+import android.graphics.drawable.AnimatedImageDrawable
 import android.net.Uri
 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 androidx.core.net.toFile
+import androidx.core.net.toUri
 import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.views.chat.item.*
 import chat.simplex.app.views.helpers.*
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
 import java.io.File
 
+@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>): ComposePreview()
+  @Serializable class VoicePreview(val voice: String, val durationMs: Int, val finished: Boolean): ComposePreview()
+  @Serializable class FilePreview(val fileName: String): 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 ComposeState(
   val message: String = "",
   val preview: ComposePreview = ComposePreview.NoPreview,
@@ -64,7 +70,7 @@ data class ComposeState(
   val inProgress: Boolean = false,
   val useLinkPreviews: Boolean
 ) {
-  constructor(editingItem: ChatItem, useLinkPreviews: Boolean): this (
+  constructor(editingItem: ChatItem, useLinkPreviews: Boolean): this(
     editingItem.content.text,
     chatItemPreview(editingItem),
     ComposeContextItem.EditingItem(editingItem),
@@ -81,6 +87,7 @@ data class ComposeState(
     get() = {
       val hasContent = when (preview) {
         is ComposePreview.ImagePreview -> true
+        is ComposePreview.VoicePreview -> true
         is ComposePreview.FilePreview -> true
         else -> message.isNotEmpty()
       }
@@ -90,6 +97,7 @@ data class ComposeState(
     get() =
       when (preview) {
         is ComposePreview.ImagePreview -> false
+        is ComposePreview.VoicePreview -> false
         is ComposePreview.FilePreview -> false
         else -> useLinkPreviews
       }
@@ -99,18 +107,28 @@ data class ComposeState(
         is ComposePreview.CLinkPreview -> preview.linkPreview
         else -> null
       }
+
+  companion object {
+    fun saver(): Saver<MutableState<ComposeState>, *> = Saver(
+      save = { json.encodeToString(serializer(), it.value) },
+      restore = {
+        mutableStateOf(json.decodeFromString(it))
+      }
+    )
+  }
 }
 
 fun chatItemPreview(chatItem: ChatItem): ComposePreview {
   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.MCImage -> ComposePreview.ImagePreview(images = listOf(mc.image))
+    is MsgContent.MCVoice -> ComposePreview.VoicePreview(voice = chatItem.file?.fileName ?: "", mc.duration / 1000, true)
     is MsgContent.MCFile -> {
       val fileName = chatItem.file?.fileName ?: ""
       ComposePreview.FilePreview(fileName)
     }
-    else -> ComposePreview.NoPreview
+    is MsgContent.MCUnknown, null -> ComposePreview.NoPreview
   }
 }
 
@@ -123,54 +141,28 @@ 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 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 = rememberLauncherForActivityResult(contract = ComposeTakePicturePreview()) { bitmap: Bitmap? ->
-    if (bitmap != null) {
-      chosenImage.value = bitmap
+  val chosenContent = rememberSaveable { mutableStateOf<List<UploadContent>>(emptyList()) }
+  val audioSaver = Saver<MutableState<Pair<Uri, Int>?>, Pair<String, Int>> (
+    save = { it.value.let { if (it == null) null else it.first.toString() to it.second } },
+    restore = { mutableStateOf(Uri.parse(it.first) to it.second) }
+  )
+  val chosenAudio = rememberSaveable(saver = audioSaver) { mutableStateOf(null) }
+  val chosenFile = rememberSaveable { mutableStateOf<Uri?>(null) }
+  val cameraLauncher = rememberCameraLauncher { uri: Uri? ->
+    if (uri != null) {
+      val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, uri)
+      val bitmap = ImageDecoder.decodeBitmap(source)
       val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
-      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
+      chosenContent.value = listOf(UploadContent.SimpleImage(uri))
+      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(listOf(imagePreview)))
     }
   }
   val cameraPermissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
@@ -180,23 +172,55 @@ fun ComposeView(
       Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
     }
   }
-  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
-    if (uri != null) {
+  val processPickedImage = { uris: List<Uri>, text: String? ->
+    val content = ArrayList<UploadContent>()
+    val imagesPreview = ArrayList<String>()
+    uris.forEach { uri ->
       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 drawable = try {
+        ImageDecoder.decodeDrawable(source)
+      } catch (e: DecodeException) {
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(R.string.image_decoding_exception_title),
+          text = generalGetString(R.string.image_decoding_exception_desc)
+        )
+        Log.e(TAG, "Error while decoding drawable: ${e.stackTraceToString()}")
+        null
+      }
+      var bitmap: Bitmap? = if (drawable != null) ImageDecoder.decodeBitmap(source) else null
+      if (drawable is AnimatedImageDrawable) {
+        // It's a gif or webp
+        val fileSize = getFileSize(context, uri)
+        if (fileSize != null && fileSize <= MAX_FILE_SIZE) {
+          content.add(UploadContent.AnimatedImage(uri))
+        } else {
+          bitmap = null
+          AlertManager.shared.showAlertMsg(
+            generalGetString(R.string.large_file),
+            String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(MAX_FILE_SIZE))
+          )
+        }
+      } else {
+        content.add(UploadContent.SimpleImage(uri))
+      }
+      if (bitmap != null) {
+        imagesPreview.add(resizeImageToStrSize(bitmap, maxDataSize = 14000))
+      }
+    }
+
+    if (imagesPreview.isNotEmpty()) {
+      chosenContent.value = content
+      composeState.value = composeState.value.copy(message = text ?: composeState.value.message, preview = ComposePreview.ImagePreview(imagesPreview))
     }
   }
-  val filesLauncher = rememberGetContentLauncher { uri: Uri? ->
+  val processPickedFile = { uri: Uri?, text: String? ->
     if (uri != null) {
       val fileSize = getFileSize(context, uri)
       if (fileSize != null && fileSize <= MAX_FILE_SIZE) {
         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))
         }
       } else {
         AlertManager.shared.showAlertMsg(
@@ -206,6 +230,9 @@ fun ComposeView(
       }
     }
   }
+  val galleryLauncher = rememberLauncherForActivityResult(contract = PickMultipleFromGallery()) { processPickedImage(it, null) }
+  val galleryLauncherFallback = rememberGetMultipleContentsLauncher { processPickedImage(it, null) }
+  val filesLauncher = rememberGetContentLauncher { processPickedFile(it, null) }
 
   LaunchedEffect(attachmentOption.value) {
     when (attachmentOption.value) {
@@ -221,7 +248,11 @@ fun ComposeView(
         attachmentOption.value = null
       }
       AttachmentOption.PickImage -> {
-        galleryLauncher.launch("image/*")
+        try {
+          galleryLauncher.launch(0)
+        } catch (e: ActivityNotFoundException) {
+          galleryLauncherFallback.launch("image/*")
+        }
         attachmentOption.value = null
       }
       AttachmentOption.PickFile -> {
@@ -250,6 +281,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
         }
       }
     }
@@ -298,6 +332,7 @@ fun ComposeView(
       is MsgContent.MCText -> checkLinkPreview()
       is MsgContent.MCLink -> checkLinkPreview()
       is MsgContent.MCImage -> MsgContent.MCImage(cs.message, image = msgContent.image)
+      is MsgContent.MCVoice -> MsgContent.MCVoice(cs.message, duration = msgContent.duration)
       is MsgContent.MCFile -> MsgContent.MCFile(cs.message)
       is MsgContent.MCUnknown -> MsgContent.MCUnknown(type = msgContent.type, text = cs.message, json = msgContent.json)
     }
@@ -306,7 +341,8 @@ fun ComposeView(
   fun clearState() {
     composeState.value = ComposeState(useLinkPreviews = useLinkPreviews)
     textStyle.value = smallFont
-    chosenImage.value = null
+    chosenContent.value = emptyList()
+    chosenAudio.value = null
     chosenFile.value = null
     linkUrl.value = null
     prevLinkUrl.value = null
@@ -336,26 +372,39 @@ fun ComposeView(
         }
       }
       else -> {
-        var mc: MsgContent? = null
-        var file: String? = null
+        val msgs: ArrayList<MsgContent> = ArrayList()
+        val files: ArrayList<String> = ArrayList()
         when (val preview = cs.preview) {
-          ComposePreview.NoPreview -> mc = MsgContent.MCText(cs.message)
-          is ComposePreview.CLinkPreview -> mc = checkLinkPreview()
+          ComposePreview.NoPreview -> msgs.add(MsgContent.MCText(cs.message))
+          is ComposePreview.CLinkPreview -> msgs.add(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)
+            chosenContent.value.forEachIndexed { index, it ->
+              val file = when (it) {
+                is UploadContent.SimpleImage -> saveImage(context, it.uri)
+                is UploadContent.AnimatedImage -> saveAnimImage(context, it.uri)
               }
+              if (file != null) {
+                files.add(file)
+                msgs.add(MsgContent.MCImage(if (msgs.isEmpty()) cs.message else "", preview.images[index]))
+              }
+            }
+          }
+          is ComposePreview.VoicePreview -> {
+            val chosenAudioVal = chosenAudio.value
+            if (chosenAudioVal != null) {
+              val file = chosenAudioVal.first.toFile().name
+              files.add((file))
+              chatModel.filesToDelete.remove(chosenAudioVal.first.toFile())
+              msgs.add(MsgContent.MCVoice(if (msgs.isEmpty()) cs.message else "", chosenAudioVal.second / 1000))
             }
           }
           is ComposePreview.FilePreview -> {
             val chosenFileVal = chosenFile.value
             if (chosenFileVal != null) {
-              file = saveFileFromUri(context, chosenFileVal)
+              val file = saveFileFromUri(context, chosenFileVal)
               if (file != null) {
-                mc = MsgContent.MCFile(cs.message)
+                files.add((file))
+                msgs.add(MsgContent.MCFile(if (msgs.isEmpty()) cs.message else ""))
               }
             }
           }
@@ -364,17 +413,19 @@ fun ComposeView(
           is ComposeContextItem.QuotedItem -> contextItem.chatItem.id
           else -> null
         }
-
-        if (mc != null) {
+        if (msgs.isNotEmpty()) {
           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)
+            msgs.forEachIndexed { index, content ->
+              if (index > 0) delay(100)
+              val aChatItem = chatModel.controller.apiSendMessage(
+                type = cInfo.chatType,
+                id = cInfo.apiId,
+                file = files.getOrNull(index),
+                quotedItemId = if (index == 0) quotedItemId else null,
+                mc = content
+              )
+              if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
+            }
             clearState()
           }
         } else {
@@ -397,6 +448,36 @@ fun ComposeView(
     }
   }
 
+  fun onAudioAdded(filePath: String, durationMs: Int, finished: Boolean) {
+    val file = File(filePath)
+    chosenAudio.value = file.toUri() to durationMs
+    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
+    val featuresAllowed = contactUserPrefsToFeaturesAllowed(contact.mergedPreferences)
+    withApi {
+      val prefs = contactFeaturesAllowedToPrefs(featuresAllowed).copy(voice = ChatPreference(FeatureAllowed.YES))
+      val toContact = chatModel.controller.apiSetContactPrefs(contact.contactId, prefs)
+      if (toContact != null) {
+        chatModel.updateContact(toContact)
+      }
+    }
+  }
+  fun showDisabledVoiceAlert() {
+    AlertManager.shared.showAlertMsg(
+      title = generalGetString(R.string.voice_messages_prohibited),
+      text = generalGetString(
+        if (chat.chatInfo is ChatInfo.Direct)
+          R.string.ask_your_contact_to_enable_voice
+        else
+          R.string.only_group_owners_can_enable_voice
+      )
+    )
+  }
+
   fun cancelLinkPreview() {
     val uri = composeState.value.linkPreview?.uri
     if (uri != null) {
@@ -406,9 +487,14 @@ 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
+    chosenContent.value = emptyList()
+  }
+
+  fun cancelVoice() {
+    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+    chosenContent.value = emptyList()
   }
 
   fun cancelFile() {
@@ -422,10 +508,17 @@ 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.VoicePreview -> ComposeVoiceView(
+        preview.voice,
+        preview.durationMs,
+        preview.finished,
+        cancelEnabled = !composeState.value.editing,
+        ::cancelVoice
+      )
       is ComposePreview.FilePreview -> ComposeFileView(
         preview.fileName,
         ::cancelFile,
@@ -447,42 +540,104 @@ fun ComposeView(
     }
   }
 
+  LaunchedEffect(chatModel.sharedContent.value) {
+    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
+  }
+
   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)) {
+      val attachEnabled = !composeState.value.editing && composeState.value.preview !is ComposePreview.VoicePreview
+      IconButton(showChooseAttachment, enabled = attachEnabled) {
         Icon(
           Icons.Filled.AttachFile,
           contentDescription = stringResource(R.string.attach),
-          tint = if (attachEnabled) MaterialTheme.colors.primary else Color.Gray,
+          tint = if (attachEnabled) MaterialTheme.colors.primary else HighOrLowlight,
           modifier = Modifier
             .size(28.dp)
             .clip(CircleShape)
-            .clickable {
-              if (attachEnabled) {
-                showChooseAttachment()
-              }
-            }
         )
       }
+      val allowedVoiceByPrefs = remember(chat.chatInfo) {
+        when (chat.chatInfo) {
+          is ChatInfo.Direct -> chat.chatInfo.contact.mergedPreferences.voice.enabled.forUser
+          is ChatInfo.Group -> chat.chatInfo.groupInfo.fullGroupPreferences.voice.enable == GroupFeatureEnabled.ON
+          else -> false
+        }
+      }
+      val needToAllowVoiceToContact = remember(chat.chatInfo) {
+        when (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
+          }
+          else -> false
+        }
+      }
       SendMsgView(
         composeState,
+        showVoiceRecordIcon = true,
+        allowedVoiceByPrefs = allowedVoiceByPrefs,
+        needToAllowVoiceToContact = needToAllowVoiceToContact,
         sendMessage = {
           sendMessage()
           resetLinkPreview()
         },
         ::onMessageChange,
+        ::onAudioAdded,
+        ::allowVoiceToContact,
+        ::showDisabledVoiceAlert,
         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 PickMultipleFromGallery: 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()
+}

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

@@ -0,0 +1,128 @@
+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.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 {
+            audioPlaying.value -> progress.value
+            finishedRecording && progress.value == duration.value -> progress.value
+            finishedRecording -> 0
+            else -> recordedDurationMs
+          }
+          val endTime = when {
+            finishedRecording -> duration.value
+            audioPlaying.value -> recordedDurationMs
+            else -> MAX_VOICE_MILLIS_FOR_SENDING.toInt()
+          }
+          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)
+          } 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 { if (audioPlaying.value) progress.value / 1000 else recordedDurationMs / 1000 }
+      }
+      Text(
+        durationToString(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,141 @@
+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.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.*
+
+@Composable
+fun ContactPreferencesView(
+  m: ChatModel,
+  user: User,
+  contactId: Long,
+) {
+  val contact = remember { derivedStateOf { (m.getContactChat(contactId)?.chatInfo as? ChatInfo.Direct)?.contact } }
+  val ct = contact.value ?: return
+  var featuresAllowed by remember(ct) { mutableStateOf(contactUserPrefsToFeaturesAllowed(ct.mergedPreferences)) }
+  var currentFeaturesAllowed by remember(ct) { mutableStateOf(featuresAllowed) }
+  ContactPreferencesLayout(
+    featuresAllowed,
+    currentFeaturesAllowed,
+    user,
+    ct,
+    applyPrefs = { prefs ->
+      featuresAllowed = prefs
+    },
+    reset = {
+      featuresAllowed = currentFeaturesAllowed
+    },
+    savePrefs = {
+      withApi {
+        val prefs = contactFeaturesAllowedToPrefs(featuresAllowed)
+        val toContact = m.controller.apiSetContactPrefs(ct.contactId, prefs)
+        if (toContact != null) {
+          m.updateContact(toContact)
+          currentFeaturesAllowed = featuresAllowed
+        }
+      }
+    },
+  )
+}
+
+@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 allowFullDeletion: MutableState<ContactFeatureAllowed> = remember(featuresAllowed) { mutableStateOf(featuresAllowed.fullDelete) }
+//    FeatureSection(Feature.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(Feature.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: Feature,
+  userDefault: FeatureAllowed,
+  pref: ContactUserPreference,
+  allowFeature: State<ContactFeatureAllowed>,
+  onSelected: (ContactFeatureAllowed) -> Unit
+) {
+  val enabled = FeatureEnabled.enabled(
+    user = ChatPreference(allow = allowFeature.value.allowed),
+    contact = pref.contactPreference
+  )
+
+  SectionView(
+    feature.text().uppercase(),
+    icon = feature.icon(true),
+    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 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)
+    }
+  }
+}

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

@@ -1,82 +1,82 @@
 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.text.InputType
+import android.view.ViewGroup
+import android.view.inputmethod.*
+import android.widget.EditText
 import androidx.compose.foundation.*
 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.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.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.platform.*
 import androidx.compose.ui.res.stringResource
 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.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.SimplexApp
 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.*
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+import kotlinx.coroutines.*
+import java.io.*
 
 @Composable
 fun SendMsgView(
   composeState: MutableState<ComposeState>,
+  showVoiceRecordIcon: Boolean,
+  allowedVoiceByPrefs: Boolean,
+  needToAllowVoiceToContact: Boolean,
   sendMessage: () -> Unit,
   onMessageChange: (String) -> Unit,
+  onAudioAdded: (String, Int, Boolean) -> Unit,
+  allowVoiceToContact: () -> Unit,
+  showDisabledVoiceAlert: () -> 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)
+  Column(Modifier.padding(vertical = 8.dp)) {
+    Box {
+      val cs = composeState.value
+      val attachEnabled = !composeState.value.editing
+      val filePath = rememberSaveable { mutableStateOf(null as String?) }
+      var recordingTimeRange by rememberSaveable(saver = LongRange.saver) { mutableStateOf(0L..0L) } // since..to
+      val showVoiceButton = ((cs.message.isEmpty() || recordingTimeRange.first > 0L) && showVoiceRecordIcon && attachEnabled && cs.preview is ComposePreview.NoPreview) || filePath.value != null
+      Box(if (recordingTimeRange.first == 0L)
+        Modifier
+      else
+        Modifier.clickable(false, onClick = {})
       ) {
-        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 {
+        NativeKeyboard(composeState, textStyle, onMessageChange)
+      }
+      Box(Modifier.align(Alignment.BottomEnd)) {
+        val icon = if (cs.editing) Icons.Filled.Check else Icons.Outlined.ArrowUpward
+        val color = if (cs.sendEnabled()) MaterialTheme.colors.primary else HighOrLowlight
+        if (cs.inProgress && (cs.preview is ComposePreview.ImagePreview || cs.preview is ComposePreview.VoicePreview || cs.preview is ComposePreview.FilePreview)) {
+          CircularProgressIndicator(Modifier.size(36.dp).padding(4.dp), color = HighOrLowlight, strokeWidth = 3.dp)
+        } else if (!showVoiceButton) {
+          IconButton(sendMessage, Modifier.size(36.dp), enabled = cs.sendEnabled()) {
             Icon(
               icon,
               stringResource(R.string.icon_descr_send_message),
@@ -86,17 +86,233 @@ fun SendMsgView(
                 .padding(4.dp)
                 .clip(CircleShape)
                 .background(color)
-                .clickable {
-                  if (cs.sendEnabled()) {
-                    sendMessage()
-                  }
-                }
             )
           }
+        } else {
+          val permissionsState = rememberMultiplePermissionsState(
+            permissions = listOf(
+              Manifest.permission.RECORD_AUDIO,
+            )
+          )
+          val rec: Recorder = remember { RecorderNative(MAX_VOICE_SIZE_FOR_SENDING) }
+          val recordingInProgress: State<Boolean> = remember { rec.recordingInProgress }
+          var now by remember { mutableStateOf(System.currentTimeMillis()) }
+          LaunchedEffect(Unit) {
+            while (isActive) {
+              now = System.currentTimeMillis()
+              if (recordingTimeRange.first != 0L && recordingInProgress.value && composeState.value.preview is ComposePreview.VoicePreview) {
+                filePath.value?.let { onAudioAdded(it, (now - recordingTimeRange.first).toInt(), false) }
+              }
+              delay(100)
+            }
+          }
+          val stopRecordingAndAddAudio: () -> Unit = {
+            rec.stop()
+            recordingTimeRange = recordingTimeRange.first..System.currentTimeMillis()
+            filePath.value?.let { onAudioAdded(it, (recordingTimeRange.last - recordingTimeRange.first).toInt(), true) }
+          }
+          val startStopRecording: () -> Unit = {
+            when {
+              !permissionsState.allPermissionsGranted -> permissionsState.launchMultiplePermissionRequest()
+              needToAllowVoiceToContact -> {
+                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 = allowVoiceToContact,
+                )
+              }
+              !allowedVoiceByPrefs -> showDisabledVoiceAlert()
+              recordingInProgress.value -> stopRecordingAndAddAudio()
+              filePath.value == null -> {
+                recordingTimeRange = System.currentTimeMillis()..0L
+                filePath.value = rec.start(stopRecordingAndAddAudio)
+                filePath.value?.let { onAudioAdded(it, (now - recordingTimeRange.first).toInt(), false) }
+              }
+            }
+          }
+          var stopRecOnNextClick by remember { mutableStateOf(false) }
+          val context = LocalContext.current
+          DisposableEffect(stopRecOnNextClick) {
+            val activity = context as? Activity ?: return@DisposableEffect onDispose {}
+            if (stopRecOnNextClick) {
+              // Lock orientation to current orientation because screen rotation will break the recording
+              activity.requestedOrientation = if (activity.resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT)
+                ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
+              else
+                ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
+            }
+            // Unlock orientation
+            onDispose { activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED }
+          }
+          val cleanUp = { remove: Boolean ->
+            rec.stop()
+            AudioPlayer.stop(filePath.value)
+            if (remove) filePath.value?.let { File(it).delete() }
+            filePath.value = null
+            stopRecOnNextClick = false
+            recordingTimeRange = 0L..0L
+          }
+          LaunchedEffect(cs.preview) {
+            if (cs.preview !is ComposePreview.VoicePreview && filePath.value != null) {
+              // Pressed on X icon in preview
+              cleanUp(true)
+            }
+          }
+          val interactionSource = interactionSourceWithTapDetection(
+            // It's just a key for triggering dropping a state in the compose function. Without it
+            // nothing will react on changed params like needToAllowVoiceToContact or allowedVoiceByPrefs
+            needToAllowVoiceToContact.toString() + allowedVoiceByPrefs.toString(),
+            onPress = {
+              if (filePath.value == null) startStopRecording()
+            },
+            onClick = {
+              // Voice not allowed or not granted voice record permission for the app
+              if (!allowedVoiceByPrefs || !permissionsState.allPermissionsGranted) return@interactionSourceWithTapDetection
+              if (!recordingInProgress.value && filePath.value != null) {
+                sendMessage()
+                cleanUp(false)
+              } else if (stopRecOnNextClick) {
+                stopRecordingAndAddAudio()
+                stopRecOnNextClick = false
+              } else {
+                // tapped and didn't hold a finger
+                stopRecOnNextClick = true
+              }
+            },
+            onCancel = startStopRecording,
+            onRelease = startStopRecording
+          )
+          val sendButtonModifier = if (recordingTimeRange.last != 0L)
+            Modifier.clip(CircleShape).background(color)
+          else
+            Modifier
+          IconButton({}, Modifier.size(36.dp), enabled = !cs.inProgress, interactionSource = interactionSource) {
+            Icon(
+              when {
+                recordingTimeRange.last != 0L -> Icons.Outlined.ArrowUpward
+                stopRecOnNextClick -> Icons.Filled.Stop
+                allowedVoiceByPrefs -> Icons.Filled.KeyboardVoice
+                else -> Icons.Outlined.KeyboardVoice
+              },
+              stringResource(R.string.icon_descr_record_voice_message),
+              tint = when {
+                recordingTimeRange.last != 0L -> Color.White
+                stopRecOnNextClick -> MaterialTheme.colors.primary
+                allowedVoiceByPrefs -> MaterialTheme.colors.primary
+                else -> HighOrLowlight
+              },
+              modifier = Modifier
+                .size(36.dp)
+                .padding(4.dp)
+                .then(sendButtonModifier)
+            )
+          }
+          DisposableEffect(Unit) {
+            onDispose {
+              rec.stop()
+            }
+          }
         }
       }
     }
-  )
+  }
+}
+
+@Composable
+private fun NativeKeyboard(
+  composeState: MutableState<ComposeState>,
+  textStyle: MutableState<TextStyle>,
+  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) {
+    when (cs.contextItem) {
+      is ComposeContextItem.QuotedItem -> {
+        delay(100)
+        showKeyboard = true
+      }
+      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)
+    editText.textCursorDrawable?.let { DrawableCompat.setTint(it, HighOrLowlight.toArgb()) }
+    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
+    }
+  }
+  if (composeState.value.preview is ComposePreview.VoicePreview) {
+    Text(
+      generalGetString(R.string.voice_message_send_text),
+      Modifier.padding(padding),
+      color = HighOrLowlight,
+      style = textStyle.value.copy(fontStyle = FontStyle.Italic)
+    )
+  }
 }
 
 @Preview(showBackground = true)
@@ -112,8 +328,14 @@ fun PreviewSendMsgView() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
+      showVoiceRecordIcon = false,
+      allowedVoiceByPrefs = false,
+      needToAllowVoiceToContact = false,
       sendMessage = {},
       onMessageChange = { _ -> },
+      onAudioAdded = { _, _, _ -> },
+      allowVoiceToContact = {},
+      showDisabledVoiceAlert = {},
       textStyle = textStyle
     )
   }
@@ -133,8 +355,14 @@ fun PreviewSendMsgViewEditing() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateEditing) },
+      showVoiceRecordIcon = false,
+      allowedVoiceByPrefs = false,
+      needToAllowVoiceToContact = false,
       sendMessage = {},
       onMessageChange = { _ -> },
+      onAudioAdded = { _, _, _ -> },
+      allowVoiceToContact = {},
+      showDisabledVoiceAlert = {},
       textStyle = textStyle
     )
   }
@@ -154,8 +382,14 @@ fun PreviewSendMsgViewInProgress() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateInProgress) },
+      showVoiceRecordIcon = false,
+      allowedVoiceByPrefs = false,
+      needToAllowVoiceToContact = false,
       sendMessage = {},
       onMessageChange = { _ -> },
+      onAudioAdded = { _, _, _ -> },
+      allowVoiceToContact = {},
+      showDisabledVoiceAlert = {},
       textStyle = textStyle
     )
   }

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,30 @@ 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) {
   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,
     contactsToAdd = getContactsToAdd(chatModel),
     selectedContacts = selectedContacts,
     selectedRole = selectedRole,
+    allowModifyMembers = allowModifyMembers,
     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()
       }
@@ -70,8 +80,9 @@ fun getContactsToAdd(chatModel: ChatModel): List<Contact> {
 fun AddGroupMembersLayout(
   groupInfo: GroupInfo,
   contactsToAdd: List<Contact>,
-  selectedContacts: SnapshotStateList<Long>,
+  selectedContacts: List<Long>,
   selectedRole: MutableState<GroupMemberRole>,
+  allowModifyMembers: Boolean,
   inviteMembers: () -> Unit,
   clearSelection: () -> Unit,
   addContact: (Long) -> Unit,
@@ -83,6 +94,7 @@ fun AddGroupMembersLayout(
       .verticalScroll(rememberScrollState()),
     horizontalAlignment = Alignment.Start,
   ) {
+    AppBarTitle(stringResource(R.string.button_add_members))
     Row(
       Modifier.fillMaxWidth(),
       horizontalArrangement = Arrangement.Center
@@ -90,7 +102,7 @@ fun AddGroupMembersLayout(
       ChatInfoToolbarTitle(
         ChatInfo.Group(groupInfo),
         imageSize = 60.dp,
-        iconColor = if (isSystemInDarkTheme()) GroupDark else SettingsSecondaryLight
+        iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight
       )
     }
     SectionSpacer()
@@ -109,20 +121,18 @@ fun AddGroupMembersLayout(
     } else {
       SectionView {
         SectionItemView {
-          RoleSelectionRow(groupInfo, selectedRole)
+          RoleSelectionRow(groupInfo, selectedRole, allowModifyMembers)
         }
         SectionDivider()
-        SectionItemView {
-          InviteMembersButton(inviteMembers, disabled = selectedContacts.isEmpty())
-        }
+        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)
+        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, allowModifyMembers, addContact, removeContact)
       }
       SectionSpacer()
     }
@@ -130,114 +140,58 @@ 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 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 +205,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,32 +228,60 @@ 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() {
@@ -308,6 +291,7 @@ fun PreviewAddGroupMembersLayout() {
       contactsToAdd = listOf(Contact.sampleData, Contact.sampleData, Contact.sampleData),
       selectedContacts = remember { mutableStateListOf() },
       selectedRole = remember { mutableStateOf(GroupMemberRole.Admin) },
+      allowModifyMembers = true,
       inviteMembers = {},
       clearSelection = {},
       addContact = {},

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

@@ -4,6 +4,7 @@ import InfoRow
 import SectionDivider
 import SectionItemView
 import SectionSpacer
+import SectionTextFooter
 import SectionView
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
@@ -11,11 +12,12 @@ 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
@@ -24,8 +26,10 @@ import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.*
-import chat.simplex.app.views.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) {
@@ -43,44 +47,51 @@ fun GroupChatInfoView(chatModel: ChatModel, close: () -> Unit) {
       developerTools,
       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, 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)
+          ModalManager.shared.showModalCloseable(true) { closeCurrent ->
+            GroupMemberInfoView(groupInfo, member, stats, chatModel, closeCurrent) { closeCurrent(); close() }
           }
         }
       },
       editGroupProfile = {
         ModalManager.shared.showCustomModal { close -> GroupProfileView(groupInfo, chatModel, close) }
       },
-      deleteGroup = { deleteGroupDialog(chat.chatInfo, chatModel, close) },
+      openPreferences = {
+        ModalManager.shared.showModal(true) {
+          GroupPreferencesView(
+            chatModel,
+            groupInfo
+          )
+        }
+      },
+      deleteGroup = { deleteGroupDialog(chat.chatInfo, groupInfo, chatModel, close) },
       clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
-      leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) }
+      leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) },
+      manageGroupLink = {
+        withApi {
+          val groupLink = chatModel.controller.apiGetGroupLink(groupInfo.groupId)
+          ModalManager.shared.showModal { GroupLinkView(chatModel, groupInfo, groupLink) }
+        }
+      }
     )
   }
 }
 
-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 {
@@ -119,9 +130,11 @@ fun GroupChatInfoLayout(
   addMembers: () -> Unit,
   showMemberInfo: (GroupMember) -> Unit,
   editGroupProfile: () -> Unit,
+  openPreferences: () -> Unit,
   deleteGroup: () -> Unit,
   clearChat: () -> Unit,
   leaveGroup: () -> Unit,
+  manageGroupLink: () -> Unit,
 ) {
   Column(
     Modifier
@@ -133,18 +146,32 @@ fun GroupChatInfoLayout(
       Modifier.fillMaxWidth(),
       horizontalArrangement = Arrangement.Center
     ) {
-      ChatInfoHeader(chat.chatInfo)
+      GroupChatInfoHeader(chat.chatInfo)
     }
     SectionSpacer()
 
+    SectionView {
+      if (groupInfo.canEdit) {
+        SectionItemView(editGroupProfile) { EditGroupProfileButton() }
+        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) { 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 +180,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,20 +205,51 @@ fun GroupChatInfoLayout(
 }
 
 @Composable
-fun AddMembersButton(addMembers: () -> Unit) {
+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
+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)
   }
 }
 
@@ -212,8 +257,8 @@ fun AddMembersButton(addMembers: () -> Unit) {
 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,10 +268,9 @@ 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
+fun MemberRow(member: GroupMember, user: Boolean = false) {
   Row(
-    modifier.fillMaxSize(),
+    Modifier.fillMaxWidth(),
     horizontalArrangement = Arrangement.SpaceBetween,
     verticalAlignment = Alignment.CenterVertically
   ) {
@@ -236,7 +280,10 @@ fun MemberRow(member: GroupMember, showMemberInfo: ((GroupMember) -> Unit)? = nu
     ) {
       ProfileImage(size = 46.dp, member.image)
       Column {
-        Text(member.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis)
+        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 +303,43 @@ fun MemberRow(member: GroupMember, showMemberInfo: ((GroupMember) -> Unit)? = nu
 }
 
 @Composable
-fun EditGroupProfileButton(editGroupProfile: () -> Unit) {
+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
+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) {
+fun LeaveGroupButton() {
   Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { leaveGroup() },
+    Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
   ) {
     Icon(
@@ -292,11 +353,9 @@ fun LeaveGroupButton(leaveGroup: () -> Unit) {
 }
 
 @Composable
-fun DeleteGroupButton(deleteGroup: () -> Unit) {
+fun DeleteGroupButton() {
   Row(
-    Modifier
-      .fillMaxSize()
-      .clickable { deleteGroup() },
+    Modifier.fillMaxSize(),
     verticalAlignment = Alignment.CenterVertically
   ) {
     Icon(
@@ -322,7 +381,7 @@ fun PreviewGroupChatInfoLayout() {
       groupInfo = GroupInfo.sampleData,
       members = listOf(GroupMember.sampleData, GroupMember.sampleData, GroupMember.sampleData),
       developerTools = false,
-      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {}
+      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, openPreferences = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {}, manageGroupLink = {},
     )
   }
 }

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

@@ -0,0 +1,101 @@
+package chat.simplex.app.views.chat.group
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.Text
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.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.ChatModel
+import chat.simplex.app.model.GroupInfo
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
+import chat.simplex.app.ui.theme.SimpleButton
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.newchat.QRCode
+
+@Composable
+fun GroupLinkView(chatModel: ChatModel, groupInfo: GroupInfo, connReqContact: String?) {
+  var groupLink by remember { mutableStateOf(connReqContact) }
+  val cxt = LocalContext.current
+  GroupLinkLayout(
+    groupLink = groupLink,
+    createLink = {
+      withApi {
+        groupLink = chatModel.controller.apiCreateGroupLink(groupInfo.groupId)
+      }
+    },
+    share = { shareText(cxt, groupLink ?: return@GroupLinkLayout) },
+    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
+            }
+          }
+        }
+      )
+    }
+  )
+}
+
+@Composable
+fun GroupLinkLayout(
+  groupLink: String?,
+  createLink: () -> Unit,
+  share: () -> Unit,
+  deleteLink: () -> Unit
+) {
+  Column(
+    Modifier.padding(horizontal = 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, click = createLink)
+      } else {
+        QRCode(groupLink, Modifier.weight(1f, fill = false).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
+          )
+        }
+      }
+    }
+  }
+}
+

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
@@ -24,32 +24,83 @@ 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.SwitchAddressButton
+import chat.simplex.app.views.chatlist.openChat
 import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.SettingsActionItem
 
 @Composable
-fun GroupMemberInfoView(groupInfo: GroupInfo, member: GroupMember, connStats: ConnectionStats?, chatModel: ChatModel, close: () -> Unit) {
+fun GroupMemberInfoView(
+  groupInfo: GroupInfo,
+  member: GroupMember,
+  connStats: ConnectionStats?,
+  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) }
+      openDirectChat = {
+        withApi {
+          val oldChat = chatModel.getContactChat(member.memberContactId ?: return@withApi)
+          if (oldChat != null) {
+            openChat(oldChat.chatInfo, chatModel)
+          } else {
+            var newChat = chatModel.controller.apiGetChat(ChatType.Direct, member.memberContactId) ?: return@withApi
+            // TODO it's not correct to blindly set network status to connected - we should manage network status in model / backend
+            newChat = newChat.copy(serverInfo = Chat.ServerInfo(networkStatus = Chat.NetworkStatus.Connected()))
+            chatModel.addChat(newChat)
+            chatModel.chatItems.clear()
+            chatModel.chatId.value = newChat.id
+          }
+          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)
+      }
     )
   }
 }
 
-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 +112,12 @@ fun GroupMemberInfoLayout(
   groupInfo: GroupInfo,
   member: GroupMember,
   connStats: ConnectionStats?,
+  newRole: MutableState<GroupMemberRole>,
   developerTools: Boolean,
+  openDirectChat: () -> Unit,
   removeMember: () -> Unit,
+  onRoleSelected: (GroupMemberRole) -> Unit,
+  switchMemberAddress: () -> Unit,
 ) {
   Column(
     Modifier
@@ -78,8 +133,22 @@ fun GroupMemberInfoLayout(
     }
     SectionSpacer()
 
+    SectionView {
+      OpenChatButton(openDirectChat)
+    }
+    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 +159,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()
+      if (connStats != null) {
+        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 +176,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,7 +204,7 @@ fun GroupMemberInfoHeader(member: GroupMember) {
     Modifier.padding(horizontal = 8.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    ProfileImage(size = 192.dp, member.image, color = if (isSystemInDarkTheme()) GroupDark else SettingsSecondaryLight)
+    ProfileImage(size = 192.dp, member.image, color = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
     Text(
       member.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
       color = MaterialTheme.colors.onBackground,
@@ -155,23 +223,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 +298,12 @@ fun PreviewGroupMemberInfoLayout() {
       groupInfo = GroupInfo.sampleData,
       member = GroupMember.sampleData,
       connStats = null,
+      newRole = remember { mutableStateOf(GroupMemberRole.Member) },
       developerTools = false,
-      removeMember = {}
+      openDirectChat = {},
+      removeMember = {},
+      onRoleSelected = {},
+      switchMemberAddress = {},
     )
   }
 }

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

@@ -0,0 +1,117 @@
+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.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.HighOrLowlight
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun GroupPreferencesView(m: ChatModel, groupInfo: GroupInfo) {
+  var preferences by remember { mutableStateOf(groupInfo.fullGroupPreferences) }
+  var currentPreferences by remember { mutableStateOf(preferences) }
+  GroupPreferencesLayout(
+    preferences,
+    currentPreferences,
+    groupInfo,
+    applyPrefs = { prefs ->
+      preferences = prefs
+    },
+    reset = {
+      preferences = currentPreferences
+    },
+    savePrefs = {
+      withApi {
+        val gp = groupInfo.groupProfile.copy(groupPreferences = preferences.toGroupPreferences())
+        val gInfo = m.controller.apiUpdateGroup(groupInfo.groupId, gp)
+        if (gInfo != null) {
+          m.updateGroup(gInfo)
+          currentPreferences = preferences
+        }
+      }
+    },
+  )
+}
+
+@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 allowFullDeletion = remember(preferences) { mutableStateOf(preferences.fullDelete.enable) }
+//    FeatureSection(Feature.FullDelete, allowFullDeletion, groupInfo) {
+//      applyPrefs(preferences.copy(fullDelete = GroupPreference(enable = it)))
+//    }
+//    SectionSpacer()
+    val allowVoice = remember(preferences) { mutableStateOf(preferences.voice.enable) }
+    FeatureSection(Feature.Voice, allowVoice, groupInfo) {
+      applyPrefs(preferences.copy(voice = GroupPreference(enable = it)))
+    }
+    if (groupInfo.canEdit) {
+      SectionSpacer()
+      ResetSaveButtons(
+        reset = reset,
+        save = savePrefs,
+        disabled = preferences == currentPreferences
+      )
+    }
+  }
+}
+
+@Composable
+private fun FeatureSection(feature: Feature, enableFeature: State<GroupFeatureEnabled>, groupInfo: GroupInfo, onSelected: (GroupFeatureEnabled) -> Unit) {
+  SectionView {
+    if (groupInfo.canEdit) {
+      SectionItemView {
+        ExposedDropDownSettingRow(
+          feature.text(),
+          GroupFeatureEnabled.values().map { it to it.text },
+          enableFeature,
+          icon = feature.icon(false),
+          onSelected = onSelected
+        )
+      }
+    } else {
+      InfoRow(
+        feature.text(),
+        enableFeature.value.text
+      )
+    }
+  }
+  SectionTextFooter(feature.enableGroupPrefDescription(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)
+    }
+  }
+}

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(
@@ -147,6 +149,7 @@ fun GroupProfileLayout(
           }
 
           LaunchedEffect(Unit) {
+            delay(300)
             focusRequester.requestFocus()
           }
         }

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

@@ -16,6 +16,7 @@ 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.durationToString
 
 @Composable
 fun CICallItemView(cInfo: ChatInfo, cItem: ChatItem, status: CICallStatus, duration: Int, acceptCall: (Contact) -> Unit) {
@@ -24,7 +25,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 +39,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(durationToString(duration), color = HighOrLowlight)
       }
       CICallStatus.Error -> {}
     }

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

@@ -0,0 +1,31 @@
+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.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+
+@Composable
+fun CIChatFeatureView(
+  chatItem: ChatItem,
+  feature: Feature,
+  iconColor: Color
+) {
+  Row(
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(feature.icon(true), feature.text(), Modifier.size(15.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,45 @@ 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) {
   Surface {
     Row(
       Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
       verticalAlignment = Alignment.Bottom
     ) {
       Text(
-        buildAnnotatedString {
-          val memberDisplayName = ci.memberDisplayName
-          if (memberDisplayName != null) {
-            withGroupEventStyle(this, memberDisplayName)
-            append(" ")
-          }
-          withGroupEventStyle(this, ci.content.text)
-          append(" ")
-          withGroupEventStyle(this, ci.timestampText)
-        },
+        chatEventText(ci),
         style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp)
       )
     }
   }
 }
 
+private fun withGroupEventStyle(builder: AnnotatedString.Builder, text: String) {
+  return builder.withStyle(SpanStyle(fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)) { append(text) }
+}
+
+fun chatEventText(ci: ChatItem): AnnotatedString =
+  buildAnnotatedString {
+    val memberDisplayName = ci.memberDisplayName
+    if (memberDisplayName != null) {
+      withGroupEventStyle(this, memberDisplayName)
+      append(" ")
+    }
+    withGroupEventStyle(this, ci.content.text)
+    append(" ")
+    withGroupEventStyle(this, 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/CIFileView.kt

@@ -2,7 +2,6 @@ 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.RoundedCornerShape
 import androidx.compose.material.*
@@ -39,7 +38,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
@@ -105,7 +104,7 @@ fun CIFileView(
   fun progressIndicator() {
     CircularProgressIndicator(
       Modifier.size(32.dp),
-      color = if (isSystemInDarkTheme()) FileDark else FileLight,
+      color = if (isInDarkTheme()) FileDark else FileLight,
       strokeWidth = 4.dp
     )
   }
@@ -206,6 +205,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,7 @@
+package chat.simplex.app.views.chat.item
+
 import android.graphics.Bitmap
+import android.os.Build.VERSION.SDK_INT
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
@@ -6,26 +9,39 @@ import androidx.compose.material.CircularProgressIndicator
 import androidx.compose.material.Icon
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.outlined.ArrowDownward
 import androidx.compose.material.icons.outlined.MoreHoriz
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
+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.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.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
 ) {
@@ -65,12 +81,25 @@ fun CIImageView(
               color = Color.White,
               strokeWidth = 2.dp
             )
+          CIFileStatus.RcvInvitation ->
+            Icon(
+              Icons.Outlined.ArrowDownward,
+              stringResource(R.string.icon_descr_asked_to_receive),
+              Modifier.fillMaxSize(),
+              tint = Color.White
+            )
           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 +108,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 +117,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 <= MAX_FILE_SIZE
+    }
+    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,7 +174,14 @@ 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(MAX_FILE_SIZE))
+                )
+              }
             CIFileStatus.RcvAccepted ->
               AlertManager.shared.showAlertMsg(
                 generalGetString(R.string.waiting_for_image),
@@ -119,3 +198,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/CIMetaView.kt

@@ -1,8 +1,7 @@
 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.runtime.Composable
@@ -16,7 +15,7 @@ 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 chat.simplex.app.ui.theme.WarningYellow
 import kotlinx.datetime.Clock
 
 @Composable
@@ -53,10 +52,10 @@ fun CIStatusView(status: CIStatus, metaColor: Color = HighOrLowlight) {
       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)
+      Icon(Icons.Filled.WarningAmber, stringResource(R.string.icon_descr_sent_msg_status_send_failed), Modifier.height(12.dp), tint = WarningYellow)
     }
     is CIStatus.RcvNew -> {
-      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = SimplexBlue)
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = MaterialTheme.colors.primary)
     }
     else -> {}
   }

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

@@ -0,0 +1,243 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.clickable
+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.text.style.TextAlign
+import androidx.compose.ui.unit.*
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun CIVoiceView(
+  providedDurationSec: Int,
+  file: CIFile?,
+  edited: Boolean,
+  sent: Boolean,
+  hasText: Boolean,
+  ci: ChatItem,
+  metaColor: Color,
+  longClick: () -> Unit,
+) {
+  Row(
+    Modifier.padding(top = 4.dp, bottom = 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 time = if (audioPlaying.value) progress.value else duration.value
+      val minWidth = with(LocalDensity.current) { 45.sp.toDp() }
+      val text = durationToString(time / 1000)
+      if (hasText) {
+        VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
+        Text(
+          text,
+          Modifier
+            .padding(start = 12.dp, end = 5.dp)
+            .widthIn(min = minWidth),
+          color = HighOrLowlight,
+          fontSize = 16.sp,
+          textAlign = TextAlign.Start,
+          maxLines = 1
+        )
+      } else {
+        if (sent) {
+          Row {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+              Spacer(Modifier.height(56.dp))
+              Text(
+                text,
+                Modifier
+                  .padding(end = 12.dp)
+                  .widthIn(min = minWidth),
+                color = HighOrLowlight,
+                fontSize = 16.sp,
+                maxLines = 1
+              )
+            }
+            Column {
+              VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
+              Box(Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp)) {
+                CIMetaView(ci, metaColor)
+              }
+            }
+          }
+        } 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, metaColor)
+              }
+            }
+            Row(verticalAlignment = Alignment.CenterVertically) {
+              Text(
+                text,
+                Modifier
+                  .padding(start = 12.dp)
+                  .widthIn(min = minWidth),
+                color = HighOrLowlight,
+                fontSize = 16.sp,
+                maxLines = 1
+              )
+              Spacer(Modifier.height(56.dp))
+            }
+          }
+        }
+      }
+    } else {
+      VoiceMsgIndicator(null, false, sent, hasText, null, null, false, {}, {}, longClick)
+      val metaReserve = if (edited)
+        "                     "
+      else
+        "                 "
+      Text(metaReserve)
+    }
+  }
+}
+
+@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.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 == CIFileStatus.RcvInvitation
+      || file?.fileStatus == CIFileStatus.RcvTransfer
+      || file?.fileStatus == 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)
+    }
+  }
+}
+
+private 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,5 @@
 package chat.simplex.app.views.chat.item
 
-import android.content.*
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -18,6 +17,7 @@ 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.SimpleXTheme
@@ -28,20 +28,21 @@ import kotlinx.datetime.Clock
 
 @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,
   joinGroup: (Long) -> Unit,
-  acceptCall: (Contact) -> Unit
+  acceptCall: (Contact) -> Unit,
+  scrollToItem: (Long) -> 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) }
@@ -52,17 +53,28 @@ fun ChatItemView(
       .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.string}")
+        }
+        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)
         } else {
           val onLinkLongClick = { _: String -> showMenu.value = true }
-          FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile, onLinkLongClick)
+          FramedItemView(cInfo, cItem, uriHandler, imageProvider, showMember = showMember, linkMode = linkMode, showMenu, receiveFile, onLinkLongClick, scrollToItem)
         }
         DropdownMenu(
           expanded = showMenu.value,
@@ -78,27 +90,32 @@ fun ChatItemView(
             showMenu.value = false
           })
           ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
-            shareText(cxt, cItem.content.text)
+            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.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.MCFile || cItem.content.msgContent is MsgContent.MCVoice) {
             val filePath = getLoadedFilePath(context, cItem.file)
             if (filePath != null) {
               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.MCVoice -> saveFileLauncher.launch(cItem.file?.fileName)
                   else -> {}
                 }
                 showMenu.value = false
               })
             }
           }
-          if (cItem.meta.editable) {
+          if (cItem.meta.editable && cItem.content.msgContent !is MsgContent.MCVoice) {
             ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
               composeState.value = ComposeState(editingItem = cItem, useLinkPreviews = useLinkPreviews)
               showMenu.value = false
@@ -147,10 +164,17 @@ fun ChatItemView(
         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.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.RcvGroupFeature -> CIChatFeatureView(cItem, c.feature, c.preference.enable.iconColor)
+        is CIContent.SndGroupFeature -> CIChatFeatureView(cItem, c.feature, c.preference.enable.iconColor)
+        is CIContent.RcvChatFeatureRejected -> CIChatFeatureView(cItem, c.feature, Color.Red)
       }
     }
   }
@@ -164,7 +188,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)
@@ -183,13 +208,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 +224,30 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteM
   )
 }
 
+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 = {},
       joinGroup = {},
-      acceptCall = { _ -> }
+      acceptCall = { _ -> },
+      scrollToItem = {},
     )
   }
 }
@@ -225,16 +257,16 @@ 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 = {},
       joinGroup = {},
-      acceptCall = { _ -> }
+      acceptCall = { _ -> },
+      scrollToItem = {},
     )
   }
 }

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

@@ -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,25 +1,25 @@
 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.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.layout.*
 import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 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.*
@@ -34,16 +34,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
 
+  fun membership(): GroupMember? {
+    return if (chatInfo is ChatInfo.Group) chatInfo.groupInfo.membership else null
+  }
+
   @Composable
   fun ciQuotedMsgView(qi: CIQuote) {
     Box(
@@ -51,8 +58,9 @@ 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
       )
     }
   }
@@ -63,6 +71,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 +89,17 @@ fun FramedItemView(
             modifier = Modifier.size(68.dp).clipToBounds()
           )
         }
-        is MsgContent.MCFile -> {
+        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 +107,78 @@ 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 != "") {
+      CIMarkdownText(ci, showMember, linkMode = linkMode, uriHandler)
+    }
+  }
+
+  val transparentBackground = (ci.content.msgContent is MsgContent.MCImage || ci.content.msgContent is MsgContent.MCVoice) && 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) {
+          ci.quotedItem?.let { ciQuoteView(it) }
+          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("")
+              }
             }
-          }
-        } else {
-          Column(Modifier.fillMaxWidth()) {
+          } else {
             when (val mc = ci.content.msgContent) {
               is MsgContent.MCImage -> {
-                CIImageView(image = mc.image, file = ci.file, showMenu, receiveFile)
+                CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, receiveFile)
                 if (mc.text == "") {
                   metaColor = Color.White
                 } else {
-                  CIMarkdownText(ci, showMember, uriHandler)
+                  CIMarkdownText(ci, showMember, linkMode, uriHandler)
                 }
               }
-              is MsgContent.MCFile -> {
-                CIFileView(ci.file, ci.meta.itemEdited, receiveFile)
+              is MsgContent.MCVoice -> {
+                CIVoiceView(mc.duration, ci.file, ci.meta.itemEdited, ci.chatDir.sent, mc.text != "" || ci.quotedItem != null, ci, metaColor, longClick = { onLinkLongClick("") })
                 if (mc.text != "") {
-                  CIMarkdownText(ci, showMember, uriHandler)
+                  CIMarkdownText(ci, showMember, linkMode, uriHandler)
                 }
               }
+              is MsgContent.MCFile -> ciFileView(ci, mc.text)
+              is MsgContent.MCUnknown ->
+                if (ci.file == null) {
+                  CIMarkdownText(ci, showMember, linkMode, uriHandler, onLinkLongClick)
+                } else {
+                  ciFileView(ci, mc.text)
+                }
               is MsgContent.MCLink -> {
                 ChatItemLinkView(mc.preview)
-                CIMarkdownText(ci, showMember, uriHandler, onLinkLongClick)
+                CIMarkdownText(ci, showMember, linkMode, uriHandler, onLinkLongClick)
               }
-              else -> CIMarkdownText(ci, showMember, uriHandler, onLinkLongClick)
+              else -> CIMarkdownText(ci, showMember, linkMode, uriHandler, onLinkLongClick)
             }
           }
         }
       }
-      Box(Modifier.padding(bottom = 6.dp, end = 12.dp)) {
-        CIMetaView(ci, metaColor)
+      if (ci.content.msgContent !is MsgContent.MCVoice || ci.content.text.isNotEmpty()) {
+        Box(Modifier.padding(bottom = 6.dp, end = 12.dp)) {
+          CIMetaView(ci, metaColor)
+        }
       }
     }
   }
@@ -155,18 +188,50 @@ fun FramedItemView(
 fun CIMarkdownText(
   ci: ChatItem,
   showMember: Boolean,
+  linkMode: SimplexLinkMode,
   uriHandler: UriHandler?,
   onLinkLongClick: (link: String) -> Unit = {}
 ) {
   Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
     MarkdownText(
       ci.content.text, ci.formattedText, if (showMember) ci.memberDisplayName else null,
-      metaText = ci.timestampText, edited = ci.meta.itemEdited,
+      metaText = ci.timestampText, edited = ci.meta.itemEdited, linkMode = linkMode,
       uriHandler = uriHandler, senderBold = true, onLinkLongClick = onLinkLongClick
     )
   }
 }
 
+const val CHAT_IMAGE_LAYOUT_ID = "chatImage"
+
+@Composable
+fun PriorityLayout(
+  modifier: Modifier = Modifier,
+  priorityLayoutId: String,
+  content: @Composable () -> Unit
+) {
+  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 ?: constraints.maxWidth)) }
+    // Limit width for every other element to width of important element and height for a sum of all elements
+    layout(imagePlaceable?.measuredWidth ?: placeables.maxOf { it.width }, placeables.sumOf { it.height }) {
+      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 +242,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 +259,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 +276,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 +284,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 +297,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 +306,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 +319,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 +328,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 +348,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 +357,7 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -306,7 +377,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 +386,7 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
         quotedItem = ciQuote,
         itemEdited = edited
       ),
+      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -333,7 +405,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 +414,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,153 @@
+package chat.simplex.app.views.chat.item
+
 import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Build
 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.runtime.*
 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.LocalContext
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.stringResource
 import chat.simplex.app.R
+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 kotlinx.coroutines.launch
+import kotlin.math.absoluteValue
 
+interface ImageGalleryProvider {
+  val initialIndex: Int
+  val totalImagesSize: MutableState<Int>
+  fun getImage(index: Int): Pair<Bitmap, Uri>?
+  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.getImage(provider.initialIndex - 1) == null) {
+      provider.scrollToStart()
+      pagerState.scrollToPage(0)
+    }
+  }
+  val scope = rememberCoroutineScope()
+  HorizontalPager(count = remember { provider.totalImagesSize }.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 image = provider.getImage(index)
+      if (image == 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.totalImagesSize.value = settledCurrentPage + 1
+              index + 1 -> {
+                provider.scrollToStart()
+                pagerState.scrollToPage(0)
               }
             }
-          )
+          }
         }
-        .fillMaxSize(),
-    )
+      } else {
+        val (imageBitmap: Bitmap, uri: Uri) = image
+        var scale by remember { mutableStateOf(1f) }
+        var translationX by remember { mutableStateOf(0f) }
+        var translationY by remember { mutableStateOf(0f) }
+        var viewWidth by remember { mutableStateOf(0) }
+        var allowTranslate by remember { mutableStateOf(true) }
+        LaunchedEffect(settledCurrentPage) {
+          scale = 1f
+          translationX = 0f
+          translationY = 0f
+        }
+        // I'm making a new instance of imageLoader here because if I use one instance in multiple places
+        // after end of composition here a GIF from the first instance will be paused automatically which isn't what I want
+        val imageLoader = ImageLoader.Builder(LocalContext.current)
+          .components {
+            if (Build.VERSION.SDK_INT >= 28) {
+              add(ImageDecoderDecoder.Factory())
+            } else {
+              add(GifDecoder.Factory())
+            }
+          }
+          .build()
+        Image(
+          rememberAsyncImagePainter(
+            ImageRequest.Builder(LocalContext.current).data(data = uri).size(Size.ORIGINAL).build(),
+            placeholder = BitmapPainter(imageBitmap.asImageBitmap()), // show original image while it's still loading by coil
+            imageLoader = imageLoader
+          ),
+          contentDescription = stringResource(R.string.image_descr),
+          contentScale = ContentScale.Fit,
+          modifier = Modifier
+            .onGloballyPositioned {
+              viewWidth = it.size.width
+            }
+            .graphicsLayer(
+              scaleX = scale,
+              scaleY = scale,
+              translationX = translationX,
+              translationY = translationY,
+            )
+            .pointerInput(Unit) {
+              detectTransformGestures(
+                { allowTranslate },
+                onGesture = { _, pan, gestureZoom, _ ->
+                  scale = (scale * gestureZoom).coerceIn(1f, 20f)
+                  allowTranslate = viewWidth * (scale - 1f) - ((translationX + pan.x * scale).absoluteValue * 2) > 0
+                  if (scale > 1 && allowTranslate) {
+                    translationX += pan.x * scale
+                    translationY += pan.y * scale
+                  } else if (allowTranslate) {
+                    translationX = 0f
+                    translationY = 0f
+                  }
+                }
+              )
+            }
+            .fillMaxSize(),
+        )
+      }
+    }
   }
 }

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

@@ -7,11 +7,13 @@ import androidx.compose.runtime.*
 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.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.model.*
 import chat.simplex.app.views.helpers.detectGesture
 
@@ -48,53 +50,75 @@ fun MarkdownText (
   uriHandler: UriHandler? = null,
   senderBold: Boolean = false,
   modifier: Modifier = Modifier,
+  linkMode: SimplexLinkMode,
   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)
-  } 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) }
+  val textLayoutDirection = remember (text) {
+    if (BidiFormatter.getInstance().isRtl(text.subSequence(0, kotlin.math.min(50, text.length)))) LayoutDirection.Rtl else LayoutDirection.Ltr
+  }
+  val reserve = when {
+    textLayoutDirection != LocalLayoutDirection.current && metaText != null -> "\n"
+    edited -> "        "
+    else -> "    "
+  }
+  CompositionLocalProvider(
+    LocalLayoutDirection provides if (textLayoutDirection != LocalLayoutDirection.current)
+      if (LocalLayoutDirection.current == LayoutDirection.Ltr) LayoutDirection.Rtl else LayoutDirection.Ltr
+    else
+      LocalLayoutDirection.current
+  ) {
+    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)
+    } 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(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) }
             }
-          } else {
-            withStyle(ft.format.style) { append(ft.text) }
           }
         }
+        // With RTL language set globally links looks bad sometimes, better to add a new line to bo sure everything looks good
+        /*if (metaText != null && hasLinks && LocalLayoutDirection.current == LayoutDirection.Rtl)
+          withStyle(reserveTimestampStyle) { append("\n" + metaText) }
+        else */if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
+      }
+      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()
+          }
+        )
+      } else {
+        Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
       }
-      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()
-        }
-      )
-    } else {
-      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
     }
   }
 }

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

@@ -5,6 +5,7 @@ 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
@@ -15,30 +16,32 @@ import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 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.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 = chatModel.controller.appPrefs.simplexLinkMode.get()
+  LaunchedEffect(chat.id) {
     showMenu.value = false
     delay(500L)
-    showMarkRead = chat.chatStats.unreadCount > 0
   }
   when (chat.chatInfo) {
     is ChatInfo.Direct ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, stopped) },
+        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped, linkMode) },
         click = { directChatAction(chat.chatInfo, chatModel) },
         dropdownMenuItems = { ContactMenuItems(chat, chatModel, showMenu, showMarkRead) },
         showMenu,
@@ -46,7 +49,7 @@ fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
       )
     is ChatInfo.Group ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, stopped) },
+        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped, linkMode) },
         click = { groupChatAction(chat.chatInfo.groupInfo, chatModel) },
         dropdownMenuItems = { GroupMenuItems(chat, chat.chatInfo.groupInfo, chatModel, showMenu, showMarkRead) },
         showMenu,
@@ -54,7 +57,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,7 +66,11 @@ 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
@@ -96,7 +103,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 +125,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 +137,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 +173,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 +225,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 +236,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 +249,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,8 +278,9 @@ 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)
       showMenu.value = false
@@ -235,25 +299,66 @@ 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)
+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,7 +366,7 @@ 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),
+    confirmText = if (chatModel.incognito.value) generalGetString(R.string.accept_contact_incognito_button) else generalGetString(R.string.accept_contact_button),
     onConfirm = { acceptContactRequest(contactRequest, chatModel) },
     dismissText = generalGetString(R.string.reject_contact_button),
     onDismiss = { rejectContactRequest(contactRequest, chatModel) }
@@ -302,14 +407,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 +422,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 +435,7 @@ fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel
         AlertManager.shared.hideAlert()
         if (chatModel.controller.apiDeleteChat(ChatType.ContactConnection, connection.apiId)) {
           chatModel.removeChat(connection.id)
+          onSuccess()
         }
       }
     }
@@ -358,13 +464,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 +497,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 +535,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 +585,10 @@ fun PreviewChatListNavLinkDirect() {
             ),
             chatStats = Chat.ChatStats()
           ),
-          stopped = false
+          false,
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},
@@ -478,7 +623,10 @@ fun PreviewChatListNavLinkGroup() {
             ),
             chatStats = Chat.ChatStats()
           ),
-          stopped = false
+          false,
+          null,
+          stopped = false,
+          linkMode = SimplexLinkMode.DESCRIPTION
         )
       },
       click = {},
@@ -500,7 +648,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,224 @@
 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.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.Path
+import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.capitalize
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.intl.Locale
 import androidx.compose.ui.unit.dp
 import 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.usersettings.SettingsView
-import kotlinx.coroutines.CoroutineScope
+import chat.simplex.app.views.usersettings.simplexTeamUri
+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 = NewChatSheetState.saver()) { mutableStateOf(MutableStateFlow(NewChatSheetState.GONE)) }
+  val showNewChatSheet = {
+    newChatSheetState.value = NewChatSheetState.VISIBLE
   }
-  BottomSheetScaffold(
-    scaffoldState = scaffoldCtrl.state,
+  val hideNewChatSheet: (animated: Boolean) -> Unit = { animated ->
+    if (animated) newChatSheetState.value = NewChatSheetState.HIDING
+    else newChatSheetState.value = NewChatSheetState.GONE
+  }
+  LaunchedEffect(chatModel.clearOverlays.value) {
+    if (chatModel.clearOverlays.value && newChatSheetState.value.isVisible()) hideNewChatSheet(false)
+  }
+  var searchInList by rememberSaveable { mutableStateOf("") }
+  val scaffoldState = rememberScaffoldState()
+  Scaffold(
+    topBar = { ChatListToolbar(chatModel, scaffoldState.drawerState, 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)
+          ChatList(chatModel, search = searchInList)
         } else {
-          MakeConnection(chatModel)
+          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)
+  }
 }
 
 @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.openUri(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, 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
+        NavigationButtonMenu { scope.launch { if (drawerState.isOpen) drawerState.close() else drawerState.open() } }
+    },
+    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))
 }
 
+private var lazyListState = 0 to 0
+
 @Composable
-fun ChatList(chatModel: ChatModel) {
+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,31 @@ 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.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Cancel
-import androidx.compose.material.icons.outlined.ErrorOutline
+import androidx.compose.material.icons.filled.NotificationsOff
+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.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 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.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, chatModelIncognito: Boolean, currentUserProfileDisplayName: String?, stopped: Boolean, linkMode: SimplexLinkMode) {
   val cInfo = chat.chatInfo
 
   @Composable
@@ -71,7 +70,7 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
         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 +79,20 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
   }
 
   @Composable
-  fun chatPreviewText() {
+  fun chatPreviewText(chatModelIncognito: Boolean) {
     val ci = chat.chatItems.lastOrNull()
     if (ci != null) {
       MarkdownText(
-        ci.text, ci.formattedText, ci.memberDisplayName,
-        metaText = ci.timestampText,
+        ci.text,
+        ci.formattedText,
+        sender = if (cInfo is ChatInfo.Group && !ci.chatDir.sent) ci.memberDisplayName else null,
+        linkMode = linkMode,
+        senderBold = true,
+        metaText = null,
         maxLines = 2,
         overflow = TextOverflow.Ellipsis,
-        style = MaterialTheme.typography.body1.copy(color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+        style = MaterialTheme.typography.body1.copy(color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+        modifier = Modifier.fillMaxWidth(),
       )
     } else {
       when (cInfo) {
@@ -98,7 +102,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 +124,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,22 +141,38 @@ 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(
@@ -163,6 +186,21 @@ fun ChatPreviewView(chat: Chat, stopped: Boolean) {
   }
 }
 
+@Composable
+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(chat: Chat) {
   val s = chat.serverInfo.networkStatus
@@ -195,6 +233,6 @@ fun ChatStatusImage(chat: Chat) {
 @Composable
 fun PreviewChatPreviewView() {
   SimpleXTheme {
-    ChatPreviewView(Chat.sampleData, stopped = false)
+    ChatPreviewView(Chat.sampleData, false, "", 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 -> {}
+  }
+}
+
+@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,138 @@
+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.*
+
+@Composable
+fun ShareListView(chatModel: ChatModel, stopped: Boolean) {
+  var searchInList by rememberSaveable { mutableStateOf("") }
+  Scaffold(
+    topBar = { Column { ShareListToolbar(chatModel, 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()
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun EmptyList() {
+  Box {
+    Text(stringResource(R.string.you_have_no_chats), Modifier.align(Alignment.Center), color = HighOrLowlight)
+  }
+}
+
+@Composable
+private fun ShareListToolbar(chatModel: ChatModel, 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,
+        )
+      }
+    }
+  }
+
+  DefaultTopAppBar(
+    navigationButton = { if (showSearch) NavigationButtonBack(hideSearchOnBack) else NavigationButtonBack { chatModel.sharedContent.value = null } },
+    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/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,507 @@
+package chat.simplex.app.views.database
+
+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.dp
+import androidx.compose.ui.unit.sp
+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.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) {
+        DatabaseKeyField(
+          currentKey,
+          generalGetString(R.string.current_passphrase),
+          modifier = Modifier.padding(horizontal = DEFAULT_PADDING),
+          isValid = ::validKey,
+          keyboardActions = KeyboardActions(onNext = { defaultKeyboardAction(ImeAction.Next) }),
+        )
+      }
+
+      DatabaseKeyField(
+        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
+
+      DatabaseKeyField(
+        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)
+        }),
+      )
+
+      SectionItemViewSpaceBetween(onClickUpdate, disabled = disabled) {
+        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,
+  onCheckedChange: (Boolean) -> Unit,
+) {
+  SectionItemView {
+    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 DatabaseKeyField(
+  key: MutableState<String>,
+  placeholder: String,
+  modifier: Modifier = Modifier,
+  showStrength: Boolean = false,
+  isValid: (String) -> Boolean,
+  keyboardActions: KeyboardActions = KeyboardActions(),
+) {
+  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
+      )
+    }
+  )
+}
+
+// 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,250 @@
+package chat.simplex.app.views.database
+
+import SectionSpacer
+import SectionView
+import android.content.Context
+import android.util.Log
+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.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.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)) }
+  val saveAndRunChatOnClick: () -> Unit = {
+    DatabaseUtils.setDatabaseKey(dbKey.value)
+    storedDBKey = dbKey.value
+    appPreferences.storeDBPassphrase.set(true)
+    useKeychain = true
+    appPreferences.initialRandomDBPassphrase.set(false)
+    runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences)
+  }
+  val title = when (chatDbStatus.value) {
+    is DBMigrationResult.OK -> ""
+    is DBMigrationResult.ErrorNotADatabase -> if (useKeychain && !storedDBKey.isNullOrEmpty())
+      generalGetString(R.string.wrong_passphrase)
+    else
+      generalGetString(R.string.encrypted_database)
+    is DBMigrationResult.Error -> generalGetString(R.string.database_error)
+    is DBMigrationResult.ErrorKeychain -> generalGetString(R.string.keychain_error)
+    is DBMigrationResult.Unknown -> generalGetString(R.string.database_error)
+    null -> "" // should never be here
+  }
+
+  Column(
+    Modifier.fillMaxSize().verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+    verticalArrangement = Arrangement.Center,
+  ) {
+    Text(
+      title,
+      Modifier.padding(start = 16.dp, top = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+    SectionView(null, padding = PaddingValues(horizontal = DEFAULT_PADDING, vertical = DEFAULT_PADDING_HALF)) {
+      val buttonEnabled = validKey(dbKey.value) && !progressIndicator.value
+      when (val status = chatDbStatus.value) {
+        is DBMigrationResult.ErrorNotADatabase -> {
+          if (useKeychain && !storedDBKey.isNullOrEmpty()) {
+            Text(generalGetString(R.string.passphrase_is_different))
+            DatabaseKeyField(dbKey, buttonEnabled) {
+              saveAndRunChatOnClick()
+            }
+            SaveAndOpenButton(buttonEnabled, saveAndRunChatOnClick)
+            SectionSpacer()
+            Text(String.format(generalGetString(R.string.file_with_path), status.dbFile))
+          } else {
+            Text(generalGetString(R.string.database_passphrase_is_required))
+            DatabaseKeyField(dbKey, buttonEnabled) {
+              if (useKeychain) saveAndRunChatOnClick() else runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences)
+            }
+            if (useKeychain) {
+              SaveAndOpenButton(buttonEnabled, saveAndRunChatOnClick)
+            } else {
+              OpenChatButton(buttonEnabled) { runChat(dbKey.value, chatDbStatus, progressIndicator, appPreferences) }
+            }
+          }
+        }
+        is DBMigrationResult.Error -> {
+          Text(String.format(generalGetString(R.string.file_with_path), status.dbFile))
+          Text(String.format(generalGetString(R.string.error_with_info), status.migrationError))
+        }
+        is DBMigrationResult.ErrorKeychain -> {
+          Text(generalGetString(R.string.cannot_access_keychain))
+        }
+        is DBMigrationResult.Unknown -> {
+          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,
+  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)
+  } 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.Error -> {
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.database_error), status.migrationError)
+    }
+    is DBMigrationResult.ErrorKeychain -> {
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.keychain_error))
+    }
+    is DBMigrationResult.Unknown -> {
+      AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), status.json)
+    }
+    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())
+  }
+}
+
+@Composable
+private fun DatabaseKeyField(text: MutableState<String>, enabled: Boolean, onClick: (() -> Unit)? = null) {
+  DatabaseKeyField(
+    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

@@ -15,10 +15,11 @@ 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
@@ -28,17 +29,19 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 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 java.io.*
 import java.text.SimpleDateFormat
 import java.util.*
+import kotlin.collections.ArrayList
 
 @Composable
 fun DatabaseView(
@@ -49,19 +52,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 +76,30 @@ 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,
+      appFilesCountAndSize,
+      chatItemTTL,
+      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 +124,59 @@ 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,
+  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
+  chatItemTTL: MutableState<ChatItemTTL>,
   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()),
     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.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()
       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 +185,7 @@ fun DatabaseLayout(
         stringResource(R.string.import_database),
         { importArchiveLauncher.launch("application/zip") },
         textColor = Color.Red,
+        iconColor = Color.Red,
         disabled = operationsDisabled
       )
       SectionDivider()
@@ -164,28 +207,91 @@ 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.data_section)) {
+      SectionItemView { TtlOptions(chatItemTTL, enabled = rememberUpdatedState(!progressIndicator && !chatDbChanged), onChatItemTTLSelected) }
+      SectionDivider()
+      val deleteFilesDisabled = operationsDisabled || appFilesCountAndSize.value.first == 0
+      SectionItemView(
+        deleteAppFilesAndMedia,
+        disabled = deleteFilesDisabled
+      ) {
+        Text(
+          stringResource(R.string.delete_files_and_media),
+          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))
       }
     )
   }
 }
 
+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 +301,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 +323,6 @@ fun RunChatSetting(
           checkedThumbColor = MaterialTheme.colors.primary,
           uncheckedThumbColor = HighOrLowlight
         ),
-        enabled = !chatDbChanged
       )
     }
   }
@@ -228,16 +333,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 +367,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 +489,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 +506,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 +537,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))
           }
@@ -429,6 +591,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 +605,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 +681,23 @@ 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,
+      appFilesCountAndSize = remember { mutableStateOf(0 to 0L) },
+      chatItemTTL = remember { mutableStateOf(ChatItemTTL.None) },
       startChat = {},
       stopChatAlert = {},
       exportArchive = {},
       deleteChatAlert = {},
-      showSettingsModal = { {} }
+      deleteAppFilesAndMedia = {},
+      showSettingsModal = { {} },
+      onChatItemTTLSelected = {},
     )
   }
 }

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

@@ -1,25 +1,28 @@
 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.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Dialog
 import chat.simplex.app.R
 import chat.simplex.app.TAG
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
 
 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 +41,50 @@ class AlertManager {
     }
   }
 
+  fun showAlertDialogButtonsColumn(
+    title: String,
+    text: String? = null,
+    buttons: @Composable () -> Unit,
+  ) {
+    showAlert {
+      Dialog(onDismissRequest = this::hideAlert) {
+        Column(Modifier.background(MaterialTheme.colors.background)) {
+          Text(title, Modifier.padding(DEFAULT_PADDING), fontSize = 18.sp)
+          if (text != null) {
+            Text(text)
+          }
+          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) }
@@ -79,7 +104,7 @@ class AlertManager {
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onConfirm?.invoke()
             hideAlert()
           }) { Text(confirmText) }
@@ -88,9 +113,16 @@ 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 {

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

@@ -3,37 +3,46 @@ 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 (
+  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
+        .width(TitleInsetWithIcon - AppBarHorizontalPadding)
+        .padding(top = 4.dp), // Like in DefaultAppBar
+      content = { NavigationButtonBack(close) }
+    )
   }
 }
 
+@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,73 @@
+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("errorNotADatabase") class ErrorNotADatabase(val dbFile: String): DBMigrationResult()
+  @Serializable @SerialName("error") class Error(val dbFile: String, val migrationError: String): DBMigrationResult()
+  @Serializable @SerialName("errorKeychain") object ErrorKeychain: DBMigrationResult()
+  @Serializable @SerialName("unknown") class Unknown(val json: String): DBMigrationResult()
+}

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,121 @@
+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), 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 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,38 @@
+package chat.simplex.app.views.helpers
+
+import android.graphics.Bitmap
+import android.net.Uri
+import androidx.compose.runtime.saveable.Saver
+import kotlinx.coroutines.flow.MutableStateFlow
+
+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 NewChatSheetState {
+  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<NewChatSheetState>, *> = Saver(
+      save = { it.value.toString() },
+      restore = {
+        MutableStateFlow(valueOf(it))
+      }
+    )
+  }
+}
+
+sealed class UploadContent {
+  data class SimpleImage(val uri: Uri): UploadContent()
+  data class AnimatedImage(val uri: Uri): 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(key: Any, onPress: () -> Unit, onClick: () -> Unit, onCancel: () -> Unit, onRelease: ()-> Unit): MutableInteractionSource {
+  val interactionSource = remember(key) { 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,7 @@ 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.pm.PackageManager
 import android.graphics.*
 import android.net.Uri
@@ -20,8 +19,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 +31,12 @@ 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.ComposeState
+import chat.simplex.app.views.chat.PickFromGallery
 import chat.simplex.app.views.newchat.ActionButton
+import kotlinx.serialization.builtins.*
+import kotlinx.serialization.decodeFromString
 import java.io.ByteArrayOutputStream
 import java.io.File
 import kotlin.math.min
@@ -65,26 +70,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 +111,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)
+    // 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 +125,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 +158,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,24 +173,32 @@ 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)
+
 @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
+      imageBitmap.value = uri
       onImageChange(bitmap)
     }
   }
-  val cameraLauncher = rememberCameraLauncher { bitmap: Bitmap? ->
-    if (bitmap != null) {
-      imageBitmap.value = bitmap
+  val galleryLauncher = rememberLauncherForActivityResult(contract = PickFromGallery()) { processPickedImage(it) }
+  val galleryLauncherFallback = rememberGetContentLauncher { processPickedImage(it) }
+  val cameraLauncher = rememberCameraLauncher { uri: Uri? ->
+    if (uri != null) {
+      imageBitmap.value = uri
+      val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, uri)
+      val bitmap = ImageDecoder.decodeBitmap(source)
       onImageChange(bitmap)
     }
   }
@@ -213,7 +237,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,22 +2,24 @@ 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,
   content: @Composable () -> Unit,
 ) {
   BackHandler(onBack = close)
@@ -30,35 +32,108 @@ fun ModalView(
 }
 
 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, content: @Composable () -> Unit) {
+    showCustomModal { close ->
+      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, 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()
   }

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

@@ -1,7 +1,15 @@
 package chat.simplex.app.views.helpers
 
+import androidx.compose.foundation.gestures.Orientation
+import androidx.compose.foundation.layout.offset
+import androidx.compose.material.*
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.layout.layout
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.LayoutDirection
+import kotlin.math.roundToInt
 
 fun Modifier.badgeLayout() =
   layout { measurable, constraints ->
@@ -15,3 +23,22 @@ fun Modifier.badgeLayout() =
       placeable.place((width - placeable.width) / 2, 0)
     }
   }
+
+@Composable
+fun SwipeToDismissModifier(
+  state: DismissState,
+  directions: Set<DismissDirection> = setOf(DismissDirection.EndToStart, DismissDirection.StartToEnd),
+  swipeDistance: Float,
+): Modifier {
+  val isRtl = LocalLayoutDirection.current == LayoutDirection.Rtl
+  val anchors = mutableMapOf(0f to DismissValue.Default)
+  if (DismissDirection.StartToEnd in directions) anchors += swipeDistance to DismissValue.DismissedToEnd
+  if (DismissDirection.EndToStart in directions) anchors += -swipeDistance to DismissValue.DismissedToStart
+  return Modifier.swipeable(
+    state = state,
+    anchors = anchors,
+    thresholds = { _, _ -> FractionalThreshold(0.5f) },
+    orientation = Orientation.Horizontal,
+    reverseDirection = isRtl,
+  ).offset { IntOffset(state.offset.value.roundToInt(), 0) }
+}

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

@@ -0,0 +1,240 @@
+package chat.simplex.app.views.helpers
+
+import android.media.*
+import android.media.MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
+import android.os.Build
+import android.util.Log
+import androidx.compose.runtime.*
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatItem
+import kotlinx.coroutines.*
+import java.io.*
+import java.text.SimpleDateFormat
+import java.util.*
+
+interface Recorder {
+  val recordingInProgress: MutableState<Boolean>
+  fun start(onStop: () -> Unit): String
+  fun stop()
+  fun cancel(filePath: String, recordingInProgress: MutableState<Boolean>)
+}
+
+class RecorderNative(private val recordedBytesLimit: Long): Recorder {
+  companion object {
+    // Allows to stop the recorder from outside without having the recorder in a variable
+    var stopRecording: (() -> Unit)? = null
+  }
+  override val recordingInProgress = mutableStateOf(false)
+  private var recorder: MediaRecorder? = null
+  private fun initRecorder() =
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      MediaRecorder(SimplexApp.context)
+    } else {
+      MediaRecorder()
+    }
+
+  override fun start(onStop: () -> Unit): String {
+    AudioPlayer.stop()
+    recordingInProgress.value = true
+    val rec: MediaRecorder
+    recorder = initRecorder().also { rec = it }
+    rec.setAudioSource(MediaRecorder.AudioSource.MIC)
+    rec.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+    rec.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+    rec.setAudioChannels(1)
+    rec.setAudioSamplingRate(16000)
+    rec.setAudioEncodingBitRate(16000)
+    rec.setMaxDuration(-1) // TODO set limit
+    rec.setMaxFileSize(recordedBytesLimit)
+    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+    val filePath = getAppFilePath(SimplexApp.context, uniqueCombine(SimplexApp.context, getAppFilePath(SimplexApp.context, "voice_${timestamp}.m4a")))
+    rec.setOutputFile(filePath)
+    rec.prepare()
+    rec.start()
+    rec.setOnInfoListener { mr, what, extra ->
+      if (what == MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED) {
+        stop()
+        onStop()
+      }
+    }
+    stopRecording = { stop(); onStop() }
+    return filePath
+  }
+
+  override fun stop() {
+    if (!recordingInProgress.value) return
+    stopRecording = null
+    recordingInProgress.value = false
+    recorder?.metrics?.
+    runCatching {
+      recorder?.stop()
+    }
+    runCatching {
+      recorder?.reset()
+    }
+    runCatching {
+      // release all resources
+      recorder?.release()
+    }
+    recorder = null
+  }
+
+  override fun cancel(filePath: String, recordingInProgress: MutableState<Boolean>) {
+    stop()
+    runCatching { File(filePath).delete() }.getOrElse { Log.d(TAG, "Unable to delete a file: ${it.stackTraceToString()}") }
+  }
+}
+
+object AudioPlayer {
+  private val player = MediaPlayer().apply {
+    setAudioAttributes(
+      AudioAttributes.Builder()
+        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+        .setUsage(AudioAttributes.USAGE_MEDIA)
+        .build()
+    )
+  }
+  private val helperPlayer: MediaPlayer =  MediaPlayer().apply {
+        setAudioAttributes(
+          AudioAttributes.Builder()
+            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+            .setUsage(AudioAttributes.USAGE_MEDIA)
+            .build()
+        )
+  }
+  // Filepath: String, onProgressUpdate
+  // onProgressUpdate(null) means stop
+  private val currentlyPlaying: MutableState<Pair<String, (position: Int?) -> Unit>?> = mutableStateOf(null)
+  private var progressJob: Job? = null
+
+  // Returns real duration of the track
+  private fun start(filePath: String, seek: Int? = null, onProgressUpdate: (position: Int?) -> Unit): Int? {
+    if (!File(filePath).exists()) {
+      Log.e(TAG, "No such file: $filePath")
+      return null
+    }
+
+    RecorderNative.stopRecording?.invoke()
+    val current = currentlyPlaying.value
+    if (current == null || current.first != filePath) {
+      stopListener()
+      player.reset()
+      runCatching {
+        player.setDataSource(filePath)
+      }.onFailure {
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), it.message)
+        return null
+      }
+      runCatching { player.prepare() }.onFailure {
+        // Can happen when audio file is broken
+        Log.e(TAG, it.stackTraceToString())
+        AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), it.message)
+        return null
+      }
+    }
+    if (seek != null) player.seekTo(seek)
+    player.start()
+    currentlyPlaying.value = filePath to onProgressUpdate
+    progressJob = CoroutineScope(Dispatchers.Default).launch {
+      onProgressUpdate(player.currentPosition)
+      while(isActive && player.isPlaying) {
+        // Even when current position is equal to duration, the player has isPlaying == true for some time,
+        // so help to make the playback stopped in UI immediately
+        if (player.currentPosition == player.duration) {
+          onProgressUpdate(player.currentPosition)
+          break
+        }
+        delay(50)
+        onProgressUpdate(player.currentPosition)
+      }
+      /*
+      * Since coroutine is still NOT canceled, means player ended (no stop/no pause). But in some cases
+      * the player can show position != duration even if they actually equal.
+      * Let's say to a listener that the position == duration in case of coroutine finished without cancel
+      * */
+      if (isActive) {
+        onProgressUpdate(player.duration)
+      }
+      onProgressUpdate(null)
+    }
+    return player.duration
+  }
+
+  private fun pause(): Int {
+    progressJob?.cancel()
+    progressJob = null
+    player.pause()
+    return player.currentPosition
+  }
+
+  fun stop() {
+    if (!player.isPlaying) return
+    player.stop()
+    stopListener()
+  }
+
+  fun stop(item: ChatItem) = stop(item.file?.fileName)
+
+  // FileName or filePath are ok
+  fun stop(fileName: String?) {
+    if (fileName != null && currentlyPlaying.value?.first?.endsWith(fileName) == true) {
+      stop()
+    }
+  }
+
+  private fun stopListener() {
+    progressJob?.cancel()
+    progressJob = null
+    // Notify prev audio listener about stop
+    currentlyPlaying.value?.second?.invoke(null)
+    currentlyPlaying.value = null
+  }
+
+  fun play(
+    filePath: String?,
+    audioPlaying: MutableState<Boolean>,
+    progress: MutableState<Int>,
+    duration: MutableState<Int>,
+    resetOnStop: Boolean = false
+  ) {
+    if (progress.value == duration.value) {
+      progress.value = 0
+    }
+    val realDuration = start(filePath ?: return, progress.value) { pro ->
+      if (pro != null) {
+        progress.value = pro
+      }
+      if (pro == null || pro == duration.value) {
+        audioPlaying.value = false
+        if (resetOnStop) {
+          progress.value = 0
+        } else if (pro == duration.value) {
+          progress.value = duration.value
+        }
+      }
+    }
+    audioPlaying.value = realDuration != null
+    // Update to real duration instead of what was received in ChatInfo
+    realDuration?.let { duration.value = it }
+  }
+
+  fun pause(audioPlaying: MutableState<Boolean>, pro: MutableState<Int>) {
+    pro.value = pause()
+    audioPlaying.value = false
+  }
+
+  fun duration(filePath: String): Int {
+    var res = 0
+    kotlin.runCatching {
+      helperPlayer.setDataSource(filePath)
+      helperPlayer.prepare()
+      helperPlayer.start()
+      helperPlayer.stop()
+      res = helperPlayer.duration
+      helperPlayer.reset()
+    }
+    return res
+  }
+}

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

@@ -0,0 +1,103 @@
+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.material.TextFieldDefaults.textFieldWithLabelPadding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+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 chat.simplex.app.R
+import kotlinx.coroutines.delay
+
+@OptIn(ExperimentalComposeUiApi::class)
+@Composable
+fun SearchTextField(modifier: Modifier, placeholder: String, onValueChange: (String) -> Unit) {
+  var searchText by rememberSaveable(stateSaver = TextFieldValue.Saver) { mutableStateOf(TextFieldValue("")) }
+  val focusRequester = remember { FocusRequester() }
+  val keyboard = LocalSoftwareKeyboardController.current
+
+  LaunchedEffect(Unit) {
+    focusRequester.requestFocus()
+    delay(200)
+    keyboard?.show()
+  }
+
+  DisposableEffect(Unit) {
+    onDispose {
+      if (searchText.text.isNotEmpty()) onValueChange("")
+    }
+  }
+
+  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 = searchText,
+    modifier = modifier
+      .background(colors.backgroundColor(enabled).value, shape)
+      .indicatorLine(enabled, false, interactionSource, colors)
+      .focusRequester(focusRequester)
+      .defaultMinSize(
+        minWidth = TextFieldDefaults.MinWidth,
+        minHeight = TextFieldDefaults.MinHeight
+      ),
+    onValueChange = {
+      searchText = it
+      onValueChange(it.text)
+    },
+    cursorBrush = SolidColor(colors.cursorColor(false).value),
+    visualTransformation = VisualTransformation.None,
+    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+    singleLine = true,
+    textStyle = TextStyle(
+      color = MaterialTheme.colors.onBackground,
+      fontWeight = FontWeight.Normal,
+      fontSize = 16.sp
+    ),
+    interactionSource = interactionSource,
+    decorationBox = @Composable { innerTextField ->
+      TextFieldDefaults.TextFieldDecorationBox(
+        value = searchText.text,
+        innerTextField = innerTextField,
+        placeholder = {
+          Text(placeholder)
+        },
+        trailingIcon = if (searchText.text.isNotEmpty()) {{
+          IconButton({ searchText = TextFieldValue(""); onValueChange("") }) {
+            Icon(Icons.Default.Close, stringResource(R.string.icon_descr_close_button), tint = MaterialTheme.colors.primary,)
+          }
+        }} else null,
+        singleLine = true,
+        enabled = enabled,
+        interactionSource = interactionSource,
+        contentPadding = textFieldWithLabelPadding(start = 0.dp, end = 0.dp),
+        visualTransformation = VisualTransformation.None,
+        colors = colors
+      )
+    }
+  )
+}

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

@@ -1,57 +1,175 @@
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.material.*
-import androidx.compose.runtime.Composable
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Check
+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.LocalConfiguration
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.*
-import chat.simplex.app.ui.theme.GroupDark
-import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.ValueTitleDesc
+import chat.simplex.app.views.helpers.ValueTitle
 
 @Composable
-fun SectionView(title: String? = null, content: (@Composable () -> Unit)) {
+fun SectionView(title: String? = null, padding: PaddingValues = PaddingValues(), content: (@Composable ColumnScope.() -> Unit)) {
   Column {
     if (title != null) {
       Text(
         title, color = HighOrLowlight, style = MaterialTheme.typography.body2,
-        modifier = Modifier.padding(start = 16.dp, bottom = 5.dp), fontSize = 12.sp
+        modifier = Modifier.padding(start = DEFAULT_PADDING, bottom = 5.dp), fontSize = 12.sp
       )
     }
-    Surface(color = if (isSystemInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
-      Column(Modifier.padding(horizontal = 6.dp).fillMaxWidth()) { content() }
+    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
+      Column(Modifier.padding(padding).fillMaxWidth()) { content() }
     }
   }
 }
 
 @Composable
-fun SectionItemView(click: (() -> Unit)? = null, height: Dp = 46.dp, disabled: Boolean = false, content: (@Composable () -> Unit)) {
+fun SectionView(
+  title: String,
+  icon: ImageVector,
+  iconTint: Color = HighOrLowlight,
+  leadingIcon: Boolean = false,
+  padding: PaddingValues = PaddingValues(),
+  content: (@Composable ColumnScope.() -> Unit)
+) {
+  Column {
+    val iconSize = with(LocalDensity.current) { 21.sp.toDp() }
+    Row(Modifier.padding(start = DEFAULT_PADDING, bottom = 5.dp), verticalAlignment = Alignment.CenterVertically) {
+      if (leadingIcon) Icon(icon, null, Modifier.padding(end = 4.dp).size(iconSize), tint = iconTint)
+      Text(title, color = HighOrLowlight, style = MaterialTheme.typography.body2, fontSize = 12.sp)
+      if (!leadingIcon) Icon(icon, null, Modifier.padding(start = 4.dp).size(iconSize), tint = iconTint)
+    }
+    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
+      Column(Modifier.padding(padding).fillMaxWidth()) { content() }
+    }
+  }
+}
+
+@Composable
+fun <T> SectionViewSelectable(
+  title: String?,
+  currentValue: State<T>,
+  values: List<ValueTitleDesc<T>>,
+  onSelected: (T) -> Unit,
+) {
+  SectionView(title) {
+    LazyColumn {
+      items(values.size) { index ->
+        val item = values[index]
+        SectionItemViewSpaceBetween({ onSelected(item.value) }) {
+          Text(item.title)
+          if (currentValue.value == item.value) {
+            Icon(Icons.Outlined.Check, item.title, tint = MaterialTheme.colors.primary)
+          }
+        }
+        Spacer(Modifier.padding(horizontal = 4.dp))
+      }
+    }
+  }
+  SectionTextFooter(values.first { it.value == currentValue.value }.description)
+}
+
+@Composable
+fun SectionItemView(
+  click: (() -> Unit)? = null,
+  minHeight: Dp = 46.dp,
+  disabled: Boolean = false,
+  content: (@Composable RowScope.() -> Unit)
+) {
   val modifier = Modifier
-    .padding(horizontal = 8.dp)
     .fillMaxWidth()
-    .height(height)
+    .sizeIn(minHeight = minHeight)
   Row(
-    if (click == null || disabled) modifier else modifier.clickable(onClick = click),
+    if (click == null || disabled) modifier.padding(horizontal = DEFAULT_PADDING) else modifier.clickable(onClick = click).padding(horizontal = DEFAULT_PADDING),
     verticalAlignment = Alignment.CenterVertically
   ) {
     content()
   }
 }
 
+@Composable
+fun SectionItemViewSpaceBetween(
+  click: (() -> Unit)? = null,
+  minHeight: Dp = 46.dp,
+  padding: PaddingValues = PaddingValues(horizontal = DEFAULT_PADDING),
+  disabled: Boolean = false,
+  content: (@Composable RowScope.() -> Unit)
+) {
+  val modifier = Modifier
+    .fillMaxWidth()
+    .sizeIn(minHeight = minHeight)
+  Row(
+    if (click == null || disabled) modifier.padding(padding) else modifier.clickable(onClick = click).padding(padding),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    content()
+  }
+}
+
+@Composable
+fun <T> SectionItemWithValue(
+  title: String,
+  currentValue: State<T>,
+  values: List<ValueTitle<T>>,
+  label: String? = null,
+  icon: ImageVector? = null,
+  iconTint: Color = HighOrLowlight,
+  enabled: State<Boolean> = mutableStateOf(true),
+  onSelected: () -> Unit
+) {
+  SectionItemView(click = if (enabled.value) onSelected else null) {
+    if (icon != null) {
+      Icon(
+        icon,
+        title,
+        Modifier.padding(end = 8.dp),
+        tint = iconTint
+      )
+    }
+    Text(title, color = if (enabled.value) Color.Unspecified else HighOrLowlight)
+
+    Spacer(Modifier.fillMaxWidth().weight(1f))
+
+    Row(
+      Modifier.padding(start = 10.dp),
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.End
+    ) {
+      Text(
+        values.first { it.value == currentValue.value }.title + (if (label != null) " $label" else ""),
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        color = HighOrLowlight
+      )
+    }
+  }
+}
+
 @Composable
 fun SectionTextFooter(text: String) {
   Text(
     text,
-    Modifier.padding(horizontal = 16.dp).padding(top = 5.dp).fillMaxWidth(0.9F),
+    Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = DEFAULT_PADDING_HALF).fillMaxWidth(0.9F),
     color = HighOrLowlight,
-    fontSize = 12.sp
+    lineHeight = 18.sp,
+    fontSize = 14.sp
   )
 }
 
 @Composable
-fun SectionCustomFooter(content: (@Composable () -> Unit)) {
+fun SectionCustomFooter(padding: PaddingValues = PaddingValues(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = 5.dp), content: (@Composable () -> Unit)) {
   Row(
-    Modifier.padding(horizontal = 16.dp).padding(top = 5.dp)
+    Modifier.padding(padding)
   ) {
     content()
   }
@@ -69,14 +187,25 @@ fun SectionSpacer() {
 
 @Composable
 fun InfoRow(title: String, value: String) {
-  SectionItemView {
-    Row(
-      Modifier.fillMaxWidth(),
-      horizontalArrangement = Arrangement.SpaceBetween,
-      verticalAlignment = Alignment.CenterVertically
-    ) {
-      Text(title)
-      Text(value, color = HighOrLowlight)
-    }
+  SectionItemViewSpaceBetween {
+    Text(title)
+    Text(value, color = HighOrLowlight)
+  }
+}
+
+@Composable
+fun InfoRowEllipsis(title: String, value: String, onClick: () -> Unit) {
+  SectionItemViewSpaceBetween(onClick) {
+    val configuration = LocalConfiguration.current
+    Text(title)
+    Text(
+      value,
+      Modifier
+        .padding(start = 10.dp)
+        .widthIn(max = (configuration.screenWidthDp / 2).dp),
+      maxLines = 1,
+      overflow = TextOverflow.Ellipsis,
+      color = HighOrLowlight
+    )
   }
 }

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

@@ -3,13 +3,15 @@ package chat.simplex.app.views.helpers
 import android.content.*
 import android.net.Uri
 import android.provider.MediaStore
+import android.webkit.MimeTypeMap
 import android.widget.Toast
 import androidx.activity.compose.ManagedActivityResultLauncher
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.runtime.Composable
 import androidx.core.content.ContextCompat
-import chat.simplex.app.R
+import androidx.core.content.FileProvider
+import chat.simplex.app.*
 import chat.simplex.app.model.CIFile
 import java.io.BufferedOutputStream
 import java.io.File
@@ -24,6 +26,22 @@ fun shareText(cxt: Context, text: String) {
   cxt.startActivity(shareIntent)
 }
 
+fun shareFile(cxt: Context, text: String, filePath: String) {
+  val uri = FileProvider.getUriForFile(SimplexApp.context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))
+  val ext = filePath.substringAfterLast(".")
+  val mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) ?: return
+  val sendIntent: Intent = Intent().apply {
+    action = Intent.ACTION_SEND
+    /*if (text.isNotEmpty()) {
+      putExtra(Intent.EXTRA_TEXT, text)
+    }*/
+    putExtra(Intent.EXTRA_STREAM, uri)
+    type = mimeType
+  }
+  val shareIntent = Intent.createChooser(sendIntent, null)
+  cxt.startActivity(shareIntent)
+}
+
 fun copyText(cxt: Context, text: String) {
   val clipboard = ContextCompat.getSystemService(cxt, ClipboardManager::class.java)
   clipboard?.setPrimaryClip(ClipData.newPlainText("text", text))
@@ -40,8 +58,7 @@ fun rememberSaveFileLauncher(cxt: Context, ciFile: CIFile?): ManagedActivityResu
           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()
           }
@@ -52,21 +69,32 @@ fun rememberSaveFileLauncher(cxt: Context, ciFile: CIFile?): ManagedActivityResu
     }
   )
 
+fun imageMimeType(fileName: String): String {
+  val lowercaseName = fileName.lowercase()
+  return when {
+    lowercaseName.endsWith(".png") -> "image/png"
+    lowercaseName.endsWith(".gif") -> "image/gif"
+    lowercaseName.endsWith(".webp") -> "image/webp"
+    lowercaseName.endsWith(".avif") -> "image/avif"
+    lowercaseName.endsWith(".svg") -> "image/svg+xml"
+    else -> "image/jpeg"
+  }
+}
+
 fun saveImage(cxt: Context, ciFile: CIFile?) {
   val filePath = getLoadedFilePath(cxt, ciFile)
   val fileName = ciFile?.fileName
   if (filePath != null && fileName != null) {
     val values = ContentValues()
     values.put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis())
-    values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
+    values.put(MediaStore.Images.Media.MIME_TYPE, imageMimeType(fileName))
     values.put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
     values.put(MediaStore.MediaColumns.TITLE, fileName)
     val uri = cxt.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
     uri?.let {
       cxt.contentResolver.openOutputStream(uri)?.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.image_saved), Toast.LENGTH_SHORT).show()
       }

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

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

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

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

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

@@ -10,10 +10,14 @@ import android.provider.OpenableColumns
 import android.text.Spanned
 import android.text.SpannedString
 import android.text.style.*
+import android.util.Base64
 import android.util.Log
+import android.view.View
 import android.view.ViewTreeObserver
+import android.view.inputmethod.InputMethodManager
 import androidx.annotation.StringRes
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.Saver
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.*
 import androidx.compose.ui.text.*
@@ -23,8 +27,7 @@ import androidx.compose.ui.text.style.TextDecoration
 import androidx.compose.ui.unit.*
 import androidx.core.content.FileProvider
 import androidx.core.text.HtmlCompat
-import chat.simplex.app.BuildConfig
-import chat.simplex.app.SimplexApp
+import chat.simplex.app.*
 import chat.simplex.app.model.CIFile
 import kotlinx.coroutines.*
 import java.io.*
@@ -67,6 +70,9 @@ fun getKeyboardState(): State<KeyboardState> {
   return keyboardState
 }
 
+fun hideKeyboard(view: View) =
+  (SimplexApp.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).hideSoftInputFromWindow(view.windowToken, 0)
+
 // Resource to annotated string from
 // https://stackoverflow.com/questions/68549248/android-jetpack-compose-how-to-show-styled-text-from-string-resources
 fun generalGetString(id: Int): String {
@@ -212,6 +218,12 @@ private fun spannableStringToAnnotatedString(
 
 // maximum image file size to be auto-accepted
 const val MAX_IMAGE_SIZE: Long = 236700
+const val MAX_IMAGE_SIZE_AUTO_RCV: Long = MAX_IMAGE_SIZE * 2
+const val MAX_VOICE_SIZE_AUTO_RCV: Long = MAX_IMAGE_SIZE
+
+const val MAX_VOICE_SIZE_FOR_SENDING: Long = 94680 // 6 chunks * 15780 bytes per chunk
+const val MAX_VOICE_MILLIS_FOR_SENDING: Long = 43_000 // approximately is ok
+
 const val MAX_FILE_SIZE: Long = 8000000
 
 fun getFilesDirectory(context: Context): String {
@@ -303,11 +315,18 @@ fun getFileSize(context: Context, uri: Uri): Long? {
   }
 }
 
+fun saveImage(context: Context, uri: Uri): String? {
+  val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, uri)
+  val bitmap = ImageDecoder.decodeBitmap(source)
+  return saveImage(context, bitmap)
+}
+
 fun saveImage(context: Context, image: Bitmap): String? {
   return try {
-    val dataResized = resizeImageToDataSize(image, maxDataSize = MAX_IMAGE_SIZE)
+    val ext = if (image.hasAlpha()) "png" else "jpg"
+    val dataResized = resizeImageToDataSize(image, ext == "png", maxDataSize = MAX_IMAGE_SIZE)
     val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
-    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.jpg")
+    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.$ext")
     val file = File(getAppFilePath(context, fileToSave))
     val output = FileOutputStream(file)
     dataResized.writeTo(output)
@@ -320,6 +339,32 @@ fun saveImage(context: Context, image: Bitmap): String? {
   }
 }
 
+fun saveAnimImage(context: Context, uri: Uri): String? {
+  return try {
+    val filename = getFileName(context, uri)?.lowercase()
+    var ext = when {
+      // remove everything but extension
+      filename?.contains(".") == true -> filename.replaceBeforeLast('.', "").replace(".", "")
+      else -> "gif"
+    }
+    // Just in case the image has a strange extension
+    if (ext.length < 3 || ext.length > 4) ext = "gif"
+    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.$ext")
+    val file = File(getAppFilePath(context, fileToSave))
+    val output = FileOutputStream(file)
+    context.contentResolver.openInputStream(uri)!!.use { input ->
+      output.use { output ->
+        input.copyTo(output)
+      }
+    }
+    fileToSave
+  } catch (e: Exception) {
+    Log.e(chat.simplex.app.TAG, "Util.kt saveAnimImage error: ${e.message}")
+    null
+  }
+}
+
 fun saveFileFromUri(context: Context, uri: Uri): String? {
   return try {
     val inputStream = context.contentResolver.openInputStream(uri)
@@ -376,3 +421,43 @@ fun removeFile(context: Context, fileName: String): Boolean {
   }
   return fileDeleted
 }
+
+fun deleteAppFiles(context: Context) {
+  val dir = File(getAppFilesDirectory(context))
+  try {
+    dir.list()?.forEach {
+      removeFile(context, it)
+    }
+  } catch (e: java.lang.Exception) {
+    Log.e(TAG, "Util deleteAppFiles error: ${e.stackTraceToString()}")
+  }
+}
+
+fun directoryFileCountAndSize(dir: String): Pair<Int, Long> { // count, size in bytes
+  var fileCount = 0
+  var bytes = 0L
+  try {
+    File(dir).listFiles()?.forEach {
+      fileCount++
+      bytes += it.length()
+    }
+  } catch (e: java.lang.Exception) {
+    Log.e(TAG, "Util directoryFileCountAndSize error: ${e.stackTraceToString()}")
+  }
+  return fileCount to bytes
+}
+
+fun durationToString(sec: Int): String = "%02d:%02d".format(sec / 60, sec % 60)
+
+fun Color.darker(factor: Float = 0.1f): Color =
+  Color(max(red * (1 - factor), 0f), max(green * (1 - factor), 0f), max(blue * (1 - factor), 0f), alpha)
+
+fun ByteArray.toBase64String() = Base64.encodeToString(this, Base64.DEFAULT)
+
+fun String.toByteArrayFromBase64() = Base64.decode(this, Base64.DEFAULT)
+
+val LongRange.Companion.saver
+  get() = Saver<MutableState<LongRange>, Pair<Long, Long>>(
+    save = { it.value.first to it.value.last },
+    restore = { mutableStateOf(it.first..it.second) }
+    )

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

@@ -2,71 +2,122 @@ package chat.simplex.app.views.newchat
 
 import android.content.res.Configuration
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+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.TheaterComedy
+import androidx.compose.material.icons.outlined.Info
 import androidx.compose.material.icons.outlined.Share
-import androidx.compose.runtime.Composable
+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.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.shareText
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
 
 @Composable
-fun AddContactView(chatModel: ChatModel) {
-  val connReq = chatModel.connReqInvitation
-  if (connReq != null) {
-    val cxt = LocalContext.current
-    AddContactLayout(
-      connReq = connReq,
-      share = { shareText(cxt, connReq) }
-    )
+fun AddContactView(connReqInvitation: String, connIncognito: Boolean) {
+  val cxt = LocalContext.current
+  AddContactLayout(
+    connReq = connReqInvitation,
+    connIncognito = connIncognito,
+    share = { shareText(cxt, connReqInvitation) }
+  )
+}
+
+@Composable
+fun AddContactLayout(connReq: String, connIncognito: Boolean, share: () -> Unit) {
+  BoxWithConstraints {
+    val screenHeight = maxHeight
+    Column(
+      Modifier
+        .verticalScroll(rememberScrollState())
+        .padding(bottom = 16.dp),
+      verticalArrangement = Arrangement.SpaceBetween,
+    ) {
+      AppBarTitle(stringResource(R.string.add_contact), false)
+      Text(
+        stringResource(R.string.show_QR_code_for_your_contact_to_scan_from_the_app__multiline),
+      )
+      Row {
+        InfoAboutIncognito(
+          connIncognito,
+          true,
+          generalGetString(R.string.incognito_random_profile_description),
+          generalGetString(R.string.your_profile_will_be_sent)
+        )
+      }
+      if (connReq.isNotEmpty()) {
+        QRCode(
+          connReq, Modifier
+            .aspectRatio(1f)
+            .padding(vertical = 3.dp)
+        )
+      } else {
+          CircularProgressIndicator(
+            Modifier
+              .size(36.dp)
+              .padding(4.dp)
+              .align(Alignment.CenterHorizontally),
+            color = HighOrLowlight,
+            strokeWidth = 3.dp
+          )
+      }
+      Text(
+        annotatedStringResource(R.string.if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel),
+        lineHeight = 22.sp,
+        modifier = Modifier
+          .padding(top = 16.dp, bottom = if (screenHeight > 600.dp) 16.dp else 0.dp)
+      )
+      Row(
+        Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.Center
+      ) {
+        SimpleButton(stringResource(R.string.share_invitation_link), icon = Icons.Outlined.Share, click = share)
+      }
+    }
   }
 }
 
 @Composable
-fun AddContactLayout(connReq: String, share: () -> Unit) {
-  BoxWithConstraints {
-    val screenHeight = maxHeight
-    Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.SpaceBetween,
+fun InfoAboutIncognito(chatModelIncognito: Boolean, supportedIncognito: Boolean = true, onText: String, offText: String) {
+  if (chatModelIncognito) {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(vertical = 4.dp),
+      verticalAlignment = Alignment.CenterVertically
     ) {
-      Text(
-        stringResource(R.string.add_contact),
-        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+      Icon(
+        if (supportedIncognito) Icons.Filled.TheaterComedy else Icons.Outlined.Info,
+        stringResource(R.string.incognito),
+        tint = if (supportedIncognito) Indigo else WarningOrange,
+        modifier = Modifier.padding(end = 10.dp).size(20.dp)
       )
-      Text(
-        stringResource(R.string.show_QR_code_for_your_contact_to_scan_from_the_app__multiline),
-        style = MaterialTheme.typography.h3,
-        textAlign = TextAlign.Center,
+      Text(onText, textAlign = TextAlign.Left, style = MaterialTheme.typography.body2)
+    }
+  } else {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(vertical = 4.dp),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Icon(
+        Icons.Outlined.Info,
+        stringResource(R.string.incognito),
+        tint = HighOrLowlight,
+        modifier = Modifier.padding(end = 10.dp).size(20.dp)
       )
-      QRCode(
-        connReq, Modifier
-          .weight(1f, fill = false)
-          .aspectRatio(1f)
-          .padding(vertical = 3.dp)
-      )
-      Text(
-        stringResource(R.string.if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel),
-        textAlign = TextAlign.Center,
-        lineHeight = 22.sp,
-        modifier = Modifier
-          .padding(horizontal = 16.dp)
-          .padding(bottom = if (screenHeight > 600.dp) 16.dp else 8.dp)
-      )
-      SimpleButton(stringResource(R.string.share_invitation_link), icon = Icons.Outlined.Share, click = share)
-      Spacer(Modifier.height(10.dp))
+      Text(offText, textAlign = TextAlign.Left, style = MaterialTheme.typography.body2)
     }
   }
 }
@@ -82,6 +133,7 @@ fun PreviewAddContactView() {
   SimpleXTheme {
     AddContactLayout(
       connReq = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D",
+      connIncognito = false,
       share = {}
     )
   }

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

@@ -1,6 +1,7 @@
 package chat.simplex.app.views.newchat
 
 import android.graphics.Bitmap
+import android.net.Uri
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -8,6 +9,7 @@ import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.ArrowForwardIos
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
@@ -21,19 +23,20 @@ import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.ProfileNameField
 import chat.simplex.app.views.chat.group.AddGroupMembersView
-import chat.simplex.app.views.chatlist.populateGroupMembers
+import chat.simplex.app.views.chatlist.setGroupMembers
 import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.isValidDisplayName
-import chat.simplex.app.views.onboarding.ReadableText
 import chat.simplex.app.views.usersettings.DeleteImageButton
 import chat.simplex.app.views.usersettings.EditImageButton
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 
 @Composable
 fun AddGroupView(chatModel: ChatModel, close: () -> Unit) {
   AddGroupLayout(
+    chatModel.incognito.value,
     createGroup = { groupProfile ->
       withApi {
         val groupInfo = chatModel.controller.apiNewGroup(groupProfile)
@@ -41,15 +44,10 @@ fun AddGroupView(chatModel: ChatModel, close: () -> Unit) {
           chatModel.addChat(Chat(chatInfo = ChatInfo.Group(groupInfo), chatItems = listOf()))
           chatModel.chatItems.clear()
           chatModel.chatId.value = groupInfo.id
-          populateGroupMembers(groupInfo, chatModel)
+          setGroupMembers(groupInfo, chatModel)
           close.invoke()
-          ModalManager.shared.showCustomModal { close ->
-            ModalView(
-              close = close, modifier = Modifier,
-              background = if (isSystemInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
-            ) {
-              AddGroupMembersView(groupInfo, chatModel, close)
-            }
+          ModalManager.shared.showModalCloseable(true) { close ->
+            AddGroupMembersView(groupInfo, chatModel, close)
           }
         }
       }
@@ -59,13 +57,13 @@ fun AddGroupView(chatModel: ChatModel, close: () -> Unit) {
 }
 
 @Composable
-fun AddGroupLayout(createGroup: (GroupProfile) -> Unit, close: () -> Unit) {
+fun AddGroupLayout(chatModelIncognito: Boolean, createGroup: (GroupProfile) -> Unit, close: () -> Unit) {
   val bottomSheetModalState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
   val scope = rememberCoroutineScope()
   val displayName = remember { mutableStateOf("") }
   val fullName = remember { mutableStateOf("") }
-  val profileImage = remember { mutableStateOf<String?>(null) }
-  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val chosenImage = rememberSaveable { mutableStateOf<Uri?>(null) }
+  val profileImage = rememberSaveable { mutableStateOf<String?>(null) }
   val focusRequester = remember { FocusRequester() }
 
   ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
@@ -83,66 +81,67 @@ fun AddGroupLayout(createGroup: (GroupProfile) -> Unit, close: () -> Unit) {
       sheetState = bottomSheetModalState,
       sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp)
     ) {
-      ModalView(close) {
-        Surface(Modifier.background(MaterialTheme.colors.onBackground).fillMaxSize()) {
-          Column(
+      ModalView(close = close) {
+        Column(
+          Modifier
+            .fillMaxSize()
+            .verticalScroll(rememberScrollState())
+            .padding(horizontal = DEFAULT_PADDING)
+        ) {
+          AppBarTitle(stringResource(R.string.create_secret_group_title), false)
+          Text(stringResource(R.string.group_is_decentralized))
+          InfoAboutIncognito(
+            chatModelIncognito,
+            false,
+            generalGetString(R.string.group_unsupported_incognito_main_profile_sent),
+            generalGetString(R.string.group_main_profile_sent)
+          )
+          Box(
             Modifier
-              .verticalScroll(rememberScrollState())
-              .padding(bottom = 16.dp),
+              .fillMaxWidth()
+              .padding(bottom = 24.dp),
+            contentAlignment = Alignment.Center
           ) {
-            Text(
-              stringResource(R.string.create_secret_group_title),
-              style = MaterialTheme.typography.h4,
-              modifier = Modifier.padding(vertical = 5.dp)
-            )
-            ReadableText(R.string.group_is_decentralized)
-            Spacer(Modifier.height(10.dp))
-            Box(
-              Modifier
-                .fillMaxWidth()
-                .padding(bottom = 24.dp),
-              contentAlignment = Alignment.Center
-            ) {
-              Box(contentAlignment = Alignment.TopEnd) {
-                Box(contentAlignment = Alignment.Center) {
-                  ProfileImage(size = 192.dp, image = profileImage.value)
-                  EditImageButton { scope.launch { bottomSheetModalState.show() } }
-                }
-                if (profileImage.value != null) {
-                  DeleteImageButton { profileImage.value = null }
-                }
+            Box(contentAlignment = Alignment.TopEnd) {
+              Box(contentAlignment = Alignment.Center) {
+                ProfileImage(size = 192.dp, image = profileImage.value)
+                EditImageButton { scope.launch { bottomSheetModalState.show() } }
+              }
+              if (profileImage.value != null) {
+                DeleteImageButton { profileImage.value = null }
               }
             }
-            Text(
-              stringResource(R.string.group_display_name_field),
-              Modifier.padding(bottom = 3.dp)
-            )
-            ProfileNameField(displayName, focusRequester)
-            val errorText = if (!isValidDisplayName(displayName.value)) stringResource(R.string.display_name_cannot_contain_whitespace) else ""
-            Text(
-              errorText,
-              fontSize = 15.sp,
-              color = MaterialTheme.colors.error
-            )
-            Spacer(Modifier.height(3.dp))
-            Text(
-              stringResource(R.string.group_full_name_field),
-              Modifier.padding(bottom = 5.dp)
-            )
-            ProfileNameField(fullName)
+          }
+          Text(
+            stringResource(R.string.group_display_name_field),
+            Modifier.padding(bottom = 3.dp)
+          )
+          ProfileNameField(displayName, focusRequester)
+          val errorText = if (!isValidDisplayName(displayName.value)) stringResource(R.string.display_name_cannot_contain_whitespace) else ""
+          Text(
+            errorText,
+            fontSize = 15.sp,
+            color = MaterialTheme.colors.error
+          )
+          Spacer(Modifier.height(3.dp))
+          Text(
+            stringResource(R.string.group_full_name_field),
+            Modifier.padding(bottom = 5.dp)
+          )
+          ProfileNameField(fullName)
 
-            Spacer(Modifier.height(8.dp))
-            val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
-            if (enabled) {
-              CreateGroupButton(MaterialTheme.colors.primary, Modifier
-                .clickable { createGroup(GroupProfile(displayName.value, fullName.value, profileImage.value)) }
-                .padding(8.dp))
-            } else {
-              CreateGroupButton(HighOrLowlight, Modifier.padding(8.dp))
-            }
-            LaunchedEffect(Unit) {
-              focusRequester.requestFocus()
-            }
+          Spacer(Modifier.height(8.dp))
+          val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
+          if (enabled) {
+            CreateGroupButton(MaterialTheme.colors.primary, Modifier
+              .clickable { createGroup(GroupProfile(displayName.value, fullName.value, profileImage.value)) }
+              .padding(8.dp))
+          } else {
+            CreateGroupButton(HighOrLowlight, Modifier.padding(8.dp))
+          }
+          LaunchedEffect(Unit) {
+            delay(300)
+            focusRequester.requestFocus()
           }
         }
       }
@@ -170,6 +169,7 @@ fun CreateGroupButton(color: Color, modifier: Modifier) {
 fun PreviewAddGroupLayout() {
   SimpleXTheme {
     AddGroupLayout(
+      chatModelIncognito = false,
       createGroup = {},
       close = {}
     )

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

@@ -0,0 +1,71 @@
+package chat.simplex.app.views.newchat
+
+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.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.HighOrLowlight
+
+enum class ConnectViaLinkTab {
+  SCAN, PASTE
+}
+
+@Composable
+fun ConnectViaLinkView(m: ChatModel, close: () -> Unit) {
+  val selection = remember {
+    mutableStateOf(
+      runCatching { ConnectViaLinkTab.valueOf(m.controller.appPrefs.connectViaLinkTab.get()!!) }.getOrDefault(ConnectViaLinkTab.SCAN)
+    )
+  }
+  val tabTitles = ConnectViaLinkTab.values().map {
+    when (it) {
+      ConnectViaLinkTab.SCAN -> stringResource(R.string.scan_QR_code)
+      ConnectViaLinkTab.PASTE -> stringResource(R.string.paste_the_link_you_received)
+    }
+  }
+  Column(
+    Modifier.fillMaxHeight(),
+    verticalArrangement = Arrangement.SpaceBetween
+  ) {
+    Column(Modifier.weight(1f)) {
+      when (selection.value) {
+        ConnectViaLinkTab.SCAN -> {
+          ScanToConnectView(m, close)
+        }
+        ConnectViaLinkTab.PASTE -> {
+          PasteToConnectView(m, close)
+        }
+      }
+    }
+    TabRow(
+      selectedTabIndex = selection.value.ordinal,
+      backgroundColor = MaterialTheme.colors.background,
+      contentColor = MaterialTheme.colors.primary,
+    ) {
+      tabTitles.forEachIndexed { index, it ->
+        Tab(
+          selected = selection.value.ordinal == index,
+          onClick = {
+            selection.value = ConnectViaLinkTab.values()[index]
+            m.controller.appPrefs.connectViaLinkTab.set(selection.value .name)
+          },
+          text = { Text(it, fontSize = 13.sp) },
+          icon = {
+            Icon(
+              if (ConnectViaLinkTab.SCAN.ordinal == index) Icons.Outlined.QrCode else Icons.Outlined.Article,
+              it
+            )
+          },
+          selectedContentColor = MaterialTheme.colors.primary,
+          unselectedContentColor = HighOrLowlight,
+        )
+      }
+    }
+  }
+}

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

@@ -0,0 +1,157 @@
+package chat.simplex.app.views.newchat
+
+import SectionDivider
+import SectionView
+import android.content.res.Configuration
+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.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.LocalAliasEditor
+import chat.simplex.app.views.chatlist.deleteContactConnectionAlert
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.usersettings.SettingsActionItem
+
+@Composable
+fun ContactConnectionInfoView(
+  chatModel: ChatModel,
+  connReqInvitation: String?,
+  contactConnection: PendingContactConnection,
+  focusAlias: Boolean,
+  close: () -> Unit
+) {
+  LaunchedEffect(connReqInvitation) {
+    chatModel.connReqInv.value = connReqInvitation
+  }
+  /** When [AddContactView] is open, we don't need to drop [chatModel.connReqInv].
+   * Otherwise, it will be called here AFTER [AddContactView] is launched and will clear the value too soon.
+   * It will be dropped automatically when connection established or when user goes away from this screen.
+   **/
+  DisposableEffect(Unit) {
+    onDispose {
+      if (!ModalManager.shared.hasModalsOpen()) {
+        chatModel.connReqInv.value = null
+      }
+    }
+  }
+  ContactConnectionInfoLayout(
+    connReq = connReqInvitation,
+    contactConnection,
+    focusAlias,
+    deleteConnection = { deleteContactConnectionAlert(contactConnection, chatModel, close) },
+    onLocalAliasChanged = { setContactAlias(contactConnection, it, chatModel) },
+    showQr = {
+      ModalManager.shared.showModal {
+        Column(
+          Modifier
+            .fillMaxHeight()
+            .padding(horizontal = DEFAULT_PADDING),
+          verticalArrangement = Arrangement.SpaceBetween
+        ) {
+          AddContactView(connReqInvitation ?: return@showModal, contactConnection.incognito)
+        }
+      }
+    }
+  )
+}
+
+@Composable
+private fun ContactConnectionInfoLayout(
+  connReq: String?,
+  contactConnection: PendingContactConnection,
+  focusAlias: Boolean,
+  deleteConnection: () -> Unit,
+  onLocalAliasChanged: (String) -> Unit,
+  showQr: () -> Unit,
+) {
+  Column(
+    Modifier
+      .verticalScroll(rememberScrollState()),
+  ) {
+    AppBarTitle(
+      stringResource(
+        if (contactConnection.initiated) R.string.you_invited_your_contact
+        else R.string.you_accepted_connection
+      )
+    )
+    if (contactConnection.groupLinkId == null) {
+      Row(Modifier.padding(bottom = DEFAULT_PADDING)) {
+        LocalAliasEditor(contactConnection.localAlias, center = false, leadingIcon = true, focus = focusAlias, updateValue = onLocalAliasChanged)
+      }
+    }
+    Text(
+      stringResource(
+        if (contactConnection.viaContactUri)
+          if (contactConnection.groupLinkId != null) R.string.you_will_be_connected_when_group_host_device_is_online
+          else R.string.you_will_be_connected_when_your_connection_request_is_accepted
+        else R.string.you_will_be_connected_when_your_contacts_device_is_online
+      ),
+      Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, bottom = DEFAULT_PADDING)
+    )
+    SectionView {
+      if (!connReq.isNullOrEmpty() && contactConnection.initiated) {
+        ShowQrButton(contactConnection.incognito, showQr)
+        SectionDivider()
+      }
+      DeleteButton(deleteConnection)
+    }
+  }
+}
+
+@Composable
+fun ShowQrButton(incognito: Boolean, onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.QrCode,
+    stringResource(R.string.show_QR_code),
+    click = onClick,
+    textColor = if (incognito) Indigo else MaterialTheme.colors.primary,
+    iconColor = if (incognito) Indigo else MaterialTheme.colors.primary,
+  )
+}
+
+@Composable
+fun DeleteButton(onClick: () -> Unit) {
+  SettingsActionItem(
+    Icons.Outlined.Delete,
+    stringResource(R.string.delete_verb),
+    click = onClick,
+    textColor = Color.Red,
+    iconColor = Color.Red,
+  )
+}
+
+private fun setContactAlias(contactConnection: PendingContactConnection, localAlias: String, chatModel: ChatModel) = withApi {
+  chatModel.controller.apiSetConnectionAlias(contactConnection.pccConnId, localAlias)?.let {
+    chatModel.updateContactConnection(it)
+  }
+}
+
+@Preview
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+private fun PreviewContactConnectionInfoView() {
+  SimpleXTheme {
+    ContactConnectionInfoLayout(
+      connReq = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D",
+      PendingContactConnection.getSampleData(),
+      focusAlias = false,
+      deleteConnection = {},
+      onLocalAliasChanged = {},
+      showQr = {},
+    )
+  }
+}

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

@@ -0,0 +1,105 @@
+package chat.simplex.app.views.newchat
+
+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.*
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.DEFAULT_PADDING
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.views.helpers.ModalManager
+import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.usersettings.UserAddressView
+
+enum class CreateLinkTab {
+  ONE_TIME, LONG_TERM
+}
+
+@Composable
+fun CreateLinkView(m: ChatModel, initialSelection: CreateLinkTab) {
+  val selection = remember { mutableStateOf(initialSelection) }
+  val connReqInvitation = rememberSaveable { m.connReqInv }
+  val creatingConnReq = rememberSaveable { mutableStateOf(false) }
+  LaunchedEffect(selection.value) {
+    if (selection.value == CreateLinkTab.ONE_TIME && connReqInvitation.value.isNullOrEmpty() && !creatingConnReq.value) {
+      createInvitation(m, creatingConnReq, connReqInvitation)
+    }
+  }
+  /** When [AddContactView] is open, we don't need to drop [chatModel.connReqInv].
+   * Otherwise, it will be called here AFTER [AddContactView] is launched and will clear the value too soon.
+   * It will be dropped automatically when connection established or when user goes away from this screen.
+   **/
+  DisposableEffect(Unit) {
+    onDispose {
+      if (!ModalManager.shared.hasModalsOpen()) {
+        m.connReqInv.value = null
+      }
+    }
+  }
+  val tabTitles = CreateLinkTab.values().map {
+    when {
+      it == CreateLinkTab.ONE_TIME && connReqInvitation.value.isNullOrEmpty() -> stringResource(R.string.create_one_time_link)
+      it == CreateLinkTab.ONE_TIME -> stringResource(R.string.one_time_link)
+      it == CreateLinkTab.LONG_TERM -> stringResource(R.string.your_contact_address)
+      else -> ""
+    }
+  }
+  Column(
+    Modifier
+      .fillMaxHeight()
+      .padding(horizontal = DEFAULT_PADDING),
+    verticalArrangement = Arrangement.SpaceBetween
+  ) {
+    Column(Modifier.weight(1f)) {
+      when (selection.value) {
+        CreateLinkTab.ONE_TIME -> {
+          AddContactView(connReqInvitation.value ?: "", m.incognito.value)
+        }
+        CreateLinkTab.LONG_TERM -> {
+          UserAddressView(m)
+        }
+      }
+    }
+    TabRow(
+      selectedTabIndex = selection.value.ordinal,
+      backgroundColor = MaterialTheme.colors.background,
+      contentColor = MaterialTheme.colors.primary,
+    ) {
+      tabTitles.forEachIndexed { index, it ->
+        Tab(
+          selected = selection.value.ordinal == index,
+          onClick = {
+            selection.value = CreateLinkTab.values()[index]
+          },
+          text = { Text(it, fontSize = 13.sp) },
+          icon = {
+            Icon(
+              if (CreateLinkTab.ONE_TIME.ordinal == index) Icons.Outlined.RepeatOne else Icons.Outlined.AllInclusive,
+              it
+            )
+          },
+          selectedContentColor = MaterialTheme.colors.primary,
+          unselectedContentColor = HighOrLowlight,
+        )
+      }
+    }
+  }
+}
+
+private fun createInvitation(m: ChatModel, creatingConnReq: MutableState<Boolean>, connReqInvitation: MutableState<String?>) {
+  creatingConnReq.value = true
+  withApi {
+    val connReq = m.controller.apiAddContact()
+    if (connReq != null) {
+      connReqInvitation.value = connReq
+    } else {
+      creatingConnReq.value = false
+    }
+  }
+}

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

@@ -1,145 +1,171 @@
 package chat.simplex.app.views.newchat
 
-import android.Manifest
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.*
+import androidx.compose.animation.core.*
 import androidx.compose.foundation.*
+import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Edit
 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.draw.drawBehind
+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.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.dp
+import androidx.core.graphics.ColorUtils
 import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.chatlist.ScaffoldController
-import chat.simplex.app.views.helpers.ModalManager
-import chat.simplex.app.views.helpers.withApi
-import com.google.accompanist.permissions.rememberPermissionState
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import kotlin.math.roundToInt
 
 @Composable
-fun NewChatSheet(chatModel: ChatModel, newChatCtrl: ScaffoldController) {
-  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+fun NewChatSheet(chatModel: ChatModel, newChatSheetState: StateFlow<NewChatSheetState>, stopped: Boolean, closeNewChatSheet: (animated: Boolean) -> Unit) {
+  if (newChatSheetState.collectAsState().value.isVisible()) BackHandler { closeNewChatSheet(true) }
   NewChatSheetLayout(
+    newChatSheetState,
+    stopped,
     addContact = {
-      withApi {
-        //        show spinner
-        chatModel.connReqInvitation = chatModel.controller.apiAddContact()
-        //        hide spinner
-        if (chatModel.connReqInvitation != null) {
-          newChatCtrl.collapse()
-          ModalManager.shared.showModal { AddContactView(chatModel) }
-        }
-      }
+      closeNewChatSheet(false)
+      ModalManager.shared.showModal { CreateLinkView(chatModel, CreateLinkTab.ONE_TIME) }
     },
-    scanCode = {
-      newChatCtrl.collapse()
-      ModalManager.shared.showCustomModal { close -> ScanToConnectView(chatModel, close) }
-      cameraPermissionState.launchPermissionRequest()
-    },
-    pasteLink = {
-      newChatCtrl.collapse()
-      ModalManager.shared.showCustomModal { close -> PasteToConnectView(chatModel, close) }
+    connectViaLink = {
+      closeNewChatSheet(false)
+      ModalManager.shared.showModalCloseable { close -> ConnectViaLinkView(chatModel, close) }
     },
     createGroup = {
-      newChatCtrl.collapse()
+      closeNewChatSheet(false)
       ModalManager.shared.showCustomModal { close -> AddGroupView(chatModel, close) }
-    }
+    },
+    closeNewChatSheet,
   )
 }
 
+private val titles = listOf(R.string.share_one_time_link, R.string.connect_via_link_or_qr, R.string.create_group)
+private val icons = listOf(Icons.Outlined.AddLink, Icons.Outlined.QrCode, Icons.Outlined.Group)
+
 @Composable
-fun NewChatSheetLayout(
+private fun NewChatSheetLayout(
+  newChatSheetState: StateFlow<NewChatSheetState>,
+  stopped: Boolean,
   addContact: () -> Unit,
-  scanCode: () -> Unit,
-  pasteLink: () -> Unit,
-  createGroup: () -> Unit
+  connectViaLink: () -> Unit,
+  createGroup: () -> Unit,
+  closeNewChatSheet: (animated: Boolean) -> Unit,
 ) {
-  Column(horizontalAlignment = Alignment.CenterHorizontally) {
-    Text(
-      stringResource(R.string.add_contact_or_create_group),
-      modifier = Modifier.padding(horizontal = 4.dp).padding(top = 20.dp, bottom = 20.dp),
-      style = MaterialTheme.typography.body2
+  var newChat by remember { mutableStateOf(newChatSheetState.value) }
+  val resultingColor = if (isInDarkTheme()) Color.Black.copy(0.64f) else DrawerDefaults.scrimColor
+  val animatedColor = remember {
+    Animatable(
+      if (newChat.isVisible()) Color.Transparent else resultingColor,
+      Color.VectorConverter(resultingColor.colorSpace)
     )
-    val boxModifier = Modifier.fillMaxWidth().height(80.dp).padding(horizontal = 0.dp)
-    Divider(Modifier.padding(horizontal = 8.dp))
-    Box(boxModifier) {
-      ActionRowButton(
-        stringResource(R.string.create_one_time_link),
-        stringResource(R.string.to_share_with_your_contact),
-        Icons.Outlined.AddLink,
-        click = addContact
-      )
-    }
-    Divider(Modifier.padding(horizontal = 8.dp))
-    Box(boxModifier) {
-      ActionRowButton(
-        stringResource(R.string.paste_received_link),
-        stringResource(R.string.paste_received_link_from_clipboard),
-        Icons.Outlined.Article,
-        click = pasteLink
-      )
-    }
-    Divider(Modifier.padding(horizontal = 8.dp))
-    Box(boxModifier) {
-      ActionRowButton(
-        stringResource(R.string.scan_QR_code),
-        stringResource(R.string.in_person_or_in_video_call__bracketed),
-        Icons.Outlined.QrCode,
-        click = scanCode
-      )
-    }
-    Divider(Modifier.padding(horizontal = 8.dp))
-    Box(boxModifier) {
-      ActionRowButton(
-        stringResource(R.string.create_group),
-        stringResource(R.string.only_stored_on_members_devices),
-        icon = Icons.Outlined.Group,
-        click = createGroup
-      )
-    }
   }
-}
-
-@Composable
-fun ActionRowButton(
-  text: String, comment: String? = null, icon: ImageVector, disabled: Boolean = false,
-  click: () -> Unit = {}
-) {
-  Surface(Modifier.fillMaxSize()) {
-    Row(
-      Modifier.clickable(onClick = click).size(48.dp).padding(8.dp),
-      verticalAlignment = Alignment.CenterVertically
-    ) {
-      val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
-      Icon(icon, text, tint = tint, modifier = Modifier.size(48.dp).padding(start = 4.dp, end = 16.dp))
-
-      Column {
-        Text(
-          text,
-          textAlign = TextAlign.Center,
-          fontWeight = FontWeight.Bold,
-          color = tint
-        )
-
-        if (comment != null) {
-          Text(
-            comment,
-            textAlign = TextAlign.Center,
-            style = MaterialTheme.typography.body2
-          )
+  val animatedFloat = remember { Animatable(if (newChat.isVisible()) 0f else 1f) }
+  LaunchedEffect(Unit) {
+    launch {
+      newChatSheetState.collect {
+        newChat = it
+        launch {
+          animatedColor.animateTo(if (newChat.isVisible()) resultingColor else Color.Transparent, newChatSheetAnimSpec())
+        }
+        launch {
+          animatedFloat.animateTo(if (newChat.isVisible()) 1f else 0f, newChatSheetAnimSpec())
+          if (newChat.isHiding()) closeNewChatSheet(false)
         }
       }
     }
   }
+  val maxWidth = with(LocalDensity.current) { LocalConfiguration.current.screenWidthDp * density }
+  Column(
+    Modifier
+      .fillMaxSize()
+      .offset { IntOffset(if (newChat.isGone()) -maxWidth.roundToInt() else 0, 0) }
+      .clickable(interactionSource = remember { MutableInteractionSource() }, indication = null) { closeNewChatSheet(true) }
+      .drawBehind { drawRect(animatedColor.value) },
+    verticalArrangement = Arrangement.Bottom,
+    horizontalAlignment = Alignment.End
+  ) {
+    val actions = remember { listOf(addContact, connectViaLink, createGroup) }
+    val backgroundColor = if (isInDarkTheme())
+      Color(ColorUtils.blendARGB(MaterialTheme.colors.primary.toArgb(), Color.Black.toArgb(), 0.7F))
+    else
+      MaterialTheme.colors.background
+    LazyColumn(Modifier
+      .graphicsLayer {
+        alpha = animatedFloat.value
+        translationY = (1 - animatedFloat.value) * 20.dp.toPx()
+      }) {
+      items(actions.size) { index ->
+        Row {
+          Spacer(Modifier.weight(1f))
+          Box(contentAlignment = Alignment.CenterEnd) {
+            Button(
+              actions[index],
+              shape = RoundedCornerShape(21.dp),
+              colors = ButtonDefaults.textButtonColors(backgroundColor = backgroundColor),
+              elevation = null,
+              contentPadding = PaddingValues(horizontal = DEFAULT_PADDING_HALF, vertical = DEFAULT_PADDING_HALF),
+              modifier = Modifier.height(42.dp)
+            ) {
+              Text(
+                stringResource(titles[index]),
+                Modifier.padding(start = DEFAULT_PADDING_HALF),
+                color = if (isInDarkTheme()) MaterialTheme.colors.primary else MaterialTheme.colors.primary,
+                fontWeight = FontWeight.Medium,
+              )
+              Icon(
+                icons[index],
+                stringResource(titles[index]),
+                Modifier.size(42.dp),
+                tint = if (isInDarkTheme()) MaterialTheme.colors.primary else MaterialTheme.colors.primary
+              )
+            }
+          }
+          Spacer(Modifier.width(DEFAULT_PADDING))
+        }
+        Spacer(Modifier.height(DEFAULT_PADDING))
+      }
+    }
+    FloatingActionButton(
+      onClick = { if (!stopped) closeNewChatSheet(true) },
+      Modifier.padding(end = 16.dp, bottom = 16.dp),
+      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(
+        Icons.Default.Edit, stringResource(R.string.add_contact_or_create_group),
+        Modifier.graphicsLayer { alpha = 1 - animatedFloat.value }
+      )
+      Icon(
+        Icons.Default.Close, stringResource(R.string.add_contact_or_create_group),
+        Modifier.graphicsLayer { alpha = animatedFloat.value }
+      )
+    }
+  }
 }
 
 @Composable
@@ -158,11 +184,13 @@ fun ActionButton(
       horizontalAlignment = Alignment.CenterHorizontally
     ) {
       val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
-      Icon(icon, text,
+      Icon(
+        icon, text,
         tint = tint,
         modifier = Modifier
           .size(40.dp)
-          .padding(bottom = 8.dp))
+          .padding(bottom = 8.dp)
+      )
       if (text != null) {
         Text(
           text,
@@ -185,13 +213,15 @@ fun ActionButton(
 
 @Preview
 @Composable
-fun PreviewNewChatSheet() {
+private fun PreviewNewChatSheet() {
   SimpleXTheme {
     NewChatSheetLayout(
+      MutableStateFlow(NewChatSheetState.VISIBLE),
+      stopped = false,
       addContact = {},
-      scanCode = {},
-      pasteLink = {},
-      createGroup = {}
+      connectViaLink = {},
+      createGroup = {},
+      closeNewChatSheet = {},
     )
   }
 }

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

@@ -3,43 +3,55 @@ package chat.simplex.app.views.newchat
 import android.content.ClipboardManager
 import android.content.res.Configuration
 import android.net.Uri
-import androidx.activity.compose.BackHandler
+import android.util.Log
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat.getSystemService
 import chat.simplex.app.R
+import chat.simplex.app.TAG
 import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
 
 @Composable
 fun PasteToConnectView(chatModel: ChatModel, close: () -> Unit) {
-  val connectionLink = remember { mutableStateOf("")}
+  val connectionLink = remember { mutableStateOf("") }
   val context = LocalContext.current
   val clipboard = getSystemService(context, ClipboardManager::class.java)
-  BackHandler(onBack = close)
   PasteToConnectLayout(
+    chatModel.incognito.value,
     connectionLink = connectionLink,
     pasteFromClipboard = {
-      connectionLink.value = clipboard?.primaryClip?.getItemAt(0)?.coerceToText(context) as String
+      connectionLink.value = clipboard?.primaryClip?.getItemAt(0)?.coerceToText(context) as? String ?: return@PasteToConnectLayout
     },
     connectViaLink = { connReqUri ->
       try {
         val uri = Uri.parse(connReqUri)
-        withUriAction(uri) { action ->
-          connectViaUri(chatModel, action, uri)
+        withUriAction(uri) { linkType ->
+          val action = suspend {
+            Log.d(TAG, "connectViaUri: connecting")
+            if (connectViaUri(chatModel, linkType, uri)) {
+              close()
+            }
+          }
+          if (linkType == ConnectionLinkType.GROUP) {
+            AlertManager.shared.showAlertMsg(
+              title = generalGetString(R.string.connect_via_group_link),
+              text = generalGetString(R.string.you_will_join_group),
+              confirmText = generalGetString(R.string.connect_via_link_verb),
+              onConfirm = { withApi { action() } }
+            )
+          } else action()
         }
       } catch (e: RuntimeException) {
         AlertManager.shared.showAlertMsg(
@@ -47,57 +59,55 @@ fun PasteToConnectView(chatModel: ChatModel, close: () -> Unit) {
           text = generalGetString(R.string.this_string_is_not_a_connection_link)
         )
       }
-      close()
     },
-    close = close
   )
 }
 
 @Composable
 fun PasteToConnectLayout(
+  chatModelIncognito: Boolean,
   connectionLink: MutableState<String>,
   pasteFromClipboard: () -> Unit,
   connectViaLink: (String) -> Unit,
-  close: () -> Unit
 ) {
-  ModalView(close) {
-    Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.SpaceBetween,
-    ) {
-      Text(
-        stringResource(R.string.connect_via_link),
-        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-        modifier = Modifier.padding(bottom = 16.dp)
-      )
-      Text(stringResource(R.string.paste_connection_link_below_to_connect))
-      Text(stringResource(R.string.profile_will_be_sent_to_contact_sending_link))
+  Column(
+    Modifier.verticalScroll(rememberScrollState()).padding(horizontal = DEFAULT_PADDING),
+    verticalArrangement = Arrangement.SpaceBetween,
+  ) {
+    AppBarTitle(stringResource(R.string.connect_via_link), false)
+    Text(stringResource(R.string.paste_connection_link_below_to_connect))
 
-      Box(Modifier.padding(top = 16.dp, bottom = 6.dp)) {
-        TextEditor(Modifier.height(180.dp), text = connectionLink)
-      }
+    InfoAboutIncognito(
+      chatModelIncognito,
+      true,
+      generalGetString(R.string.incognito_random_profile_from_contact_description),
+      generalGetString(R.string.profile_will_be_sent_to_contact_sending_link)
+    )
 
-      Row(
-        Modifier.fillMaxWidth().padding(bottom = 6.dp),
-        horizontalArrangement = Arrangement.Start,
-      ) {
-        if (connectionLink.value == "") {
-          SimpleButton(text = "Paste", icon = Icons.Outlined.ContentPaste) {
-            pasteFromClipboard()
-          }
-        } else {
-          SimpleButton(text = "Clear", icon = Icons.Outlined.Clear) {
-            connectionLink.value = ""
-          }
-        }
-        Spacer(Modifier.weight(1f).fillMaxWidth())
-        SimpleButton(text = "Connect", icon = Icons.Outlined.Link) {
-          connectViaLink(connectionLink.value)
-        }
-      }
-
-      Text(annotatedStringResource(R.string.you_can_also_connect_by_clicking_the_link))
+    Box(Modifier.padding(top = 16.dp, bottom = 6.dp)) {
+      TextEditor(Modifier.height(180.dp), text = connectionLink)
     }
+
+    Row(
+      Modifier.fillMaxWidth().padding(bottom = 6.dp),
+      horizontalArrangement = Arrangement.Start,
+    ) {
+      if (connectionLink.value == "") {
+        SimpleButton(text = stringResource(R.string.paste_button), icon = Icons.Outlined.ContentPaste) {
+          pasteFromClipboard()
+        }
+      } else {
+        SimpleButton(text = stringResource(R.string.clear_verb), icon = Icons.Outlined.Clear) {
+          connectionLink.value = ""
+        }
+      }
+      Spacer(Modifier.weight(1f).fillMaxWidth())
+      SimpleButton(text = stringResource(R.string.connect_button), icon = Icons.Outlined.Link) {
+        connectViaLink(connectionLink.value)
+      }
+    }
+
+    Text(annotatedStringResource(R.string.you_can_also_connect_by_clicking_the_link))
   }
 }
 
@@ -111,6 +121,7 @@ fun PasteToConnectLayout(
 fun PreviewPasteToConnectTextbox() {
   SimpleXTheme {
     PasteToConnectLayout(
+      chatModelIncognito = false,
       connectionLink = remember { mutableStateOf("") },
       pasteFromClipboard = {},
       connectViaLink = { link ->
@@ -121,7 +132,6 @@ fun PreviewPasteToConnectTextbox() {
           e.printStackTrace()
         }
       },
-      close = {}
     )
   }
 }