file provider works

.github/workflows/build.yml

@@ -5,7 +5,6 @@ on:
     branches:
       - master
       - stable
-      - sqlcipher
     tags:
       - "v*"
   pull_request:
@@ -50,75 +49,50 @@ jobs:
       matrix:
         include:
           - os: ubuntu-20.04
-            cache_path: ~/.cabal/store
+            cache_path: ~/.stack
             asset_name: simplex-chat-ubuntu-20_04-x86-64
           - os: ubuntu-18.04
-            cache_path: ~/.cabal/store
+            cache_path: ~/.stack
             asset_name: simplex-chat-ubuntu-18_04-x86-64
           - os: macos-latest
-            cache_path: ~/.cabal/store
+            cache_path: ~/.stack
             asset_name: simplex-chat-macos-x86-64
           - os: windows-latest
-            cache_path: C:/cabal
+            cache_path: C:/sr
             asset_name: simplex-chat-windows-x86-64
     steps:
       - name: Clone project
         uses: actions/checkout@v2
 
-      - name: Setup Haskell
+      - name: Setup Stack
         uses: haskell/actions/setup@v1
         with:
-          ghc-version: "8.10.7"
-          cabal-version: "latest"
+          ghc-version: '8.10.7'
+          enable-stack: true
+          stack-version: 'latest'
 
       - name: Cache dependencies
         uses: actions/cache@v2
         with:
-          path: |
-            ${{ matrix.cache_path }}
-            dist-newstyle
-          key: ${{ matrix.os }}-${{ hashFiles('cabal.project', 'simplex-chat.cabal') }}
+          path: ${{ matrix.cache_path }}
+          key: ${{ matrix.os }}-${{ hashFiles('stack.yaml') }}
 
       # / 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: |
-          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
+          stack build --test
+          echo "::set-output name=local_install_root::$(stack path --local-install-root)"
 
       - 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.bin_path }}
+          file: ${{ steps.unix_build.outputs.local_install_root }}/bin/simplex-chat
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 
@@ -128,23 +102,25 @@ 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: |
-          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%
+          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%
 
       - 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.bin_path }}
+          file: ${{ steps.windows_build.outputs.local_install_root }}\bin\simplex-chat.exe
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 

.github/workflows/web.yml

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

.gitignore

@@ -42,33 +42,3 @@ 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,32 +1,10 @@
-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
-
+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
 COPY . /project
 WORKDIR /project
-
-# 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
+RUN stack install
 
 FROM scratch AS export-stage
-COPY --from=build /root/.cabal/bin/simplex-chat /
+COPY --from=build-stage /root/.local/bin/simplex-chat /

PRIVACY.md

@@ -1,26 +1,22 @@
 # SimpleX Chat Terms & Privacy Policy
 
-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).
+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.
 
 ## 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 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.
+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.
 
-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).
+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.
 
 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](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.
+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.
 
 ### Information we may share
 
@@ -35,8 +31,6 @@ 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.
@@ -53,7 +47,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 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.
+**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.
 
 **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.
 
@@ -93,4 +87,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 November 8, 2022
+Updated March 1, 2022

README.md

@@ -5,9 +5,8 @@
 [![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
 [![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
 [![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
-[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
-[![Follow on Mastodon](https://img.shields.io/mastodon/follow/108619463746856738?domain=https%3A%2F%2Fmastodon.social&style=social)](https://mastodon.social/@simplex)
 [![Follow on Twitter](https://img.shields.io/twitter/follow/SimpleXChat?style=social)](https://twitter.com/SimpleXChat)
+[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
 
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apple_store.svg" alt="iOS app" height="42">](https://apps.apple.com/us/app/simplex-chat/id1605771084)
 &nbsp;
@@ -17,16 +16,14 @@
 &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/simplex-chat/releases/latest/download/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/website/raw/master/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/simplex-chat/releases/latest/download/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/website/raw/master/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,13 +37,9 @@
 - [Make a private connection](#make-a-private-connection)
 - [Quick installation of a terminal app](#zap-quick-installation-of-a-terminal-app)
 - [SimpleX Platform design](#simplex-platform-design)
-- [Privacy: technical details and limitations](#privacy-technical-details-and-limitations)
 - [For developers](#for-developers)
 - [Roadmap](#roadmap)
-- [Join a user group](#join-a-user-group)
-- [Contribute](#contribute)
-- [Help us with donations](#help-us-with-donations)
-- [Disclaimers, Security contact, License](#disclaimers)
+- [Disclaimer, License](#disclaimer)
 
 ## Why privacy matters
 
@@ -78,21 +71,19 @@ You can use SimpleX with your own servers and still communicate with people usin
 
 1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release annoucement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
 
-2. _Why should I not just use Signal?_ Signal is a centralised platform that uses phone numbers to identify its users and their contacts. It means that while the content of your messages on Signal is protected with robust end-to-end encryption, there is a large amount of meta-data visible to Signal - who you talk with and when.
+2. _Why should I not just use Signal?_ This [post](https://github.com/dessalines/essays/blob/master/why_not_signal.md) shows why Signal cannot be considered a private messenger. Signal is a centralised platform that uses phone numbers to identify its users and their contacts.
 
 3. _How is it different from Matrix, Session, Ricochet, Cwtch, etc., that also don't require user identites?_ Although these platforms do not require a _real identity_, they do rely on anonymous user identities to deliver messages – it can be, for example, an identity key or a random number. Using a persistent user identity, even anonymous, creates a risk that user's connection graph becomes known to the observers and/or service providers, and it can lead to de-anonymizing some users. If the same user profile is used to connect to two different people via any messenger other than SimpleX, these two people can confirm if they are connected to the same person - they would use the same user identifier in the messages. With SimpleX there is no meta-data in common between your conversations with different contacts - the quality that no other messaging platform has.
 
 ## News and updates
 
-Recent updates:
+[Jun 4, 2022. v2.2: the new Privacy and Security settings](./blog/20220604-simplex-chat-new-privacy-security-settings.md)
 
-[Dec 06, 2022. November reviews and v4.3 released - with instant voice messages, irreversible deletion of sent messages and improved server configuration.](./blog/20221206-simplex-chat-v4.3-voice-messages.md)
+[May 11, 2022. v2.0 released - sending images and files in mobile apps](./blog/20220511-simplex-chat-v2-images-files.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)
+[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.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)
+[Jan 12, 2022. SimpleX v1 released: the only messaging and application platform without user identities](./20220112-simplex-chat-v1-released.md)
 
 [All updates](./blog)
 
@@ -102,7 +93,7 @@ You need to share a link or scan a QR code (in person or during a video call) to
 
 The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
 
-<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app1.png" alt="Make a private connection" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app2.png" alt="Conversation" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app3.png" alt="Video call" height="360">
+<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/conversation.png" alt="Make a private connection" width="594" height="360">
 
 ## :zap: Quick installation of a terminal app
 
@@ -126,41 +117,16 @@ 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/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
-
-SimpleX Chat is a work in progress – we are releasing improvements as they are ready. You have to decide if the current state is good enough for your usage scenario.
-
-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 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 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. 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.
+See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information on platform objectives and technical design.
 
 ## For developers
 
-You can:
+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.
 
-- 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.
+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).
 
 If you are considering developing with SimpleX platform please get in touch for any advice and support.
 
@@ -175,110 +141,28 @@ If you are considering developing with SimpleX platform please get in touch for
 - ✅ Haskell chat bot templates.
 - ✅ v2.0 - supporting images and files in mobile apps.
 - ✅ 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.
-- ✅ Connecting to messaging servers via Tor.
-- ✅ Dual server addresses to access messaging servers as v3 hidden services.
-- ✅ Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (ready for announcement).
-- ✅ Incognito mode to share a new random name with each contact.
-- ✅ Chat database encryption.
-- ✅ Automatic chat history deletion.
-- ✅ Links to join groups and improve groups stability.
-- ✅ Voice messages (with recipient opt-out per contact).
-- ✅ Basic authentication for SMP servers (to authorize creating new queues).
-- ✅ View deleted messages, full message deletion by sender (with recipient opt-in per contact).
-- ✅ Block screenshots and view in recent apps.
-- ✅ Advanced server configuration.
-- 🏗 SMP queue redundancy and rotation (manual is supported).
-- 🏗 Contact verification via a separate out-of-band channel.
-- 🏗 Ephemeral/disappearing/OTR conversations with the existing contacts.
-- Optionally avoid re-using the same TCP session for multiple connections.
-- Access password/pin (with optional alternative access password).
-- 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.
-- Feeds/broadcasts.
-- Unconfirmed: disappearing messages (with recipient opt-in per-contact).
+- 🚀 End-to-end encrypted audio and video calls via the mobile apps (enable via Experimental Features).
+- 🏗 Privacy preserving instant notifications for iOS using Apple Push Notification service (in progress).
+- 🏗 Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (in progress).
+- 🏗 Chat database portability and encryption.
+- Groups support for mobile apps.
+- Disappearing messages, with mutual agreement.
 - Web widgets for custom interactivity in the chats.
-- Programmable chat automations / rules (automatic replies/forward/deletion/sending, reminders, etc.).
-- Supporting the same profile on multiple devices.
-- Desktop client.
+- SMP protocol improvements:
+  - SMP queue redundancy and rotation.
+  - Message delivery confirmation.
+  - Supporting the same profile on multiple devices.
 - 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.
+- Media server to optimize sending large files to groups.
 - Channels server for large groups and broadcast channels.
 
-## Join a user group
+## Disclaimer
 
-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).
+[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed and had many improvements in v1.0.0; we are currently arranging for the independent implementation audit.
 
-You 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).
-
-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.
-
-Your donations help us raise more funds – any amount, even the price of the cup of coffee, would make a big difference for us.
-
-It is possible to donate via:
-
-- [GitHub](https://github.com/sponsors/simplex-chat) - it is commission-free for us.
-- [OpenCollective](https://opencollective.com/simplex-chat) - it charges a commission, and also accepts donations in crypto-currencies.
-- Monero address: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
-- Bitcoin address: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
-- BCH address: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
-- Ethereum address: 0x83fd788f7241a2be61780ea9dc72d2151e6843e2
-- 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,
-
-Evgeny
-
-SimpleX Chat founder
-
-## Disclaimers
-
-[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.
-
-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.
+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.
 
 ## License
 
@@ -292,4 +176,4 @@ Please treat any findings of possible traffic correlation attacks allowing to co
 &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/simplex-chat/releases/latest/download/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/website/raw/master/simplex.apk)

apps/android/.gitignore

@@ -9,12 +9,9 @@
 /.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,9 +13,7 @@
     <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,5 +1,6 @@
 <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 78
-        versionName "4.3.2"
+        versionCode 36
+        versionName "2.2"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         ndk {
@@ -26,19 +26,9 @@ 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'
@@ -62,6 +52,7 @@ android {
     externalNativeBuild {
         cmake {
             path file('src/main/cpp/CMakeLists.txt')
+            version '3.10.2'
         }
     }
     buildFeatures {
@@ -74,7 +65,6 @@ android {
         resources {
             excludes += '/META-INF/{AL2.0,LGPL2.1}'
         }
-        jniLibs.useLegacyPackaging = compression_level != "0"
     }
 }
 
@@ -90,11 +80,9 @@ dependencies {
     implementation 'org.jetbrains.kotlinx:kotlinx-datetime:0.3.2'
     implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2'
     implementation "androidx.compose.material:material-icons-extended:$compose_version"
-    implementation "androidx.compose.ui:ui-util:$compose_version"
     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"
@@ -112,7 +100,6 @@ 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'
@@ -120,80 +107,9 @@ 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

@@ -24,11 +24,8 @@
   <application
       android:name="SimplexApp"
       android:allowBackup="true"
-      android:fullBackupOnly="true"
-      android:backupAgent="BackupAgent"
       android:icon="@mipmap/icon"
-      android:label="${app_name}"
-      android:extractNativeLibs="${extract_native_libs}"
+      android:label="@string/app_name"
       android:supportsRtl="true"
       android:theme="@style/Theme.SimpleX">
 
@@ -37,10 +34,11 @@
         android:name=".MainActivity"
         android:launchMode="singleTask"
         android:exported="true"
-        android:label="${app_name}"
+        android:label="@string/app_name"
         android:windowSoftInputMode="adjustResize"
         android:theme="@style/Theme.SimpleX">
       <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
         <category android:name="android.intent.category.LAUNCHER" />
       </intent-filter>
 
@@ -65,52 +63,14 @@
         <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:exported="true"
-        android:icon="@mipmap/icon"
-        android:enabled="true"
-        android:targetActivity=".MainActivity">
-      <intent-filter>
-        <action android:name="android.intent.action.MAIN" />
-        <category android:name="android.intent.category.LAUNCHER" />
-      </intent-filter>
-    </activity-alias>
-
-    <activity-alias
-        android:name=".MainActivity_dark_blue"
-        android:exported="true"
-        android:icon="@mipmap/icon_dark_blue"
-        android:enabled="false"
-        android:targetActivity=".MainActivity">
-      <intent-filter>
-        <action android:name="android.intent.action.MAIN" />
-        <category android:name="android.intent.category.LAUNCHER" />
-      </intent-filter>
-    </activity-alias>
-
-
     <activity android:name=".views.call.IncomingCallActivity"
-        android:showOnLockScreen="true"
-        android:exported="false"
-        android:launchMode="singleTask"/>
+        android:showOnLockScreen="true"/>
 
     <provider
         android:name="androidx.core.content.FileProvider"
-        android:authorities="${provider_authorities}"
+        android:authorities="chat.simplex.app.provider"
         android:exported="false"
         android:grantUriPermissions="true">
       <meta-data
@@ -118,12 +78,6 @@
           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:443"] },
-        { urls: ["turn:turn.simplex.im:443"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
+        { urls: ["stun:stun.simplex.chat:5349"] },
+        { urls: ["turn:turn.simplex.chat:5349"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
     ];
     function getCallConfig(encodedInsertableStreams, iceServers, relay) {
         return {
@@ -495,7 +495,6 @@ function callCryptoFunction() {
     const initialPlainTextRequired = {
         key: 10,
         delta: 3,
-        empty: 1,
     };
     const IV_LENGTH = 12;
     function encryptFrame(key) {
@@ -506,9 +505,7 @@ function callCryptoFunction() {
             const initial = data.subarray(0, n);
             const plaintext = data.subarray(n, data.byteLength);
             try {
-                const ciphertext = plaintext.length
-                    ? new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext))
-                    : new Uint8Array(0);
+                const ciphertext = new Uint8Array(plaintext.length ? await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext) : 0);
                 frame.data = concatN(initial, ciphertext, iv).buffer;
                 controller.enqueue(frame);
             }
@@ -526,9 +523,7 @@ function callCryptoFunction() {
             const ciphertext = data.subarray(n, data.byteLength - IV_LENGTH);
             const iv = data.subarray(data.byteLength - IV_LENGTH, data.byteLength);
             try {
-                const plaintext = ciphertext.length
-                    ? new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext))
-                    : new Uint8Array(0);
+                const plaintext = new Uint8Array(ciphertext.length ? await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext) : 0);
                 frame.data = concatN(initial, plaintext).buffer;
                 controller.enqueue(frame);
             }

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

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

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

@@ -22,34 +22,18 @@ Java_chat_simplex_app_SimplexAppKt_initHS(__unused JNIEnv *env, __unused jclass
 }
 
 // from simplex-chat
-typedef long* chat_ctrl;
+typedef void* chat_ctrl;
 
-extern char *chat_migrate_init(const char *path, const char *key, chat_ctrl *ctrl);
+extern chat_ctrl chat_init(const char * path);
 extern char *chat_send_cmd(chat_ctrl ctrl, const char *cmd);
-extern char *chat_recv_msg(chat_ctrl ctrl); // deprecated
-extern char *chat_recv_msg_wait(chat_ctrl ctrl, const int wait);
-extern char *chat_parse_markdown(const char *str);
-extern char *chat_parse_server(const char *str);
+extern char *chat_recv_msg(chat_ctrl ctrl);
 
-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 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 jstring JNICALL
@@ -64,24 +48,3 @@ JNIEXPORT jstring JNICALL
 Java_chat_simplex_app_SimplexAppKt_chatRecvMsg(JNIEnv *env, __unused jclass clazz, jlong controller) {
     return (*env)->NewStringUTF(env, chat_recv_msg((void*)controller));
 }
-
-JNIEXPORT jstring JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatRecvMsgWait(JNIEnv *env, __unused jclass clazz, jlong controller, jint wait) {
-    return (*env)->NewStringUTF(env, chat_recv_msg_wait((void*)controller, wait));
-}
-
-JNIEXPORT jstring JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatParseMarkdown(JNIEnv *env, __unused jclass clazz, jstring str) {
-    const char *_str = (*env)->GetStringUTFChars(env, str, JNI_FALSE);
-    jstring res = (*env)->NewStringUTF(env, chat_parse_markdown(_str));
-    (*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/BackupAgent.kt

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

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

@@ -3,30 +3,25 @@ package chat.simplex.app
 import android.app.Application
 import android.content.Intent
 import android.net.Uri
-import android.os.Build
 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.Lock
+import androidx.compose.material.icons.outlined.Replay
 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
@@ -35,53 +30,28 @@ 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.*
-import chat.simplex.app.views.database.DatabaseErrorView
+import chat.simplex.app.views.chatlist.ChatListView
+import chat.simplex.app.views.chatlist.openChat
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.*
+import chat.simplex.app.views.newchat.connectViaUri
+import chat.simplex.app.views.newchat.withUriAction
 import chat.simplex.app.views.onboarding.*
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filter
-import kotlinx.coroutines.launch
+import java.util.concurrent.TimeUnit
 
-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
-    }
-  }
+class MainActivity: FragmentActivity(), LifecycleEventObserver {
   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
-    // 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
-      )
-    }
+    processNotificationIntent(intent, m)
     setContent {
       SimpleXTheme {
         Surface(
@@ -100,57 +70,27 @@ class MainActivity: FragmentActivity() {
         }
       }
     }
-    SimplexApp.context.schedulePeriodicServiceRestartWorker()
-    SimplexApp.context.schedulePeriodicWakeUp()
+    schedulePeriodicServiceRestartWorker()
   }
 
   override fun onNewIntent(intent: Intent?) {
     super.onNewIntent(intent)
     processIntent(intent, vm.chatModel)
-    processExternalIntent(intent, vm.chatModel)
   }
 
-  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() {
-    if (
-      onBackPressedDispatcher.hasEnabledCallbacks() // Has something to do in a backstack
-      || Build.VERSION.SDK_INT >= Build.VERSION_CODES.R // Android 11 or above
-      || isTaskRoot // there are still other tasks after we reach the main (home) activity
-    ) {
-      // https://medium.com/mobile-app-development-publication/the-risk-of-android-strandhogg-security-issue-and-how-it-can-be-mitigated-80d2ddb4af06
-      super.onBackPressed()
-    }
-
-    if (!onBackPressedDispatcher.hasEnabledCallbacks() && vm.chatModel.controller.appPrefs.performLA.get()) {
-      // When pressed Back and there is no one wants to process the back event, clear auth state to force re-auth on launch
-      clearAuthState()
-      laFailed.value = true
-    }
-    if (!onBackPressedDispatcher.hasEnabledCallbacks()) {
-      // Drop shared content
-      SimplexApp.context.chatModel.sharedContent.value = null
+  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()
+          }
+        }
+      }
     }
   }
 
@@ -167,10 +107,17 @@ class MainActivity: FragmentActivity() {
         this@MainActivity,
         completed = { laResult ->
           when (laResult) {
-            LAResult.Success ->
+            LAResult.Success -> {
               userAuthorized.value = true
-            is LAResult.Error, LAResult.Failed ->
+            }
+            is LAResult.Error -> {
               laFailed.value = true
+              laErrorToast(applicationContext, laResult.errString)
+            }
+            LAResult.Failed -> {
+              laFailed.value = true
+              laFailedToast(applicationContext)
+            }
             LAResult.Unavailable -> {
               userAuthorized.value = true
               m.performLA.value = false
@@ -183,6 +130,24 @@ class MainActivity: FragmentActivity() {
     }
   }
 
+  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) {
@@ -206,9 +171,15 @@ class MainActivity: FragmentActivity() {
             prefPerformLA.set(true)
             laTurnedOnAlert()
           }
-          is LAResult.Error, LAResult.Failed -> {
+          is LAResult.Error -> {
             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
@@ -233,9 +204,15 @@ class MainActivity: FragmentActivity() {
             m.performLA.value = false
             prefPerformLA.set(false)
           }
-          is LAResult.Error, LAResult.Failed -> {
+          is LAResult.Error -> {
             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
@@ -263,20 +240,13 @@ fun MainPage(
   showLANotice: () -> Unit
 ) {
   // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
-  var chatsAccessAuthorized by rememberSaveable { mutableStateOf(false) }
+  var chatsAccessAuthorized by remember { mutableStateOf(false) }
   LaunchedEffect(userAuthorized.value) {
     if (chatModel.controller.appPrefs.performLA.get()) {
       delay(500L)
     }
     chatsAccessAuthorized = userAuthorized.value == true
   }
-  var showChatDatabaseError by rememberSaveable {
-    mutableStateOf(chatModel.chatDbStatus.value != DBMigrationResult.OK && chatModel.chatDbStatus.value != null)
-  }
-  LaunchedEffect(chatModel.chatDbStatus.value) {
-    showChatDatabaseError = chatModel.chatDbStatus.value != DBMigrationResult.OK && chatModel.chatDbStatus.value != null
-  }
-
   var showAdvertiseLAAlert by remember { mutableStateOf(false) }
   LaunchedEffect(showAdvertiseLAAlert) {
     if (
@@ -302,14 +272,14 @@ fun MainPage(
   }
 
   @Composable
-  fun authView() {
+  fun retryAuthView() {
     Box(
       Modifier.fillMaxSize(),
       contentAlignment = Alignment.Center
     ) {
       SimpleButton(
-        stringResource(R.string.auth_unlock),
-        icon = Icons.Outlined.Lock,
+        stringResource(R.string.auth_retry),
+        icon = Icons.Outlined.Replay,
         click = {
           laFailed.value = false
           runAuthenticate()
@@ -322,15 +292,10 @@ 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) {
-          authView()
+          retryAuthView()
         } else {
           SplashView()
         }
@@ -340,62 +305,16 @@ fun MainPage(
           if (chatModel.showCallView.value) ActiveCallView(chatModel)
           else {
             showAdvertiseLAAlert = true
-            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()
-                      }
-                    }
-                }
-              }
-              Box (Modifier.graphicsLayer { translationX = maxWidth.toPx() - offset.value.dp.toPx() }) Box2@ {
-                currentChatId?.let {
-                  ChatView(it, chatModel, onComposed)
-                }
-              }
-            }
+            if (chatModel.chatId.value == null) ChatListView(chatModel, setPerformLA = { setPerformLA(it) })
+            else ChatView(chatModel)
           }
         }
       }
-      onboarding == OnboardingStage.Step1_SimpleXInfo -> SimpleXInfo(chatModel, onboarding = true)
+      onboarding == OnboardingStage.Step1_SimpleXInfo ->
+        Box(Modifier.padding(horizontal = 20.dp)) {
+          SimpleXInfo(chatModel, onboarding = true)
+        }
       onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
-      onboarding == OnboardingStage.Step3_SetNotificationsMode -> SetNotificationsMode(chatModel)
     }
     ModalManager.shared.showInView()
     val invitation = chatModel.activeCallInvitation.value
@@ -444,61 +363,29 @@ 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) { 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)
+    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
+        }
       }
       AlertManager.shared.showAlertMsg(
         title = title,
-        text = if (linkType == ConnectionLinkType.GROUP)
-          generalGetString(R.string.you_will_join_group)
-        else
-          generalGetString(R.string.profile_will_be_sent_to_contact_sending_link),
+        text = 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, linkType, uri)
+            connectViaUri(chatModel, action, uri)
           }
         }
       )

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

@@ -4,17 +4,14 @@ 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.*
+import chat.simplex.app.views.helpers.getFilesDirectory
+import chat.simplex.app.views.helpers.withApi
 import chat.simplex.app.views.onboarding.OnboardingStage
-import chat.simplex.app.views.usersettings.NotificationsMode
-import kotlinx.coroutines.*
-import kotlinx.serialization.decodeFromString
-import java.io.*
+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"
@@ -26,56 +23,19 @@ external fun pipeStdOutToSocket(socketName: String) : Int
 
 // SimpleX API
 typealias ChatCtrl = Long
-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
+external fun chatInit(path: String): ChatCtrl
+external fun chatSendCmd(ctrl: ChatCtrl, msg: String) : String
+external fun chatRecvMsg(ctrl: ChatCtrl) : String
 
 class SimplexApp: Application(), LifecycleEventObserver {
-  lateinit var chatController: ChatController
-
-  var isAppOnForeground: Boolean = false
-
-  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 chatController: ChatController by lazy {
+    val ctrl = chatInit(getFilesDirectory(applicationContext))
+    ChatController(ctrl, ntfManager, applicationContext, appPreferences)
   }
 
-  val chatModel: ChatModel
-    get() = chatController.chatModel
+  val chatModel: ChatModel by lazy {
+    chatController.chatModel
+  }
 
   private val ntfManager: NtfManager by lazy {
     NtfManager(applicationContext, appPreferences)
@@ -88,106 +48,44 @@ 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_START -> {
-          isAppOnForeground = true
-          if (chatModel.chatRunning.value == true) {
-            kotlin.runCatching {
-              val chats = chatController.apiGetChats()
-              chatModel.updateChats(chats)
-            }.onFailure { Log.e(TAG, it.stackTraceToString()) }
-          }
-        }
-        Lifecycle.Event.ON_RESUME -> {
-          isAppOnForeground = true
+        Lifecycle.Event.ON_STOP ->
+          if (!appPreferences.runServiceInBackground.get()) SimplexService.stop(applicationContext)
+        Lifecycle.Event.ON_START ->
+          SimplexService.start(applicationContext)
+        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 &&
-            chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete &&
-            appPreferences.notificationsMode.get() == NotificationsMode.SERVICE.name
-          ) {
-            SimplexService.start(applicationContext)
-          }
-        }
-        else -> isAppOnForeground = false
       }
     }
   }
 
-  fun allowToStartServiceAfterAppExit() = with(chatModel.controller) {
-    appPrefs.notificationsMode.get() == NotificationsMode.SERVICE.name &&
-        (!NotificationsMode.SERVICE.requiresIgnoringBattery || isIgnoringBatteryOptimizations(chatModel.controller.appContext))
-  }
-
-  private fun allowToStartPeriodically() = with(chatModel.controller) {
-    appPrefs.notificationsMode.get() == NotificationsMode.PERIODIC.name &&
-        (!NotificationsMode.PERIODIC.requiresIgnoringBattery || isIgnoringBatteryOptimizations(chatModel.controller.appContext))
-  }
-
-  /*
-  * It takes 1-10 milliseconds to process this function. Better to do it in a background thread
-  * */
-  fun schedulePeriodicServiceRestartWorker() = CoroutineScope(Dispatchers.Default).launch {
-    if (!allowToStartServiceAfterAppExit()) {
-      return@launch
-    }
-    val workerVersion = chatController.appPrefs.autoRestartWorkerVersion.get()
-    val workPolicy = if (workerVersion == SimplexService.SERVICE_START_WORKER_VERSION) {
-      Log.d(TAG, "ServiceStartWorker version matches: choosing KEEP as existing work policy")
-      ExistingPeriodicWorkPolicy.KEEP
-    } else {
-      Log.d(TAG, "ServiceStartWorker version DOES NOT MATCH: choosing REPLACE as existing work policy")
-      chatController.appPrefs.autoRestartWorkerVersion.set(SimplexService.SERVICE_START_WORKER_VERSION)
-      ExistingPeriodicWorkPolicy.REPLACE
-    }
-    val work = PeriodicWorkRequestBuilder<SimplexService.ServiceStartWorker>(SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES, TimeUnit.MINUTES)
-      .addTag(SimplexService.TAG)
-      .addTag(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC)
-      .build()
-    Log.d(TAG, "ServiceStartWorker: Scheduling period work every ${SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES} minutes")
-    WorkManager.getInstance(context)?.enqueueUniquePeriodicWork(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC, workPolicy, work)
-  }
-
-  fun schedulePeriodicWakeUp() = CoroutineScope(Dispatchers.Default).launch {
-    if (!allowToStartPeriodically()) {
-      return@launch
-    }
-    MessagesFetcherWorker.scheduleWork()
-  }
-
   companion object {
     lateinit var context: SimplexApp private set
 
     init {
-      val socketName = BuildConfig.APPLICATION_ID + ".local.socket.address.listen.native.cmd2"
+      val socketName = "local.socket.address.listen.native.cmd2"
       val s = Semaphore(0)
       thread(name="stdout/stderr pipe") {
         Log.d(TAG, "starting server")
-        var server: LocalServerSocket? = null
-        for (i in 0..100) {
-          try {
-            server = LocalServerSocket(socketName + i)
-            break
-          } catch (e: IOException) {
-            Log.e(TAG, e.stackTraceToString())
-          }
-        }
-        if (server == null) {
-          throw Error("Unable to setup local server socket. Contact developers")
-        }
+        val server = LocalServerSocket(socketName)
         Log.d(TAG, "started server")
         s.release()
         val receiver = server.accept()
@@ -197,13 +95,12 @@ class SimplexApp: Application(), LifecycleEventObserver {
           val inStream = receiver.inputStream
           val inStreamReader = InputStreamReader(inStream)
           val input = BufferedReader(inStreamReader)
-          Log.d(TAG, "starting receiver loop")
+
           while (true) {
             val line = input.readLine() ?: break
             Log.w("$TAG (stdout/stderr)", line)
             logbuffer.add(line)
           }
-          Log.w(TAG, "exited receiver loop")
         }
       }
 

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

@@ -2,14 +2,13 @@ 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.*
+import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.onboarding.OnboardingStage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -19,9 +18,11 @@ 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")
@@ -30,6 +31,7 @@ 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 {
@@ -45,60 +47,37 @@ class SimplexService: Service() {
     val text = getString(R.string.simplex_service_notification_text)
     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")
-    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))
+    stopService()
+    sendBroadcast(Intent(this, AutoRestartReceiver::class.java)) // Restart if necessary!
     super.onDestroy()
   }
 
   private fun startService() {
     Log.d(TAG, "SimplexService startService")
-    if (wakeLock != null || isStartingService) return
+    if (isServiceStarted || isStartingService) return
     val self = this
     isStartingService = true
     withApi {
-      val chatController = (application as SimplexApp).chatController
       try {
-        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()
+        val user = chatController.apiGetActiveUser()
+        if (user == null) {
+          chatController.chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+        } else {
+          Log.w(TAG, "Starting foreground service")
+          chatController.startChat(user)
+          chatController.startReceiver()
+          isServiceStarted = true
+          saveServiceState(self, ServiceState.STARTED)
+          wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
+            newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
+              acquire()
+            }
           }
         }
       } finally {
@@ -107,6 +86,23 @@ 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
@@ -124,27 +120,15 @@ class SimplexService: Service() {
     val pendingIntent: PendingIntent = Intent(this, MainActivity::class.java).let { notificationIntent ->
       PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE)
     }
-
-    val builder =  NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
-      .setSmallIcon(R.drawable.ntf_service_icon)
+    return NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
+      .setSmallIcon(R.drawable.ntf_icon)
       .setColor(0x88FFFF)
       .setContentTitle(title)
       .setContentText(text)
       .setContentIntent(pendingIntent)
-      .setSilent(true)
+      .setSound(null)
       .setShowWhen(false) // no date/time
-
-    // Shows a button which opens notification channel settings
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val flags = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-      val setupIntent = Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS)
-      setupIntent.putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
-      setupIntent.putExtra(Settings.EXTRA_CHANNEL_ID, NOTIFICATION_CHANNEL_ID)
-      val setup = PendingIntent.getActivity(this, 0, setupIntent, flags)
-      builder.addAction(0, getString(R.string.hide_notification), setup)
-    }
-
-    return builder.build()
+      .build()
   }
 
   override fun onBind(intent: Intent): IBinder? {
@@ -153,14 +137,6 @@ 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)
     };
@@ -176,17 +152,6 @@ 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
@@ -214,6 +179,7 @@ class SimplexService: Service() {
 
   enum class Action {
     START,
+    STOP
   }
 
   enum class ServiceState {
@@ -230,16 +196,11 @@ 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)
@@ -249,17 +210,7 @@ class SimplexService: Service() {
 
     suspend fun start(context: Context) = serviceAction(context, Action.START)
 
-    /**
-     * 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
-      }
-    }
+    suspend fun stop(context: Context) = serviceAction(context, Action.STOP)
 
     private suspend fun serviceAction(context: Context, action: Action) {
       Log.d(TAG, "SimplexService serviceAction: ${action.name}")
@@ -289,41 +240,6 @@ class SimplexService: Service() {
       return ServiceState.valueOf(value!!)
     }
 
-    fun showPassphraseNotification(chatDbStatus: DBMigrationResult?) {
-      val pendingIntent: PendingIntent = Intent(SimplexApp.context, MainActivity::class.java).let { notificationIntent ->
-        PendingIntent.getActivity(SimplexApp.context, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE)
-      }
-
-      val title = when(chatDbStatus) {
-        is DBMigrationResult.ErrorNotADatabase -> generalGetString(R.string.enter_passphrase_notification_title)
-        is DBMigrationResult.OK -> return
-        else -> generalGetString(R.string.database_initialization_error_title)
-      }
-
-      val description = when(chatDbStatus) {
-        is DBMigrationResult.ErrorNotADatabase -> generalGetString(R.string.enter_passphrase_notification_desc)
-        is DBMigrationResult.OK -> return
-        else -> generalGetString(R.string.database_initialization_error_desc)
-      }
-
-      val builder =  NotificationCompat.Builder(SimplexApp.context, NOTIFICATION_CHANNEL_ID)
-        .setSmallIcon(R.drawable.ntf_service_icon)
-        .setColor(0x88FFFF)
-        .setContentTitle(title)
-        .setContentText(description)
-        .setContentIntent(pendingIntent)
-        .setSilent(true)
-        .setShowWhen(false)
-
-      val notificationManager = SimplexApp.context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-      notificationManager.notify(PASSPHRASE_NOTIFICATION_ID, builder.build())
-    }
-
-    fun cancelPassphraseNotification() {
-      val notificationManager = SimplexApp.context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-      notificationManager.cancel(PASSPHRASE_NOTIFICATION_ID)
-    }
-
     private fun getPreferences(context: Context): SharedPreferences = context.getSharedPreferences(SHARED_PREFS_ID, Context.MODE_PRIVATE)
   }
 }

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

@@ -3,18 +3,15 @@ package chat.simplex.app.model
 import android.app.*
 import android.content.*
 import android.graphics.BitmapFactory
-import android.hardware.display.DisplayManager
 import android.media.AudioAttributes
 import android.net.Uri
 import android.util.Log
-import android.view.Display
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import chat.simplex.app.*
 import chat.simplex.app.views.call.*
-import chat.simplex.app.views.chatlist.acceptContactRequest
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.NotificationPreviewMode
+import chat.simplex.app.views.helpers.base64ToBitmap
+import chat.simplex.app.views.helpers.generalGetString
 import kotlinx.datetime.Clock
 
 class NtfManager(val context: Context, private val appPreferences: AppPreferences) {
@@ -25,12 +22,10 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     const val ShowChatsAction: String = "chat.simplex.app.SHOW_CHATS"
 
     // DO NOT change notification channel settings / names
-    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION_1"
+    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION"
+    const val LockScreenCallChannel: String = "chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION"
     const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
-    const val RejectCallAction: String = "chat.simplex.app.REJECT_CALL"
     const val CallNotificationId: Int = -1
-
-    private const val ChatIdKey: String = "chatId"
   }
 
   private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -38,30 +33,21 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
   private val msgNtfTimeoutMs = 30000L
 
   init {
-    manager.createNotificationChannel(NotificationChannel(MessageChannel, generalGetString(R.string.ntf_channel_messages), NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(callNotificationChannel(CallChannel, generalGetString(R.string.ntf_channel_calls)))
-    // Remove old channels since they can't be edited
-    manager.deleteNotificationChannel("chat.simplex.app.CALL_NOTIFICATION")
-    manager.deleteNotificationChannel("chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION")
+    manager.createNotificationChannel(NotificationChannel(MessageChannel, "SimpleX Chat messages", NotificationManager.IMPORTANCE_HIGH))
+    manager.createNotificationChannel(NotificationChannel(LockScreenCallChannel, "SimpleX Chat calls (lock screen)", NotificationManager.IMPORTANCE_HIGH))
+    manager.createNotificationChannel(callNotificationChannel())
   }
 
-  enum class NotificationAction {
-    ACCEPT_CONTACT_REQUEST
-  }
-
-  private fun callNotificationChannel(channelId: String, channelName: String): NotificationChannel {
-    val callChannel = NotificationChannel(channelId, channelName, NotificationManager.IMPORTANCE_HIGH)
+  private fun callNotificationChannel(): NotificationChannel {
+    val callChannel = NotificationChannel(CallChannel, "SimpleX Chat calls", NotificationManager.IMPORTANCE_HIGH)
     val attrs = AudioAttributes.Builder()
       .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-      .setUsage(AudioAttributes.USAGE_NOTIFICATION_RINGTONE)
+      .setUsage(AudioAttributes.USAGE_NOTIFICATION)
       .build()
     val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
     Log.d(TAG,"callNotificationChannel sound: $soundUri")
     callChannel.setSound(soundUri, attrs)
     callChannel.enableVibration(true)
-    // the numbers below are explained here: https://developer.android.com/reference/android/os/Vibrator
-    // (wait, vibration duration, wait till off, wait till on again = ringtone mp3 duration - vibration duration - ~50ms lost somewhere)
-    callChannel.vibrationPattern = longArrayOf(250, 250, 0, 2600)
     return callChannel
   }
 
@@ -77,69 +63,28 @@ 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, image: String? = null, actions: List<NotificationAction> = emptyList()) {
+  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String) {
     Log.d(TAG, "notifyMessageReceived $chatId")
     val now = Clock.System.now().toEpochMilliseconds()
     val recentNotification = (now - prevNtfTime.getOrDefault(chatId, 0) < msgNtfTimeoutMs)
     prevNtfTime[chatId] = now
 
-    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)
+    val notification = NotificationCompat.Builder(context, MessageChannel)
+      .setContentTitle(displayName)
+      .setContentText(msgText)
       .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(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)
-    }
+      .setSilent(recentNotification)
+      .build()
 
     val summary = NotificationCompat.Builder(context, MessageChannel)
       .setSmallIcon(R.drawable.ntf_icon)
@@ -152,73 +97,50 @@ 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(), builder.build())
+      notify(chatId.hashCode(), notification)
       notify(0, summary)
     }
   }
 
-  fun notifyCallInvitation(invitation: RcvCallInvitation) {
-    val keyguardManager = getKeyguardManager(context)
-    Log.d(TAG,
-      "notifyCallInvitation pre-requests: " +
-          "keyguard locked ${keyguardManager.isKeyguardLocked}, " +
-          "callOnLockScreen ${appPreferences.callOnLockScreen.get()}, " +
-          "onForeground ${SimplexApp.context.isAppOnForeground}"
-    )
-    if (SimplexApp.context.isAppOnForeground) return
+  fun notifyCallInvitation(invitation: CallInvitation) {
+    if (isAppOnForeground(context)) return
     val contactId = invitation.contact.id
     Log.d(TAG, "notifyCallInvitation $contactId")
+    val keyguardManager = getKeyguardManager(context)
     val image = invitation.contact.image
-    val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
-    val screenOff = displayManager.displays.all { it.state != Display.STATE_ON }
     var ntfBuilder =
-      if ((keyguardManager.isKeyguardLocked || screenOff) && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
+      if (keyguardManager.isDeviceLocked && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
         val fullScreenIntent = Intent(context, IncomingCallActivity::class.java)
         val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        NotificationCompat.Builder(context, CallChannel)
+        NotificationCompat.Builder(context, LockScreenCallChannel)
           .setFullScreenIntent(fullScreenPendingIntent, true)
           .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+          .setSilent(true)
       } else {
         val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
-        val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, Intent(), PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
         NotificationCompat.Builder(context, CallChannel)
           .setContentIntent(chatPendingIntent(OpenChatAction, invitation.contact.id))
           .addAction(R.drawable.ntf_icon, generalGetString(R.string.accept), chatPendingIntent(AcceptCallAction, contactId))
-          .addAction(R.drawable.ntf_icon, generalGetString(R.string.reject), chatPendingIntent(RejectCallAction, contactId, true))
-          .setFullScreenIntent(fullScreenPendingIntent, true)
           .setSound(soundUri)
       }
     val text = generalGetString(
-      if (invitation.callType.media == CallMediaType.Video) {
+      if (invitation.peerMedia == CallMediaType.Video) {
         if (invitation.sharedKey == null) R.string.video_call_no_encryption else R.string.encrypted_video_call
       } else {
         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(title)
+      .setContentTitle(invitation.contact.displayName)
       .setContentText(text)
       .setPriority(NotificationCompat.PRIORITY_HIGH)
       .setCategory(NotificationCompat.CATEGORY_CALL)
       .setSmallIcon(R.drawable.ntf_icon)
-      .setLargeIcon(largeIcon)
+      .setLargeIcon(if (image == null) BitmapFactory.decodeResource(context.resources, R.drawable.icon) else base64ToBitmap(image))
       .setColor(0x88FFFF)
       .setAutoCancel(true)
-    val notification = ntfBuilder.build()
-    // This makes notification sound and vibration repeat endlessly
-    notification.flags = notification.flags or NotificationCompat.FLAG_INSISTENT
     with(NotificationManagerCompat.from(context)) {
-      notify(CallNotificationId, notification)
+      notify(CallNotificationId, ntfBuilder.build())
     }
   }
 
@@ -226,62 +148,33 @@ class NtfManager(val context: Context, private val appPreferences: AppPreference
     manager.cancel(CallNotificationId)
   }
 
-  fun hasNotificationsForChat(chatId: String): Boolean = manager.activeNotifications.any { it.id == chatId.hashCode() }
-
   private fun hideSecrets(cItem: ChatItem) : String {
     val md = cItem.formattedText
-    return if (md != null) {
+    return if (md == null) {
+      if (cItem.content.text != "") {
+        cItem.content.text
+      } else {
+        cItem.file?.fileName ?: ""
+      }
+    } else {
       var res = ""
       for (ft in md) {
         res += if (ft.format is Format.Secret) "..." else ft.text
       }
       res
-    } else {
-      cItem.text
     }
   }
 
-  private fun chatPendingIntent(intentAction: String, chatId: String? = null, broadcast: Boolean = false): PendingIntent {
+  private fun chatPendingIntent(intentAction: String, chatId: String? = null): PendingIntent {
     Log.d(TAG, "chatPendingIntent for $intentAction")
     val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
-    var intent = Intent(context, if (!broadcast) MainActivity::class.java else NtfActionReceiver::class.java)
+    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(ChatIdKey, chatId)
-    return if (!broadcast) {
-      TaskStackBuilder.create(context).run {
-        addNextIntentWithParentStack(intent)
-        getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
-      }
-    } else {
-      PendingIntent.getBroadcast(SimplexApp.context, uniqueInt, intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-    }
-  }
-
-  /**
-   * 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)
-        }
-        RejectCallAction -> {
-          val invitation = SimplexApp.context.chatModel.callInvitations[chatId]
-          if (invitation != null) {
-            SimplexApp.context.chatModel.callManager.endCall(invitation = invitation)
-          }
-        }
-        else -> {
-          Log.e(TAG, "Unknown action. Make sure you provide action from NotificationAction enum")
-        }
-      }
+    if (chatId != null) intent = intent.putExtra("chatId", chatId)
+    return TaskStackBuilder.create(context).run {
+      addNextIntentWithParentStack(intent)
+      getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
     }
   }
 }

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

@@ -7,7 +7,6 @@ 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)
@@ -16,14 +15,12 @@ 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, 12)
-val ToolbarDark = Color(80, 80, 80, 12)
+val ToolbarLight = Color(220, 220, 220, 20)
+val ToolbarDark = Color(80, 80, 80, 20)
 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,24 +1,11 @@
 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.*
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.SimplexApp
-import kotlinx.coroutines.flow.MutableStateFlow
 
-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(
+private val DarkColorPalette = darkColors(
   primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = DarkGray,
@@ -31,7 +18,7 @@ val DarkColorPalette = darkColors(
   onSurface = Color(0xFFFFFBFA),
 //  onError: Color = Color.Black,
 )
-val LightColorPalette = lightColors(
+private val LightColorPalette = lightColors(
   primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = LightGray,
@@ -43,32 +30,16 @@ val LightColorPalette = lightColors(
 //  onSurface = Color.Black,
 )
 
-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
+fun SimpleXTheme(darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
+  val colors = if (darkTheme) {
+    DarkColorPalette
+  } else {
+    LightColorPalette
+  }
 
-@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 = theme.first,
+    colors = colors,
     typography = Typography,
     shapes = Shapes,
     content = content

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

@@ -1,64 +0,0 @@
-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/ui/theme/Type.kt

@@ -13,7 +13,6 @@ val Inter = FontFamily(
   Font(R.font.inter_bold, weight = FontWeight.Bold),
   Font(R.font.inter_semi_bold, weight = FontWeight.SemiBold),
   Font(R.font.inter_medium, weight = FontWeight.Medium),
-  Font(R.font.inter_light, weight = FontWeight.Light),
 )
 
 // Set of Material typography styles to start with

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

@@ -1,121 +1,48 @@
 package chat.simplex.app.views
 
-import android.content.Context
 import android.content.res.Configuration
-import android.os.SystemClock
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Lock
 import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.fragment.app.FragmentActivity
-import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.*
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.chat.ComposeState
+import chat.simplex.app.views.chat.SendMsgView
 import chat.simplex.app.views.helpers.*
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
-
-private val lastSuccessfulAuth: MutableState<Long?> = mutableStateOf(null)
+import kotlinx.coroutines.launch
 
 @Composable
 fun TerminalView(chatModel: ChatModel, close: () -> Unit) {
   val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) }
-  val lastSuccessfulAuth = remember { lastSuccessfulAuth }
-  BackHandler(onBack = {
-    lastSuccessfulAuth.value = null
-    close()
-  })
-  val authorized = remember { !chatModel.controller.appPrefs.performLA.get() }
-  val context = LocalContext.current
-  LaunchedEffect(lastSuccessfulAuth.value) {
-    if (!authorized && !authorizedPreviously(lastSuccessfulAuth)) {
-      runAuth(lastSuccessfulAuth, context)
-    }
-  }
-  if (authorized || authorizedPreviously(lastSuccessfulAuth)) {
-    LaunchedEffect(Unit) {
-      // Update auth each time user visits this screen in authenticated state just to prolong authorized time
-      lastSuccessfulAuth.value = SystemClock.elapsedRealtime()
-    }
-    TerminalLayout(
-      chatModel.terminalItems,
-      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)
-            }
-          )
-        }
+  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"
       }
-    }
-  }
-}
-
-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
-      }
-    }
+    },
+    close
   )
 }
 
-private fun sendCommand(chatModel: ChatModel, composeState: MutableState<ComposeState>) {
-  val developerTools = chatModel.controller.appPrefs.developerTools.get()
-  val prefPerformLA = chatModel.controller.appPrefs.performLA.get()
-  val s = composeState.value.message
-  if (s.startsWith("/sql") && (!prefPerformLA || !developerTools)) {
-    val resp = CR.ChatCmdError(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>,
@@ -135,21 +62,7 @@ fun TerminalLayout(
       topBar = { CloseSheetBar(close) },
       bottomBar = {
         Box(Modifier.padding(horizontal = 8.dp)) {
-          SendMsgView(
-            composeState = composeState,
-            showVoiceRecordIcon = false,
-            recState = mutableStateOf(RecordingState.NotStarted),
-            isDirectChat = false,
-            liveMessageAlertShown = SharedPreference(get = { false }, set = {}),
-            needToAllowVoiceToContact = false,
-            allowedVoiceByPrefs = false,
-            allowVoiceToContact = {},
-            sendMessage = sendCommand,
-            sendLiveMessage = null,
-            updateLiveMessage = null,
-            ::onMessageChange,
-            textStyle
-          )
+          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
         }
       },
       modifier = Modifier.navigationBarsWithImePadding()
@@ -166,33 +79,33 @@ fun TerminalLayout(
   }
 }
 
-private var lazyListState = 0 to 0
-
 @Composable
 fun TerminalLog(terminalItems: List<TerminalItem>) {
-  val listState = rememberLazyListState(lazyListState.first, lazyListState.second)
-  DisposableEffect(Unit) {
-    onDispose { lazyListState = listState.firstVisibleItemIndex to listState.firstVisibleItemScrollOffset }
-  }
-  val reversedTerminalItems by remember { derivedStateOf { terminalItems.reversed() } }
-  LazyColumn(state = listState, reverseLayout = true) {
-    items(reversedTerminalItems) { item ->
-      Text(
-        "${item.date.toString().subSequence(11, 19)} ${item.label}",
+  val listState = rememberLazyListState()
+  val scope = rememberCoroutineScope()
+  LazyColumn(state = listState) {
+    items(terminalItems) { 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
-          .fillMaxWidth()
+          .padding(horizontal = 8.dp, vertical = 4.dp)
           .clickable {
             ModalManager.shared.showModal {
               SelectionContainer(modifier = Modifier.verticalScroll(rememberScrollState())) {
-                Text(item.details, modifier = Modifier.padding(horizontal = DEFAULT_PADDING).padding(bottom = DEFAULT_PADDING))
+                Text(item.details)
               }
             }
-          }.padding(horizontal = 8.dp, vertical = 4.dp)
+          }
       )
     }
+    val len = terminalItems.count()
+    if (len > 1) {
+      scope.launch {
+        listState.animateScrollToItem(len - 1)
+      }
+    }
   }
 }
 

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

@@ -1,6 +1,7 @@
 package chat.simplex.app.views
 
-import androidx.compose.foundation.*
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
@@ -25,13 +26,12 @@ 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.*
-import chat.simplex.app.views.helpers.AppBarTitle
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleButton
 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,9 +45,13 @@ fun CreateProfilePanel(chatModel: ChatModel) {
 
   Surface(Modifier.background(MaterialTheme.colors.onBackground)) {
     Column(
-      modifier = Modifier.fillMaxSize().verticalScroll(rememberScrollState())
+      modifier = Modifier.fillMaxSize()
     ) {
-      AppBarTitle(stringResource(R.string.create_profile), false)
+      Text(
+        stringResource(R.string.create_profile),
+        style = MaterialTheme.typography.h4,
+        modifier = Modifier.padding(vertical = 5.dp)
+      )
       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))
@@ -98,7 +102,6 @@ fun CreateProfilePanel(chatModel: ChatModel) {
       }
 
       LaunchedEffect(Unit) {
-        delay(300)
         focusRequester.requestFocus()
       }
     }
@@ -111,7 +114,9 @@ fun createProfile(chatModel: ChatModel, displayName: String, fullName: String) {
       Profile(displayName, fullName, null)
     )
     chatModel.controller.startChat(user)
-    chatModel.onboardingStage.value = OnboardingStage.Step3_SetNotificationsMode
+    SimplexService.start(chatModel.controller.appContext)
+    chatModel.controller.showBackgroundServiceNoticeIfNeeded()
+    chatModel.onboardingStage.value = OnboardingStage.OnboardingComplete
   }
 }
 

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

@@ -9,10 +9,11 @@ import kotlinx.datetime.Clock
 import kotlin.time.Duration.Companion.minutes
 
 class CallManager(val chatModel: ChatModel) {
-  fun reportNewIncomingCall(invitation: RcvCallInvitation) {
+  fun reportNewIncomingCall(invitation: CallInvitation) {
     Log.d(TAG, "CallManager.reportNewIncomingCall")
     with (chatModel) {
       callInvitations[invitation.contact.id] = invitation
+      if (!chatModel.controller.appPrefs.experimentalCalls.get()) return
       if (Clock.System.now() - invitation.callTs <= 3.minutes) {
         activeCallInvitation.value = invitation
         controller.ntfManager.notifyCallInvitation(invitation)
@@ -23,7 +24,7 @@ class CallManager(val chatModel: ChatModel) {
     }
   }
 
-  fun acceptIncomingCall(invitation: RcvCallInvitation) {
+  fun acceptIncomingCall(invitation: CallInvitation) {
     ModalManager.shared.closeModals()
     val call = chatModel.activeCall.value
     if (call == null) {
@@ -41,24 +42,17 @@ class CallManager(val chatModel: ChatModel) {
     }
   }
 
-  private fun justAcceptIncomingCall(invitation: RcvCallInvitation) {
+  private fun justAcceptIncomingCall(invitation: CallInvitation) {
     with (chatModel) {
       activeCall.value = Call(
         contact = invitation.contact,
         callState = CallState.InvitationAccepted,
-        localMedia = invitation.callType.media,
+        localMedia = invitation.peerMedia,
         sharedKey = invitation.sharedKey
       )
       showCallView.value = true
       val useRelay = controller.appPrefs.webrtcPolicyRelay.get()
-      val iceServers = getIceServers()
-      Log.d(TAG, "answerIncomingCall iceServers: $iceServers")
-      callCommand.value = WCallCommand.Start(
-        media = invitation.callType.media,
-        aesKey = invitation.sharedKey,
-        iceServers = iceServers,
-        relay = useRelay
-      )
+      callCommand.value = WCallCommand.Start (media = invitation.peerMedia, aesKey = invitation.sharedKey, relay = useRelay)
       callInvitations.remove(invitation.contact.id)
       if (invitation.contact.id == activeCallInvitation.value?.contact?.id) {
         activeCallInvitation.value = null
@@ -83,7 +77,7 @@ class CallManager(val chatModel: ChatModel) {
     }
   }
 
-  fun endCall(invitation: RcvCallInvitation) {
+  fun endCall(invitation: CallInvitation) {
     with (chatModel) {
       callInvitations.remove(invitation.contact.id)
       if (invitation.contact.id == activeCallInvitation.value?.contact?.id) {
@@ -98,7 +92,7 @@ class CallManager(val chatModel: ChatModel) {
     }
   }
 
-  fun reportCallRemoteEnded(invitation: RcvCallInvitation) {
+  fun reportCallRemoteEnded(invitation: CallInvitation) {
     if (chatModel.activeCallInvitation.value?.contact?.id == invitation.contact.id) {
       chatModel.activeCallInvitation.value = null
       chatModel.controller.ntfManager.cancelCallNotification()

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

@@ -1,13 +1,6 @@
 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.*
@@ -34,44 +27,23 @@ 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.*
+import kotlinx.coroutines.delay
 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()) {
     WebRTCView(chatModel.callCommand) { apiMsg ->
       Log.d(TAG, "received from WebRTCView: $apiMsg")
@@ -107,10 +79,6 @@ fun ActiveCallView(chatModel: ChatModel) {
             }
           is WCallResponse.Connected -> {
             chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo)
-            scope.launch {
-              delay(2000L)
-              setCallSound(cxt, call)
-            }
           }
           is WCallResponse.Ended -> {
             chatModel.activeCall.value = call.copy(callState = CallState.Ended)
@@ -145,68 +113,25 @@ 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
 private fun ActiveCallOverlay(call: Call, chatModel: ChatModel) {
-  var cxt = LocalContext.current
   ActiveCallOverlayLayout(
     call = call,
     dismiss = { withApi { chatModel.callManager.endCall(call) } },
     toggleAudio = { chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Audio, enable = !call.audioEnabled) },
     toggleVideo = { chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Video, enable = !call.videoEnabled) },
-    toggleSound = {
-      var call = chatModel.activeCall.value
-      if (call != null) {
-        call = call.copy(soundSpeaker = !call.soundSpeaker)
-        chatModel.activeCall.value = call
-        setCallSound(cxt, call)
-      }
-    },
     flipCamera = { chatModel.callCommand.value = WCallCommand.Camera(call.localCamera.flipped) }
   )
 }
 
-private fun setCallSound(cxt: Context, call: Call) {
-  Log.d(TAG, "setCallSound: set audio mode")
-  val am = cxt.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-  if (call.soundSpeaker) {
-    am.mode = AudioManager.MODE_NORMAL
-    am.isSpeakerphoneOn = true
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      am.availableCommunicationDevices.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_SPEAKER }?.let {
-        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)
-      }
-    }
-  }
-}
-
 @Composable
 private fun ActiveCallOverlayLayout(
   call: Call,
   dismiss: () -> Unit,
   toggleAudio: () -> Unit,
   toggleVideo: () -> Unit,
-  toggleSound: () -> Unit,
   flipCamera: () -> Unit
 ) {
   Column(Modifier.padding(16.dp)) {
@@ -249,11 +174,6 @@ private fun ActiveCallOverlayLayout(
           Box(Modifier.padding(start = 32.dp)) {
             ToggleAudioButton(call, toggleAudio)
           }
-          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
-            Box(Modifier.padding(end = 32.dp)) {
-              ToggleSoundButton(call, toggleSound)
-            }
-          }
         }
       }
     }
@@ -274,21 +194,12 @@ private fun ControlButton(call: Call, icon: ImageVector, @StringRes iconText: In
 @Composable
 private fun ToggleAudioButton(call: Call, toggleAudio: () -> Unit) {
   if (call.audioEnabled) {
-    ControlButton(call, Icons.Outlined.Mic, R.string.icon_descr_audio_off, toggleAudio)
+    ControlButton(call, Icons.Outlined.Mic, R.string.icon_descr_video_off, toggleAudio)
   } else {
     ControlButton(call, Icons.Outlined.MicOff, R.string.icon_descr_audio_on, toggleAudio)
   }
 }
 
-@Composable
-private fun ToggleSoundButton(call: Call, toggleSound: () -> Unit) {
-  if (call.soundSpeaker) {
-    ControlButton(call, Icons.Outlined.VolumeUp, R.string.icon_descr_speaker_off, toggleSound)
-  } else {
-    ControlButton(call, Icons.Outlined.VolumeDown, R.string.icon_descr_speaker_on, toggleSound)
-  }
-}
-
 @Composable
 fun CallInfoView(call: Call, alignment: Alignment.Horizontal) {
   @Composable fun InfoText(text: String, style: TextStyle = MaterialTheme.typography.body2) =
@@ -356,7 +267,6 @@ 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(
@@ -382,8 +292,6 @@ 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) {
@@ -435,7 +343,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)
-        scope.launch {
+        withApi {
           delay(2000L)
           wv.evaluateJavascript("sendMessageToNative = (msg) => WebRTCInterface.postMessage(JSON.stringify(msg))", null)
           webView.value = wv
@@ -485,7 +393,6 @@ fun PreviewActiveCallOverlayVideo() {
       dismiss = {},
       toggleAudio = {},
       toggleVideo = {},
-      toggleSound = {},
       flipCamera = {}
     )
   }
@@ -506,7 +413,6 @@ fun PreviewActiveCallOverlayAudio() {
       dismiss = {},
       toggleAudio = {},
       toggleVideo = {},
-      toggleSound = {},
       flipCamera = {}
     )
   }

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

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

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

@@ -24,7 +24,7 @@ import chat.simplex.app.views.usersettings.ProfilePreview
 import kotlinx.datetime.Clock
 
 @Composable
-fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
+fun IncomingCallAlertView(invitation: CallInvitation, chatModel: ChatModel) {
   val cm = chatModel.callManager
   val cxt = LocalContext.current
   val scope = rememberCoroutineScope()
@@ -33,43 +33,37 @@ fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
   IncomingCallAlertLayout(
     invitation,
     rejectCall = { cm.endCall(invitation = invitation) },
-    ignoreCall = {
-      chatModel.activeCallInvitation.value = null
-      chatModel.controller.ntfManager.cancelCallNotification()
-    },
+    ignoreCall = { chatModel.activeCallInvitation.value = null },
     acceptCall = { cm.acceptIncomingCall(invitation = invitation) }
   )
 }
 
 @Composable
 fun IncomingCallAlertLayout(
-  invitation: RcvCallInvitation,
+  invitation: CallInvitation,
   rejectCall: () -> Unit,
   ignoreCall: () -> Unit,
   acceptCall: () -> Unit
 ) {
-  val color = if (isInDarkTheme()) IncomingCallDark else IncomingCallLight
-  Column(Modifier.fillMaxWidth().background(color).padding(top = 16.dp, bottom = 16.dp, start = 16.dp, end = 8.dp)) {
+  val color = if (isSystemInDarkTheme()) IncomingCallDark else IncomingCallLight
+  Column(Modifier.background(color).padding(top = 16.dp, bottom = 16.dp, start = 16.dp, end = 8.dp)) {
     IncomingCallInfo(invitation)
     Spacer(Modifier.height(8.dp))
-    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)
-      }
+    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)
     }
   }
 }
 
 @Composable
-fun IncomingCallInfo(invitation: RcvCallInvitation) {
+fun IncomingCallInfo(invitation: CallInvitation) {
   @Composable fun CallIcon(icon: ImageVector, descr: String) = Icon(icon, descr, tint = SimplexGreen)
   Row {
-    if (invitation.callType.media == CallMediaType.Video) CallIcon(Icons.Filled.Videocam, stringResource(R.string.icon_descr_video_call))
+    if (invitation.peerMedia == CallMediaType.Video) CallIcon(Icons.Filled.Videocam, stringResource(R.string.icon_descr_video_call))
     else CallIcon(Icons.Filled.Phone, stringResource(R.string.icon_descr_audio_call))
     Spacer(Modifier.width(4.dp))
     Text(invitation.callTypeText)
@@ -100,9 +94,9 @@ private fun CallButton(text: String, icon: ImageVector, color: Color, action: ()
 fun PreviewIncomingCallAlertLayout() {
   SimpleXTheme {
     IncomingCallAlertLayout(
-      invitation = RcvCallInvitation(
+      invitation = CallInvitation(
         contact = Contact.sampleData,
-        callType = CallType(media = CallMediaType.Audio, capabilities = CallCapabilities(encryption = false)),
+        peerMedia = CallMediaType.Audio,
         sharedKey = null,
         callTs = Clock.System.now()
       ),

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

@@ -1,33 +1,21 @@
 package chat.simplex.app.views.call
 
 import android.content.Context
-import android.media.*
-import android.net.Uri
+import android.media.MediaPlayer
 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 {
-  private var player: MediaPlayer? = null
+  var player: MediaPlayer? = null
   var playing = false
 
   fun start(cxt: Context, scope: CoroutineScope, sound: Boolean) {
-    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()
-    }
+    if (sound) player = MediaPlayer.create(cxt, R.raw.ring_once)
     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,13 +3,11 @@ 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,
@@ -20,7 +18,6 @@ data class Call(
   val sharedKey: String? = null,
   val audioEnabled: Boolean = true,
   val videoEnabled: Boolean = localMedia == CallMediaType.Video,
-  val soundSpeaker: Boolean = localMedia == CallMediaType.Video,
   var localCamera: VideoCamera = VideoCamera.User,
   val connectionInfo: ConnectionInfo? = null
 ) {
@@ -93,12 +90,12 @@ 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? = null, val callTs: Instant) {
-  val callTypeText: String get() = generalGetString(when(callType.media) {
+@Serializable class CallInvitation(val contact: Contact, val peerMedia: CallMediaType, val sharedKey: String?, val callTs: Instant) {
+  val callTypeText: String get() = generalGetString(when(peerMedia) {
     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
   })
-  val callTitle: String get() = generalGetString(when(callType.media) {
+  val callTitle: String get() = generalGetString(when(peerMedia) {
     CallMediaType.Video -> R.string.incoming_video_call
     CallMediaType.Audio -> R.string.incoming_audio_call
   })
@@ -117,7 +114,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 data class RTCIceServer(val urls: List<String>, val username: String? = null, val credential: String? = null)
+@Serializable 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
@@ -155,48 +152,4 @@ 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,115 +1,43 @@
 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.background
 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.*
-import androidx.compose.runtime.saveable.rememberSaveable
+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.ClipboardManager
-import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
-import chat.simplex.app.SimplexApp
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.*
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.*
-import kotlinx.datetime.Clock
 
 @Composable
-fun ChatInfoView(
-  chatModel: ChatModel,
-  contact: Contact,
-  connStats: ConnectionStats?,
-  customUserProfile: Profile?,
-  localAlias: String,
-  connectionCode: String?,
-  close: () -> Unit,
-) {
+fun ChatInfoView(chatModel: ChatModel, 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,
-      connectionCode,
-      developerTools,
-      onLocalAliasChanged = {
-        setContactAlias(chat.chatInfo.apiId, it, chatModel)
-      },
-      openPreferences = {
-        ModalManager.shared.showCustomModal { close ->
-          val user = chatModel.currentUser.value
-          if (user != null) {
-            ContactPreferencesView(chatModel, user, contact.contactId, close)
-          }
-        }
-      },
+      close = close,
       deleteContact = { deleteContactDialog(chat.chatInfo, chatModel, close) },
-      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
-      switchContactAddress = {
-        showSwitchContactAddressAlert(chatModel, contact.contactId)
-      },
-      verifyClicked = {
-        ModalManager.shared.showModalCloseable { close ->
-          remember { derivedStateOf { (chatModel.getContactChat(contact.contactId)?.chatInfo as? ChatInfo.Direct)?.contact } }.value?.let { ct ->
-            VerifyCodeView(
-              ct.displayName,
-              connectionCode,
-              ct.verified,
-              verify = { code ->
-                chatModel.controller.apiVerifyContact(ct.contactId, code)?.let { r ->
-                  val (verified, existingCode) = r
-                  chatModel.updateContact(
-                    ct.copy(
-                      activeConn = ct.activeConn.copy(
-                        connectionCode = if (verified) SecurityCode(existingCode, Clock.System.now()) else null
-                      )
-                    )
-                  )
-                  r
-                }
-              },
-              close,
-            )
-          }
-        }
-      }
+      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) }
     )
   }
 }
 
 fun deleteContactDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
   AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.delete_contact_question),
+    title = generalGetString(R.string.delete_contact__question),
     text = generalGetString(R.string.delete_contact_all_messages_deleted_cannot_undo_warning),
     confirmText = generalGetString(R.string.delete_verb),
     onConfirm = {
@@ -147,298 +75,110 @@ fun clearChatDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit
 @Composable
 fun ChatInfoLayout(
   chat: Chat,
-  contact: Contact,
-  connStats: ConnectionStats?,
-  customUserProfile: Profile?,
-  localAlias: String,
-  connectionCode: String?,
-  developerTools: Boolean,
-  onLocalAliasChanged: (String) -> Unit,
-  openPreferences: () -> Unit,
+  close: () -> Unit,
   deleteContact: () -> Unit,
-  clearChat: () -> Unit,
-  switchContactAddress: () -> Unit,
-  verifyClicked: () -> Unit,
+  clearChat: () -> Unit
 ) {
   Column(
     Modifier
-      .fillMaxWidth()
-      .verticalScroll(rememberScrollState()),
-    horizontalAlignment = Alignment.Start
-  ) {
-    Row(
-      Modifier.fillMaxWidth(),
-      horizontalArrangement = Arrangement.Center
-    ) {
-      ChatInfoHeader(chat.chatInfo, contact)
-    }
-
-    LocalAliasEditor(localAlias, updateValue = onLocalAliasChanged)
-
-    if (customUserProfile != null) {
-      SectionSpacer()
-      SectionView(generalGetString(R.string.incognito).uppercase()) {
-        InfoRow(generalGetString(R.string.incognito_random_profile), customUserProfile.chatViewName)
-      }
-    }
-
-    SectionSpacer()
-    SectionView {
-      if (connectionCode != null) {
-        VerifyCodeButton(contact.verified, verifyClicked)
-        SectionDivider()
-      }
-      ContactPreferencesButton(openPreferences)
-    }
-
-    SectionSpacer()
-
-    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
-        if (rcvServers != null && rcvServers.isNotEmpty()) {
-          SectionDivider()
-          SimplexServers(stringResource(R.string.receiving_via), rcvServers)
-        }
-        val sndServers = connStats.sndServers
-        if (sndServers != null && sndServers.isNotEmpty()) {
-          SectionDivider()
-          SimplexServers(stringResource(R.string.sending_via), sndServers)
-        }
-      }
-    }
-    SectionSpacer()
-    SectionView {
-      ClearChatButton(clearChat)
-      SectionDivider()
-      DeleteContactButton(deleteContact)
-    }
-    SectionSpacer()
-
-    if (developerTools) {
-      SectionView(title = stringResource(R.string.section_title_for_console)) {
-        InfoRow(stringResource(R.string.info_row_local_name), chat.chatInfo.localDisplayName)
-        SectionDivider()
-        InfoRow(stringResource(R.string.info_row_database_id), chat.chatInfo.apiId.toString())
-      }
-      SectionSpacer()
-    }
-  }
-}
-
-@Composable
-fun ChatInfoHeader(cInfo: ChatInfo, contact: Contact) {
-  Column(
-    Modifier.padding(horizontal = 8.dp),
+      .fillMaxSize()
+      .background(MaterialTheme.colors.background)
+      .padding(horizontal = 8.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Row(Modifier.padding(bottom = 8.dp), verticalAlignment = Alignment.CenterVertically) {
-      if (contact.verified) {
-        Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 6.dp, top = 4.dp).size(24.dp), tint = HighOrLowlight)
-      }
-      Text(
-        contact.profile.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-        color = MaterialTheme.colors.onBackground,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-      )
-    }
-    if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName && cInfo.fullName != contact.profile.displayName) {
-      Text(
-        cInfo.fullName, style = MaterialTheme.typography.h2,
-        color = MaterialTheme.colors.onBackground,
-        maxLines = 2,
-        overflow = TextOverflow.Ellipsis
-      )
-    }
-  }
-}
+    CloseSheetBar(close)
+    Spacer(Modifier.size(48.dp))
+    val cInfo = chat.chatInfo
+    ChatInfoImage(cInfo, size = 192.dp)
+    Text(
+      cInfo.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+      color = MaterialTheme.colors.onBackground,
+      modifier = Modifier
+        .padding(top = 32.dp)
+        .padding(bottom = 8.dp)
+    )
+    Text(
+      cInfo.fullName, style = MaterialTheme.typography.h2,
+      color = MaterialTheme.colors.onBackground,
+      modifier = Modifier.padding(bottom = 16.dp)
+    )
 
-@Composable
-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,
-      {
+    if (cInfo is ChatInfo.Direct) {
+      Column(horizontalAlignment = Alignment.CenterHorizontally) {
+        Row(Modifier.padding(horizontal = 32.dp)) {
+          ServerImage(chat)
+          Text(
+            chat.serverInfo.networkStatus.statusString,
+            textAlign = TextAlign.Center,
+            color = MaterialTheme.colors.onBackground,
+            modifier = Modifier.padding(start = 8.dp)
+          )
+        }
         Text(
-          generalGetString(R.string.text_field_set_contact_placeholder),
-          textAlign = if (center) TextAlign.Center else TextAlign.Start,
-          color = HighOrLowlight
+          chat.serverInfo.networkStatus.statusExplanation,
+          style = MaterialTheme.typography.body2,
+          color = MaterialTheme.colors.onBackground,
+          textAlign = TextAlign.Center,
+          modifier = Modifier
+            .padding(top = 16.dp)
+            .padding(horizontal = 16.dp)
         )
-      },
-      leadingIcon = if (leadingIcon) {
-        { Icon(Icons.Default.Edit, null, Modifier.padding(start = 7.dp)) }
-      } else null,
-      color = HighOrLowlight,
-      focus = focus,
-      textStyle = TextStyle.Default.copy(textAlign = if (value.isEmpty() || !center) TextAlign.Start else TextAlign.Center),
-      keyboardActions = KeyboardActions(onDone = { updateValue(value) })
-    ) {
-      value = it
-    }
-  }
-  LaunchedEffect(Unit) {
-    snapshotFlow { value }
-      .onEach { delay(500) } // wait a little after every new character, don't emit until user stops typing
-      .conflate() // get the latest value
-      .filter { it == value } // don't process old ones
-      .collect {
-        updateValue(value)
       }
-  }
-  DisposableEffect(Unit) {
-    onDispose { updateValue(value) } // just in case snapshotFlow will be canceled when user presses Back too fast
-  }
-}
 
-@Composable
-private fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
-  Row(
-    Modifier.fillMaxSize(),
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Row(
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-      Text(stringResource(R.string.network_status))
-      Icon(
-        Icons.Outlined.Info,
-        stringResource(R.string.network_status),
-        tint = MaterialTheme.colors.primary
-      )
-    }
+      Spacer(Modifier.weight(1F))
 
-    Row(
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-      Text(
-        networkStatus.statusString,
-        color = HighOrLowlight
-      )
-      ServerImage(networkStatus)
+      Box(Modifier.padding(4.dp)) {
+        SimpleButton(
+          stringResource(R.string.clear_chat_button),
+          icon = Icons.Outlined.Restore,
+          color = WarningOrange,
+          click = clearChat
+        )
+      }
+      Box(
+        Modifier
+          .padding(4.dp)
+          .padding(bottom = 32.dp)
+      ) {
+        SimpleButton(
+          stringResource(R.string.button_delete_contact),
+          icon = Icons.Outlined.Delete,
+          color = Color.Red,
+          click = deleteContact
+        )
+      }
+    } else if (cInfo is ChatInfo.Group) {
+      Spacer(Modifier.weight(1F))
+
+      Box(
+        Modifier
+          .padding(4.dp)
+          .padding(bottom = 32.dp)
+      ) {
+        SimpleButton(
+          stringResource(R.string.clear_chat_button),
+          icon = Icons.Outlined.Restore,
+          color = WarningOrange,
+          click = clearChat
+        )
+      }
     }
   }
 }
 
 @Composable
-private fun ServerImage(networkStatus: Chat.NetworkStatus) {
-  Box(Modifier.size(18.dp)) {
-    when (networkStatus) {
-      is Chat.NetworkStatus.Connected ->
-        Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_server_status_connected), tint = MaterialTheme.colors.primaryVariant)
-      is Chat.NetworkStatus.Disconnected ->
-        Icon(Icons.Filled.Pending, stringResource(R.string.icon_descr_server_status_disconnected), tint = HighOrLowlight)
-      is Chat.NetworkStatus.Error ->
-        Icon(Icons.Filled.Error, stringResource(R.string.icon_descr_server_status_error), tint = HighOrLowlight)
-      else -> Icon(Icons.Outlined.Circle, stringResource(R.string.icon_descr_server_status_pending), tint = HighOrLowlight)
-    }
+fun ServerImage(chat: Chat) {
+  when (chat.serverInfo.networkStatus) {
+    is Chat.NetworkStatus.Connected ->
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_server_status_connected), tint = MaterialTheme.colors.primaryVariant)
+    is Chat.NetworkStatus.Disconnected ->
+      Icon(Icons.Filled.Pending, stringResource(R.string.icon_descr_server_status_disconnected), tint = HighOrLowlight)
+    is Chat.NetworkStatus.Error ->
+      Icon(Icons.Filled.Error, stringResource(R.string.icon_descr_server_status_error), tint = HighOrLowlight)
+    else -> Icon(Icons.Outlined.Circle, stringResource(R.string.icon_descr_server_status_pending), tint = HighOrLowlight)
   }
 }
 
-@Composable
-fun SimplexServers(text: String, servers: List<String>) {
-  val info = servers.joinToString(separator = ", ") { it.substringAfter("@") }
-  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 SwitchAddressButton(onClick: () -> Unit) {
-  SectionItemView(onClick) {
-    Text(stringResource(R.string.switch_receiving_address), color = MaterialTheme.colors.primary)
-  }
-}
-
-@Composable
-fun VerifyCodeButton(contactVerified: Boolean, onClick: () -> Unit) {
-  SettingsActionItem(
-    if (contactVerified) Icons.Outlined.VerifiedUser else Icons.Outlined.Shield,
-    stringResource(if (contactVerified) R.string.view_security_code else R.string.verify_security_code),
-    click = onClick,
-    iconColor = HighOrLowlight,
-  )
-}
-
-@Composable
-private fun ContactPreferencesButton(onClick: () -> Unit) {
-  SettingsActionItem(
-    Icons.Outlined.ToggleOn,
-    stringResource(R.string.contact_preferences),
-    click = onClick
-  )
-}
-
-@Composable
-fun ClearChatButton(onClick: () -> Unit) {
-  SettingsActionItem(
-    Icons.Outlined.Restore,
-    stringResource(R.string.clear_chat_button),
-    click = onClick,
-    textColor = WarningOrange,
-    iconColor = WarningOrange,
-  )
-}
-
-@Composable
-private fun DeleteContactButton(onClick: () -> Unit) {
-  SettingsActionItem(
-    Icons.Outlined.Delete,
-    stringResource(R.string.button_delete_contact),
-    click = onClick,
-    textColor = Color.Red,
-    iconColor = Color.Red,
-  )
-}
-
-private fun setContactAlias(contactApiId: Long, localAlias: String, chatModel: ChatModel) = withApi {
-  chatModel.controller.apiSetContactAlias(contactApiId, localAlias)?.let {
-    chatModel.updateContact(it)
-  }
-}
-
-private fun showSwitchContactAddressAlert(m: ChatModel, contactId: Long) {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.switch_receiving_address_question),
-    text = generalGetString(R.string.switch_receiving_address_desc),
-    confirmText = generalGetString(R.string.switch_verb),
-    onConfirm = {
-      switchContactAddress(m, contactId)
-    }
-  )
-}
-
-private fun switchContactAddress(m: ChatModel, contactId: Long) = withApi {
-  m.controller.apiSwitchContact(contactId)
-}
-
 @Preview
 @Composable
 fun PreviewChatInfoLayout() {
@@ -449,18 +189,7 @@ fun PreviewChatInfoLayout() {
         chatItems = arrayListOf(),
         serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
       ),
-      Contact.sampleData,
-      localAlias = "",
-      connectionCode = "123",
-      developerTools = false,
-      connStats = null,
-      onLocalAliasChanged = {},
-      customUserProfile = null,
-      openPreferences = {},
-      deleteContact = {},
-      clearChat = {},
-      switchContactAddress = {},
-      verifyClicked = {},
+      close = {}, deleteContact = {}, clearChat = {}
     )
   }
 }

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

@@ -1,4 +1,5 @@
 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
@@ -30,7 +31,7 @@ fun ComposeFileView(fileName: String, cancelFile: () -> Unit, cancelEnabled: Boo
       Modifier
         .padding(start = 4.dp, end = 2.dp)
         .size(36.dp),
-      tint = if (isInDarkTheme()) FileDark else FileLight
+      tint = if (isSystemInDarkTheme()) FileDark else FileLight
     )
     Text(fileName)
     Spacer(Modifier.weight(1f))

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

@@ -1,51 +1,45 @@
-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.*
+import androidx.compose.runtime.Composable
 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(images: List<String>, cancelImages: () -> Unit, cancelEnabled: Boolean) {
+fun ComposeImageView(image: String, cancelImage: () -> Unit, cancelEnabled: Boolean) {
   Row(
     Modifier
+      .fillMaxWidth()
       .padding(top = 8.dp)
       .background(SentColorLight),
-    verticalAlignment = Alignment.CenterVertically,
+    verticalAlignment = Alignment.CenterVertically
   ) {
-    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)
-        )
-      }
-    }
+    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))
     if (cancelEnabled) {
-      IconButton(onClick = cancelImages) {
+      IconButton(onClick = cancelImage, modifier = Modifier.padding(0.dp)) {
         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,87 +1,71 @@
 package chat.simplex.app.views.chat
 
-import ComposeVoiceView
 import ComposeFileView
+import ComposeImageView
 import android.Manifest
 import android.app.Activity
-import android.content.*
+import android.content.Context
+import android.content.Intent
 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.*
+import androidx.compose.material.Icon
+import androidx.compose.material.MaterialTheme
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
+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.net.toFile
-import androidx.core.net.toUri
+import androidx.core.content.FileProvider
 import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.views.chat.item.*
 import chat.simplex.app.views.helpers.*
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.runBlocking
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.decodeFromString
 import java.io.File
 
-@Serializable
 sealed class ComposePreview {
-  @Serializable object NoPreview: ComposePreview()
-  @Serializable class CLinkPreview(val linkPreview: LinkPreview?): ComposePreview()
-  @Serializable class ImagePreview(val images: List<String>): ComposePreview()
-  @Serializable class VoicePreview(val voice: String, val durationMs: Int, val finished: Boolean): ComposePreview()
-  @Serializable class FilePreview(val fileName: String): ComposePreview()
+  object NoPreview: ComposePreview()
+  class CLinkPreview(val linkPreview: LinkPreview?): ComposePreview()
+  class ImagePreview(val image: String): ComposePreview()
+  class FilePreview(val fileName: String): ComposePreview()
 }
 
-@Serializable
 sealed class ComposeContextItem {
-  @Serializable object NoContextItem: ComposeContextItem()
-  @Serializable class QuotedItem(val chatItem: ChatItem): ComposeContextItem()
-  @Serializable class EditingItem(val chatItem: ChatItem): ComposeContextItem()
+  object NoContextItem: ComposeContextItem()
+  class QuotedItem(val chatItem: ChatItem): ComposeContextItem()
+  class EditingItem(val chatItem: ChatItem): ComposeContextItem()
 }
 
-@Serializable
-data class LiveMessage(
-  val chatItem: ChatItem,
-  val typedMsg: String,
-  val sentMsg: String
-)
-
-@Serializable
 data class ComposeState(
   val message: String = "",
-  val liveMessage: LiveMessage? = null,
   val preview: ComposePreview = ComposePreview.NoPreview,
   val contextItem: ComposeContextItem = ComposeContextItem.NoContextItem,
   val inProgress: Boolean = false,
   val useLinkPreviews: Boolean
 ) {
-  constructor(editingItem: ChatItem, liveMessage: LiveMessage? = null, useLinkPreviews: Boolean): this(
+  constructor(editingItem: ChatItem, useLinkPreviews: Boolean): this (
     editingItem.content.text,
-    liveMessage,
     chatItemPreview(editingItem),
     ComposeContextItem.EditingItem(editingItem),
     useLinkPreviews = useLinkPreviews
@@ -97,9 +81,8 @@ data class ComposeState(
     get() = {
       val hasContent = when (preview) {
         is ComposePreview.ImagePreview -> true
-        is ComposePreview.VoicePreview -> true
         is ComposePreview.FilePreview -> true
-        else -> message.isNotEmpty() || liveMessage != null
+        else -> message.isNotEmpty()
       }
       hasContent && !inProgress
     }
@@ -107,7 +90,6 @@ data class ComposeState(
     get() =
       when (preview) {
         is ComposePreview.ImagePreview -> false
-        is ComposePreview.VoicePreview -> false
         is ComposePreview.FilePreview -> false
         else -> useLinkPreviews
       }
@@ -117,47 +99,18 @@ data class ComposeState(
         is ComposePreview.CLinkPreview -> preview.linkPreview
         else -> null
       }
-
-  val attachmentDisabled: Boolean
-    get() {
-      if (editing || liveMessage != null) return true
-      return when (preview) {
-        ComposePreview.NoPreview -> false
-        is ComposePreview.CLinkPreview -> false
-        else -> true
-      }
-    }
-
-  companion object {
-    fun saver(): Saver<MutableState<ComposeState>, *> = Saver(
-      save = { json.encodeToString(serializer(), it.value) },
-      restore = {
-        mutableStateOf(json.decodeFromString(it))
-      }
-    )
-  }
-}
-
-sealed class RecordingState {
-  object NotStarted: RecordingState()
-  class Started(val filePath: String, val progressMs: Int = 0): RecordingState()
-  class Finished(val filePath: String, val durationMs: Int): RecordingState()
-
-  val filePathNullable: String?
-    get() = (this as? Started)?.filePath
 }
 
 fun chatItemPreview(chatItem: ChatItem): ComposePreview {
   return when (val mc = chatItem.content.msgContent) {
     is MsgContent.MCText -> ComposePreview.NoPreview
     is MsgContent.MCLink -> ComposePreview.CLinkPreview(linkPreview = mc.preview)
-    is MsgContent.MCImage -> ComposePreview.ImagePreview(images = listOf(mc.image))
-    is MsgContent.MCVoice -> ComposePreview.VoicePreview(voice = chatItem.file?.fileName ?: "", mc.duration / 1000, true)
+    is MsgContent.MCImage -> ComposePreview.ImagePreview(image = mc.image)
     is MsgContent.MCFile -> {
       val fileName = chatItem.file?.fileName ?: ""
       ComposePreview.FilePreview(fileName)
     }
-    is MsgContent.MCUnknown, null -> ComposePreview.NoPreview
+    else -> ComposePreview.NoPreview
   }
 }
 
@@ -170,86 +123,80 @@ fun ComposeView(
   showChooseAttachment: () -> Unit
 ) {
   val context = LocalContext.current
-  val linkUrl = rememberSaveable { mutableStateOf<String?>(null) }
-  val prevLinkUrl = rememberSaveable { mutableStateOf<String?>(null) }
-  val pendingLinkUrl = rememberSaveable { mutableStateOf<String?>(null) }
-  val cancelledLinks = rememberSaveable { mutableSetOf<String>() }
+  val linkUrl = remember { mutableStateOf<String?>(null) }
+  val prevLinkUrl = remember { mutableStateOf<String?>(null) }
+  val pendingLinkUrl = remember { mutableStateOf<String?>(null) }
+  val cancelledLinks = remember { 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 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 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 imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
-      chosenContent.value = listOf(UploadContent.SimpleImage(uri))
-      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(listOf(imagePreview)))
+      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
     }
   }
   val cameraPermissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
     if (isGranted) {
-      cameraLauncher.launchWithFallback()
+      cameraLauncher.launch(null)
     } else {
       Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
     }
   }
-  val processPickedImage = { uris: List<Uri>, text: String? ->
-    val content = ArrayList<UploadContent>()
-    val imagesPreview = ArrayList<String>()
-    uris.forEach { uri ->
+  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
+    if (uri != null) {
       val source = ImageDecoder.createSource(context.contentResolver, uri)
-      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 bitmap = ImageDecoder.decodeBitmap(source)
+      chosenImage.value = bitmap
+      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
     }
   }
-  val processPickedFile = { uri: Uri?, text: String? ->
+  val filesLauncher = rememberGetContentLauncher { uri: Uri? ->
     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(message = text ?: composeState.value.message, preview = ComposePreview.FilePreview(fileName))
+          composeState.value = composeState.value.copy(preview = ComposePreview.FilePreview(fileName))
         }
       } else {
         AlertManager.shared.showAlertMsg(
@@ -259,17 +206,13 @@ fun ComposeView(
       }
     }
   }
-  val galleryLauncher = rememberLauncherForActivityResult(contract = PickMultipleFromGallery()) { processPickedImage(it, null) }
-  val galleryLauncherFallback = rememberGetMultipleContentsLauncher { processPickedImage(it, null) }
-  val filesLauncher = rememberGetContentLauncher { processPickedFile(it, null) }
-  val recState: MutableState<RecordingState> = remember { mutableStateOf(RecordingState.NotStarted) }
 
   LaunchedEffect(attachmentOption.value) {
     when (attachmentOption.value) {
       AttachmentOption.TakePhoto -> {
         when (PackageManager.PERMISSION_GRANTED) {
           ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
-            cameraLauncher.launchWithFallback()
+            cameraLauncher.launch(null)
           }
           else -> {
             cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
@@ -278,11 +221,7 @@ fun ComposeView(
         attachmentOption.value = null
       }
       AttachmentOption.PickImage -> {
-        try {
-          galleryLauncher.launch(0)
-        } catch (e: ActivityNotFoundException) {
-          galleryLauncherFallback.launch("image/*")
-        }
+        galleryLauncher.launch("image/*")
         attachmentOption.value = null
       }
       AttachmentOption.PickFile -> {
@@ -311,9 +250,6 @@ 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
         }
       }
     }
@@ -340,157 +276,111 @@ fun ComposeView(
     cancelledLinks.clear()
   }
 
-  fun clearState(live: Boolean = false) {
-    if (live) {
-      composeState.value = composeState.value.copy(inProgress = false)
-    } else {
-      composeState.value = ComposeState(useLinkPreviews = useLinkPreviews)
-      resetLinkPreview()
-    }
-    recState.value = RecordingState.NotStarted
-    textStyle.value = smallFont
-    chosenContent.value = emptyList()
-    chosenAudio.value = null
-    chosenFile.value = null
-  }
-
-  suspend fun send(cInfo: ChatInfo, mc: MsgContent, quoted: Long?, file: String? = null, live: Boolean = false): ChatItem? {
-    val aChatItem = chatModel.controller.apiSendMessage(
-      type = cInfo.chatType,
-      id = cInfo.apiId,
-      file = file,
-      quotedItemId = quoted,
-      mc = mc,
-      live = live
-    )
-    if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
-    return aChatItem?.chatItem
-  }
-
-
-
-  suspend fun sendMessageAsync(text: String?, live: Boolean): ChatItem? {
-    val cInfo = chat.chatInfo
+  fun checkLinkPreview(): MsgContent {
     val cs = composeState.value
-    var sent: ChatItem?
-    val msgText = text ?: cs.message
-
-    fun sending() {
-      composeState.value = composeState.value.copy(inProgress = true)
-    }
-
-    fun checkLinkPreview(): MsgContent {
-      return when (val composePreview = cs.preview) {
-        is ComposePreview.CLinkPreview -> {
-          val url = parseMessage(msgText)
-          val lp = composePreview.linkPreview
-          if (lp != null && url == lp.uri) {
-            MsgContent.MCLink(msgText, preview = lp)
-          } else {
-            MsgContent.MCText(msgText)
-          }
-        }
-        else -> MsgContent.MCText(msgText)
-      }
-    }
-
-    fun updateMsgContent(msgContent: MsgContent): MsgContent {
-      return when (msgContent) {
-        is MsgContent.MCText -> checkLinkPreview()
-        is MsgContent.MCLink -> checkLinkPreview()
-        is MsgContent.MCImage -> MsgContent.MCImage(msgText, image = msgContent.image)
-        is MsgContent.MCVoice -> MsgContent.MCVoice(msgText, duration = msgContent.duration)
-        is MsgContent.MCFile -> MsgContent.MCFile(msgText)
-        is MsgContent.MCUnknown -> MsgContent.MCUnknown(type = msgContent.type, text = msgText, json = msgContent.json)
-      }
-    }
-
-    suspend fun updateMessage(ei: ChatItem, cInfo: ChatInfo, live: Boolean): ChatItem? {
-      val oldMsgContent = ei.content.msgContent
-      if (oldMsgContent != null) {
-        val updatedItem = chatModel.controller.apiUpdateChatItem(
-          type = cInfo.chatType,
-          id = cInfo.apiId,
-          itemId = ei.meta.itemId,
-          mc = updateMsgContent(oldMsgContent),
-          live = live
-        )
-        if (updatedItem != null) chatModel.upsertChatItem(cInfo, updatedItem.chatItem)
-        return updatedItem?.chatItem
-      }
-      return null
-    }
-
-    if (!live) {
-      sending()
-    }
-
-    if (cs.contextItem is ComposeContextItem.EditingItem) {
-      val ei = cs.contextItem.chatItem
-      sent = updateMessage(ei, cInfo, live)
-    } else if (cs.liveMessage != null) {
-      sent = updateMessage(cs.liveMessage.chatItem, cInfo, live)
-    } else {
-      val msgs: ArrayList<MsgContent> = ArrayList()
-      val files: ArrayList<String> = ArrayList()
-      when (val preview = cs.preview) {
-        ComposePreview.NoPreview -> msgs.add(MsgContent.MCText(msgText))
-        is ComposePreview.CLinkPreview -> msgs.add(checkLinkPreview())
-        is ComposePreview.ImagePreview -> {
-          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 (chosenContent.value.lastIndex == index) msgText 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())
-            AudioPlayer.stop(chosenAudioVal.first.toFile().absolutePath)
-            msgs.add(MsgContent.MCVoice(if (msgs.isEmpty()) msgText else "", chosenAudioVal.second / 1000))
-          }
-        }
-        is ComposePreview.FilePreview -> {
-          val chosenFileVal = chosenFile.value
-          if (chosenFileVal != null) {
-            val file = saveFileFromUri(context, chosenFileVal)
-            if (file != null) {
-              files.add((file))
-              msgs.add(MsgContent.MCFile(if (msgs.isEmpty()) msgText else ""))
-            }
-          }
+    return when (val composePreview = cs.preview) {
+      is ComposePreview.CLinkPreview -> {
+        val url = parseMessage(cs.message)
+        val lp = composePreview.linkPreview
+        if (lp != null && url == lp.uri) {
+          MsgContent.MCLink(cs.message, preview = lp)
+        } else {
+          MsgContent.MCText(cs.message)
         }
       }
-      val quotedItemId: Long? = when (cs.contextItem) {
-        is ComposeContextItem.QuotedItem -> cs.contextItem.chatItem.id
-        else -> null
-      }
-      sent = null
-      msgs.forEachIndexed { index, content ->
-        if (index > 0) delay(100)
-        sent = send(cInfo, content, if (index == 0) quotedItemId else null, files.getOrNull(index),
-          if (content !is MsgContent.MCVoice && index == msgs.lastIndex) live else false
-        )
-      }
-      if (sent == null && chosenContent.value.isNotEmpty()) {
-        sent = send(cInfo, MsgContent.MCText(msgText), quotedItemId, null, live)
-      }
+      else -> MsgContent.MCText(cs.message)
     }
-    clearState(live)
-    return sent
+  }
+
+  fun updateMsgContent(msgContent: MsgContent): MsgContent {
+    val cs = composeState.value
+    return when (msgContent) {
+      is MsgContent.MCText -> checkLinkPreview()
+      is MsgContent.MCLink -> checkLinkPreview()
+      is MsgContent.MCImage -> MsgContent.MCImage(cs.message, image = msgContent.image)
+      is MsgContent.MCFile -> MsgContent.MCFile(cs.message)
+      is MsgContent.MCUnknown -> MsgContent.MCUnknown(type = msgContent.type, text = cs.message, json = msgContent.json)
+    }
+  }
+
+  fun clearState() {
+    composeState.value = ComposeState(useLinkPreviews = useLinkPreviews)
+    textStyle.value = smallFont
+    chosenImage.value = null
+    chosenFile.value = null
+    linkUrl.value = null
+    prevLinkUrl.value = null
+    pendingLinkUrl.value = null
+    cancelledLinks.clear()
   }
 
   fun sendMessage() {
-    withBGApi {
-      sendMessageAsync(null, false)
+    composeState.value = composeState.value.copy(inProgress = true)
+    val cInfo = chat.chatInfo
+    val cs = composeState.value
+    when (val contextItem = cs.contextItem) {
+      is ComposeContextItem.EditingItem -> {
+        val ei = contextItem.chatItem
+        val oldMsgContent = ei.content.msgContent
+        if (oldMsgContent != null) {
+          withApi {
+            val updatedItem = chatModel.controller.apiUpdateChatItem(
+              type = cInfo.chatType,
+              id = cInfo.apiId,
+              itemId = ei.meta.itemId,
+              mc = updateMsgContent(oldMsgContent)
+            )
+            if (updatedItem != null) chatModel.upsertChatItem(cInfo, updatedItem.chatItem)
+            clearState()
+          }
+        }
+      }
+      else -> {
+        var mc: MsgContent? = null
+        var file: String? = null
+        when (val preview = cs.preview) {
+          ComposePreview.NoPreview -> mc = MsgContent.MCText(cs.message)
+          is ComposePreview.CLinkPreview -> mc = checkLinkPreview()
+          is ComposePreview.ImagePreview -> {
+            val chosenImageVal = chosenImage.value
+            if (chosenImageVal != null) {
+              file = saveImage(context, chosenImageVal)
+              if (file != null) {
+                mc = MsgContent.MCImage(cs.message, preview.image)
+              }
+            }
+          }
+          is ComposePreview.FilePreview -> {
+            val chosenFileVal = chosenFile.value
+            if (chosenFileVal != null) {
+              file = saveFileFromUri(context, chosenFileVal)
+              if (file != null) {
+                mc = MsgContent.MCFile(cs.message)
+              }
+            }
+          }
+        }
+        val quotedItemId: Long? = when (contextItem) {
+          is ComposeContextItem.QuotedItem -> contextItem.chatItem.id
+          else -> null
+        }
+
+        if (mc != null) {
+          withApi {
+            val aChatItem = chatModel.controller.apiSendMessage(
+              type = cInfo.chatType,
+              id = cInfo.apiId,
+              file = file,
+              quotedItemId = quotedItemId,
+              mc = mc
+            )
+            if (aChatItem != null) chatModel.addChatItem(cInfo, aChatItem.chatItem)
+            clearState()
+          }
+        } else {
+          clearState()
+        }
+      }
     }
   }
 
@@ -507,20 +397,6 @@ 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
-    withApi {
-      chatModel.controller.allowFeatureToContact(contact, ChatFeature.Voice)
-    }
-  }
-
   fun cancelLinkPreview() {
     val uri = composeState.value.linkPreview?.uri
     if (uri != null) {
@@ -530,21 +406,9 @@ fun ComposeView(
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
   }
 
-  fun cancelImages() {
+  fun cancelImage() {
     composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
-    chosenContent.value = emptyList()
-  }
-
-  fun cancelVoice() {
-    val filePath = recState.value.filePathNullable
-    recState.value = RecordingState.NotStarted
-    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
-    withBGApi {
-      RecorderNative.stopRecording?.invoke()
-      AudioPlayer.stop(filePath)
-      filePath?.let { File(it).delete() }
-    }
-    chosenAudio.value = null
+    chosenImage.value = null
   }
 
   fun cancelFile() {
@@ -552,69 +416,16 @@ fun ComposeView(
     chosenFile.value = null
   }
 
-  fun truncateToWords(s: String): String {
-    var acc = ""
-    val word = StringBuilder()
-    for (c in s) {
-      if (c.isLetter() || c.isDigit()) {
-        word.append(c)
-      } else {
-        acc = acc + word.toString() + c
-        word.clear()
-      }
-    }
-    return acc
-  }
-
-  suspend fun sendLiveMessage() {
-    val typedMsg = composeState.value.message
-    val sentMsg = truncateToWords(typedMsg)
-    if (composeState.value.liveMessage == null) {
-      val ci = sendMessageAsync(sentMsg, live = true)
-      if (ci != null) {
-        composeState.value = composeState.value.copy(liveMessage = LiveMessage(ci, typedMsg = typedMsg, sentMsg = sentMsg))
-      }
-    }
-  }
-
-  fun liveMessageToSend(lm: LiveMessage, t: String): String? {
-    val s = if (t != lm.typedMsg) truncateToWords(t) else t
-    return if (s != lm.sentMsg) s else null
-  }
-
-  suspend fun updateLiveMessage() {
-    val typedMsg = composeState.value.message
-    val liveMessage = composeState.value.liveMessage
-    if (liveMessage != null) {
-      val sentMsg = liveMessageToSend(liveMessage, typedMsg)
-      if (sentMsg != null) {
-        val ci = sendMessageAsync(sentMsg, live = true)
-        if (ci != null) {
-          composeState.value = composeState.value.copy(liveMessage = LiveMessage(ci, typedMsg = typedMsg, sentMsg = sentMsg))
-        }
-      } else if (liveMessage.typedMsg != typedMsg) {
-        composeState.value = composeState.value.copy(liveMessage = liveMessage.copy(typedMsg = typedMsg))
-      }
-    }
-  }
-
   @Composable
   fun previewView() {
     when (val preview = composeState.value.preview) {
       ComposePreview.NoPreview -> {}
       is ComposePreview.CLinkPreview -> ComposeLinkView(preview.linkPreview, ::cancelLinkPreview)
       is ComposePreview.ImagePreview -> ComposeImageView(
-        preview.images,
-        ::cancelImages,
+        preview.image,
+        ::cancelImage,
         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,
@@ -636,129 +447,42 @@ fun ComposeView(
     }
   }
 
-  LaunchedEffect(chatModel.sharedContent.value) {
-    // Important. If it's null, don't do anything, chat is not closed yet but will be after a moment
-    if (chatModel.chatId.value == null) return@LaunchedEffect
-
-    when (val shared = chatModel.sharedContent.value) {
-      is SharedContent.Text -> onMessageChange(shared.text)
-      is SharedContent.Images -> processPickedImage(shared.uris, shared.text)
-      is SharedContent.File -> processPickedFile(shared.uri, shared.text)
-      null -> {}
-    }
-    chatModel.sharedContent.value = null
-  }
-
   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(end = 8.dp),
+      modifier = Modifier.padding(start = 4.dp, end = 8.dp),
       verticalAlignment = Alignment.Bottom,
+      horizontalArrangement = Arrangement.spacedBy(2.dp)
     ) {
-      IconButton(showChooseAttachment, enabled = !composeState.value.attachmentDisabled) {
+      val attachEnabled = !composeState.value.editing
+      Box(Modifier.padding(bottom = 12.dp)) {
         Icon(
           Icons.Filled.AttachFile,
           contentDescription = stringResource(R.string.attach),
-          tint = if (!composeState.value.attachmentDisabled) MaterialTheme.colors.primary else HighOrLowlight,
+          tint = if (attachEnabled) MaterialTheme.colors.primary else Color.Gray,
           modifier = Modifier
             .size(28.dp)
             .clip(CircleShape)
+            .clickable {
+              if (attachEnabled) {
+                showChooseAttachment()
+              }
+            }
         )
       }
-      val allowedVoiceByPrefs = remember(chat.chatInfo) { chat.chatInfo.featureEnabled(ChatFeature.Voice) }
-      LaunchedEffect(allowedVoiceByPrefs) {
-        if (!allowedVoiceByPrefs && chosenAudio.value != null) {
-          // Voice was disabled right when this user records it, just cancel it
-          cancelVoice()
-        }
-      }
-      val needToAllowVoiceToContact = remember(chat.chatInfo) {
-        chat.chatInfo is ChatInfo.Direct && with(chat.chatInfo.contact.mergedPreferences.voice) {
-          ((userPreference as? ContactUserPref.User)?.preference?.allow == FeatureAllowed.NO || (userPreference as? ContactUserPref.Contact)?.preference?.allow == FeatureAllowed.NO) &&
-              contactPreference.allow == FeatureAllowed.YES
-        }
-      }
-      LaunchedEffect(Unit) {
-        snapshotFlow { recState.value }
-          .distinctUntilChanged()
-          .collect {
-            when(it) {
-              is RecordingState.Started -> onAudioAdded(it.filePath, it.progressMs, false)
-              is RecordingState.Finished -> onAudioAdded(it.filePath, it.durationMs, true)
-              is RecordingState.NotStarted -> {}
-            }
-          }
-      }
-
-      val activity = LocalContext.current as Activity
-      DisposableEffect(Unit) {
-        val orientation = activity.resources.configuration.orientation
-        onDispose {
-          if (orientation == activity.resources.configuration.orientation && composeState.value.liveMessage != null) {
-            sendMessage()
-            resetLinkPreview()
-          }
-        }
-      }
-
       SendMsgView(
         composeState,
-        showVoiceRecordIcon = true,
-        recState,
-        chat.chatInfo is ChatInfo.Direct,
-        liveMessageAlertShown = chatModel.controller.appPrefs.liveMessageAlertShown,
-        needToAllowVoiceToContact,
-        allowedVoiceByPrefs,
-        allowVoiceToContact = ::allowVoiceToContact,
         sendMessage = {
           sendMessage()
           resetLinkPreview()
         },
-        sendLiveMessage = ::sendLiveMessage,
-        updateLiveMessage = ::updateLiveMessage,
-        onMessageChange = ::onMessageChange,
-        textStyle = textStyle
+        ::onMessageChange,
+        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

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

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

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

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

@@ -14,7 +14,8 @@ 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.*
+import chat.simplex.app.model.CIDirection
+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.chat.item.*
@@ -51,9 +52,7 @@ fun ContextItemView(
       )
       MarkdownText(
         contextItem.text, contextItem.formattedText,
-        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3,
-        linkMode = SimplexLinkMode.DESCRIPTION,
-        modifier = Modifier.fillMaxWidth(),
+        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3
       )
     }
     IconButton(onClick = cancelContextItem) {

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

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

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

@@ -1,509 +1,101 @@
 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.animation.core.*
 import androidx.compose.foundation.*
-import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.material.ripple.rememberRipple
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.outlined.ArrowUpward
 import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.*
-import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.*
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.*
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.*
-import androidx.compose.ui.viewinterop.AndroidView
-import androidx.core.graphics.drawable.DrawableCompat
-import androidx.core.view.inputmethod.EditorInfoCompat
-import androidx.core.view.inputmethod.InputConnectionCompat
-import androidx.core.widget.*
+import androidx.compose.ui.unit.dp
 import chat.simplex.app.R
-import chat.simplex.app.SimplexApp
-import chat.simplex.app.model.*
+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.chat.item.ItemAction
-import chat.simplex.app.views.helpers.*
-import com.google.accompanist.permissions.rememberMultiplePermissionsState
-import kotlinx.coroutines.*
 
 @Composable
 fun SendMsgView(
   composeState: MutableState<ComposeState>,
-  showVoiceRecordIcon: Boolean,
-  recState: MutableState<RecordingState>,
-  isDirectChat: Boolean,
-  liveMessageAlertShown: SharedPreference<Boolean>,
-  needToAllowVoiceToContact: Boolean,
-  allowedVoiceByPrefs: Boolean,
-  allowVoiceToContact: () -> Unit,
   sendMessage: () -> Unit,
-  sendLiveMessage: ( suspend () -> Unit)? = null,
-  updateLiveMessage: (suspend () -> Unit)? = null,
   onMessageChange: (String) -> Unit,
   textStyle: MutableState<TextStyle>
 ) {
-  Box(Modifier.padding(vertical = 8.dp)) {
-    val cs = composeState.value
-    val showProgress = cs.inProgress && (cs.preview is ComposePreview.ImagePreview  || cs.preview is ComposePreview.FilePreview)
-    val showVoiceButton = cs.message.isEmpty() && showVoiceRecordIcon && !composeState.value.editing &&
-        cs.liveMessage == null && (cs.preview is ComposePreview.NoPreview || recState.value is RecordingState.Started)
-    NativeKeyboard(composeState, textStyle, onMessageChange)
-    // Disable clicks on text field
-    if (cs.preview is ComposePreview.VoicePreview) {
-      Box(Modifier.matchParentSize().clickable(enabled = false, onClick = { }))
-    }
-    Box(Modifier.align(Alignment.BottomEnd)) {
-      val sendButtonSize = remember { Animatable(36f) }
-      val sendButtonAlpha = remember { Animatable(1f) }
-      val permissionsState = rememberMultiplePermissionsState(listOf(Manifest.permission.RECORD_AUDIO))
-      val scope = rememberCoroutineScope()
-      LaunchedEffect(Unit) {
-        // Making LiveMessage alive when screen orientation was changed
-        if (cs.liveMessage != null && sendLiveMessage != null && updateLiveMessage != null) {
-          startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
-        }
-      }
-      when {
-        showProgress -> ProgressIndicator()
-        showVoiceButton -> {
-          Row(verticalAlignment = Alignment.CenterVertically) {
-            val stopRecOnNextClick = remember { mutableStateOf(false) }
-            when {
-              needToAllowVoiceToContact || !allowedVoiceByPrefs -> {
-                DisallowedVoiceButton {
-                  if (needToAllowVoiceToContact) {
-                    showNeedToAllowVoiceAlert(allowVoiceToContact)
-                  } else {
-                    showDisabledVoiceAlert(isDirectChat)
+  val cs = composeState.value
+  BasicTextField(
+    value = cs.message,
+    onValueChange = onMessageChange,
+    textStyle = textStyle.value,
+    maxLines = 16,
+    keyboardOptions = KeyboardOptions.Default.copy(
+      capitalization = KeyboardCapitalization.Sentences,
+      autoCorrect = true
+    ),
+    modifier = Modifier.padding(vertical = 8.dp),
+    cursorBrush = SolidColor(HighOrLowlight),
+    decorationBox = { innerTextField ->
+      Surface(
+        shape = RoundedCornerShape(18.dp),
+        border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
+      ) {
+        Row(
+          Modifier.background(MaterialTheme.colors.background),
+          verticalAlignment = Alignment.Bottom
+        ) {
+          Box(
+            Modifier
+              .weight(1f)
+              .padding(horizontal = 12.dp)
+              .padding(top = 5.dp)
+              .padding(bottom = 7.dp)
+          ) {
+            innerTextField()
+          }
+          val icon = if (cs.editing) Icons.Filled.Check else Icons.Outlined.ArrowUpward
+          val color = if (cs.sendEnabled()) MaterialTheme.colors.primary else HighOrLowlight
+          if (cs.inProgress
+            && (cs.preview is ComposePreview.ImagePreview || cs.preview is ComposePreview.FilePreview)
+          ) {
+            CircularProgressIndicator(
+              Modifier
+                .size(36.dp)
+                .padding(4.dp),
+              color = HighOrLowlight,
+              strokeWidth = 3.dp
+            )
+          } else {
+            Icon(
+              icon,
+              stringResource(R.string.icon_descr_send_message),
+              tint = Color.White,
+              modifier = Modifier
+                .size(36.dp)
+                .padding(4.dp)
+                .clip(CircleShape)
+                .background(color)
+                .clickable {
+                  if (cs.sendEnabled()) {
+                    sendMessage()
                   }
                 }
-              }
-              !permissionsState.allPermissionsGranted ->
-                VoiceButtonWithoutPermission { permissionsState.launchMultiplePermissionRequest() }
-              else ->
-                RecordVoiceView(recState, stopRecOnNextClick)
-            }
-            if (sendLiveMessage != null && updateLiveMessage != null && (cs.preview !is ComposePreview.VoicePreview || !stopRecOnNextClick.value)) {
-              Spacer(Modifier.width(10.dp))
-              StartLiveMessageButton {
-                if (composeState.value.preview is ComposePreview.NoPreview) {
-                  startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
-                }
-              }
-            }
-          }
-        }
-        else -> {
-          val icon = if (cs.editing || cs.liveMessage != null) Icons.Filled.Check else Icons.Outlined.ArrowUpward
-          val color = if (cs.sendEnabled()) MaterialTheme.colors.primary else HighOrLowlight
-          if (composeState.value.liveMessage == null &&
-            cs.preview !is ComposePreview.VoicePreview && !cs.editing &&
-            sendLiveMessage != null && updateLiveMessage != null
-          ) {
-            var showDropdown by rememberSaveable { mutableStateOf(false) }
-            SendTextButton(icon, color, sendButtonSize, sendButtonAlpha, cs.sendEnabled(), sendMessage) { showDropdown = true }
-
-            DropdownMenu(
-              expanded = showDropdown,
-              onDismissRequest = { showDropdown = false },
-              Modifier.width(220.dp),
-            ) {
-              ItemAction(
-                generalGetString(R.string.send_live_message),
-                Icons.Filled.MoreHoriz,
-                onClick = {
-                  startLiveMessage(scope, sendLiveMessage, updateLiveMessage, sendButtonSize, sendButtonAlpha, composeState, liveMessageAlertShown)
-                  showDropdown = false
-                }
-              )
-            }
-          } else {
-            SendTextButton(icon, color, sendButtonSize, sendButtonAlpha, cs.sendEnabled(), sendMessage)
+            )
           }
         }
       }
     }
-  }
-}
-
-@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) {
-    if (cs.contextItem is ComposeContextItem.QuotedItem) {
-      delay(100)
-      showKeyboard = true
-    } else if (cs.contextItem is ComposeContextItem.EditingItem) {
-      // Keyboard will not show up if we try to show it too fast
-      delay(300)
-      showKeyboard = true
-    }
-  }
-
-  AndroidView(modifier = Modifier, factory = {
-    val editText = @SuppressLint("AppCompatCustomView") object: EditText(it) {
-      override fun setOnReceiveContentListener(
-        mimeTypes: Array<out String>?,
-        listener: android.view.OnReceiveContentListener?
-      ) {
-        super.setOnReceiveContentListener(mimeTypes, listener)
-      }
-      override fun onCreateInputConnection(editorInfo: EditorInfo): InputConnection {
-        val connection = super.onCreateInputConnection(editorInfo)
-        EditorInfoCompat.setContentMimeTypes(editorInfo, arrayOf("image/*"))
-        val onCommit = InputConnectionCompat.OnCommitContentListener { inputContentInfo, _, _ ->
-          try {
-            inputContentInfo.requestPermission()
-          } catch (e: Exception) {
-            return@OnCommitContentListener false
-          }
-          SimplexApp.context.chatModel.sharedContent.value = SharedContent.Images("", listOf(inputContentInfo.contentUri))
-          true
-        }
-        return InputConnectionCompat.createWrapper(connection, editorInfo, onCommit)
-      }
-    }
-    editText.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)
-    editText.maxLines = 16
-    editText.inputType = InputType.TYPE_TEXT_FLAG_CAP_SENTENCES or editText.inputType
-    editText.setTextColor(textColor.toArgb())
-    editText.textSize = textStyle.value.fontSize.value
-    val drawable = it.getDrawable(R.drawable.send_msg_view_background)!!
-    DrawableCompat.setTint(drawable, tintColor.toArgb())
-    editText.background = drawable
-    editText.setPadding(paddingStart, paddingTop, paddingEnd, paddingBottom)
-    editText.setText(cs.message)
-    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)
-    )
-  }
-}
-
-@Composable
-private fun RecordVoiceView(recState: MutableState<RecordingState>, stopRecOnNextClick: MutableState<Boolean>) {
-  val rec: Recorder = remember { RecorderNative(MAX_VOICE_SIZE_FOR_SENDING) }
-  DisposableEffect(Unit) { onDispose { rec.stop() } }
-  val stopRecordingAndAddAudio: () -> Unit = {
-    recState.value.filePathNullable?.let {
-      recState.value = RecordingState.Finished(it, rec.stop())
-    }
-  }
-  if (stopRecOnNextClick.value) {
-    LaunchedEffect(recState.value) {
-      if (recState.value is RecordingState.NotStarted) {
-        stopRecOnNextClick.value = false
-      }
-    }
-    // Lock orientation to current orientation because screen rotation will break the recording
-    LockToCurrentOrientationUntilDispose()
-    StopRecordButton(stopRecordingAndAddAudio)
-  } else {
-    val startRecording: () -> Unit = {
-      recState.value = RecordingState.Started(
-        filePath = rec.start { progress: Int?, finished: Boolean ->
-          val state = recState.value
-          if (state is RecordingState.Started && progress != null) {
-            recState.value = if (!finished)
-              RecordingState.Started(state.filePath, progress)
-            else
-              RecordingState.Finished(state.filePath, progress)
-          }
-        },
-      )
-    }
-    val interactionSource = interactionSourceWithTapDetection(
-      onPress = { if (recState.value is RecordingState.NotStarted) startRecording() },
-      onClick = {
-        if (stopRecOnNextClick.value) {
-          stopRecordingAndAddAudio()
-        } else {
-          // tapped and didn't hold a finger
-          stopRecOnNextClick.value = true
-        }
-      },
-      onCancel = stopRecordingAndAddAudio,
-      onRelease = stopRecordingAndAddAudio
-    )
-    RecordVoiceButton(interactionSource)
-  }
-}
-
-@Composable
-private fun DisallowedVoiceButton(onClick: () -> Unit) {
-  IconButton(onClick, Modifier.size(36.dp)) {
-    Icon(
-      Icons.Outlined.KeyboardVoice,
-      stringResource(R.string.icon_descr_record_voice_message),
-      tint = HighOrLowlight,
-      modifier = Modifier
-        .size(36.dp)
-        .padding(4.dp)
-    )
-  }
-}
-
-@Composable
-private fun VoiceButtonWithoutPermission(onClick: () -> Unit) {
-  IconButton(onClick, Modifier.size(36.dp)) {
-    Icon(
-      Icons.Filled.KeyboardVoice,
-      stringResource(R.string.icon_descr_record_voice_message),
-      tint = MaterialTheme.colors.primary,
-      modifier = Modifier
-        .size(36.dp)
-        .padding(4.dp)
-    )
-  }
-}
-
-@Composable
-private fun LockToCurrentOrientationUntilDispose() {
-  val context = LocalContext.current
-  DisposableEffect(Unit) {
-    val activity = context as Activity
-    activity.requestedOrientation = when (activity.display?.rotation) {
-      android.view.Surface.ROTATION_90 -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-      android.view.Surface.ROTATION_180 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
-      android.view.Surface.ROTATION_270 -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
-      else -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
-    }
-    // Unlock orientation
-    onDispose { activity.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED }
-  }
-}
-
-
-@Composable
-private fun StopRecordButton(onClick: () -> Unit) {
-  IconButton(onClick, Modifier.size(36.dp)) {
-    Icon(
-      Icons.Filled.Stop,
-      stringResource(R.string.icon_descr_record_voice_message),
-      tint = MaterialTheme.colors.primary,
-      modifier = Modifier
-        .size(36.dp)
-        .padding(4.dp)
-    )
-  }
-}
-
-@Composable
-private fun RecordVoiceButton(interactionSource: MutableInteractionSource) {
-  IconButton({}, Modifier.size(36.dp), interactionSource = interactionSource) {
-    Icon(
-      Icons.Filled.KeyboardVoice,
-      stringResource(R.string.icon_descr_record_voice_message),
-      tint = MaterialTheme.colors.primary,
-      modifier = Modifier
-        .size(36.dp)
-        .padding(4.dp)
-    )
-  }
-}
-
-@Composable
-private fun ProgressIndicator() {
-  CircularProgressIndicator(Modifier.size(36.dp).padding(4.dp), color = HighOrLowlight, strokeWidth = 3.dp)
-}
-
-@Composable
-private fun SendTextButton(
-  icon: ImageVector,
-  backgroundColor: Color,
-  sizeDp: Animatable<Float, AnimationVector1D>,
-  alpha: Animatable<Float, AnimationVector1D>,
-  enabled: Boolean,
-  sendMessage: () -> Unit,
-  onLongClick: (() -> Unit)? = null
-) {
-  val interactionSource = remember { MutableInteractionSource() }
-  Box(
-    modifier = Modifier.requiredSize(36.dp)
-      .combinedClickable(
-        onClick = sendMessage,
-        onLongClick = onLongClick,
-        enabled = enabled,
-        role = Role.Button,
-        interactionSource = interactionSource,
-        indication = rememberRipple(bounded = false, radius = 24.dp)
-      ),
-    contentAlignment = Alignment.Center
-  ) {
-    Icon(
-      icon,
-      stringResource(R.string.icon_descr_send_message),
-      tint = Color.White,
-      modifier = Modifier
-        .size(sizeDp.value.dp)
-        .padding(4.dp)
-        .alpha(alpha.value)
-        .clip(CircleShape)
-        .background(backgroundColor)
-        .padding(3.dp)
-    )
-  }
-}
-
-@Composable
-private fun StartLiveMessageButton(onClick: () -> Unit) {
-  val interactionSource = remember { MutableInteractionSource() }
-  Box(
-    modifier = Modifier.requiredSize(36.dp)
-      .clickable(
-        onClick = onClick,
-        enabled = true,
-        role = Role.Button,
-        interactionSource = interactionSource,
-        indication = rememberRipple(bounded = false, radius = 24.dp)
-      ),
-    contentAlignment = Alignment.Center
-  ) {
-    Icon(
-      Icons.Filled.MoreHoriz,
-      stringResource(R.string.icon_descr_send_message),
-      tint = Color.White,
-      modifier = Modifier
-        .size(36.dp)
-        .padding(4.dp)
-        .clip(CircleShape)
-        .background(MaterialTheme.colors.primary)
-        .padding(1.dp)
-    )
-  }
-}
-
-private fun startLiveMessage(
-  scope: CoroutineScope,
-  send: suspend () -> Unit,
-  update: suspend () -> Unit,
-  sendButtonSize: Animatable<Float, AnimationVector1D>,
-  sendButtonAlpha: Animatable<Float, AnimationVector1D>,
-  composeState: MutableState<ComposeState>,
-  liveMessageAlertShown: SharedPreference<Boolean>
-) {
-  fun run() {
-    scope.launch {
-      while (composeState.value.liveMessage != null) {
-        sendButtonSize.animateTo(if (sendButtonSize.value == 36f) 32f else 36f, tween(700, 50))
-      }
-      sendButtonSize.snapTo(36f)
-    }
-    scope.launch {
-      while (composeState.value.liveMessage != null) {
-        sendButtonAlpha.animateTo(if (sendButtonAlpha.value == 1f) 0.75f else 1f, tween(700, 50))
-      }
-      sendButtonAlpha.snapTo(1f)
-    }
-    scope.launch {
-      while (composeState.value.liveMessage != null) {
-        delay(3000)
-        update()
-      }
-    }
-  }
-
-  fun start() = withBGApi {
-    if (composeState.value.liveMessage == null) {
-      send()
-    }
-    run()
-  }
-
-  if (liveMessageAlertShown.state.value) {
-    start()
-  } else {
-    AlertManager.shared.showAlertDialog(
-      title = generalGetString(R.string.live_message),
-      text = generalGetString(R.string.send_live_message_desc),
-      confirmText = generalGetString(R.string.send_verb),
-      onConfirm = {
-        liveMessageAlertShown.set(true)
-        start()
-      })
-  }
-}
-
-private fun showNeedToAllowVoiceAlert(onConfirm: () -> Unit) {
-  AlertManager.shared.showAlertDialog(
-    title = generalGetString(R.string.allow_voice_messages_question),
-    text = generalGetString(R.string.you_need_to_allow_to_send_voice),
-    confirmText = generalGetString(R.string.allow_verb),
-    dismissText = generalGetString(R.string.cancel_verb),
-    onConfirm = onConfirm,
-  )
-}
-
-private fun showDisabledVoiceAlert(isDirectChat: Boolean) {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.voice_messages_prohibited),
-    text = generalGetString(
-      if (isDirectChat)
-        R.string.ask_your_contact_to_enable_voice
-      else
-        R.string.only_group_owners_can_enable_voice
-    )
   )
 }
 
@@ -520,13 +112,6 @@ fun PreviewSendMsgView() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      showVoiceRecordIcon = false,
-      recState = mutableStateOf(RecordingState.NotStarted),
-      isDirectChat = true,
-      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
-      needToAllowVoiceToContact = false,
-      allowedVoiceByPrefs = true,
-      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle
@@ -548,13 +133,6 @@ fun PreviewSendMsgViewEditing() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateEditing) },
-      showVoiceRecordIcon = false,
-      recState = mutableStateOf(RecordingState.NotStarted),
-      isDirectChat = true,
-      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
-      needToAllowVoiceToContact = false,
-      allowedVoiceByPrefs = true,
-      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle
@@ -576,13 +154,6 @@ fun PreviewSendMsgViewInProgress() {
   SimpleXTheme {
     SendMsgView(
       composeState = remember { mutableStateOf(composeStateInProgress) },
-      showVoiceRecordIcon = false,
-      recState = mutableStateOf(RecordingState.NotStarted),
-      isDirectChat = true,
-      liveMessageAlertShown = SharedPreference(get = { true }, set = { }),
-      needToAllowVoiceToContact = false,
-      allowedVoiceByPrefs = true,
-      allowVoiceToContact = {},
       sendMessage = {},
       onMessageChange = { _ -> },
       textStyle = textStyle

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

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

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

@@ -1,335 +0,0 @@
-package chat.simplex.app.views.chat.group
-
-import SectionCustomFooter
-import SectionDivider
-import SectionItemView
-import SectionSpacer
-import SectionView
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.CheckCircle
-import androidx.compose.material.icons.filled.TheaterComedy
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.ChatInfoToolbarTitle
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.SettingsActionItem
-
-@Composable
-fun AddGroupMembersView(groupInfo: GroupInfo, creatingGroup: Boolean = false, chatModel: ChatModel, close: () -> Unit) {
-  val selectedContacts = remember { mutableStateListOf<Long>() }
-  val selectedRole = remember { mutableStateOf(GroupMemberRole.Member) }
-  var allowModifyMembers by remember { mutableStateOf(true) }
-  BackHandler(onBack = close)
-  AddGroupMembersLayout(
-    groupInfo = groupInfo,
-    creatingGroup = creatingGroup,
-    contactsToAdd = getContactsToAdd(chatModel),
-    selectedContacts = selectedContacts,
-    selectedRole = selectedRole,
-    allowModifyMembers = allowModifyMembers,
-    openPreferences = {
-      ModalManager.shared.showCustomModal { close ->
-        GroupPreferencesView(chatModel, groupInfo.id, close)
-      }
-    },
-    inviteMembers = {
-      allowModifyMembers = false
-      withApi {
-        for (contactId in selectedContacts) {
-          val member = chatModel.controller.apiAddMember(groupInfo.groupId, contactId, selectedRole.value)
-          if (member != null) {
-            chatModel.upsertGroupMember(groupInfo, member)
-          } else {
-            break
-          }
-        }
-        close.invoke()
-      }
-    },
-    clearSelection = { selectedContacts.clear() },
-    addContact = { contactId -> if (contactId !in selectedContacts) selectedContacts.add(contactId) },
-    removeContact = { contactId -> selectedContacts.removeIf { it == contactId } },
-    close = close,
-  )
-}
-
-fun getContactsToAdd(chatModel: ChatModel): List<Contact> {
-  val memberContactIds = chatModel.groupMembers
-    .filter { it.memberCurrent }
-    .mapNotNull { it.memberContactId }
-  return chatModel.chats
-    .asSequence()
-    .map { it.chatInfo }
-    .filterIsInstance<ChatInfo.Direct>()
-    .map { it.contact }
-    .filter { it.contactId !in memberContactIds }
-    .sortedBy { it.displayName.lowercase() }
-    .toList()
-}
-
-@Composable
-fun AddGroupMembersLayout(
-  groupInfo: GroupInfo,
-  creatingGroup: Boolean,
-  contactsToAdd: List<Contact>,
-  selectedContacts: List<Long>,
-  selectedRole: MutableState<GroupMemberRole>,
-  allowModifyMembers: Boolean,
-  openPreferences: () -> Unit,
-  inviteMembers: () -> Unit,
-  clearSelection: () -> Unit,
-  addContact: (Long) -> Unit,
-  removeContact: (Long) -> Unit,
-  close: () -> Unit,
-) {
-  Column(
-    Modifier
-      .fillMaxWidth()
-      .verticalScroll(rememberScrollState()),
-    horizontalAlignment = Alignment.Start,
-  ) {
-    AppBarTitle(stringResource(R.string.button_add_members))
-    Row(
-      Modifier.fillMaxWidth(),
-      horizontalArrangement = Arrangement.Center
-    ) {
-      ChatInfoToolbarTitle(
-        ChatInfo.Group(groupInfo),
-        imageSize = 60.dp,
-        iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight
-      )
-    }
-    SectionSpacer()
-
-    if (contactsToAdd.isEmpty()) {
-      Row(
-        Modifier.fillMaxWidth(),
-        horizontalArrangement = Arrangement.Center
-      ) {
-        Text(
-          stringResource(R.string.no_contacts_to_add),
-          Modifier.padding(),
-          color = HighOrLowlight
-        )
-      }
-    } else {
-      SectionView {
-        if (creatingGroup) {
-          SectionItemView(openPreferences) {
-            Text(stringResource(R.string.set_group_preferences))
-          }
-          SectionDivider()
-        }
-        SectionItemView {
-          RoleSelectionRow(groupInfo, selectedRole, allowModifyMembers)
-        }
-        SectionDivider()
-        if (creatingGroup && selectedContacts.isEmpty()) {
-          SkipInvitingButton(close)
-        } else {
-          InviteMembersButton(inviteMembers, disabled = selectedContacts.isEmpty() || !allowModifyMembers)
-        }
-      }
-      SectionCustomFooter {
-        InviteSectionFooter(selectedContactsCount = selectedContacts.size, allowModifyMembers, clearSelection)
-      }
-      SectionSpacer()
-
-      SectionView(stringResource(R.string.select_contacts)) {
-        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, allowModifyMembers, addContact, removeContact)
-      }
-      SectionSpacer()
-    }
-  }
-}
-
-@Composable
-private fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>, enabled: Boolean) {
-  Row(
-    Modifier.fillMaxWidth(),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.SpaceBetween
-  ) {
-    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 InviteMembersButton(onClick: () -> Unit, disabled: Boolean) {
-  SettingsActionItem(
-    Icons.Outlined.Check,
-    stringResource(R.string.invite_to_group_button),
-    click = onClick,
-    textColor = MaterialTheme.colors.primary,
-    iconColor = MaterialTheme.colors.primary,
-    disabled = disabled,
-  )
-}
-
-@Composable
-fun SkipInvitingButton(onClick: () -> Unit) {
-  SettingsActionItem(
-    Icons.Outlined.Check,
-    stringResource(R.string.skip_inviting_button),
-    click = onClick,
-    textColor = MaterialTheme.colors.primary,
-    iconColor = MaterialTheme.colors.primary,
-  )
-}
-
-@Composable
-fun InviteSectionFooter(selectedContactsCount: Int, enabled: Boolean, clearSelection: () -> Unit) {
-  Row(
-    Modifier.fillMaxWidth(),
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    if (selectedContactsCount >= 1) {
-      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),
-        color = HighOrLowlight,
-        fontSize = 12.sp
-      )
-    }
-  }
-}
-
-@Composable
-fun ContactList(
-  contacts: List<Contact>,
-  selectedContacts: List<Long>,
-  groupInfo: GroupInfo,
-  enabled: Boolean,
-  addContact: (Long) -> Unit,
-  removeContact: (Long) -> Unit
-) {
-  Column {
-    contacts.forEachIndexed { index, contact ->
-      ContactCheckRow(
-        contact, groupInfo, addContact, removeContact,
-        checked = selectedContacts.contains(contact.apiId),
-        enabled = enabled,
-      )
-      if (index < contacts.lastIndex) {
-        SectionDivider()
-      }
-    }
-  }
-}
-
-@Composable
-fun ContactCheckRow(
-  contact: Contact,
-  groupInfo: GroupInfo,
-  addContact: (Long) -> Unit,
-  removeContact: (Long) -> Unit,
-  checked: Boolean,
-  enabled: Boolean,
-) {
-  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
-  ) {
-    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(
-      icon,
-      contentDescription = stringResource(R.string.icon_descr_contact_checked),
-      tint = iconColor
-    )
-  }
-}
-
-fun showProhibitedToInviteIncognitoAlertDialog() {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.invite_prohibited),
-    text = generalGetString(R.string.invite_prohibited_description),
-    confirmText = generalGetString(R.string.ok),
-  )
-}
-
-@Preview
-@Composable
-fun PreviewAddGroupMembersLayout() {
-  SimpleXTheme {
-    AddGroupMembersLayout(
-      groupInfo = GroupInfo.sampleData,
-      creatingGroup = false,
-      contactsToAdd = listOf(Contact.sampleData, Contact.sampleData, Contact.sampleData),
-      selectedContacts = remember { mutableStateListOf() },
-      selectedRole = remember { mutableStateOf(GroupMemberRole.Admin) },
-      allowModifyMembers = true,
-      openPreferences = {},
-      inviteMembers = {},
-      clearSelection = {},
-      addContact = {},
-      removeContact = {},
-      close = {},
-    )
-  }
-}

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

@@ -1,440 +0,0 @@
-package chat.simplex.app.views.chat.group
-
-import InfoRow
-import SectionDivider
-import SectionItemView
-import SectionSpacer
-import SectionTextFooter
-import SectionView
-import android.util.Log
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.TAG
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.*
-import chat.simplex.app.views.chatlist.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, groupLink: String?, onGroupLinkUpdated: (String?) -> Unit, 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 && chat.chatInfo is ChatInfo.Group) {
-    val groupInfo = chat.chatInfo.groupInfo
-    GroupChatInfoLayout(
-      chat,
-      groupInfo,
-      members = chatModel.groupMembers
-        .filter { it.memberStatus != GroupMemberStatus.MemLeft && it.memberStatus != GroupMemberStatus.MemRemoved }
-        .sortedBy { it.displayName.lowercase() },
-      developerTools,
-      groupLink,
-      addMembers = {
-        withApi {
-          setGroupMembers(groupInfo, chatModel)
-          ModalManager.shared.showModalCloseable(true) { close ->
-            AddGroupMembersView(groupInfo, false, chatModel, close)
-          }
-        }
-      },
-      showMemberInfo = { member ->
-        withApi {
-          val stats = chatModel.controller.apiGroupMemberInfo(groupInfo.groupId, member.groupMemberId)
-          val (_, code) = if (member.memberActive) {
-            try {
-              chatModel.controller.apiGetGroupMemberCode(groupInfo.apiId, member.groupMemberId)
-            } catch (e: Exception) {
-              Log.e(TAG, e.stackTraceToString())
-              member to null
-            }
-          } else {
-            member to null
-          }
-          ModalManager.shared.showModalCloseable(true) { closeCurrent ->
-            remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
-              GroupMemberInfoView(groupInfo, mem, stats, code, chatModel, closeCurrent) {
-                closeCurrent()
-                close()
-              }
-            }
-          }
-        }
-      },
-      editGroupProfile = {
-        ModalManager.shared.showCustomModal { close -> GroupProfileView(groupInfo, chatModel, close) }
-      },
-      openPreferences = {
-        ModalManager.shared.showCustomModal { close ->
-          GroupPreferencesView(
-            chatModel,
-            chat.id,
-            close
-          )
-        }
-      },
-      deleteGroup = { deleteGroupDialog(chat.chatInfo, groupInfo, chatModel, close) },
-      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
-      leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) },
-      manageGroupLink = {
-        withApi {
-          ModalManager.shared.showModal { GroupLinkView(chatModel, groupInfo, groupLink, onGroupLinkUpdated) }
-        }
-      }
-    )
-  }
-}
-
-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(alertTextKey),
-    confirmText = generalGetString(R.string.delete_verb),
-    onConfirm = {
-      withApi {
-        val r = chatModel.controller.apiDeleteChat(chatInfo.chatType, chatInfo.apiId)
-        if (r) {
-          chatModel.removeChat(chatInfo.id)
-          chatModel.chatId.value = null
-          chatModel.controller.ntfManager.cancelNotificationsForChat(chatInfo.id)
-          close?.invoke()
-        }
-      }
-    }
-  )
-}
-
-fun leaveGroupDialog(groupInfo: GroupInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.leave_group_question),
-    text = generalGetString(R.string.you_will_stop_receiving_messages_from_this_group_chat_history_will_be_preserved),
-    confirmText = generalGetString(R.string.leave_group_button),
-    onConfirm = {
-      withApi {
-        chatModel.controller.leaveGroup(groupInfo.groupId)
-        close?.invoke()
-      }
-    }
-  )
-}
-
-@Composable
-fun GroupChatInfoLayout(
-  chat: Chat,
-  groupInfo: GroupInfo,
-  members: List<GroupMember>,
-  developerTools: Boolean,
-  groupLink: String?,
-  addMembers: () -> Unit,
-  showMemberInfo: (GroupMember) -> Unit,
-  editGroupProfile: () -> Unit,
-  openPreferences: () -> Unit,
-  deleteGroup: () -> Unit,
-  clearChat: () -> Unit,
-  leaveGroup: () -> Unit,
-  manageGroupLink: () -> Unit,
-) {
-  Column(
-    Modifier
-      .fillMaxWidth()
-      .verticalScroll(rememberScrollState()),
-    horizontalAlignment = Alignment.Start
-  ) {
-    Row(
-      Modifier.fillMaxWidth(),
-      horizontalArrangement = Arrangement.Center
-    ) {
-      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(manageGroupLink) {
-          if (groupLink == null) {
-            CreateGroupLinkButton()
-          } else {
-            GroupLinkButton()
-          }
-        }
-        SectionDivider()
-        val onAddMembersClick = if (chat.chatInfo.incognito) ::cantInviteIncognitoAlert else addMembers
-        SectionItemView(onAddMembersClick) {
-          val tint = if (chat.chatInfo.incognito) HighOrLowlight else MaterialTheme.colors.primary
-          AddMembersButton(tint)
-        }
-        SectionDivider()
-      }
-      SectionItemView(minHeight = 50.dp) {
-        MemberRow(groupInfo.membership, user = true)
-      }
-      if (members.isNotEmpty()) {
-        SectionDivider()
-      }
-      MembersList(members, showMemberInfo)
-    }
-    SectionSpacer()
-    SectionView {
-      ClearChatButton(clearChat)
-      if (groupInfo.canDelete) {
-        SectionDivider()
-        SectionItemView(deleteGroup) { DeleteGroupButton() }
-      }
-      if (groupInfo.membership.memberCurrent) {
-        SectionDivider()
-        SectionItemView(leaveGroup) { LeaveGroupButton() }
-      }
-    }
-    SectionSpacer()
-
-    if (developerTools) {
-      SectionView(title = stringResource(R.string.section_title_for_console)) {
-        InfoRow(stringResource(R.string.info_row_local_name), groupInfo.localDisplayName)
-        SectionDivider()
-        InfoRow(stringResource(R.string.info_row_database_id), groupInfo.apiId.toString())
-      }
-      SectionSpacer()
-    }
-  }
-}
-
-@Composable
-private fun GroupChatInfoHeader(cInfo: ChatInfo) {
-  Column(
-    Modifier.padding(horizontal = 8.dp),
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Text(
-      cInfo.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      color = MaterialTheme.colors.onBackground,
-      maxLines = 1,
-      overflow = TextOverflow.Ellipsis
-    )
-    if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName) {
-      Text(
-        cInfo.fullName, style = MaterialTheme.typography.h2,
-        color = MaterialTheme.colors.onBackground,
-        maxLines = 2,
-        overflow = TextOverflow.Ellipsis
-      )
-    }
-  }
-}
-
-@Composable
-private fun GroupPreferencesButton(onClick: () -> Unit) {
-  SettingsActionItem(
-    Icons.Outlined.ToggleOn,
-    stringResource(R.string.group_preferences),
-    click = onClick
-  )
-}
-
-@Composable
-private fun AddMembersButton(tint: Color = MaterialTheme.colors.primary) {
-  Row(
-    Modifier.fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Add,
-      stringResource(R.string.button_add_members),
-      tint = tint
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_add_members), color = tint)
-  }
-}
-
-@Composable
-private fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
-  Column {
-    members.forEachIndexed { index, member ->
-      SectionItemView({ showMemberInfo(member) }, minHeight = 50.dp) {
-        MemberRow(member)
-      }
-      if (index < members.lastIndex) {
-        SectionDivider()
-      }
-    }
-  }
-}
-
-@Composable
-private fun MemberRow(member: GroupMember, user: Boolean = false) {
-  Row(
-    Modifier.fillMaxWidth(),
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Row(
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.spacedBy(4.dp)
-    ) {
-      ProfileImage(size = 46.dp, member.image)
-      Column {
-        Row(verticalAlignment = Alignment.CenterVertically) {
-          if (member.verified) {
-            MemberVerifiedShield()
-          }
-          Text(
-            member.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
-            color = if (member.memberIncognito) Indigo else Color.Unspecified
-          )
-        }
-        val s = member.memberStatus.shortText
-        val statusDescr = if (user) String.format(generalGetString(R.string.group_info_member_you), s) else s
-        Text(
-          statusDescr,
-          color = HighOrLowlight,
-          fontSize = 12.sp,
-          maxLines = 1,
-          overflow = TextOverflow.Ellipsis
-        )
-      }
-    }
-    val role = member.memberRole
-    if (role == GroupMemberRole.Owner || role == GroupMemberRole.Admin) {
-      Text(role.text, color = HighOrLowlight)
-    }
-  }
-}
-
-@Composable
-private fun MemberVerifiedShield() {
-  Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 3.dp).size(16.dp), tint = HighOrLowlight)
-}
-
-@Composable
-private fun GroupLinkButton() {
-  Row(
-    Modifier
-      .fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Link,
-      stringResource(R.string.group_link),
-      tint = HighOrLowlight
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.group_link))
-  }
-}
-
-@Composable
-private fun CreateGroupLinkButton() {
-  Row(
-    Modifier
-      .fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.AddLink,
-      stringResource(R.string.create_group_link),
-      tint = HighOrLowlight
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.create_group_link))
-  }
-}
-
-@Composable
-fun EditGroupProfileButton() {
-  Row(
-    Modifier
-      .fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Edit,
-      stringResource(R.string.button_edit_group_profile),
-      tint = HighOrLowlight
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_edit_group_profile))
-  }
-}
-
-@Composable
-private fun LeaveGroupButton() {
-  Row(
-    Modifier.fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Logout,
-      stringResource(R.string.button_leave_group),
-      tint = Color.Red
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_leave_group), color = Color.Red)
-  }
-}
-
-@Composable
-private fun DeleteGroupButton() {
-  Row(
-    Modifier.fillMaxSize(),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    Icon(
-      Icons.Outlined.Delete,
-      stringResource(R.string.button_delete_group),
-      tint = Color.Red
-    )
-    Spacer(Modifier.size(8.dp))
-    Text(stringResource(R.string.button_delete_group), color = Color.Red)
-  }
-}
-
-@Preview
-@Composable
-fun PreviewGroupChatInfoLayout() {
-  SimpleXTheme {
-    GroupChatInfoLayout(
-      chat = Chat(
-        chatInfo = ChatInfo.Direct.sampleData,
-        chatItems = arrayListOf(),
-        serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
-      ),
-      groupInfo = GroupInfo.sampleData,
-      members = listOf(GroupMember.sampleData, GroupMember.sampleData, GroupMember.sampleData),
-      developerTools = false,
-      groupLink = null,
-      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, openPreferences = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {}, manageGroupLink = {},
-    )
-  }
-}

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

@@ -1,133 +0,0 @@
-package chat.simplex.app.views.chat.group
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.CircularProgressIndicator
-import androidx.compose.material.Text
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.model.GroupInfo
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.QRCode
-
-@Composable
-fun GroupLinkView(chatModel: ChatModel, groupInfo: GroupInfo, connReqContact: String?, onGroupLinkUpdated: (String?) -> Unit) {
-  var groupLink by rememberSaveable { mutableStateOf(connReqContact) }
-  var creatingLink by rememberSaveable { mutableStateOf(false) }
-  val cxt = LocalContext.current
-  fun createLink() {
-    creatingLink = true
-    withApi {
-      groupLink = chatModel.controller.apiCreateGroupLink(groupInfo.groupId)
-      onGroupLinkUpdated(groupLink)
-      creatingLink = false
-    }
-  }
-  LaunchedEffect(Unit) {
-    if (groupLink == null && !creatingLink) {
-      createLink()
-    }
-  }
-  GroupLinkLayout(
-    groupLink = groupLink,
-    creatingLink,
-    createLink = ::createLink,
-    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
-              onGroupLinkUpdated(null)
-            }
-          }
-        }
-      )
-    }
-  )
-  if (creatingLink) {
-    ProgressIndicator()
-  }
-}
-
-@Composable
-fun GroupLinkLayout(
-  groupLink: String?,
-  creatingLink: Boolean,
-  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, disabled = creatingLink, 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
-          )
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun ProgressIndicator() {
-  Box(
-    Modifier.fillMaxSize(),
-    contentAlignment = Alignment.Center
-  ) {
-    CircularProgressIndicator(
-      Modifier
-        .padding(horizontal = 2.dp)
-        .size(30.dp),
-      color = HighOrLowlight,
-      strokeWidth = 2.5.dp
-    )
-  }
-}

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

@@ -1,377 +0,0 @@
-package chat.simplex.app.views.chat.group
-
-import InfoRow
-import SectionDivider
-import SectionItemView
-import SectionSpacer
-import SectionView
-import android.util.Log
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-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 chat.simplex.app.R
-import chat.simplex.app.TAG
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.*
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.SettingsActionItem
-import kotlinx.datetime.Clock
-
-@Composable
-fun GroupMemberInfoView(
-  groupInfo: GroupInfo,
-  member: GroupMember,
-  connStats: ConnectionStats?,
-  connectionCode: String?,
-  chatModel: ChatModel,
-  close: () -> Unit,
-  closeAll: () -> Unit, // Close all open windows up to ChatView
-) {
-  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,
-      connectionCode,
-      getContactChat = { chatModel.getContactChat(it) },
-      knownDirectChat = {
-        withApi {
-          chatModel.chatItems.clear()
-          chatModel.chatItems.addAll(it.chatItems)
-          chatModel.chatId.value = it.chatInfo.id
-          closeAll()
-        }
-      },
-      newDirectChat = {
-        withApi {
-          val c = chatModel.controller.apiGetChat(ChatType.Direct, it)
-          if (c != null) {
-            // TODO it's not correct to blindly set network status to connected - we should manage network status in model / backend
-            val newChat = c.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)
-      },
-      verifyClicked = {
-        ModalManager.shared.showModalCloseable { close ->
-          remember { derivedStateOf { chatModel.groupMembers.firstOrNull { it.memberId == member.memberId } } }.value?.let { mem ->
-            VerifyCodeView(
-              mem.displayName,
-              connectionCode,
-              mem.verified,
-              verify = { code ->
-                chatModel.controller.apiVerifyGroupMember(mem.groupId, mem.groupMemberId, code)?.let { r ->
-                  val (verified, existingCode) = r
-                  chatModel.upsertGroupMember(
-                    groupInfo,
-                    mem.copy(
-                      activeConn = mem.activeConn?.copy(
-                        connectionCode = if (verified) SecurityCode(existingCode, Clock.System.now()) else null
-                      )
-                    )
-                  )
-                  r
-                }
-              },
-              close,
-            )
-          }
-        }
-      }
-    )
-  }
-}
-
-fun removeMemberDialog(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 {
-        val removedMember = chatModel.controller.apiRemoveMember(member.groupId, member.groupMemberId)
-        if (removedMember != null) {
-          chatModel.upsertGroupMember(groupInfo, removedMember)
-        }
-        close?.invoke()
-      }
-    }
-  )
-}
-
-@Composable
-fun GroupMemberInfoLayout(
-  groupInfo: GroupInfo,
-  member: GroupMember,
-  connStats: ConnectionStats?,
-  newRole: MutableState<GroupMemberRole>,
-  developerTools: Boolean,
-  connectionCode: String?,
-  getContactChat: (Long) -> Chat?,
-  knownDirectChat: (Chat) -> Unit,
-  newDirectChat: (Long) -> Unit,
-  removeMember: () -> Unit,
-  onRoleSelected: (GroupMemberRole) -> Unit,
-  switchMemberAddress: () -> Unit,
-  verifyClicked: () -> Unit,
-) {
-  Column(
-    Modifier
-      .fillMaxWidth()
-      .verticalScroll(rememberScrollState()),
-    horizontalAlignment = Alignment.Start
-  ) {
-    Row(
-      Modifier.fillMaxWidth(),
-      horizontalArrangement = Arrangement.Center
-    ) {
-      GroupMemberInfoHeader(member)
-    }
-    SectionSpacer()
-
-    if (member.memberActive) {
-      val contactId = member.memberContactId
-      if (contactId != null) {
-        SectionView {
-          val chat = getContactChat(contactId)
-          if (chat != null && chat.chatInfo is ChatInfo.Direct && chat.chatInfo.contact.directOrUsed) {
-            OpenChatButton(onClick = { knownDirectChat(chat) })
-            if (connectionCode != null) {
-              SectionDivider()
-            }
-          } else if (groupInfo.fullGroupPreferences.directMessages.on) {
-            OpenChatButton(onClick = { newDirectChat(contactId) })
-            if (connectionCode != null) {
-              SectionDivider()
-            }
-          }
-          if (connectionCode != null) {
-            VerifyCodeButton(member.verified, verifyClicked)
-          }
-        }
-        SectionSpacer()
-      }
-    }
-
-    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()
-        val connLevelDesc =
-          if (conn.connLevel == 0) stringResource(R.string.conn_level_desc_direct)
-          else String.format(generalGetString(R.string.conn_level_desc_indirect), conn.connLevel)
-        InfoRow(stringResource(R.string.info_row_connection), connLevelDesc)
-      }
-    }
-    SectionSpacer()
-    if (connStats != null) {
-      SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
-      SwitchAddressButton(switchMemberAddress)
-      SectionDivider()
-        val rcvServers = connStats.rcvServers
-        val sndServers = connStats.sndServers
-        if ((rcvServers != null && rcvServers.isNotEmpty()) || (sndServers != null && sndServers.isNotEmpty())) {
-          if (rcvServers != null && rcvServers.isNotEmpty()) {
-            SimplexServers(stringResource(R.string.receiving_via), rcvServers)
-            if (sndServers != null && sndServers.isNotEmpty()) {
-              SectionDivider()
-              SimplexServers(stringResource(R.string.sending_via), sndServers)
-            }
-          } else if (sndServers != null && sndServers.isNotEmpty()) {
-            SimplexServers(stringResource(R.string.sending_via), sndServers)
-          }
-        }
-      }
-      SectionSpacer()
-    }
-
-    if (member.canBeRemoved(groupInfo)) {
-      SectionView {
-        RemoveMemberButton(removeMember)
-      }
-      SectionSpacer()
-    }
-
-    if (developerTools) {
-      SectionView(title = stringResource(R.string.section_title_for_console)) {
-        InfoRow(stringResource(R.string.info_row_local_name), member.localDisplayName)
-        SectionDivider()
-        InfoRow(stringResource(R.string.info_row_database_id), member.groupMemberId.toString())
-      }
-      SectionSpacer()
-    }
-  }
-}
-
-@Composable
-fun GroupMemberInfoHeader(member: GroupMember) {
-  Column(
-    Modifier.padding(horizontal = 8.dp),
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    ProfileImage(size = 192.dp, member.image, color = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      if (member.verified) {
-        Icon(Icons.Outlined.VerifiedUser, null, Modifier.padding(end = 6.dp, top = 4.dp).size(24.dp), tint = HighOrLowlight)
-      }
-      Text(
-        member.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-        color = MaterialTheme.colors.onBackground,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis
-      )
-    }
-    if (member.fullName != "" && member.fullName != member.displayName) {
-      Text(
-        member.fullName, style = MaterialTheme.typography.h2,
-        color = MaterialTheme.colors.onBackground,
-        maxLines = 2,
-        overflow = TextOverflow.Ellipsis
-      )
-    }
-  }
-}
-
-@Composable
-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.fillMaxWidth(),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.SpaceBetween
-  ) {
-    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
-    )
-  }
-}
-
-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() {
-  SimpleXTheme {
-    GroupMemberInfoLayout(
-      groupInfo = GroupInfo.sampleData,
-      member = GroupMember.sampleData,
-      connStats = null,
-      newRole = remember { mutableStateOf(GroupMemberRole.Member) },
-      developerTools = false,
-      connectionCode = "123",
-      getContactChat = { Chat.sampleData },
-      knownDirectChat = {},
-      newDirectChat = {},
-      removeMember = {},
-      onRoleSelected = {},
-      switchMemberAddress = {},
-      verifyClicked = {},
-    )
-  }
-}

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

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

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

@@ -1,176 +0,0 @@
-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
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-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
-fun GroupProfileView(groupInfo: GroupInfo, chatModel: ChatModel, close: () -> Unit) {
-  GroupProfileLayout(
-    close = close,
-    groupProfile = groupInfo.groupProfile,
-    saveProfile = { p ->
-      withApi {
-        val gInfo = chatModel.controller.apiUpdateGroup(groupInfo.groupId, p)
-        if (gInfo != null) {
-          chatModel.updateGroup(gInfo)
-          close.invoke()
-        }
-      }
-    }
-  )
-}
-
-@Composable
-fun GroupProfileLayout(
-  close: () -> Unit,
-  groupProfile: GroupProfile,
-  saveProfile: (GroupProfile) -> Unit,
-) {
-  val bottomSheetModalState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
-  val displayName = remember { mutableStateOf(groupProfile.displayName) }
-  val fullName = remember { mutableStateOf(groupProfile.fullName) }
-  val chosenImage = rememberSaveable { mutableStateOf<Uri?>(null) }
-  val profileImage = rememberSaveable { mutableStateOf(groupProfile.image) }
-  val scope = rememberCoroutineScope()
-  val scrollState = rememberScrollState()
-  val focusRequester = remember { FocusRequester() }
-
-  ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
-    ModalBottomSheetLayout(
-      scrimColor = Color.Black.copy(alpha = 0.12F),
-      modifier = Modifier.navigationBarsWithImePadding(),
-      sheetContent = {
-        GetImageBottomSheet(
-          chosenImage,
-          onImageChange = { bitmap -> profileImage.value = resizeImageToStrSize(cropToSquare(bitmap), maxDataSize = 12500) },
-          hideBottomSheet = {
-            scope.launch { bottomSheetModalState.hide() }
-          })
-      },
-      sheetState = bottomSheetModalState,
-      sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp)
-    ) {
-      ModalView(close = close) {
-        Column(
-          Modifier
-            .verticalScroll(scrollState)
-            .padding(horizontal = DEFAULT_PADDING),
-          horizontalAlignment = Alignment.Start
-        ) {
-          Text(
-            stringResource(R.string.group_profile_is_stored_on_members_devices),
-            Modifier.padding(bottom = 24.dp),
-            color = MaterialTheme.colors.onBackground,
-            lineHeight = 22.sp
-          )
-          Column(
-            Modifier.fillMaxWidth(),
-            horizontalAlignment = Alignment.Start
-          ) {
-            Box(
-              Modifier
-                .fillMaxWidth()
-                .padding(bottom = 24.dp),
-              contentAlignment = Alignment.Center
-            ) {
-              Box(contentAlignment = Alignment.TopEnd) {
-                Box(contentAlignment = Alignment.Center) {
-                  ProfileImage(192.dp, 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)
-            Spacer(Modifier.height(16.dp))
-            Row {
-              TextButton(stringResource(R.string.cancel_verb)) {
-                close.invoke()
-              }
-              Spacer(Modifier.padding(horizontal = 8.dp))
-              val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
-              if (enabled) {
-                Text(
-                  stringResource(R.string.save_group_profile),
-                  modifier = Modifier.clickable { saveProfile(GroupProfile(displayName.value, fullName.value, profileImage.value)) },
-                  color = MaterialTheme.colors.primary
-                )
-              } else {
-                Text(
-                  stringResource(R.string.save_group_profile),
-                  color = HighOrLowlight
-                )
-              }
-            }
-          }
-
-          LaunchedEffect(Unit) {
-            delay(300)
-            focusRequester.requestFocus()
-          }
-        }
-      }
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewGroupProfileLayout() {
-  SimpleXTheme {
-    GroupProfileLayout(
-      close = {},
-      groupProfile = GroupProfile.sampleData,
-      saveProfile = { _ -> }
-    )
-  }
-}

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

@@ -24,7 +24,7 @@ fun CICallItemView(cInfo: ChatInfo, cItem: ChatItem, status: CICallStatus, durat
     Modifier
       .padding(horizontal = 4.dp)
       .padding(bottom = 8.dp), horizontalAlignment = Alignment.CenterHorizontally) {
-    @Composable fun ConnectingCallIcon() = Icon(Icons.Outlined.SettingsPhone, stringResource(R.string.icon_descr_call_connecting), tint = SimplexGreen)
+    @Composable fun ConnectingCallIcon() = Icon(Icons.Outlined.SettingsPhone, stringResource(R.string.icon_descr_call_connecting), tint = Color.Green)
     when (status) {
       CICallStatus.Pending -> if (sent) {
         Icon(Icons.Outlined.Call, stringResource(R.string.icon_descr_call_pending_sent))
@@ -38,9 +38,8 @@ 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(durationText(duration), color = HighOrLowlight)
+        Text(status.duration(duration), color = HighOrLowlight)
       }
-      CICallStatus.Error -> {}
     }
 
     Text(

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

@@ -1,34 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.model.*
-
-@Composable
-fun CIChatFeatureView(
-  chatItem: ChatItem,
-  feature: Feature,
-  iconColor: Color,
-  icon: ImageVector? = null
-) {
-  Row(
-    Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.spacedBy(4.dp)
-  ) {
-    Icon(icon ?: feature.iconFilled, feature.text, Modifier.size(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

@@ -1,69 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.*
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.model.ChatItem
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
-
-@Composable
-fun CIEventView(ci: ChatItem) {
-  @Composable
-  fun chatEventTextView(text: AnnotatedString) {
-    Text(text, style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp))
-  }
-
-  Surface {
-    Row(
-      Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
-      verticalAlignment = Alignment.CenterVertically
-    ) {
-      val memberDisplayName = ci.memberDisplayName
-      if (memberDisplayName != null) {
-        chatEventTextView(
-          buildAnnotatedString {
-            withChatEventStyle(this, memberDisplayName)
-            append(" ")
-          }.plus(chatEventText(ci))
-        )
-      } else {
-        chatEventTextView(chatEventText(ci))
-      }
-    }
-  }
-}
-
-fun withChatEventStyle(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 {
-    withChatEventStyle(this, ci.content.text)
-    append(" ")
-    withChatEventStyle(this, ci.timestampText)
-  }
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  name = "Dark Mode"
-)
-@Composable
-fun CIEventViewPreview() {
-  SimpleXTheme {
-    CIEventView(
-      ChatItem.getGroupEventSample()
-    )
-  }
-}

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

@@ -1,54 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleButton
-
-@Composable
-fun CIFeaturePreferenceView(
-  chatItem: ChatItem,
-  chatInfo: ChatInfo,
-  feature: ChatFeature,
-  allowed: FeatureAllowed,
-  acceptFeature: (Contact, ChatFeature) -> Unit
-) {
-  Row(
-    Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.spacedBy(4.dp)
-  ) {
-    Icon(feature.icon, feature.text, Modifier.size(15.dp), tint = HighOrLowlight)
-    Text(chatItem.content.text, fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)
-    if (chatInfo is ChatInfo.Direct && allowed != FeatureAllowed.NO) {
-      val ct = chatInfo.contact
-      if (ct.allowsFeature(feature) && !ct.userAllowsFeature(feature)) {
-        Text(stringResource(R.string.accept), modifier = Modifier.clickable { acceptFeature(ct, feature) },
-          fontSize = 12.sp, color = MaterialTheme.colors.primary)
-      }
-    }
-    Text(chatItem.timestampText, fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)
-//      buildAnnotatedString {
-//        withChatEventStyle(this, chatItem.content.text)
-//        append(" ")
-//        withChatEventStyle(this, chatItem.timestampText)
-//      },
-//      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/CIFileView.kt

@@ -2,6 +2,7 @@ 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.*
@@ -38,7 +39,7 @@ fun CIFileView(
   @Composable
   fun fileIcon(
     innerIcon: ImageVector? = null,
-    color: Color = if (isInDarkTheme()) FileDark else FileLight
+    color: Color = if (isSystemInDarkTheme()) FileDark else FileLight
   ) {
     Box(
       contentAlignment = Alignment.Center
@@ -104,7 +105,7 @@ fun CIFileView(
   fun progressIndicator() {
     CircularProgressIndicator(
       Modifier.size(32.dp),
-      color = if (isInDarkTheme()) FileDark else FileLight,
+      color = if (isSystemInDarkTheme()) FileDark else FileLight,
       strokeWidth = 4.dp
     )
   }
@@ -205,6 +206,6 @@ class ChatItemProvider: PreviewParameterProvider<ChatItem> {
 fun PreviewCIFileFramedItemView(@PreviewParameter(ChatItemProvider::class) chatItem: ChatItem) {
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
-    FramedItemView(ChatInfo.Direct.sampleData, chatItem, linkMode = SimplexLinkMode.DESCRIPTION, showMenu = showMenu, receiveFile = {})
+    FramedItemView(User.sampleData, chatItem, showMenu = showMenu, receiveFile = {})
   }
 }

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

@@ -1,167 +0,0 @@
-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.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.SupervisedUserCircle
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-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.*
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.*
-
-@Composable
-fun CIGroupInvitationView(
-  ci: ChatItem,
-  groupInvitation: CIGroupInvitation,
-  memberRole: GroupMemberRole,
-  chatIncognito: Boolean = false,
-  joinGroup: (Long) -> Unit
-) {
-  val sent = ci.chatDir.sent
-  val action = !sent && groupInvitation.status == CIGroupInvitationStatus.Pending
-
-  @Composable
-  fun groupInfoView() {
-    val p = groupInvitation.groupProfile
-    val iconColor =
-      if (action) if (chatIncognito) Indigo else MaterialTheme.colors.primary
-      else if (isInDarkTheme()) FileDark else FileLight
-
-    Row(
-      Modifier
-        .defaultMinSize(minWidth = 220.dp)
-        .padding(vertical = 4.dp)
-        .padding(end = 2.dp)
-    ) {
-      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),
-        verticalArrangement = Arrangement.Center
-      ) {
-        Text(p.displayName, style = MaterialTheme.typography.caption, fontWeight = FontWeight.Medium, maxLines = 2, overflow = TextOverflow.Ellipsis)
-        if (p.fullName != "" && p.displayName != p.fullName) {
-          Text(p.fullName, maxLines = 2, overflow = TextOverflow.Ellipsis)
-        }
-      }
-    }
-  }
-
-  @Composable
-  fun groupInvitationText() {
-    when {
-      sent -> Text(stringResource(R.string.you_sent_group_invitation))
-      !sent && groupInvitation.status == CIGroupInvitationStatus.Pending -> Text(stringResource(R.string.you_are_invited_to_group))
-      !sent && groupInvitation.status == CIGroupInvitationStatus.Accepted -> Text(stringResource(R.string.you_joined_this_group))
-      !sent && groupInvitation.status == CIGroupInvitationStatus.Rejected -> Text(stringResource(R.string.you_rejected_group_invitation))
-      !sent && groupInvitation.status == CIGroupInvitationStatus.Expired -> Text(stringResource(R.string.group_invitation_expired))
-    }
-  }
-
-  Surface(
-    modifier = if (action) Modifier.clickable(onClick = {
-      joinGroup(groupInvitation.groupId)
-    }) else Modifier,
-    shape = RoundedCornerShape(18.dp),
-    color = if (sent) SentColorLight else ReceivedColorLight,
-  ) {
-    Box(
-      Modifier
-        .width(IntrinsicSize.Min)
-        .padding(vertical = 3.dp)
-        .padding(start = 8.dp, end = 12.dp),
-      contentAlignment = Alignment.BottomEnd
-    ) {
-      Column(
-        Modifier
-          .defaultMinSize(minWidth = 220.dp)
-          .padding(bottom = 4.dp),
-        horizontalAlignment = Alignment.Start
-      ) {
-        groupInfoView()
-        Column(Modifier.padding(top = 2.dp, start = 5.dp)) {
-          Divider(Modifier.fillMaxWidth().padding(bottom = 4.dp))
-          if (action) {
-            groupInvitationText()
-            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()
-            }
-          }
-        }
-      }
-      Text(
-        ci.timestampText,
-        color = HighOrLowlight,
-        fontSize = 14.sp,
-        modifier = Modifier.padding(start = 3.dp)
-      )
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  name = "Dark Mode"
-)
-@Composable
-fun PendingCIGroupInvitationViewPreview() {
-  SimpleXTheme {
-    CIGroupInvitationView(
-      ci = ChatItem.getGroupInvitationSample(),
-      groupInvitation = CIGroupInvitation.getSample(),
-      memberRole = GroupMemberRole.Admin,
-      joinGroup = {}
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  name = "Dark Mode"
-)
-@Composable
-fun CIGroupInvitationViewAcceptedPreview() {
-  SimpleXTheme {
-    CIGroupInvitationView(
-      ci = ChatItem.getGroupInvitationSample(),
-      groupInvitation = CIGroupInvitation.getSample(status = CIGroupInvitationStatus.Accepted),
-      memberRole = GroupMemberRole.Admin,
-      joinGroup = {}
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Composable
-fun CIGroupInvitationViewLongNamePreview() {
-  SimpleXTheme {
-    CIGroupInvitationView(
-      ci = ChatItem.getGroupInvitationSample(),
-      groupInvitation = CIGroupInvitation.getSample(
-        groupProfile = GroupProfile("group_with_a_really_really_really_long_name", "Group With A Really Really Really Long Name"),
-        status = CIGroupInvitationStatus.Accepted
-      ),
-      memberRole = GroupMemberRole.Admin,
-      joinGroup = {}
-    )
-  }
-}

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

@@ -1,7 +1,4 @@
-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.*
@@ -9,39 +6,26 @@ 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.*
+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.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.layout.layoutId
-import androidx.compose.ui.platform.*
+import androidx.compose.ui.platform.LocalContext
 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
 ) {
@@ -81,25 +65,12 @@ 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(
@@ -108,7 +79,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(if (imageBitmap.width * 0.97 <= imageBitmap.height) imageViewFullWidth() * 0.75f else 1000.dp)
+        .width(1000.dp)
         .combinedClickable(
           onLongClick = { showMenu.value = true },
           onClick = onClick
@@ -117,56 +88,13 @@ fun CIImageView(
     )
   }
 
-  @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
-  ) {
+  Box(contentAlignment = Alignment.TopEnd) {
     val context = LocalContext.current
-    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)
+    val imageBitmap: Bitmap? = getLoadedImage(context, file)
+    if (imageBitmap != null) {
+      imageView(imageBitmap, onClick = {
         if (getLoadedFilePath(context, file) != null) {
-          ModalManager.shared.showCustomModal(animated = false) { close ->
-            ImageFullScreenView(imageProvider, close)
-          }
+          ModalManager.shared.showCustomModal { close -> ImageFullScreenView(imageBitmap, close) }
         }
       })
     } else {
@@ -174,14 +102,7 @@ fun CIImageView(
         if (file != null) {
           when (file.fileStatus) {
             CIFileStatus.RcvInvitation ->
-              if (fileSizeValid()) {
-                receiveFile(file.fileId)
-              } else {
-                AlertManager.shared.showAlertMsg(
-                  generalGetString(R.string.large_file),
-                  String.format(generalGetString(R.string.contact_sent_large_file), formatBytes(MAX_FILE_SIZE))
-                )
-              }
+              receiveFile(file.fileId)
             CIFileStatus.RcvAccepted ->
               AlertManager.shared.showAlertMsg(
                 generalGetString(R.string.waiting_for_image),
@@ -198,13 +119,3 @@ 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,86 +1,65 @@
 package chat.simplex.app.views.chat.item
 
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
+import androidx.compose.material.Icon
+import androidx.compose.material.Text
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Circle
-import androidx.compose.material.icons.outlined.Edit
-import androidx.compose.material.icons.outlined.Timer
+import androidx.compose.material.icons.filled.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimplexBlue
 import kotlinx.datetime.Clock
 
 @Composable
-fun CIMetaView(chatItem: ChatItem, timedMessagesTTL: Int?, metaColor: Color = HighOrLowlight) {
-  Row(Modifier.padding(start = 3.dp), verticalAlignment = Alignment.CenterVertically) {
-    if (chatItem.isDeletedContent) {
-      Text(
-        chatItem.timestampText,
-        color = metaColor,
-        fontSize = 14.sp,
-        modifier = Modifier.padding(start = 3.dp)
-      )
-    } else {
-      CIMetaText(chatItem.meta, timedMessagesTTL, metaColor)
+fun CIMetaView(chatItem: ChatItem, metaColor: Color = HighOrLowlight) {
+  Row(verticalAlignment = Alignment.CenterVertically) {
+    if (!chatItem.isDeletedContent) {
+      if (chatItem.meta.itemEdited) {
+        Icon(
+          Icons.Filled.Edit,
+          modifier = Modifier.height(12.dp).padding(end = 1.dp),
+          contentDescription = stringResource(R.string.icon_descr_edited),
+          tint = metaColor,
+        )
+      }
+      CIStatusView(chatItem.meta.itemStatus, metaColor)
     }
+    Text(
+      chatItem.timestampText,
+      color = metaColor,
+      fontSize = 14.sp,
+      modifier = Modifier.padding(start = 3.dp)
+    )
   }
 }
 
+
 @Composable
-private fun CIMetaText(meta: CIMeta, chatTTL: Int?, color: Color) {
-  if (meta.itemEdited) {
-    StatusIconText(Icons.Outlined.Edit, color)
-    Spacer(Modifier.width(3.dp))
-  }
-  if (meta.disappearing) {
-    StatusIconText(Icons.Outlined.Timer, color)
-    val ttl = meta.itemTimed?.ttl
-    if (ttl != chatTTL) {
-      Text(TimedMessagesPreference.shortTtlText(ttl), color = color, fontSize = 13.sp)
+fun CIStatusView(status: CIStatus, metaColor: Color = HighOrLowlight) {
+  when (status) {
+    is CIStatus.SndSent -> {
+      Icon(Icons.Filled.Check, stringResource(R.string.icon_descr_sent_msg_status_sent), Modifier.height(12.dp), tint = metaColor)
     }
-    Spacer(Modifier.width(4.dp))
-  }
-  val statusIcon = meta.statusIcon(MaterialTheme.colors.primary, color)
-  if (statusIcon != null) {
-    val (icon, statusColor) = statusIcon
-    StatusIconText(icon, statusColor)
-    Spacer(Modifier.width(4.dp))
-  } else if (!meta.disappearing) {
-    StatusIconText(Icons.Filled.Circle, Color.Transparent)
-    Spacer(Modifier.width(4.dp))
-  }
-  Text(meta.timestampText, color = color, fontSize = 13.sp)
-}
-
-fun reserveSpaceForMeta(meta: CIMeta, chatTTL: Int?): String {
-  var res = ""
-  var repeats = 0
-  if (meta.itemEdited) repeats++
-  if (meta.itemTimed != null) {
-    repeats++
-    val ttl = meta.itemTimed?.ttl
-    if (ttl != chatTTL) {
-      res += TimedMessagesPreference.shortTtlText(ttl)
+    is CIStatus.SndErrorAuth -> {
+      Icon(Icons.Filled.Close,  stringResource(R.string.icon_descr_sent_msg_status_unauthorized_send), Modifier.height(12.dp), tint = Color.Red)
     }
+    is CIStatus.SndError -> {
+      Icon(Icons.Filled.WarningAmber, stringResource(R.string.icon_descr_sent_msg_status_send_failed), Modifier.height(12.dp), tint = Color.Yellow)
+    }
+    is CIStatus.RcvNew -> {
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = SimplexBlue)
+    }
+    else -> {}
   }
-  if (meta.itemStatus !is CIStatus.RcvRead && meta.itemStatus !is CIStatus.RcvNew) repeats++
-  repeat(repeats) {
-    res += "    "
-  }
-  return res + meta.timestampText
-}
-
-@Composable
-private fun StatusIconText(icon: ImageVector, color: Color) {
-  Icon(icon, null, Modifier.height(12.dp), tint = color)
 }
 
 @Preview
@@ -89,8 +68,7 @@ fun PreviewCIMetaView() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-    ),
-    null
+    )
   )
 }
 
@@ -101,8 +79,7 @@ fun PreviewCIMetaViewUnread() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       status = CIStatus.RcvNew()
-    ),
-    null
+    )
   )
 }
 
@@ -112,9 +89,8 @@ fun PreviewCIMetaViewSendFailed() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
-      status = CIStatus.SndError("CMD SYNTAX")
-    ),
-    null
+      status = CIStatus.SndError(AgentErrorType.CMD(CommandErrorType.SYNTAX()))
+    )
   )
 }
 
@@ -124,8 +100,7 @@ fun PreviewCIMetaViewSendNoAuth() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndErrorAuth()
-    ),
-    null
+    )
   )
 }
 
@@ -135,8 +110,7 @@ fun PreviewCIMetaViewSendSent() {
   CIMetaView(
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndSent()
-    ),
-    null
+    )
   )
 }
 
@@ -147,8 +121,7 @@ fun PreviewCIMetaViewEdited() {
     chatItem = ChatItem.getSampleData(
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true
-    ),
-    null
+    )
   )
 }
 
@@ -160,8 +133,7 @@ fun PreviewCIMetaViewEditedUnread() {
       1, CIDirection.DirectRcv(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.RcvNew()
-    ),
-    null
+    )
   )
 }
 
@@ -173,8 +145,7 @@ fun PreviewCIMetaViewEditedSent() {
       1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
       itemEdited = true,
       status=CIStatus.SndSent()
-    ),
-    null
+    )
   )
 }
 
@@ -182,7 +153,6 @@ fun PreviewCIMetaViewEditedSent() {
 @Composable
 fun PreviewCIMetaViewDeletedContent() {
   CIMetaView(
-    chatItem = ChatItem.getDeletedContentSampleData(),
-    null
+    chatItem = ChatItem.getDeletedContentSampleData()
   )
 }

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

@@ -1,260 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CornerSize
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.runtime.*
-import androidx.compose.runtime.saveable.rememberSaveable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.drawWithCache
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.*
-import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.*
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.*
-
-// TODO refactor https://github.com/simplex-chat/simplex-chat/pull/1451#discussion_r1033429901
-
-@Composable
-fun CIVoiceView(
-  providedDurationSec: Int,
-  file: CIFile?,
-  edited: Boolean,
-  sent: Boolean,
-  hasText: Boolean,
-  ci: ChatItem,
-  timedMessagesTTL: Int?,
-  longClick: () -> Unit,
-) {
-  Row(
-    Modifier.padding(top = if (hasText) 14.dp else 4.dp, bottom = if (hasText) 14.dp else 6.dp, start = 6.dp, end = 6.dp),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    if (file != null) {
-      val context = LocalContext.current
-      val filePath = remember(file.filePath, file.fileStatus) { getLoadedFilePath(context, file) }
-      var brokenAudio by rememberSaveable(file.filePath) { mutableStateOf(false) }
-      val audioPlaying = rememberSaveable(file.filePath) { mutableStateOf(false) }
-      val progress = rememberSaveable(file.filePath) { mutableStateOf(0) }
-      val duration = rememberSaveable(file.filePath) { mutableStateOf(providedDurationSec * 1000) }
-      val play = {
-        AudioPlayer.play(filePath, audioPlaying, progress, duration, true)
-        brokenAudio = !audioPlaying.value
-      }
-      val pause = {
-        AudioPlayer.pause(audioPlaying, progress)
-      }
-      val text = remember {
-        derivedStateOf {
-          val time = when {
-            audioPlaying.value || progress.value != 0 -> progress.value
-            else -> duration.value
-          }
-          durationText(time / 1000)
-        }
-      }
-      VoiceLayout(file, ci, text, audioPlaying, progress, duration, brokenAudio, sent, hasText, timedMessagesTTL, play, pause, longClick)
-    } else {
-      VoiceMsgIndicator(null, false, sent, hasText, null, null, false, {}, {}, longClick)
-      val metaReserve = if (edited)
-        "                     "
-      else
-        "                 "
-      Text(metaReserve)
-    }
-  }
-}
-
-@Composable
-private fun VoiceLayout(
-  file: CIFile,
-  ci: ChatItem,
-  text: State<String>,
-  audioPlaying: State<Boolean>,
-  progress: State<Int>,
-  duration: State<Int>,
-  brokenAudio: Boolean,
-  sent: Boolean,
-  hasText: Boolean,
-  timedMessagesTTL: Int?,
-  play: () -> Unit,
-  pause: () -> Unit,
-  longClick: () -> Unit
-) {
-  when {
-    hasText -> {
-      Spacer(Modifier.width(6.dp))
-      VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
-      DurationText(text, PaddingValues(start = 12.dp))
-    }
-    sent -> {
-      Row {
-        Row(verticalAlignment = Alignment.CenterVertically) {
-          Spacer(Modifier.height(56.dp))
-          DurationText(text, PaddingValues(end = 12.dp))
-        }
-        Column {
-          VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
-          Box(Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp)) {
-            CIMetaView(ci, timedMessagesTTL)
-          }
-        }
-      }
-    }
-    else -> {
-      Row {
-        Column {
-          VoiceMsgIndicator(file, audioPlaying.value, sent, hasText, progress, duration, brokenAudio, play, pause, longClick)
-          Box(Modifier.align(Alignment.CenterHorizontally).padding(top = 6.dp)) {
-            CIMetaView(ci, timedMessagesTTL)
-          }
-        }
-        Row(verticalAlignment = Alignment.CenterVertically) {
-          DurationText(text, PaddingValues(start = 12.dp))
-          Spacer(Modifier.height(56.dp))
-        }
-      }
-    }
-  }
-}
-
-@Composable
-private fun DurationText(text: State<String>, padding: PaddingValues) {
-  val minWidth = with(LocalDensity.current) { 45.sp.toDp() }
-  Text(
-    text.value,
-    Modifier
-      .padding(padding)
-      .widthIn(min = minWidth),
-    color = HighOrLowlight,
-    fontSize = 16.sp,
-    maxLines = 1
-  )
-}
-
-@Composable
-private fun PlayPauseButton(
-  audioPlaying: Boolean,
-  sent: Boolean,
-  angle: Float,
-  strokeWidth: Float,
-  strokeColor: Color,
-  enabled: Boolean,
-  error: Boolean,
-  play: () -> Unit,
-  pause: () -> Unit,
-  longClick: () -> Unit
-) {
-  Surface(
-    Modifier.drawRingModifier(angle, strokeColor, strokeWidth),
-    color = if (sent) SentColorLight else ReceivedColorLight,
-    shape = MaterialTheme.shapes.small.copy(CornerSize(percent = 50))
-  ) {
-    Box(
-      Modifier
-        .defaultMinSize(minWidth = 56.dp, minHeight = 56.dp)
-        .combinedClickable(
-          onClick = { if (!audioPlaying) play() else pause() },
-          onLongClick = longClick
-        ),
-      contentAlignment = Alignment.Center
-    ) {
-      Icon(
-        imageVector = if (audioPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
-        contentDescription = null,
-        Modifier.size(36.dp),
-        tint = if (error) WarningOrange else if (!enabled) HighOrLowlight else MaterialTheme.colors.primary
-      )
-    }
-  }
-}
-
-@Composable
-private fun VoiceMsgIndicator(
-  file: CIFile?,
-  audioPlaying: Boolean,
-  sent: Boolean,
-  hasText: Boolean,
-  progress: State<Int>?,
-  duration: State<Int>?,
-  error: Boolean,
-  play: () -> Unit,
-  pause: () -> Unit,
-  longClick: () -> Unit
-) {
-  val strokeWidth = with(LocalDensity.current) { 3.dp.toPx() }
-  val strokeColor = MaterialTheme.colors.primary
-  if (file != null && file.loaded && progress != null && duration != null) {
-    val angle = 360f * (progress.value.toDouble() / duration.value).toFloat()
-    if (hasText) {
-      IconButton({ if (!audioPlaying) play() else pause() }, Modifier.size(56.dp).drawRingModifier(angle, strokeColor, strokeWidth)) {
-        Icon(
-          imageVector = if (audioPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow,
-          contentDescription = null,
-          Modifier.size(36.dp),
-          tint = MaterialTheme.colors.primary
-        )
-      }
-    } else {
-      PlayPauseButton(audioPlaying, sent, angle, strokeWidth, strokeColor, true, error, play, pause, longClick = longClick)
-    }
-  } else {
-    if (file?.fileStatus == 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,5 +1,6 @@
 package chat.simplex.app.views.chat.item
 
+import android.content.Context
 import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
@@ -13,196 +14,123 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.*
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import chat.simplex.app.*
 import chat.simplex.app.R
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.chat.ComposeContextItem
 import chat.simplex.app.views.chat.ComposeState
 import chat.simplex.app.views.helpers.*
 import kotlinx.datetime.Clock
 
-// TODO refactor so that FramedItemView can show all CIContent items if they're deleted (see Swift code)
-
 @Composable
 fun ChatItemView(
+  user: User,
   cInfo: ChatInfo,
   cItem: ChatItem,
   composeState: MutableState<ComposeState>,
-  imageProvider: (() -> ImageGalleryProvider)? = null,
+  cxt: Context,
+  uriHandler: UriHandler? = null,
   showMember: Boolean = false,
   useLinkPreviews: Boolean,
-  linkMode: SimplexLinkMode,
   deleteMessage: (Long, CIDeleteMode) -> Unit,
   receiveFile: (Long) -> Unit,
-  joinGroup: (Long) -> Unit,
-  acceptCall: (Contact) -> Unit,
-  scrollToItem: (Long) -> Unit,
-  acceptFeature: (Contact, ChatFeature) -> Unit
+  acceptCall: (Contact) -> Unit
 ) {
   val context = LocalContext.current
-  val uriHandler = LocalUriHandler.current
   val sent = cItem.chatDir.sent
   val alignment = if (sent) Alignment.CenterEnd else Alignment.CenterStart
   val showMenu = remember { mutableStateOf(false) }
-  val revealed = remember { mutableStateOf(false) }
-  val fullDeleteAllowed = remember(cInfo) { cInfo.featureEnabled(ChatFeature.FullDelete) }
   val saveFileLauncher = rememberSaveFileLauncher(cxt = context, ciFile = cItem.file)
-  val onLinkLongClick = { _: String -> showMenu.value = true }
-
   Box(
     modifier = Modifier
       .padding(bottom = 4.dp)
       .fillMaxWidth(),
     contentAlignment = alignment,
   ) {
-    val onClick = {
-      when (cItem.meta.itemStatus) {
-        is CIStatus.SndErrorAuth -> {
-          showMsgDeliveryErrorAlert(generalGetString(R.string.message_delivery_error_desc))
-        }
-        is CIStatus.SndError -> {
-          showMsgDeliveryErrorAlert(generalGetString(R.string.unknown_error) + ": ${cItem.meta.itemStatus.agentError}")
-        }
-        else -> {}
-      }
-    }
     Column(
       Modifier
         .clip(RoundedCornerShape(18.dp))
-        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = onClick),
+        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
     ) {
-      @Composable
-      fun framedItemView() {
-        FramedItemView(cInfo, cItem, uriHandler, imageProvider, showMember = showMember, linkMode = linkMode, showMenu, receiveFile, onLinkLongClick, scrollToItem)
-      }
-
-      fun deleteMessageQuestionText(): String {
-        return if (fullDeleteAllowed) {
-          generalGetString(R.string.delete_message_cannot_be_undone_warning)
+      @Composable fun ContentItem() {
+        if (cItem.file == null && cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
+          EmojiItemView(cItem)
         } else {
-          generalGetString(R.string.delete_message_mark_deleted_warning)
+          FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile)
         }
-      }
-
-      @Composable
-      fun MsgContentItemDropdownMenu() {
         DropdownMenu(
           expanded = showMenu.value,
           onDismissRequest = { showMenu.value = false },
           Modifier.width(220.dp)
         ) {
-          if (!cItem.meta.itemDeleted) {
-            ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
-              if (composeState.value.editing) {
-                composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
-              } else {
-                composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
-              }
-              showMenu.value = false
-            })
-          }
-          ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
-            val filePath = getLoadedFilePath(SimplexApp.context, cItem.file)
-            when {
-              filePath != null -> shareFile(context, cItem.text, filePath)
-              else -> shareText(context, cItem.content.text)
+          ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
+            if (composeState.value.editing) {
+              composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
+            } else {
+              composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
             }
             showMenu.value = false
           })
-          ItemAction(stringResource(R.string.copy_verb), Icons.Outlined.ContentCopy, onClick = {
-            copyText(context, cItem.content.text)
+          ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
+            shareText(cxt, cItem.content.text)
             showMenu.value = false
           })
-          if (cItem.content.msgContent is MsgContent.MCImage || cItem.content.msgContent is MsgContent.MCFile || cItem.content.msgContent is MsgContent.MCVoice) {
+          ItemAction(stringResource(R.string.copy_verb), Icons.Outlined.ContentCopy, onClick = {
+            copyText(cxt, cItem.content.text)
+            showMenu.value = false
+          })
+          if (cItem.content.msgContent is MsgContent.MCImage || cItem.content.msgContent is MsgContent.MCFile) {
             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 && cItem.content.msgContent !is MsgContent.MCVoice) {
+          if (cItem.meta.editable) {
             ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
               composeState.value = ComposeState(editingItem = cItem, useLinkPreviews = useLinkPreviews)
               showMenu.value = false
             })
           }
-          if (cItem.meta.itemDeleted && revealed.value) {
-            ItemAction(
-              stringResource(R.string.hide_verb),
-              Icons.Outlined.VisibilityOff,
-              onClick = {
-                revealed.value = false
-                showMenu.value = false
-              }
-            )
-          }
-          DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
+          ItemAction(
+            stringResource(R.string.delete_verb),
+            Icons.Outlined.Delete,
+            onClick = {
+              showMenu.value = false
+              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
+            },
+            color = Color.Red
+          )
         }
       }
 
-      @Composable
-      fun MarkedDeletedItemDropdownMenu() {
+      @Composable fun DeletedItem() {
+        DeletedItemView(cItem, showMember = showMember)
         DropdownMenu(
           expanded = showMenu.value,
           onDismissRequest = { showMenu.value = false },
           Modifier.width(220.dp)
         ) {
           ItemAction(
-            stringResource(R.string.reveal_verb),
-            Icons.Outlined.Visibility,
+            stringResource(R.string.delete_verb),
+            Icons.Outlined.Delete,
             onClick = {
-              revealed.value = true
               showMenu.value = false
-            }
+              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
+            },
+            color = Color.Red
           )
-          DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
-        }
-      }
-
-      @Composable
-      fun ContentItem() {
-        val mc = cItem.content.msgContent
-        if (cItem.meta.itemDeleted && !revealed.value) {
-          MarkedDeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
-          MarkedDeletedItemDropdownMenu()
-        } else if (cItem.quotedItem == null && !cItem.meta.itemDeleted && !cItem.meta.isLive) {
-          if (mc is MsgContent.MCText && isShortEmoji(cItem.content.text)) {
-            EmojiItemView(cItem, cInfo.timedMessagesTTL)
-            MsgContentItemDropdownMenu()
-          } else if (mc is MsgContent.MCVoice && cItem.content.text.isEmpty()) {
-            CIVoiceView(mc.duration, cItem.file, cItem.meta.itemEdited, cItem.chatDir.sent, hasText = false, cItem, cInfo.timedMessagesTTL, longClick = { onLinkLongClick("") })
-            MsgContentItemDropdownMenu()
-          } else {
-            framedItemView()
-            MsgContentItemDropdownMenu()
-          }
-        } else {
-          framedItemView()
-          MsgContentItemDropdownMenu()
-        }
-      }
-
-      @Composable fun DeletedItem() {
-        DeletedItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
-        DropdownMenu(
-          expanded = showMenu.value,
-          onDismissRequest = { showMenu.value = false },
-          Modifier.width(220.dp)
-        ) {
-          DeleteItemAction(cItem, showMenu, questionText = deleteMessageQuestionText(), deleteMessage)
         }
       }
 
@@ -217,44 +145,12 @@ fun ChatItemView(
         is CIContent.RcvDeleted -> DeletedItem()
         is CIContent.SndCall -> CallItem(c.status, c.duration)
         is CIContent.RcvCall -> CallItem(c.status, c.duration)
-        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, cInfo.timedMessagesTTL, showMember = showMember)
-        is CIContent.RcvGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
-        is CIContent.SndGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
-        is CIContent.RcvGroupEventContent -> CIEventView(cItem)
-        is CIContent.SndGroupEventContent -> CIEventView(cItem)
-        is CIContent.RcvConnEventContent -> CIEventView(cItem)
-        is CIContent.SndConnEventContent -> CIEventView(cItem)
-        is CIContent.RcvChatFeature -> CIChatFeatureView(cItem, c.feature, c.enabled.iconColor)
-        is CIContent.SndChatFeature -> CIChatFeatureView(cItem, c.feature, c.enabled.iconColor)
-        is CIContent.RcvChatPreference -> CIFeaturePreferenceView(cItem, cInfo, c.feature, c.allowed, acceptFeature)
-        is CIContent.SndChatPreference -> CIChatFeatureView(cItem, c.feature, HighOrLowlight, icon = c.feature.icon,)
-        is CIContent.RcvGroupFeature -> CIChatFeatureView(cItem, c.groupFeature, c.preference.enable.iconColor)
-        is CIContent.SndGroupFeature -> CIChatFeatureView(cItem, c.groupFeature, c.preference.enable.iconColor)
-        is CIContent.RcvChatFeatureRejected -> CIChatFeatureView(cItem, c.feature, Color.Red)
-        is CIContent.RcvGroupFeatureRejected -> CIChatFeatureView(cItem, c.groupFeature, Color.Red)
+        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, showMember = showMember)
       }
     }
   }
 }
 
-@Composable
-fun DeleteItemAction(
-  cItem: ChatItem,
-  showMenu: MutableState<Boolean>,
-  questionText: String,
-  deleteMessage: (Long, CIDeleteMode) -> Unit
-) {
-  ItemAction(
-    stringResource(R.string.delete_verb),
-    Icons.Outlined.Delete,
-    onClick = {
-      showMenu.value = false
-      deleteMessageAlertDialog(cItem, questionText, deleteMessage = deleteMessage)
-    },
-    color = Color.Red
-  )
-}
-
 @Composable
 fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Color = MaterialTheme.colors.onBackground) {
   DropdownMenuItem(onClick) {
@@ -263,8 +159,7 @@ fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Colo
         text,
         modifier = Modifier
           .fillMaxWidth()
-          .weight(1F)
-          .padding(end = 15.dp),
+          .weight(1F),
         color = color
       )
       Icon(icon, text, tint = color)
@@ -272,10 +167,10 @@ fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Colo
   }
 }
 
-fun deleteMessageAlertDialog(chatItem: ChatItem, questionText: String, deleteMessage: (Long, CIDeleteMode) -> Unit) {
+fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteMode) -> Unit) {
   AlertManager.shared.showAlertDialogButtons(
     title = generalGetString(R.string.delete_message__question),
-    text = questionText,
+    text = generalGetString(R.string.delete_message_cannot_be_undone_warning),
     buttons = {
       Row(
         Modifier
@@ -283,13 +178,13 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, questionText: String, deleteMes
           .padding(horizontal = 8.dp, vertical = 2.dp),
         horizontalArrangement = Arrangement.End,
       ) {
-        TextButton(onClick = {
+        Button(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))
-          TextButton(onClick = {
+          Button(onClick = {
             deleteMessage(chatItem.id, CIDeleteMode.cidmBroadcast)
             AlertManager.shared.hideAlert()
           }) { Text(stringResource(R.string.for_everybody)) }
@@ -299,31 +194,22 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, questionText: String, deleteMes
   )
 }
 
-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 = { _ -> },
-      scrollToItem = {},
-      acceptFeature = { _, _ -> }
+      acceptCall = { _ -> }
     )
   }
 }
@@ -333,17 +219,15 @@ 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 = { _ -> },
-      scrollToItem = {},
-      acceptFeature = { _, _ -> }
+      acceptCall = { _ -> }
     )
   }
 }

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

@@ -18,7 +18,7 @@ import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
-fun DeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean = false) {
+fun DeletedItemView(ci: ChatItem, showMember: Boolean = false) {
   Surface(
     shape = RoundedCornerShape(18.dp),
     color = ReceivedColorLight,
@@ -35,7 +35,7 @@ fun DeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean =
         style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
         modifier = Modifier.padding(end = 8.dp)
       )
-      CIMetaView(ci, timedMessagesTTL)
+      CIMetaView(ci)
     }
   }
 }
@@ -49,8 +49,7 @@ fun DeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean =
 fun PreviewDeletedItemView() {
   SimpleXTheme {
     DeletedItemView(
-      ChatItem.getDeletedContentSampleData(),
-      null
+      ChatItem.getDeletedContentSampleData()
     )
   }
 }

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

@@ -15,13 +15,13 @@ val largeEmojiFont: TextStyle = TextStyle(fontSize = 48.sp)
 val mediumEmojiFont: TextStyle = TextStyle(fontSize = 36.sp)
 
 @Composable
-fun EmojiItemView(chatItem: ChatItem, timedMessagesTTL: Int?) {
+fun EmojiItemView(chatItem: ChatItem) {
   Column(
     Modifier.padding(vertical = 8.dp, horizontal = 12.dp),
     horizontalAlignment = Alignment.CenterHorizontally
   ) {
     EmojiText(chatItem.content.text)
-    CIMetaView(chatItem, timedMessagesTTL)
+    CIMetaView(chatItem)
   }
 }
 
@@ -31,19 +31,12 @@ fun EmojiText(text: String) {
   Text(s, style = if (s.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont)
 }
 
-// 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)
+private fun isSimpleEmoji(c: Int): Boolean = c > 0x238C
 
+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 && emojiRegex.matches(str)
+  return s.codePoints().count() in 1..5 && s.codePoints().allMatch(::isEmoji)
 }

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

@@ -1,32 +1,30 @@
 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.*
-import androidx.compose.material.icons.outlined.Delete
+import androidx.compose.material.icons.filled.InsertDriveFile
 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.graphics.vector.ImageVector
-import androidx.compose.ui.layout.*
+import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.*
-import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.tooling.preview.*
-import androidx.compose.ui.unit.*
-import androidx.compose.ui.util.fastMap
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.helpers.ChatItemLinkView
+import chat.simplex.app.views.helpers.base64ToBitmap
 import kotlinx.datetime.Clock
 
 val SentColorLight = Color(0x1E45B8FF)
@@ -36,23 +34,14 @@ val ReceivedQuoteColorLight = Color(0x25B1B0B5)
 
 @Composable
 fun FramedItemView(
-  chatInfo: ChatInfo,
+  user: User,
   ci: ChatItem,
   uriHandler: UriHandler? = null,
-  imageProvider: (() -> ImageGalleryProvider)? = null,
   showMember: Boolean = false,
-  linkMode: SimplexLinkMode,
   showMenu: MutableState<Boolean>,
-  receiveFile: (Long) -> Unit,
-  onLinkLongClick: (link: String) -> Unit = {},
-  scrollToItem: (Long) -> Unit = {},
+  receiveFile: (Long) -> Unit
 ) {
   val sent = ci.chatDir.sent
-  val chatTTL = chatInfo.timedMessagesTTL
-
-  fun membership(): GroupMember? {
-    return if (chatInfo is ChatInfo.Group) chatInfo.groupInfo.membership else null
-  }
 
   @Composable
   fun ciQuotedMsgView(qi: CIQuote) {
@@ -61,40 +50,8 @@ fun FramedItemView(
       contentAlignment = Alignment.TopStart
     ) {
       MarkdownText(
-        qi.text, qi.formattedText, sender = qi.sender(membership()), senderBold = true, maxLines = 3,
-        style = TextStyle(fontSize = 15.sp, color = MaterialTheme.colors.onSurface),
-        linkMode = linkMode
-      )
-    }
-  }
-
-  @Composable
-  fun FramedItemHeader(caption: String, italic: Boolean, icon: ImageVector? = null) {
-    Row(
-      Modifier
-        .background(if (sent) SentQuoteColorLight else ReceivedQuoteColorLight)
-        .fillMaxWidth()
-        .padding(start = 8.dp)
-        .padding(end = 12.dp)
-        .padding(top = 6.dp)
-        .padding(bottom = if (ci.quotedItem == null) 6.dp else 0.dp),
-      horizontalArrangement = Arrangement.spacedBy(4.dp),
-    ) {
-      if (icon != null) {
-        Icon(
-          icon,
-          caption,
-          Modifier.size(18.dp),
-          tint = if (isInDarkTheme()) FileDark else FileLight
-        )
-      }
-      Text(
-        buildAnnotatedString {
-          withStyle(SpanStyle(fontSize = 12.sp, fontStyle = if (italic) FontStyle.Italic else FontStyle.Normal, color = HighOrLowlight)) {
-            append(caption)
-          }
-        },
-        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
+        qi.text, qi.formattedText, sender = qi.sender(user), senderBold = true, maxLines = 3,
+        style = TextStyle(fontSize = 15.sp, color = MaterialTheme.colors.onSurface)
       )
     }
   }
@@ -105,10 +62,6 @@ 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 -> {
@@ -123,17 +76,17 @@ fun FramedItemView(
             modifier = Modifier.size(68.dp).clipToBounds()
           )
         }
-        is MsgContent.MCFile, is MsgContent.MCVoice -> {
+        is MsgContent.MCFile -> {
           Box(Modifier.fillMaxWidth().weight(1f)) {
             ciQuotedMsgView(qi)
           }
           Icon(
-            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),
+            Icons.Filled.InsertDriveFile,
+            stringResource(R.string.icon_descr_file),
             Modifier
               .padding(top = 6.dp, end = 4.dp)
               .size(22.dp),
-            tint = if (isInDarkTheme()) FileDark else FileLight
+            tint = if (isSystemInDarkTheme()) FileDark else FileLight
           )
         }
         else -> ciQuotedMsgView(qi)
@@ -141,136 +94,72 @@ fun FramedItemView(
     }
   }
 
-  @Composable
-  fun ciFileView(ci: ChatItem, text: String) {
-    CIFileView(ci.file, ci.meta.itemEdited, receiveFile)
-    if (text != "" || ci.meta.isLive) {
-      CIMarkdownText(ci, chatTTL, showMember, linkMode = linkMode, uriHandler)
-    }
-  }
-
-  val transparentBackground = (ci.content.msgContent is MsgContent.MCImage) && !ci.meta.isLive && ci.content.text.isEmpty() && ci.quotedItem == null
-
-  Box(Modifier
-    .clip(RoundedCornerShape(18.dp))
-    .background(
-      when {
-        transparentBackground -> Color.Transparent
-        sent -> SentColorLight
-        else -> ReceivedColorLight
-      }
-    )) {
+  Surface(
+    shape = RoundedCornerShape(18.dp),
+    color = if (sent) SentColorLight else ReceivedColorLight
+  ) {
     var metaColor = HighOrLowlight
     Box(contentAlignment = Alignment.BottomEnd) {
       Column(Modifier.width(IntrinsicSize.Max)) {
-        PriorityLayout(Modifier, CHAT_IMAGE_LAYOUT_ID) {
-          if (ci.meta.itemDeleted) {
-            FramedItemHeader(stringResource(R.string.marked_deleted_description), true, Icons.Outlined.Delete)
-          } else if (ci.meta.isLive) {
-            FramedItemHeader(stringResource(R.string.live), false)
-          }
-          ci.quotedItem?.let { ciQuoteView(it) }
-          if (ci.file == null && ci.formattedText == null && !ci.meta.isLive && isShortEmoji(ci.content.text)) {
-            Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
-              Column(
-                Modifier
-                  .padding(bottom = 2.dp)
-                  .fillMaxWidth(),
-                horizontalAlignment = Alignment.CenterHorizontally
-              ) {
-                EmojiText(ci.content.text)
-                Text("")
-              }
+        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("")
             }
-          } else {
+          }
+        } else {
+          Column(Modifier.fillMaxWidth()) {
             when (val mc = ci.content.msgContent) {
               is MsgContent.MCImage -> {
-                CIImageView(image = mc.image, file = ci.file, imageProvider ?: return@PriorityLayout, showMenu, receiveFile)
-                if (mc.text == "" && !ci.meta.isLive) {
+                CIImageView(image = mc.image, file = ci.file, showMenu, receiveFile)
+                if (mc.text == "") {
                   metaColor = Color.White
                 } else {
-                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler)
+                  CIMarkdownText(ci, showMember, uriHandler)
                 }
               }
-              is MsgContent.MCVoice -> {
-                CIVoiceView(mc.duration, ci.file, ci.meta.itemEdited, ci.chatDir.sent, hasText = true, ci, timedMessagesTTL = chatTTL, longClick = { onLinkLongClick("") })
+              is MsgContent.MCFile -> {
+                CIFileView(ci.file, ci.meta.itemEdited, receiveFile)
                 if (mc.text != "") {
-                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler)
+                  CIMarkdownText(ci, showMember, uriHandler)
                 }
               }
-              is MsgContent.MCFile -> ciFileView(ci, mc.text)
-              is MsgContent.MCUnknown ->
-                if (ci.file == null) {
-                  CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
-                } else {
-                  ciFileView(ci, mc.text)
-                }
               is MsgContent.MCLink -> {
                 ChatItemLinkView(mc.preview)
-                CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
+                CIMarkdownText(ci, showMember, uriHandler)
               }
-              else -> CIMarkdownText(ci, chatTTL, showMember, linkMode, uriHandler, onLinkLongClick)
+              else -> CIMarkdownText(ci, showMember, uriHandler)
             }
           }
         }
       }
       Box(Modifier.padding(bottom = 6.dp, end = 12.dp)) {
-        CIMetaView(ci, chatTTL, metaColor)
+        CIMetaView(ci, metaColor)
       }
     }
   }
 }
 
 @Composable
-fun CIMarkdownText(
-  ci: ChatItem,
-  chatTTL: Int?,
-  showMember: Boolean,
-  linkMode: SimplexLinkMode,
-  uriHandler: UriHandler?,
-  onLinkLongClick: (link: String) -> Unit = {}
-) {
+fun CIMarkdownText(ci: ChatItem, showMember: Boolean, uriHandler: UriHandler?) {
   Box(Modifier.padding(vertical = 6.dp, horizontal = 12.dp)) {
-    val text = if (ci.meta.isLive) ci.content.msgContent?.text ?: ci.text else ci.text
     MarkdownText(
-      text, if (text.isEmpty()) emptyList() else ci.formattedText, if (showMember) ci.memberDisplayName else null,
-      meta = ci.meta, chatTTL = chatTTL, linkMode = linkMode,
-      uriHandler = uriHandler, senderBold = true, onLinkLongClick = onLinkLongClick
+      ci.content.text, ci.formattedText, if (showMember) ci.memberDisplayName else null,
+      metaText = ci.timestampText, edited = ci.meta.itemEdited, uriHandler = uriHandler, senderBold = true
     )
   }
 }
 
-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()
 }
@@ -281,11 +170,10 @@ fun PreviewTextItemViewSnd(@PreviewParameter(EditedProvider::class) edited: Bool
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello", itemEdited = edited,
       ),
-      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -298,11 +186,10 @@ fun PreviewTextItemViewRcv(@PreviewParameter(EditedProvider::class) edited: Bool
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectRcv(), Clock.System.now(), "hello", itemEdited = edited
       ),
-      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -315,7 +202,7 @@ fun PreviewTextItemViewLong(@PreviewParameter(EditedProvider::class) edited: Boo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1,
         CIDirection.DirectSnd(),
@@ -323,7 +210,6 @@ 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 = {}
     )
@@ -336,7 +222,7 @@ fun PreviewTextItemViewQuote(@PreviewParameter(EditedProvider::class) edited: Bo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -345,7 +231,6 @@ 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 = {}
     )
@@ -358,7 +243,7 @@ fun PreviewTextItemViewEmoji(@PreviewParameter(EditedProvider::class) edited: Bo
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -367,7 +252,6 @@ 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 = {}
     )
@@ -387,7 +271,7 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -396,7 +280,6 @@ fun PreviewQuoteWithTextAndImage(@PreviewParameter(EditedProvider::class) edited
         quotedItem = ciQuote,
         itemEdited = edited
       ),
-      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -416,7 +299,7 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -425,7 +308,6 @@ fun PreviewQuoteWithLongTextAndImage(@PreviewParameter(EditedProvider::class) ed
         quotedItem = ciQuote,
         itemEdited = edited
       ),
-      linkMode = SimplexLinkMode.DESCRIPTION,
       showMenu = showMenu,
       receiveFile = {}
     )
@@ -444,7 +326,7 @@ fun PreviewQuoteWithLongTextAndFile(@PreviewParameter(EditedProvider::class) edi
   val showMenu = remember { mutableStateOf(false) }
   SimpleXTheme {
     FramedItemView(
-      ChatInfo.Direct.sampleData,
+      User.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(),
         Clock.System.now(),
@@ -453,7 +335,6 @@ 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,153 +1,55 @@
-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.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.gestures.detectTransformGestures
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.*
-import androidx.compose.ui.graphics.painter.BitmapPainter
-import androidx.compose.ui.input.pointer.*
+import androidx.compose.ui.input.pointer.pointerInput
 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(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)
+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
               }
             }
-          }
+          )
         }
-      } 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(),
-        )
-      }
-    }
+        .fillMaxSize(),
+    )
   }
 }

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

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

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

@@ -1,58 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.*
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.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.ChatItem
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.generalGetString
-
-@Composable
-fun MarkedDeletedItemView(ci: ChatItem, timedMessagesTTL: Int?, showMember: Boolean = false) {
-  Surface(
-    shape = RoundedCornerShape(18.dp),
-    color = if (ci.chatDir.sent) SentColorLight else ReceivedColorLight,
-  ) {
-    Row(
-      Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
-      verticalAlignment = Alignment.CenterVertically
-    ) {
-      Text(
-        buildAnnotatedString {
-          // appendSender(this, if (showMember) ci.memberDisplayName else null, true) // TODO font size
-          withStyle(SpanStyle(fontSize = 12.sp, fontStyle = FontStyle.Italic, color = HighOrLowlight)) { append(generalGetString(R.string.marked_deleted_description)) }
-        },
-        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
-        modifier = Modifier.padding(end = 8.dp)
-      )
-      CIMetaView(ci, timedMessagesTTL)
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewMarkedDeletedItemView() {
-  SimpleXTheme {
-    DeletedItemView(
-      ChatItem.getSampleData(itemDeleted = true),
-      null
-    )
-  }
-}

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

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

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

@@ -5,7 +5,6 @@ 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
@@ -16,69 +15,57 @@ 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.*
-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.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.WarningOrange
+import chat.simplex.app.views.chat.clearChatDialog
+import chat.simplex.app.views.chat.deleteContactDialog
 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) }
-  val showMarkRead = remember(chat.chatStats.unreadCount, chat.chatStats.unreadChat) {
-    chat.chatStats.unreadCount > 0 || chat.chatStats.unreadChat
-  }
-  val stopped = chatModel.chatRunning.value == false
-  val linkMode by remember { chatModel.controller.appPrefs.simplexLinkMode.state }
-  LaunchedEffect(chat.id) {
+  var showMarkRead by remember { mutableStateOf(false) }
+  LaunchedEffect(chat.id, chat.chatStats.unreadCount > 0) {
     showMenu.value = false
     delay(500L)
+    showMarkRead = chat.chatStats.unreadCount > 0
   }
   when (chat.chatInfo) {
     is ChatInfo.Direct ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped, linkMode) },
-        click = { directChatAction(chat.chatInfo, chatModel) },
+        chatLinkPreview = { ChatPreviewView(chat) },
+        click = { openOrPendingChat(chat.chatInfo, chatModel) },
         dropdownMenuItems = { ContactMenuItems(chat, chatModel, showMenu, showMarkRead) },
-        showMenu,
-        stopped
+        showMenu
       )
     is ChatInfo.Group ->
       ChatListNavLinkLayout(
-        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,
-        stopped
+        chatLinkPreview = { ChatPreviewView(chat) },
+        click = { openOrPendingChat(chat.chatInfo, chatModel) },
+        dropdownMenuItems = { GroupMenuItems(chat, chatModel, showMenu, showMarkRead) },
+        showMenu
       )
     is ChatInfo.ContactRequest ->
       ChatListNavLinkLayout(
-        chatLinkPreview = { ContactRequestView(chatModel.incognito.value, chat.chatInfo) },
+        chatLinkPreview = { ContactRequestView(chat.chatInfo) },
         click = { contactRequestAlertDialog(chat.chatInfo, chatModel) },
         dropdownMenuItems = { ContactRequestMenuItems(chat.chatInfo, chatModel, showMenu) },
-        showMenu,
-        stopped
+        showMenu
       )
     is ChatInfo.ContactConnection ->
       ChatListNavLinkLayout(
         chatLinkPreview = { ContactConnectionView(chat.chatInfo.contactConnection) },
-        click = {
-          ModalManager.shared.showModalCloseable(true) { close ->
-            ContactConnectionInfoView(chatModel, chat.chatInfo.contactConnection.connReqInv, chat.chatInfo.contactConnection, false, close)
-          }
-        },
+        click = { contactConnectionAlertDialog(chat.chatInfo.contactConnection, chatModel) },
         dropdownMenuItems = { ContactConnectionMenuItems(chat.chatInfo, chatModel, showMenu) },
-        showMenu,
-        stopped
+        showMenu
       )
   }
 }
 
-fun directChatAction(chatInfo: ChatInfo, chatModel: ChatModel) {
+fun openOrPendingChat(chatInfo: ChatInfo, chatModel: ChatModel) {
   if (chatInfo.ready) {
     withApi { openChat(chatInfo, chatModel) }
   } else {
@@ -86,14 +73,6 @@ fun directChatAction(chatInfo: ChatInfo, chatModel: ChatModel) {
   }
 }
 
-fun groupChatAction(groupInfo: GroupInfo, chatModel: ChatModel) {
-  when (groupInfo.membership.memberStatus) {
-    GroupMemberStatus.MemInvited -> acceptGroupInvitationAlertDialog(groupInfo, chatModel)
-    GroupMemberStatus.MemAccepted -> groupInvitationAcceptedAlert()
-    else -> withApi { openChat(ChatInfo.Group(groupInfo), chatModel) }
-  }
-}
-
 suspend fun openChat(chatInfo: ChatInfo, chatModel: ChatModel) {
   val chat = chatModel.controller.apiGetChat(chatInfo.chatType, chatInfo.apiId)
   if (chat != null) {
@@ -103,116 +82,54 @@ suspend fun openChat(chatInfo: ChatInfo, 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)
-}
-
 @Composable
 fun ContactMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
   if (showMarkRead) {
-    MarkReadChatAction(chat, chatModel, showMenu)
-  } else {
-    MarkUnreadChatAction(chat, chatModel, showMenu)
+    ItemAction(
+      stringResource(R.string.mark_read),
+      Icons.Outlined.Check,
+      onClick = {
+        markChatRead(chat, chatModel)
+        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
+        showMenu.value = false
+      }
+    )
   }
-  ToggleNotificationsChatAction(chat, chatModel, chat.chatInfo.ntfsEnabled, showMenu)
-  ClearChatAction(chat, chatModel, showMenu)
-  DeleteContactAction(chat, chatModel, showMenu)
-}
-
-@Composable
-fun GroupMenuItems(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
-  when (groupInfo.membership.memberStatus) {
-    GroupMemberStatus.MemInvited -> {
-      JoinGroupAction(chat, groupInfo, chatModel, showMenu)
-      if (groupInfo.canDelete) {
-        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, groupInfo, chatModel, showMenu)
-      }
-    }
-  }
-}
-
-@Composable
-fun MarkReadChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    stringResource(R.string.mark_read),
-    Icons.Outlined.Check,
+    stringResource(R.string.clear_verb),
+    Icons.Outlined.Restore,
     onClick = {
-      markChatRead(chat, chatModel)
-      chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
+      clearChatDialog(chat.chatInfo, chatModel)
       showMenu.value = false
-    }
+    },
+    color = WarningOrange
+  )
+  ItemAction(
+    stringResource(R.string.delete_verb),
+    Icons.Outlined.Delete,
+    onClick = {
+      deleteContactDialog(chat.chatInfo as ChatInfo.Direct, chatModel)
+      showMenu.value = false
+    },
+    color = Color.Red
   )
 }
 
 @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
-      )
-    }
+fun GroupMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
+  if (showMarkRead) {
+    ItemAction(
+      stringResource(R.string.mark_read),
+      Icons.Outlined.Check,
+      onClick = {
+        markChatRead(chat, chatModel)
+        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
+        showMenu.value = false
+      }
+    )
   }
-}
-
-@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_chat_menu_action),
+    stringResource(R.string.clear_verb),
     Icons.Outlined.Restore,
     onClick = {
       clearChatDialog(chat.chatInfo, chatModel)
@@ -222,65 +139,11 @@ fun ClearChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boo
   )
 }
 
-@Composable
-fun DeleteContactAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  ItemAction(
-    stringResource(R.string.delete_contact_menu_action),
-    Icons.Outlined.Delete,
-    onClick = {
-      deleteContactDialog(chat.chatInfo, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
-@Composable
-fun DeleteGroupAction(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  ItemAction(
-    stringResource(R.string.delete_group_menu_action),
-    Icons.Outlined.Delete,
-    onClick = {
-      deleteGroupDialog(chat.chatInfo, groupInfo, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
-@Composable
-fun JoinGroupAction(chat: Chat, groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  val joinGroup: () -> Unit = { withApi { chatModel.controller.apiJoinGroup(groupInfo.groupId) } }
-  ItemAction(
-    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 = {
-      joinGroup()
-      showMenu.value = false
-    }
-  )
-}
-
-@Composable
-fun LeaveGroupAction(groupInfo: GroupInfo, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  ItemAction(
-    stringResource(R.string.leave_group_button),
-    Icons.Outlined.Logout,
-    onClick = {
-      leaveGroupDialog(groupInfo, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
 @Composable
 fun ContactRequestMenuItems(chatInfo: ChatInfo.ContactRequest, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
   ItemAction(
-    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,
+    stringResource(R.string.accept_contact_button),
+    Icons.Outlined.Check,
     onClick = {
       acceptContactRequest(chatInfo, chatModel)
       showMenu.value = false
@@ -299,66 +162,25 @@ 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(c: Chat, chatModel: ChatModel) {
-  var chat = c
+fun markChatRead(chat: Chat, chatModel: ChatModel) {
+  chatModel.markChatItemsRead(chat.chatInfo)
   withApi {
-    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(
+    chatModel.controller.apiChatRead(
       chat.chatInfo.chatType,
       chat.chatInfo.apiId,
-      true
+      CC.ItemRange(chat.chatStats.minUnreadItemId, chat.chatItems.last().id)
     )
-    if (success) {
-      chatModel.replaceChat(chat.id, chat.copy(chatStats = chat.chatStats.copy(unreadChat = true)))
-    }
   }
 }
 
@@ -366,7 +188,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 = if (chatModel.incognito.value) generalGetString(R.string.accept_contact_incognito_button) else generalGetString(R.string.accept_contact_button),
+    confirmText = generalGetString(R.string.accept_contact_button),
     onConfirm = { acceptContactRequest(contactRequest, chatModel) },
     dismissText = generalGetString(R.string.reject_contact_button),
     onDismiss = { rejectContactRequest(contactRequest, chatModel) }
@@ -407,14 +229,14 @@ fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel
           .padding(horizontal = 8.dp, vertical = 2.dp),
         horizontalArrangement = Arrangement.End,
       ) {
-        TextButton(onClick = {
+        Button(onClick = {
           AlertManager.shared.hideAlert()
-          deleteContactConnectionAlert(connection, chatModel) {}
+          deleteContactConnectionAlert(connection, chatModel)
         }) {
           Text(stringResource(R.string.delete_verb))
         }
         Spacer(Modifier.padding(horizontal = 4.dp))
-        TextButton(onClick = { AlertManager.shared.hideAlert() }) {
+        Button(onClick = { AlertManager.shared.hideAlert() }) {
           Text(stringResource(R.string.ok))
         }
       }
@@ -422,7 +244,7 @@ fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel
   )
 }
 
-fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel: ChatModel, onSuccess: () -> Unit) {
+fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel: ChatModel) {
   AlertManager.shared.showAlertDialog(
     title = generalGetString(R.string.delete_pending_connection__question),
     text = generalGetString(
@@ -435,7 +257,6 @@ fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel
         AlertManager.shared.hideAlert()
         if (chatModel.controller.apiDeleteChat(ChatType.ContactConnection, connection.apiId)) {
           chatModel.removeChat(connection.id)
-          onSuccess()
         }
       }
     }
@@ -460,88 +281,28 @@ fun pendingContactAlertDialog(chatInfo: ChatInfo, chatModel: ChatModel) {
   )
 }
 
-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 = 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)
-    if (r) {
-      chatModel.removeChat(groupInfo.id)
-      chatModel.chatId.value = null
-      chatModel.controller.ntfManager.cancelNotificationsForChat(groupInfo.id)
-    }
-  }
-}
-
-fun groupInvitationAcceptedAlert() {
-  AlertManager.shared.showAlertMsg(
-    generalGetString(R.string.joining_group),
-    generalGetString(R.string.youve_accepted_group_invitation_connecting_to_inviting_group_member)
-  )
-}
-
-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,
   click: () -> Unit,
   dropdownMenuItems: (@Composable () -> Unit)?,
-  showMenu: MutableState<Boolean>,
-  stopped: Boolean
+  showMenu: MutableState<Boolean>
 ) {
-  var modifier = Modifier.fillMaxWidth()
-  if (!stopped) modifier = modifier.combinedClickable(onClick = click, onLongClick = { showMenu.value = true })
-  Box(modifier) {
+  Surface(
+    modifier = Modifier
+      .fillMaxWidth()
+      .combinedClickable(
+        onClick = click,
+        onLongClick = { showMenu.value = true }
+      )
+      .height(88.dp)
+  ) {
     Row(
       modifier = Modifier
         .fillMaxWidth()
-        .padding(start = 8.dp, top = 8.dp, end = 12.dp, bottom = 8.dp),
+        .padding(vertical = 8.dp)
+        .padding(start = 8.dp)
+        .padding(end = 12.dp),
       verticalAlignment = Alignment.Top
     ) {
       chatLinkPreview()
@@ -584,17 +345,12 @@ fun PreviewChatListNavLinkDirect() {
               )
             ),
             chatStats = Chat.ChatStats()
-          ),
-          false,
-          null,
-          stopped = false,
-          linkMode = SimplexLinkMode.DESCRIPTION
+          )
         )
       },
       click = {},
       dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) },
-      stopped = false
+      showMenu = remember { mutableStateOf(false) }
     )
   }
 }
@@ -622,17 +378,12 @@ fun PreviewChatListNavLinkGroup() {
               )
             ),
             chatStats = Chat.ChatStats()
-          ),
-          false,
-          null,
-          stopped = false,
-          linkMode = SimplexLinkMode.DESCRIPTION
+          )
         )
       },
       click = {},
       dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) },
-      stopped = false
+      showMenu = remember { mutableStateOf(false) }
     )
   }
 }
@@ -648,12 +399,11 @@ fun PreviewChatListNavLinkContactRequest() {
   SimpleXTheme {
     ChatListNavLinkLayout(
       chatLinkPreview = {
-        ContactRequestView(false, ChatInfo.ContactRequest.sampleData)
+        ContactRequestView(ChatInfo.ContactRequest.sampleData)
       },
       click = {},
       dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) },
-      stopped = false
+      showMenu = remember { mutableStateOf(false) }
     )
   }
 }

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

@@ -1,224 +1,149 @@
 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.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.material.icons.outlined.*
+import androidx.compose.material.icons.outlined.Menu
+import androidx.compose.material.icons.outlined.PersonAdd
 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.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.helpers.*
+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.newchat.NewChatSheet
+import chat.simplex.app.views.onboarding.MakeConnection
 import chat.simplex.app.views.usersettings.SettingsView
-import chat.simplex.app.views.usersettings.simplexTeamUri
-import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.CoroutineScope
 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 ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped: Boolean) {
-  val newChatSheetState by rememberSaveable(stateSaver = NewChatSheetState.saver()) { mutableStateOf(MutableStateFlow(NewChatSheetState.GONE)) }
-  val showNewChatSheet = {
-    newChatSheetState.value = NewChatSheetState.VISIBLE
-  }
-  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) },
-    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))
-        }
-      }
+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) {
+  val scaffoldCtrl = scaffoldController()
+  LaunchedEffect(chatModel.clearOverlays.value) {
+    if (chatModel.clearOverlays.value && scaffoldCtrl.expanded.value) scaffoldCtrl.collapse()
+  }
+  BottomSheetScaffold(
+    scaffoldState = scaffoldCtrl.state,
+    drawerContent = { SettingsView(chatModel, setPerformLA) },
+    sheetPeekHeight = 0.dp,
+    sheetContent = { NewChatSheet(chatModel, scaffoldCtrl) },
+    sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp),
   ) {
-    Box(Modifier.padding(it)) {
+    Box {
       Column(
         modifier = Modifier
           .fillMaxSize()
           .background(MaterialTheme.colors.background)
       ) {
+        ChatListToolbar(scaffoldCtrl)
+        Divider()
         if (chatModel.chats.isNotEmpty()) {
-          ChatList(chatModel, search = searchInList)
+          ChatList(chatModel)
         } else {
-          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)
-          }
+          MakeConnection(chatModel)
         }
       }
+      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
-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)
-    }
-    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())
-      }
-      drawPath(
-        color = color,
-        path = trianglePath
+fun ChatListToolbar(scaffoldCtrl: ScaffoldController) {
+  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)
+      )
+    }
+    Text(
+      stringResource(R.string.your_chats),
+      color = MaterialTheme.colors.onBackground,
+      fontWeight = FontWeight.SemiBold,
+      modifier = Modifier.padding(5.dp)
+    )
+    IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
+      Icon(
+        Icons.Outlined.PersonAdd,
+        stringResource(R.string.add_contact),
+        tint = MaterialTheme.colors.primary,
+        modifier = Modifier.padding(10.dp)
       )
-    })
-    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,
-        )
-      }
-    }
-  }
-  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
-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) } }
+fun ChatList(chatModel: ChatModel) {
   LazyColumn(
-    modifier = Modifier.fillMaxWidth(),
-    listState
+    modifier = Modifier.fillMaxWidth()
   ) {
-    items(chats) { chat ->
+    items(chatModel.chats) { chat ->
       ChatListNavLinkView(chat, chatModel)
     }
   }

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

@@ -2,139 +2,60 @@ 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.*
-import androidx.compose.material.icons.outlined.*
+import androidx.compose.material.icons.outlined.ErrorOutline
 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.*
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import chat.simplex.app.R
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.item.MarkdownText
-import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.helpers.ChatInfoImage
+import chat.simplex.app.views.helpers.badgeLayout
 
 @Composable
-fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileDisplayName: String?, stopped: Boolean, linkMode: SimplexLinkMode) {
-  val cInfo = chat.chatInfo
-
-  @Composable
-  fun groupInactiveIcon() {
-    Icon(
-      Icons.Filled.Cancel,
-      stringResource(R.string.icon_descr_group_inactive),
-      Modifier.size(18.dp).background(MaterialTheme.colors.background, CircleShape),
-      tint = HighOrLowlight
-    )
-  }
-
-  @Composable
-  fun chatPreviewImageOverlayIcon() {
-    if (cInfo is ChatInfo.Group) {
-      when (cInfo.groupInfo.membership.memberStatus) {
-        GroupMemberStatus.MemLeft -> groupInactiveIcon()
-        GroupMemberStatus.MemRemoved -> groupInactiveIcon()
-        GroupMemberStatus.MemGroupDeleted -> groupInactiveIcon()
-        else -> {}
-      }
-    }
-  }
-
-  @Composable
-  fun chatPreviewTitleText(color: Color = Color.Unspecified) {
-    Text(
-      cInfo.chatViewName,
-      maxLines = 1,
-      overflow = TextOverflow.Ellipsis,
-      style = MaterialTheme.typography.h3,
-      fontWeight = FontWeight.Bold,
-      color = color
-    )
-  }
-
-  @Composable
-  fun VerifiedIcon() {
-    Icon(Icons.Outlined.VerifiedUser, null, Modifier.size(19.dp).padding(end = 3.dp, top = 1.dp), tint = HighOrLowlight)
-  }
-
-  @Composable
-  fun chatPreviewTitle() {
-    when (cInfo) {
-      is ChatInfo.Direct ->
-        Row(verticalAlignment = Alignment.CenterVertically) {
-          if (cInfo.contact.verified) {
-            VerifiedIcon()
-          }
-          chatPreviewTitleText(if (cInfo.ready) Color.Unspecified else HighOrLowlight)
-        }
-      is ChatInfo.Group ->
-        when (cInfo.groupInfo.membership.memberStatus) {
-          GroupMemberStatus.MemInvited -> chatPreviewTitleText(if (chat.chatInfo.incognito) Indigo else MaterialTheme.colors.primary)
-          GroupMemberStatus.MemAccepted -> chatPreviewTitleText(HighOrLowlight)
-          else -> chatPreviewTitleText()
-        }
-      else -> chatPreviewTitleText()
-    }
-  }
-
-  @Composable
-  fun chatPreviewText(chatModelIncognito: Boolean) {
-    val ci = chat.chatItems.lastOrNull()
-    if (ci != null) {
-      MarkdownText(
-        if (!ci.meta.itemDeleted) ci.text else generalGetString(R.string.marked_deleted_description),
-        if (!ci.meta.itemDeleted) ci.formattedText else null,
-        sender = if (cInfo is ChatInfo.Group && !ci.chatDir.sent) ci.memberDisplayName else null,
-        linkMode = linkMode,
-        senderBold = true,
-        maxLines = 2,
-        overflow = TextOverflow.Ellipsis,
-        style = MaterialTheme.typography.body1.copy(color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
-        modifier = Modifier.fillMaxWidth(),
-      )
-    } else {
-      when (cInfo) {
-        is ChatInfo.Direct ->
-          if (!cInfo.ready) {
-            Text(stringResource(R.string.contact_connection_pending), color = HighOrLowlight)
-          }
-        is ChatInfo.Group ->
-          when (cInfo.groupInfo.membership.memberStatus) {
-            GroupMemberStatus.MemInvited -> Text(groupInvitationPreviewText(chatModelIncognito, currentUserProfileDisplayName, cInfo.groupInfo))
-            GroupMemberStatus.MemAccepted -> Text(stringResource(R.string.group_connection_pending), color = HighOrLowlight)
-            else -> {}
-          }
-        else -> {}
-      }
-    }
-  }
-
+fun ChatPreviewView(chat: Chat) {
   Row {
-    Box(contentAlignment = Alignment.BottomEnd) {
-      ChatInfoImage(cInfo, size = 72.dp)
-      Box(Modifier.padding(end = 6.dp, bottom = 6.dp)) {
-        chatPreviewImageOverlayIcon()
-      }
-    }
+    val cInfo = chat.chatInfo
+    ChatInfoImage(cInfo, size = 72.dp)
     Column(
       modifier = Modifier
         .padding(horizontal = 8.dp)
         .weight(1F)
     ) {
-      chatPreviewTitle()
-      val height = with(LocalDensity.current) { 46.sp.toDp() }
-      Row(Modifier.heightIn(min = height)) {
-        chatPreviewText(chatModelIncognito)
+      Text(
+        cInfo.chatViewName,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        style = MaterialTheme.typography.h3,
+        fontWeight = FontWeight.Bold,
+        color = if (cInfo.ready) Color.Unspecified else HighOrLowlight
+      )
+      if (cInfo.ready) {
+        val ci = chat.chatItems.lastOrNull()
+        if (ci != null) {
+          MarkdownText(
+            ci.text, ci.formattedText, ci.memberDisplayName,
+            metaText = ci.timestampText,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis,
+            style = MaterialTheme.typography.body1.copy(color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+          )
+        }
+      } else {
+        Text(stringResource(R.string.contact_connection_pending), color = HighOrLowlight)
       }
     }
     val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.updatedAt)
@@ -149,38 +70,22 @@ fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileD
         modifier = Modifier.padding(bottom = 5.dp)
       )
       val n = chat.chatStats.unreadCount
-      val showNtfsIcon = !chat.chatInfo.ntfsEnabled && (chat.chatInfo is ChatInfo.Direct || chat.chatInfo is ChatInfo.Group)
-      if (n > 0 || chat.chatStats.unreadChat) {
+      if (n > 0) {
         Box(
           Modifier.padding(top = 24.dp),
           contentAlignment = Alignment.Center
         ) {
           Text(
-            if (n > 0) unreadCountStr(n) else "",
+            if (n < 1000) "$n" else "${n / 1000}" + stringResource(R.string.thousand_abbreviation),
             color = MaterialTheme.colors.onPrimary,
             fontSize = 11.sp,
             modifier = Modifier
-              .background(if (stopped || showNtfsIcon) HighOrLowlight else MaterialTheme.colors.primary, shape = CircleShape)
+              .background(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(
@@ -194,21 +99,6 @@ fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileD
   }
 }
 
-@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
@@ -241,6 +131,6 @@ fun ChatStatusImage(chat: Chat) {
 @Composable
 fun PreviewChatPreviewView() {
   SimpleXTheme {
-    ChatPreviewView(Chat.sampleData, false, "", stopped = false, linkMode = SimplexLinkMode.DESCRIPTION)
+    ChatPreviewView(Chat.sampleData)
   }
 }

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

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

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

@@ -1,66 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,142 +0,0 @@
-package chat.simplex.app.views.database
-
-import SectionDivider
-import SectionTextFooter
-import SectionView
-import android.content.Context
-import android.content.res.Configuration
-import android.net.Uri
-import android.util.Log
-import android.widget.Toast
-import androidx.activity.compose.ManagedActivityResultLauncher
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-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 chat.simplex.app.R
-import chat.simplex.app.TAG
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.usersettings.*
-import kotlinx.datetime.*
-import java.io.BufferedOutputStream
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.*
-
-@Composable
-fun ChatArchiveView(m: ChatModel, title: String, archiveName: String, archiveTime: Instant) {
-  val context = LocalContext.current
-  val archivePath = "${getFilesDirectory(context)}/$archiveName"
-  val saveArchiveLauncher = rememberSaveArchiveLauncher(cxt = context, archivePath)
-  ChatArchiveLayout(
-    title,
-    archiveTime,
-    saveArchive = { saveArchiveLauncher.launch(archivePath.substringAfterLast("/")) },
-    deleteArchiveAlert = { deleteArchiveAlert(m, archivePath) }
-  )
-}
-
-@Composable
-fun ChatArchiveLayout(
-  title: String,
-  archiveTime: Instant,
-  saveArchive: () -> Unit,
-  deleteArchiveAlert: () -> Unit
-) {
-  Column(
-    Modifier.fillMaxWidth(),
-    horizontalAlignment = Alignment.Start,
-  ) {
-    AppBarTitle(title)
-    SectionView(stringResource(R.string.chat_archive_section)) {
-      SettingsActionItem(
-        Icons.Outlined.IosShare,
-        stringResource(R.string.save_archive),
-        saveArchive,
-        textColor = MaterialTheme.colors.primary,
-        iconColor = MaterialTheme.colors.primary,
-      )
-      SectionDivider()
-      SettingsActionItem(
-        Icons.Outlined.Delete,
-        stringResource(R.string.delete_archive),
-        deleteArchiveAlert,
-        textColor = Color.Red,
-        iconColor = Color.Red,
-      )
-    }
-    val archiveTs = SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z", Locale.US).format(Date.from(archiveTime.toJavaInstant()))
-    SectionTextFooter(
-      String.format(generalGetString(R.string.archive_created_on_ts), archiveTs)
-    )
-  }
-}
-
-@Composable
-private fun rememberSaveArchiveLauncher(cxt: Context, chatArchivePath: String): ManagedActivityResultLauncher<String, Uri?> =
-  rememberLauncherForActivityResult(
-    contract = ActivityResultContracts.CreateDocument(),
-    onResult = { destination ->
-      try {
-        destination?.let {
-          val contentResolver = cxt.contentResolver
-          contentResolver.openOutputStream(destination)?.let { stream ->
-            val outputStream = BufferedOutputStream(stream)
-            File(chatArchivePath).inputStream().use { it.copyTo(outputStream) }
-            outputStream.close()
-            Toast.makeText(cxt, generalGetString(R.string.file_saved), Toast.LENGTH_SHORT).show()
-          }
-        }
-      } catch (e: Error) {
-        Toast.makeText(cxt, generalGetString(R.string.error_saving_file), Toast.LENGTH_SHORT).show()
-        Log.e(TAG, "rememberSaveArchiveLauncher error saving archive $e")
-      }
-    }
-  )
-
-private fun deleteArchiveAlert(m: ChatModel, archivePath: String) {
-  AlertManager.shared.showAlertDialog(
-    title = generalGetString(R.string.delete_chat_archive_question),
-    confirmText = generalGetString(R.string.delete_verb),
-    onConfirm = {
-      val fileDeleted = File(archivePath).delete()
-      if (fileDeleted) {
-        m.controller.appPrefs.chatArchiveName.set(null)
-        m.controller.appPrefs.chatArchiveTime.set(null)
-        ModalManager.shared.closeModal()
-      } else {
-        Log.e(TAG, "deleteArchiveAlert delete() error")
-      }
-    }
-  )
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatArchiveLayout() {
-  SimpleXTheme {
-    ChatArchiveLayout(
-      "New database archive",
-      archiveTime = Clock.System.now(),
-      saveArchive = {},
-      deleteArchiveAlert = {}
-    )
-  }
-}

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

@@ -1,507 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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

@@ -1,708 +0,0 @@
-package chat.simplex.app.views.database
-
-import SectionDivider
-import SectionTextFooter
-import SectionItemView
-import SectionSpacer
-import SectionView
-import android.content.Context
-import android.content.res.Configuration
-import android.net.Uri
-import android.os.FileUtils
-import android.util.Log
-import android.widget.Toast
-import androidx.activity.compose.ManagedActivityResultLauncher
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-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.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.*
-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(
-  m: ChatModel,
-  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit)
-) {
-  val context = LocalContext.current
-  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, 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(),
-  ) {
-    DatabaseLayout(
-      progressIndicator.value,
-      runChat.value,
-      m.chatDbChanged.value,
-      useKeychain.value,
-      m.chatDbEncrypted.value,
-      m.controller.appPrefs.initialRandomDBPassphrase,
-      importArchiveLauncher,
-      chatArchiveName,
-      chatArchiveTime,
-      chatLastStart,
-      chatDbDeleted.value,
-      m.controller.appPrefs.privacyFullBackup,
-      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) {
-      Box(
-        Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center
-      ) {
-        CircularProgressIndicator(
-          Modifier
-            .padding(horizontal = 2.dp)
-            .size(30.dp),
-          color = HighOrLowlight,
-          strokeWidth = 2.5.dp
-        )
-      }
-    }
-  }
-}
-
-@Composable
-fun DatabaseLayout(
-  progressIndicator: Boolean,
-  runChat: Boolean,
-  chatDbChanged: Boolean,
-  useKeyChain: Boolean,
-  chatDbEncrypted: Boolean?,
-  initialRandomDBPassphrase: SharedPreference<Boolean>,
-  importArchiveLauncher: ManagedActivityResultLauncher<String, Uri?>,
-  chatArchiveName: MutableState<String?>,
-  chatArchiveTime: MutableState<Instant?>,
-  chatLastStart: MutableState<Instant?>,
-  chatDbDeleted: Boolean,
-  privacyFullBackup: SharedPreference<Boolean>,
-  appFilesCountAndSize: MutableState<Pair<Int, Long>>,
-  chatItemTTL: MutableState<ChatItemTTL>,
-  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
-
-  Column(
-    Modifier.fillMaxWidth().verticalScroll(rememberScrollState()),
-    horizontalAlignment = Alignment.Start,
-  ) {
-    AppBarTitle(stringResource(R.string.your_chat_database))
-    SectionView(stringResource(R.string.run_chat_section)) {
-      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()
-      SettingsPreferenceItem(Icons.Outlined.Backup, stringResource(R.string.full_backup), privacyFullBackup)
-      SectionDivider()
-      SettingsActionItem(
-        Icons.Outlined.IosShare,
-        stringResource(R.string.export_database),
-        click = {
-          if (initialRandomDBPassphrase.get()) {
-            exportProhibitedAlert()
-          } else {
-            exportArchive()
-          }
-        },
-        textColor = MaterialTheme.colors.primary,
-        iconColor = MaterialTheme.colors.primary,
-        disabled = operationsDisabled
-      )
-      SectionDivider()
-      SettingsActionItem(
-        Icons.Outlined.FileDownload,
-        stringResource(R.string.import_database),
-        { importArchiveLauncher.launch("application/zip") },
-        textColor = Color.Red,
-        iconColor = Color.Red,
-        disabled = operationsDisabled
-      )
-      SectionDivider()
-      val chatArchiveNameVal = chatArchiveName.value
-      val chatArchiveTimeVal = chatArchiveTime.value
-      val chatLastStartVal = chatLastStart.value
-      if (chatArchiveNameVal != null && chatArchiveTimeVal != null && chatLastStartVal != null) {
-        val title = chatArchiveTitle(chatArchiveTimeVal, chatLastStartVal)
-        SettingsActionItem(
-          Icons.Outlined.Inventory2,
-          title,
-          click = showSettingsModal { ChatArchiveView(it, title, chatArchiveNameVal, chatArchiveTimeVal) },
-          disabled = operationsDisabled
-        )
-        SectionDivider()
-      }
-      SettingsActionItem(
-        Icons.Outlined.DeleteForever,
-        stringResource(R.string.delete_database),
-        deleteChatAlert,
-        textColor = Color.Red,
-        iconColor = Color.Red,
-        disabled = operationsDisabled
-      )
-    }
-    SectionTextFooter(
-      if (stopped) {
-        stringResource(R.string.you_must_use_the_most_recent_version_of_database)
-      } else {
-        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,
-  chatDbDeleted: Boolean,
-  startChat: () -> Unit,
-  stopChatAlert: () -> Unit
-) {
-  SectionItemView() {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      val chatRunningText = if (stopped) stringResource(R.string.chat_is_stopped) else stringResource(R.string.chat_is_running)
-      Icon(
-        if (stopped) Icons.Filled.Report else Icons.Filled.PlayArrow,
-        chatRunningText,
-        tint = if (stopped) Color.Red else MaterialTheme.colors.primary
-      )
-      Spacer(Modifier.padding(horizontal = 4.dp))
-      Text(
-        chatRunningText,
-        Modifier.padding(end = 24.dp)
-      )
-      Spacer(Modifier.fillMaxWidth().weight(1f))
-      Switch(
-        enabled = !chatDbDeleted,
-        checked = runChat,
-        onCheckedChange = { runChatSwitch ->
-          if (runChatSwitch) {
-            startChat()
-          } else {
-            stopChatAlert()
-          }
-        },
-        colors = SwitchDefaults.colors(
-          checkedThumbColor = MaterialTheme.colors.primary,
-          uncheckedThumbColor = HighOrLowlight
-        ),
-      )
-    }
-  }
-}
-
-@Composable
-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?>, 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
-      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())
-    }
-  }
-}
-
-private fun stopChatAlert(m: ChatModel, runChat: MutableState<Boolean>, context: Context) {
-  AlertManager.shared.showAlertDialog(
-    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 = { 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.safeStopService(context)
-      MessagesFetcherWorker.cancelAll()
-    } catch (e: Error) {
-      runChat.value = true
-      AlertManager.shared.showAlertMsg(generalGetString(R.string.error_starting_chat), e.toString())
-    }
-  }
-}
-
-private fun exportArchive(
-  context: Context,
-  m: ChatModel,
-  progressIndicator: MutableState<Boolean>,
-  chatArchiveName: MutableState<String?>,
-  chatArchiveTime: MutableState<Instant?>,
-  chatArchiveFile: MutableState<String?>,
-  saveArchiveLauncher: ManagedActivityResultLauncher<String, Uri?>
-) {
-  progressIndicator.value = true
-  withApi {
-    try {
-      val archiveFile = exportChatArchive(m, context, chatArchiveName, chatArchiveTime, chatArchiveFile)
-      chatArchiveFile.value = archiveFile
-      saveArchiveLauncher.launch(archiveFile.substringAfterLast("/"))
-      progressIndicator.value = false
-    } catch (e: Error) {
-      AlertManager.shared.showAlertMsg(generalGetString(R.string.error_exporting_chat_database), e.toString())
-      progressIndicator.value = false
-    }
-  }
-}
-
-private suspend fun exportChatArchive(
-  m: ChatModel,
-  context: Context,
-  chatArchiveName: MutableState<String?>,
-  chatArchiveTime: MutableState<Instant?>,
-  chatArchiveFile: MutableState<String?>
-): String {
-  val archiveTime = Clock.System.now()
-  val ts = SimpleDateFormat("yyyy-MM-dd'T'HHmmss", Locale.US).format(Date.from(archiveTime.toJavaInstant()))
-  val archiveName = "simplex-chat.$ts.zip"
-  val archivePath = "${getFilesDirectory(context)}/$archiveName"
-  val config = ArchiveConfig(archivePath, parentTempDirectory = context.cacheDir.toString())
-  m.controller.apiExportArchive(config)
-  deleteOldArchive(m, context)
-  m.controller.appPrefs.chatArchiveName.set(archiveName)
-  chatArchiveName.value = archiveName
-  m.controller.appPrefs.chatArchiveTime.set(archiveTime)
-  chatArchiveTime.value = archiveTime
-  chatArchiveFile.value = archivePath
-  return archivePath
-}
-
-private fun deleteOldArchive(m: ChatModel, context: Context) {
-  val chatArchiveName = m.controller.appPrefs.chatArchiveName.get()
-  if (chatArchiveName != null) {
-    val file = File("${getFilesDirectory(context)}/$chatArchiveName")
-    val fileDeleted = file.delete()
-    if (fileDeleted) {
-      m.controller.appPrefs.chatArchiveName.set(null)
-      m.controller.appPrefs.chatArchiveTime.set(null)
-    } else {
-      Log.e(TAG, "deleteOldArchive file.delete() error")
-    }
-  }
-}
-
-@Composable
-private fun rememberSaveArchiveLauncher(cxt: Context, chatArchiveFile: MutableState<String?>): ManagedActivityResultLauncher<String, Uri?> =
-  rememberLauncherForActivityResult(
-    contract = ActivityResultContracts.CreateDocument(),
-    onResult = { destination ->
-      try {
-        destination?.let {
-          val filePath = chatArchiveFile.value
-          if (filePath != null) {
-            val contentResolver = cxt.contentResolver
-            contentResolver.openOutputStream(destination)?.let { stream ->
-              val outputStream = BufferedOutputStream(stream)
-              File(filePath).inputStream().use { it.copyTo(outputStream) }
-              outputStream.close()
-              Toast.makeText(cxt, generalGetString(R.string.file_saved), Toast.LENGTH_SHORT).show()
-            }
-          } else {
-            Toast.makeText(cxt, generalGetString(R.string.file_not_found), Toast.LENGTH_SHORT).show()
-          }
-        }
-      } catch (e: Error) {
-        Toast.makeText(cxt, generalGetString(R.string.error_saving_file), Toast.LENGTH_SHORT).show()
-        Log.e(TAG, "rememberSaveArchiveLauncher error saving archive $e")
-      } finally {
-        chatArchiveFile.value = null
-      }
-    }
-  )
-
-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, appFilesCountAndSize, progressIndicator) }
-  )
-}
-
-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) {
-    withApi {
-      try {
-        m.controller.apiDeleteStorage()
-        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))
-          }
-        } catch (e: Error) {
-          operationEnded(m, progressIndicator) {
-            AlertManager.shared.showAlertMsg(generalGetString(R.string.error_importing_database), e.toString())
-          }
-        }
-      } catch (e: Error) {
-        operationEnded(m, progressIndicator) {
-          AlertManager.shared.showAlertMsg(generalGetString(R.string.error_deleting_database), e.toString())
-        }
-      } finally {
-        File(archivePath).delete()
-      }
-    }
-  }
-}
-
-private fun saveArchiveFromUri(context: Context, importedArchiveUri: Uri): String? {
-  return try {
-    val inputStream = context.contentResolver.openInputStream(importedArchiveUri)
-    val archiveName = getFileName(context, importedArchiveUri)
-    if (inputStream != null && archiveName != null) {
-      val archivePath = "${context.cacheDir}/$archiveName"
-      val destFile = File(archivePath)
-      FileUtils.copy(inputStream, FileOutputStream(destFile))
-      archivePath
-    } else {
-      Log.e(TAG, "saveArchiveFromUri null inputStream")
-      null
-    }
-  } catch (e: Exception) {
-    Log.e(TAG, "saveArchiveFromUri error: ${e.message}")
-    null
-  }
-}
-
-private fun deleteChatAlert(m: ChatModel, progressIndicator: MutableState<Boolean>) {
-  AlertManager.shared.showAlertDialog(
-    title = generalGetString(R.string.delete_chat_profile_question),
-    text = generalGetString(R.string.delete_chat_profile_action_cannot_be_undone_warning),
-    confirmText = generalGetString(R.string.delete_verb),
-    onConfirm = { deleteChat(m, progressIndicator) }
-  )
-}
-
-private fun deleteChat(m: ChatModel, progressIndicator: MutableState<Boolean>) {
-  progressIndicator.value = true
-  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))
-      }
-    } catch (e: Error) {
-      operationEnded(m, progressIndicator) {
-        AlertManager.shared.showAlertMsg(generalGetString(R.string.error_deleting_database), e.toString())
-      }
-    }
-  }
-}
-
-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
-  alert.invoke()
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewDatabaseLayout() {
-  SimpleXTheme {
-    DatabaseLayout(
-      progressIndicator = false,
-      runChat = true,
-      chatDbChanged = false,
-      useKeyChain = false,
-      chatDbEncrypted = false,
-      initialRandomDBPassphrase = SharedPreference({ true }, {}),
-      importArchiveLauncher = rememberGetContentLauncher {},
-      chatArchiveName = remember { mutableStateOf("dummy_archive") },
-      chatArchiveTime = remember { mutableStateOf(Clock.System.now()) },
-      chatLastStart = remember { mutableStateOf(Clock.System.now()) },
-      chatDbDeleted = false,
-      privacyFullBackup = SharedPreference({ true }, {}),
-      appFilesCountAndSize = remember { mutableStateOf(0 to 0L) },
-      chatItemTTL = remember { mutableStateOf(ChatItemTTL.None) },
-      startChat = {},
-      stopChatAlert = {},
-      exportArchive = {},
-      deleteChatAlert = {},
-      deleteAppFilesAndMedia = {},
-      showSettingsModal = { {} },
-      onChatItemTTLSelected = {},
-    )
-  }
-}

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

@@ -1,29 +1,25 @@
 package chat.simplex.app.views.helpers
 
 import android.util.Log
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.*
-import androidx.compose.ui.window.Dialog
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
 import chat.simplex.app.R
 import chat.simplex.app.TAG
-import chat.simplex.app.ui.theme.DEFAULT_PADDING
 
 class AlertManager {
-  var alertViews = mutableStateListOf<(@Composable () -> Unit)>()
+  var alertView = mutableStateOf<(@Composable () -> Unit)?>(null)
+  var presentAlert = mutableStateOf<Boolean>(false)
 
   fun showAlert(alert: @Composable () -> Unit) {
     Log.d(TAG, "AlertManager.showAlert")
-    alertViews.add(alert)
+    alertView.value = alert
+    presentAlert.value = true
   }
 
   fun hideAlert() {
-    alertViews.removeLastOrNull()
+    presentAlert.value = false
+    alertView.value = null
   }
 
   fun showAlertDialogButtons(
@@ -42,50 +38,28 @@ 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,
-    onDismissRequest: (() -> Unit)? = null,
-    destructive: Boolean = false
+    onDismiss: (() -> Unit)? = null
   ) {
     val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
     showAlert {
       AlertDialog(
-        onDismissRequest = { onDismissRequest?.invoke(); hideAlert() },
+        onDismissRequest = this::hideAlert,
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          TextButton(onClick = {
+          Button(onClick = {
             onConfirm?.invoke()
             hideAlert()
-          }) { Text(confirmText, color = if (destructive) MaterialTheme.colors.error else Color.Unspecified) }
+          }) { Text(confirmText) }
         },
         dismissButton = {
-          TextButton(onClick = {
+          Button(onClick = {
             onDismiss?.invoke()
             hideAlert()
           }) { Text(dismissText) }
@@ -94,41 +68,6 @@ class AlertManager {
     }
   }
 
-  fun showAlertDialogStacked(
-    title: String,
-    text: String? = null,
-    confirmText: String = generalGetString(R.string.ok),
-    onConfirm: (() -> Unit)? = null,
-    dismissText: String = generalGetString(R.string.cancel_verb),
-    onDismiss: (() -> Unit)? = null,
-    onDismissRequest: (() -> Unit)? = null,
-    destructive: Boolean = false
-  ) {
-    val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
-    showAlert {
-      AlertDialog(
-        onDismissRequest = { onDismissRequest?.invoke(); hideAlert() },
-        title = { Text(title) },
-        text = alertText,
-        buttons = {
-          Column(
-            Modifier.fillMaxWidth().padding(horizontal = 8.dp).padding(top = 16.dp, bottom = 2.dp),
-            horizontalAlignment = Alignment.End
-          ) {
-            TextButton(onClick = {
-              onDismiss?.invoke()
-              hideAlert()
-            }) { Text(dismissText) }
-            TextButton(onClick = {
-              onConfirm?.invoke()
-              hideAlert()
-            }) { Text(confirmText, color = if (destructive) MaterialTheme.colors.error else Color.Unspecified) }
-          }
-        },
-      )
-    }
-  }
-
   fun showAlertMsg(
     title: String, text: String? = null,
     confirmText: String = generalGetString(R.string.ok), onConfirm: (() -> Unit)? = null
@@ -140,7 +79,7 @@ class AlertManager {
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          TextButton(onClick = {
+          Button(onClick = {
             onConfirm?.invoke()
             hideAlert()
           }) { Text(confirmText) }
@@ -149,19 +88,12 @@ 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() {
-    remember { alertViews }.lastOrNull()?.invoke()
+    if (presentAlert.value) alertView.value?.invoke()
   }
 
   companion object {
     val shared = AlertManager()
   }
-}
+}

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

@@ -1,9 +0,0 @@
-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,7 +6,8 @@ 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.*
+import androidx.compose.material.icons.filled.AccountCircle
+import androidx.compose.material.icons.filled.SupervisedUserCircle
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
@@ -23,22 +24,11 @@ import chat.simplex.app.model.ChatInfo
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
-fun ChatInfoImage(chatInfo: ChatInfo, size: Dp, iconColor: Color = MaterialTheme.colors.secondary) {
+fun ChatInfoImage(chatInfo: ChatInfo, size: Dp) {
   val icon =
     if (chatInfo is ChatInfo.Group) Icons.Filled.SupervisedUserCircle
                                     else Icons.Filled.AccountCircle
-  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
-    )
-  }
+  ProfileImage(size, chatInfo.image, icon)
 }
 
 @Composable

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

@@ -3,46 +3,37 @@ 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.text.style.TextOverflow
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import chat.simplex.app.ui.theme.*
+import chat.simplex.app.R
+import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
 fun CloseSheetBar(close: () -> Unit) {
-  Column(
+  Row (
     Modifier
       .fillMaxWidth()
-      .heightIn(min = AppBarHeight)
-      .padding(horizontal = AppBarHorizontalPadding),
+      .height(60.dp),
+    horizontalArrangement = Arrangement.End,
+    verticalAlignment = Alignment.CenterVertically
   ) {
-    Row(
-      Modifier
-        .width(TitleInsetWithIcon - AppBarHorizontalPadding)
-        .padding(top = 4.dp), // Like in DefaultAppBar
-      content = { NavigationButtonBack(close) }
-    )
+    IconButton(onClick = close) {
+      Icon(
+        Icons.Outlined.Close,
+        stringResource(R.string.icon_descr_close_button),
+        tint = MaterialTheme.colors.primary,
+        modifier = Modifier.padding(10.dp)
+      )
+    }
   }
 }
 
-@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

@@ -1,12 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,295 +0,0 @@
-/*
- * Copyright 2020 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package chat.simplex.app.views.helpers
-
-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.*
-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 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 {
-  suspend fun tryAwaitRelease(): Boolean
-}
-
-private val NoPressGesture: suspend PressGestureScope.(Offset) -> Unit = { }
-
-suspend fun PointerInputScope.detectGesture(
-  onLongPress: ((Offset) -> Unit)? = null,
-  onPress: suspend PressGestureScope.(Offset) -> Unit = NoPressGesture,
-  shouldConsumeEvent: (Offset) -> Boolean
-) = coroutineScope {
-  val pressScope = PressGestureScopeImpl(this@detectGesture)
-
-  forEachGesture {
-    awaitPointerEventScope {
-      val down = awaitFirstDown()
-      // If shouldConsumeEvent == false, all touches will be propagated to parent
-      val shouldConsume = shouldConsumeEvent(down.position)
-      if (shouldConsume)
-        down.consumeDownChange()
-      pressScope.reset()
-      if (onPress !== NoPressGesture) launch {
-        pressScope.onPress(down.position)
-      }
-      val longPressTimeout = onLongPress?.let {
-        viewConfiguration.longPressTimeoutMillis
-      } ?: (Long.MAX_VALUE / 2)
-
-      try {
-        val upOrCancel: PointerInputChange? = withTimeout(longPressTimeout) {
-          waitForUpOrCancellation()
-        }
-        if (upOrCancel == null) {
-          pressScope.cancel()
-        } else {
-          if (shouldConsume)
-            upOrCancel.consumeDownChange()
-          pressScope.release()
-        }
-      } catch (_: PointerEventTimeoutCancellationException) {
-        onLongPress?.invoke(down.position)
-        if (shouldConsume)
-          consumeUntilUp()
-        pressScope.release()
-      }
-    }
-  }
-}
-
-private suspend fun AwaitPointerEventScope.consumeUntilUp() {
-  do {
-    val event = awaitPointerEvent()
-    event.changes.fastForEach { it.consumeAllChanges() }
-  } while (event.changes.fastAny { it.pressed })
-}
-
-suspend fun AwaitPointerEventScope.awaitFirstDown(
-  requireUnconsumed: Boolean = true
-): PointerInputChange =
-  awaitFirstDownOnPass(pass = PointerEventPass.Main, requireUnconsumed = requireUnconsumed)
-
-internal suspend fun AwaitPointerEventScope.awaitFirstDownOnPass(
-  pass: PointerEventPass,
-  requireUnconsumed: Boolean
-): PointerInputChange {
-  var event: PointerEvent
-  do {
-    event = awaitPointerEvent(pass)
-  } while (
-    !event.changes.fastAll {
-      if (requireUnconsumed) it.changedToDown() else it.changedToDownIgnoreConsumed()
-    }
-  )
-  return event.changes[0]
-}
-
-suspend fun AwaitPointerEventScope.waitForUpOrCancellation(): PointerInputChange? {
-  while (true) {
-    val event = awaitPointerEvent(PointerEventPass.Main)
-    if (event.changes.fastAll { it.changedToUp() }) {
-      return event.changes[0]
-    }
-
-    if (event.changes.fastAny {
-        it.consumed.downChange || it.isOutOfBounds(size, extendedTouchPadding)
-      }
-    ) {
-      return null
-    }
-    val consumeCheck = awaitPointerEvent(PointerEventPass.Final)
-    if (consumeCheck.changes.fastAny { it.positionChangeConsumed() }) {
-      return null
-    }
-  }
-}
-
-private class PressGestureScopeImpl(
-  density: Density
-): PressGestureScope, Density by density {
-  private var isReleased = false
-  private var isCanceled = false
-  private val mutex = Mutex(locked = false)
-
-  fun cancel() {
-    isCanceled = true
-    mutex.unlock()
-  }
-
-  fun release() {
-    isReleased = true
-    mutex.unlock()
-  }
-
-  fun reset() {
-    mutex.tryLock()
-    isReleased = false
-    isCanceled = false
-  }
-
-  override suspend fun tryAwaitRelease(): Boolean {
-    if (!isReleased && !isCanceled) {
-      mutex.lock()
-    }
-    return isReleased && !isCanceled
-  }
-}
-
-/**
- * Captures click events and calls [onLongClick] or [onClick] when such even happens. Otherwise, does nothing.
- * Apply [MutableInteractionSource] to any element that allows to pass it in (for example, in [Modifier.clickable]).
- * Works in situations when using [Modifier.combinedClickable] doesn't work because external element overrides [Modifier.clickable]
- * */
-@Composable
-fun interactionSourceWithDetection(onClick: () -> Unit, onLongClick: () -> Unit): MutableInteractionSource {
-  val interactionSource = remember { MutableInteractionSource() }
-  val longPressTimeoutMillis = LocalViewConfiguration.current.longPressTimeoutMillis
-  var topLevelInteraction: Interaction? by remember { mutableStateOf(null) }
-  LaunchedEffect(interactionSource) {
-    interactionSource.interactions.collect { interaction ->
-      topLevelInteraction = interaction
-    }
-  }
-  LaunchedEffect(topLevelInteraction is PressInteraction.Press) {
-    if (topLevelInteraction !is PressInteraction.Press) return@LaunchedEffect
-    try {
-      withTimeout(longPressTimeoutMillis) {
-        while (isActive) {
-          delay(10)
-          when (topLevelInteraction) {
-            is PressInteraction.Press -> {}
-            is PressInteraction.Release -> {
-              onClick(); break
-            }
-            is PressInteraction.Cancel -> break
-          }
-        }
-      }
-    } catch (_: TimeoutCancellationException) {
-      // Long click happened
-      onLongClick()
-    } catch (ex: CancellationException) {
-      // Canceled coroutine + PressInteraction.Release == short click
-      if (topLevelInteraction is PressInteraction.Release)
-        onClick()
-      Log.e(TAG, ex.stackTraceToString())
-    } catch (ex: Exception) {
-      // Should never be called
-      Log.e(TAG, ex.stackTraceToString())
-    }
-  }
-  return interactionSource
-}
-
-@Composable
-fun interactionSourceWithTapDetection(onPress: () -> Unit, onClick: () -> Unit, onCancel: () -> Unit, onRelease: ()-> Unit): MutableInteractionSource {
-  val interactionSource = remember { MutableInteractionSource() }
-  LaunchedEffect(interactionSource) {
-    var firstTapTime = 0L
-    interactionSource.interactions.collect { interaction ->
-      when (interaction) {
-        is PressInteraction.Press -> {
-          firstTapTime = System.currentTimeMillis(); onPress()
-        }
-        is PressInteraction.Release -> if (firstTapTime + 1000L < System.currentTimeMillis()) onRelease() else onClick()
-        is PressInteraction.Cancel -> onCancel()
-      }
-    }
-  }
-  return interactionSource
-}
-
-suspend fun PointerInputScope.detectTransformGestures(
-  allowIntercept: () -> Boolean,
-  panZoomLock: Boolean = false,
-  onGesture: (centroid: Offset, pan: Offset, zoom: Float, rotation: Float) -> Unit
-) {
-  var zoom = 1f
-  forEachGesture {
-    awaitPointerEventScope {
-      var rotation = 0f
-      var pan = Offset.Zero
-      var pastTouchSlop = false
-      val touchSlop = viewConfiguration.touchSlop
-      var lockedToPanZoom = false
-
-      awaitFirstDown(requireUnconsumed = false)
-      do {
-        val event = awaitPointerEvent()
-        val canceled = event.changes.fastAny { it.isConsumed }
-        if (!canceled) {
-          val zoomChange = event.calculateZoom()
-          val rotationChange = event.calculateRotation()
-          val panChange = event.calculatePan()
-
-          if (!pastTouchSlop) {
-            zoom *= zoomChange
-            rotation += rotationChange
-            pan += panChange
-
-            val centroidSize = event.calculateCentroidSize(useCurrent = false)
-            val zoomMotion = abs(1 - zoom) * centroidSize
-            val rotationMotion = abs(rotation * PI.toFloat() * centroidSize / 180f)
-            val panMotion = pan.getDistance()
-
-            if (zoomMotion > touchSlop ||
-              rotationMotion > touchSlop ||
-              panMotion > touchSlop
-            ) {
-              pastTouchSlop = true
-              lockedToPanZoom = panZoomLock && rotationMotion < touchSlop
-            }
-          }
-
-          if (pastTouchSlop) {
-            val centroid = event.calculateCentroid(useCurrent = false)
-            val effectiveRotation = if (lockedToPanZoom) 0f else rotationChange
-            if (effectiveRotation != 0f ||
-              zoomChange != 1f ||
-              panChange != Offset.Zero
-            ) {
-              onGesture(centroid, panChange, zoomChange, effectiveRotation)
-            }
-            event.changes.fastForEach {
-              if (it.positionChanged() && zoom != 1f && allowIntercept()) {
-                it.consume()
-              }
-            }
-          }
-        }
-      } while (!canceled && event.changes.fastAny { it.pressed })
-    }
-  }
-}

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

@@ -2,8 +2,8 @@ package chat.simplex.app.views.helpers
 
 import android.Manifest
 import android.app.Activity
-import android.content.*
-import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.graphics.*
 import android.net.Uri
@@ -20,9 +20,8 @@ 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.*
-import androidx.compose.runtime.saveable.Saver
-import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.platform.LocalContext
@@ -32,10 +31,7 @@ import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
 import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.model.json
-import chat.simplex.app.views.chat.PickFromGallery
 import chat.simplex.app.views.newchat.ActionButton
-import kotlinx.serialization.builtins.*
 import java.io.ByteArrayOutputStream
 import java.io.File
 import kotlin.math.min
@@ -69,53 +65,46 @@ fun resizeImageToStrSize(image: Bitmap, maxDataSize: Long): String {
 }
 
 private fun compressImageStr(bitmap: Bitmap): String {
-  val usePng = bitmap.hasAlpha()
-  val ext = if (usePng) "png" else "jpg"
-  return "data:image/$ext;base64," + Base64.encodeToString(compressImageData(bitmap, usePng).toByteArray(), Base64.NO_WRAP)
+  return "data:image/jpg;base64," + Base64.encodeToString(compressImageData(bitmap).toByteArray(), Base64.NO_WRAP)
 }
 
-fun resizeImageToDataSize(image: Bitmap, usePng: Boolean, maxDataSize: Long): ByteArrayOutputStream {
+fun resizeImageToDataSize(image: Bitmap, maxDataSize: Long): ByteArrayOutputStream {
   var img = image
-  var stream = compressImageData(img, usePng)
+  var stream = compressImageData(img)
   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, usePng)
+    stream = compressImageData(img)
   }
   return stream
 }
 
-private fun compressImageData(bitmap: Bitmap, usePng: Boolean): ByteArrayOutputStream {
+private fun compressImageData(bitmap: Bitmap): ByteArrayOutputStream {
   val stream = ByteArrayOutputStream()
-  bitmap.compress(if (!usePng) Bitmap.CompressFormat.JPEG else Bitmap.CompressFormat.PNG, 85, stream)
+  bitmap.compress(Bitmap.CompressFormat.JPEG, 85, stream)
   return stream
 }
 
-val errorBitmapBytes = Base64.decode("iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAKVJREFUeF7t1kENACEUQ0FQhnVQ9lfGO+xggITQdvbMzArPey+8fa3tAfwAEdABZQspQStgBssEcgAIkSAJkiAJljtEgiRIgmUCSZAESZAESZAEyx0iQRIkwTKBJEiCv5fgvTd1wDmn7QAP4AeIgA4oW0gJWgEzWCZwbQ7gAA7ggLKFOIADOKBMIAeAEAmSIAmSYLlDJEiCJFgmkARJkARJ8N8S/ADTZUewBvnTOQAAAABJRU5ErkJggg==", Base64.NO_WRAP)
-val errorBitmap: Bitmap = BitmapFactory.decodeByteArray(errorBitmapBytes, 0, errorBitmapBytes.size)
-
 fun base64ToBitmap(base64ImageString: String): Bitmap {
   val imageString = base64ImageString
     .removePrefix("data:image/png;base64,")
     .removePrefix("data:image/jpg;base64,")
-  try {
-    val imageBytes = Base64.decode(imageString, Base64.NO_WRAP)
-    return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
-  } catch (e: Exception) {
-    Log.e(TAG, "base64ToBitmap error: $e")
-    return errorBitmap
-  }
+  val imageBytes = Base64.decode(imageString, Base64.NO_WRAP)
+  return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
 }
 
-class CustomTakePicturePreview(var uri: Uri?, var tmpFile: File?): ActivityResultContract<Void?, Uri?>() {
+class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
+  private var uri: Uri? = null
+  private var tmpFile: File? = null
+  lateinit var externalContext: Context
+
   @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)
@@ -124,28 +113,20 @@ class CustomTakePicturePreview(var uri: Uri?, var tmpFile: File?): ActivityResul
   override fun getSynchronousResult(
     context: Context,
     input: Void?
-  ): SynchronousResult<Uri?>? = null
+  ): SynchronousResult<Bitmap?>? = null
 
-  override fun parseResult(resultCode: Int, intent: Intent?): Uri? {
+  override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
     return if (resultCode == Activity.RESULT_OK && uri != null) {
-      uri
+      val source = ImageDecoder.createSource(externalContext.contentResolver, uri!!)
+      val bitmap = ImageDecoder.decodeBitmap(source)
+      tmpFile?.delete()
+      bitmap
     } 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 {
@@ -157,12 +138,8 @@ class CustomTakePicturePreview(var uri: Uri?, var tmpFile: File?): ActivityResul
 //fun rememberGalleryLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
 //  rememberLauncherForActivityResult(contract = GetGalleryContent(), cb)
 @Composable
-fun rememberCameraLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<Void?, Uri?> {
-  val contract = rememberSaveable(stateSaver = CustomTakePicturePreview.saver()) {
-    mutableStateOf(CustomTakePicturePreview(null, null))
-  }
-  return rememberLauncherForActivityResult(contract = contract.value, cb)
-}
+fun rememberCameraLauncher(cb: (Bitmap?) -> Unit): ManagedActivityResultLauncher<Void?, Bitmap?> =
+  rememberLauncherForActivityResult(contract = CustomTakePicturePreview(), cb)
 
 @Composable
 fun rememberPermissionLauncher(cb: (Boolean) -> Unit): ManagedActivityResultLauncher<String, Boolean> =
@@ -172,57 +149,30 @@ fun rememberPermissionLauncher(cb: (Boolean) -> Unit): ManagedActivityResultLaun
 fun rememberGetContentLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
   rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent(), cb)
 
-@Composable
-fun rememberGetMultipleContentsLauncher(cb: (List<Uri>) -> Unit): ManagedActivityResultLauncher<String, List<Uri>> =
-  rememberLauncherForActivityResult(contract = ActivityResultContracts.GetMultipleContents(), cb)
-
-fun ManagedActivityResultLauncher<Void?, Uri?>.launchWithFallback() {
-  try {
-    launch(null)
-  } catch (e: ActivityNotFoundException) {
-    // No Activity found to handle Intent android.media.action.IMAGE_CAPTURE
-    // Means, no system camera app (Android 11+ requirement)
-    // https://developer.android.com/about/versions/11/behavior-changes-11#media-capture
-    Log.e(TAG, "Camera launcher: " + e.stackTraceToString())
-
-    try {
-      // Try to open any camera just to capture an image, will not be returned like with previous intent
-      SimplexApp.context.startActivity(Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA).also { it.addFlags(FLAG_ACTIVITY_NEW_TASK) })
-    } catch (e: ActivityNotFoundException) {
-      // No camera apps available at all
-      Log.e(TAG, "Camera launcher2: " + e.stackTraceToString())
-    }
-  }
-}
-
 @Composable
 fun GetImageBottomSheet(
-  imageBitmap: MutableState<Uri?>,
+  imageBitmap: MutableState<Bitmap?>,
   onImageChange: (Bitmap) -> Unit,
   hideBottomSheet: () -> Unit
 ) {
   val context = LocalContext.current
-  val processPickedImage = { uri: Uri? ->
+  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
     if (uri != null) {
       val source = ImageDecoder.createSource(context.contentResolver, uri)
       val bitmap = ImageDecoder.decodeBitmap(source)
-      imageBitmap.value = uri
+      imageBitmap.value = bitmap
       onImageChange(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)
+  val cameraLauncher = rememberCameraLauncher { bitmap: Bitmap? ->
+    if (bitmap != null) {
+      imageBitmap.value = bitmap
       onImageChange(bitmap)
     }
   }
   val permissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
     if (isGranted) {
-      cameraLauncher.launchWithFallback()
+      cameraLauncher.launch(null)
       hideBottomSheet()
     } else {
       Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
@@ -246,7 +196,7 @@ fun GetImageBottomSheet(
       ActionButton(null, stringResource(R.string.use_camera_button), icon = Icons.Outlined.PhotoCamera) {
         when (PackageManager.PERMISSION_GRANTED) {
           ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
-            cameraLauncher.launchWithFallback()
+            cameraLauncher.launch(null)
             hideBottomSheet()
           }
           else -> {
@@ -255,11 +205,7 @@ fun GetImageBottomSheet(
         }
       }
       ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Collections) {
-        try {
-          galleryLauncher.launch(0)
-        } catch (e: ActivityNotFoundException) {
-          galleryLauncherFallback.launch("image/*")
-        }
+        galleryLauncher.launch("image/*")
         hideBottomSheet()
       }
     }

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

@@ -26,44 +26,29 @@ 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 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")
-        }
-      }
+      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")
       if (imageUri != null) {
-        imageUri = normalizeImageUri(u, imageUri)
         try {
-          val stream = URL(imageUri).openStream()
+          val stream = java.net.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)
           }
@@ -78,6 +63,8 @@ suspend fun getLinkPreview(url: String): LinkPreview? {
   }
 }
 
+
+
 @Composable
 fun ComposeLinkView(linkPreview: LinkPreview?, cancelPreview: () -> Unit) {
   Row(
@@ -140,37 +127,6 @@ 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,6 +89,18 @@ 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

@@ -1,90 +0,0 @@
-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,24 +2,22 @@ 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.*
-import androidx.compose.runtime.*
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
 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,
+  modifier: Modifier = Modifier.padding(horizontal = 16.dp),
   content: @Composable () -> Unit,
 ) {
   BackHandler(onBack = close)
@@ -32,108 +30,35 @@ fun ModalView(
 }
 
 class ModalManager {
-  private val modalViews = arrayListOf<Pair<Boolean, (@Composable (close: () -> Unit) -> Unit)>>()
+  private val modalViews = arrayListOf<(@Composable (close: () -> Unit) -> Unit)?>()
   private val modalCount = mutableStateOf(0)
-  private val toRemove = mutableSetOf<Int>()
-  private var oldViewChanging = AtomicBoolean(false)
 
-  fun showModal(settings: Boolean = false, content: @Composable () -> Unit) {
-    showCustomModal { close ->
-      ModalView(close, if (!settings || isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight, content = content)
-    }
+  fun showModal(content: @Composable () -> Unit) {
+    showCustomModal { close -> ModalView(close, content = content) }
   }
 
-  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) {
+  fun showCustomModal(modal: @Composable (close: () -> Unit) -> Unit) {
     Log.d(TAG, "ModalManager.showModal")
-    // 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
+    modalViews.add(modal)
+    modalCount.value = modalViews.count()
   }
 
-  fun hasModalsOpen() = modalCount.value > 0
-
   fun closeModal() {
     if (modalViews.isNotEmpty()) {
-      if (modalViews.lastOrNull()?.first == false) modalViews.removeAt(modalViews.lastIndex)
-      else runAtomically { toRemove.add(modalViews.lastIndex - toRemove.size) }
+      modalViews.removeAt(modalViews.count() - 1)
     }
-    modalCount.value = modalViews.size - toRemove.size
+    modalCount.value = modalViews.count()
   }
 
   fun closeModals() {
-    while (modalCount.value > 0) closeModal()
+    while (modalViews.isNotEmpty()) closeModal()
   }
 
-  @OptIn(ExperimentalAnimationApi::class)
   @Composable
   fun showInView() {
-    // 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 } }
-      }
-    }
+    if (modalCount.value > 0) modalViews.lastOrNull()?.invoke(::closeModal)
   }
 
-  /**
-  * 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,15 +1,7 @@
 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 ->
@@ -23,22 +15,3 @@ 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

@@ -1,285 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import android.content.Context
-import android.media.*
-import android.media.AudioManager.AudioPlaybackCallback
-import android.media.MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED
-import android.media.MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
-import android.os.Build
-import android.util.Log
-import androidx.compose.runtime.*
-import chat.simplex.app.*
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatItem
-import chat.simplex.app.views.helpers.AudioPlayer.duration
-import kotlinx.coroutines.*
-import java.io.*
-import java.text.SimpleDateFormat
-import java.util.*
-
-interface Recorder {
-  fun start(onProgressUpdate: (position: Int?, finished: Boolean) -> Unit): String
-  fun stop(): Int
-}
-
-class RecorderNative(private val recordedBytesLimit: Long): Recorder {
-  companion object {
-    // Allows to stop the recorder from outside without having the recorder in a variable
-    var stopRecording: (() -> Unit)? = null
-  }
-  private var recorder: MediaRecorder? = null
-  private var progressJob: Job? = null
-  private var filePath: String? = null
-  private var recStartedAt: Long? = null
-  private fun initRecorder() =
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      MediaRecorder(SimplexApp.context)
-    } else {
-      MediaRecorder()
-    }
-
-  override fun start(onProgressUpdate: (position: Int?, finished: Boolean) -> Unit): String {
-    AudioPlayer.stop()
-    val rec: MediaRecorder
-    recorder = initRecorder().also { rec = it }
-    rec.setAudioSource(MediaRecorder.AudioSource.MIC)
-    rec.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
-    rec.setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
-    rec.setAudioChannels(1)
-    rec.setAudioSamplingRate(16000)
-    rec.setAudioEncodingBitRate(16000)
-    rec.setMaxDuration(MAX_VOICE_MILLIS_FOR_SENDING)
-    rec.setMaxFileSize(recordedBytesLimit)
-    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
-    val path = getAppFilePath(SimplexApp.context, uniqueCombine(SimplexApp.context, getAppFilePath(SimplexApp.context, "voice_${timestamp}.m4a")))
-    filePath = path
-    rec.setOutputFile(path)
-    rec.prepare()
-    rec.start()
-    recStartedAt = System.currentTimeMillis()
-    progressJob = CoroutineScope(Dispatchers.Default).launch {
-      while(isActive) {
-        onProgressUpdate(progress(), false)
-        delay(50)
-      }
-    }.apply {
-      invokeOnCompletion {
-        onProgressUpdate(realDuration(path), true)
-      }
-    }
-    rec.setOnInfoListener { _, what, _ ->
-      if (what == MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED || what == MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
-        stop()
-      }
-    }
-    stopRecording = { stop() }
-    return path
-  }
-
-  override fun stop(): Int {
-    val path = filePath ?: return 0
-    stopRecording = null
-    runCatching {
-      recorder?.stop()
-    }
-    runCatching {
-      recorder?.reset()
-    }
-    runCatching {
-      recorder?.release()
-    }
-    // Await coroutine finishes in order to send real duration to it's listener
-    runBlocking {
-      progressJob?.cancelAndJoin()
-    }
-    progressJob = null
-    filePath = null
-    recorder = null
-    return (realDuration(path) ?: 0).also { recStartedAt = null }
-  }
-
-  private fun progress(): Int? = recStartedAt?.let { (System.currentTimeMillis() - it).toInt() }
-
-  /**
-  * Return real duration from [AudioPlayer] if it's possible (should always be possible).
-  * As a fallback, return internally counted duration
-  * */
-  private fun realDuration(path: String): Int? = duration(path) ?: progress()
-}
-
-object AudioPlayer {
-  private val player = MediaPlayer().apply {
-    setAudioAttributes(
-      AudioAttributes.Builder()
-        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
-        .setUsage(AudioAttributes.USAGE_MEDIA)
-        .build()
-    )
-    (SimplexApp.context.getSystemService(Context.AUDIO_SERVICE) as AudioManager)
-      .registerAudioPlaybackCallback(object: AudioPlaybackCallback() {
-        override fun onPlaybackConfigChanged(configs: MutableList<AudioPlaybackConfiguration>?) {
-          if (configs?.any { it.audioAttributes.usage == AudioAttributes.USAGE_VOICE_COMMUNICATION } == true) {
-            // In a process of making a call
-            RecorderNative.stopRecording?.invoke()
-            stop()
-          }
-          super.onPlaybackConfigChanged(configs)
-        }
-      }, null)
-  }
-  private val helperPlayer: MediaPlayer =  MediaPlayer().apply {
-        setAudioAttributes(
-          AudioAttributes.Builder()
-            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
-            .setUsage(AudioAttributes.USAGE_MEDIA)
-            .build()
-        )
-  }
-  // Filepath: String, onProgressUpdate
-  private val currentlyPlaying: MutableState<Pair<String, (position: Int?, state: TrackState) -> Unit>?> = mutableStateOf(null)
-  private var progressJob: Job? = null
-
-  enum class TrackState {
-    PLAYING, PAUSED, REPLACED
-  }
-
-  // Returns real duration of the track
-  private fun start(filePath: String, seek: Int? = null, onProgressUpdate: (position: Int?, state: TrackState) -> Unit): Int? {
-    if (!File(filePath).exists()) {
-      Log.e(TAG, "No such file: $filePath")
-      return null
-    }
-
-    RecorderNative.stopRecording?.invoke()
-    val current = currentlyPlaying.value
-    if (current == null || current.first != filePath) {
-      stopListener()
-      player.reset()
-      runCatching {
-        player.setDataSource(filePath)
-      }.onFailure {
-        Log.e(TAG, it.stackTraceToString())
-        AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), it.message)
-        return null
-      }
-      runCatching { player.prepare() }.onFailure {
-        // Can happen when audio file is broken
-        Log.e(TAG, it.stackTraceToString())
-        AlertManager.shared.showAlertMsg(generalGetString(R.string.unknown_error), it.message)
-        return null
-      }
-    }
-    if (seek != null) player.seekTo(seek)
-    player.start()
-    currentlyPlaying.value = filePath to onProgressUpdate
-    progressJob = CoroutineScope(Dispatchers.Default).launch {
-      onProgressUpdate(player.currentPosition, TrackState.PLAYING)
-      while(isActive && player.isPlaying) {
-        // Even when current position is equal to duration, the player has isPlaying == true for some time,
-        // so help to make the playback stopped in UI immediately
-        if (player.currentPosition == player.duration) {
-          onProgressUpdate(player.currentPosition, TrackState.PLAYING)
-          break
-        }
-        delay(50)
-        onProgressUpdate(player.currentPosition, TrackState.PLAYING)
-      }
-      /*
-      * Since coroutine is still NOT canceled, means player ended (no stop/no pause). But in some cases
-      * the player can show position != duration even if they actually equal.
-      * Let's say to a listener that the position == duration in case of coroutine finished without cancel
-      * */
-      if (isActive) {
-        onProgressUpdate(player.duration, TrackState.PAUSED)
-      }
-      onProgressUpdate(null, TrackState.PAUSED)
-    }
-    return player.duration
-  }
-
-  private fun pause(): Int {
-    progressJob?.cancel()
-    progressJob = null
-    player.pause()
-    return player.currentPosition
-  }
-
-  fun stop() {
-    if (currentlyPlaying.value == null) return
-    player.stop()
-    stopListener()
-  }
-
-  fun stop(item: ChatItem) = stop(item.file?.fileName)
-
-  // FileName or filePath are ok
-  fun stop(fileName: String?) {
-    if (fileName != null && currentlyPlaying.value?.first?.endsWith(fileName) == true) {
-      stop()
-    }
-  }
-
-  private fun stopListener() {
-    val afterCoroutineCancel: CompletionHandler = {
-      // Notify prev audio listener about stop
-      currentlyPlaying.value?.second?.invoke(null, TrackState.REPLACED)
-      currentlyPlaying.value = null
-    }
-    /** Preventing race by calling a code AFTER coroutine ends, so [TrackState] will be:
-     * [TrackState.PLAYING] -> [TrackState.PAUSED] -> [TrackState.REPLACED] (in this order)
-     * */
-    if (progressJob != null) {
-      progressJob?.invokeOnCompletion(afterCoroutineCancel)
-    } else {
-      afterCoroutineCancel(null)
-    }
-    progressJob?.cancel()
-    progressJob = null
-  }
-
-  fun play(
-    filePath: String?,
-    audioPlaying: MutableState<Boolean>,
-    progress: MutableState<Int>,
-    duration: MutableState<Int>,
-    resetOnEnd: Boolean,
-  ) {
-    if (progress.value == duration.value) {
-      progress.value = 0
-    }
-    val realDuration = start(filePath ?: return, progress.value) { pro, state ->
-      if (pro != null) {
-        progress.value = pro
-      }
-      if (pro == null || pro == duration.value) {
-        audioPlaying.value = false
-        if (pro == duration.value) {
-          progress.value = if (resetOnEnd) 0 else duration.value
-        } else if (state == TrackState.REPLACED) {
-          progress.value = 0
-        }
-      }
-    }
-    audioPlaying.value = realDuration != null
-    // Update to real duration instead of what was received in ChatInfo
-    realDuration?.let { duration.value = it }
-  }
-
-  fun pause(audioPlaying: MutableState<Boolean>, pro: MutableState<Int>) {
-    pro.value = pause()
-    audioPlaying.value = false
-  }
-
-  fun duration(filePath: String): Int? {
-    var res: Int? = null
-    kotlin.runCatching {
-      helperPlayer.setDataSource(filePath)
-      helperPlayer.prepare()
-      helperPlayer.start()
-      helperPlayer.stop()
-      res = helperPlayer.duration
-      helperPlayer.reset()
-    }
-    return res
-  }
-}

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

@@ -1,103 +0,0 @@
-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,215 +0,0 @@
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.material.*
-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.*
-import chat.simplex.app.views.helpers.ValueTitleDesc
-import chat.simplex.app.views.helpers.ValueTitle
-
-@Composable
-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 = DEFAULT_PADDING, bottom = 5.dp), fontSize = 12.sp
-      )
-    }
-    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
-      Column(Modifier.padding(padding).fillMaxWidth()) { content() }
-    }
-  }
-}
-
-@Composable
-fun SectionView(
-  title: String,
-  icon: ImageVector,
-  iconTint: Color = HighOrLowlight,
-  leadingIcon: Boolean = false,
-  padding: PaddingValues = PaddingValues(),
-  content: (@Composable ColumnScope.() -> Unit)
-) {
-  Column {
-    val iconSize = with(LocalDensity.current) { 21.sp.toDp() }
-    Row(Modifier.padding(start = DEFAULT_PADDING, bottom = 5.dp), verticalAlignment = Alignment.CenterVertically) {
-      if (leadingIcon) Icon(icon, null, Modifier.padding(end = 4.dp).size(iconSize), tint = iconTint)
-      Text(title, color = HighOrLowlight, style = MaterialTheme.typography.body2, fontSize = 12.sp)
-      if (!leadingIcon) Icon(icon, null, Modifier.padding(start = 4.dp).size(iconSize), tint = iconTint)
-    }
-    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
-      Column(Modifier.padding(padding).fillMaxWidth()) { content() }
-    }
-  }
-}
-
-@Composable
-fun <T> SectionViewSelectable(
-  title: String?,
-  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
-    .fillMaxWidth()
-    .sizeIn(minHeight = minHeight)
-  Row(
-    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(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = DEFAULT_PADDING_HALF).fillMaxWidth(0.9F),
-    color = HighOrLowlight,
-    lineHeight = 18.sp,
-    fontSize = 14.sp
-  )
-}
-
-@Composable
-fun SectionCustomFooter(padding: PaddingValues = PaddingValues(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = 5.dp), content: (@Composable () -> Unit)) {
-  Row(
-    Modifier.padding(padding)
-  ) {
-    content()
-  }
-}
-
-@Composable
-fun SectionDivider() {
-  Divider(Modifier.padding(horizontal = 8.dp))
-}
-
-@Composable
-fun SectionSpacer() {
-  Spacer(Modifier.height(30.dp))
-}
-
-@Composable
-fun InfoRow(title: String, value: String, icon: ImageVector? = null, iconTint: Color? = null) {
-  SectionItemViewSpaceBetween {
-    Row {
-      val iconSize = with(LocalDensity.current) { 21.sp.toDp() }
-      if (icon != null) Icon(icon, title, Modifier.padding(end = 8.dp).size(iconSize), tint = iconTint ?: HighOrLowlight)
-      Text(title)
-    }
-    Text(value, color = HighOrLowlight)
-  }
-}
-
-@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
-    )
-  }
-}