3.2.1 (#992)

* Options when using .onion hosts

* Confirmation alert before applying network settings

* Useless new line was removed

* Different ordering of options in enum

.github/CODEOWNERS

@@ -1 +1 @@
-* @epoberezkin @efim-poberezkin
+* @epoberezkin @jr-simplex

.gitignore

@@ -42,3 +42,4 @@ stack.yaml.lock
 
 # Temporary test files
 tests/tmp
+logs/

README.md

@@ -1,8 +1,8 @@
 <img src="images/simplex-chat-logo.svg" alt="SimpleX logo" width="100%">
 
-# SimpleX - the first chat platform that is 100% private by design - it has no access to your connection graph!
+# SimpleX - the first messaging platform that has no user identifiers of any kind - 100% private by design!
 
-[![GitHub build](https://github.com/simplex-chat/simplex-chat/workflows/build/badge.svg)](https://github.com/simplex-chat/simplex-chat/actions?query=workflow%3Abuild)
+[![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
 [![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
 [![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
 [![Follow on Twitter](https://img.shields.io/twitter/follow/SimpleXChat?style=social)](https://twitter.com/SimpleXChat)
@@ -19,281 +19,219 @@
 [<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 encryption.
-- 📱 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). [See the announcement here](https://github.com/simplex-chat/simplex-chat/blob/master/blog/20220308-simplex-chat-mobile-apps.md).
+- 🔐 Double ratchet end-to-end encryption, with additional encryption layer.
+- 📱 Mobile apps for Android ([Google Play](https://play.google.com/store/apps/details?id=chat.simplex.app), [APK](https://github.com/simplex-chat/website/raw/master/simplex.apk)) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084).
 - 🚀 [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](https://github.com/simplex-chat/simplex-chat) on Linux, MacOS, Windows.
+- 🖥 Available as a terminal (console) app / CLI on Linux, MacOS, Windows.
 
-See [SimpleX overview](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information on platform objectives and technical design.
+## Contents
 
-### :zap: Quick installation of a terminal app
+- [Why privacy matters](#why-privacy-matters)
+- [SimpleX approach to privacy and security](#simplex-approach-to-privacy-and-security)
+  - [Complete privacy](#complete-privacy-of-your-identity-profile-contacts-and-metadata)
+  - [Protection against spam and abuse](#the-best-protection-against-spam-and-abuse)
+  - [Ownership and security of your data](#complete-ownership-control-and-security-of-your-data)
+  - [Users own SimpleX network](#users-own-simplex-network)
+- [Frequently asked questions](#frequently-asked-questions)
+- [News and updates](#news-and-updates)
+- [Make a private connection](#make-a-private-connection)
+- [Quick installation of a terminal app](#zap-quick-installation-of-a-terminal-app)
+- [SimpleX Platform design](#simplex-platform-design)
+- [Privacy: technical details and limitations](#privacy-technical-details-and-limitations)
+- [For developers](#for-developers)
+- [Roadmap](#roadmap)
+- [Help us pay for 3rd party security audit](#help-us-pay-for-3rd-party-security-audit)
+- [Disclaimer, License](#disclaimer)
+
+## Why privacy matters
+
+Everyone should care about privacy and security of their communications - innocuous conversations can put you in danger even if there is nothing to hide.
+
+One of the most shocking stories is the experience of [Mohamedou Ould Salahi](https://en.wikipedia.org/wiki/Mohamedou_Ould_Slahi) that he wrote about in his memoir and that is shown in The Mauritanian movie. He was put into Guantanamo camp, without trial, and was tortured there for 15 years after a phone call to his relative in Afghanistan, under suspicion of being involved in 9/11 attacks, even though he lived in Germany for the 10 years prior to the attacks.
+
+It is not enough to use an end-to-end encrypted messenger, we all should use the messengers that protect the privacy of our personal networks - who we are connected with.
+
+## SimpleX approach to privacy and security
+
+### Complete privacy of your identity, profile, contacts and metadata
+
+**Unlike any other existing messaging platform, SimpleX has no identifiers assigned to the users** - not even random numbers. This protects the privacy of who are you communicating with, hiding it from SimpleX platform servers and from any observers. [Read more](./docs/SIMPLEX.md#full-privacy-of-your-identity-profile-contacts-and-metadata).
+
+### The best protection against spam and abuse
+
+As you have no identifier on SimpleX platform, you cannot be contacted unless you share a one-time invitation link or an optional temporary user address. [Read more](./docs/SIMPLEX.md#the-best-protection-against-spam-and-abuse).
+
+### Complete ownership, control and security of your data
+
+SimpleX stores all user data on client devices, the messages are only held temporarily on SimpleX relay servers until they are received. [Read more](./docs/SIMPLEX.md#complete-ownership-control-and-security-of-your-data).
+
+### Users own SimpleX network
+
+You can use SimpleX with your own servers and still communicate with people using the servers that are pre-configured in the apps or any other SimpleX servers. [Read more](./docs/SIMPLEX.md#users-own-simplex-network).
+
+## Frequently asked questions
+
+1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release annoucement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
+
+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.
+
+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
+
+Selected updates:
+
+[Aug 8, 2022. v3.1: secret chat groups, access via Tor, reduced battery and traffic usage, advanced netwrok settings, etc.](./blog/20220808-simplex-chat-v3.1-chat-groups.md)
+
+[Jul 11, 2022. v3.0: instant push notifications for iOS, e2e encrypted WebRTC audio/video calls, chat database export/import, privacy and performance improvements](./blog/20220711-simplex-chat-v3-released-ios-notifications-audio-video-calls-database-export-import-protocol-improvements.md)
+
+[May 11, 2022. v2.0 released - sending images and files in mobile apps](./blog/20220511-simplex-chat-v2-images-files.md)
+
+[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.md)
+
+[Jan 12, 2022. SimpleX v1 released: the only messaging and application platform without user identities](./20220112-simplex-chat-v1-released.md)
+
+[All updates](./blog)
+
+## Make a private connection
+
+You need to share a link or scan a QR code (in person or during a video call) to make a connection and start messaging.
+
+The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
+
+<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/conversation.png" alt="Make a private connection" width="594" height="360">
+
+## :zap: Quick installation of a terminal app
 
 ```sh
-curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/master/install.sh | bash
+curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/stable/install.sh | bash
 ```
 
 Once the chat client is installed, simply run `simplex-chat` from your terminal.
 
 ![simplex-chat](./images/connection.gif)
 
-## Table of contents
+Read more about [installing and using the terminal app](./docs/CLI.md).
 
-- [Disclaimer](#disclaimer)
-- [Network topology](#network-topology)
-- [Terminal chat features](#terminal-chat-features)
-- [Installation](#🚀-installation)
-  - [Download chat client](#download-chat-client)
-    - [Linux and MacOS](#linux-and-macos)
-    - [Windows](#windows)
-  - [Build from source](#build-from-source)
-    - [Using Docker](#using-docker)
-    - [Using Haskell stack](#using-haskell-stack)
-- [Usage](#usage)
-  - [Running the chat client](#running-the-chat-client)
-  - [How to use SimpleX chat](#how-to-use-simplex-chat)
-  - [Groups](#groups)
-  - [Sending files](#sending-files)
-  - [User contact addresses](#user-contact-addresses)
-  - [Access chat history](#access-chat-history)
-- [Roadmap](#Roadmap)
-- [License](#license)
+## SimpleX Platform design
 
-## Disclaimer
+SimpleX is a client-server network with a unique network topology that uses redundant, disposable message relay nodes to asynchronously pass messages via unidirectional (simplex) message queues, providing recipient and sender anonymity.
 
-SimpleX Chat implements a new network topology for asynchronous communication combining the advantages and avoiding the disadvantages of federated and P2P networks.
+Unlike P2P networks, all messages are passed through one or several server nodes, that do not even need to have persistence. In fact, the current [SMP server implementation](https://github.com/simplex-chat/simplexmq#smp-server) uses in-memory message storage, persisting only the queue records. SimpleX provides better metadata protection than P2P designs, as no global participant identifiers are used to deliver messages, and avoids [the problems of P2P networks](./docs/SIMPLEX.md#comparison-with-p2p-messaging-protocols).
 
-[SimpleXMQ security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) had many improvements in v1.0.0; the implementation has not been audited yet.
+Unlike federated networks, the server nodes **do not have records of the users**, **do not communicate with each other** and **do not store messages** after they are delivered to the recipients. There is no way to discover the full list of servers participating in SimpleX network. This design avoids the problem of metadata visibility that all federated networks have and better protects from the network-wide attacks.
 
-We use SimpleX Chat all the time, but you may find some bugs. We would really appreciate if you use it and let us know anything that needs to be fixed or improved.
+Only the client devices have information about users, their contacts and groups.
 
-## Network topology
+See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/overview-tjr.md) for more information on platform objectives and technical design.
 
-SimpleX is a client-server network that uses redundant, disposable nodes to asynchronously pass messages via message queues, providing receiver and sender anonymity.
+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).
 
-Unlike P2P networks, all messages are passed through one or several (for redundancy) servers, that do not even need to have persistence (in fact, the current [SMP server implementation](https://github.com/simplex-chat/simplexmq#smp-server) uses in-memory message storage, persisting only the queue records) - it provides better metadata protection than P2P designs, as no global participant ID is required, and avoids many [problems of P2P networks](https://github.com/simplex-chat/simplex-chat/blob/master/simplex.md#comparison-with-p2p-messaging-protocols).
+## Privacy: technical details and limitations
 
-Unlike federated networks, the participating server nodes **do not have records of the users**, **do not communicate with each other**, **do not store messages** after they are delivered to the recipients, and there is no way to discover the full list of participating servers. SimpleX network avoids the problem of metadata visibility that federated networks have and better protects the network, as servers do not communicate with each other. Each server node provides unidirectional "dumb pipes" to the users, that do authorization without authentication, having no knowledge of the the users or their contacts. Each queue is assigned two Ed448 keys - one for receiver and one for sender - and each queue access is authorized with a signature created using a respective key's private counterpart.
+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.
 
-The routing of messages relies on the knowledge of client devices how user contacts and groups map at any given moment of time to these disposable queues on server nodes.
+What is already implemented:
 
-## Terminal chat features
+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.
 
-- 1-to-1 chat with multiple people in the same terminal window.
-- Group messaging.
-- Sending files to contacts and groups.
-- User contact addresses - establish connections via multiple-use contact links.
-- Messages persisted in a local SQLite database.
-- Auto-populated recipient name - just type your messages to reply to the sender once the connection is established.
-- Demo SMP servers available and pre-configured in the app - or you can [deploy your own server](https://github.com/simplex-chat/simplexmq#using-smp-server-and-smp-agent).
-- No global identity or any names visible to the server(s), ensuring full privacy of your contacts and conversations.
-- Two layers of E2E encryption (double-ratchet for duplex connections, using X3DH key agreement with ephemeral Curve448 keys, and NaCl crypto_box for SMP queues, using Curve25519 keys) and out-of-band passing of recipient keys (see [How to use SimpleX chat](#how-to-use-simplex-chat)).
-- Message integrity validation (via including the digests of the previous messages).
-- Authentication of each command/message by SMP servers with automatically generated Ed448 keys.
-- TLS 1.3 transport encryption.
-- Additional encryption of messages from SMP server to recipient to reduce traffic correlation.
+We plan to add soon:
 
-Public keys involved in key exchange are not used as identity, they are randomly generated for each contact.
+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 database encryption. Currently the local chat database stored on your device is not encrypted.
+3. Message "mixing" - adding latency to message delivery, to protect against traffic correlation by message time.
+4. Independent implementation audit.
 
-See [Encryption Primitives Used](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md#encryption-primitives-used) for technical details.
+## For developers
 
-<a name="🚀-installation"></a>
+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.
 
-## 🚀 Installation
+You already can:
 
-### Download chat client
+- 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).
 
-#### Linux and MacOS
-
-To **install** or **update** `simplex-chat`, you should run the install script. To do that, use the following cURL or Wget command:
-
-```sh
-curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/master/install.sh | bash
-```
-
-```sh
-wget -qO- https://raw.githubusercontent.com/simplex-chat/simplex-chat/master/install.sh | bash
-```
-
-Once the chat client downloads, you can run it with `simplex-chat` command in your terminal.
-
-Alternatively, you can manually download the chat binary for your system from the [latest stable release](https://github.com/simplex-chat/simplex-chat/releases) and make it executable as shown below.
-
-```sh
-chmod +x <binary>
-mv <binary> ~/.local/bin/simplex-chat
-```
-
-(or any other preferred location on `PATH`).
-
-On MacOS you also need to [allow Gatekeeper to run it](https://support.apple.com/en-us/HT202491).
-
-#### Windows
-
-```sh
-move <binary> %APPDATA%/local/bin/simplex-chat.exe
-```
-
-### Build from source
-
-> **Please note:** to build the app use source code from [stable branch](https://github.com/simplex-chat/simplex-chat/tree/stable).
-
-#### Using Docker
-
-On Linux, you can build the chat executable using [docker build with custom output](https://docs.docker.com/engine/reference/commandline/build/#custom-build-outputs):
-
-```shell
-$ git clone git@github.com:simplex-chat/simplex-chat.git
-$ cd simplex-chat
-$ git checkout stable
-$ DOCKER_BUILDKIT=1 docker build --output ~/.local/bin .
-```
-
-> **Please note:** If you encounter `` version `GLIBC_2.28' not found `` error, rebuild it with `haskell:8.10.4-stretch` base image (change it in your local [Dockerfile](Dockerfile)).
-
-#### Using Haskell stack
-
-Install [Haskell stack](https://docs.haskellstack.org/en/stable/README/):
-
-```shell
-curl -sSL https://get.haskellstack.org/ | sh
-```
-
-and build the project:
-
-```shell
-$ git clone git@github.com:simplex-chat/simplex-chat.git
-$ cd simplex-chat
-$ git checkout stable
-$ stack install
-```
-
-## Usage
-
-### Running the chat client
-
-To start the chat client, run `simplex-chat` from the terminal.
-
-By default, app data directory is created in the home directory (`~/.simplex`, or `%APPDATA%/simplex` on Windows), and two SQLite database files `simplex_v1_chat.db` and `simplex_v1_agent.db` are initialized in it.
-
-To specify a different file path prefix for the database files use `-d` command line option:
-
-```shell
-$ simplex-chat -d alice
-```
-
-Running above, for example, would create `alice_v1_chat.db` and `alice_v1_agent.db` database files in current directory.
-
-Three default SMP servers are hosted on Linode - they are [pre-configured in the app](https://github.com/simplex-chat/simplex-chat/blob/master/src/Simplex/Chat/Options.hs#L42).
-
-If you deployed your own SMP server(s) you can configure client via `-s` option:
-
-```shell
-$ simplex-chat -s smp://LcJUMfVhwD8yxjAiSaDzzGF3-kLG4Uh0Fl_ZIjrRwjI=@smp.example.com
-```
-
-Base64url encoded string preceding the server address is the server's offline certificate fingerprint which is validated by client during TLS handshake.
-
-You can still talk to people using default or any other server - it only affects the location of the message queue when you initiate the connection (and the reply queue can be on another server, as set by the other party's client).
-
-Run `simplex-chat -h` to see all available options.
-
-### How to use SimpleX chat
-
-Once you have started the chat, you will be prompted to specify your "display name" and an optional "full name" to create a local chat profile. Your display name is an alias for your contacts to refer to you by - it is not unique and does not serve as a global identity. If some of your contacts chose the same display name, the chat client adds a numeric suffix to their local display name.
-
-The diagram below shows how to connect and message a contact:
-
-<div align="center">
-  <img align="center" src="images/how-to-use-simplex.svg">
-</div>
-
-Once you've set up your local profile, enter `/c` (for `/connect`) to create a new connection and generate an invitation. Send this invitation to your contact via any other channel.
-
-You are able to create multiple invitations by entering `/connect` multiple times and sending these invitations to the corresponding contacts you'd like to connect with.
-
-The invitation can only be used once and even if this is intercepted, the attacker would not be able to use it to send you the messages via this queue once your contact confirms that the connection is established. See agent protocol for explanation of [invitation format](https://github.com/simplex-chat/simplexmq/blob/master/protocol/agent-protocol.md#connection-request).
-
-The contact who received the invitation should enter `/c <invitation>` to accept the connection. This establishes the connection, and both parties are notified.
-
-They would then use `@<name> <message>` commands to send messages. You may also just start typing a message to send it to the contact that was the last.
-
-Use `/help` in chat to see the list of available commands.
-
-### Groups
-
-To create a group use `/g <group>`, then add contacts to it with `/a <group> <name>`. You can then send messages to the group by entering  `#<group> <message>`. Use `/help groups` for other commands.
-
-![simplex-chat](./images/groups.gif)
-
-> **Please note**: the groups are not stored on any server, they are maintained as a list of members in the app database to whom the messages will be sent.
-
-### Sending files
-
-You can send a file to your contact with `/f @<contact> <file_path>` - the recipient will have to accept it before it is sent. Use `/help files` for other commands.
-
-![simplex-chat](./images/files.gif)
-
-You can send files to a group with `/f #<group> <file_path>`.
-
-### User contact addresses
-
-As an alternative to one-time invitation links, you can create a long-term address with `/ad` (for `/address`). The created address can then be shared via any channel, and used by other users as a link to make a contact request with `/c <user_contact_address>`.
-
-You can accept or reject incoming requests with `/ac <name>` and `/rc <name>` commands.
-
-User address is "long-term" in a sense that it is a multiple-use connection link - it can be used until it is deleted by the user, in which case all established connections would still remain active (unlike how it works with email, when changing the address results in people not being able to message you).
-
-Use `/help address` for other commands.
-
-![simplex-chat](./images/user-addresses.gif)
-
-### Access chat history
-
-SimpleX chat stores all your contacts and conversations in a local SQLite database, making it private and portable by design, owned and controlled by user.
-
-You can view and search your chat history by querying your database. Run the below script to create message views in your database.
-
-```sh
-curl -o- https://raw.githubusercontent.com/simplex-chat/simplex-chat/master/message_views.sql | sqlite3 ~/.simplex/simplex_v1_chat.db
-```
-
-Open SQLite Command Line Shell:
-
-```sh
-sqlite3 ~/.simplex/simplex_v1_chat.db
-```
-
-See [Message queries](./message_queries.md) for examples.
-
-> **Please note:** SQLite foreign key constraints are disabled by default, and must be **[enabled separately for each database connection](https://sqlite.org/foreignkeys.html#fk_enable)**. The latter can be achieved by running `PRAGMA foreign_keys = ON;` command on an open database connection. By running data altering queries without enabling foreign keys prior to that, you may risk putting your database in an inconsistent state.
-
-**Convenience queries**
-
-Get all messages from today (`chat_dt` is in UTC):
-
-```sql
-select * from all_messages_plain where date(chat_dt) > date('now', '-1 day') order by chat_dt;
-```
-
-Get overnight messages in the morning:
-
-```sql
-select * from all_messages_plain where chat_dt > datetime('now', '-15 hours') order by chat_dt;
-```
+If you are considering developing with SimpleX platform please get in touch for any advice and support.
 
 ## Roadmap
 
-1. Mobile and desktop apps (in progress).
-2. SMP protocol improvements:
-   - SMP queue redundancy and rotation.
-   - Message delivery confirmation.
-   - Support multiple devices.
-3. 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.
-4. Media server to optimize sending large files to groups.
-5. Channels server for large groups and broadcast channels.
+- ✅ Easy to deploy SimpleX server with in-memory message storage, without any dependencies.
+- ✅ Terminal (console) client with groups and files support.
+- ✅ One-click SimpleX server deployment on Linode.
+- ✅ End-to-end encryption using double-ratchet protocol with additional encryption layer.
+- ✅ Mobile apps v1 for Android and iOS.
+- ✅ Private instant notifications for Android using background service.
+- ✅ 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 (in progress).
+- 🏗 Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (in progress).
+- Chat database encryption.
+- Disappearing messages, with mutual agreement.
+- Web widgets for custom interactivity in the chats.
+- SMP protocol improvements:
+  - SMP queue redundancy and rotation.
+  - Message delivery confirmation.
+  - Supporting the same profile on multiple devices.
+- Privacy-preserving identity server for optional DNS-based contact/group addresses to simplify connection and discovery, but not used to deliver messages:
+  - keep all your contacts and groups even if you lose the domain.
+  - the server doesn't have information about your contacts and groups.
+- Channels server for large groups and broadcast channels.
+- Media server to optimize sending large files to groups.
+
+## Help us pay for 3rd party security audit
+
+I will get straight to the point: I ask you to support SimpleX Chat with donations.
+
+We are prioritizing users privacy and security - it would be impossible without your support we were lucky to have so far.
+
+We are planning a 3rd party security audit for the app, and it would hugely help us if some part of this $20,000+ expense could be covered with donations.
+
+Our pledge to our users is that SimpleX protocols are and will remain open, and in public domain, - so anybody can build the future implementations of the clients and the servers. We are building SimpleX platform based on the same principles as email and web, but much more private and secure.
+
+If you are already using SimpleX Chat, or plan to use it in the future when it has more features, please consider making a donation - it will help us to raise more funds. Donating any amount, even the price of the cup of coffee, would make a huge difference for us.
+
+It is possible to donate via:
+
+- [GitHub](https://github.com/sponsors/simplex-chat) - it is commission-free for us.
+- [OpenCollective](https://opencollective.com/simplex-chat) - it charges a commission, and also accepts donations in crypto-currencies.
+- Monero wallet: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+
+Thank you,
+
+Evgeny
+
+SimpleX Chat founder
+
+## Disclaimer
+
+[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed and had many improvements in v1.0.0; we are currently arranging for the independent implementation audit.
+
+You are likely to discover some bugs - we would really appreciate if you use it and let us know anything that needs to be fixed or improved.
 
 ## License
 
 [AGPL v3](./LICENSE)
+
+[<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;
+[![Android app](https://github.com/simplex-chat/.github/blob/master/profile/images/google_play.svg)](https://play.google.com/store/apps/details?id=chat.simplex.app)
+&nbsp;
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/f_droid.svg" alt="F-Droid" height="41">](https://app.simplex.chat)
+&nbsp;
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/testflight.png" alt="iOS TestFlight" height="41">](https://testflight.apple.com/join/DWuT2LQu)
+&nbsp;
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)

apps/android/.gitignore

@@ -9,6 +9,7 @@
 /.idea/assetWizardSettings.xml
 /.idea/deploymentTargetDropDown.xml
 /.idea/misc.xml
+/.idea/uiDesigner.xml
 .DS_Store
 /build
 /captures

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

@@ -1,5 +1,8 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <ComposeCustomCodeStyleSettings>
+      <option name="USE_CUSTOM_FORMATTING_FOR_MODIFIERS" value="false" />
+    </ComposeCustomCodeStyleSettings>
     <JetCodeStyleSettings>
       <option name="SPACE_BEFORE_EXTEND_COLON" value="false" />
       <option name="NAME_COUNT_TO_USE_STAR_IMPORT" value="3" />
@@ -123,9 +126,11 @@
     <codeStyleSettings language="kotlin">
       <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
       <option name="RIGHT_MARGIN" value="140" />
+      <option name="KEEP_FIRST_COLUMN_COMMENT" value="false" />
       <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
       <option name="KEEP_BLANK_LINES_IN_CODE" value="0" />
       <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="0" />
+      <option name="ALIGN_MULTILINE_PARAMETERS" value="false" />
       <option name="CALL_PARAMETERS_WRAP" value="0" />
       <option name="METHOD_PARAMETERS_WRAP" value="0" />
       <option name="EXTENDS_LIST_WRAP" value="0" />

apps/android/.idea/gradle.xml

@@ -13,7 +13,6 @@
             <option value="$PROJECT_DIR$/app" />
           </set>
         </option>
-        <option name="resolveModulePerSourceSet" value="false" />
       </GradleProjectSettings>
     </option>
   </component>

apps/android/app/build.gradle

@@ -11,8 +11,8 @@ android {
         applicationId "chat.simplex.app"
         minSdk 29
         targetSdk 32
-        versionCode 19
-        versionName "1.4"
+        versionCode 51
+        versionName "3.2"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         ndk {
@@ -26,9 +26,19 @@ android {
                 cppFlags ''
             }
         }
+        manifestPlaceholders.app_name = "@string/app_name"
+        manifestPlaceholders.provider_authorities = "chat.simplex.app.provider"
+        manifestPlaceholders.extract_native_libs = compression_level != "0"
     }
 
     buildTypes {
+        debug {
+            applicationIdSuffix "$application_id_suffix"
+            debuggable new Boolean("$enable_debuggable")
+            manifestPlaceholders.app_name = "$app_name"
+            // Provider can't be the same for different apps on the same device
+            manifestPlaceholders.provider_authorities = "chat.simplex.app${application_id_suffix}.provider"
+        }
         release {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
@@ -47,11 +57,11 @@ android {
         freeCompilerArgs += "-opt-in=com.google.accompanist.insets.ExperimentalAnimatedInsets"
         freeCompilerArgs += "-opt-in=com.google.accompanist.permissions.ExperimentalPermissionsApi"
         freeCompilerArgs += "-opt-in=kotlinx.serialization.InternalSerializationApi"
+        freeCompilerArgs += "-opt-in=kotlinx.serialization.ExperimentalSerializationApi"
     }
     externalNativeBuild {
         cmake {
             path file('src/main/cpp/CMakeLists.txt')
-            version '3.10.2'
         }
     }
     buildFeatures {
@@ -64,6 +74,7 @@ android {
         resources {
             excludes += '/META-INF/{AL2.0,LGPL2.1}'
         }
+        jniLibs.useLegacyPackaging = compression_level != "0"
     }
 }
 
@@ -75,11 +86,15 @@ dependencies {
     implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.1'
     implementation 'androidx.lifecycle:lifecycle-process:2.4.1'
     implementation 'androidx.activity:activity-compose:1.4.0'
+    implementation 'androidx.fragment:fragment:1.4.1'
     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"
@@ -90,15 +105,90 @@ dependencies {
     implementation "androidx.camera:camera-camera2:${camerax_version}"
     implementation "androidx.camera:camera-lifecycle:${camerax_version}"
     implementation "androidx.camera:camera-view:${camerax_version}"
+
     //Barcode
-    implementation 'com.google.zxing:core:3.4.0'
-    implementation 'com.google.mlkit:barcode-scanning:17.0.2'
+    implementation 'org.boofcv:boofcv-android:0.40.1'
+    implementation 'org.boofcv:boofcv-core:0.40.1'
+
     //Camera Permission
     implementation "com.google.accompanist:accompanist-permissions:0.23.0"
 
+    // Link Previews
+    implementation 'org.jsoup:jsoup:1.13.1'
+
+    // Biometric authentication
+    implementation 'androidx.biometric:biometric:1.2.0-alpha04'
+
     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

@@ -1,55 +1,106 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-  package="chat.simplex.app">
+    xmlns:tools="http://schemas.android.com/tools"
+    package="chat.simplex.app">
 
   <uses-feature android:name="android.hardware.camera" />
+
   <uses-permission android:name="android.permission.CAMERA" />
-  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
-  <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
-  <uses-permission android:name="android.permission.WAKE_LOCK"/>
-  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
-  <uses-permission android:name="android.permission.VIBRATE"/>
+  <uses-permission android:name="android.permission.VIDEO_CAPTURE" />
+  <uses-permission android:name="android.permission.RECORD_AUDIO" />
+  <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+  <uses-permission android:name="android.permission.WAKE_LOCK" />
+  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+  <uses-permission android:name="android.permission.VIBRATE" />
   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
   <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+      tools:ignore="ScopedStorage" />
+  <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+  <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
 
   <application
-    android:name="SimplexApp"
-    android:allowBackup="true"
-    android:icon="@mipmap/icon"
-    android:label="@string/app_name"
-    android:supportsRtl="true"
-    android:theme="@style/Theme.SimpleX">
+      android:name="SimplexApp"
+      android:allowBackup="true"
+      android:icon="@mipmap/icon"
+      android:label="${app_name}"
+      android:extractNativeLibs="${extract_native_libs}"
+      android:supportsRtl="true"
+      android:theme="@style/Theme.SimpleX">
 
     <!-- Main activity -->
     <activity
-      android:name=".MainActivity"
-      android:exported="true"
-      android:label="@string/app_name"
-      android:windowSoftInputMode="adjustResize"
-      android:theme="@style/Theme.SimpleX">
+        android:name=".MainActivity"
+        android:launchMode="singleTask"
+        android:exported="true"
+        android:label="${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>
 
       <!-- open simplex:/ connection URI -->
       <intent-filter>
         <action android:name="android.intent.action.VIEW" />
+
         <category android:name="android.intent.category.DEFAULT" />
         <category android:name="android.intent.category.BROWSABLE" />
+
         <data android:scheme="simplex" />
       </intent-filter>
+      <intent-filter android:autoVerify="true">
+        <action android:name="android.intent.action.VIEW" />
+
+        <category android:name="android.intent.category.DEFAULT" />
+        <category android:name="android.intent.category.BROWSABLE" />
+
+        <data android:scheme="http" />
+        <data android:scheme="https" />
+        <data android:host="simplex.chat" />
+        <data android:pathPrefix="/invitation" />
+        <data android:pathPrefix="/contact" />
+      </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"/>
+
     <provider
         android:name="androidx.core.content.FileProvider"
-        android:authorities="chat.simplex.app.provider"
+        android:authorities="${provider_authorities}"
         android:exported="false"
         android:grantUriPermissions="true">
       <meta-data
           android:name="android.support.FILE_PROVIDER_PATHS"
-          android:resource="@xml/file_paths"/>
+          android:resource="@xml/file_paths" />
     </provider>
 
     <!-- SimplexService foreground service -->
@@ -57,8 +108,7 @@
         android:name=".SimplexService"
         android:enabled="true"
         android:exported="false"
-        android:stopWithTask="false">
-    </service>
+        android:stopWithTask="false"></service>
 
     <!-- SimplexService restart on reboot -->
     <receiver
@@ -66,7 +116,7 @@
         android:enabled="true"
         android:exported="true">
       <intent-filter>
-        <action android:name="android.intent.action.BOOT_COMPLETED"/>
+        <action android:name="android.intent.action.BOOT_COMPLETED" />
       </intent-filter>
     </receiver>
 
@@ -74,6 +124,6 @@
     <receiver
         android:name=".SimplexService$AutoRestartReceiver"
         android:enabled="true"
-        android:exported="false"/>
+        android:exported="false" />
   </application>
 </manifest>

apps/android/app/src/main/assets/www/README.md

@@ -0,0 +1,3 @@
+# WebView for WebRTC calls in SimpleX Chat
+
+Do NOT edit call.js here, it is compiled abd copied here from call.ts in packages/simplex-chat-webrtc

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

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
+    <link href="./style.css" rel="stylesheet" />
+    <script src="./lz-string.min.js"></script>
+  </head>
+  <body>
+    <video
+      id="remote-video-stream"
+      autoplay
+      playsinline
+      poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
+    ></video>
+    <video
+      id="local-video-stream"
+      muted
+      autoplay
+      playsinline
+      poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
+    ></video>
+  </body>
+  <footer>
+    <script src="./call.js"></script>
+  </footer>
+</html>

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

@@ -0,0 +1,650 @@
+"use strict";
+// Inspired by
+// https://github.com/webrtc/samples/blob/gh-pages/src/content/insertable-streams/endtoend-encryption
+var CallMediaType;
+(function (CallMediaType) {
+    CallMediaType["Audio"] = "audio";
+    CallMediaType["Video"] = "video";
+})(CallMediaType || (CallMediaType = {}));
+var VideoCamera;
+(function (VideoCamera) {
+    VideoCamera["User"] = "user";
+    VideoCamera["Environment"] = "environment";
+})(VideoCamera || (VideoCamera = {}));
+// for debugging
+// var sendMessageToNative = ({resp}: WVApiMessage) => console.log(JSON.stringify({command: resp}))
+var sendMessageToNative = (msg) => console.log(JSON.stringify(msg));
+// Global object with cryptrographic/encoding functions
+const callCrypto = callCryptoFunction();
+var TransformOperation;
+(function (TransformOperation) {
+    TransformOperation["Encrypt"] = "encrypt";
+    TransformOperation["Decrypt"] = "decrypt";
+})(TransformOperation || (TransformOperation = {}));
+let activeCall;
+const processCommand = (function () {
+    const defaultIceServers = [
+        { urls: ["stun:stun.simplex.im:5349"] },
+        { urls: ["turn:turn.simplex.im:5349"], username: "private", credential: "yleob6AVkiNI87hpR94Z" },
+    ];
+    function getCallConfig(encodedInsertableStreams, iceServers, relay) {
+        return {
+            peerConnectionConfig: {
+                iceServers: iceServers !== null && iceServers !== void 0 ? iceServers : defaultIceServers,
+                iceCandidatePoolSize: 10,
+                encodedInsertableStreams,
+                iceTransportPolicy: relay ? "relay" : "all",
+            },
+            iceCandidates: {
+                delay: 3000,
+                extrasInterval: 2000,
+                extrasTimeout: 8000,
+            },
+        };
+    }
+    function getIceCandidates(conn, config) {
+        return new Promise((resolve, _) => {
+            let candidates = [];
+            let resolved = false;
+            let extrasInterval;
+            let extrasTimeout;
+            const delay = setTimeout(() => {
+                if (!resolved) {
+                    resolveIceCandidates();
+                    extrasInterval = setInterval(() => {
+                        sendIceCandidates();
+                    }, config.iceCandidates.extrasInterval);
+                    extrasTimeout = setTimeout(() => {
+                        clearInterval(extrasInterval);
+                        sendIceCandidates();
+                    }, config.iceCandidates.extrasTimeout);
+                }
+            }, config.iceCandidates.delay);
+            conn.onicecandidate = ({ candidate: c }) => c && candidates.push(c);
+            conn.onicegatheringstatechange = () => {
+                if (conn.iceGatheringState == "complete") {
+                    if (resolved) {
+                        if (extrasInterval)
+                            clearInterval(extrasInterval);
+                        if (extrasTimeout)
+                            clearTimeout(extrasTimeout);
+                        sendIceCandidates();
+                    }
+                    else {
+                        resolveIceCandidates();
+                    }
+                }
+            };
+            function resolveIceCandidates() {
+                if (delay)
+                    clearTimeout(delay);
+                resolved = true;
+                const iceCandidates = serialize(candidates);
+                candidates = [];
+                resolve(iceCandidates);
+            }
+            function sendIceCandidates() {
+                if (candidates.length === 0)
+                    return;
+                const iceCandidates = serialize(candidates);
+                candidates = [];
+                sendMessageToNative({ resp: { type: "ice", iceCandidates } });
+            }
+        });
+    }
+    async function initializeCall(config, mediaType, aesKey, useWorker) {
+        const pc = new RTCPeerConnection(config.peerConnectionConfig);
+        const remoteStream = new MediaStream();
+        const localCamera = VideoCamera.User;
+        const localStream = await getLocalMediaStream(mediaType, localCamera);
+        const iceCandidates = getIceCandidates(pc, config);
+        const call = { connection: pc, iceCandidates, localMedia: mediaType, localCamera, localStream, remoteStream, aesKey, useWorker };
+        await setupMediaStreams(call);
+        pc.addEventListener("connectionstatechange", connectionStateChange);
+        return call;
+        async function connectionStateChange() {
+            sendMessageToNative({
+                resp: {
+                    type: "connection",
+                    state: {
+                        connectionState: pc.connectionState,
+                        iceConnectionState: pc.iceConnectionState,
+                        iceGatheringState: pc.iceGatheringState,
+                        signalingState: pc.signalingState,
+                    },
+                },
+            });
+            if (pc.connectionState == "disconnected" || pc.connectionState == "failed") {
+                pc.removeEventListener("connectionstatechange", connectionStateChange);
+                if (activeCall) {
+                    setTimeout(() => sendMessageToNative({ resp: { type: "ended" } }), 0);
+                }
+                endCall();
+            }
+            else if (pc.connectionState == "connected") {
+                const stats = (await pc.getStats());
+                for (const stat of stats.values()) {
+                    const { type, state } = stat;
+                    if (type === "candidate-pair" && state === "succeeded") {
+                        const iceCandidatePair = stat;
+                        const resp = {
+                            type: "connected",
+                            connectionInfo: {
+                                iceCandidatePair,
+                                localCandidate: stats.get(iceCandidatePair.localCandidateId),
+                                remoteCandidate: stats.get(iceCandidatePair.remoteCandidateId),
+                            },
+                        };
+                        setTimeout(() => sendMessageToNative({ resp }), 500);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    function serialize(x) {
+        return LZString.compressToBase64(JSON.stringify(x));
+    }
+    function parse(s) {
+        return JSON.parse(LZString.decompressFromBase64(s));
+    }
+    async function processCommand(body) {
+        const { corrId, command } = body;
+        const pc = activeCall === null || activeCall === void 0 ? void 0 : activeCall.connection;
+        let resp;
+        try {
+            switch (command.type) {
+                case "capabilities":
+                    console.log("starting outgoing call - capabilities");
+                    if (activeCall)
+                        endCall();
+                    // This request for local media stream is made to prompt for camera/mic permissions on call start
+                    if (command.media)
+                        await getLocalMediaStream(command.media, VideoCamera.User);
+                    const encryption = supportsInsertableStreams(command.useWorker);
+                    resp = { type: "capabilities", capabilities: { encryption } };
+                    break;
+                case "start": {
+                    console.log("starting incoming call - create webrtc session");
+                    if (activeCall)
+                        endCall();
+                    const { media, useWorker, iceServers, relay } = command;
+                    const encryption = supportsInsertableStreams(useWorker);
+                    const aesKey = encryption ? command.aesKey : undefined;
+                    activeCall = await initializeCall(getCallConfig(encryption && !!aesKey, iceServers, relay), media, aesKey, useWorker);
+                    const pc = activeCall.connection;
+                    const offer = await pc.createOffer();
+                    await pc.setLocalDescription(offer);
+                    // for debugging, returning the command for callee to use
+                    // resp = {
+                    //   type: "offer",
+                    //   offer: serialize(offer),
+                    //   iceCandidates: await activeCall.iceCandidates,
+                    //   capabilities: {encryption},
+                    //   media,
+                    //   iceServers,
+                    //   relay,
+                    //   aesKey,
+                    //   useWorker,
+                    // }
+                    resp = {
+                        type: "offer",
+                        offer: serialize(offer),
+                        iceCandidates: await activeCall.iceCandidates,
+                        capabilities: { encryption },
+                    };
+                    break;
+                }
+                case "offer":
+                    if (activeCall) {
+                        resp = { type: "error", message: "accept: call already started" };
+                    }
+                    else if (!supportsInsertableStreams(command.useWorker) && command.aesKey) {
+                        resp = { type: "error", message: "accept: encryption is not supported" };
+                    }
+                    else {
+                        const offer = parse(command.offer);
+                        const remoteIceCandidates = parse(command.iceCandidates);
+                        const { media, aesKey, useWorker, iceServers, relay } = command;
+                        activeCall = await initializeCall(getCallConfig(!!aesKey, iceServers, relay), media, aesKey, useWorker);
+                        const pc = activeCall.connection;
+                        await pc.setRemoteDescription(new RTCSessionDescription(offer));
+                        const answer = await pc.createAnswer();
+                        await pc.setLocalDescription(answer);
+                        addIceCandidates(pc, remoteIceCandidates);
+                        // same as command for caller to use
+                        resp = {
+                            type: "answer",
+                            answer: serialize(answer),
+                            iceCandidates: await activeCall.iceCandidates,
+                        };
+                    }
+                    break;
+                case "answer":
+                    if (!pc) {
+                        resp = { type: "error", message: "answer: call not started" };
+                    }
+                    else if (!pc.localDescription) {
+                        resp = { type: "error", message: "answer: local description is not set" };
+                    }
+                    else if (pc.currentRemoteDescription) {
+                        resp = { type: "error", message: "answer: remote description already set" };
+                    }
+                    else {
+                        const answer = parse(command.answer);
+                        const remoteIceCandidates = parse(command.iceCandidates);
+                        await pc.setRemoteDescription(new RTCSessionDescription(answer));
+                        addIceCandidates(pc, remoteIceCandidates);
+                        resp = { type: "ok" };
+                    }
+                    break;
+                case "ice":
+                    if (pc) {
+                        const remoteIceCandidates = parse(command.iceCandidates);
+                        addIceCandidates(pc, remoteIceCandidates);
+                        resp = { type: "ok" };
+                    }
+                    else {
+                        resp = { type: "error", message: "ice: call not started" };
+                    }
+                    break;
+                case "media":
+                    if (!activeCall) {
+                        resp = { type: "error", message: "media: call not started" };
+                    }
+                    else if (activeCall.localMedia == CallMediaType.Audio && command.media == CallMediaType.Video) {
+                        resp = { type: "error", message: "media: no video" };
+                    }
+                    else {
+                        enableMedia(activeCall.localStream, command.media, command.enable);
+                        resp = { type: "ok" };
+                    }
+                    break;
+                case "camera":
+                    if (!activeCall || !pc) {
+                        resp = { type: "error", message: "camera: call not started" };
+                    }
+                    else {
+                        await replaceMedia(activeCall, command.camera);
+                        resp = { type: "ok" };
+                    }
+                    break;
+                case "end":
+                    endCall();
+                    resp = { type: "ok" };
+                    break;
+                default:
+                    resp = { type: "error", message: "unknown command" };
+                    break;
+            }
+        }
+        catch (e) {
+            resp = { type: "error", message: `${command.type}: ${e.message}` };
+        }
+        const apiResp = { corrId, resp, command };
+        sendMessageToNative(apiResp);
+        return apiResp;
+    }
+    function endCall() {
+        var _a;
+        try {
+            (_a = activeCall === null || activeCall === void 0 ? void 0 : activeCall.connection) === null || _a === void 0 ? void 0 : _a.close();
+        }
+        catch (e) {
+            console.log(e);
+        }
+        activeCall = undefined;
+        resetVideoElements();
+    }
+    function addIceCandidates(conn, iceCandidates) {
+        for (const c of iceCandidates) {
+            conn.addIceCandidate(new RTCIceCandidate(c));
+        }
+    }
+    async function setupMediaStreams(call) {
+        const videos = getVideoElements();
+        if (!videos)
+            throw Error("no video elements");
+        await setupEncryptionWorker(call);
+        setupLocalStream(call);
+        setupRemoteStream(call);
+        setupCodecPreferences(call);
+        // setupVideoElement(videos.local)
+        // setupVideoElement(videos.remote)
+        videos.local.srcObject = call.localStream;
+        videos.remote.srcObject = call.remoteStream;
+    }
+    async function setupEncryptionWorker(call) {
+        if (call.aesKey) {
+            if (!call.key)
+                call.key = await callCrypto.decodeAesKey(call.aesKey);
+            if (call.useWorker && !call.worker) {
+                const workerCode = `const callCrypto = (${callCryptoFunction.toString()})(); (${workerFunction.toString()})()`;
+                call.worker = new Worker(URL.createObjectURL(new Blob([workerCode], { type: "text/javascript" })));
+                call.worker.onerror = ({ error, filename, lineno, message }) => console.log(JSON.stringify({ error, filename, lineno, message }));
+                call.worker.onmessage = ({ data }) => console.log(JSON.stringify({ message: data }));
+            }
+        }
+    }
+    function setupLocalStream(call) {
+        const videos = getVideoElements();
+        if (!videos)
+            throw Error("no video elements");
+        const pc = call.connection;
+        let { localStream } = call;
+        for (const track of localStream.getTracks()) {
+            pc.addTrack(track, localStream);
+        }
+        if (call.aesKey && call.key) {
+            console.log("set up encryption for sending");
+            for (const sender of pc.getSenders()) {
+                setupPeerTransform(TransformOperation.Encrypt, sender, call.worker, call.aesKey, call.key);
+            }
+        }
+    }
+    function setupRemoteStream(call) {
+        // Pull tracks from remote stream as they arrive add them to remoteStream video
+        const pc = call.connection;
+        pc.ontrack = (event) => {
+            try {
+                if (call.aesKey && call.key) {
+                    console.log("set up decryption for receiving");
+                    setupPeerTransform(TransformOperation.Decrypt, event.receiver, call.worker, call.aesKey, call.key);
+                }
+                for (const stream of event.streams) {
+                    for (const track of stream.getTracks()) {
+                        call.remoteStream.addTrack(track);
+                    }
+                }
+                console.log(`ontrack success`);
+            }
+            catch (e) {
+                console.log(`ontrack error: ${e.message}`);
+            }
+        };
+    }
+    function setupCodecPreferences(call) {
+        // We assume VP8 encoding in the decode/encode stages to get the initial
+        // bytes to pass as plaintext so we enforce that here.
+        // VP8 is supported by all supports of webrtc.
+        // Use of VP8 by default may also reduce depacketisation issues.
+        // We do not encrypt the first couple of bytes of the payload so that the
+        // video elements can work by determining video keyframes and the opus mode
+        // being used. This appears to be necessary for any video feed at all.
+        // For VP8 this is the content described in
+        //   https://tools.ietf.org/html/rfc6386#section-9.1
+        // which is 10 bytes for key frames and 3 bytes for delta frames.
+        // For opus (where encodedFrame.type is not set) this is the TOC byte from
+        //   https://tools.ietf.org/html/rfc6716#section-3.1
+        var _a;
+        const capabilities = RTCRtpSender.getCapabilities("video");
+        if (capabilities) {
+            const { codecs } = capabilities;
+            const selectedCodecIndex = codecs.findIndex((c) => c.mimeType === "video/VP8");
+            const selectedCodec = codecs[selectedCodecIndex];
+            codecs.splice(selectedCodecIndex, 1);
+            codecs.unshift(selectedCodec);
+            for (const t of call.connection.getTransceivers()) {
+                if (((_a = t.sender.track) === null || _a === void 0 ? void 0 : _a.kind) === "video") {
+                    t.setCodecPreferences(codecs);
+                }
+            }
+        }
+    }
+    async function replaceMedia(call, camera) {
+        const videos = getVideoElements();
+        if (!videos)
+            throw Error("no video elements");
+        const pc = call.connection;
+        for (const t of call.localStream.getTracks())
+            t.stop();
+        call.localCamera = camera;
+        const localStream = await getLocalMediaStream(call.localMedia, camera);
+        replaceTracks(pc, localStream.getVideoTracks());
+        replaceTracks(pc, localStream.getAudioTracks());
+        call.localStream = localStream;
+        videos.local.srcObject = localStream;
+    }
+    function replaceTracks(pc, tracks) {
+        if (!tracks.length)
+            return;
+        const sender = pc.getSenders().find((s) => { var _a; return ((_a = s.track) === null || _a === void 0 ? void 0 : _a.kind) === tracks[0].kind; });
+        if (sender)
+            for (const t of tracks)
+                sender.replaceTrack(t);
+    }
+    function setupPeerTransform(operation, peer, worker, aesKey, key) {
+        if (worker && "RTCRtpScriptTransform" in window) {
+            console.log(`${operation} with worker & RTCRtpScriptTransform`);
+            peer.transform = new RTCRtpScriptTransform(worker, { operation, aesKey });
+        }
+        else if ("createEncodedStreams" in peer) {
+            const { readable, writable } = peer.createEncodedStreams();
+            if (worker) {
+                console.log(`${operation} with worker`);
+                worker.postMessage({ operation, readable, writable, aesKey }, [readable, writable]);
+            }
+            else {
+                console.log(`${operation} without worker`);
+                const transform = callCrypto.transformFrame[operation](key);
+                readable.pipeThrough(new TransformStream({ transform })).pipeTo(writable);
+            }
+        }
+        else {
+            console.log(`no ${operation}`);
+        }
+    }
+    function getLocalMediaStream(mediaType, facingMode) {
+        const constraints = callMediaConstraints(mediaType, facingMode);
+        return navigator.mediaDevices.getUserMedia(constraints);
+    }
+    function callMediaConstraints(mediaType, facingMode) {
+        switch (mediaType) {
+            case CallMediaType.Audio:
+                return { audio: true, video: false };
+            case CallMediaType.Video:
+                return {
+                    audio: true,
+                    video: {
+                        frameRate: 24,
+                        width: {
+                            min: 480,
+                            ideal: 720,
+                            max: 1280,
+                        },
+                        aspectRatio: 1.33,
+                        facingMode,
+                    },
+                };
+        }
+    }
+    function supportsInsertableStreams(useWorker) {
+        return (("createEncodedStreams" in RTCRtpSender.prototype && "createEncodedStreams" in RTCRtpReceiver.prototype) ||
+            (!!useWorker && "RTCRtpScriptTransform" in window));
+    }
+    function resetVideoElements() {
+        const videos = getVideoElements();
+        if (!videos)
+            return;
+        videos.local.srcObject = null;
+        videos.remote.srcObject = null;
+    }
+    function getVideoElements() {
+        const local = document.getElementById("local-video-stream");
+        const remote = document.getElementById("remote-video-stream");
+        if (!(local && remote && local instanceof HTMLMediaElement && remote instanceof HTMLMediaElement))
+            return;
+        return { local, remote };
+    }
+    // function setupVideoElement(video: HTMLElement) {
+    //   // TODO use display: none
+    //   video.style.opacity = "0"
+    //   video.onplaying = () => {
+    //     video.style.opacity = "1"
+    //   }
+    // }
+    function enableMedia(s, media, enable) {
+        const tracks = media == CallMediaType.Video ? s.getVideoTracks() : s.getAudioTracks();
+        for (const t of tracks)
+            t.enabled = enable;
+    }
+    return processCommand;
+})();
+// Cryptography function - it is loaded both in the main window and in worker context (if the worker is used)
+function callCryptoFunction() {
+    const initialPlainTextRequired = {
+        key: 10,
+        delta: 3,
+    };
+    const IV_LENGTH = 12;
+    function encryptFrame(key) {
+        return async (frame, controller) => {
+            const data = new Uint8Array(frame.data);
+            const n = initialPlainTextRequired[frame.type] || 1;
+            const iv = randomIV();
+            const initial = data.subarray(0, n);
+            const plaintext = data.subarray(n, data.byteLength);
+            try {
+                const ciphertext = new Uint8Array(plaintext.length ? await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext) : 0);
+                frame.data = concatN(initial, ciphertext, iv).buffer;
+                controller.enqueue(frame);
+            }
+            catch (e) {
+                console.log(`encryption error ${e}`);
+                throw e;
+            }
+        };
+    }
+    function decryptFrame(key) {
+        return async (frame, controller) => {
+            const data = new Uint8Array(frame.data);
+            const n = initialPlainTextRequired[frame.type] || 1;
+            const initial = data.subarray(0, n);
+            const ciphertext = data.subarray(n, data.byteLength - IV_LENGTH);
+            const iv = data.subarray(data.byteLength - IV_LENGTH, data.byteLength);
+            try {
+                const plaintext = new Uint8Array(ciphertext.length ? await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext) : 0);
+                frame.data = concatN(initial, plaintext).buffer;
+                controller.enqueue(frame);
+            }
+            catch (e) {
+                console.log(`decryption error ${e}`);
+                throw e;
+            }
+        };
+    }
+    function decodeAesKey(aesKey) {
+        const keyData = callCrypto.decodeBase64url(callCrypto.encodeAscii(aesKey));
+        return crypto.subtle.importKey("raw", keyData, { name: "AES-GCM", length: 256 }, true, ["encrypt", "decrypt"]);
+    }
+    function concatN(...bs) {
+        const a = new Uint8Array(bs.reduce((size, b) => size + b.byteLength, 0));
+        bs.reduce((offset, b) => {
+            a.set(b, offset);
+            return offset + b.byteLength;
+        }, 0);
+        return a;
+    }
+    function randomIV() {
+        return crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+    }
+    const base64urlChars = new Uint8Array("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".split("").map((c) => c.charCodeAt(0)));
+    const base64urlLookup = new Array(256);
+    base64urlChars.forEach((c, i) => (base64urlLookup[c] = i));
+    const char_equal = "=".charCodeAt(0);
+    function encodeAscii(s) {
+        const a = new Uint8Array(s.length);
+        let i = s.length;
+        while (i--)
+            a[i] = s.charCodeAt(i);
+        return a;
+    }
+    function decodeAscii(a) {
+        let s = "";
+        for (let i = 0; i < a.length; i++)
+            s += String.fromCharCode(a[i]);
+        return s;
+    }
+    function encodeBase64url(a) {
+        const len = a.length;
+        const b64len = Math.ceil(len / 3) * 4;
+        const b64 = new Uint8Array(b64len);
+        let j = 0;
+        for (let i = 0; i < len; i += 3) {
+            b64[j++] = base64urlChars[a[i] >> 2];
+            b64[j++] = base64urlChars[((a[i] & 3) << 4) | (a[i + 1] >> 4)];
+            b64[j++] = base64urlChars[((a[i + 1] & 15) << 2) | (a[i + 2] >> 6)];
+            b64[j++] = base64urlChars[a[i + 2] & 63];
+        }
+        if (len % 3)
+            b64[b64len - 1] = char_equal;
+        if (len % 3 === 1)
+            b64[b64len - 2] = char_equal;
+        return b64;
+    }
+    function decodeBase64url(b64) {
+        let len = b64.length;
+        if (len % 4)
+            return;
+        let bLen = (len * 3) / 4;
+        if (b64[len - 1] === char_equal) {
+            len--;
+            bLen--;
+            if (b64[len - 1] === char_equal) {
+                len--;
+                bLen--;
+            }
+        }
+        const bytes = new Uint8Array(bLen);
+        let i = 0;
+        let pos = 0;
+        while (i < len) {
+            const enc1 = base64urlLookup[b64[i++]];
+            const enc2 = i < len ? base64urlLookup[b64[i++]] : 0;
+            const enc3 = i < len ? base64urlLookup[b64[i++]] : 0;
+            const enc4 = i < len ? base64urlLookup[b64[i++]] : 0;
+            if (enc1 === undefined || enc2 === undefined || enc3 === undefined || enc4 === undefined)
+                return;
+            bytes[pos++] = (enc1 << 2) | (enc2 >> 4);
+            bytes[pos++] = ((enc2 & 15) << 4) | (enc3 >> 2);
+            bytes[pos++] = ((enc3 & 3) << 6) | (enc4 & 63);
+        }
+        return bytes;
+    }
+    return {
+        transformFrame: { encrypt: encryptFrame, decrypt: decryptFrame },
+        decodeAesKey,
+        encodeAscii,
+        decodeAscii,
+        encodeBase64url,
+        decodeBase64url,
+    };
+}
+// If the worker is used for decryption, this function code (as string) is used to load the worker via Blob
+// We have to use worker optionally, as it crashes in Android web view, regardless of how it is loaded
+function workerFunction() {
+    // encryption with createEncodedStreams support
+    self.addEventListener("message", async ({ data }) => {
+        await setupTransform(data);
+    });
+    // encryption using RTCRtpScriptTransform.
+    if ("RTCTransformEvent" in self) {
+        self.addEventListener("rtctransform", async ({ transformer }) => {
+            try {
+                const { operation, aesKey } = transformer.options;
+                const { readable, writable } = transformer;
+                await setupTransform({ operation, aesKey, readable, writable });
+                self.postMessage({ result: "setupTransform success" });
+            }
+            catch (e) {
+                self.postMessage({ message: `setupTransform error: ${e.message}` });
+            }
+        });
+    }
+    async function setupTransform({ operation, aesKey, readable, writable }) {
+        const key = await callCrypto.decodeAesKey(aesKey);
+        const transform = callCrypto.transformFrame[operation](key);
+        readable.pipeThrough(new TransformStream({ transform })).pipeTo(writable);
+    }
+}
+//# sourceMappingURL=call.js.map

apps/android/app/src/main/assets/www/lz-string.min.js

@@ -0,0 +1 @@
+var LZString=function(){function o(o,r){if(!t[o]){t[o]={};for(var n=0;n<o.length;n++)t[o][o.charAt(n)]=n}return t[o][r]}var r=String.fromCharCode,n="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$",t={},i={compressToBase64:function(o){if(null==o)return"";var r=i._compress(o,6,function(o){return n.charAt(o)});switch(r.length%4){default:case 0:return r;case 1:return r+"===";case 2:return r+"==";case 3:return r+"="}},decompressFromBase64:function(r){return null==r?"":""==r?null:i._decompress(r.length,32,function(e){return o(n,r.charAt(e))})},compressToUTF16:function(o){return null==o?"":i._compress(o,15,function(o){return r(o+32)})+" "},decompressFromUTF16:function(o){return null==o?"":""==o?null:i._decompress(o.length,16384,function(r){return o.charCodeAt(r)-32})},compressToUint8Array:function(o){for(var r=i.compress(o),n=new Uint8Array(2*r.length),e=0,t=r.length;t>e;e++){var s=r.charCodeAt(e);n[2*e]=s>>>8,n[2*e+1]=s%256}return n},decompressFromUint8Array:function(o){if(null===o||void 0===o)return i.decompress(o);for(var n=new Array(o.length/2),e=0,t=n.length;t>e;e++)n[e]=256*o[2*e]+o[2*e+1];var s=[];return n.forEach(function(o){s.push(r(o))}),i.decompress(s.join(""))},compressToEncodedURIComponent:function(o){return null==o?"":i._compress(o,6,function(o){return e.charAt(o)})},decompressFromEncodedURIComponent:function(r){return null==r?"":""==r?null:(r=r.replace(/ /g,"+"),i._decompress(r.length,32,function(n){return o(e,r.charAt(n))}))},compress:function(o){return i._compress(o,16,function(o){return r(o)})},_compress:function(o,r,n){if(null==o)return"";var e,t,i,s={},p={},u="",c="",a="",l=2,f=3,h=2,d=[],m=0,v=0;for(i=0;i<o.length;i+=1)if(u=o.charAt(i),Object.prototype.hasOwnProperty.call(s,u)||(s[u]=f++,p[u]=!0),c=a+u,Object.prototype.hasOwnProperty.call(s,c))a=c;else{if(Object.prototype.hasOwnProperty.call(p,a)){if(a.charCodeAt(0)<256){for(e=0;h>e;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++),s[c]=f++,a=String(u)}if(""!==a){if(Object.prototype.hasOwnProperty.call(p,a)){if(a.charCodeAt(0)<256){for(e=0;h>e;e++)m<<=1,v==r-1?(v=0,d.push(n(m)),m=0):v++;for(t=a.charCodeAt(0),e=0;8>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}else{for(t=1,e=0;h>e;e++)m=m<<1|t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t=0;for(t=a.charCodeAt(0),e=0;16>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1}l--,0==l&&(l=Math.pow(2,h),h++),delete p[a]}else for(t=s[a],e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;l--,0==l&&(l=Math.pow(2,h),h++)}for(t=2,e=0;h>e;e++)m=m<<1|1&t,v==r-1?(v=0,d.push(n(m)),m=0):v++,t>>=1;for(;;){if(m<<=1,v==r-1){d.push(n(m));break}v++}return d.join("")},decompress:function(o){return null==o?"":""==o?null:i._decompress(o.length,32768,function(r){return o.charCodeAt(r)})},_decompress:function(o,n,e){var t,i,s,p,u,c,a,l,f=[],h=4,d=4,m=3,v="",w=[],A={val:e(0),position:n,index:1};for(i=0;3>i;i+=1)f[i]=i;for(p=0,c=Math.pow(2,2),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(t=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;l=r(p);break;case 2:return""}for(f[3]=l,s=l,w.push(l);;){if(A.index>o)return"";for(p=0,c=Math.pow(2,m),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;switch(l=p){case 0:for(p=0,c=Math.pow(2,8),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 1:for(p=0,c=Math.pow(2,16),a=1;a!=c;)u=A.val&A.position,A.position>>=1,0==A.position&&(A.position=n,A.val=e(A.index++)),p|=(u>0?1:0)*a,a<<=1;f[d++]=r(p),l=d-1,h--;break;case 2:return w.join("")}if(0==h&&(h=Math.pow(2,m),m++),f[l])v=f[l];else{if(l!==d)return null;v=s+s.charAt(0)}w.push(v),f[d++]=s+v.charAt(0),h--,s=v,0==h&&(h=Math.pow(2,m),m++)}}};return i}();"function"==typeof define&&define.amd?define(function(){return LZString}):"undefined"!=typeof module&&null!=module&&(module.exports=LZString);

apps/android/app/src/main/assets/www/style.css

@@ -0,0 +1,41 @@
+html,
+body {
+  padding: 0;
+  margin: 0;
+  background-color: black;
+}
+
+#remote-video-stream {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+
+#local-video-stream {
+  position: absolute;
+  width: 30%;
+  max-width: 30%;
+  object-fit: cover;
+  margin: 16px;
+  border-radius: 16px;
+  top: 0;
+  right: 0;
+}
+
+*::-webkit-media-controls {
+  display: none !important;
+  -webkit-appearance: none !important;
+}
+*::-webkit-media-controls-panel {
+  display: none !important;
+  -webkit-appearance: none !important;
+}
+*::-webkit-media-controls-play-button {
+  display: none !important;
+  -webkit-appearance: none !important;
+}
+*::-webkit-media-controls-start-playback-button {
+  display: none !important;
+  -webkit-appearance: none !important;
+}

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

@@ -24,9 +24,11 @@ Java_chat_simplex_app_SimplexAppKt_initHS(__unused JNIEnv *env, __unused jclass
 // from simplex-chat
 typedef void* chat_ctrl;
 
-extern chat_ctrl chat_init(const char * path);
+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);
+extern char *chat_recv_msg_wait(chat_ctrl ctrl, const int wait);
+extern char *chat_parse_markdown(const char *str);
 
 JNIEXPORT jlong JNICALL
 Java_chat_simplex_app_SimplexAppKt_chatInit(JNIEnv *env, __unused jclass clazz, jstring datadir) {
@@ -48,3 +50,16 @@ 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;
+}

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

@@ -4,42 +4,54 @@ import android.app.Application
 import android.content.Intent
 import android.net.Uri
 import android.os.Bundle
+import android.os.SystemClock.elapsedRealtime
 import android.util.Log
-import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.viewModels
 import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Replay
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.lifecycle.AndroidViewModel
+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
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.SplashView
-import chat.simplex.app.views.WelcomeView
+import chat.simplex.app.views.call.ActiveCallView
+import chat.simplex.app.views.call.IncomingCallAlertView
 import chat.simplex.app.views.chat.ChatView
 import chat.simplex.app.views.chatlist.ChatListView
 import chat.simplex.app.views.chatlist.openChat
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.withApi
-import chat.simplex.app.views.newchat.*
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.newchat.connectViaUri
+import chat.simplex.app.views.newchat.withUriAction
+import chat.simplex.app.views.onboarding.*
+import kotlinx.coroutines.delay
 import java.util.concurrent.TimeUnit
 
-//import kotlinx.serialization.decodeFromString
-
-class MainActivity: ComponentActivity() {
+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)
-//    testJson()
-    processIntent(intent, vm.chatModel)
+    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+    // testJson()
+    val m = vm.chatModel
+    processNotificationIntent(intent, m)
     setContent {
       SimpleXTheme {
         Surface(
@@ -47,29 +59,152 @@ class MainActivity: ComponentActivity() {
             .background(MaterialTheme.colors.background)
             .fillMaxSize()
         ) {
-          MainPage(vm.chatModel)
+          MainPage(
+            m,
+            userAuthorized,
+            laFailed,
+            ::runAuthenticate,
+            ::setPerformLA,
+            showLANotice = { m.controller.showLANotice(this) }
+          )
         }
       }
     }
-    schedulePeriodicServiceRestartWorker()
+    SimplexApp.context.schedulePeriodicServiceRestartWorker()
   }
 
-  private fun schedulePeriodicServiceRestartWorker() {
-    val workerVersion = chatController.getAutoRestartWorkerVersion()
-    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.setAutoRestartWorkerVersion(SimplexService.SERVICE_START_WORKER_VERSION)
-      ExistingPeriodicWorkPolicy.REPLACE
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    processIntent(intent, vm.chatModel)
+  }
+
+  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
+    withApi {
+      when (event) {
+        Lifecycle.Event.ON_STOP -> {
+          enteredBackground.value = elapsedRealtime()
+        }
+        Lifecycle.Event.ON_START -> {
+          val enteredBackgroundVal = enteredBackground.value
+          if (enteredBackgroundVal == null || elapsedRealtime() - enteredBackgroundVal >= 30 * 1e+3) {
+            runAuthenticate()
+          }
+        }
+        else -> {}
+      }
     }
-    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 runAuthenticate() {
+    val m = vm.chatModel
+    if (!m.controller.appPrefs.performLA.get()) {
+      userAuthorized.value = true
+    } else {
+      userAuthorized.value = false
+      ModalManager.shared.closeModals()
+      authenticate(
+        generalGetString(R.string.auth_unlock),
+        generalGetString(R.string.auth_log_in_using_credential),
+        this@MainActivity,
+        completed = { laResult ->
+          when (laResult) {
+            LAResult.Success -> {
+              userAuthorized.value = true
+            }
+            is LAResult.Error -> {
+              laFailed.value = true
+              laErrorToast(applicationContext, laResult.errString)
+            }
+            LAResult.Failed -> {
+              laFailed.value = true
+              laFailedToast(applicationContext)
+            }
+            LAResult.Unavailable -> {
+              userAuthorized.value = true
+              m.performLA.value = false
+              m.controller.appPrefs.performLA.set(false)
+              laUnavailableTurningOffAlert()
+            }
+          }
+        }
+      )
+    }
+  }
+
+  private fun setPerformLA(on: Boolean) {
+    vm.chatModel.controller.appPrefs.laNoticeShown.set(true)
+    if (on) {
+      enableLA()
+    } else {
+      disableLA()
+    }
+  }
+
+  private fun enableLA() {
+    val m = vm.chatModel
+    authenticate(
+      generalGetString(R.string.auth_enable_simplex_lock),
+      generalGetString(R.string.auth_confirm_credential),
+      this@MainActivity,
+      completed = { laResult ->
+        val prefPerformLA = m.controller.appPrefs.performLA
+        when (laResult) {
+          LAResult.Success -> {
+            m.performLA.value = true
+            prefPerformLA.set(true)
+            laTurnedOnAlert()
+          }
+          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
+            prefPerformLA.set(false)
+            laUnavailableInstructionAlert()
+          }
+        }
+      }
+    )
+  }
+
+  private fun disableLA() {
+    val m = vm.chatModel
+    authenticate(
+      generalGetString(R.string.auth_disable_simplex_lock),
+      generalGetString(R.string.auth_confirm_credential),
+      this@MainActivity,
+      completed = { laResult ->
+        val prefPerformLA = m.controller.appPrefs.performLA
+        when (laResult) {
+          LAResult.Success -> {
+            m.performLA.value = false
+            prefPerformLA.set(false)
+          }
+          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
+            prefPerformLA.set(false)
+            laUnavailableTurningOffAlert()
+          }
+        }
+      }
+    )
   }
 }
 
@@ -79,30 +214,132 @@ class SimplexViewModel(application: Application): AndroidViewModel(application)
 }
 
 @Composable
-fun MainPage(chatModel: ChatModel) {
+fun MainPage(
+  chatModel: ChatModel,
+  userAuthorized: MutableState<Boolean?>,
+  laFailed: MutableState<Boolean>,
+  runAuthenticate: () -> Unit,
+  setPerformLA: (Boolean) -> Unit,
+  showLANotice: () -> Unit
+) {
+  // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
+  var chatsAccessAuthorized by remember { mutableStateOf(false) }
+  LaunchedEffect(userAuthorized.value) {
+    if (chatModel.controller.appPrefs.performLA.get()) {
+      delay(500L)
+    }
+    chatsAccessAuthorized = userAuthorized.value == true
+  }
+  var showAdvertiseLAAlert by remember { mutableStateOf(false) }
+  LaunchedEffect(showAdvertiseLAAlert) {
+    if (
+      !chatModel.controller.appPrefs.laNoticeShown.get()
+      && showAdvertiseLAAlert
+      && chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete
+      && chatModel.chats.isNotEmpty()
+      && chatModel.activeCallInvitation.value == null
+    ) {
+      showLANotice()
+    }
+  }
+  LaunchedEffect(chatModel.showAdvertiseLAUnavailableAlert.value) {
+    if (chatModel.showAdvertiseLAUnavailableAlert.value) {
+      laUnavailableInstructionAlert()
+    }
+  }
+  LaunchedEffect(chatModel.clearOverlays.value) {
+    if (chatModel.clearOverlays.value) {
+      ModalManager.shared.closeModals()
+      chatModel.clearOverlays.value = false
+    }
+  }
+
+  @Composable
+  fun retryAuthView() {
+    Box(
+      Modifier.fillMaxSize(),
+      contentAlignment = Alignment.Center
+    ) {
+      SimpleButton(
+        stringResource(R.string.auth_retry),
+        icon = Icons.Outlined.Replay,
+        click = {
+          laFailed.value = false
+          runAuthenticate()
+        }
+      )
+    }
+  }
+
   Box {
-    when (chatModel.userCreated.value) {
-      null -> SplashView()
-      false -> WelcomeView(chatModel)
-      true ->
-        if (chatModel.chatId.value == null) ChatListView(chatModel)
-        else ChatView(chatModel)
+    val onboarding = chatModel.onboardingStage.value
+    val userCreated = chatModel.userCreated.value
+    when {
+      onboarding == null || userCreated == null -> SplashView()
+      !chatsAccessAuthorized -> {
+        if (chatModel.controller.appPrefs.performLA.get() && laFailed.value) {
+          retryAuthView()
+        } else {
+          SplashView()
+        }
+      }
+      onboarding == OnboardingStage.OnboardingComplete && userCreated -> {
+        Box {
+          if (chatModel.showCallView.value) ActiveCallView(chatModel)
+          else {
+            showAdvertiseLAAlert = true
+            val stopped = chatModel.chatRunning.value == false
+            if (chatModel.chatId.value == null) ChatListView(chatModel, setPerformLA, stopped)
+            else ChatView(chatModel)
+          }
+        }
+      }
+      onboarding == OnboardingStage.Step1_SimpleXInfo ->
+        Box(Modifier.padding(horizontal = 20.dp)) {
+          SimpleXInfo(chatModel, onboarding = true)
+        }
+      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
     }
     ModalManager.shared.showInView()
+    val invitation = chatModel.activeCallInvitation.value
+    if (invitation != null) IncomingCallAlertView(invitation, chatModel)
     AlertManager.shared.showInView()
   }
 }
 
+fun processNotificationIntent(intent: Intent?, chatModel: ChatModel) {
+  when (intent?.action) {
+    NtfManager.OpenChatAction -> {
+      val chatId = intent.getStringExtra("chatId")
+      Log.d(TAG, "processNotificationIntent: OpenChatAction $chatId")
+      if (chatId != null) {
+        val cInfo = chatModel.getChat(chatId)?.chatInfo
+        chatModel.clearOverlays.value = true
+        if (cInfo != null) withApi { openChat(cInfo, chatModel) }
+      }
+    }
+    NtfManager.ShowChatsAction -> {
+      Log.d(TAG, "processNotificationIntent: ShowChatsAction")
+      chatModel.chatId.value = null
+      chatModel.clearOverlays.value = true
+    }
+    NtfManager.AcceptCallAction -> {
+      val chatId = intent.getStringExtra("chatId")
+      if (chatId == null || chatId == "") return
+      Log.d(TAG, "processNotificationIntent: AcceptCallAction $chatId")
+      chatModel.clearOverlays.value = true
+      val invitation = chatModel.callInvitations[chatId]
+      if (invitation == null) {
+        AlertManager.shared.showAlertMsg(generalGetString(R.string.call_already_ended))
+      } else {
+        chatModel.callManager.acceptIncomingCall(invitation = invitation)
+      }
+    }
+  }
+}
+
 fun processIntent(intent: Intent?, chatModel: ChatModel) {
   when (intent?.action) {
-    NtfManager.OpenChatAction -> {
-      val chatId = intent.getStringExtra("chatId")
-      Log.d(TAG, "processIntent: OpenChatAction $chatId")
-      if (chatId != null) {
-        val cInfo = chatModel.getChat(chatId)?.chatInfo
-        if (cInfo != null) withApi { openChat(chatModel, cInfo) }
-      }
-    }
     "android.intent.action.VIEW" -> {
       val uri = intent.data
       if (uri != null) connectIfOpenedViaUri(uri, chatModel)
@@ -117,10 +354,18 @@ fun connectIfOpenedViaUri(uri: Uri, chatModel: ChatModel) {
     chatModel.appOpenUrl.value = uri
   } else {
     withUriAction(uri) { action ->
+      val title = when (action) {
+        "contact" -> generalGetString(R.string.connect_via_contact_link)
+        "invitation" -> generalGetString(R.string.connect_via_invitation_link)
+        else -> {
+          Log.e(TAG, "URI has unexpected action. Alert shown.")
+          action
+        }
+      }
       AlertManager.shared.showAlertMsg(
-        title = "Connect via $action link?",
-        text = "Your profile will be sent to the contact that you received this link from.",
-        confirmText = "Connect",
+        title = title,
+        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")
@@ -131,7 +376,6 @@ fun connectIfOpenedViaUri(uri: Uri, chatModel: ChatModel) {
     }
   }
 }
-
 //fun testJson() {
 //  val str: String = """
 //  """.trimIndent()

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

@@ -4,12 +4,17 @@ import android.app.Application
 import android.net.LocalServerSocket
 import android.util.Log
 import androidx.lifecycle.*
+import androidx.work.*
 import chat.simplex.app.model.*
+import chat.simplex.app.views.helpers.getFilesDirectory
 import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.onboarding.OnboardingStage
+import kotlinx.coroutines.*
 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"
@@ -22,13 +27,15 @@ external fun pipeStdOutToSocket(socketName: String) : Int
 // SimpleX API
 typealias ChatCtrl = Long
 external fun chatInit(path: String): ChatCtrl
-external fun chatSendCmd(ctrl: ChatCtrl, msg: String) : String
-external fun chatRecvMsg(ctrl: ChatCtrl) : String
+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
 
 class SimplexApp: Application(), LifecycleEventObserver {
   val chatController: ChatController by lazy {
-    val ctrl = chatInit(applicationContext.filesDir.toString())
-    ChatController(ctrl, ntfManager, applicationContext)
+    val ctrl = chatInit(getFilesDirectory(applicationContext))
+    ChatController(ctrl, ntfManager, applicationContext, appPreferences)
   }
 
   val chatModel: ChatModel by lazy {
@@ -36,18 +43,23 @@ class SimplexApp: Application(), LifecycleEventObserver {
   }
 
   private val ntfManager: NtfManager by lazy {
-    NtfManager(applicationContext)
+    NtfManager(applicationContext, appPreferences)
+  }
+
+  private val appPreferences: AppPreferences by lazy {
+    AppPreferences(applicationContext)
   }
 
   override fun onCreate() {
     super.onCreate()
+    context = this
     ProcessLifecycleOwner.get().lifecycle.addObserver(this)
     withApi {
       val user = chatController.apiGetActiveUser()
-      if (user != null) {
+      if (user == null) {
+        chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+      } else {
         chatController.startChat(user)
-        SimplexService.start(applicationContext)
-        chatController.showBackgroundServiceNotice()
       }
     }
   }
@@ -57,17 +69,51 @@ class SimplexApp: Application(), LifecycleEventObserver {
     withApi {
       when (event) {
         Lifecycle.Event.ON_STOP ->
-          if (!chatController.getRunServiceInBackground()) SimplexService.stop(applicationContext)
+          if (!appPreferences.runServiceInBackground.get()) SimplexService.stop(applicationContext)
         Lifecycle.Event.ON_START ->
-          SimplexService.start(applicationContext)
+          if (chatModel.chatRunning.value != false)  SimplexService.start(applicationContext)
+        Lifecycle.Event.ON_RESUME ->
+          if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) {
+            chatController.showBackgroundServiceNoticeIfNeeded()
+          }
+        else -> {}
       }
     }
   }
 
-  companion object {
-    init {
-      val socketName = "local.socket.address.listen.native.cmd2"
+  fun allowToStartServiceAfterAppExit() = with(chatModel.controller) {
+    appPrefs.runServiceInBackground.get() && 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)
+  }
+
+  companion object {
+    lateinit var context: SimplexApp private set
+
+    init {
+      val socketName = BuildConfig.APPLICATION_ID + ".local.socket.address.listen.native.cmd2"
       val s = Semaphore(0)
       thread(name="stdout/stderr pipe") {
         Log.d(TAG, "starting server")
@@ -81,12 +127,13 @@ class SimplexApp: Application(), LifecycleEventObserver {
           val inStream = receiver.inputStream
           val inStreamReader = InputStreamReader(inStream)
           val input = BufferedReader(inStreamReader)
-
-          while(true) {
+          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,12 +2,15 @@ package chat.simplex.app
 
 import android.app.*
 import android.content.*
+import android.content.pm.PackageManager
 import android.os.*
+import android.provider.Settings
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import androidx.work.*
 import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.onboarding.OnboardingStage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
@@ -46,14 +49,16 @@ class SimplexService: Service() {
     val text = getString(R.string.simplex_service_notification_text)
     notificationManager = createNotificationChannel()
     serviceNotification = createNotification(title, text)
-
     startForeground(SIMPLEX_SERVICE_ID, serviceNotification)
   }
 
   override fun onDestroy() {
     Log.d(TAG, "Simplex service destroyed")
     stopService()
-    sendBroadcast(Intent(this, AutoRestartReceiver::class.java)) // Restart if necessary!
+
+    // If private notifications are enabled and battery optimization is disabled, restart the service
+    if (SimplexApp.context.allowToStartServiceAfterAppExit())
+      sendBroadcast(Intent(this, AutoRestartReceiver::class.java))
     super.onDestroy()
   }
 
@@ -65,10 +70,11 @@ class SimplexService: Service() {
     withApi {
       try {
         val user = chatController.apiGetActiveUser()
-        if (user != null) {
+        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 {
@@ -95,7 +101,6 @@ class SimplexService: Service() {
     } catch (e: Exception) {
       Log.d(TAG, "Service stopped without being started: ${e.message}")
     }
-
     isServiceStarted = false
     saveServiceState(this, ServiceState.STOPPED)
   }
@@ -117,15 +122,27 @@ class SimplexService: Service() {
     val pendingIntent: PendingIntent = Intent(this, MainActivity::class.java).let { notificationIntent ->
       PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE)
     }
-    return NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
-      .setSmallIcon(R.drawable.ntf_icon)
+
+    val builder =  NotificationCompat.Builder(this, NOTIFICATION_CHANNEL_ID)
+      .setSmallIcon(R.drawable.ntf_service_icon)
       .setColor(0x88FFFF)
       .setContentTitle(title)
       .setContentText(text)
       .setContentIntent(pendingIntent)
-      .setSound(null)
+      .setSilent(true)
       .setShowWhen(false) // no date/time
-      .build()
+
+    // 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()
   }
 
   override fun onBind(intent: Intent): IBinder? {
@@ -134,6 +151,11 @@ class SimplexService: Service() {
 
   // re-schedules the task when "Clear recent apps" is pressed
   override fun onTaskRemoved(rootIntent: Intent) {
+    // If private notifications aren'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)
     };
@@ -149,6 +171,17 @@ class SimplexService: Service() {
       Log.d(TAG, "StartReceiver: onReceive called")
       scheduleStart(context)
     }
+    companion object {
+      fun toggleReceiver(enable: Boolean) {
+        Log.d(TAG, "StartReceiver: toggleReceiver enabled: $enable")
+        val component = ComponentName(BuildConfig.APPLICATION_ID, StartReceiver::class.java.name)
+        SimplexApp.context.packageManager.setComponentEnabledSetting(
+          component,
+          if (enable) PackageManager.COMPONENT_ENABLED_STATE_ENABLED else PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
+          PackageManager.DONT_KILL_APP
+        )
+      }
+    }
   }
 
   // restart on destruction

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

@@ -1,19 +1,31 @@
 package chat.simplex.app.model
 
 import android.app.*
-import android.content.Context
-import android.content.Intent
+import android.content.*
+import android.graphics.BitmapFactory
+import android.media.AudioAttributes
+import android.net.Uri
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import chat.simplex.app.*
+import chat.simplex.app.views.call.*
+import chat.simplex.app.views.helpers.base64ToBitmap
+import chat.simplex.app.views.helpers.generalGetString
 import kotlinx.datetime.Clock
 
-class NtfManager(val context: Context) {
+class NtfManager(val context: Context, private val appPreferences: AppPreferences) {
   companion object {
     const val MessageChannel: String = "chat.simplex.app.MESSAGE_NOTIFICATION"
     const val MessageGroup: String = "chat.simplex.app.MESSAGE_NOTIFICATION"
     const val OpenChatAction: String = "chat.simplex.app.OPEN_CHAT"
+    const val ShowChatsAction: String = "chat.simplex.app.SHOW_CHATS"
+
+    // DO NOT change notification channel settings / names
+    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION"
+    const val LockScreenCallChannel: String = "chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION"
+    const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
+    const val CallNotificationId: Int = -1
   }
 
   private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -21,29 +33,58 @@ class NtfManager(val context: Context) {
   private val msgNtfTimeoutMs = 30000L
 
   init {
-    manager.createNotificationChannel(NotificationChannel(
-      MessageChannel,
-      "SimpleX Chat messages",
-      NotificationManager.IMPORTANCE_HIGH
-    ))
+    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())
+  }
+
+  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)
+      .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)
+    return callChannel
+  }
+
+  fun cancelNotificationsForChat(chatId: String) {
+    prevNtfTime.remove(chatId)
+    manager.cancel(chatId.hashCode())
+    val msgNtfs = manager.activeNotifications.filter {
+      ntf -> ntf.notification.channelId == MessageChannel
+    }
+    if (msgNtfs.count() == 1) {
+      // Have a group notification with no children so cancel it
+      manager.cancel(0)
+    }
   }
 
   fun notifyMessageReceived(cInfo: ChatInfo, cItem: ChatItem) {
-    Log.d(TAG, "notifyMessageReceived ${cInfo.id}")
+    if (!cInfo.ntfsEnabled) return
+
+    notifyMessageReceived(chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
+  }
+
+  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String) {
+    Log.d(TAG, "notifyMessageReceived $chatId")
     val now = Clock.System.now().toEpochMilliseconds()
-    val recentNotification = (now - prevNtfTime.getOrDefault(cInfo.id, 0) < msgNtfTimeoutMs)
-    prevNtfTime[cInfo.id] = now
+    val recentNotification = (now - prevNtfTime.getOrDefault(chatId, 0) < msgNtfTimeoutMs)
+    prevNtfTime[chatId] = now
 
     val notification = NotificationCompat.Builder(context, MessageChannel)
-      .setContentTitle(cInfo.displayName)
-      .setContentText(hideSecrets(cItem))
+      .setContentTitle(displayName)
+      .setContentText(msgText)
       .setPriority(NotificationCompat.PRIORITY_HIGH)
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
       .setSmallIcon(R.drawable.ntf_icon)
       .setColor(0x88FFFF)
       .setAutoCancel(true)
-      .setContentIntent(getMsgPendingIntent(cInfo))
+      .setContentIntent(chatPendingIntent(OpenChatAction, chatId))
       .setSilent(recentNotification)
       .build()
 
@@ -53,19 +94,70 @@ class NtfManager(val context: Context) {
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
       .setGroupSummary(true)
+      .setContentIntent(chatPendingIntent(ShowChatsAction))
       .build()
 
     with(NotificationManagerCompat.from(context)) {
       // using cInfo.id only shows one notification per chat and updates it when the message arrives
-      notify(cInfo.id.hashCode(), notification)
+      notify(chatId.hashCode(), notification)
       notify(0, summary)
     }
   }
 
-  private fun hideSecrets(cItem: ChatItem): String {
+  fun notifyCallInvitation(invitation: RcvCallInvitation) {
+    if (isAppOnForeground(context)) return
+    val contactId = invitation.contact.id
+    Log.d(TAG, "notifyCallInvitation $contactId")
+    val keyguardManager = getKeyguardManager(context)
+    val image = invitation.contact.image
+    var ntfBuilder =
+      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, 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)
+        NotificationCompat.Builder(context, CallChannel)
+          .setContentIntent(chatPendingIntent(OpenChatAction, invitation.contact.id))
+          .addAction(R.drawable.ntf_icon, generalGetString(R.string.accept), chatPendingIntent(AcceptCallAction, contactId))
+          .setSound(soundUri)
+      }
+    val text = generalGetString(
+      if (invitation.callType.media == 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
+      }
+    )
+    ntfBuilder = ntfBuilder
+      .setContentTitle(invitation.contact.displayName)
+      .setContentText(text)
+      .setPriority(NotificationCompat.PRIORITY_HIGH)
+      .setCategory(NotificationCompat.CATEGORY_CALL)
+      .setSmallIcon(R.drawable.ntf_icon)
+      .setLargeIcon(if (image == null) BitmapFactory.decodeResource(context.resources, R.drawable.icon) else base64ToBitmap(image))
+      .setColor(0x88FFFF)
+      .setAutoCancel(true)
+    with(NotificationManagerCompat.from(context)) {
+      notify(CallNotificationId, ntfBuilder.build())
+    }
+  }
+
+  fun cancelCallNotification() {
+    manager.cancel(CallNotificationId)
+  }
+
+  private fun hideSecrets(cItem: ChatItem) : String {
     val md = cItem.formattedText
     return if (md == null) {
-      cItem.content.text
+      if (cItem.content.text != "") {
+        cItem.content.text
+      } else {
+        cItem.file?.fileName ?: ""
+      }
     } else {
       var res = ""
       for (ft in md) {
@@ -75,13 +167,13 @@ class NtfManager(val context: Context) {
     }
   }
 
-  private fun getMsgPendingIntent(cInfo: ChatInfo) : PendingIntent{
-    Log.d(TAG, "getMsgPendingIntent ${cInfo.id}")
+  private fun chatPendingIntent(intentAction: String, chatId: String? = null): PendingIntent {
+    Log.d(TAG, "chatPendingIntent for $intentAction")
     val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
-    val intent = Intent(context, MainActivity::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)
-      .putExtra("chatId", cInfo.id)
-      .setAction(OpenChatAction)
+      .setAction(intentAction)
+    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,11 +7,22 @@ val Purple500 = Color(0xFF6200EE)
 val Purple700 = Color(0xFF3700B3)
 val Teal200 = Color(0xFF03DAC5)
 val Gray = Color(0x22222222)
-val SimplexBlue = Color(0, 136, 255, 255)
-val SimplexGreen = Color(98, 196, 103, 255)
+val Indigo = Color(0xff330099)
+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)
 val LightGray = Color(241, 242, 246, 255)
 val DarkGray = Color(43, 44, 46, 255)
-val HighOrLowlight = Color(134, 135, 139, 255)
-val ToolbarLight = Color(220, 220, 220, 20)
-val ToolbarDark = Color(80, 80, 80, 20)
+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 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 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

@@ -2,10 +2,16 @@ package chat.simplex.app.ui.theme
 
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material.*
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
+import androidx.compose.ui.graphics.Color
+import kotlinx.coroutines.flow.MutableStateFlow
 
-private val DarkColorPalette = darkColors(
-  primary = SimplexBlue,
+enum class DefaultTheme {
+  SYSTEM, DARK, LIGHT
+}
+
+val DarkColorPalette = darkColors(
+  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = DarkGray,
 //  background = Color.Black,
@@ -13,14 +19,12 @@ private val DarkColorPalette = darkColors(
 //  background = Color(0xFF121212),
 //  surface = Color(0xFF121212),
 //  error = Color(0xFFCF6679),
-//  onPrimary = Color.Black,
-//  onSecondary = Color.Black,
-//  onBackground = Color.White,
-//  onSurface = Color.White,
+  onBackground = Color(0xFFFFFBFA),
+  onSurface = Color(0xFFFFFBFA),
 //  onError: Color = Color.Black,
 )
-private val LightColorPalette = lightColors(
-  primary = SimplexBlue,
+val LightColorPalette = lightColors(
+  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = LightGray,
 //  background = Color.White,
@@ -31,16 +35,28 @@ private val LightColorPalette = lightColors(
 //  onSurface = Color.Black,
 )
 
-@Composable
-fun SimpleXTheme(darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
-  val colors = if (darkTheme) {
-    DarkColorPalette
-  } else {
-    LightColorPalette
-  }
+val CurrentColors: MutableStateFlow<Pair<Colors, DefaultTheme>> = MutableStateFlow(ThemeManager.currentColors(true))
 
+@Composable
+fun isInDarkTheme(): Boolean = !CurrentColors.collectAsState().value.first.isLight
+
+@Composable
+fun SimpleXTheme(darkTheme: Boolean? = null, content: @Composable () -> Unit) {
+  LaunchedEffect(darkTheme) {
+    // For preview
+    if (darkTheme != null)
+      CurrentColors.value = ThemeManager.currentColors(darkTheme)
+  }
+  val systemDark = isSystemInDarkTheme()
+  LaunchedEffect(systemDark) {
+    if (CurrentColors.value.second == DefaultTheme.SYSTEM && CurrentColors.value.first.isLight == systemDark) {
+      // Change active colors from light to dark and back based on system theme
+      ThemeManager.applyTheme(DefaultTheme.SYSTEM.name, systemDark)
+    }
+  }
+  val theme by CurrentColors.collectAsState()
   MaterialTheme(
-    colors = colors,
+    colors = theme.first,
     typography = Typography,
     shapes = Shapes,
     content = content

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

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

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

@@ -13,6 +13,7 @@ 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
@@ -30,7 +31,7 @@ val Typography = Typography(
   h3 = TextStyle(
     fontFamily = Inter,
     fontWeight = FontWeight.Normal,
-    fontSize = 19.sp
+    fontSize = 18.5.sp
   ),
   body1 = TextStyle(
     fontFamily = Inter,

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

@@ -3,12 +3,12 @@ package chat.simplex.app.views
 import android.content.res.Configuration
 import androidx.activity.compose.BackHandler
 import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
 import androidx.compose.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
 import androidx.compose.runtime.*
+import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
@@ -18,32 +18,53 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.chat.SendMsgView
-import chat.simplex.app.views.helpers.CloseSheetBar
-import chat.simplex.app.views.helpers.withApi
-import chat.simplex.app.views.newchat.ModalManager
+import chat.simplex.app.views.chat.*
+import chat.simplex.app.views.helpers.*
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
 import kotlinx.coroutines.launch
 
 @Composable
 fun TerminalView(chatModel: ChatModel, close: () -> Unit) {
+  val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) }
   BackHandler(onBack = close)
-  TerminalLayout(chatModel.terminalItems, close) { cmd ->
-    withApi {
-      // show "in progress"
-      chatModel.controller.sendCmd(CC.Console(cmd))
-      // hide "in progress"
-    }
-  }
+  TerminalLayout(
+    chatModel.terminalItems,
+    composeState,
+    sendCommand = {
+      withApi {
+        // show "in progress"
+        chatModel.controller.sendCmd(CC.Console(composeState.value.message))
+        composeState.value = ComposeState(useLinkPreviews = false)
+        // hide "in progress"
+      }
+    },
+    close
+  )
 }
 
 @Composable
-fun TerminalLayout(terminalItems: List<TerminalItem>, close: () -> Unit, sendCommand: (String) -> Unit) {
+fun TerminalLayout(
+  terminalItems: List<TerminalItem>,
+  composeState: MutableState<ComposeState>,
+  sendCommand: () -> Unit,
+  close: () -> Unit
+) {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+
+  fun onMessageChange(s: String) {
+    composeState.value = composeState.value.copy(message = s)
+  }
+
   ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
     Scaffold(
       topBar = { CloseSheetBar(close) },
-      bottomBar = { SendMsgView(msg = remember { mutableStateOf("") }, sendCommand) },
+      bottomBar = {
+        Box(Modifier.padding(horizontal = 8.dp)) {
+          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
+        }
+      },
       modifier = Modifier.navigationBarsWithImePadding()
     ) { contentPadding ->
       Surface(
@@ -61,6 +82,10 @@ fun TerminalLayout(terminalItems: List<TerminalItem>, close: () -> Unit, sendCom
 @Composable
 fun TerminalLog(terminalItems: List<TerminalItem>) {
   val listState = rememberLazyListState()
+  val keyboardState by getKeyboardState()
+  val ciListState = rememberSaveable(stateSaver = CIListStateSaver) {
+    mutableStateOf(CIListState(false, terminalItems.count(), keyboardState))
+  }
   val scope = rememberCoroutineScope()
   LazyColumn(state = listState) {
     items(terminalItems) { item ->
@@ -80,8 +105,9 @@ fun TerminalLog(terminalItems: List<TerminalItem>) {
       )
     }
     val len = terminalItems.count()
-    if (len > 1) {
+    if (len > 1 && (keyboardState != ciListState.value.keyboardState || !ciListState.value.scrolled || len != ciListState.value.itemCount)) {
       scope.launch {
+        ciListState.value = CIListState(true, len, keyboardState)
         listState.animateScrollToItem(len - 1)
       }
     }
@@ -99,8 +125,9 @@ fun PreviewTerminalLayout() {
   SimpleXTheme {
     TerminalLayout(
       terminalItems = TerminalItem.sampleData,
-      close = {},
-      sendCommand = {}
+      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) },
+      sendCommand = {},
+      close = {}
     )
   }
 }

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

@@ -1,15 +1,24 @@
 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
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.ArrowBackIosNew
+import androidx.compose.material.icons.outlined.ArrowForwardIos
 import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
@@ -17,146 +26,119 @@ import chat.simplex.app.R
 import chat.simplex.app.SimplexService
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.model.Profile
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleButton
 import chat.simplex.app.views.helpers.withApi
-import com.google.accompanist.insets.ProvideWindowInsets
+import chat.simplex.app.views.onboarding.OnboardingStage
+import chat.simplex.app.views.onboarding.ReadableText
 import com.google.accompanist.insets.navigationBarsWithImePadding
 
-@Composable
-fun WelcomeView(chatModel: ChatModel) {
-  ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
-    Box(
-      modifier = Modifier
-        .fillMaxSize()
-        .background(color = MaterialTheme.colors.background)
-    ) {
-      Column(
-        verticalArrangement = Arrangement.SpaceBetween,
-        modifier = Modifier
-          .verticalScroll(rememberScrollState())
-          .fillMaxSize()
-          .background(color = MaterialTheme.colors.background)
-          .padding(12.dp)
-      ) {
-        Image(
-          painter = painterResource(R.drawable.logo),
-          contentDescription = "Simplex Logo",
-          modifier = Modifier.padding(vertical = 15.dp)
-        )
-        Text(
-          "You control your chat!",
-          style = MaterialTheme.typography.h4,
-          color = MaterialTheme.colors.onBackground
-        )
-        Text(
-          "The messaging and application platform protecting your privacy and security.",
-          style = MaterialTheme.typography.body1,
-          color = MaterialTheme.colors.onBackground
-        )
-        Spacer(Modifier.height(8.dp))
-        Text(
-          "We don't store any of your contacts or messages (once delivered) on the servers.",
-          style = MaterialTheme.typography.body1,
-          color = MaterialTheme.colors.onBackground
-        )
-        Spacer(Modifier.height(24.dp))
-        CreateProfilePanel(chatModel)
-      }
-    }
-  }
-}
-
-
 fun isValidDisplayName(name: String) : Boolean {
   return (name.firstOrNull { it.isWhitespace() }) == null
 }
 
 @Composable
 fun CreateProfilePanel(chatModel: ChatModel) {
-  var displayName by remember { mutableStateOf("") }
-  var fullName by remember { mutableStateOf("") }
+  val displayName = remember { mutableStateOf("") }
+  val fullName = remember { mutableStateOf("") }
+  val focusRequester = remember { FocusRequester() }
 
-  Column(
-    modifier=Modifier.fillMaxSize()
-  ) {
-    Text(
-      "Create profile",
-      style = MaterialTheme.typography.h4,
-      color = MaterialTheme.colors.onBackground,
-      modifier = Modifier.padding(vertical = 5.dp)
-    )
-    Text(
-      "Your profile is stored on your device and shared only with your contacts.",
-      style = MaterialTheme.typography.body1,
-      color = MaterialTheme.colors.onBackground
-    )
-    Spacer(Modifier.height(10.dp))
-    Text(
-      "Display Name",
-      style = MaterialTheme.typography.h6,
-      color = MaterialTheme.colors.onBackground,
-      modifier = Modifier.padding(bottom = 3.dp)
-    )
-    BasicTextField(
-      value = displayName,
-      onValueChange = { displayName = it },
-      modifier = Modifier
-        .fillMaxWidth()
-        .background(MaterialTheme.colors.secondary)
-        .height(40.dp)
-        .clip(RoundedCornerShape(5.dp))
-        .padding(8.dp)
-        .navigationBarsWithImePadding(),
-      textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
-      keyboardOptions = KeyboardOptions(
-        capitalization = KeyboardCapitalization.None,
-        autoCorrect = false
-      ),
-      singleLine = true
-    )
-    val errorText = if(!isValidDisplayName(displayName)) "Display name cannot contain whitespace." else ""
+  Surface(Modifier.background(MaterialTheme.colors.onBackground)) {
+    Column(
+      modifier = Modifier.fillMaxSize()
+    ) {
+      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))
+      Text(
+        stringResource(R.string.display_name),
+        style = MaterialTheme.typography.h6,
+        modifier = 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.full_name_optional__prompt),
+        style = MaterialTheme.typography.h6,
+        modifier = Modifier.padding(bottom = 5.dp)
+      )
+      ProfileNameField(fullName)
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+      Row {
+        SimpleButton(
+          text = stringResource(R.string.about_simplex),
+          icon = Icons.Outlined.ArrowBackIosNew
+        ) { chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo }
 
-    Text(
-      errorText,
-      fontSize = 15.sp,
-      color = MaterialTheme.colors.error
-    )
+        Spacer(Modifier.fillMaxWidth().weight(1f))
 
-    Spacer(Modifier.height(3.dp))
-    Text(
-      "Full Name (Optional)",
-      style = MaterialTheme.typography.h6,
-      color = MaterialTheme.colors.onBackground,
-      modifier = Modifier.padding(bottom = 5.dp)
-    )
-    BasicTextField(
-      value = fullName,
-      onValueChange = { fullName = it },
-      modifier = Modifier
-        .fillMaxWidth()
-        .background(MaterialTheme.colors.secondary)
-        .height(40.dp)
-        .clip(RoundedCornerShape(3.dp))
-        .padding(8.dp)
-        .navigationBarsWithImePadding(),
-      textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
-      keyboardOptions = KeyboardOptions(
-        capitalization = KeyboardCapitalization.None,
-        autoCorrect = false
-      ),
-      singleLine = true
-    )
-    Spacer(Modifier.height(20.dp))
-    Button(onClick = {
-      withApi {
-        val user = chatModel.controller.apiCreateActiveUser(
-          Profile(displayName, fullName, null)
-        )
-        chatModel.controller.startChat(user)
-        SimplexService.start(chatModel.controller.appContext)
-        chatModel.controller.showBackgroundServiceNotice()
+        val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
+        val createModifier: Modifier
+        val createColor: Color
+        if (enabled) {
+          createModifier = Modifier.clickable { createProfile(chatModel, displayName.value, fullName.value) }.padding(8.dp)
+          createColor = MaterialTheme.colors.primary
+        } else {
+          createModifier = Modifier.padding(8.dp)
+          createColor = HighOrLowlight
+        }
+        Surface(shape = RoundedCornerShape(20.dp)) {
+          Row(verticalAlignment = Alignment.CenterVertically, modifier = createModifier) {
+            Text(stringResource(R.string.create_profile_button), style = MaterialTheme.typography.caption, color = createColor)
+            Icon(Icons.Outlined.ArrowForwardIos, stringResource(R.string.create_profile_button), tint = createColor)
+          }
+        }
       }
-    },
-    enabled = (displayName.isNotEmpty() && isValidDisplayName(displayName))
-    ) { Text("Create") }
+
+      LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+      }
+    }
   }
 }
+
+fun createProfile(chatModel: ChatModel, displayName: String, fullName: String) {
+  withApi {
+    val user = chatModel.controller.apiCreateActiveUser(
+      Profile(displayName, fullName, null)
+    )
+    chatModel.controller.startChat(user)
+    chatModel.controller.showBackgroundServiceNoticeIfNeeded()
+    SimplexService.start(chatModel.controller.appContext)
+    chatModel.onboardingStage.value = OnboardingStage.OnboardingComplete
+  }
+}
+
+@Composable
+fun ProfileNameField(name: MutableState<String>, focusRequester: FocusRequester? = null) {
+  val modifier = Modifier
+    .fillMaxWidth()
+    .background(MaterialTheme.colors.secondary)
+    .height(40.dp)
+    .clip(RoundedCornerShape(5.dp))
+    .padding(8.dp)
+    .navigationBarsWithImePadding()
+  BasicTextField(
+    value = name.value,
+    onValueChange = { name.value = it },
+    modifier = if (focusRequester == null) modifier else modifier.focusRequester(focusRequester),
+    textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
+    keyboardOptions = KeyboardOptions(
+      capitalization = KeyboardCapitalization.None,
+      autoCorrect = false
+    ),
+    singleLine = true,
+    cursorBrush = SolidColor(HighOrLowlight)
+  )
+}

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

@@ -0,0 +1,100 @@
+package chat.simplex.app.views.call
+
+import android.util.Log
+import chat.simplex.app.TAG
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.views.helpers.ModalManager
+import chat.simplex.app.views.helpers.withApi
+import kotlinx.datetime.Clock
+import kotlin.time.Duration.Companion.minutes
+
+class CallManager(val chatModel: ChatModel) {
+  fun reportNewIncomingCall(invitation: RcvCallInvitation) {
+    Log.d(TAG, "CallManager.reportNewIncomingCall")
+    with (chatModel) {
+      callInvitations[invitation.contact.id] = invitation
+      if (Clock.System.now() - invitation.callTs <= 3.minutes) {
+        activeCallInvitation.value = invitation
+        controller.ntfManager.notifyCallInvitation(invitation)
+      } else {
+        val contact = invitation.contact
+        controller.ntfManager.notifyMessageReceived(chatId = contact.id, displayName = contact.displayName, msgText = invitation.callTypeText)
+      }
+    }
+  }
+
+  fun acceptIncomingCall(invitation: RcvCallInvitation) {
+    ModalManager.shared.closeModals()
+    val call = chatModel.activeCall.value
+    if (call == null) {
+      justAcceptIncomingCall(invitation = invitation)
+    } else {
+      withApi {
+        chatModel.switchingCall.value = true
+        try {
+          endCall(call = call)
+          justAcceptIncomingCall(invitation = invitation)
+        } finally {
+          withApi { chatModel.switchingCall.value = false }
+        }
+      }
+    }
+  }
+
+  private fun justAcceptIncomingCall(invitation: RcvCallInvitation) {
+    with (chatModel) {
+      activeCall.value = Call(
+        contact = invitation.contact,
+        callState = CallState.InvitationAccepted,
+        localMedia = invitation.callType.media,
+        sharedKey = invitation.sharedKey
+      )
+      showCallView.value = true
+      val useRelay = controller.appPrefs.webrtcPolicyRelay.get()
+      callCommand.value = WCallCommand.Start (media = invitation.callType.media, aesKey = invitation.sharedKey, relay = useRelay)
+      callInvitations.remove(invitation.contact.id)
+      if (invitation.contact.id == activeCallInvitation.value?.contact?.id) {
+        activeCallInvitation.value = null
+        controller.ntfManager.cancelCallNotification()
+      }
+    }
+  }
+
+  suspend fun endCall(call: Call) {
+    with (chatModel) {
+      if (call.callState == CallState.Ended) {
+        Log.d(TAG, "CallManager.endCall: call ended")
+        activeCall.value = null
+        showCallView.value = false
+      } else {
+        Log.d(TAG, "CallManager.endCall: ending call...")
+        callCommand.value = WCallCommand.End
+        showCallView.value = false
+        controller.apiEndCall(call.contact)
+        activeCall.value = null
+      }
+    }
+  }
+
+  fun endCall(invitation: RcvCallInvitation) {
+    with (chatModel) {
+      callInvitations.remove(invitation.contact.id)
+      if (invitation.contact.id == activeCallInvitation.value?.contact?.id) {
+        activeCallInvitation.value = null
+        controller.ntfManager.cancelCallNotification()
+      }
+      withApi {
+        if (!controller.apiRejectCall(invitation.contact)) {
+          Log.e(TAG, "apiRejectCall error")
+        }
+      }
+    }
+  }
+
+  fun reportCallRemoteEnded(invitation: RcvCallInvitation) {
+    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

@@ -0,0 +1,466 @@
+package chat.simplex.app.views.call
+
+import android.Manifest
+import android.content.Context
+import android.media.AudioManager
+import android.util.Log
+import android.view.ViewGroup
+import android.webkit.*
+import androidx.activity.compose.BackHandler
+import androidx.annotation.StringRes
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.webkit.WebViewAssetLoader
+import androidx.webkit.WebViewClientCompat
+import chat.simplex.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 com.google.accompanist.permissions.rememberMultiplePermissionsState
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+
+@Composable
+fun ActiveCallView(chatModel: ChatModel) {
+  BackHandler(onBack = {
+    val call = chatModel.activeCall.value
+    if (call != null) withApi { chatModel.callManager.endCall(call) }
+  })
+  val cxt = LocalContext.current
+  val scope = rememberCoroutineScope()
+  Box(Modifier.fillMaxSize()) {
+    WebRTCView(chatModel.callCommand) { apiMsg ->
+      Log.d(TAG, "received from WebRTCView: $apiMsg")
+      val call = chatModel.activeCall.value
+      if (call != null) {
+        Log.d(TAG, "has active call $call")
+        when (val r = apiMsg.resp) {
+          is WCallResponse.Capabilities -> withApi {
+            val callType = CallType(call.localMedia, r.capabilities)
+            chatModel.controller.apiSendCallInvitation(call.contact, callType)
+            chatModel.activeCall.value = call.copy(callState = CallState.InvitationSent, localCapabilities = r.capabilities)
+          }
+          is WCallResponse.Offer -> withApi {
+            chatModel.controller.apiSendCallOffer(call.contact, r.offer, r.iceCandidates, call.localMedia, r.capabilities)
+            chatModel.activeCall.value = call.copy(callState = CallState.OfferSent, localCapabilities = r.capabilities)
+          }
+          is WCallResponse.Answer -> withApi {
+            chatModel.controller.apiSendCallAnswer(call.contact, r.answer, r.iceCandidates)
+            chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
+          }
+          is WCallResponse.Ice -> withApi {
+            chatModel.controller.apiSendCallExtraInfo(call.contact, r.iceCandidates)
+          }
+          is WCallResponse.Connection ->
+            try {
+              val callStatus = json.decodeFromString<WebRTCCallStatus>("\"${r.state.connectionState}\"")
+              if (callStatus == WebRTCCallStatus.Connected) {
+                chatModel.activeCall.value = call.copy(callState = CallState.Connected)
+              }
+              withApi { chatModel.controller.apiCallStatus(call.contact, callStatus) }
+            } catch (e: Error) {
+              Log.d(TAG,"call status ${r.state.connectionState} not used")
+            }
+          is WCallResponse.Connected -> {
+            chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo)
+            scope.launch {
+              delay(2000L)
+              setCallSound(cxt, call)
+            }
+          }
+          is WCallResponse.Ended -> {
+            chatModel.activeCall.value = call.copy(callState = CallState.Ended)
+            withApi { chatModel.callManager.endCall(call) }
+            chatModel.showCallView.value = false
+          }
+          is WCallResponse.Ok -> when (val cmd = apiMsg.command) {
+            is WCallCommand.Answer ->
+              chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
+            is WCallCommand.Media -> {
+              when (cmd.media) {
+                CallMediaType.Video -> chatModel.activeCall.value = call.copy(videoEnabled = cmd.enable)
+                CallMediaType.Audio -> chatModel.activeCall.value = call.copy(audioEnabled = cmd.enable)
+              }
+            }
+            is WCallCommand.Camera -> {
+              chatModel.activeCall.value = call.copy(localCamera = cmd.camera)
+              if (!call.audioEnabled) {
+                chatModel.callCommand.value = WCallCommand.Media(CallMediaType.Audio, enable = false)
+              }
+            }
+            is WCallCommand.End ->
+              chatModel.showCallView.value = false
+            else -> {}
+          }
+          is WCallResponse.Error -> {
+            Log.e(TAG, "ActiveCallView: command error ${r.message}")
+          }
+        }
+      }
+    }
+    val call = chatModel.activeCall.value
+    if (call != null)  ActiveCallOverlay(call, chatModel)
+  }
+}
+
+@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
+  } else {
+    am.mode = AudioManager.MODE_IN_CALL
+    am.isSpeakerphoneOn = false
+  }
+}
+
+@Composable
+private fun ActiveCallOverlayLayout(
+  call: Call,
+  dismiss: () -> Unit,
+  toggleAudio: () -> Unit,
+  toggleVideo: () -> Unit,
+  toggleSound: () -> Unit,
+  flipCamera: () -> Unit
+) {
+  Column(Modifier.padding(16.dp)) {
+    when (call.peerMedia ?: call.localMedia) {
+      CallMediaType.Video -> {
+        CallInfoView(call, alignment = Alignment.Start)
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
+          ToggleAudioButton(call, toggleAudio)
+          Spacer(Modifier.size(40.dp))
+          IconButton(onClick = dismiss) {
+            Icon(Icons.Filled.CallEnd, stringResource(R.string.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
+          }
+          if (call.videoEnabled) {
+            ControlButton(call, Icons.Filled.FlipCameraAndroid, R.string.icon_descr_flip_camera, flipCamera)
+            ControlButton(call, Icons.Filled.Videocam, R.string.icon_descr_video_off, toggleVideo)
+          } else {
+            Spacer(Modifier.size(48.dp))
+            ControlButton(call, Icons.Outlined.VideocamOff, R.string.icon_descr_video_on, toggleVideo)
+          }
+        }
+      }
+      CallMediaType.Audio -> {
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Column(
+          Modifier.fillMaxWidth(),
+          horizontalAlignment = Alignment.CenterHorizontally,
+          verticalArrangement = Arrangement.Center
+        ) {
+          ProfileImage(size = 192.dp, image = call.contact.profile.image)
+          CallInfoView(call, alignment = Alignment.CenterHorizontally)
+        }
+        Spacer(Modifier.fillMaxHeight().weight(1f))
+        Box(Modifier.fillMaxWidth().padding(bottom = 48.dp), contentAlignment = Alignment.CenterStart) {
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
+            IconButton(onClick = dismiss) {
+              Icon(Icons.Filled.CallEnd, stringResource(R.string.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
+            }
+          }
+          Box(Modifier.padding(start = 32.dp)) {
+            ToggleAudioButton(call, toggleAudio)
+          }
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
+            Box(Modifier.padding(end = 32.dp)) {
+              ToggleSoundButton(call, toggleSound)
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun ControlButton(call: Call, icon: ImageVector, @StringRes iconText: Int, action: () -> Unit) {
+  if (call.hasMedia) {
+    IconButton(onClick = action) {
+      Icon(icon, stringResource(iconText), tint = Color(0xFFFFFFD8), modifier = Modifier.size(40.dp))
+    }
+  } else {
+    Spacer(Modifier.size(40.dp))
+  }
+}
+
+@Composable
+private fun ToggleAudioButton(call: Call, toggleAudio: () -> Unit) {
+  if (call.audioEnabled) {
+    ControlButton(call, Icons.Outlined.Mic, R.string.icon_descr_audio_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) =
+    Text(text, color = Color(0xFFFFFFD8), style = style)
+  Column(horizontalAlignment = alignment) {
+    InfoText(call.contact.chatViewName, style = MaterialTheme.typography.h2)
+    InfoText(call.callState.text)
+
+    val connInfo =
+      if (call.connectionInfo == null) ""
+      else " (${call.connectionInfo.text})"
+    InfoText(call.encryptionStatus + connInfo)
+  }
+}
+
+//@Composable
+//fun CallViewDebug(close: () -> Unit) {
+//  val callCommand = remember { mutableStateOf<WCallCommand?>(null)}
+//  val commandText = remember { mutableStateOf("{\"command\": {\"type\": \"start\", \"media\": \"video\", \"aesKey\": \"FwW+t6UbnwHoapYOfN4mUBUuqR7UtvYWxW16iBqM29U=\"}}") }
+//  val clipboard = ContextCompat.getSystemService(LocalContext.current, ClipboardManager::class.java)
+//
+//  BackHandler(onBack = close)
+//  Column(
+//    horizontalAlignment = Alignment.CenterHorizontally,
+//    verticalArrangement = Arrangement.spacedBy(12.dp),
+//    modifier = Modifier
+//      .background(MaterialTheme.colors.background)
+//      .fillMaxSize()
+//  ) {
+//    WebRTCView(callCommand) { apiMsg ->
+//      // for debugging
+//      // commandText.value = apiMsg
+//      commandText.value = json.encodeToString(apiMsg)
+//    }
+//
+//    TextEditor(Modifier.height(180.dp), text = commandText)
+//
+//    Row(
+//      Modifier
+//        .fillMaxWidth()
+//        .padding(bottom = 6.dp),
+//      horizontalArrangement = Arrangement.SpaceBetween
+//    ) {
+//      Button(onClick = {
+//        val clip: ClipData = ClipData.newPlainText("js command", commandText.value)
+//        clipboard?.setPrimaryClip(clip)
+//      }) { Text("Copy") }
+//      Button(onClick = {
+//        try {
+//          val apiCall: WVAPICall = json.decodeFromString(commandText.value)
+//          commandText.value = ""
+//          println("sending: ${commandText.value}")
+//          callCommand.value = apiCall.command
+//        } catch(e: Error) {
+//          println("error parsing command: ${commandText.value}")
+//          println(e)
+//        }
+//      }) { Text("Send") }
+//      Button(onClick = {
+//        commandText.value = ""
+//      }) { Text("Clear") }
+//    }
+//  }
+//}
+
+@Composable
+fun WebRTCView(callCommand: MutableState<WCallCommand?>, onResponse: (WVAPIMessage) -> Unit) {
+  val webView = remember { mutableStateOf<WebView?>(null) }
+  val permissionsState = rememberMultiplePermissionsState(
+    permissions = listOf(
+      Manifest.permission.CAMERA,
+      Manifest.permission.RECORD_AUDIO,
+      Manifest.permission.MODIFY_AUDIO_SETTINGS,
+      Manifest.permission.INTERNET
+    )
+  )
+  fun processCommand(wv: WebView, cmd: WCallCommand) {
+    val apiCall = WVAPICall(command = cmd)
+    wv.evaluateJavascript("processCommand(${json.encodeToString(apiCall)})", null)
+  }
+  val lifecycleOwner = LocalLifecycleOwner.current
+  DisposableEffect(lifecycleOwner) {
+    val observer = LifecycleEventObserver { _, event ->
+      if (event == Lifecycle.Event.ON_RESUME || event == Lifecycle.Event.ON_START) {
+        permissionsState.launchMultiplePermissionRequest()
+      }
+    }
+    lifecycleOwner.lifecycle.addObserver(observer)
+    onDispose {
+      val wv = webView.value
+      if (wv != null) processCommand(wv, WCallCommand.End)
+      lifecycleOwner.lifecycle.removeObserver(observer)
+    }
+  }
+  LaunchedEffect(callCommand.value, webView.value) {
+    val cmd = callCommand.value
+    val wv = webView.value
+    if (cmd != null && wv != null) {
+      Log.d(TAG, "WebRTCView LaunchedEffect executing $cmd")
+      processCommand(wv, cmd)
+      callCommand.value = null
+    }
+  }
+  val assetLoader = WebViewAssetLoader.Builder()
+    .addPathHandler("/assets/www/", WebViewAssetLoader.AssetsPathHandler(LocalContext.current))
+    .build()
+
+  if (permissionsState.allPermissionsGranted) {
+    Box(Modifier.fillMaxSize()) {
+      AndroidView(
+        factory = { AndroidViewContext ->
+          WebView(AndroidViewContext).apply {
+            layoutParams = ViewGroup.LayoutParams(
+              ViewGroup.LayoutParams.MATCH_PARENT,
+              ViewGroup.LayoutParams.MATCH_PARENT,
+            )
+            this.webChromeClient = object: WebChromeClient() {
+              override fun onPermissionRequest(request: PermissionRequest) {
+                if (request.origin.toString().startsWith("file:/")) {
+                  request.grant(request.resources)
+                } else {
+                  Log.d(TAG, "Permission request from webview denied.")
+                  request.deny()
+                }
+              }
+            }
+            this.webViewClient = LocalContentWebViewClient(assetLoader)
+            this.clearHistory()
+            this.clearCache(true)
+            this.addJavascriptInterface(WebRTCInterface(onResponse), "WebRTCInterface")
+            val webViewSettings = this.settings
+            webViewSettings.allowFileAccess = true
+            webViewSettings.allowContentAccess = true
+            webViewSettings.javaScriptEnabled = true
+            webViewSettings.mediaPlaybackRequiresUserGesture = false
+            webViewSettings.cacheMode = WebSettings.LOAD_NO_CACHE
+            this.loadUrl("file:android_asset/www/call.html")
+          }
+        }
+      ) { wv ->
+        Log.d(TAG, "WebRTCView: webview ready")
+        // for debugging
+        // wv.evaluateJavascript("sendMessageToNative = ({resp}) => WebRTCInterface.postMessage(JSON.stringify({command: resp}))", null)
+        withApi {
+          delay(2000L)
+          wv.evaluateJavascript("sendMessageToNative = (msg) => WebRTCInterface.postMessage(JSON.stringify(msg))", null)
+          webView.value = wv
+        }
+      }
+    }
+  }
+}
+
+// for debugging
+// class WebRTCInterface(private val onResponse: (String) -> Unit) {
+class WebRTCInterface(private val onResponse: (WVAPIMessage) -> Unit) {
+  @JavascriptInterface
+  fun postMessage(message: String) {
+    Log.d(TAG, "WebRTCInterface.postMessage")
+    try {
+      // for debugging
+      // onResponse(message)
+      onResponse(json.decodeFromString(message))
+    } catch (e: Error) {
+      Log.e(TAG, "failed parsing WebView message: $message")
+    }
+  }
+}
+
+private class LocalContentWebViewClient(private val assetLoader: WebViewAssetLoader) : WebViewClientCompat() {
+  override fun shouldInterceptRequest(
+    view: WebView,
+    request: WebResourceRequest
+  ): WebResourceResponse? {
+    return assetLoader.shouldInterceptRequest(request.url)
+  }
+}
+
+@Preview
+@Composable
+fun PreviewActiveCallOverlayVideo() {
+  SimpleXTheme {
+    ActiveCallOverlayLayout(
+      call = Call(
+        contact = Contact.sampleData,
+        callState = CallState.Negotiated,
+        localMedia = CallMediaType.Video,
+        peerMedia = CallMediaType.Video,
+        connectionInfo = ConnectionInfo(RTCIceCandidate(RTCIceCandidateType.Host), RTCIceCandidate(RTCIceCandidateType.Host))
+      ),
+      dismiss = {},
+      toggleAudio = {},
+      toggleVideo = {},
+      toggleSound = {},
+      flipCamera = {}
+    )
+  }
+}
+
+@Preview
+@Composable
+fun PreviewActiveCallOverlayAudio() {
+  SimpleXTheme {
+    ActiveCallOverlayLayout(
+      call = Call(
+        contact = Contact.sampleData,
+        callState = CallState.Negotiated,
+        localMedia = CallMediaType.Audio,
+        peerMedia = CallMediaType.Audio,
+        connectionInfo = ConnectionInfo(RTCIceCandidate(RTCIceCandidateType.Host), RTCIceCandidate(RTCIceCandidateType.Host))
+      ),
+      dismiss = {},
+      toggleAudio = {},
+      toggleVideo = {},
+      toggleSound = {},
+      flipCamera = {}
+    )
+  }
+}

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

@@ -0,0 +1,227 @@
+package chat.simplex.app.views.call
+
+import android.app.KeyguardManager
+import android.content.Context
+import android.content.Intent
+import android.content.res.Configuration
+import android.os.Build
+import android.os.Bundle
+import android.util.Log
+import android.view.WindowManager
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.viewModels
+import androidx.compose.foundation.background
+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.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.model.NtfManager.Companion.OpenChatAction
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.ProfileImage
+import chat.simplex.app.views.onboarding.SimpleXLogo
+import kotlinx.datetime.Clock
+
+class IncomingCallActivity: ComponentActivity() {
+  private val vm by viewModels<SimplexViewModel>()
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val activity = this
+    setContent { IncomingCallActivityView(vm.chatModel, activity) }
+    unlockForIncomingCall()
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    lockAfterIncomingCall()
+  }
+
+  private fun unlockForIncomingCall() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+      setShowWhenLocked(true)
+      setTurnScreenOn(true)
+    } else {
+      window.addFlags(activityFlags)
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      getKeyguardManager(this).requestDismissKeyguard(this, null)
+    }
+  }
+
+  private fun lockAfterIncomingCall() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+      setShowWhenLocked(false)
+      setTurnScreenOn(false)
+    } else {
+      window.clearFlags(activityFlags)
+    }
+  }
+
+  companion object {
+    const val activityFlags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
+  }
+}
+
+fun getKeyguardManager(context: Context): KeyguardManager =
+  context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+
+@Composable
+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
+  LaunchedEffect(invitation, call, switchingCall, showCallView) {
+    if (!switchingCall && invitation == null && (!showCallView || call == null)) {
+      Log.d(TAG, "IncomingCallActivityView: finishing activity")
+      activity.finish()
+    }
+  }
+  SimpleXTheme {
+    Surface(
+      Modifier
+        .background(MaterialTheme.colors.background)
+        .fillMaxSize()) {
+      if (showCallView) {
+        Box {
+          ActiveCallView(m)
+          if (invitation != null) IncomingCallAlertView(invitation, m)
+        }
+      } else if (invitation != null) {
+        IncomingCallLockScreenAlert(invitation, m, activity)
+      }
+    }
+  }
+}
+
+@Composable
+fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatModel, activity: IncomingCallActivity) {
+  val cm = chatModel.callManager
+  val cxt = LocalContext.current
+  val scope = rememberCoroutineScope()
+  var callOnLockScreen by remember { mutableStateOf(chatModel.controller.appPrefs.callOnLockScreen.get()) }
+  LaunchedEffect(true) { SoundPlayer.shared.start(cxt, scope, sound = true) }
+  DisposableEffect(true) { onDispose { SoundPlayer.shared.stop() } }
+  IncomingCallLockScreenAlertLayout(
+    invitation,
+    callOnLockScreen,
+    rejectCall = { cm.endCall(invitation = invitation) },
+    ignoreCall = { chatModel.activeCallInvitation.value = null },
+    acceptCall = { cm.acceptIncomingCall(invitation = invitation) },
+    openApp = {
+      SoundPlayer.shared.stop()
+      var intent = Intent(activity, MainActivity::class.java)
+        .setAction(OpenChatAction)
+        .putExtra("chatId", invitation.contact.id)
+      activity.startActivity(intent)
+      activity.finish()
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        getKeyguardManager(activity).requestDismissKeyguard(activity, null)
+      }
+    }
+  )
+}
+
+@Composable
+fun IncomingCallLockScreenAlertLayout(
+  invitation: RcvCallInvitation,
+  callOnLockScreen: CallOnLockScreen?,
+  rejectCall: () -> Unit,
+  ignoreCall: () -> Unit,
+  acceptCall: () -> Unit,
+  openApp: () -> Unit
+) {
+  Column(
+    Modifier
+      .padding(30.dp)
+      .fillMaxSize(),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    IncomingCallInfo(invitation)
+    Spacer(Modifier.fillMaxHeight().weight(1f))
+    if (callOnLockScreen == CallOnLockScreen.ACCEPT) {
+      ProfileImage(size = 192.dp, image = invitation.contact.profile.image)
+      Text(invitation.contact.chatViewName, style = MaterialTheme.typography.h2)
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+      Row {
+        LockScreenCallButton(stringResource(R.string.reject), Icons.Filled.CallEnd, Color.Red, rejectCall)
+        Spacer(Modifier.size(48.dp))
+        LockScreenCallButton(stringResource(R.string.ignore), Icons.Filled.Close, MaterialTheme.colors.primary, ignoreCall)
+        Spacer(Modifier.size(48.dp))
+        LockScreenCallButton(stringResource(R.string.accept), Icons.Filled.Check, SimplexGreen, acceptCall)
+      }
+    } else if (callOnLockScreen == CallOnLockScreen.SHOW) {
+      SimpleXLogo()
+      Text(stringResource(R.string.open_simplex_chat_to_accept_call), textAlign = TextAlign.Center, lineHeight = 22.sp)
+      Text(stringResource(R.string.allow_accepting_calls_from_lock_screen), textAlign = TextAlign.Center, style = MaterialTheme.typography.body2, lineHeight = 22.sp)
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+      SimpleButton(text = stringResource(R.string.open_verb), icon = Icons.Filled.Check, click = openApp)
+    }
+  }
+}
+
+@Composable
+private fun LockScreenCallButton(text: String, icon: ImageVector, color: Color, action: () -> Unit) {
+  Surface(
+    shape = RoundedCornerShape(10.dp),
+    color = Color.Transparent
+  ) {
+    Column(
+      Modifier
+        .defaultMinSize(minWidth = 50.dp)
+        .padding(4.dp),
+      horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+      IconButton(action) {
+        Icon(icon, text, tint = color, modifier = Modifier.scale(1.75f))
+      }
+      Spacer(Modifier.height(16.dp))
+      Text(text, style = MaterialTheme.typography.body2, color = HighOrLowlight)
+    }
+  }
+}
+
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true
+)
+@Composable
+fun PreviewIncomingCallLockScreenAlert() {
+  SimpleXTheme(true) {
+    Surface(
+      Modifier
+        .background(MaterialTheme.colors.background)
+        .fillMaxSize()) {
+      IncomingCallLockScreenAlertLayout(
+        invitation = RcvCallInvitation(
+          contact = Contact.sampleData,
+          callType = CallType(media = CallMediaType.Audio, capabilities = CallCapabilities(encryption = false)),
+          sharedKey = null,
+          callTs = Clock.System.now()
+        ),
+        callOnLockScreen = null,
+        rejectCall = {},
+        ignoreCall = {},
+        acceptCall = {},
+        openApp = {},
+      )
+    }
+  }
+}

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

@@ -0,0 +1,108 @@
+package chat.simplex.app.views.call
+
+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.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+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.model.ChatModel
+import chat.simplex.app.model.Contact
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.usersettings.ProfilePreview
+import kotlinx.datetime.Clock
+
+@Composable
+fun IncomingCallAlertView(invitation: RcvCallInvitation, chatModel: ChatModel) {
+  val cm = chatModel.callManager
+  val cxt = LocalContext.current
+  val scope = rememberCoroutineScope()
+  LaunchedEffect(true) { SoundPlayer.shared.start(cxt, scope, sound = !chatModel.showCallView.value) }
+  DisposableEffect(true) { onDispose { SoundPlayer.shared.stop() } }
+  IncomingCallAlertLayout(
+    invitation,
+    rejectCall = { cm.endCall(invitation = invitation) },
+    ignoreCall = { chatModel.activeCallInvitation.value = null },
+    acceptCall = { cm.acceptIncomingCall(invitation = invitation) }
+  )
+}
+
+@Composable
+fun IncomingCallAlertLayout(
+  invitation: RcvCallInvitation,
+  rejectCall: () -> Unit,
+  ignoreCall: () -> Unit,
+  acceptCall: () -> Unit
+) {
+  val color = if (isInDarkTheme()) 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(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) {
+  @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))
+    else CallIcon(Icons.Filled.Phone, stringResource(R.string.icon_descr_audio_call))
+    Spacer(Modifier.width(4.dp))
+    Text(invitation.callTypeText)
+  }
+}
+
+@Composable
+private fun CallButton(text: String, icon: ImageVector, color: Color, action: () -> Unit) {
+  Surface(
+    shape = RoundedCornerShape(10.dp),
+    color = Color.Transparent
+  ) {
+    Column(
+      Modifier
+        .clickable(onClick = action)
+        .defaultMinSize(minWidth = 50.dp)
+        .padding(4.dp),
+      horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+      Icon(icon, text, tint = color, modifier = Modifier.scale(1.2f))
+      Text(text, style = MaterialTheme.typography.body2, color = HighOrLowlight)
+    }
+  }
+}
+
+@Preview
+@Composable
+fun PreviewIncomingCallAlertLayout() {
+  SimpleXTheme {
+    IncomingCallAlertLayout(
+      invitation = RcvCallInvitation(
+        contact = Contact.sampleData,
+        callType = CallType(media = CallMediaType.Audio, capabilities = CallCapabilities(encryption = false)),
+        sharedKey = null,
+        callTs = Clock.System.now()
+      ),
+      rejectCall = {},
+      ignoreCall = {},
+      acceptCall = {}
+    )
+  }
+}

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

@@ -0,0 +1,39 @@
+package chat.simplex.app.views.call
+
+import android.content.Context
+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.views.helpers.withScope
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+
+class SoundPlayer {
+  var player: MediaPlayer? = null
+  var playing = false
+
+  fun start(cxt: Context, scope: CoroutineScope, sound: Boolean) {
+    if (sound) player = MediaPlayer.create(cxt, R.raw.ring_once)
+    val vibrator = ContextCompat.getSystemService(cxt, Vibrator::class.java)
+    val effect = VibrationEffect.createOneShot(250, VibrationEffect.DEFAULT_AMPLITUDE)
+    playing = true
+    withScope(scope) {
+      while (playing) {
+        if (sound) player?.start()
+        vibrator?.vibrate(effect)
+        delay(3500)
+      }
+    }
+  }
+
+  fun stop() {
+    playing = false
+    player?.stop()
+  }
+
+  companion object {
+    val shared = SoundPlayer()
+  }
+}

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

@@ -0,0 +1,156 @@
+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.model.Contact
+import chat.simplex.app.views.helpers.generalGetString
+import kotlinx.datetime.Instant
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+data class Call(
+  val contact: Contact,
+  val callState: CallState,
+  val localMedia: CallMediaType,
+  val localCapabilities: CallCapabilities? = null,
+  val peerMedia: CallMediaType? = null,
+  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
+) {
+  val encrypted: Boolean get() = localEncrypted && sharedKey != null
+  val localEncrypted: Boolean get() = localCapabilities?.encryption ?: false
+
+  val encryptionStatus: String @Composable get() = when(callState) {
+    CallState.WaitCapabilities -> ""
+    CallState.InvitationSent -> stringResource(if (localEncrypted) R.string.status_e2e_encrypted else R.string.status_no_e2e_encryption)
+    CallState.InvitationAccepted -> stringResource(if (sharedKey == null) R.string.status_contact_has_no_e2e_encryption else R.string.status_contact_has_e2e_encryption)
+    else -> stringResource(if (!localEncrypted) R.string.status_no_e2e_encryption else if (sharedKey == null) R.string.status_contact_has_no_e2e_encryption else R.string.status_e2e_encrypted)
+  }
+
+  val hasMedia: Boolean get() = callState == CallState.OfferSent || callState == CallState.Negotiated || callState == CallState.Connected
+}
+
+enum class CallState {
+  WaitCapabilities,
+  InvitationSent,
+  InvitationAccepted,
+  OfferSent,
+  OfferReceived,
+  AnswerReceived,
+  Negotiated,
+  Connected,
+  Ended;
+
+  val text: String @Composable get() = when(this) {
+    WaitCapabilities -> stringResource(R.string.callstate_starting)
+    InvitationSent -> stringResource(R.string.callstate_waiting_for_answer)
+    InvitationAccepted -> stringResource(R.string.callstate_starting)
+    OfferSent -> stringResource(R.string.callstate_waiting_for_confirmation)
+    OfferReceived -> stringResource(R.string.callstate_received_answer)
+    AnswerReceived -> stringResource(R.string.callstate_received_confirmation)
+    Negotiated -> stringResource(R.string.callstate_connecting)
+    Connected -> stringResource(R.string.callstate_connected)
+    Ended -> stringResource(R.string.callstate_ended)
+  }
+}
+
+@Serializable class WVAPICall(val corrId: Int? = null, val command: WCallCommand)
+@Serializable class WVAPIMessage(val corrId: Int? = null, val resp: WCallResponse, val command: WCallCommand? = null)
+
+@Serializable
+sealed class WCallCommand {
+  @Serializable @SerialName("capabilities") object Capabilities: WCallCommand()
+  @Serializable @SerialName("start") class Start(val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
+  @Serializable @SerialName("offer") class Offer(val offer: String, val iceCandidates: String, val media: CallMediaType, val aesKey: String? = null, val iceServers: List<RTCIceServer>? = null, val relay: Boolean? = null): WCallCommand()
+  @Serializable @SerialName("answer") class Answer (val answer: String, val iceCandidates: String): WCallCommand()
+  @Serializable @SerialName("ice") class Ice(val iceCandidates: String): WCallCommand()
+  @Serializable @SerialName("media") class Media(val media: CallMediaType, val enable: Boolean): WCallCommand()
+  @Serializable @SerialName("camera") class Camera(val camera: VideoCamera): WCallCommand()
+  @Serializable @SerialName("end") object End: WCallCommand()
+}
+
+@Serializable
+sealed class WCallResponse {
+  @Serializable @SerialName("capabilities") class Capabilities(val capabilities: CallCapabilities): WCallResponse()
+  @Serializable @SerialName("offer") class Offer(val offer: String, val iceCandidates: String, val capabilities: CallCapabilities): WCallResponse()
+  @Serializable @SerialName("answer") class Answer(val answer: String, val iceCandidates: String): WCallResponse()
+  @Serializable @SerialName("ice") class Ice(val iceCandidates: String): WCallResponse()
+  @Serializable @SerialName("connection") class Connection(val state: ConnectionState): WCallResponse()
+  @Serializable @SerialName("connected") class Connected(val connectionInfo: ConnectionInfo): WCallResponse()
+  @Serializable @SerialName("ended") object Ended: WCallResponse()
+  @Serializable @SerialName("ok") object Ok: WCallResponse()
+  @Serializable @SerialName("error") class Error(val message: String): WCallResponse()
+}
+
+@Serializable class WebRTCCallOffer(val callType: CallType, val rtcSession: WebRTCSession)
+@Serializable class WebRTCSession(val rtcSession: String, val rtcIceCandidates: String)
+@Serializable class WebRTCExtraInfo(val rtcIceCandidates: String)
+@Serializable class CallType(val media: CallMediaType, val capabilities: CallCapabilities)
+@Serializable class RcvCallInvitation(val contact: Contact, val callType: CallType, val sharedKey: String?, val callTs: Instant) {
+  val callTypeText: String get() = generalGetString(when(callType.media) {
+    CallMediaType.Video -> if (sharedKey == null) R.string.video_call_no_encryption else R.string.encrypted_video_call
+    CallMediaType.Audio -> if (sharedKey == null) R.string.audio_call_no_encryption else R.string.encrypted_audio_call
+  })
+  val callTitle: String get() = generalGetString(when(callType.media) {
+    CallMediaType.Video -> R.string.incoming_video_call
+    CallMediaType.Audio -> R.string.incoming_audio_call
+  })
+}
+@Serializable class CallCapabilities(val encryption: Boolean)
+@Serializable class ConnectionInfo(private val localCandidate: RTCIceCandidate?, private val remoteCandidate: RTCIceCandidate?) {
+  val text: String @Composable get() = when {
+    localCandidate?.candidateType == RTCIceCandidateType.Host && remoteCandidate?.candidateType == RTCIceCandidateType.Host ->
+      stringResource(R.string.call_connection_peer_to_peer)
+    localCandidate?.candidateType == RTCIceCandidateType.Relay && remoteCandidate?.candidateType == RTCIceCandidateType.Relay ->
+      stringResource(R.string.call_connection_via_relay)
+    else ->
+      "${localCandidate?.candidateType?.value ?: "unknown"} / ${remoteCandidate?.candidateType?.value ?: "unknown"}"
+  }
+}
+// https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate
+@Serializable class RTCIceCandidate(val candidateType: RTCIceCandidateType?)
+// https://developer.mozilla.org/en-US/docs/Web/API/RTCIceServer
+@Serializable class RTCIceServer(val urls: List<String>, val username: String? = null, val credential: String? = null)
+
+// https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidate/type
+@Serializable
+enum class RTCIceCandidateType(val value: String) {
+  @SerialName("host") Host("host"),
+  @SerialName("srflx") ServerReflexive("srflx"),
+  @SerialName("prflx") PeerReflexive("prflx"),
+  @SerialName("relay") Relay("relay")
+}
+
+@Serializable
+enum class WebRTCCallStatus(val value: String) {
+  @SerialName("connected") Connected("connected"),
+  @SerialName("connecting") Connecting("connecting"),
+  @SerialName("disconnected") Disconnected("disconnected"),
+  @SerialName("failed") Failed("failed")
+}
+
+@Serializable
+enum class CallMediaType {
+  @SerialName("video") Video,
+  @SerialName("audio") Audio
+}
+
+@Serializable
+enum class VideoCamera {
+  @SerialName("user") User,
+  @SerialName("environment") Environment;
+  val flipped: VideoCamera get() = if (this == User) Environment else User
+}
+
+@Serializable
+class ConnectionState(
+  val connectionState: String,
+  val iceConnectionState: String,
+  val iceGatheringState: String,
+  val signalingState: String
+)

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

@@ -1,122 +1,414 @@
 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.background
+import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.text.KeyboardActions
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
-import androidx.compose.material.icons.outlined.Circle
-import androidx.compose.material.icons.outlined.Delete
-import androidx.compose.runtime.Composable
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.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.*
 
 @Composable
-fun ChatInfoView(chatModel: ChatModel, close: () -> Unit) {
+fun ChatInfoView(
+  chatModel: ChatModel,
+  contact: Contact,
+  connStats: ConnectionStats?,
+  customUserProfile: Profile?,
+  localAlias: String,
+  close: () -> Unit,
+  onChatUpdated: (Chat) -> Unit,
+) {
   BackHandler(onBack = close)
   val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
+  val developerTools = chatModel.controller.appPrefs.developerTools.get()
   if (chat != null) {
-    ChatInfoLayout(chat,
-      close = close,
-      deleteContact = {
-        AlertManager.shared.showAlertMsg(
-          title = "Delete contact?",
-          text = "Contact and all messages will be deleted - this cannot be undone!",
-          confirmText = "Delete",
-          onConfirm = {
-            val cInfo = chat.chatInfo
-            withApi {
-              val r = chatModel.controller.apiDeleteChat(cInfo.chatType, cInfo.apiId)
-              if (r) {
-                chatModel.removeChat(cInfo.id)
-                chatModel.chatId.value = null
-                close()
-              }
-            }
-          }
-        )
-      }
+    ChatInfoLayout(
+      chat,
+      contact,
+      connStats,
+      customUserProfile,
+      localAlias,
+      developerTools,
+      onLocalAliasChanged = {
+        setContactAlias(chat.chatInfo.apiId, it, chatModel, onChatUpdated)
+      },
+      deleteContact = { deleteContactDialog(chat.chatInfo, chatModel, close) },
+      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
+      changeNtfsState = { enabled ->
+        changeNtfsState(enabled, chat, chatModel)
+      },
     )
   }
 }
 
-@Composable
-fun ChatInfoLayout(chat: Chat, close: () -> Unit, deleteContact: () -> Unit) {
-  Column(Modifier
-    .fillMaxSize()
-    .background(MaterialTheme.colors.background)
-    .padding(horizontal = 8.dp),
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    CloseSheetBar(close)
-    Spacer(Modifier.size(48.dp))
-    ChatInfoImage(chat, size = 192.dp)
-    val cInfo = chat.chatInfo
-    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)
-    )
-
-    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(
-          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)
-        )
+fun changeNtfsState(enabled: 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)
       }
-
-      Spacer(Modifier.weight(1F))
-
-      Box(Modifier.padding(48.dp)) {
-        SimpleButton(
-          "Delete contact", icon = Icons.Outlined.Delete,
-          color = Color.Red,
-          click = deleteContact
-        )
+      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)
       }
     }
   }
 }
 
+fun deleteContactDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
+  AlertManager.shared.showAlertMsg(
+    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 = {
+      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 clearChatDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.clear_chat_question),
+    text = generalGetString(R.string.clear_chat_warning),
+    confirmText = generalGetString(R.string.clear_verb),
+    onConfirm = {
+      withApi {
+        val updatedChatInfo = chatModel.controller.apiClearChat(chatInfo.chatType, chatInfo.apiId)
+        if (updatedChatInfo != null) {
+          chatModel.clearChat(updatedChatInfo)
+          chatModel.controller.ntfManager.cancelNotificationsForChat(chatInfo.id)
+          close?.invoke()
+        }
+      }
+    }
+  )
+}
+
 @Composable
-fun ServerImage(chat: Chat) {
-  val status = chat.serverInfo.networkStatus
-  when {
-    status is Chat.NetworkStatus.Connected ->
-      Icon(Icons.Filled.Circle, "Connected", tint = MaterialTheme.colors.primaryVariant)
-    status is Chat.NetworkStatus.Disconnected ->
-      Icon(Icons.Filled.Pending, "Disconnected", tint = HighOrLowlight)
-    status is Chat.NetworkStatus.Error ->
-      Icon(Icons.Filled.Error, "Error", tint = HighOrLowlight)
-    else ->
-      Icon(Icons.Outlined.Circle, "Pending", tint = HighOrLowlight)
+fun ChatInfoLayout(
+  chat: Chat,
+  contact: Contact,
+  connStats: ConnectionStats?,
+  customUserProfile: Profile?,
+  localAlias: String,
+  developerTools: Boolean,
+  onLocalAliasChanged: (String) -> Unit,
+  deleteContact: () -> Unit,
+  clearChat: () -> Unit,
+  changeNtfsState: (Boolean) -> 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()
+
+    if (connStats != null) {
+      SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+        SectionItemView {
+          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()
+    }
+
+    var ntfsEnabled by remember { mutableStateOf(chat.chatInfo.ntfsEnabled) }
+    SectionView(title = stringResource(R.string.settings_section_title_settings)) {
+      SectionItemView {
+        NtfsSwitch(ntfsEnabled) {
+          ntfsEnabled = !ntfsEnabled
+          changeNtfsState(ntfsEnabled)
+        }
+      }
+    }
+    SectionSpacer()
+
+    SectionView {
+      SectionItemView {
+        ClearChatButton(clearChat)
+      }
+      SectionDivider()
+      SectionItemView {
+        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),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    ChatInfoImage(cInfo, size = 192.dp, iconColor = if (isInDarkTheme()) GroupDark else SettingsSecondaryLight)
+    Text(
+      contact.profile.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+      color = MaterialTheme.colors.onBackground,
+      maxLines = 1,
+      overflow = TextOverflow.Ellipsis,
+      modifier = Modifier.padding(bottom = 8.dp)
+    )
+    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
+      )
+    }
+  }
+}
+
+@Composable
+private fun LocalAliasEditor(initialValue: String, updateValue: (String) -> Unit) {
+  var value by remember { mutableStateOf(initialValue) }
+  DefaultBasicTextField(
+    Modifier.fillMaxWidth().padding(horizontal = 10.dp),
+    initialValue,
+    {
+      Text(
+        generalGetString(R.string.text_field_set_contact_placeholder),
+        Modifier.fillMaxWidth(),
+        textAlign = TextAlign.Center,
+        color = HighOrLowlight
+      )
+    },
+    color = HighOrLowlight,
+    textStyle = TextStyle.Default.copy(textAlign = TextAlign.Center),
+    keyboardActions = KeyboardActions(onDone = { updateValue(value) })
+  ) {
+    value = it
+  }
+  DisposableEffect(Unit) {
+    onDispose { updateValue(value) }
+  }
+}
+
+@Composable
+fun NetworkStatusRow(networkStatus: Chat.NetworkStatus) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.network_status),
+          networkStatus.statusExplanation
+        )
+      },
+    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
+      )
+    }
+
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+      Text(
+        networkStatus.statusString,
+        color = HighOrLowlight
+      )
+      ServerImage(networkStatus)
+    }
+  }
+}
+
+@Composable
+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)
+    }
+  }
+}
+
+@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 NtfsSwitch(
+  ntfsEnabled: Boolean,
+  toggleNtfs: (Boolean) -> Unit
+) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+      Icon(
+        Icons.Outlined.Notifications,
+        stringResource(R.string.notifications),
+        tint = HighOrLowlight
+      )
+      Text(stringResource(R.string.notifications))
+    }
+    Switch(
+      checked = ntfsEnabled,
+      onCheckedChange = toggleNtfs,
+      colors = SwitchDefaults.colors(
+        checkedThumbColor = MaterialTheme.colors.primary,
+        uncheckedThumbColor = HighOrLowlight
+      ),
+    )
+  }
+}
+
+@Composable
+fun ClearChatButton(clearChat: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { clearChat() },
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Restore,
+      stringResource(R.string.clear_chat_button),
+      tint = WarningOrange
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.clear_chat_button), color = WarningOrange)
+  }
+}
+
+@Composable
+fun DeleteContactButton(deleteContact: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { deleteContact() },
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Delete,
+      stringResource(R.string.button_delete_contact),
+      tint = Color.Red
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.button_delete_contact), color = Color.Red)
+  }
+}
+
+private fun setContactAlias(contactApiId: Long, localAlias: String, chatModel: ChatModel, onChatUpdated: (Chat) -> Unit) = withApi {
+  chatModel.controller.apiSetContactAlias(contactApiId, localAlias)?.let {
+    chatModel.updateContact(it)
+    onChatUpdated(chatModel.getChat(chatModel.chatId.value ?: return@withApi) ?: return@withApi)
   }
 }
 
@@ -130,7 +422,14 @@ fun PreviewChatInfoLayout() {
         chatItems = arrayListOf(),
         serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
       ),
-      close = {}, deleteContact = {}
+      Contact.sampleData,
+      localAlias = "",
+      changeNtfsState = {},
+      developerTools = false,
+      connStats = null,
+      onLocalAliasChanged = {},
+      customUserProfile = null,
+      deleteContact = {}, clearChat = {}
     )
   }
 }

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

@@ -0,0 +1,60 @@
+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.InsertDriveFile
+import androidx.compose.material.icons.outlined.Close
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.item.SentColorLight
+
+@Composable
+fun ComposeFileView(fileName: String, cancelFile: () -> Unit, cancelEnabled: Boolean) {
+  Row(
+    Modifier
+      .height(60.dp)
+      .fillMaxWidth()
+      .padding(top = 8.dp)
+      .background(SentColorLight),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Filled.InsertDriveFile,
+      stringResource(R.string.icon_descr_file),
+      Modifier
+        .padding(start = 4.dp, end = 2.dp)
+        .size(36.dp),
+      tint = if (isInDarkTheme()) FileDark else FileLight
+    )
+    Text(fileName)
+    Spacer(Modifier.weight(1f))
+    if (cancelEnabled) {
+      IconButton(onClick = cancelFile, 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 PreviewComposeFileView() {
+  SimpleXTheme {
+    ComposeFileView(
+      "test.txt",
+      cancelFile = {},
+      cancelEnabled = true
+    )
+  }
+}

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

@@ -0,0 +1,47 @@
+import androidx.compose.foundation.Image
+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.outlined.Close
+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.views.chat.item.SentColorLight
+import chat.simplex.app.views.helpers.base64ToBitmap
+
+@Composable
+fun ComposeImageView(image: String, cancelImage: () -> Unit, cancelEnabled: Boolean) {
+  Row(
+    Modifier
+      .fillMaxWidth()
+      .padding(top = 8.dp)
+      .background(SentColorLight),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    val imageBitmap = base64ToBitmap(image).asImageBitmap()
+    Image(
+      imageBitmap,
+      "preview image",
+      modifier = Modifier
+        .width(80.dp)
+        .height(60.dp)
+        .padding(end = 8.dp)
+    )
+    Spacer(Modifier.weight(1f))
+    if (cancelEnabled) {
+      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,30 +1,488 @@
 package chat.simplex.app.views.chat
 
-import androidx.compose.foundation.layout.Column
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
-import chat.simplex.app.model.ChatItem
+import ComposeFileView
+import ComposeImageView
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.graphics.Bitmap
+import android.graphics.ImageDecoder
+import android.net.Uri
+import android.provider.MediaStore
+import android.util.Log
+import android.widget.Toast
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.annotation.CallSuper
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.Icon
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.AttachFile
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.outlined.Reply
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.core.content.FileProvider
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.views.chat.item.*
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import java.io.File
 
-// TODO ComposeState
+sealed class ComposePreview {
+  object NoPreview: ComposePreview()
+  class CLinkPreview(val linkPreview: LinkPreview?): ComposePreview()
+  class ImagePreview(val image: String): ComposePreview()
+  class FilePreview(val fileName: String): ComposePreview()
+}
+
+sealed class ComposeContextItem {
+  object NoContextItem: ComposeContextItem()
+  class QuotedItem(val chatItem: ChatItem): ComposeContextItem()
+  class EditingItem(val chatItem: ChatItem): ComposeContextItem()
+}
+
+data class ComposeState(
+  val message: String = "",
+  val preview: ComposePreview = ComposePreview.NoPreview,
+  val contextItem: ComposeContextItem = ComposeContextItem.NoContextItem,
+  val inProgress: Boolean = false,
+  val useLinkPreviews: Boolean
+) {
+  constructor(editingItem: ChatItem, useLinkPreviews: Boolean): this (
+    editingItem.content.text,
+    chatItemPreview(editingItem),
+    ComposeContextItem.EditingItem(editingItem),
+    useLinkPreviews = useLinkPreviews
+  )
+
+  val editing: Boolean
+    get() =
+      when (contextItem) {
+        is ComposeContextItem.EditingItem -> true
+        else -> false
+      }
+  val sendEnabled: () -> Boolean
+    get() = {
+      val hasContent = when (preview) {
+        is ComposePreview.ImagePreview -> true
+        is ComposePreview.FilePreview -> true
+        else -> message.isNotEmpty()
+      }
+      hasContent && !inProgress
+    }
+  val linkPreviewAllowed: Boolean
+    get() =
+      when (preview) {
+        is ComposePreview.ImagePreview -> false
+        is ComposePreview.FilePreview -> false
+        else -> useLinkPreviews
+      }
+  val linkPreview: LinkPreview?
+    get() =
+      when (preview) {
+        is ComposePreview.CLinkPreview -> preview.linkPreview
+        else -> null
+      }
+}
+
+fun chatItemPreview(chatItem: ChatItem): ComposePreview {
+  return when (val mc = chatItem.content.msgContent) {
+    is MsgContent.MCText -> ComposePreview.NoPreview
+    is MsgContent.MCLink -> ComposePreview.CLinkPreview(linkPreview = mc.preview)
+    is MsgContent.MCImage -> ComposePreview.ImagePreview(image = mc.image)
+    is MsgContent.MCFile -> {
+      val fileName = chatItem.file?.fileName ?: ""
+      ComposePreview.FilePreview(fileName)
+    }
+    else -> ComposePreview.NoPreview
+  }
+}
 
 @Composable
 fun ComposeView(
-  msg: MutableState<String>,
-  quotedItem: MutableState<ChatItem?>,
-  editingItem: MutableState<ChatItem?>,
-  sendMessage: (String) -> Unit,
-  resetMessage: () -> Unit
+  chatModel: ChatModel,
+  chat: Chat,
+  composeState: MutableState<ComposeState>,
+  attachmentOption: MutableState<AttachmentOption?>,
+  showChooseAttachment: () -> Unit
 ) {
-  Column {
-    when {
-      quotedItem.value != null -> {
-        ContextItemView(quotedItem)
+  val context = LocalContext.current
+  val linkUrl = remember { mutableStateOf<String?>(null) }
+  val prevLinkUrl = remember { mutableStateOf<String?>(null) }
+  val pendingLinkUrl = remember { mutableStateOf<String?>(null) }
+  val cancelledLinks = remember { mutableSetOf<String>() }
+  val useLinkPreviews = chatModel.controller.appPrefs.privacyLinkPreviews.get()
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+  // attachments
+  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val chosenFile = remember { mutableStateOf<Uri?>(null) }
+  val photoUri = remember { mutableStateOf<Uri?>(null) }
+  val photoTmpFile = remember { mutableStateOf<File?>(null) }
+
+  class ComposeTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
+    @CallSuper
+    override fun createIntent(context: Context, input: Void?): Intent {
+      photoTmpFile.value = File.createTempFile("image", ".bmp", SimplexApp.context.filesDir)
+      photoUri.value = FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", photoTmpFile.value!!)
+      return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+        .putExtra(MediaStore.EXTRA_OUTPUT, photoUri.value)
+    }
+
+    override fun getSynchronousResult(
+      context: Context,
+      input: Void?
+    ): SynchronousResult<Bitmap?>? = null
+
+    override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
+      val photoUriVal = photoUri.value
+      val photoTmpFileVal = photoTmpFile.value
+      return if (resultCode == Activity.RESULT_OK && photoUriVal != null && photoTmpFileVal != null) {
+        val source = ImageDecoder.createSource(SimplexApp.context.contentResolver, photoUriVal)
+        val bitmap = ImageDecoder.decodeBitmap(source)
+        photoTmpFileVal.delete()
+        bitmap
+      } else {
+        Log.e(TAG, "Getting image from camera cancelled or failed.")
+        photoTmpFile.value?.delete()
+        null
       }
-      editingItem.value != null -> {
-        ContextItemView(editingItem, editing = editingItem.value != null, resetMessage)
+    }
+  }
+
+  val cameraLauncher = rememberLauncherForActivityResult(contract = ComposeTakePicturePreview()) { bitmap: Bitmap? ->
+    if (bitmap != null) {
+      chosenImage.value = bitmap
+      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
+    }
+  }
+  val cameraPermissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
+    if (isGranted) {
+      cameraLauncher.launch(null)
+    } else {
+      Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
+    }
+  }
+  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
+    if (uri != null) {
+      val source = ImageDecoder.createSource(context.contentResolver, uri)
+      val bitmap = ImageDecoder.decodeBitmap(source)
+      chosenImage.value = bitmap
+      val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+      composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
+    }
+  }
+  val 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(preview = ComposePreview.FilePreview(fileName))
+        }
+      } else {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.large_file),
+          String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(MAX_FILE_SIZE))
+        )
+      }
+    }
+  }
+
+  LaunchedEffect(attachmentOption.value) {
+    when (attachmentOption.value) {
+      AttachmentOption.TakePhoto -> {
+        when (PackageManager.PERMISSION_GRANTED) {
+          ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
+            cameraLauncher.launch(null)
+          }
+          else -> {
+            cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
+          }
+        }
+        attachmentOption.value = null
+      }
+      AttachmentOption.PickImage -> {
+        galleryLauncher.launch("image/*")
+        attachmentOption.value = null
+      }
+      AttachmentOption.PickFile -> {
+        filesLauncher.launch("*/*")
+        attachmentOption.value = null
       }
       else -> {}
     }
-    SendMsgView(msg, sendMessage, editing = editingItem.value != null)
+  }
+
+  fun isSimplexLink(link: String): Boolean =
+    link.startsWith("https://simplex.chat", true) || link.startsWith("http://simplex.chat", true)
+
+  fun parseMessage(msg: String): String? {
+    val parsedMsg = runBlocking { chatModel.controller.apiParseMarkdown(msg) }
+    val link = parsedMsg?.firstOrNull { ft -> ft.format is Format.Uri && !cancelledLinks.contains(ft.text) && !isSimplexLink(ft.text) }
+    return link?.text
+  }
+
+  fun loadLinkPreview(url: String, wait: Long? = null) {
+    if (pendingLinkUrl.value == url) {
+      composeState.value = composeState.value.copy(preview = ComposePreview.CLinkPreview(null))
+      withApi {
+        if (wait != null) delay(wait)
+        val lp = getLinkPreview(url)
+        if (lp != null && pendingLinkUrl.value == url) {
+          composeState.value = composeState.value.copy(preview = ComposePreview.CLinkPreview(lp))
+          pendingLinkUrl.value = null
+        }
+      }
+    }
+  }
+
+  fun showLinkPreview(s: String) {
+    prevLinkUrl.value = linkUrl.value
+    linkUrl.value = parseMessage(s)
+    val url = linkUrl.value
+    if (url != null) {
+      if (url != composeState.value.linkPreview?.uri && url != pendingLinkUrl.value) {
+        pendingLinkUrl.value = url
+        loadLinkPreview(url, wait = if (prevLinkUrl.value == url) null else 1500L)
+      }
+    } else {
+      composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+    }
+  }
+
+  fun resetLinkPreview() {
+    linkUrl.value = null
+    prevLinkUrl.value = null
+    pendingLinkUrl.value = null
+    cancelledLinks.clear()
+  }
+
+  fun checkLinkPreview(): MsgContent {
+    val cs = composeState.value
+    return when (val composePreview = cs.preview) {
+      is ComposePreview.CLinkPreview -> {
+        val url = parseMessage(cs.message)
+        val lp = composePreview.linkPreview
+        if (lp != null && url == lp.uri) {
+          MsgContent.MCLink(cs.message, preview = lp)
+        } else {
+          MsgContent.MCText(cs.message)
+        }
+      }
+      else -> MsgContent.MCText(cs.message)
+    }
+  }
+
+  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() {
+    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()
+        }
+      }
+    }
+  }
+
+  fun onMessageChange(s: String) {
+    composeState.value = composeState.value.copy(message = s)
+    if (isShortEmoji(s)) {
+      textStyle.value = if (s.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont
+    } else {
+      textStyle.value = smallFont
+      if (composeState.value.linkPreviewAllowed) {
+        if (s.isNotEmpty()) showLinkPreview(s)
+        else resetLinkPreview()
+      }
+    }
+  }
+
+  fun cancelLinkPreview() {
+    val uri = composeState.value.linkPreview?.uri
+    if (uri != null) {
+      cancelledLinks.add(uri)
+    }
+    pendingLinkUrl.value = null
+    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+  }
+
+  fun cancelImage() {
+    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+    chosenImage.value = null
+  }
+
+  fun cancelFile() {
+    composeState.value = composeState.value.copy(preview = ComposePreview.NoPreview)
+    chosenFile.value = null
+  }
+
+  @Composable
+  fun previewView() {
+    when (val preview = composeState.value.preview) {
+      ComposePreview.NoPreview -> {}
+      is ComposePreview.CLinkPreview -> ComposeLinkView(preview.linkPreview, ::cancelLinkPreview)
+      is ComposePreview.ImagePreview -> ComposeImageView(
+        preview.image,
+        ::cancelImage,
+        cancelEnabled = !composeState.value.editing
+      )
+      is ComposePreview.FilePreview -> ComposeFileView(
+        preview.fileName,
+        ::cancelFile,
+        cancelEnabled = !composeState.value.editing
+      )
+    }
+  }
+
+  @Composable
+  fun contextItemView() {
+    when (val contextItem = composeState.value.contextItem) {
+      ComposeContextItem.NoContextItem -> {}
+      is ComposeContextItem.QuotedItem -> ContextItemView(contextItem.chatItem, Icons.Outlined.Reply) {
+        composeState.value = composeState.value.copy(contextItem = ComposeContextItem.NoContextItem)
+      }
+      is ComposeContextItem.EditingItem -> ContextItemView(contextItem.chatItem, Icons.Filled.Edit) {
+        clearState()
+      }
+    }
+  }
+
+  Column {
+    contextItemView()
+    when {
+      composeState.value.editing && composeState.value.preview is ComposePreview.FilePreview -> {}
+      else -> previewView()
+    }
+    Row(
+      modifier = Modifier.padding(start = 4.dp, end = 8.dp),
+      verticalAlignment = Alignment.Bottom,
+      horizontalArrangement = Arrangement.spacedBy(2.dp)
+    ) {
+      val attachEnabled = !composeState.value.editing
+      Box(Modifier.padding(bottom = 12.dp)) {
+        Icon(
+          Icons.Filled.AttachFile,
+          contentDescription = stringResource(R.string.attach),
+          tint = if (attachEnabled) MaterialTheme.colors.primary else Color.Gray,
+          modifier = Modifier
+            .size(28.dp)
+            .clip(CircleShape)
+            .clickable {
+              if (attachEnabled) {
+                showChooseAttachment()
+              }
+            }
+        )
+      }
+      SendMsgView(
+        composeState,
+        sendMessage = {
+          sendMessage()
+          resetLinkPreview()
+        },
+        ::onMessageChange,
+        textStyle
+      )
+    }
   }
 }

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

@@ -4,72 +4,65 @@ 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.Edit
 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.text.buildAnnotatedString
-import androidx.compose.ui.text.withStyle
+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 chat.simplex.app.R
 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.*
 import kotlinx.datetime.Clock
 
 @Composable
 fun ContextItemView(
-  contextItem: MutableState<ChatItem?>,
-  editing: Boolean = false,
-  resetMessage: () -> Unit = {}
+  contextItem: ChatItem,
+  contextIcon: ImageVector,
+  cancelContextItem: () -> Unit
 ) {
-  val cxtItem = contextItem.value
-  if (cxtItem != null) {
-    val sent = cxtItem.chatDir.sent
+  val sent = contextItem.chatDir.sent
+  Row(
+    Modifier
+      .padding(top = 8.dp)
+      .background(if (sent) SentColorLight else ReceivedColorLight),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
     Row(
       Modifier
-        .padding(top = 8.dp)
-        .background(if (sent) SentColorLight else ReceivedColorLight),
+        .padding(vertical = 12.dp)
+        .fillMaxWidth()
+        .weight(1F),
       verticalAlignment = Alignment.CenterVertically
     ) {
-      Box(
-        Modifier
-          .padding(start = 16.dp)
-          .padding(vertical = 12.dp)
-          .fillMaxWidth()
-          .weight(1F)
-      ) {
-        ContextItemText(cxtItem)
-      }
-      IconButton(onClick = {
-        contextItem.value = null
-        if (editing) {
-          resetMessage()
-        }
-      }) {
-        Icon(
-          Icons.Outlined.Close,
-          contentDescription = "Cancel",
-          tint = MaterialTheme.colors.primary,
-          modifier = Modifier.padding(10.dp)
-        )
-      }
+      Icon(
+        contextIcon,
+        modifier = Modifier
+          .padding(horizontal = 8.dp)
+          .height(20.dp)
+          .width(20.dp),
+        contentDescription = stringResource(R.string.icon_descr_context),
+        tint = HighOrLowlight,
+      )
+      MarkdownText(
+        contextItem.text, contextItem.formattedText,
+        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3
+      )
     }
-  }
-}
-
-@Composable
-private fun ContextItemText(cxtItem: ChatItem) {
-  val member = cxtItem.memberDisplayName
-  if (member == null) {
-    Text(cxtItem.content.text, maxLines = 3)
-  } else {
-    val annotatedText = buildAnnotatedString {
-      withStyle(boldFont) { append(member) }
-      append(": ${cxtItem.content.text}")
+    IconButton(onClick = cancelContextItem) {
+      Icon(
+        Icons.Outlined.Close,
+        contentDescription = stringResource(R.string.cancel_verb),
+        tint = MaterialTheme.colors.primary,
+        modifier = Modifier.padding(10.dp)
+      )
     }
-    Text(annotatedText, maxLines = 3)
   }
 }
 
@@ -78,13 +71,9 @@ private fun ContextItemText(cxtItem: ChatItem) {
 fun PreviewContextItemView() {
   SimpleXTheme {
     ContextItemView(
-      contextItem = remember {
-        mutableStateOf(
-          ChatItem.getSampleData(
-            1, CIDirection.DirectRcv(), Clock.System.now(), "hello"
-          )
-        )
-      }
+      contextItem = ChatItem.getSampleData(1, CIDirection.DirectRcv(), Clock.System.now(), "hello"),
+      contextIcon = Icons.Filled.Edit,
+      cancelContextItem = {}
     )
   }
 }

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

@@ -12,39 +12,53 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.outlined.ArrowUpward
 import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
+import androidx.compose.ui.*
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 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.TextStyle
 import androidx.compose.ui.text.input.KeyboardCapitalization
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+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.chat.item.*
+import kotlinx.coroutines.delay
 
+@OptIn(ExperimentalComposeUiApi::class)
 @Composable
-fun SendMsgView(msg: MutableState<String>, sendMessage: (String) -> Unit, editing: Boolean = false) {
-  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
-  var textStyle by remember { mutableStateOf(smallFont) }
+fun SendMsgView(
+  composeState: MutableState<ComposeState>,
+  sendMessage: () -> Unit,
+  onMessageChange: (String) -> Unit,
+  textStyle: MutableState<TextStyle>
+) {
+  val cs = composeState.value
+  val focusRequester = remember { FocusRequester() }
+  val keyboard = LocalSoftwareKeyboardController.current
+  LaunchedEffect(cs.contextItem) {
+    if (cs.contextItem !is ComposeContextItem.QuotedItem) return@LaunchedEffect
+    // In replying state
+    focusRequester.requestFocus()
+    delay(50)
+    keyboard?.show()
+  }
+
   BasicTextField(
-    value = msg.value,
-    onValueChange = {
-      msg.value = it
-      textStyle = if (isShortEmoji(it)) {
-        if (it.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont
-      } else {
-        smallFont
-      }
-    },
-    textStyle = textStyle,
+    value = cs.message,
+    onValueChange = onMessageChange,
+    textStyle = textStyle.value,
     maxLines = 16,
     keyboardOptions = KeyboardOptions.Default.copy(
       capitalization = KeyboardCapitalization.Sentences,
       autoCorrect = true
     ),
-    modifier = Modifier.padding(8.dp),
+    modifier = Modifier.padding(vertical = 8.dp).focusRequester(focusRequester),
     cursorBrush = SolidColor(HighOrLowlight),
     decorationBox = { innerTextField ->
       Surface(
@@ -64,24 +78,35 @@ fun SendMsgView(msg: MutableState<String>, sendMessage: (String) -> Unit, editin
           ) {
             innerTextField()
           }
-          val color = if (msg.value.isNotEmpty()) MaterialTheme.colors.primary else Color.Gray
-          Icon(
-            if (editing) Icons.Filled.Check else Icons.Outlined.ArrowUpward,
-            "Send Message",
-            tint = Color.White,
-            modifier = Modifier
-              .size(36.dp)
-              .padding(4.dp)
-              .clip(CircleShape)
-              .background(color)
-              .clickable {
-                if (msg.value.isNotEmpty()) {
-                  sendMessage(msg.value)
-                  msg.value = ""
-                  textStyle = smallFont
+          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()
+                  }
                 }
-              }
-          )
+            )
+          }
         }
       }
     }
@@ -96,10 +121,14 @@ fun SendMsgView(msg: MutableState<String>, sendMessage: (String) -> Unit, editin
 )
 @Composable
 fun PreviewSendMsgView() {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
   SimpleXTheme {
     SendMsgView(
-      msg = remember { mutableStateOf("") },
-      sendMessage = { msg -> println(msg) }
+      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
+      sendMessage = {},
+      onMessageChange = { _ -> },
+      textStyle = textStyle
     )
   }
 }
@@ -112,11 +141,36 @@ fun PreviewSendMsgView() {
 )
 @Composable
 fun PreviewSendMsgViewEditing() {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+  val composeStateEditing = ComposeState(editingItem = ChatItem.getSampleData(), useLinkPreviews = true)
   SimpleXTheme {
     SendMsgView(
-      msg = remember { mutableStateOf("") },
-      sendMessage = { msg -> println(msg) },
-      editing = true
+      composeState = remember { mutableStateOf(composeStateEditing) },
+      sendMessage = {},
+      onMessageChange = { _ -> },
+      textStyle = textStyle
+    )
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewSendMsgViewInProgress() {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+  val composeStateInProgress = ComposeState(preview = ComposePreview.FilePreview("test.txt"), inProgress = true, useLinkPreviews = true)
+  SimpleXTheme {
+    SendMsgView(
+      composeState = remember { mutableStateOf(composeStateInProgress) },
+      sendMessage = {},
+      onMessageChange = { _ -> },
+      textStyle = textStyle
     )
   }
 }

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

@@ -0,0 +1,356 @@
+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.runtime.snapshots.SnapshotStateList
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+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.*
+
+@Composable
+fun AddGroupMembersView(groupInfo: GroupInfo, chatModel: ChatModel, close: () -> Unit) {
+  val selectedContacts = remember { mutableStateListOf<Long>() }
+  val selectedRole = remember { mutableStateOf(GroupMemberRole.Admin) }
+
+  BackHandler(onBack = close)
+  AddGroupMembersLayout(
+    groupInfo = groupInfo,
+    contactsToAdd = getContactsToAdd(chatModel),
+    selectedContacts = selectedContacts,
+    selectedRole = selectedRole,
+    inviteMembers = {
+      withApi {
+        selectedContacts.forEach {
+          val member = chatModel.controller.apiAddMember(groupInfo.groupId, it, selectedRole.value)
+          if (member != null) {
+            chatModel.upsertGroupMember(groupInfo, member)
+          }
+        }
+        close.invoke()
+      }
+    },
+    clearSelection = { selectedContacts.clear() },
+    addContact = { contactId -> if (contactId !in selectedContacts) selectedContacts.add(contactId) },
+    removeContact = { contactId -> selectedContacts.removeIf { it == contactId } },
+  )
+}
+
+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,
+  contactsToAdd: List<Contact>,
+  selectedContacts: SnapshotStateList<Long>,
+  selectedRole: MutableState<GroupMemberRole>,
+  inviteMembers: () -> Unit,
+  clearSelection: () -> Unit,
+  addContact: (Long) -> Unit,
+  removeContact: (Long) -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxWidth()
+      .verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    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 {
+        SectionItemView {
+          RoleSelectionRow(groupInfo, selectedRole)
+        }
+        SectionDivider()
+        SectionItemView {
+          InviteMembersButton(inviteMembers, disabled = selectedContacts.isEmpty())
+        }
+      }
+      SectionCustomFooter {
+        InviteSectionFooter(selectedContactsCount = selectedContacts.count(), clearSelection)
+      }
+      SectionSpacer()
+
+      SectionView {
+        ContactList(contacts = contactsToAdd, selectedContacts, groupInfo, addContact, removeContact)
+      }
+      SectionSpacer()
+    }
+  }
+}
+
+@Composable
+fun RoleSelectionRow(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    Text(stringResource(R.string.new_member_role))
+    RoleDropdownMenu(groupInfo, selectedRole)
+  }
+}
+
+@Composable
+fun RoleDropdownMenu(groupInfo: GroupInfo, selectedRole: MutableState<GroupMemberRole>) {
+  val options = GroupMemberRole.values()
+    .filter { it <= groupInfo.membership.memberRole }
+  var expanded by remember { mutableStateOf(false) }
+
+  ExposedDropdownMenuBox(
+    expanded = expanded,
+    onExpandedChange = {
+      expanded = !expanded
+    }
+  ) {
+    Row(
+      Modifier.fillMaxWidth(0.7f),
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.End
+    ) {
+      Text(
+        selectedRole.value.text,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        color = HighOrLowlight
+      )
+      Spacer(Modifier.size(4.dp))
+      Icon(
+        if (!expanded) Icons.Outlined.ExpandMore else Icons.Outlined.ExpandLess,
+        generalGetString(R.string.invite_to_group_button),
+        modifier = Modifier.padding(start = 8.dp),
+        tint = HighOrLowlight
+      )
+    }
+    ExposedDropdownMenu(
+      expanded = expanded,
+      onDismissRequest = {
+        expanded = false
+      }
+    ) {
+      options.forEach { selectionOption ->
+        DropdownMenuItem(
+          onClick = {
+            selectedRole.value = selectionOption
+            expanded = false
+          }
+        ) {
+          Text(
+            selectionOption.text,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+          )
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun InviteMembersButton(inviteMembers: () -> Unit, disabled: Boolean) {
+  val modifier = if (disabled) Modifier else Modifier.clickable { inviteMembers() }
+  Row(
+    modifier.fillMaxSize(),
+    horizontalArrangement = Arrangement.End,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    val color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+    Text(stringResource(R.string.invite_to_group_button), color = color)
+    Spacer(Modifier.size(8.dp))
+    Icon(
+      Icons.Outlined.Check,
+      stringResource(R.string.invite_to_group_button),
+      tint = color
+    )
+  }
+}
+
+@Composable
+fun InviteSectionFooter(selectedContactsCount: Int, clearSelection: () -> Unit) {
+  Row(
+    Modifier.fillMaxWidth(),
+    horizontalArrangement = if (selectedContactsCount >= 1) Arrangement.SpaceBetween else Arrangement.End,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    if (selectedContactsCount >= 1) {
+      Box(
+        Modifier.clickable { clearSelection() }
+      ) {
+        Text(
+          stringResource(R.string.clear_contacts_selection_button),
+          color = MaterialTheme.colors.primary,
+          fontSize = 12.sp
+        )
+      }
+
+      Text(
+        String.format(generalGetString(R.string.num_contacts_selected), selectedContactsCount),
+        color = HighOrLowlight,
+        fontSize = 12.sp
+      )
+    } else {
+      Text(
+        stringResource(R.string.no_contacts_selected),
+        color = HighOrLowlight,
+        fontSize = 12.sp
+      )
+    }
+  }
+}
+
+@Composable
+fun ContactList(
+  contacts: List<Contact>,
+  selectedContacts: SnapshotStateList<Long>,
+  groupInfo: GroupInfo,
+  addContact: (Long) -> Unit,
+  removeContact: (Long) -> Unit
+) {
+  Column {
+    contacts.forEachIndexed { index, contact ->
+      SectionItemView {
+        ContactCheckRow(
+          contact, groupInfo, addContact, removeContact,
+          checked = selectedContacts.contains(contact.apiId)
+        )
+      }
+      if (index < contacts.lastIndex) {
+        SectionDivider()
+      }
+    }
+  }
+}
+
+@Composable
+fun ContactCheckRow(
+  contact: Contact,
+  groupInfo: GroupInfo,
+  addContact: (Long) -> Unit,
+  removeContact: (Long) -> Unit,
+  checked: 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 = MaterialTheme.colors.primary
+  } else {
+    icon = Icons.Outlined.Circle
+    iconColor = HighOrLowlight
+  }
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable {
+        if (prohibitedToInviteIncognito) {
+          showProhibitedToInviteIncognitoAlertDialog()
+        } else if (!checked)
+          addContact(contact.apiId)
+        else
+          removeContact(contact.apiId)
+      },
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+      ProfileImage(size = 36.dp, contact.image)
+      Text(
+        contact.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
+        color = if (prohibitedToInviteIncognito) HighOrLowlight else Color.Unspecified
+      )
+    }
+    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,
+      contactsToAdd = listOf(Contact.sampleData, Contact.sampleData, Contact.sampleData),
+      selectedContacts = remember { mutableStateListOf() },
+      selectedRole = remember { mutableStateOf(GroupMemberRole.Admin) },
+      inviteMembers = {},
+      clearSelection = {},
+      addContact = {},
+      removeContact = {}
+    )
+  }
+}

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

@@ -0,0 +1,373 @@
+package chat.simplex.app.views.chat.group
+
+import InfoRow
+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.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.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.*
+
+@Composable
+fun GroupChatInfoView(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 && 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,
+      addMembers = {
+        withApi {
+          setGroupMembers(groupInfo, chatModel)
+          ModalManager.shared.showCustomModal { close ->
+            ModalView(
+              close = close, modifier = Modifier,
+              background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+            ) {
+              AddGroupMembersView(groupInfo, chatModel, close)
+            }
+          }
+        }
+      },
+      showMemberInfo = { member ->
+        withApi {
+          val stats = chatModel.controller.apiGroupMemberInfo(groupInfo.groupId, member.groupMemberId)
+          ModalManager.shared.showCustomModal { closeCurrent ->
+            ModalView(
+              close = closeCurrent, modifier = Modifier,
+              background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+            ) {
+              GroupMemberInfoView(groupInfo, member, stats, chatModel, closeCurrent) { closeCurrent(); close() }
+            }
+          }
+        }
+      },
+      editGroupProfile = {
+        ModalManager.shared.showCustomModal { close -> GroupProfileView(groupInfo, chatModel, close) }
+      },
+      deleteGroup = { deleteGroupDialog(chat.chatInfo, chatModel, close) },
+      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) },
+      leaveGroup = { leaveGroupDialog(groupInfo, chatModel, close) },
+      changeNtfsState = { enabled ->
+        changeNtfsState(enabled, chat, chatModel)
+      },
+    )
+  }
+}
+
+fun deleteGroupDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
+  AlertManager.shared.showAlertMsg(
+    title = generalGetString(R.string.delete_group_question),
+    text = generalGetString(R.string.delete_group_for_all_members_cannot_undo_warning),
+    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,
+  addMembers: () -> Unit,
+  showMemberInfo: (GroupMember) -> Unit,
+  editGroupProfile: () -> Unit,
+  deleteGroup: () -> Unit,
+  clearChat: () -> Unit,
+  leaveGroup: () -> Unit,
+  changeNtfsState: (Boolean) -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxWidth()
+      .verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start
+  ) {
+    Row(
+      Modifier.fillMaxWidth(),
+      horizontalArrangement = Arrangement.Center
+    ) {
+      GroupChatInfoHeader(chat.chatInfo)
+    }
+    SectionSpacer()
+
+    SectionView(title = String.format(generalGetString(R.string.group_info_section_title_num_members), members.count() + 1)) {
+      if (groupInfo.canAddMembers) {
+        SectionItemView {
+          val tint = if (chat.chatInfo.incognito) HighOrLowlight else MaterialTheme.colors.primary
+          val onClick = if (chat.chatInfo.incognito) ::cantInviteIncognitoAlert else addMembers
+          AddMembersButton(tint, onClick)
+        }
+        SectionDivider()
+      }
+      SectionItemView(height = 50.dp) {
+        MemberRow(groupInfo.membership, user = true)
+      }
+      if (members.isNotEmpty()) {
+        SectionDivider()
+      }
+      MembersList(members, showMemberInfo)
+    }
+    SectionSpacer()
+
+    var ntfsEnabled by remember { mutableStateOf(chat.chatInfo.ntfsEnabled) }
+    SectionView(title = stringResource(R.string.settings_section_title_settings)) {
+      SectionItemView {
+        NtfsSwitch(ntfsEnabled) {
+          ntfsEnabled = !ntfsEnabled
+          changeNtfsState(ntfsEnabled)
+        }
+      }
+    }
+    SectionSpacer()
+
+    SectionView {
+      if (groupInfo.canEdit) {
+        SectionItemView {
+          EditGroupProfileButton(editGroupProfile)
+        }
+        SectionDivider()
+      }
+      SectionItemView {
+        ClearChatButton(clearChat)
+      }
+      if (groupInfo.canDelete) {
+        SectionDivider()
+        SectionItemView {
+          DeleteGroupButton(deleteGroup)
+        }
+      }
+      if (groupInfo.membership.memberCurrent) {
+        SectionDivider()
+        SectionItemView {
+          LeaveGroupButton(leaveGroup)
+        }
+      }
+    }
+    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
+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
+fun AddMembersButton(tint: Color = MaterialTheme.colors.primary, addMembers: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { addMembers() },
+    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
+fun MembersList(members: List<GroupMember>, showMemberInfo: (GroupMember) -> Unit) {
+  Column {
+    members.forEachIndexed { index, member ->
+      SectionItemView(height = 50.dp) {
+        MemberRow(member, showMemberInfo)
+      }
+      if (index < members.lastIndex) {
+        SectionDivider()
+      }
+    }
+  }
+}
+
+@Composable
+fun MemberRow(member: GroupMember, showMemberInfo: ((GroupMember) -> Unit)? = null, user: Boolean = false) {
+  val modifier = if (showMemberInfo != null) Modifier.clickable { showMemberInfo(member) } else Modifier
+  Row(
+    modifier.fillMaxSize(),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      horizontalArrangement = Arrangement.spacedBy(4.dp)
+    ) {
+      ProfileImage(size = 46.dp, member.image)
+      Column {
+        Text(member.chatViewName, maxLines = 1, overflow = TextOverflow.Ellipsis,
+        color = if (member.memberIncognito) Indigo else Color.Unspecified)
+        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
+fun EditGroupProfileButton(editGroupProfile: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { editGroupProfile() },
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Edit,
+      stringResource(R.string.button_edit_group_profile),
+      tint = MaterialTheme.colors.primary
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.button_edit_group_profile), color = MaterialTheme.colors.primary)
+  }
+}
+
+@Composable
+fun LeaveGroupButton(leaveGroup: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { leaveGroup() },
+    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
+fun DeleteGroupButton(deleteGroup: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { deleteGroup() },
+    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,
+      addMembers = {}, showMemberInfo = {}, editGroupProfile = {}, deleteGroup = {}, clearChat = {}, leaveGroup = {},
+      changeNtfsState = {},
+    )
+  }
+}

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

@@ -0,0 +1,242 @@
+package chat.simplex.app.views.chat.group
+
+import InfoRow
+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.outlined.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.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.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.SimplexServers
+import chat.simplex.app.views.chatlist.openChat
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun GroupMemberInfoView(
+  groupInfo: GroupInfo,
+  member: GroupMember,
+  connStats: ConnectionStats?,
+  chatModel: ChatModel,
+  close: () -> Unit,
+  closeAll: () -> Unit, // Close all open windows up to ChatView
+) {
+  BackHandler(onBack = close)
+  val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
+  val developerTools = chatModel.controller.appPrefs.developerTools.get()
+  if (chat != null) {
+    GroupMemberInfoLayout(
+      groupInfo,
+      member,
+      connStats,
+      developerTools,
+      openDirectChat = {
+        withApi {
+          val oldChat = chatModel.getContactChat(member.memberContactId ?: return@withApi)
+          if (oldChat != null) {
+            openChat(oldChat.chatInfo, chatModel)
+          } else {
+            var newChat = chatModel.controller.apiGetChat(ChatType.Direct, member.memberContactId) ?: return@withApi
+            // TODO it's not correct to blindly set network status to connected - we should manage network status in model / backend
+            newChat = newChat.copy(serverInfo = Chat.ServerInfo(networkStatus = Chat.NetworkStatus.Connected()))
+            chatModel.addChat(newChat)
+            chatModel.chatItems.clear()
+            chatModel.chatId.value = newChat.id
+          }
+          closeAll()
+        }
+      },
+      removeMember = { removeMemberDialog(groupInfo, member, chatModel, close) }
+    )
+  }
+}
+
+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?,
+  developerTools: Boolean,
+  openDirectChat: () -> Unit,
+  removeMember: () -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxWidth()
+      .verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start
+  ) {
+    Row(
+      Modifier.fillMaxWidth(),
+      horizontalArrangement = Arrangement.Center
+    ) {
+      GroupMemberInfoHeader(member)
+    }
+    SectionSpacer()
+
+    SectionView {
+      SectionItemView {
+        OpenChatButton(openDirectChat)
+      }
+    }
+    SectionSpacer()
+
+    SectionView(title = stringResource(R.string.member_info_section_title_member)) {
+      InfoRow(stringResource(R.string.info_row_group), groupInfo.displayName)
+      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) {
+      val rcvServers = connStats.rcvServers
+      val sndServers = connStats.sndServers
+      if ((rcvServers != null && rcvServers.isNotEmpty()) || (sndServers != null && sndServers.isNotEmpty())) {
+        SectionView(title = stringResource(R.string.conn_stats_section_title_servers)) {
+          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.membership)) {
+      SectionView {
+        SectionItemView {
+          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)
+    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(removeMember: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { removeMember() },
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Delete,
+      stringResource(R.string.button_remove_member),
+      tint = Color.Red
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.button_remove_member), color = Color.Red)
+  }
+}
+
+@Composable
+fun OpenChatButton(onClick: () -> Unit) {
+  Row(
+    Modifier
+      .fillMaxSize()
+      .clickable { onClick() },
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Icon(
+      Icons.Outlined.Message,
+      stringResource(R.string.button_send_direct_message),
+      Modifier.padding(top = 5.dp),
+      tint = MaterialTheme.colors.primary
+    )
+    Spacer(Modifier.size(8.dp))
+    Text(stringResource(R.string.button_send_direct_message), color = MaterialTheme.colors.primary)
+  }
+}
+
+@Preview
+@Composable
+fun PreviewGroupMemberInfoLayout() {
+  SimpleXTheme {
+    GroupMemberInfoLayout(
+      groupInfo = GroupInfo.sampleData,
+      member = GroupMember.sampleData,
+      connStats = null,
+      developerTools = false,
+      openDirectChat = {},
+      removeMember = {}
+    )
+  }
+}

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

@@ -0,0 +1,173 @@
+package chat.simplex.app.views.chat.group
+
+import android.content.res.Configuration
+import android.graphics.Bitmap
+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.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.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleXTheme
+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.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 = remember { mutableStateOf<Bitmap?>(null) }
+  val profileImage = remember { 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(bottom = 16.dp),
+          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) {
+            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

@@ -0,0 +1,157 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.Icon
+import androidx.compose.material.Text
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.PhoneInTalk
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+
+@Composable
+fun CICallItemView(cInfo: ChatInfo, cItem: ChatItem, status: CICallStatus, duration: Int, acceptCall: (Contact) -> Unit) {
+  val sent = cItem.chatDir.sent
+  Column(
+    Modifier
+      .padding(horizontal = 4.dp)
+      .padding(bottom = 8.dp), horizontalAlignment = Alignment.CenterHorizontally) {
+    @Composable fun ConnectingCallIcon() = Icon(Icons.Outlined.SettingsPhone, stringResource(R.string.icon_descr_call_connecting), tint = Color.Green)
+    when (status) {
+      CICallStatus.Pending -> if (sent) {
+        Icon(Icons.Outlined.Call, stringResource(R.string.icon_descr_call_pending_sent))
+      } else {
+        AcceptCallButton(cInfo, acceptCall)
+      }
+      CICallStatus.Missed -> Icon(Icons.Outlined.Call, stringResource(R.string.icon_descr_call_missed), tint = Color.Red)
+      CICallStatus.Rejected -> Icon(Icons.Outlined.CallEnd, stringResource(R.string.icon_descr_call_rejected), tint = Color.Red)
+      CICallStatus.Accepted -> ConnectingCallIcon()
+      CICallStatus.Negotiated -> ConnectingCallIcon()
+      CICallStatus.Progress -> Icon(Icons.Filled.PhoneInTalk, stringResource(R.string.icon_descr_call_progress), tint = SimplexGreen)
+      CICallStatus.Ended -> Row {
+        Icon(Icons.Outlined.CallEnd, stringResource(R.string.icon_descr_call_ended), tint = HighOrLowlight, modifier = Modifier.padding(end = 4.dp))
+        Text(status.duration(duration), color = HighOrLowlight)
+      }
+      CICallStatus.Error -> {}
+    }
+
+    Text(
+      cItem.timestampText,
+      color = HighOrLowlight,
+      fontSize = 14.sp,
+      modifier = Modifier.padding(start = 3.dp)
+    )
+  }
+}
+
+@Composable
+fun AcceptCallButton(cInfo: ChatInfo, acceptCall: (Contact) -> Unit) {
+  if (cInfo is ChatInfo.Direct) {
+    SimpleButton(stringResource(R.string.answer_call), Icons.Outlined.RingVolume) { acceptCall(cInfo.contact) }
+  } else {
+    Icon(Icons.Outlined.RingVolume, stringResource(R.string.answer_call), tint = HighOrLowlight)
+  }
+//    if case let .direct(contact) = chatInfo {
+//      Button {
+//        if let invitation = m.callInvitations.removeValue(forKey: contact.id) {
+//        m.activeCallInvitation = nil
+//        m.activeCall = Call(
+//          contact: contact,
+//          callState: .invitationReceived,
+//        localMedia: invitation.peerMedia,
+//        sharedKey: invitation.sharedKey
+//        )
+//        m.showCallView = true
+//        m.callCommand = .start(media: invitation.peerMedia, aesKey: invitation.sharedKey, useWorker: true)
+//      } else {
+//        AlertManager.shared.showAlertMsg(title: "Call already ended!")
+//      }
+//      } label: {
+//        Label("Answer call", systemImage: "phone.arrow.down.left")
+//      }
+//    } else {
+//      Image(systemName: "phone.arrow.down.left").foregroundColor(.secondary)
+//    }
+
+}
+
+//struct CICallItemView: View {
+//  @EnvironmentObject var m: ChatModel
+//  var chatInfo: ChatInfo
+//  var chatItem: ChatItem
+//  var status: CICallStatus
+//  var duration: Int
+//
+//  var body: some View {
+//    switch status {
+//      case .pending:
+//      if sent {
+//        Image(systemName: "phone.arrow.up.right").foregroundColor(.secondary)
+//      } else {
+//        acceptCallButton()
+//      }
+//      case .missed: missedCallIcon(sent).foregroundColor(.red)
+//      case .rejected: Image(systemName: "phone.down").foregroundColor(.secondary)
+//      case .accepted: connectingCallIcon()
+//      case .negotiated: connectingCallIcon()
+//      case .progress: Image(systemName: "phone.and.waveform.fill").foregroundColor(.green)
+//      case .ended: endedCallIcon(sent)
+//      case .error: missedCallIcon(sent).foregroundColor(.orange)
+//    }
+//
+//    chatItem.timestampText
+//      .font(.caption)
+//    .foregroundColor(.secondary)
+//    .padding(.bottom, 8)
+//    .padding(.horizontal, 12)
+//  }
+//  }
+//
+//  private func missedCallIcon(_ sent: Bool) -> some View {
+//    Image(systemName: sent ? "phone.arrow.up.right" : "phone.arrow.down.left")
+//  }
+//
+//  private func connectingCallIcon() -> some View {
+//    Image(systemName: "phone.connection").foregroundColor(.green)
+//  }
+//
+//  @ViewBuilder private func endedCallIcon(_ sent: Bool) -> some View {
+//    HStack {
+//      Image(systemName: "phone.down")
+//      Text(CICallStatus.durationText(duration)).foregroundColor(.secondary)
+//    }
+//  }
+//
+//
+//  @ViewBuilder private func acceptCallButton() -> some View {
+//    if case let .direct(contact) = chatInfo {
+//      Button {
+//        if let invitation = m.callInvitations.removeValue(forKey: contact.id) {
+//        m.activeCallInvitation = nil
+//        m.activeCall = Call(
+//          contact: contact,
+//          callState: .invitationReceived,
+//        localMedia: invitation.peerMedia,
+//        sharedKey: invitation.sharedKey
+//        )
+//        m.showCallView = true
+//        m.callCommand = .start(media: invitation.peerMedia, aesKey: invitation.sharedKey, useWorker: true)
+//      } else {
+//        AlertManager.shared.showAlertMsg(title: "Call already ended!")
+//      }
+//      } label: {
+//        Label("Answer call", systemImage: "phone.arrow.down.left")
+//      }
+//    } else {
+//      Image(systemName: "phone.arrow.down.left").foregroundColor(.secondary)
+//    }
+//  }
+//}

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

@@ -0,0 +1,210 @@
+package chat.simplex.app.views.chat.item
+
+import android.widget.Toast
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.InsertDriveFile
+import androidx.compose.material.icons.outlined.*
+import androidx.compose.runtime.*
+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.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+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.*
+import kotlinx.datetime.Clock
+
+@Composable
+fun CIFileView(
+  file: CIFile?,
+  edited: Boolean,
+  receiveFile: (Long) -> Unit
+) {
+  val context = LocalContext.current
+  val saveFileLauncher = rememberSaveFileLauncher(cxt = context, ciFile = file)
+
+  @Composable
+  fun fileIcon(
+    innerIcon: ImageVector? = null,
+    color: Color = if (isInDarkTheme()) FileDark else FileLight
+  ) {
+    Box(
+      contentAlignment = Alignment.Center
+    ) {
+      Icon(
+        Icons.Filled.InsertDriveFile,
+        stringResource(R.string.icon_descr_file),
+        Modifier.fillMaxSize(),
+        tint = color
+      )
+      if (innerIcon != null) {
+        Icon(
+          innerIcon,
+          stringResource(R.string.icon_descr_file),
+          Modifier
+            .size(32.dp)
+            .padding(top = 12.dp),
+          tint = Color.White
+        )
+      }
+    }
+  }
+
+  fun fileSizeValid(): Boolean {
+    if (file != null) {
+      return file.fileSize <= MAX_FILE_SIZE
+    }
+    return false
+  }
+
+  fun fileAction() {
+    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))
+            )
+          }
+        }
+        CIFileStatus.RcvAccepted ->
+          AlertManager.shared.showAlertMsg(
+            generalGetString(R.string.waiting_for_file),
+            String.format(generalGetString(R.string.file_will_be_received_when_contact_is_online), MAX_FILE_SIZE)
+          )
+        CIFileStatus.RcvComplete -> {
+          val filePath = getLoadedFilePath(context, file)
+          if (filePath != null) {
+            saveFileLauncher.launch(file.fileName)
+          } else {
+            Toast.makeText(context, generalGetString(R.string.file_not_found), Toast.LENGTH_SHORT).show()
+          }
+        }
+        else -> {}
+      }
+    }
+  }
+
+  @Composable
+  fun progressIndicator() {
+    CircularProgressIndicator(
+      Modifier.size(32.dp),
+      color = if (isInDarkTheme()) FileDark else FileLight,
+      strokeWidth = 4.dp
+    )
+  }
+
+  @Composable
+  fun fileIndicator() {
+    Box(
+      Modifier
+        .size(42.dp)
+        .clip(RoundedCornerShape(4.dp))
+        .clickable(onClick = { fileAction() }),
+      contentAlignment = Alignment.Center
+    ) {
+      if (file != null) {
+        when (file.fileStatus) {
+          CIFileStatus.SndStored -> fileIcon()
+          CIFileStatus.SndTransfer -> progressIndicator()
+          CIFileStatus.SndComplete -> fileIcon(innerIcon = Icons.Filled.Check)
+          CIFileStatus.SndCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
+          CIFileStatus.RcvInvitation ->
+            if (fileSizeValid())
+              fileIcon(innerIcon = Icons.Outlined.ArrowDownward, color = MaterialTheme.colors.primary)
+            else
+              fileIcon(innerIcon = Icons.Outlined.PriorityHigh, color = WarningOrange)
+          CIFileStatus.RcvAccepted -> fileIcon(innerIcon = Icons.Outlined.MoreHoriz)
+          CIFileStatus.RcvTransfer -> progressIndicator()
+          CIFileStatus.RcvComplete -> fileIcon()
+          CIFileStatus.RcvCancelled -> fileIcon(innerIcon = Icons.Outlined.Close)
+        }
+      } else {
+        fileIcon()
+      }
+    }
+  }
+
+  Row(
+    Modifier.padding(top = 4.dp, bottom = 6.dp, start = 6.dp, end = 12.dp),
+    verticalAlignment = Alignment.Bottom,
+    horizontalArrangement = Arrangement.spacedBy(2.dp)
+  ) {
+    fileIndicator()
+    val metaReserve = if (edited)
+      "                     "
+    else
+      "                 "
+    if (file != null) {
+      Column(
+        horizontalAlignment = Alignment.Start
+      ) {
+        Text(
+          file.fileName,
+          maxLines = 1
+        )
+        Text(
+          formatBytes(file.fileSize) + metaReserve,
+          color = HighOrLowlight,
+          fontSize = 14.sp,
+          maxLines = 1
+        )
+      }
+    } else {
+      Text(metaReserve)
+    }
+  }
+}
+
+class ChatItemProvider: PreviewParameterProvider<ChatItem> {
+  private val sentFile = ChatItem(
+    chatDir = CIDirection.DirectSnd(),
+    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.SndSent(), itemDeleted = false, itemEdited = true, editable = false),
+    content = CIContent.SndMsgContent(msgContent = MsgContent.MCFile("")),
+    quotedItem = null,
+    file = CIFile.getSample(fileStatus = CIFileStatus.SndComplete)
+  )
+  private val fileChatItemWtFile = ChatItem(
+    chatDir = CIDirection.DirectRcv(),
+    meta = CIMeta.getSample(1, Clock.System.now(), "", CIStatus.RcvRead(), itemDeleted = false, itemEdited = false, editable = false),
+    content = CIContent.RcvMsgContent(msgContent = MsgContent.MCFile("")),
+    quotedItem = null,
+    file = null
+  )
+  override val values = listOf(
+    sentFile,
+    ChatItem.getFileMsgContentSample(),
+    ChatItem.getFileMsgContentSample(fileName = "some_long_file_name_here", fileStatus = CIFileStatus.RcvInvitation),
+    ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvAccepted),
+    ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvTransfer),
+    ChatItem.getFileMsgContentSample(fileStatus = CIFileStatus.RcvCancelled),
+    ChatItem.getFileMsgContentSample(fileSize = 1_000_000_000, fileStatus = CIFileStatus.RcvInvitation),
+    ChatItem.getFileMsgContentSample(text = "Hello there", fileStatus = CIFileStatus.RcvInvitation),
+    ChatItem.getFileMsgContentSample(text = "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.", fileStatus = CIFileStatus.RcvInvitation),
+    fileChatItemWtFile
+  ).asSequence()
+}
+
+@Preview
+@Composable
+fun PreviewCIFileFramedItemView(@PreviewParameter(ChatItemProvider::class) chatItem: ChatItem) {
+  val showMenu = remember { mutableStateOf(false) }
+  SimpleXTheme {
+    FramedItemView(User.sampleData, chatItem, showMenu = showMenu, receiveFile = {})
+  }
+}

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

@@ -0,0 +1,59 @@
+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 CIGroupEventView(ci: ChatItem) {
+  fun withGroupEventStyle(builder: AnnotatedString.Builder, text: String) {
+    return builder.withStyle(SpanStyle(fontSize = 12.sp, fontWeight = FontWeight.Light, color = HighOrLowlight)) { append(text) }
+  }
+
+  Surface {
+    Row(
+      Modifier.padding(horizontal = 6.dp, vertical = 6.dp),
+      verticalAlignment = Alignment.Bottom
+    ) {
+      Text(
+        buildAnnotatedString {
+          val memberDisplayName = ci.memberDisplayName
+          if (memberDisplayName != null) {
+            withGroupEventStyle(this, memberDisplayName)
+            append(" ")
+          }
+          withGroupEventStyle(this, ci.content.text)
+          append(" ")
+          withGroupEventStyle(this, ci.timestampText)
+        },
+        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp)
+      )
+    }
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  name = "Dark Mode"
+)
+@Composable
+fun CIGroupEventViewPreview() {
+  SimpleXTheme {
+    CIGroupEventView(
+      ChatItem.getGroupEventSample()
+    )
+  }
+}

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

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

@@ -0,0 +1,121 @@
+import android.graphics.Bitmap
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.CircularProgressIndicator
+import androidx.compose.material.Icon
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.outlined.MoreHoriz
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.CIFile
+import chat.simplex.app.model.CIFileStatus
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun CIImageView(
+  image: String,
+  file: CIFile?,
+  showMenu: MutableState<Boolean>,
+  receiveFile: (Long) -> Unit
+) {
+  @Composable
+  fun loadingIndicator() {
+    if (file != null) {
+      Box(
+        Modifier
+          .padding(8.dp)
+          .size(20.dp),
+        contentAlignment = Alignment.Center
+      ) {
+        when (file.fileStatus) {
+          CIFileStatus.SndTransfer ->
+            CircularProgressIndicator(
+              Modifier.size(16.dp),
+              color = Color.White,
+              strokeWidth = 2.dp
+            )
+          CIFileStatus.SndComplete ->
+            Icon(
+              Icons.Filled.Check,
+              stringResource(R.string.icon_descr_image_snd_complete),
+              Modifier.fillMaxSize(),
+              tint = Color.White
+            )
+          CIFileStatus.RcvAccepted ->
+            Icon(
+              Icons.Outlined.MoreHoriz,
+              stringResource(R.string.icon_descr_waiting_for_image),
+              Modifier.fillMaxSize(),
+              tint = Color.White
+            )
+          CIFileStatus.RcvTransfer ->
+            CircularProgressIndicator(
+              Modifier.size(16.dp),
+              color = Color.White,
+              strokeWidth = 2.dp
+            )
+          else -> {}
+        }
+      }
+    }
+  }
+
+  @Composable
+  fun imageView(imageBitmap: Bitmap, onClick: () -> Unit) {
+    Image(
+      imageBitmap.asImageBitmap(),
+      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(1000.dp)
+        .combinedClickable(
+          onLongClick = { showMenu.value = true },
+          onClick = onClick
+        ),
+      contentScale = ContentScale.FillWidth,
+    )
+  }
+
+  Box(contentAlignment = Alignment.TopEnd) {
+    val context = LocalContext.current
+    val imageBitmap: Bitmap? = getLoadedImage(context, file)
+    if (imageBitmap != null) {
+      imageView(imageBitmap, onClick = {
+        if (getLoadedFilePath(context, file) != null) {
+          ModalManager.shared.showCustomModal { close -> ImageFullScreenView(imageBitmap, close) }
+        }
+      })
+    } else {
+      imageView(base64ToBitmap(image), onClick = {
+        if (file != null) {
+          when (file.fileStatus) {
+            CIFileStatus.RcvInvitation ->
+              receiveFile(file.fileId)
+            CIFileStatus.RcvAccepted ->
+              AlertManager.shared.showAlertMsg(
+                generalGetString(R.string.waiting_for_image),
+                generalGetString(R.string.image_will_be_received_when_contact_is_online)
+              )
+            CIFileStatus.RcvTransfer -> {} // ?
+            CIFileStatus.RcvComplete -> {} // ?
+            CIFileStatus.RcvCancelled -> {} // TODO
+            else -> {}
+          }
+        }
+      })
+    }
+    loadingIndicator()
+  }
+}

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

@@ -1,46 +1,65 @@
 package chat.simplex.app.views.chat.item
 
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.Icon
-import androidx.compose.material.Text
+import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Edit
+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.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.model.CIDirection
-import chat.simplex.app.model.ChatItem
+import chat.simplex.app.R
+import chat.simplex.app.model.*
 import chat.simplex.app.ui.theme.HighOrLowlight
 import kotlinx.datetime.Clock
 
 @Composable
-fun CIMetaView(chatItem: ChatItem) {
-  Row(
-    horizontalArrangement = Arrangement.spacedBy(4.dp),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
+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),
-          contentDescription = "Edited",
-          tint = HighOrLowlight,
+          modifier = Modifier.height(12.dp).padding(end = 1.dp),
+          contentDescription = stringResource(R.string.icon_descr_edited),
+          tint = metaColor,
         )
       }
-      // TODO status
+      CIStatusView(chatItem.meta.itemStatus, metaColor)
     }
     Text(
       chatItem.timestampText,
-      color = HighOrLowlight,
-      fontSize = 14.sp
+      color = metaColor,
+      fontSize = 14.sp,
+      modifier = Modifier.padding(start = 3.dp)
     )
   }
 }
 
+
+@Composable
+fun CIStatusView(status: CIStatus, metaColor: Color = HighOrLowlight) {
+  when (status) {
+    is CIStatus.SndSent -> {
+      Icon(Icons.Filled.Check, stringResource(R.string.icon_descr_sent_msg_status_sent), Modifier.height(12.dp), tint = metaColor)
+    }
+    is CIStatus.SndErrorAuth -> {
+      Icon(Icons.Filled.Close,  stringResource(R.string.icon_descr_sent_msg_status_unauthorized_send), Modifier.height(12.dp), tint = Color.Red)
+    }
+    is CIStatus.SndError -> {
+      Icon(Icons.Filled.WarningAmber, stringResource(R.string.icon_descr_sent_msg_status_send_failed), Modifier.height(12.dp), tint = Color.Yellow)
+    }
+    is CIStatus.RcvNew -> {
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = MaterialTheme.colors.primary)
+    }
+    else -> {}
+  }
+}
+
 @Preview
 @Composable
 fun PreviewCIMetaView() {
@@ -51,6 +70,48 @@ fun PreviewCIMetaView() {
   )
 }
 
+@Preview
+@Composable
+fun PreviewCIMetaViewUnread() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
+      status = CIStatus.RcvNew()
+    )
+  )
+}
+
+@Preview
+@Composable
+fun PreviewCIMetaViewSendFailed() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
+      status = CIStatus.SndError(AgentErrorType.CMD(CommandErrorType.SYNTAX()))
+    )
+  )
+}
+
+@Preview
+@Composable
+fun PreviewCIMetaViewSendNoAuth() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndErrorAuth()
+    )
+  )
+}
+
+@Preview
+@Composable
+fun PreviewCIMetaViewSendSent() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello", status = CIStatus.SndSent()
+    )
+  )
+}
+
 @Preview
 @Composable
 fun PreviewCIMetaViewEdited() {
@@ -62,6 +123,30 @@ fun PreviewCIMetaViewEdited() {
   )
 }
 
+@Preview
+@Composable
+fun PreviewCIMetaViewEditedUnread() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectRcv(), Clock.System.now(), "hello",
+      itemEdited = true,
+      status=CIStatus.RcvNew()
+    )
+  )
+}
+
+@Preview
+@Composable
+fun PreviewCIMetaViewEditedSent() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
+      itemEdited = true,
+      status=CIStatus.SndSent()
+    )
+  )
+}
+
 @Preview
 @Composable
 fun PreviewCIMetaViewDeletedContent() {

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

@@ -1,8 +1,9 @@
 package chat.simplex.app.views.chat.item
 
-import android.content.Context
+import android.content.*
 import androidx.compose.foundation.combinedClickable
 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.Edit
@@ -10,96 +11,162 @@ import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.*
 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.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.UriHandler
+import androidx.compose.ui.platform.*
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.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
 
 @Composable
 fun ChatItemView(
   user: User,
+  cInfo: ChatInfo,
   cItem: ChatItem,
-  msg: MutableState<String>,
-  quotedItem: MutableState<ChatItem?>,
-  editingItem: MutableState<ChatItem?>,
+  composeState: MutableState<ComposeState>,
   cxt: Context,
   uriHandler: UriHandler? = null,
   showMember: Boolean = false,
-  deleteMessage: (Long, CIDeleteMode) -> Unit
+  chatModelIncognito: Boolean,
+  useLinkPreviews: Boolean,
+  deleteMessage: (Long, CIDeleteMode) -> Unit,
+  receiveFile: (Long) -> Unit,
+  joinGroup: (Long) -> Unit,
+  acceptCall: (Contact) -> Unit
 ) {
+  val context = LocalContext.current
   val sent = cItem.chatDir.sent
   val alignment = if (sent) Alignment.CenterEnd else Alignment.CenterStart
-  var showMenu by remember { mutableStateOf(false) }
+  val showMenu = remember { mutableStateOf(false) }
+  val saveFileLauncher = rememberSaveFileLauncher(cxt = context, ciFile = cItem.file)
   Box(
     modifier = Modifier
       .padding(bottom = 4.dp)
       .fillMaxWidth(),
     contentAlignment = alignment,
   ) {
-    Column(Modifier.combinedClickable(onLongClick = { showMenu = true }, onClick = {})) {
-      if (cItem.isMsgContent) {
-        if (cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
+    Column(
+      Modifier
+        .clip(RoundedCornerShape(18.dp))
+        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
+    ) {
+      @Composable fun ContentItem() {
+        if (cItem.file == null && cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
           EmojiItemView(cItem)
         } else {
-          FramedItemView(user, cItem, uriHandler, showMember = showMember)
+          val onLinkLongClick = { _: String -> showMenu.value = true }
+          FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile, onLinkLongClick)
         }
-      } else if (cItem.isDeletedContent) {
-        DeletedItemView(cItem, showMember = showMember)
-      }
-      if (cItem.isMsgContent) {
-        DropdownMenu(expanded = showMenu, onDismissRequest = { showMenu = false }) {
-          ItemAction("Reply", Icons.Outlined.Reply, onClick = {
-            editingItem.value = null
-            quotedItem.value = cItem
-            showMenu = false
+        DropdownMenu(
+          expanded = showMenu.value,
+          onDismissRequest = { showMenu.value = false },
+          Modifier.width(220.dp)
+        ) {
+          ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
+            if (composeState.value.editing) {
+              composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
+            } else {
+              composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
+            }
+            showMenu.value = false
           })
-          ItemAction("Share", Icons.Outlined.Share, onClick = {
+          ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
             shareText(cxt, cItem.content.text)
-            showMenu = false
+            showMenu.value = false
           })
-          ItemAction("Copy", Icons.Outlined.ContentCopy, onClick = {
+          ItemAction(stringResource(R.string.copy_verb), Icons.Outlined.ContentCopy, onClick = {
             copyText(cxt, cItem.content.text)
-            showMenu = false
+            showMenu.value = false
           })
-          if (cItem.chatDir.sent && cItem.meta.editable) {
-            ItemAction("Edit", Icons.Filled.Edit, onClick = {
-              quotedItem.value = null
-              editingItem.value = cItem
-              msg.value = cItem.content.text
-              showMenu = 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)
+                  else -> {}
+                }
+                showMenu.value = false
+              })
+            }
+          }
+          if (cItem.meta.editable) {
+            ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
+              composeState.value = ComposeState(editingItem = cItem, useLinkPreviews = useLinkPreviews)
+              showMenu.value = false
             })
           }
           ItemAction(
-            "Delete",
+            stringResource(R.string.delete_verb),
             Icons.Outlined.Delete,
             onClick = {
-              showMenu = false
+              showMenu.value = false
               deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
             },
             color = Color.Red
           )
         }
       }
+
+      @Composable fun DeletedItem() {
+        DeletedItemView(cItem, showMember = showMember)
+        DropdownMenu(
+          expanded = showMenu.value,
+          onDismissRequest = { showMenu.value = false },
+          Modifier.width(220.dp)
+        ) {
+          ItemAction(
+            stringResource(R.string.delete_verb),
+            Icons.Outlined.Delete,
+            onClick = {
+              showMenu.value = false
+              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
+            },
+            color = Color.Red
+          )
+        }
+      }
+
+      @Composable fun CallItem(status: CICallStatus, duration: Int) {
+        CICallItemView(cInfo, cItem, status, duration, acceptCall)
+      }
+
+      when (val c = cItem.content) {
+        is CIContent.SndMsgContent -> ContentItem()
+        is CIContent.RcvMsgContent -> ContentItem()
+        is CIContent.SndDeleted -> DeletedItem()
+        is CIContent.RcvDeleted -> DeletedItem()
+        is CIContent.SndCall -> CallItem(c.status, c.duration)
+        is CIContent.RcvCall -> CallItem(c.status, c.duration)
+        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, showMember = showMember)
+        is CIContent.RcvGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
+        is CIContent.SndGroupInvitation -> CIGroupInvitationView(cItem, c.groupInvitation, c.memberRole, joinGroup = joinGroup, chatIncognito = cInfo.incognito)
+        is CIContent.RcvGroupEventContent -> CIGroupEventView(cItem)
+        is CIContent.SndGroupEventContent -> CIGroupEventView(cItem)
+      }
     }
   }
 }
 
 @Composable
-private fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Color = MaterialTheme.colors.onBackground) {
+fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Color = MaterialTheme.colors.onBackground) {
   DropdownMenuItem(onClick) {
     Row {
       Text(
         text,
         modifier = Modifier
           .fillMaxWidth()
-          .weight(1F),
+          .weight(1F)
+          .padding(end = 15.dp),
         color = color
       )
       Icon(icon, text, tint = color)
@@ -109,8 +176,8 @@ private fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, col
 
 fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteMode) -> Unit) {
   AlertManager.shared.showAlertDialogButtons(
-    title = "Delete message?",
-    text = "Message will be deleted - this cannot be undone!",
+    title = generalGetString(R.string.delete_message__question),
+    text = generalGetString(R.string.delete_message_cannot_be_undone_warning),
     buttons = {
       Row(
         Modifier
@@ -118,16 +185,16 @@ fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteM
           .padding(horizontal = 8.dp, vertical = 2.dp),
         horizontalArrangement = Arrangement.End,
       ) {
-        Button(onClick = {
+        TextButton(onClick = {
           deleteMessage(chatItem.id, CIDeleteMode.cidmInternal)
           AlertManager.shared.hideAlert()
-        }) { Text("For me only") }
+        }) { Text(stringResource(R.string.for_me_only)) }
         if (chatItem.meta.editable) {
           Spacer(Modifier.padding(horizontal = 4.dp))
-          Button(onClick = {
+          TextButton(onClick = {
             deleteMessage(chatItem.id, CIDeleteMode.cidmBroadcast)
             AlertManager.shared.hideAlert()
-          }) { Text("For everyone") }
+          }) { Text(stringResource(R.string.for_everybody)) }
         }
       }
     }
@@ -140,14 +207,18 @@ fun PreviewChatItemView() {
   SimpleXTheme {
     ChatItemView(
       User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
       ),
-      msg = remember { mutableStateOf("") },
-      quotedItem = remember { mutableStateOf(null) },
-      editingItem = remember { mutableStateOf(null) },
+      useLinkPreviews = true,
+      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
       cxt = LocalContext.current,
-      deleteMessage = { _, _ -> }
+      chatModelIncognito = false,
+      deleteMessage = { _, _ -> },
+      receiveFile = {},
+      joinGroup = {},
+      acceptCall = { _ -> }
     )
   }
 }
@@ -158,12 +229,16 @@ fun PreviewChatItemViewDeletedContent() {
   SimpleXTheme {
     ChatItemView(
       User.sampleData,
+      ChatInfo.Direct.sampleData,
       ChatItem.getDeletedContentSampleData(),
-      msg = remember { mutableStateOf("") },
-      quotedItem = remember { mutableStateOf(null) },
-      editingItem = remember { mutableStateOf(null) },
+      useLinkPreviews = true,
+      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
       cxt = LocalContext.current,
-      deleteMessage = { _, _ -> }
+      chatModelIncognito = false,
+      deleteMessage = { _, _ -> },
+      receiveFile = {},
+      joinGroup = {},
+      acceptCall = { _ -> }
     )
   }
 }

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

@@ -1,9 +1,8 @@
 package chat.simplex.app.views.chat.item
 
 import android.content.res.Configuration
-import androidx.compose.foundation.BorderStroke
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
+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
@@ -11,10 +10,10 @@ 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.*
+import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import chat.simplex.app.model.*
+import chat.simplex.app.model.ChatItem
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 

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

@@ -31,12 +31,19 @@ fun EmojiText(text: String) {
   Text(s, style = if (s.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont)
 }
 
-private fun isSimpleEmoji(c: Int): Boolean = c > 0x238C
+// https://stackoverflow.com/a/46279500
+private const val emojiStr = "^(" +
+    "(?:[\\u2700-\\u27bf]|" +
+    "(?:[\\ud83c\\udde6-\\ud83c\\uddff]){2}|" +
+    "[\\ud800\\udc00-\\uDBFF\\uDFFF]|[\\u2600-\\u26FF])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]|[\\ud83c\\udffb-\\ud83c\\udfff])?" +
+    "(?:\\u200d(?:[^\\ud800-\\udfff]|" +
+    "(?:[\\ud83c\\udde6-\\ud83c\\uddff]){2}|" +
+    "[\\ud800\\udc00-\\uDBFF\\uDFFF]|[\\u2600-\\u26FF])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]|[\\ud83c\\udffb-\\ud83c\\udfff])?)*|" +
+    "[\\u0023-\\u0039]\\ufe0f?\\u20e3|\\u3299|\\u3297|\\u303d|\\u3030|\\u24c2|[\\ud83c\\udd70-\\ud83c\\udd71]|[\\ud83c\\udd7e-\\ud83c\\udd7f]|\\ud83c\\udd8e|[\\ud83c\\udd91-\\ud83c\\udd9a]|[\\ud83c\\udde6-\\ud83c\\uddff]|[\\ud83c\\ude01-\\ud83c\\ude02]|\\ud83c\\ude1a|\\ud83c\\ude2f|[\\ud83c\\ude32-\\ud83c\\ude3a]|[\\ud83c\\ude50-\\ud83c\\ude51]|\\u203c|\\u2049|[\\u25aa-\\u25ab]|\\u25b6|\\u25c0|[\\u25fb-\\u25fe]|\\u00a9|\\u00ae|\\u2122|\\u2139|\\ud83c\\udc04|[\\u2600-\\u26FF]|\\u2b05|\\u2b06|\\u2b07|\\u2b1b|\\u2b1c|\\u2b50|\\u2b55|\\u231a|\\u231b|\\u2328|\\u23cf|[\\u23e9-\\u23f3]|[\\u23f8-\\u23fa]|\\ud83c\\udccf|\\u2934|\\u2935|[\\u2190-\\u21ff]" +
+    ")+$" // Multiple matches with emojis where one follows another without interruptions from other characters
+private val emojiRegex = Regex(emojiStr)
 
-fun isEmoji(c: Int): Boolean = isSimpleEmoji(c) // || isCombinedIntoEmoji(c)
-
-// TODO count perceived emojis, possibly using icu4j
 fun isShortEmoji(str: String): Boolean {
   val s = str.trim()
-  return s.codePoints().count() in 1..5 && s.codePoints().allMatch(::isEmoji)
+  return s.codePoints().count() in 1..5 && emojiRegex.matches(str)
 }

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

@@ -0,0 +1,55 @@
+import android.graphics.Bitmap
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.*
+import androidx.compose.foundation.gestures.detectTransformGestures
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
+import chat.simplex.app.R
+
+@Composable
+fun ImageFullScreenView(imageBitmap: Bitmap, close: () -> Unit) {
+  BackHandler(onBack = close)
+  Column(
+    Modifier
+      .fillMaxSize()
+      .background(Color.Black)
+      .clickable(onClick = close)
+  ) {
+    var scale by remember { mutableStateOf(1f) }
+    var translationX by remember { mutableStateOf(0f) }
+    var translationY by remember { mutableStateOf(0f) }
+    Image(
+      imageBitmap.asImageBitmap(),
+      contentDescription = stringResource(R.string.image_descr),
+      contentScale = ContentScale.Fit,
+      modifier = Modifier
+        .graphicsLayer(
+          scaleX = scale,
+          scaleY = scale,
+          translationX = translationX,
+          translationY = translationY,
+        )
+        .pointerInput(Unit) {
+          detectTransformGestures(
+            onGesture = { _, pan, gestureZoom, _ ->
+              scale = (scale * gestureZoom).coerceIn(1f, 20f)
+              if (scale > 1) {
+                translationX += pan.x * scale
+                translationY += pan.y * scale
+              } else {
+                translationX = 0f
+                translationY = 0f
+              }
+            }
+          )
+        }
+        .fillMaxSize(),
+    )
+  }
+}

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

@@ -0,0 +1,65 @@
+package chat.simplex.app.views.chat.item
+
+import android.content.res.Configuration
+import androidx.compose.foundation.clickable
+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.graphics.Color
+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.SimpleXTheme
+import chat.simplex.app.views.helpers.AlertManager
+import chat.simplex.app.views.helpers.generalGetString
+
+@Composable
+fun IntegrityErrorItemView(ci: ChatItem, showMember: Boolean = false) {
+  Surface(
+    Modifier.clickable(onClick = {
+      AlertManager.shared.showAlertMsg(
+        title = generalGetString(R.string.alert_title_skipped_messages),
+        text = generalGetString(R.string.alert_text_skipped_messages_it_can_happen_when)
+      )
+    }),
+    shape = RoundedCornerShape(18.dp),
+    color = ReceivedColorLight,
+  ) {
+    Row(
+      Modifier.padding(horizontal = 12.dp, vertical = 6.dp),
+      verticalAlignment = Alignment.Bottom
+    ) {
+      Text(
+        buildAnnotatedString {
+          appendSender(this, if (showMember) ci.memberDisplayName else null, true)
+          withStyle(SpanStyle(fontStyle = FontStyle.Italic, color = Color.Red)) { append(ci.content.text) }
+        },
+        style = MaterialTheme.typography.body1.copy(lineHeight = 22.sp),
+        modifier = Modifier.padding(end = 8.dp)
+      )
+      CIMetaView(ci)
+    }
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  name = "Dark Mode"
+)
+@Composable
+fun IntegrityErrorItemViewPreview() {
+  SimpleXTheme {
+    IntegrityErrorItemView(
+      ChatItem.getDeletedContentSampleData()
+    )
+  }
+}

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

@@ -1,17 +1,19 @@
 package chat.simplex.app.views.chat.item
 
-import androidx.compose.foundation.text.ClickableText
+import androidx.compose.foundation.text.*
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.platform.UriHandler
 import androidx.compose.ui.text.*
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.sp
+import androidx.compose.ui.unit.*
 import chat.simplex.app.model.*
+import chat.simplex.app.views.helpers.detectGesture
 
 val reserveTimestampStyle = SpanStyle(color = Color.Transparent)
 val boldFont = SpanStyle(fontWeight = FontWeight.Medium)
@@ -35,7 +37,7 @@ fun appendSender(b: AnnotatedString.Builder, sender: String?, senderBold: Boolea
 
 @Composable
 fun MarkdownText (
-  content: ItemContent,
+  text: String,
   formattedText: List<FormattedText>? = null,
   sender: String? = null,
   metaText: String? = null,
@@ -45,13 +47,14 @@ fun MarkdownText (
   overflow: TextOverflow = TextOverflow.Clip,
   uriHandler: UriHandler? = null,
   senderBold: Boolean = false,
-  modifier: Modifier = Modifier
+  modifier: Modifier = Modifier,
+  onLinkLongClick: (link: String) -> Unit = {}
 ) {
-  val reserve = if (edited) "      " else "   "
+  val reserve = if (edited) "        " else "    "
   if (formattedText == null) {
     val annotatedText = buildAnnotatedString {
       appendSender(this, sender, senderBold)
-      append(content.text)
+      append(text)
       if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
     }
     Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
@@ -65,8 +68,9 @@ fun MarkdownText (
           val link = ft.link
           if (link != null) {
             hasLinks = true
+            val ftStyle = ft.format.style
             withAnnotation(tag = "URL", annotation = link) {
-              withStyle(ft.format.style) { append(ft.text) }
+              withStyle(ftStyle) { append(ft.text) }
             }
           } else {
             withStyle(ft.format.style) { append(ft.text) }
@@ -77,9 +81,16 @@ fun MarkdownText (
     }
     if (hasLinks && uriHandler != null) {
       ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
+        onLongClick = { offset ->
+          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
+            .firstOrNull()?.let { annotation -> onLinkLongClick(annotation.item) }
+        },
         onClick = { offset ->
           annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
             .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
+        },
+        shouldConsumeEvent = { offset ->
+          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset).any()
         }
       )
     } else {
@@ -87,3 +98,53 @@ fun MarkdownText (
     }
   }
 }
+
+@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/ChatHelpView.kt

@@ -1,4 +1,4 @@
-package chat.simplex.app.views.chat
+package chat.simplex.app.views.chatlist
 
 import android.content.res.Configuration
 import androidx.compose.foundation.clickable
@@ -10,11 +10,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalUriHandler
-import androidx.compose.ui.text.*
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
 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.R
 import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.annotatedStringResource
 import chat.simplex.app.views.usersettings.simplexTeamUri
 
 val bold = SpanStyle(fontWeight = FontWeight.Bold)
@@ -27,18 +31,13 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
   ) {
     val uriHandler = LocalUriHandler.current
 
-    Text("Thank you for installing SimpleX Chat!")
+    Text(stringResource(R.string.thank_you_for_installing_simplex), lineHeight = 22.sp)
     Text(
-      buildAnnotatedString {
-        append("You can ")
-        withStyle(SpanStyle(color = MaterialTheme.colors.primary)) {
-          append("connect to SimpleX Chat founder")
-        }
-        append(".")
-      },
+      annotatedStringResource(R.string.you_can_connect_to_simplex_chat_founder),
       modifier = Modifier.clickable(onClick = {
         uriHandler.openUri(simplexTeamUri)
-      })
+      }),
+      lineHeight = 22.sp
     )
 
     Column(
@@ -47,33 +46,24 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
       verticalArrangement = Arrangement.spacedBy(10.dp)
     ) {
       Text(
-        "To start a new chat",
-        style = MaterialTheme.typography.h2
+        stringResource(R.string.to_start_a_new_chat_help_header),
+        style = MaterialTheme.typography.h2,
+        lineHeight = 22.sp
       )
       Row(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(8.dp)
       ) {
-        Text("Tap button")
+        Text(stringResource(R.string.chat_help_tap_button))
         Icon(
           Icons.Outlined.PersonAdd,
-          "Add Contact",
+          stringResource(R.string.add_contact),
           modifier = if (addContact != null) Modifier.clickable(onClick = addContact) else Modifier,
         )
-        Text("above, then:")
+        Text(stringResource(R.string.above_then_preposition_continuation))
       }
-      Text(
-        buildAnnotatedString {
-          withStyle(bold) { append("Add new contact") }
-          append(": to create your one-time QR Code for your contact.")
-        }
-      )
-      Text(
-        buildAnnotatedString {
-          withStyle(bold) { append("Scan QR code") }
-          append(": to connect to your contact who shows QR code to you.")
-        }
-      )
+      Text(annotatedStringResource(R.string.add_new_contact_to_create_one_time_QR_code), lineHeight = 22.sp)
+      Text(annotatedStringResource(R.string.scan_QR_code_to_connect_to_contact_who_shows_QR_code), lineHeight = 22.sp)
     }
 
     Column(
@@ -81,24 +71,10 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
       horizontalAlignment = Alignment.Start,
       verticalArrangement = Arrangement.spacedBy(10.dp)
     ) {
-      Text("To connect via link", style = MaterialTheme.typography.h2)
-      Text("If you received SimpleX Chat invitation link you can open it in your browser:")
-      Text(
-        buildAnnotatedString {
-          append("\uD83D\uDCBB desktop: scan displayed QR code from the app, via ")
-          withStyle(bold) { append("Scan QR code") }
-          append(".")
-        }
-      )
-      Text(
-        buildAnnotatedString {
-          append("\uD83D\uDCF1 mobile: tap ")
-          withStyle(bold) { append("Open in mobile app") }
-          append(", then tap ")
-          withStyle(bold) { append("Connect") }
-          append(" in the app.")
-        }
-      )
+      Text(stringResource(R.string.to_connect_via_link_title), style = MaterialTheme.typography.h2)
+      Text(stringResource(R.string.if_you_received_simplex_invitation_link_you_can_open_in_browser), lineHeight = 22.sp)
+      Text(annotatedStringResource(R.string.desktop_scan_QR_code_from_app_via_scan_QR_code), lineHeight = 22.sp)
+      Text(annotatedStringResource(R.string.mobile_tap_open_in_mobile_app_then_tap_connect_in_app), lineHeight = 22.sp)
     }
   }
 }
@@ -112,6 +88,6 @@ fun ChatHelpView(addContact: (() -> Unit)? = null) {
 @Composable
 fun PreviewChatHelpLayout() {
   SimpleXTheme {
-    ChatHelpView({})
+    ChatHelpView {}
   }
 }

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

@@ -1,77 +1,440 @@
 package chat.simplex.app.views.chatlist
 
 import android.content.res.Configuration
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.Divider
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.toMutableStateList
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+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.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.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.chat.*
+import chat.simplex.app.views.chat.group.deleteGroupDialog
+import chat.simplex.app.views.chat.group.leaveGroupDialog
+import chat.simplex.app.views.chat.item.ItemAction
+import chat.simplex.app.views.helpers.*
+import kotlinx.coroutines.delay
 import kotlinx.datetime.Clock
 
 @Composable
 fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
-  ChatListNavLinkLayout(
-    chat = chat,
-    click = {
-      if (chat.chatInfo is ChatInfo.ContactRequest) {
-        contactRequestAlertDialog(chat.chatInfo, chatModel)
-      } else {
-        withApi { openChat(chatModel, chat.chatInfo) }
+  val showMenu = remember { mutableStateOf(false) }
+  var showMarkRead by remember { mutableStateOf(false) }
+  val stopped = chatModel.chatRunning.value == 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) },
+        click = { directChatAction(chat.chatInfo, chatModel) },
+        dropdownMenuItems = { ContactMenuItems(chat, chatModel, showMenu, showMarkRead) },
+        showMenu,
+        stopped
+      )
+    is ChatInfo.Group ->
+      ChatListNavLinkLayout(
+        chatLinkPreview = { ChatPreviewView(chat, chatModel.incognito.value, chatModel.currentUser.value?.profile?.displayName, stopped) },
+        click = { groupChatAction(chat.chatInfo.groupInfo, chatModel) },
+        dropdownMenuItems = { GroupMenuItems(chat, chat.chatInfo.groupInfo, chatModel, showMenu, showMarkRead) },
+        showMenu,
+        stopped
+      )
+    is ChatInfo.ContactRequest ->
+      ChatListNavLinkLayout(
+        chatLinkPreview = { ContactRequestView(chatModel.incognito.value, chat.chatInfo) },
+        click = { contactRequestAlertDialog(chat.chatInfo, chatModel) },
+        dropdownMenuItems = { ContactRequestMenuItems(chat.chatInfo, chatModel, showMenu) },
+        showMenu,
+        stopped
+      )
+    is ChatInfo.ContactConnection ->
+      ChatListNavLinkLayout(
+        chatLinkPreview = { ContactConnectionView(chat.chatInfo.contactConnection) },
+        click = { contactConnectionAlertDialog(chat.chatInfo.contactConnection, chatModel) },
+        dropdownMenuItems = { ContactConnectionMenuItems(chat.chatInfo, chatModel, showMenu) },
+        showMenu,
+        stopped
+      )
+  }
+}
+
+fun directChatAction(chatInfo: ChatInfo, chatModel: ChatModel) {
+  if (chatInfo.ready) {
+    withApi { openChat(chatInfo, chatModel) }
+  } else {
+    pendingContactAlertDialog(chatInfo, 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) {
+    chatModel.chatItems.clear()
+    chatModel.chatItems.addAll(chat.chatItems)
+    chatModel.chatId.value = chatInfo.id
+  }
+}
+
+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)
+  }
+  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, chatModel, showMenu)
       }
     }
+    else -> {
+      if (showMarkRead) {
+        MarkReadChatAction(chat, chatModel, showMenu)
+      }
+      ToggleNotificationsChatAction(chat, chatModel, chat.chatInfo.ntfsEnabled, showMenu)
+      ClearChatAction(chat, chatModel, showMenu)
+      if (groupInfo.membership.memberCurrent) {
+        LeaveGroupAction(groupInfo, chatModel, showMenu)
+      }
+      if (groupInfo.canDelete) {
+        DeleteGroupAction(chat, chatModel, showMenu)
+      }
+    }
+  }
+}
+
+@Composable
+fun MarkReadChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.mark_read),
+    Icons.Outlined.Check,
+    onClick = {
+      markChatRead(chat, chatModel)
+      chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
+      showMenu.value = false
+    }
   )
 }
 
-suspend fun openChat(chatModel: ChatModel, cInfo: ChatInfo) {
-  val chat = chatModel.controller.apiGetChat(cInfo.chatType, cInfo.apiId)
-  if (chat != null) {
-    chatModel.chatItems = chat.chatItems.toMutableStateList()
-    chatModel.chatId.value = cInfo.id
+@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 = {
+      changeNtfsState(!ntfsEnabled, chat, chatModel)
+      showMenu.value = false
+    }
+  )
+}
+
+@Composable
+fun ClearChatAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.clear_verb),
+    Icons.Outlined.Restore,
+    onClick = {
+      clearChatDialog(chat.chatInfo, chatModel)
+      showMenu.value = false
+    },
+    color = WarningOrange
+  )
+}
+
+@Composable
+fun DeleteContactAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.delete_verb),
+    Icons.Outlined.Delete,
+    onClick = {
+      deleteContactDialog(chat.chatInfo, chatModel)
+      showMenu.value = false
+    },
+    color = Color.Red
+  )
+}
+
+@Composable
+fun DeleteGroupAction(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.delete_verb),
+    Icons.Outlined.Delete,
+    onClick = {
+      deleteGroupDialog(chat.chatInfo, 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,
+    onClick = {
+      acceptContactRequest(chatInfo, chatModel)
+      showMenu.value = false
+    }
+  )
+  ItemAction(
+    stringResource(R.string.reject_contact_button),
+    Icons.Outlined.Close,
+    onClick = {
+      rejectContactRequest(chatInfo, chatModel)
+      showMenu.value = false
+    },
+    color = Color.Red
+  )
+}
+
+@Composable
+fun ContactConnectionMenuItems(chatInfo: ChatInfo.ContactConnection, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
+  ItemAction(
+    stringResource(R.string.delete_verb),
+    Icons.Outlined.Delete,
+    onClick = {
+      deleteContactConnectionAlert(chatInfo.contactConnection, chatModel)
+      showMenu.value = false
+    },
+    color = Color.Red
+  )
+}
+
+fun markChatRead(chat: Chat, chatModel: ChatModel) {
+  // Just to be sure
+  if (chat.chatStats.unreadCount == 0) return
+
+  val minUnreadItemId = chat.chatStats.minUnreadItemId
+  chatModel.markChatItemsRead(chat.chatInfo)
+  withApi {
+    chatModel.controller.apiChatRead(
+      chat.chatInfo.chatType,
+      chat.chatInfo.apiId,
+      CC.ItemRange(minUnreadItemId, chat.chatItems.last().id)
+    )
   }
 }
 
 fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
   AlertManager.shared.showAlertDialog(
-    title = "Accept connection request?",
-    text = "If you choose to reject sender will NOT be notified.",
-    confirmText = "Accept",
-    onConfirm = {
-      withApi {
-        val contact = chatModel.controller.apiAcceptContactRequest(contactRequest.apiId)
-        if (contact != null) {
-          val chat = Chat(ChatInfo.Direct(contact), listOf())
-          chatModel.replaceChat(contactRequest.id, chat)
+    title = generalGetString(R.string.accept_connection_request__question),
+    text = generalGetString(R.string.if_you_choose_to_reject_the_sender_will_not_be_notified),
+    confirmText = if (chatModel.incognito.value) generalGetString(R.string.accept_contact_incognito_button) else generalGetString(R.string.accept_contact_button),
+    onConfirm = { acceptContactRequest(contactRequest, chatModel) },
+    dismissText = generalGetString(R.string.reject_contact_button),
+    onDismiss = { rejectContactRequest(contactRequest, chatModel) }
+  )
+}
+
+fun acceptContactRequest(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
+  withApi {
+    val contact = chatModel.controller.apiAcceptContactRequest(contactRequest.apiId)
+    if (contact != null) {
+      val chat = Chat(ChatInfo.Direct(contact), listOf())
+      chatModel.replaceChat(contactRequest.id, chat)
+    }
+  }
+}
+
+fun rejectContactRequest(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
+  withApi {
+    chatModel.controller.apiRejectContactRequest(contactRequest.apiId)
+    chatModel.removeChat(contactRequest.id)
+  }
+}
+
+fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel: ChatModel) {
+  AlertManager.shared.showAlertDialogButtons(
+    title = generalGetString(
+      if (connection.initiated) R.string.you_invited_your_contact
+      else R.string.you_accepted_connection
+    ),
+    text = generalGetString(
+      if (connection.viaContactUri) R.string.you_will_be_connected_when_your_connection_request_is_accepted
+      else R.string.you_will_be_connected_when_your_contacts_device_is_online
+    ),
+    buttons = {
+      Row(
+        Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 8.dp, vertical = 2.dp),
+        horizontalArrangement = Arrangement.End,
+      ) {
+        TextButton(onClick = {
+          AlertManager.shared.hideAlert()
+          deleteContactConnectionAlert(connection, chatModel)
+        }) {
+          Text(stringResource(R.string.delete_verb))
+        }
+        Spacer(Modifier.padding(horizontal = 4.dp))
+        TextButton(onClick = { AlertManager.shared.hideAlert() }) {
+          Text(stringResource(R.string.ok))
         }
-      }
-    },
-    dismissText = "Reject",
-    onDismiss = {
-      withApi {
-        chatModel.controller.apiRejectContactRequest(contactRequest.apiId)
-        chatModel.removeChat(contactRequest.id)
       }
     }
   )
 }
 
+fun deleteContactConnectionAlert(connection: PendingContactConnection, chatModel: ChatModel) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.delete_pending_connection__question),
+    text = generalGetString(
+      if (connection.initiated) R.string.contact_you_shared_link_with_wont_be_able_to_connect
+      else R.string.connection_you_accepted_will_be_cancelled
+    ),
+    confirmText = generalGetString(R.string.delete_verb),
+    onConfirm = {
+      withApi {
+        AlertManager.shared.hideAlert()
+        if (chatModel.controller.apiDeleteChat(ChatType.ContactConnection, connection.apiId)) {
+          chatModel.removeChat(connection.id)
+        }
+      }
+    }
+  )
+}
+
+fun pendingContactAlertDialog(chatInfo: ChatInfo, chatModel: ChatModel) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.alert_title_contact_connection_pending),
+    text = generalGetString(R.string.alert_text_connection_pending_they_need_to_be_online_can_delete_and_retry),
+    confirmText = generalGetString(R.string.button_delete_contact),
+    onConfirm = {
+      withApi {
+        val r = chatModel.controller.apiDeleteChat(chatInfo.chatType, chatInfo.apiId)
+        if (r) {
+          chatModel.removeChat(chatInfo.id)
+          chatModel.chatId.value = null
+        }
+      }
+    },
+    dismissText = generalGetString(R.string.cancel_verb),
+  )
+}
+
+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)
+  )
+}
+
 @Composable
-fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit) {
-  Surface(
-    modifier = Modifier
-      .fillMaxWidth()
-      .clickable(onClick = click)
-      .height(88.dp)
-  ) {
+fun ChatListNavLinkLayout(
+  chatLinkPreview: @Composable () -> Unit,
+  click: () -> Unit,
+  dropdownMenuItems: (@Composable () -> Unit)?,
+  showMenu: MutableState<Boolean>,
+  stopped: Boolean
+) {
+  var modifier = Modifier.fillMaxWidth().height(88.dp)
+  if (!stopped) modifier = modifier.combinedClickable(onClick = click, onLongClick = { showMenu.value = true })
+  Surface(modifier) {
     Row(
       modifier = Modifier
         .fillMaxWidth()
@@ -80,10 +443,17 @@ fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit) {
         .padding(end = 12.dp),
       verticalAlignment = Alignment.Top
     ) {
-      if (chat.chatInfo is ChatInfo.ContactRequest) {
-        ContactRequestView(chat)
-      } else {
-        ChatPreviewView(chat)
+      chatLinkPreview()
+    }
+    if (dropdownMenuItems != null) {
+      Box(Modifier.padding(horizontal = 16.dp)) {
+        DropdownMenu(
+          expanded = showMenu.value,
+          onDismissRequest = { showMenu.value = false },
+          Modifier.width(220.dp)
+        ) {
+          dropdownMenuItems()
+        }
       }
     }
   }
@@ -100,19 +470,29 @@ fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit) {
 fun PreviewChatListNavLinkDirect() {
   SimpleXTheme {
     ChatListNavLinkLayout(
-      chat = Chat(
-        chatInfo = ChatInfo.Direct.sampleData,
-        chatItems = listOf(
-          ChatItem.getSampleData(
-            1,
-            CIDirection.DirectSnd(),
-            Clock.System.now(),
-            "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."
-          )
-        ),
-        chatStats = Chat.ChatStats()
-      ),
-      click = {}
+      chatLinkPreview = {
+        ChatPreviewView(
+          chat = Chat(
+            chatInfo = ChatInfo.Direct.sampleData,
+            chatItems = listOf(
+              ChatItem.getSampleData(
+                1,
+                CIDirection.DirectSnd(),
+                Clock.System.now(),
+                "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."
+              )
+            ),
+            chatStats = Chat.ChatStats()
+          ),
+          false,
+          null,
+          stopped = false
+        )
+      },
+      click = {},
+      dropdownMenuItems = null,
+      showMenu = remember { mutableStateOf(false) },
+      stopped = false
     )
   }
 }
@@ -127,19 +507,29 @@ fun PreviewChatListNavLinkDirect() {
 fun PreviewChatListNavLinkGroup() {
   SimpleXTheme {
     ChatListNavLinkLayout(
-      chat = Chat(
-        chatInfo = ChatInfo.Group.sampleData,
-        chatItems = listOf(
-          ChatItem.getSampleData(
-            1,
-            CIDirection.DirectSnd(),
-            Clock.System.now(),
-            "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."
-          )
-        ),
-        chatStats = Chat.ChatStats()
-      ),
-      click = {}
+      chatLinkPreview = {
+        ChatPreviewView(
+          Chat(
+            chatInfo = ChatInfo.Group.sampleData,
+            chatItems = listOf(
+              ChatItem.getSampleData(
+                1,
+                CIDirection.DirectSnd(),
+                Clock.System.now(),
+                "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."
+              )
+            ),
+            chatStats = Chat.ChatStats()
+          ),
+          false,
+          null,
+          stopped = false
+        )
+      },
+      click = {},
+      dropdownMenuItems = null,
+      showMenu = remember { mutableStateOf(false) },
+      stopped = false
     )
   }
 }
@@ -154,12 +544,13 @@ fun PreviewChatListNavLinkGroup() {
 fun PreviewChatListNavLinkContactRequest() {
   SimpleXTheme {
     ChatListNavLinkLayout(
-      chat = Chat(
-        chatInfo = ChatInfo.ContactRequest.sampleData,
-        chatItems = listOf(),
-        chatStats = Chat.ChatStats()
-      ),
-      click = {}
+      chatLinkPreview = {
+        ContactRequestView(false, ChatInfo.ContactRequest.sampleData)
+      },
+      click = {},
+      dropdownMenuItems = null,
+      showMenu = remember { mutableStateOf(false) },
+      stopped = false
     )
   }
 }

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

@@ -7,18 +7,22 @@ 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.Report
+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.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.ToolbarDark
-import chat.simplex.app.ui.theme.ToolbarLight
-import chat.simplex.app.views.chat.ChatHelpView
+import chat.simplex.app.ui.theme.Indigo
+import chat.simplex.app.views.helpers.*
 import chat.simplex.app.views.newchat.NewChatSheet
+import chat.simplex.app.views.onboarding.MakeConnection
 import chat.simplex.app.views.usersettings.SettingsView
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
@@ -61,11 +65,15 @@ fun scaffoldController(): ScaffoldController {
 }
 
 @Composable
-fun ChatListView(chatModel: ChatModel) {
+fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit, stopped: Boolean) {
   val scaffoldCtrl = scaffoldController()
+  LaunchedEffect(chatModel.clearOverlays.value) {
+    if (chatModel.clearOverlays.value && scaffoldCtrl.expanded.value) scaffoldCtrl.collapse()
+  }
   BottomSheetScaffold(
+    topBar = { ChatListToolbar(chatModel, scaffoldCtrl, stopped) },
     scaffoldState = scaffoldCtrl.state,
-    drawerContent = { SettingsView(chatModel) },
+    drawerContent = { SettingsView(chatModel, setPerformLA) },
     sheetPeekHeight = 0.dp,
     sheetContent = { NewChatSheet(chatModel, scaffoldCtrl) },
     sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp),
@@ -76,13 +84,10 @@ fun ChatListView(chatModel: ChatModel) {
           .fillMaxSize()
           .background(MaterialTheme.colors.background)
       ) {
-        ChatListToolbar(scaffoldCtrl)
-        Divider()
         if (chatModel.chats.isNotEmpty()) {
           ChatList(chatModel)
         } else {
-          val user = chatModel.currentUser.value
-          Help(scaffoldCtrl, displayName = user?.profile?.displayName)
+          MakeConnection(chatModel)
         }
       }
       if (scaffoldCtrl.expanded.value) {
@@ -98,72 +103,53 @@ fun ChatListView(chatModel: ChatModel) {
 }
 
 @Composable
-fun Help(scaffoldCtrl: ScaffoldController, displayName: String?) {
-  Column(
-    Modifier
-      .fillMaxWidth()
-      .padding(16.dp)
-  ) {
-    Text(
-      text = if (displayName != null) "Welcome ${displayName}!" else "Welcome!",
-      Modifier.padding(bottom = 24.dp),
-      style = MaterialTheme.typography.h1,
-      color = MaterialTheme.colors.onBackground
-    )
-    ChatHelpView({ scaffoldCtrl.toggleSheet() })
-    Row(
-      Modifier.padding(top = 30.dp),
-      verticalAlignment = Alignment.CenterVertically,
-      horizontalArrangement = Arrangement.spacedBy(8.dp)
-    ) {
-      Text(
-        "This text is available in settings",
-        color = MaterialTheme.colors.onBackground
-      )
-      Icon(
-        Icons.Outlined.Settings,
-        "Settings",
-        tint = MaterialTheme.colors.onBackground,
-        modifier = Modifier.clickable(onClick = { scaffoldCtrl.toggleDrawer() })
-      )
+fun ChatListToolbar(chatModel: ChatModel, scaffoldCtrl: ScaffoldController, stopped: Boolean) {
+  DefaultTopAppBar(
+    navigationButton = { NavigationButtonMenu { scaffoldCtrl.toggleDrawer() } },
+    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 = false,
+    onSearchValueChanged = {},
+    buttons = listOf{
+      if (!stopped) {
+        IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
+          Icon(
+            Icons.Outlined.AddCircle,
+            stringResource(R.string.add_contact),
+            tint = MaterialTheme.colors.primary,
+            modifier = Modifier.padding(10.dp).size(26.dp)
+          )
+        }
+      } else {
+        IconButton(onClick = { AlertManager.shared.showAlertMsg(generalGetString(R.string.chat_is_stopped_indication),
+          generalGetString(R.string.you_can_start_chat_via_setting_or_by_restarting_the_app)) }) {
+          Icon(
+            Icons.Filled.Report,
+            generalGetString(R.string.chat_is_stopped_indication),
+            tint = Color.Red,
+            modifier = Modifier.padding(10.dp)
+          )
+        }
+      }
     }
-  }
-}
-
-@Composable
-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,
-        "Settings",
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-    Text(
-      "Your chats",
-      color = MaterialTheme.colors.onBackground,
-      fontWeight = FontWeight.SemiBold,
-      modifier = Modifier.padding(5.dp)
-    )
-    IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
-      Icon(
-        Icons.Outlined.PersonAdd,
-        "Add Contact",
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-  }
+  )
+  Divider()
 }
 
 @Composable

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

@@ -4,55 +4,127 @@ import android.content.res.Configuration
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Cancel
+import androidx.compose.material.icons.filled.NotificationsOff
+import androidx.compose.material.icons.outlined.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.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.model.Chat
-import chat.simplex.app.model.getTimestampText
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.item.MarkdownText
-import chat.simplex.app.views.helpers.ChatInfoImage
-import chat.simplex.app.views.helpers.badgeLayout
+import chat.simplex.app.views.helpers.*
 
 @Composable
-fun ChatPreviewView(chat: Chat) {
+fun ChatPreviewView(chat: Chat, chatModelIncognito: Boolean, currentUserProfileDisplayName: String?, stopped: Boolean) {
+  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 chatPreviewTitle() {
+    when (cInfo) {
+      is ChatInfo.Direct ->
+        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(
+        ci.text, ci.formattedText, ci.memberDisplayName,
+        metaText = ci.timestampText,
+        maxLines = 2,
+        overflow = TextOverflow.Ellipsis,
+        style = MaterialTheme.typography.body1.copy(color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
+      )
+    } 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 -> {}
+      }
+    }
+  }
+
   Row {
-    ChatInfoImage(chat, size = 72.dp)
+    Box(contentAlignment = Alignment.BottomEnd) {
+      ChatInfoImage(cInfo, size = 72.dp)
+      Box(Modifier.padding(end = 6.dp, bottom = 6.dp)) {
+        chatPreviewImageOverlayIcon()
+      }
+    }
     Column(
       modifier = Modifier
         .padding(horizontal = 8.dp)
         .weight(1F)
     ) {
-      Text(
-        chat.chatInfo.chatViewName,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-        style = MaterialTheme.typography.h3,
-        fontWeight = FontWeight.Bold
-      )
-
-      val ci = chat.chatItems.lastOrNull()
-      if (ci != null) {
-        MarkdownText(
-          ci.content,  ci.formattedText, ci.memberDisplayName,
-          metaText = ci.timestampText,
-          maxLines = 2,
-          overflow = TextOverflow.Ellipsis
-        )
-      }
+      chatPreviewTitle()
+      chatPreviewText(chatModelIncognito)
     }
-    val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.createdAt)
-    Column(
-      Modifier.fillMaxHeight(),
-      verticalArrangement = Arrangement.Top
+    val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.updatedAt)
+
+    Box(
+      contentAlignment = Alignment.TopEnd
     ) {
       Text(
         ts,
@@ -61,23 +133,89 @@ fun ChatPreviewView(chat: Chat) {
         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) {
-        Text(
-          if (n < 1000) "$n" else "${n / 1000}k",
-          color = MaterialTheme.colors.onPrimary,
-          fontSize = 14.sp,
-          modifier = Modifier
-            .background(MaterialTheme.colors.primary, shape = CircleShape)
-            .align(Alignment.End)
-            .badgeLayout()
-            .padding(horizontal = 3.dp)
-            .padding(vertical = 1.dp)
-        )
+        Box(
+          Modifier.padding(top = 24.dp),
+          contentAlignment = Alignment.Center
+        ) {
+          Text(
+            unreadCountStr(n),
+            color = MaterialTheme.colors.onPrimary,
+            fontSize = 11.sp,
+            modifier = Modifier
+              .background(if (stopped || showNtfsIcon) HighOrLowlight else MaterialTheme.colors.primary, shape = CircleShape)
+              .badgeLayout()
+              .padding(horizontal = 3.dp)
+              .padding(vertical = 1.dp)
+          )
+        }
+      } else if (showNtfsIcon) {
+        Box(
+          Modifier.padding(top = 24.dp),
+          contentAlignment = Alignment.Center
+        ) {
+          Icon(
+            Icons.Filled.NotificationsOff,
+            contentDescription = generalGetString(R.string.notifications),
+            tint = HighOrLowlight,
+            modifier = Modifier
+              .padding(horizontal = 3.dp)
+              .padding(vertical = 1.dp)
+              .size(17.dp)
+          )
+        }
+      }
+      if (cInfo is ChatInfo.Direct) {
+        Box(
+          Modifier.padding(top = 52.dp),
+          contentAlignment = Alignment.Center
+        ) {
+          ChatStatusImage(chat)
+        }
       }
     }
   }
 }
 
+@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
+  val descr = s.statusString
+  if (s is Chat.NetworkStatus.Error) {
+    Icon(
+      Icons.Outlined.ErrorOutline,
+      contentDescription = descr,
+      tint = HighOrLowlight,
+      modifier = Modifier
+        .size(19.dp)
+    )
+  } else if (s !is Chat.NetworkStatus.Connected) {
+    CircularProgressIndicator(
+      Modifier
+        .padding(horizontal = 2.dp)
+        .size(15.dp),
+      color = HighOrLowlight,
+      strokeWidth = 1.5.dp
+    )
+  }
+}
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,
@@ -87,6 +225,6 @@ fun ChatPreviewView(chat: Chat) {
 @Composable
 fun PreviewChatPreviewView() {
   SimpleXTheme {
-    ChatPreviewView(Chat.sampleData)
+    ChatPreviewView(Chat.sampleData, false, "", stopped = false)
   }
 }

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

@@ -0,0 +1,54 @@
+package chat.simplex.app.views.chatlist
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.AddLink
+import androidx.compose.material.icons.outlined.Link
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.model.PendingContactConnection
+import chat.simplex.app.model.getTimestampText
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.ProfileImage
+
+@Composable
+fun ContactConnectionView(contactConnection: PendingContactConnection) {
+  Row {
+    Box(Modifier.size(72.dp), contentAlignment = Alignment.Center) {
+      ProfileImage(size = 54.dp, null, if (contactConnection.initiated) Icons.Outlined.AddLink else Icons.Outlined.Link)
+    }
+    Column(
+      modifier = Modifier
+        .padding(horizontal = 8.dp)
+        .weight(1F)
+    ) {
+      Text(
+        contactConnection.displayName,
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        style = MaterialTheme.typography.h3,
+        fontWeight = FontWeight.Bold,
+        color = HighOrLowlight
+      )
+      Text(contactConnection.description, maxLines = 2, color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
+    }
+    val ts = getTimestampText(contactConnection.updatedAt)
+    Column(
+      Modifier.fillMaxHeight(),
+      verticalArrangement = Arrangement.Top
+    ) {
+      Text(
+        ts,
+        color = HighOrLowlight,
+        style = MaterialTheme.typography.body2,
+        modifier = Modifier.padding(bottom = 5.dp)
+      )
+    }
+  }
+}

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

@@ -5,38 +5,35 @@ import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 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.unit.dp
-import chat.simplex.app.model.Chat
-import chat.simplex.app.model.getTimestampText
-import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.helpers.ChatInfoImage
 
 @Composable
-fun ContactRequestView(chat: Chat) {
+fun ContactRequestView(chatModelIncognito: Boolean, contactRequest: ChatInfo.ContactRequest) {
   Row {
-    ChatInfoImage(chat, size = 72.dp)
+    ChatInfoImage(contactRequest, size = 72.dp)
     Column(
       modifier = Modifier
         .padding(horizontal = 8.dp)
         .weight(1F)
     ) {
       Text(
-        chat.chatInfo.chatViewName,
+        contactRequest.chatViewName,
         maxLines = 1,
         overflow = TextOverflow.Ellipsis,
         style = MaterialTheme.typography.h3,
         fontWeight = FontWeight.Bold,
-        color = MaterialTheme.colors.primary
-      )
-      Text(
-        "wants to connect to you!",
-        maxLines = 2,
-        overflow = TextOverflow.Ellipsis
+        color = if (chatModelIncognito) Indigo else MaterialTheme.colors.primary
       )
+      Text(stringResource(R.string.contact_wants_to_connect_with_you), maxLines = 2, color = if (isInDarkTheme()) MessagePreviewDark else MessagePreviewLight)
     }
-    val ts = getTimestampText(chat.chatInfo.createdAt)
+    val ts = getTimestampText(contactRequest.contactRequest.updatedAt)
     Column(
       Modifier.fillMaxHeight(),
       verticalArrangement = Arrangement.Top

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

@@ -0,0 +1,146 @@
+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,
+  ) {
+    Text(
+      title,
+      Modifier.padding(start = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+
+    SectionView(stringResource(R.string.chat_archive_section)) {
+      SettingsActionItem(
+        Icons.Outlined.IosShare,
+        stringResource(R.string.save_archive),
+        saveArchive,
+        textColor = MaterialTheme.colors.primary
+      )
+      SectionDivider()
+      SettingsActionItem(
+        Icons.Outlined.Delete,
+        stringResource(R.string.delete_archive),
+        deleteArchiveAlert,
+        textColor = 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)
+            val file = File(chatArchivePath)
+            outputStream.write(file.readBytes())
+            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(
+      title = "New database archive",
+      archiveTime = Clock.System.now(),
+      saveArchive = {},
+      deleteArchiveAlert = {}
+    )
+  }
+}

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

@@ -0,0 +1,473 @@
+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.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.Report
+import androidx.compose.material.icons.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.*
+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.helpers.*
+import chat.simplex.app.views.usersettings.*
+import kotlinx.datetime.*
+import java.io.*
+import java.text.SimpleDateFormat
+import java.util.*
+
+@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 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 importArchiveLauncher = rememberGetContentLauncher { uri: Uri? ->
+    if (uri != null) {
+      importArchiveAlert(m, context, uri, progressIndicator)
+    }
+  }
+  LaunchedEffect(m.chatRunning) {
+    runChat.value = m.chatRunning.value ?: true
+  }
+  Box(
+    Modifier.fillMaxSize(),
+  ) {
+    DatabaseLayout(
+      progressIndicator.value,
+      runChat.value,
+      m.chatDbChanged.value,
+      importArchiveLauncher,
+      chatArchiveName,
+      chatArchiveTime,
+      chatLastStart,
+      startChat = { startChat(m, runChat, chatLastStart, context) },
+      stopChatAlert = { stopChatAlert(m, runChat, context) },
+      exportArchive = { exportArchive(context, m, progressIndicator, chatArchiveName, chatArchiveTime, chatArchiveFile, saveArchiveLauncher) },
+      deleteChatAlert = { deleteChatAlert(m, progressIndicator) },
+      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,
+  importArchiveLauncher: ManagedActivityResultLauncher<String, Uri?>,
+  chatArchiveName: MutableState<String?>,
+  chatArchiveTime: MutableState<Instant?>,
+  chatLastStart: MutableState<Instant?>,
+  startChat: () -> Unit,
+  stopChatAlert: () -> Unit,
+  exportArchive: () -> Unit,
+  deleteChatAlert: () -> Unit,
+  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit)
+) {
+  val stopped = !runChat
+  val operationsDisabled = !stopped || progressIndicator || chatDbChanged
+
+  Column(
+    Modifier.fillMaxWidth(),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    Text(
+      stringResource(R.string.your_chat_database),
+      Modifier.padding(start = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+
+    SectionView(stringResource(R.string.run_chat_section)) {
+      RunChatSetting(runChat, stopped, chatDbChanged, startChat, stopChatAlert)
+    }
+    SectionSpacer()
+
+    SectionView(stringResource(R.string.chat_database_section)) {
+      SettingsActionItem(
+        Icons.Outlined.IosShare,
+        stringResource(R.string.export_database),
+        exportArchive,
+        textColor = MaterialTheme.colors.primary,
+        disabled = operationsDisabled
+      )
+      SectionDivider()
+      SettingsActionItem(
+        Icons.Outlined.FileDownload,
+        stringResource(R.string.import_database),
+        { importArchiveLauncher.launch("application/zip") },
+        textColor = 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,
+        disabled = operationsDisabled
+      )
+    }
+    SectionTextFooter(
+      if (chatDbChanged) {
+        stringResource(R.string.restart_the_app_to_use_new_chat_database)
+      } else {
+        if (stopped) {
+          stringResource(R.string.you_must_use_the_most_recent_version_of_database)
+        } else {
+          stringResource(R.string.stop_chat_to_enable_database_actions)
+        }
+      }
+    )
+  }
+}
+
+@Composable
+fun RunChatSetting(
+  runChat: Boolean,
+  stopped: Boolean,
+  chatDbChanged: 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 (chatDbChanged) HighOrLowlight else if (stopped) Color.Red else MaterialTheme.colors.primary
+      )
+      Spacer(Modifier.padding(horizontal = 4.dp))
+      Text(
+        chatRunningText,
+        Modifier.padding(end = 24.dp),
+        color = if (chatDbChanged) HighOrLowlight else Color.Unspecified
+      )
+      Spacer(Modifier.fillMaxWidth().weight(1f))
+      Switch(
+        checked = runChat,
+        onCheckedChange = { runChatSwitch ->
+          if (runChatSwitch) {
+            startChat()
+          } else {
+            stopChatAlert()
+          }
+        },
+        colors = SwitchDefaults.colors(
+          checkedThumbColor = MaterialTheme.colors.primary,
+          uncheckedThumbColor = HighOrLowlight
+        ),
+        enabled = !chatDbChanged
+      )
+    }
+  }
+}
+
+@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?>, context: Context) {
+  withApi {
+    try {
+      m.controller.apiStartChat()
+      runChat.value = true
+      m.chatRunning.value = true
+      val ts = Clock.System.now()
+      m.controller.appPrefs.chatLastStart.set(ts)
+      chatLastStart.value = ts
+      SimplexService.start(context)
+    } 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 = { stopChat(m, runChat, context) },
+    onDismiss = { runChat.value = true }
+  )
+}
+
+private fun stopChat(m: ChatModel, runChat: MutableState<Boolean>, context: Context) {
+  withApi {
+    try {
+      m.controller.apiStopChat()
+      runChat.value = false
+      m.chatRunning.value = false
+      SimplexService.stop(context)
+    } 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)
+              val file = File(filePath)
+              outputStream.write(file.readBytes())
+              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, progressIndicator: MutableState<Boolean>) {
+  AlertManager.shared.showAlertDialog(
+    title = generalGetString(R.string.import_database_question),
+    text = generalGetString(R.string.your_current_chat_database_will_be_deleted_and_replaced_with_the_imported_one),
+    confirmText = generalGetString(R.string.import_database_confirmation),
+    onConfirm = { importArchive(m, context, importedArchiveUri, progressIndicator) }
+  )
+}
+
+private fun importArchive(m: ChatModel, context: Context, importedArchiveUri: Uri, 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)
+          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()
+      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 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,
+      importArchiveLauncher = rememberGetContentLauncher {},
+      chatArchiveName = remember { mutableStateOf("dummy_archive") },
+      chatArchiveTime = remember { mutableStateOf(Clock.System.now()) },
+      chatLastStart = remember { mutableStateOf(Clock.System.now()) },
+      startChat = {},
+      stopChatAlert = {},
+      exportArchive = {},
+      deleteChatAlert = {},
+      showSettingsModal = { {} }
+    )
+  }
+}

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

@@ -2,8 +2,11 @@ package chat.simplex.app.views.helpers
 
 import android.util.Log
 import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.*
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import chat.simplex.app.R
 import chat.simplex.app.TAG
 
 class AlertManager {
@@ -40,10 +43,11 @@ class AlertManager {
   fun showAlertDialog(
     title: String,
     text: String? = null,
-    confirmText: String = "Ok",
+    confirmText: String = generalGetString(R.string.ok),
     onConfirm: (() -> Unit)? = null,
-    dismissText: String = "Cancel",
-    onDismiss: (() -> Unit)? = null
+    dismissText: String = generalGetString(R.string.cancel_verb),
+    onDismiss: (() -> Unit)? = null,
+    destructive: Boolean = false
   ) {
     val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
     showAlert {
@@ -52,13 +56,13 @@ class AlertManager {
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onConfirm?.invoke()
             hideAlert()
-          }) { Text(confirmText) }
+          }) { Text(confirmText, color = if (destructive) MaterialTheme.colors.error else Color.Unspecified) }
         },
         dismissButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onDismiss?.invoke()
             hideAlert()
           }) { Text(dismissText) }
@@ -69,7 +73,7 @@ class AlertManager {
 
   fun showAlertMsg(
     title: String, text: String? = null,
-    confirmText: String = "Ok", onConfirm: (() -> Unit)? = null
+    confirmText: String = generalGetString(R.string.ok), onConfirm: (() -> Unit)? = null
   ) {
     val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
     showAlert {
@@ -78,7 +82,7 @@ class AlertManager {
         title = { Text(title) },
         text = alertText,
         confirmButton = {
-          Button(onClick = {
+          TextButton(onClick = {
             onConfirm?.invoke()
             hideAlert()
           }) { Text(confirmText) }

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

@@ -6,48 +6,61 @@ import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.Icon
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.AccountCircle
-import androidx.compose.material.icons.filled.SupervisedUserCircle
+import androidx.compose.material.icons.filled.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.asImageBitmap
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
-import chat.simplex.app.model.Chat
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatInfo
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
-fun ChatInfoImage(chat: Chat, size: Dp) {
+fun ChatInfoImage(chatInfo: ChatInfo, size: Dp, iconColor: Color = MaterialTheme.colors.secondary) {
   val icon =
-    if (chat.chatInfo is ChatInfo.Group) Icons.Filled.SupervisedUserCircle
+    if (chatInfo is ChatInfo.Group) Icons.Filled.SupervisedUserCircle
                                     else Icons.Filled.AccountCircle
-  ProfileImage(size, chat.chatInfo.image, icon)
+  ProfileImage(size, chatInfo.image, icon, iconColor)
+}
+
+@Composable
+fun IncognitoImage(size: Dp, iconColor: Color = MaterialTheme.colors.secondary) {
+  Box(Modifier.size(size)) {
+    Icon(
+      Icons.Filled.TheaterComedy, stringResource(R.string.incognito),
+      modifier = Modifier.size(size).padding(size / 12),
+      iconColor
+    )
+  }
 }
 
 @Composable
 fun ProfileImage(
   size: Dp,
   image: String? = null,
-  icon: ImageVector = Icons.Filled.AccountCircle
+  icon: ImageVector = Icons.Filled.AccountCircle,
+  color: Color = MaterialTheme.colors.secondary
 ) {
   Box(Modifier.size(size)) {
     if (image == null) {
       Icon(
         icon,
-        contentDescription = "profile image placeholder",
-        tint = MaterialTheme.colors.secondary,
+        contentDescription = stringResource(R.string.icon_descr_profile_image_placeholder),
+        tint = color,
         modifier = Modifier.fillMaxSize()
       )
     } else {
       val imageBitmap = base64ToBitmap(image).asImageBitmap()
       Image(
         imageBitmap,
-        "profile image",
+        stringResource(R.string.image_descr_profile_image),
         contentScale = ContentScale.Crop,
         modifier = Modifier.size(size).padding(size / 12).clip(CircleShape)
       )
@@ -60,7 +73,7 @@ fun ProfileImage(
 fun PreviewChatInfoImage() {
   SimpleXTheme {
     ChatInfoImage(
-      chat = Chat(chatInfo = ChatInfo.Direct.sampleData, chatItems = arrayListOf()),
+      chatInfo = ChatInfo.Direct.sampleData,
       size = 55.dp
     )
   }

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

@@ -0,0 +1,54 @@
+package chat.simplex.app.views.helpers
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.*
+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.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.views.newchat.ActionButton
+
+sealed class AttachmentOption {
+  object TakePhoto: AttachmentOption()
+  object PickImage: AttachmentOption()
+  object PickFile: AttachmentOption()
+}
+
+@Composable
+fun ChooseAttachmentView(
+  attachmentOption: MutableState<AttachmentOption?>,
+  hide: () -> Unit
+) {
+  Box(
+    modifier = Modifier
+      .fillMaxWidth()
+      .wrapContentHeight()
+      .onFocusChanged { focusState ->
+        if (!focusState.hasFocus) hide()
+      }
+  ) {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(horizontal = 8.dp, vertical = 30.dp),
+      horizontalArrangement = Arrangement.SpaceEvenly
+    ) {
+      ActionButton(null, stringResource(R.string.use_camera_button), icon = Icons.Outlined.PhotoCamera) {
+        attachmentOption.value = AttachmentOption.TakePhoto
+        hide()
+      }
+      ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Collections) {
+        attachmentOption.value = AttachmentOption.PickImage
+        hide()
+      }
+      ActionButton(null, stringResource(R.string.choose_file), icon = Icons.Outlined.InsertDriveFile) {
+        attachmentOption.value = AttachmentOption.PickFile
+        hide()
+      }
+    }
+  }
+}

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

@@ -8,8 +8,10 @@ import androidx.compose.material.icons.outlined.Close
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
@@ -24,7 +26,7 @@ fun CloseSheetBar(close: () -> Unit) {
     IconButton(onClick = close) {
       Icon(
         Icons.Outlined.Close,
-        "Close button",
+        stringResource(R.string.icon_descr_close_button),
         tint = MaterialTheme.colors.primary,
         modifier = Modifier.padding(10.dp)
       )

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

@@ -0,0 +1,110 @@
+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,
+  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
+    focusRequester.requestFocus()
+    delay(200)
+    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,
+        interactionSource = interactionSource,
+        contentPadding = TextFieldDefaults.textFieldWithLabelPadding(start = 0.dp, end = 0.dp),
+        visualTransformation = VisualTransformation.None,
+        colors = colors
+      )
+    }
+  )
+}

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

@@ -0,0 +1,123 @@
+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.ArrowBackIos
+import androidx.compose.material.icons.outlined.Menu
+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()
+      } 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
+private val AppBarHorizontalPadding = 4.dp
+private val TitleInsetWithoutIcon = 16.dp - AppBarHorizontalPadding
+private val TitleInsetWithIcon = 72.dp

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

@@ -0,0 +1,227 @@
+/*
+ * 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.forEachGesture
+import androidx.compose.foundation.interaction.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.input.pointer.AwaitPointerEventScope
+import androidx.compose.ui.input.pointer.PointerEventTimeoutCancellationException
+import androidx.compose.ui.input.pointer.PointerEvent
+import androidx.compose.ui.input.pointer.PointerEventPass
+import androidx.compose.ui.input.pointer.PointerInputChange
+import androidx.compose.ui.input.pointer.PointerInputScope
+import androidx.compose.ui.input.pointer.changedToDown
+import androidx.compose.ui.input.pointer.changedToDownIgnoreConsumed
+import androidx.compose.ui.input.pointer.changedToUp
+import androidx.compose.ui.input.pointer.consumeAllChanges
+import androidx.compose.ui.input.pointer.consumeDownChange
+import androidx.compose.ui.input.pointer.isOutOfBounds
+import androidx.compose.ui.input.pointer.positionChangeConsumed
+import androidx.compose.ui.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
+
+/**
+ * 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()
+          // If onLongPress event is needed, cancel short press event
+          if (onLongPress != null)
+            pressScope.cancel()
+          else
+            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 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
+}

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

@@ -20,56 +20,91 @@ 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.Composable
+import androidx.compose.runtime.MutableState
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
 import androidx.core.content.ContextCompat
 import androidx.core.content.FileProvider
-import chat.simplex.app.BuildConfig
-import chat.simplex.app.TAG
+import chat.simplex.app.*
+import chat.simplex.app.R
 import chat.simplex.app.views.newchat.ActionButton
 import java.io.ByteArrayOutputStream
 import java.io.File
+import kotlin.math.min
+import kotlin.math.sqrt
 
 // Inspired by https://github.com/MakeItEasyDev/Jetpack-Compose-Capture-Image-Or-Choose-from-Gallery
-
-fun bitmapToBase64(bitmap: Bitmap, squareCrop: Boolean = true): String {
-  val size = 104
-  var height = size
-  var width = size
+fun cropToSquare(image: Bitmap): Bitmap {
   var xOffset = 0
   var yOffset = 0
-  if (bitmap.height < bitmap.width) {
-    width = height * bitmap.width / bitmap.height
-    xOffset = (width - height) / 2
+  val side = min(image.height, image.width)
+  if (image.height < image.width) {
+    xOffset = (image.width - side) / 2
   } else {
-    height = width * bitmap.height / bitmap.width
-    yOffset = (height - width) / 2
+    yOffset = (image.height - side) / 2
   }
-  var image = bitmap
-  while (image.width / 2 > width) {
-    image = Bitmap.createScaledBitmap(image, image.width / 2, image.height / 2, true)
-  }
-  image = Bitmap.createScaledBitmap(image, width, height, true)
-  if (squareCrop) {
-    image = Bitmap.createBitmap(image, xOffset, yOffset, size, size)
-  }
-  val stream = ByteArrayOutputStream()
-  image.compress(Bitmap.CompressFormat.JPEG, 85, stream)
-  return "data:image/jpg;base64," + Base64.encodeToString(stream.toByteArray(), Base64.NO_WRAP)
+  return Bitmap.createBitmap(image, xOffset, yOffset, side, side)
 }
 
-fun base64ToBitmap(base64ImageString: String) : Bitmap {
+fun resizeImageToStrSize(image: Bitmap, maxDataSize: Long): String {
+  var img = image
+  var str = compressImageStr(img)
+  while (str.length > maxDataSize) {
+    val ratio = sqrt(str.length.toDouble() / maxDataSize.toDouble())
+    val clippedRatio = min(ratio, 2.0)
+    val width = (img.width.toDouble() / clippedRatio).toInt()
+    val height = img.height * width / img.width
+    img = Bitmap.createScaledBitmap(img, width, height, true)
+    str = compressImageStr(img)
+  }
+  return str
+}
+
+private fun compressImageStr(bitmap: Bitmap): String {
+  return "data:image/jpg;base64," + Base64.encodeToString(compressImageData(bitmap).toByteArray(), Base64.NO_WRAP)
+}
+
+fun resizeImageToDataSize(image: Bitmap, maxDataSize: Long): ByteArrayOutputStream {
+  var img = image
+  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)
+  }
+  return stream
+}
+
+private fun compressImageData(bitmap: Bitmap): ByteArrayOutputStream {
+  val stream = ByteArrayOutputStream()
+  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,")
-  val imageBytes = Base64.decode(imageString, Base64.NO_WRAP)
-  return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+  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
+  }
 }
 
-class CustomTakePicturePreview : ActivityResultContract<Void?, Bitmap?>() {
+class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
   private var uri: Uri? = null
   private var tmpFile: File? = null
   lateinit var externalContext: Context
@@ -95,17 +130,21 @@ class CustomTakePicturePreview : ActivityResultContract<Void?, Bitmap?>() {
       tmpFile?.delete()
       bitmap
     } else {
-      Log.e( TAG, "Getting image from camera cancelled or failed.")
+      Log.e(TAG, "Getting image from camera cancelled or failed.")
       tmpFile?.delete()
       null
     }
   }
 }
-
-@Composable
-fun rememberGalleryLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
-  rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent(), cb)
-
+//class GetGalleryContent: ActivityResultContracts.GetContent() {
+//  override fun createIntent(context: Context, input: String): Intent {
+//    super.createIntent(context, input)
+//    return Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI)
+//  }
+//}
+//@Composable
+//fun rememberGalleryLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
+//  rememberLauncherForActivityResult(contract = GetGalleryContent(), cb)
 @Composable
 fun rememberCameraLauncher(cb: (Bitmap?) -> Unit): ManagedActivityResultLauncher<Void?, Bitmap?> =
   rememberLauncherForActivityResult(contract = CustomTakePicturePreview(), cb)
@@ -114,33 +153,37 @@ fun rememberCameraLauncher(cb: (Bitmap?) -> Unit): ManagedActivityResultLauncher
 fun rememberPermissionLauncher(cb: (Boolean) -> Unit): ManagedActivityResultLauncher<String, Boolean> =
   rememberLauncherForActivityResult(contract = ActivityResultContracts.RequestPermission(), cb)
 
+@Composable
+fun rememberGetContentLauncher(cb: (Uri?) -> Unit): ManagedActivityResultLauncher<String, Uri?> =
+  rememberLauncherForActivityResult(contract = ActivityResultContracts.GetContent(), cb)
+
 @Composable
 fun GetImageBottomSheet(
-  profileImageStr: MutableState<String?>,
+  imageBitmap: MutableState<Bitmap?>,
+  onImageChange: (Bitmap) -> Unit,
   hideBottomSheet: () -> Unit
 ) {
   val context = LocalContext.current
-  val isCameraSelected = remember { mutableStateOf (false) }
-
-  val galleryLauncher = rememberGalleryLauncher { uri: Uri? ->
+  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
     if (uri != null) {
       val source = ImageDecoder.createSource(context.contentResolver, uri)
       val bitmap = ImageDecoder.decodeBitmap(source)
-      profileImageStr.value = bitmapToBase64(bitmap)
+      imageBitmap.value = bitmap
+      onImageChange(bitmap)
     }
   }
-
   val cameraLauncher = rememberCameraLauncher { bitmap: Bitmap? ->
-    if (bitmap != null) profileImageStr.value = bitmapToBase64(bitmap)
+    if (bitmap != null) {
+      imageBitmap.value = bitmap
+      onImageChange(bitmap)
+    }
   }
-
   val permissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
     if (isGranted) {
-      if (isCameraSelected.value) cameraLauncher.launch(null)
-      else galleryLauncher.launch("image/*")
+      cameraLauncher.launch(null)
       hideBottomSheet()
     } else {
-      Toast.makeText(context, "Permission Denied!", Toast.LENGTH_SHORT).show()
+      Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
     }
   }
 
@@ -158,29 +201,20 @@ fun GetImageBottomSheet(
         .padding(horizontal = 8.dp, vertical = 30.dp),
       horizontalArrangement = Arrangement.SpaceEvenly
     ) {
-      ActionButton(null, "Use Camera", icon = Icons.Outlined.PhotoCamera) {
+      ActionButton(null, stringResource(R.string.use_camera_button), icon = Icons.Outlined.PhotoCamera) {
         when (PackageManager.PERMISSION_GRANTED) {
           ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
             cameraLauncher.launch(null)
             hideBottomSheet()
           }
           else -> {
-            isCameraSelected.value = true
             permissionLauncher.launch(Manifest.permission.CAMERA)
           }
         }
       }
-      ActionButton(null, "From Gallery", icon = Icons.Outlined.Collections) {
-        when (PackageManager.PERMISSION_GRANTED) {
-          ContextCompat.checkSelfPermission(context, Manifest.permission.READ_EXTERNAL_STORAGE) -> {
-            galleryLauncher.launch("image/*")
-            hideBottomSheet()
-          }
-          else -> {
-            isCameraSelected.value = false
-            permissionLauncher.launch(Manifest.permission.READ_EXTERNAL_STORAGE)
-          }
-        }
+      ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Collections) {
+        galleryLauncher.launch("image/*")
+        hideBottomSheet()
       }
     }
   }

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

@@ -0,0 +1,163 @@
+package chat.simplex.app.views.helpers
+
+import android.content.res.Configuration
+import android.graphics.BitmapFactory
+import androidx.compose.foundation.Image
+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.outlined.Close
+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.layout.ContentScale
+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.LinkPreview
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.chat.item.SentColorLight
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.jsoup.Jsoup
+
+private const val OG_SELECT_QUERY = "meta[property^=og:]"
+
+suspend fun getLinkPreview(url: String): LinkPreview? {
+  return withContext(Dispatchers.IO) {
+    try {
+      val response = Jsoup.connect(url)
+        .ignoreContentType(true)
+        .timeout(10000)
+        .followRedirects(true)
+        .execute()
+      val doc = response.parse()
+      val ogTags = doc.select(OG_SELECT_QUERY)
+      val imageUri = ogTags.firstOrNull { it.attr("property") == "og:image" }?.attr("content")
+      if (imageUri != null) {
+        try {
+          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)
+          }
+        } catch (e: Exception) {
+          e.printStackTrace()
+        }
+      }
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+    return@withContext null
+  }
+}
+
+
+
+@Composable
+fun ComposeLinkView(linkPreview: LinkPreview?, cancelPreview: () -> Unit) {
+  Row(
+    Modifier.fillMaxWidth().padding(top = 8.dp).background(SentColorLight),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    if (linkPreview == null) {
+      Box(
+        Modifier.fillMaxWidth().weight(1f).height(60.dp).padding(start = 16.dp),
+        contentAlignment = Alignment.CenterStart
+      ) {
+        CircularProgressIndicator(
+          Modifier.size(16.dp),
+          color = HighOrLowlight,
+          strokeWidth = 2.dp
+        )
+      }
+    } else {
+      val imageBitmap = base64ToBitmap(linkPreview.image).asImageBitmap()
+      Image(
+        imageBitmap,
+        stringResource(R.string.image_descr_link_preview),
+        modifier = Modifier.width(80.dp).height(60.dp).padding(end = 8.dp)
+      )
+      Column(Modifier.fillMaxWidth().weight(1F)) {
+        Text(linkPreview.title, maxLines = 1, overflow = TextOverflow.Ellipsis)
+        Text(
+          linkPreview.uri, maxLines = 1, overflow = TextOverflow.Ellipsis,
+          style = MaterialTheme.typography.body2
+        )
+      }
+    }
+    IconButton(onClick = cancelPreview, modifier = Modifier.padding(0.dp)) {
+      Icon(
+        Icons.Outlined.Close,
+        contentDescription = stringResource(R.string.icon_descr_cancel_link_preview),
+        tint = MaterialTheme.colors.primary,
+        modifier = Modifier.padding(10.dp)
+      )
+    }
+  }
+}
+
+@Composable
+fun ChatItemLinkView(linkPreview: LinkPreview) {
+  Column {
+    Image(
+      base64ToBitmap(linkPreview.image).asImageBitmap(),
+      stringResource(R.string.image_descr_link_preview),
+      modifier = Modifier.fillMaxWidth(),
+      contentScale = ContentScale.FillWidth,
+    )
+    Column(Modifier.padding(top = 6.dp).padding(horizontal = 12.dp)) {
+      Text(linkPreview.title, maxLines = 3, overflow = TextOverflow.Ellipsis, lineHeight = 22.sp, modifier = Modifier.padding(bottom = 4.dp))
+      if (linkPreview.description != "") {
+        Text(linkPreview.description, maxLines = 12, overflow = TextOverflow.Ellipsis, fontSize = 14.sp, lineHeight = 20.sp)
+      }
+      Text(linkPreview.uri, maxLines = 1, overflow = TextOverflow.Ellipsis, fontSize = 12.sp, color = HighOrLowlight)
+    }
+  }
+}
+
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "ChatItemLinkView (Dark Mode)"
+)
+@Composable
+fun PreviewChatItemLinkView() {
+  SimpleXTheme {
+    ChatItemLinkView(LinkPreview.sampleData)
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "ComposeLinkView (Dark Mode)"
+)
+@Composable
+fun PreviewComposeLinkView() {
+  SimpleXTheme {
+    ComposeLinkView(LinkPreview.sampleData) { -> }
+  }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewComposeLinkViewLoading() {
+  SimpleXTheme {
+    ComposeLinkView(null) { -> }
+  }
+}

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

@@ -0,0 +1,112 @@
+package chat.simplex.app.views.helpers
+
+import android.content.Context
+import android.os.Build.VERSION.SDK_INT
+import android.widget.Toast
+import androidx.biometric.BiometricManager
+import androidx.biometric.BiometricManager.Authenticators.*
+import androidx.biometric.BiometricPrompt
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.FragmentActivity
+import chat.simplex.app.R
+
+sealed class LAResult {
+  object Success: LAResult()
+  class Error(val errString: CharSequence): LAResult()
+  object Failed: LAResult()
+  object Unavailable: LAResult()
+}
+
+fun authenticate(
+  promptTitle: String,
+  promptSubtitle: String,
+  activity: FragmentActivity,
+  completed: (LAResult) -> Unit
+) {
+  when {
+    SDK_INT in 28..29 ->
+      // KeyguardManager.isDeviceSecure()? https://developer.android.com/training/sign-in/biometric-auth#declare-supported-authentication-types
+      authenticateWithBiometricManager(promptTitle, promptSubtitle, activity, completed, BIOMETRIC_WEAK or DEVICE_CREDENTIAL)
+    SDK_INT > 29 ->
+      authenticateWithBiometricManager(promptTitle, promptSubtitle, activity, completed, BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
+    else ->
+      completed(LAResult.Unavailable)
+  }
+}
+
+private fun authenticateWithBiometricManager(
+  promptTitle: String,
+  promptSubtitle: String,
+  activity: FragmentActivity,
+  completed: (LAResult) -> Unit,
+  authenticators: Int
+) {
+  val biometricManager = BiometricManager.from(activity)
+  when (biometricManager.canAuthenticate(authenticators)) {
+    BiometricManager.BIOMETRIC_SUCCESS -> {
+      val executor = ContextCompat.getMainExecutor(activity)
+      val biometricPrompt = BiometricPrompt(
+        activity,
+        executor,
+        object: BiometricPrompt.AuthenticationCallback() {
+          override fun onAuthenticationError(
+            errorCode: Int,
+            errString: CharSequence
+          ) {
+            super.onAuthenticationError(errorCode, errString)
+            completed(LAResult.Error(errString))
+          }
+
+          override fun onAuthenticationSucceeded(
+            result: BiometricPrompt.AuthenticationResult
+          ) {
+            super.onAuthenticationSucceeded(result)
+            completed(LAResult.Success)
+          }
+
+          override fun onAuthenticationFailed() {
+            super.onAuthenticationFailed()
+            completed(LAResult.Failed)
+          }
+        }
+      )
+      val promptInfo = BiometricPrompt.PromptInfo.Builder()
+        .setTitle(promptTitle)
+        .setSubtitle(promptSubtitle)
+        .setAllowedAuthenticators(authenticators)
+        .setConfirmationRequired(false)
+        .build()
+      biometricPrompt.authenticate(promptInfo)
+    }
+    else -> {
+      completed(LAResult.Unavailable)
+    }
+  }
+}
+
+fun laTurnedOnAlert() = AlertManager.shared.showAlertMsg(
+  generalGetString(R.string.auth_simplex_lock_turned_on),
+  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)
+)
+
+fun laUnavailableTurningOffAlert() = AlertManager.shared.showAlertMsg(
+  generalGetString(R.string.auth_unavailable),
+  generalGetString(R.string.auth_device_authentication_is_disabled_turning_off)
+)

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

@@ -1,4 +1,4 @@
-package chat.simplex.app.views.newchat
+package chat.simplex.app.views.helpers
 
 import android.util.Log
 import androidx.activity.compose.BackHandler
@@ -9,21 +9,22 @@ 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.views.helpers.CloseSheetBar
 
 @Composable
-fun ModalView(close: () -> Unit, content: @Composable () -> Unit) {
+fun ModalView(
+  close: () -> Unit,
+  background: Color = MaterialTheme.colors.background,
+  modifier: Modifier = Modifier.padding(horizontal = 16.dp),
+  content: @Composable () -> Unit,
+) {
   BackHandler(onBack = close)
-  Surface(
-    Modifier
-      .background(MaterialTheme.colors.background)
-      .fillMaxSize()
-  ) {
-    Column {
+  Surface(Modifier.fillMaxSize()) {
+    Column(Modifier.background(background)) {
       CloseSheetBar(close)
-      Box(Modifier.padding(horizontal = 16.dp)) { content() }
+      Box(modifier) { content() }
     }
   }
 }
@@ -33,7 +34,7 @@ class ModalManager {
   private val modalCount = mutableStateOf(0)
 
   fun showModal(content: @Composable () -> Unit) {
-    showCustomModal { close -> ModalView(close, content) }
+    showCustomModal { close -> ModalView(close, content = content) }
   }
 
   fun showCustomModal(modal: @Composable (close: () -> Unit) -> Unit) {
@@ -43,12 +44,16 @@ class ModalManager {
   }
 
   fun closeModal() {
-    if (!modalViews.isEmpty()) {
+    if (modalViews.isNotEmpty()) {
       modalViews.removeAt(modalViews.count() - 1)
     }
     modalCount.value = modalViews.count()
   }
 
+  fun closeModals() {
+    while (modalViews.isNotEmpty()) closeModal()
+  }
+
   @Composable
   fun showInView() {
     if (modalCount.value > 0) modalViews.lastOrNull()?.invoke(::closeModal)

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

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

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

@@ -0,0 +1,97 @@
+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.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.ImeAction
+import androidx.compose.ui.text.input.VisualTransformation
+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 remember { mutableStateOf("") }
+  val focusRequester = remember { FocusRequester() }
+  val keyboard = LocalSoftwareKeyboardController.current
+
+  LaunchedEffect(Unit) {
+    focusRequester.requestFocus()
+    delay(200)
+    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 = 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)
+    },
+    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,
+        innerTextField = innerTextField,
+        placeholder = {
+          Text(placeholder)
+        },
+        trailingIcon = if (searchText.isNotEmpty()) {{
+          IconButton({ searchText = ""; 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

@@ -0,0 +1,126 @@
+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.platform.LocalConfiguration
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.*
+import chat.simplex.app.ui.theme.*
+
+@Composable
+fun SectionView(title: String? = null, content: (@Composable () -> Unit)) {
+  Column {
+    if (title != null) {
+      Text(
+        title, color = HighOrLowlight, style = MaterialTheme.typography.body2,
+        modifier = Modifier.padding(start = 16.dp, bottom = 5.dp), fontSize = 12.sp
+      )
+    }
+    Surface(color = if (isInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
+      Column(Modifier.padding(horizontal = 6.dp).fillMaxWidth()) { content() }
+    }
+  }
+}
+
+@Composable
+fun SectionItemView(click: (() -> Unit)? = null, height: Dp = 46.dp, disabled: Boolean = false, content: (@Composable () -> Unit)) {
+  val modifier = Modifier
+    .padding(horizontal = 8.dp)
+    .fillMaxWidth()
+    .height(height)
+  Row(
+    if (click == null || disabled) modifier else modifier.clickable(onClick = click),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    content()
+  }
+}
+
+@Composable
+fun SectionItemViewSpaceBetween(
+  click: (() -> Unit)? = null,
+  height: Dp = 46.dp,
+  padding: PaddingValues = PaddingValues(horizontal = 8.dp),
+  disabled: Boolean = false,
+  content: (@Composable () -> Unit)
+) {
+  val modifier = Modifier
+    .padding(padding)
+    .fillMaxWidth()
+    .height(height)
+  Row(
+    if (click == null || disabled) modifier else modifier.clickable(onClick = click),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    content()
+  }
+}
+
+@Composable
+fun SectionTextFooter(text: String) {
+  Text(
+    text,
+    Modifier.padding(horizontal = 16.dp).padding(top = 5.dp).fillMaxWidth(0.9F),
+    color = HighOrLowlight,
+    fontSize = 12.sp
+  )
+}
+
+@Composable
+fun SectionCustomFooter(padding: PaddingValues = PaddingValues(start = 16.dp, end = 16.dp, 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) {
+  SectionItemView {
+    Row(
+      Modifier.fillMaxWidth(),
+      horizontalArrangement = Arrangement.SpaceBetween,
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Text(title)
+      Text(value, color = HighOrLowlight)
+    }
+  }
+}
+
+@Composable
+fun InfoRowEllipsis(title: String, value: String, onClick: () -> Unit) {
+  SectionItemView {
+    Row(
+      Modifier.fillMaxWidth(),
+      horizontalArrangement = Arrangement.SpaceBetween,
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      val configuration = LocalConfiguration.current
+      Text(title)
+      Text(value,
+        Modifier
+          .padding(start = 10.dp)
+          .widthIn(max = (configuration.screenWidthDp / 2).dp)
+          .clickable(onClick = onClick),
+        maxLines = 1,
+        overflow = TextOverflow.Ellipsis,
+        color = HighOrLowlight
+      )
+    }
+  }
+}

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

@@ -1,7 +1,18 @@
 package chat.simplex.app.views.helpers
 
 import android.content.*
+import android.net.Uri
+import android.provider.MediaStore
+import android.widget.Toast
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
 import androidx.core.content.ContextCompat
+import chat.simplex.app.R
+import chat.simplex.app.model.CIFile
+import java.io.BufferedOutputStream
+import java.io.File
 
 fun shareText(cxt: Context, text: String) {
   val sendIntent: Intent = Intent().apply {
@@ -17,3 +28,50 @@ fun copyText(cxt: Context, text: String) {
   val clipboard = ContextCompat.getSystemService(cxt, ClipboardManager::class.java)
   clipboard?.setPrimaryClip(ClipData.newPlainText("text", text))
 }
+
+@Composable
+fun rememberSaveFileLauncher(cxt: Context, ciFile: CIFile?): ManagedActivityResultLauncher<String, Uri?> =
+  rememberLauncherForActivityResult(
+    contract = ActivityResultContracts.CreateDocument(),
+    onResult = { destination ->
+      destination?.let {
+        val filePath = getLoadedFilePath(cxt, ciFile)
+        if (filePath != null) {
+          val contentResolver = cxt.contentResolver
+          contentResolver.openOutputStream(destination)?.let { stream ->
+            val outputStream = BufferedOutputStream(stream)
+            val file = File(filePath)
+            outputStream.write(file.readBytes())
+            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()
+        }
+      }
+    }
+  )
+
+fun saveImage(cxt: Context, ciFile: CIFile?) {
+  val filePath = getLoadedFilePath(cxt, ciFile)
+  val fileName = ciFile?.fileName
+  if (filePath != null && fileName != null) {
+    val values = ContentValues()
+    values.put(MediaStore.Images.Media.DATE_TAKEN, System.currentTimeMillis())
+    values.put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg")
+    values.put(MediaStore.MediaColumns.DISPLAY_NAME, fileName)
+    values.put(MediaStore.MediaColumns.TITLE, fileName)
+    val uri = cxt.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
+    uri?.let {
+      cxt.contentResolver.openOutputStream(uri)?.let { stream ->
+        val outputStream = BufferedOutputStream(stream)
+        val file = File(filePath)
+        outputStream.write(file.readBytes())
+        outputStream.close()
+        Toast.makeText(cxt, generalGetString(R.string.image_saved), Toast.LENGTH_SHORT).show()
+      }
+    }
+  } else {
+    Toast.makeText(cxt, generalGetString(R.string.file_not_found), Toast.LENGTH_SHORT).show()
+  }
+}

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

@@ -3,6 +3,7 @@ package chat.simplex.app.ui.theme
 import androidx.compose.foundation.clickable
 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.material.icons.Icons
 import androidx.compose.material.icons.outlined.Share
@@ -18,14 +19,23 @@ import androidx.compose.ui.unit.dp
 fun SimpleButton(text: String, icon: ImageVector,
                  color: Color = MaterialTheme.colors.primary,
                  click: () -> Unit) {
-  Row(
-    verticalAlignment = Alignment.CenterVertically,
-    modifier = Modifier.clickable { click() }
-  ) {
-    Icon(icon, text, tint = color,
-      modifier = Modifier.padding(horizontal = 10.dp)
+  SimpleButtonFrame(click) {
+    Icon(
+      icon, text, tint = color,
+      modifier = Modifier.padding(end = 8.dp)
     )
-    Text(text, style = MaterialTheme.typography.caption,  color = color)
+    Text(text, style = MaterialTheme.typography.caption, color = color)
+  }
+}
+
+@Composable
+fun SimpleButtonFrame(click: () -> Unit, disabled: Boolean = false, content: @Composable () -> Unit) {
+  Surface(shape = RoundedCornerShape(20.dp)) {
+    val modifier = if (disabled) Modifier else Modifier.clickable { click() }
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      modifier = modifier.padding(8.dp)
+    ) { content() }
   }
 }
 

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

@@ -0,0 +1,58 @@
+package chat.simplex.app.views.helpers
+
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.ui.theme.HighOrLowlight
+
+@Composable
+fun TextEditor(modifier: Modifier, text: MutableState<String>) {
+  BasicTextField(
+    value = text.value,
+    onValueChange = { text.value = it },
+    textStyle = TextStyle(
+      fontFamily = FontFamily.Monospace, fontSize = 14.sp,
+      color = MaterialTheme.colors.onBackground
+    ),
+    keyboardOptions = KeyboardOptions.Default.copy(
+      capitalization = KeyboardCapitalization.None,
+      autoCorrect = false
+    ),
+    modifier = modifier,
+    cursorBrush = SolidColor(HighOrLowlight),
+    decorationBox = { innerTextField ->
+      Surface(
+        shape = RoundedCornerShape(10.dp),
+        border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
+      ) {
+        Row(
+          Modifier.background(MaterialTheme.colors.background),
+          verticalAlignment = Alignment.Top
+        ) {
+          Box(
+            Modifier
+              .weight(1f)
+              .padding(vertical = 5.dp, horizontal = 7.dp)
+          ) {
+            innerTextField()
+          }
+        }
+      }
+    }
+  )
+}

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

@@ -1,13 +1,41 @@
 package chat.simplex.app.views.helpers
 
-import android.graphics.Rect
+import android.content.Context
+import android.content.res.Resources
+import android.graphics.*
+import android.graphics.Typeface
+import android.net.Uri
+import android.os.FileUtils
+import android.provider.OpenableColumns
+import android.text.Spanned
+import android.text.SpannedString
+import android.text.style.*
+import android.util.Log
 import android.view.ViewTreeObserver
+import androidx.annotation.StringRes
 import androidx.compose.runtime.*
-import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.*
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.*
+import androidx.compose.ui.text.style.BaselineShift
+import androidx.compose.ui.text.style.TextDecoration
+import androidx.compose.ui.unit.*
+import androidx.core.content.FileProvider
+import androidx.core.text.HtmlCompat
+import chat.simplex.app.BuildConfig
+import chat.simplex.app.SimplexApp
+import chat.simplex.app.model.CIFile
 import kotlinx.coroutines.*
+import java.io.*
+import java.text.SimpleDateFormat
+import java.util.*
+import kotlin.math.*
 
-fun withApi(action: suspend CoroutineScope.() -> Unit): Job =
-  GlobalScope.launch { withContext(Dispatchers.Main, action) }
+fun withApi(action: suspend CoroutineScope.() -> Unit): Job = withScope(GlobalScope, action)
+
+fun withScope(scope: CoroutineScope, action: suspend CoroutineScope.() -> Unit): Job =
+  scope.launch { withContext(Dispatchers.Main, action) }
 
 enum class KeyboardState {
   Opened, Closed
@@ -38,3 +66,313 @@ fun getKeyboardState(): State<KeyboardState> {
 
   return keyboardState
 }
+
+// Resource to annotated string from
+// https://stackoverflow.com/questions/68549248/android-jetpack-compose-how-to-show-styled-text-from-string-resources
+fun generalGetString(id: Int): String {
+  // prefer stringResource in Composable items to retain preview abilities
+  return SimplexApp.context.getString(id)
+}
+
+@Composable
+@ReadOnlyComposable
+private fun resources(): Resources {
+  LocalConfiguration.current
+  return LocalContext.current.resources
+}
+
+fun Spanned.toHtmlWithoutParagraphs(): String {
+  return HtmlCompat.toHtml(this, HtmlCompat.TO_HTML_PARAGRAPH_LINES_CONSECUTIVE)
+    .substringAfter("<p dir=\"ltr\">").substringBeforeLast("</p>")
+}
+
+fun Resources.getText(@StringRes id: Int, vararg args: Any): CharSequence {
+  val escapedArgs = args.map {
+    if (it is Spanned) it.toHtmlWithoutParagraphs() else it
+  }.toTypedArray()
+  val resource = SpannedString(getText(id))
+  val htmlResource = resource.toHtmlWithoutParagraphs()
+  val formattedHtml = String.format(htmlResource, *escapedArgs)
+  return HtmlCompat.fromHtml(formattedHtml, HtmlCompat.FROM_HTML_MODE_LEGACY)
+}
+
+@Composable
+fun annotatedStringResource(@StringRes id: Int): AnnotatedString {
+  val resources = resources()
+  val density = LocalDensity.current
+  return remember(id) {
+    val text = resources.getText(id)
+    spannableStringToAnnotatedString(text, density)
+  }
+}
+
+private fun spannableStringToAnnotatedString(
+  text: CharSequence,
+  density: Density,
+): AnnotatedString {
+  return if (text is Spanned) {
+    with(density) {
+      buildAnnotatedString {
+        append((text.toString()))
+        text.getSpans(0, text.length, Any::class.java).forEach {
+          val start = text.getSpanStart(it)
+          val end = text.getSpanEnd(it)
+          when (it) {
+            is StyleSpan -> when (it.style) {
+              Typeface.NORMAL -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Normal,
+                  fontStyle = FontStyle.Normal,
+                ),
+                start,
+                end
+              )
+              Typeface.BOLD -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Bold,
+                  fontStyle = FontStyle.Normal
+                ),
+                start,
+                end
+              )
+              Typeface.ITALIC -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Normal,
+                  fontStyle = FontStyle.Italic
+                ),
+                start,
+                end
+              )
+              Typeface.BOLD_ITALIC -> addStyle(
+                SpanStyle(
+                  fontWeight = FontWeight.Bold,
+                  fontStyle = FontStyle.Italic
+                ),
+                start,
+                end
+              )
+            }
+            is TypefaceSpan -> addStyle(
+              SpanStyle(
+                fontFamily = when (it.family) {
+                  FontFamily.SansSerif.name -> FontFamily.SansSerif
+                  FontFamily.Serif.name -> FontFamily.Serif
+                  FontFamily.Monospace.name -> FontFamily.Monospace
+                  FontFamily.Cursive.name -> FontFamily.Cursive
+                  else -> FontFamily.Default
+                }
+              ),
+              start,
+              end
+            )
+            is AbsoluteSizeSpan -> addStyle(
+              SpanStyle(fontSize = if (it.dip) it.size.dp.toSp() else it.size.toSp()),
+              start,
+              end
+            )
+            is RelativeSizeSpan -> addStyle(
+              SpanStyle(fontSize = it.sizeChange.em),
+              start,
+              end
+            )
+            is StrikethroughSpan -> addStyle(
+              SpanStyle(textDecoration = TextDecoration.LineThrough),
+              start,
+              end
+            )
+            is UnderlineSpan -> addStyle(
+              SpanStyle(textDecoration = TextDecoration.Underline),
+              start,
+              end
+            )
+            is SuperscriptSpan -> addStyle(
+              SpanStyle(baselineShift = BaselineShift.Superscript),
+              start,
+              end
+            )
+            is SubscriptSpan -> addStyle(
+              SpanStyle(baselineShift = BaselineShift.Subscript),
+              start,
+              end
+            )
+            is ForegroundColorSpan -> addStyle(
+              SpanStyle(color = Color(it.foregroundColor)),
+              start,
+              end
+            )
+            else -> addStyle(SpanStyle(color = Color.White), start, end)
+          }
+        }
+      }
+    }
+  } else {
+    AnnotatedString(text.toString())
+  }
+}
+
+// maximum image file size to be auto-accepted
+const val MAX_IMAGE_SIZE: Long = 236700
+const val MAX_FILE_SIZE: Long = 8000000
+
+fun getFilesDirectory(context: Context): String {
+  return context.filesDir.toString()
+}
+
+fun getAppFilesDirectory(context: Context): String {
+  return "${getFilesDirectory(context)}/app_files"
+}
+
+fun getAppFilePath(context: Context, fileName: String): String {
+  return "${getAppFilesDirectory(context)}/$fileName"
+}
+
+fun getLoadedFilePath(context: Context, file: CIFile?): String? {
+  return if (file?.filePath != null && file.loaded) {
+    val filePath = getAppFilePath(context, file.filePath)
+    if (File(filePath).exists()) filePath else null
+  } else {
+    null
+  }
+}
+
+// https://developer.android.com/training/data-storage/shared/documents-files#bitmap
+fun getLoadedImage(context: Context, file: CIFile?): Bitmap? {
+  val filePath = getLoadedFilePath(context, file)
+  return if (filePath != null) {
+    try {
+      val uri = FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", File(filePath))
+      val parcelFileDescriptor = context.contentResolver.openFileDescriptor(uri, "r")
+      val fileDescriptor = parcelFileDescriptor?.fileDescriptor
+      val image = decodeSampledBitmapFromFileDescriptor(fileDescriptor, 1000, 1000)
+      parcelFileDescriptor?.close()
+      image
+    } catch (e: Exception) {
+      null
+    }
+  } else {
+    null
+  }
+}
+
+// https://developer.android.com/topic/performance/graphics/load-bitmap#load-bitmap
+private fun decodeSampledBitmapFromFileDescriptor(fileDescriptor: FileDescriptor?, reqWidth: Int, reqHeight: Int): Bitmap {
+  // First decode with inJustDecodeBounds=true to check dimensions
+  return BitmapFactory.Options().run {
+    inJustDecodeBounds = true
+    BitmapFactory.decodeFileDescriptor(fileDescriptor, null, this)
+    // Calculate inSampleSize
+    inSampleSize = calculateInSampleSize(this, reqWidth, reqHeight)
+    // Decode bitmap with inSampleSize set
+    inJustDecodeBounds = false
+
+    BitmapFactory.decodeFileDescriptor(fileDescriptor, null, this)
+  }
+}
+
+private fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+  // Raw height and width of image
+  val (height: Int, width: Int) = options.run { outHeight to outWidth }
+  var inSampleSize = 1
+
+  if (height > reqHeight || width > reqWidth) {
+    val halfHeight: Int = height / 2
+    val halfWidth: Int = width / 2
+    // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+    // height and width larger than the requested height and width.
+    while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
+      inSampleSize *= 2
+    }
+  }
+
+  return inSampleSize
+}
+
+fun getFileName(context: Context, uri: Uri): String? {
+  return context.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+    cursor.moveToFirst()
+    cursor.getString(nameIndex)
+  }
+}
+
+fun getFileSize(context: Context, uri: Uri): Long? {
+  return context.contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+    val sizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE)
+    cursor.moveToFirst()
+    cursor.getLong(sizeIndex)
+  }
+}
+
+fun saveImage(context: Context, image: Bitmap): String? {
+  return try {
+    val dataResized = resizeImageToDataSize(image, maxDataSize = MAX_IMAGE_SIZE)
+    val timestamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
+    val fileToSave = uniqueCombine(context, "IMG_${timestamp}.jpg")
+    val file = File(getAppFilePath(context, fileToSave))
+    val output = FileOutputStream(file)
+    dataResized.writeTo(output)
+    output.flush()
+    output.close()
+    fileToSave
+  } catch (e: Exception) {
+    Log.e(chat.simplex.app.TAG, "Util.kt saveImage error: ${e.message}")
+    null
+  }
+}
+
+fun saveFileFromUri(context: Context, uri: Uri): String? {
+  return try {
+    val inputStream = context.contentResolver.openInputStream(uri)
+    val fileToSave = getFileName(context, uri)
+    if (inputStream != null && fileToSave != null) {
+      val destFileName = uniqueCombine(context, fileToSave)
+      val destFile = File(getAppFilePath(context, destFileName))
+      FileUtils.copy(inputStream, FileOutputStream(destFile))
+      destFileName
+    } else {
+      Log.e(chat.simplex.app.TAG, "Util.kt saveFileFromUri null inputStream")
+      null
+    }
+  } catch (e: Exception) {
+    Log.e(chat.simplex.app.TAG, "Util.kt saveFileFromUri error: ${e.message}")
+    null
+  }
+}
+
+fun uniqueCombine(context: Context, fileName: String): String {
+  fun tryCombine(fileName: String, n: Int): String {
+    val name = File(fileName).nameWithoutExtension
+    val ext = File(fileName).extension
+    val suffix = if (n == 0) "" else "_$n"
+    val f = "$name$suffix.$ext"
+    return if (File(getAppFilePath(context, f)).exists()) tryCombine(fileName, n + 1) else f
+  }
+  return tryCombine(fileName, 0)
+}
+
+fun formatBytes(bytes: Long): String {
+  if (bytes == 0.toLong()) {
+    return "0 bytes"
+  }
+  val bytesDouble = bytes.toDouble()
+  val k = 1000.toDouble()
+  val units = arrayOf("bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+  val i = kotlin.math.floor(log2(bytesDouble) / log2(k))
+  val size = bytesDouble / k.pow(i)
+  val unit = units[i.toInt()]
+
+  return if (i <= 1) {
+    String.format("%.0f %s", size, unit)
+  } else {
+    String.format("%.2f %s", size, unit)
+  }
+}
+
+fun removeFile(context: Context, fileName: String): Boolean {
+  val file = File(getAppFilePath(context, fileName))
+  val fileDeleted = file.delete()
+  if (!fileDeleted) {
+    Log.e(chat.simplex.app.TAG, "Util.kt removeFile error")
+  }
+  return fileDeleted
+}

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

@@ -2,23 +2,25 @@ package chat.simplex.app.views.newchat
 
 import android.content.res.Configuration
 import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.TheaterComedy
+import androidx.compose.material.icons.outlined.Info
 import androidx.compose.material.icons.outlined.Share
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.*
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.generalGetString
 import chat.simplex.app.views.helpers.shareText
 
 @Composable
@@ -27,6 +29,7 @@ fun AddContactView(chatModel: ChatModel) {
   if (connReq != null) {
     val cxt = LocalContext.current
     AddContactLayout(
+      chatModelIncognito = chatModel.incognito.value,
       connReq = connReq,
       share = { shareText(cxt, connReq) }
     )
@@ -34,22 +37,32 @@ fun AddContactView(chatModel: ChatModel) {
 }
 
 @Composable
-fun AddContactLayout(connReq: String, share: () -> Unit) {
+fun AddContactLayout(chatModelIncognito: Boolean, connReq: String, share: () -> Unit) {
   BoxWithConstraints {
     val screenHeight = maxHeight
     Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
+      Modifier.padding(bottom = 16.dp),
       verticalArrangement = Arrangement.SpaceBetween,
     ) {
       Text(
-        "Add contact",
+        stringResource(R.string.add_contact),
         style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        modifier = Modifier
+          .padding(vertical = 5.dp)
+          .padding(horizontal = 8.dp)
       )
       Text(
-        "Show QR code to your contact\nto scan from the app",
-        style = MaterialTheme.typography.h3,
-        textAlign = TextAlign.Center,
+        stringResource(R.string.show_QR_code_for_your_contact_to_scan_from_the_app__multiline),
+        modifier = Modifier.padding(horizontal = 8.dp)
       )
+      Row(Modifier.padding(horizontal = 8.dp)) {
+        InfoAboutIncognito(
+          chatModelIncognito,
+          true,
+          generalGetString(R.string.incognito_random_profile_description),
+          generalGetString(R.string.your_profile_will_be_sent)
+        )
+      }
       QRCode(
         connReq, Modifier
           .weight(1f, fill = false)
@@ -57,21 +70,53 @@ fun AddContactLayout(connReq: String, share: () -> Unit) {
           .padding(vertical = 3.dp)
       )
       Text(
-        buildAnnotatedString {
-          append("If you cannot meet in person, you can ")
-          withStyle(SpanStyle(fontWeight = FontWeight.Bold)) {
-            append("scan QR code in the video call")
-          }
-          append(", or you can share the invitation link via any other channel.")
-        },
-        textAlign = TextAlign.Center,
-        style = MaterialTheme.typography.caption.copy(fontSize=if(screenHeight > 600.dp) 20.sp else 16.sp),
+        stringResource(R.string.if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel),
+        lineHeight = 22.sp,
         modifier = Modifier
-          .padding(horizontal = 16.dp)
-          .padding(bottom = if(screenHeight > 600.dp) 16.dp else 8.dp)
+          .padding(horizontal = 8.dp)
+          .padding(bottom = if (screenHeight > 600.dp) 16.dp else 8.dp)
       )
-      SimpleButton("Share invitation link", icon = Icons.Outlined.Share, click = share)
-      Spacer(Modifier.height(10.dp))
+      Row(
+        Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.Center
+      ) {
+        SimpleButton(stringResource(R.string.share_invitation_link), icon = Icons.Outlined.Share, click = share)
+      }
+    }
+  }
+}
+
+@Composable
+fun InfoAboutIncognito(chatModelIncognito: Boolean, supportedIncognito: Boolean = true, onText: String, offText: String) {
+  if (chatModelIncognito) {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(vertical = 4.dp),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Icon(
+        if (supportedIncognito) Icons.Filled.TheaterComedy else Icons.Outlined.Info,
+        stringResource(R.string.incognito),
+        tint = if (supportedIncognito) Indigo else WarningOrange,
+        modifier = Modifier.padding(end = 10.dp).size(20.dp)
+      )
+      Text(onText, textAlign = TextAlign.Left, style = MaterialTheme.typography.body2)
+    }
+  } else {
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(vertical = 4.dp),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Icon(
+        Icons.Outlined.Info,
+        stringResource(R.string.incognito),
+        tint = HighOrLowlight,
+        modifier = Modifier.padding(end = 10.dp).size(20.dp)
+      )
+      Text(offText, textAlign = TextAlign.Left, style = MaterialTheme.typography.body2)
     }
   }
 }
@@ -86,6 +131,7 @@ fun AddContactLayout(connReq: String, share: () -> Unit) {
 fun PreviewAddContactView() {
   SimpleXTheme {
     AddContactLayout(
+      chatModelIncognito = false,
       connReq = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D",
       share = {}
     )

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

@@ -0,0 +1,185 @@
+package chat.simplex.app.views.newchat
+
+import android.graphics.Bitmap
+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.outlined.ArrowForwardIos
+import androidx.compose.runtime.*
+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.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.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.ProfileNameField
+import chat.simplex.app.views.chat.group.AddGroupMembersView
+import chat.simplex.app.views.chatlist.setGroupMembers
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.isValidDisplayName
+import chat.simplex.app.views.onboarding.ReadableText
+import chat.simplex.app.views.usersettings.DeleteImageButton
+import chat.simplex.app.views.usersettings.EditImageButton
+import com.google.accompanist.insets.ProvideWindowInsets
+import com.google.accompanist.insets.navigationBarsWithImePadding
+import kotlinx.coroutines.launch
+
+@Composable
+fun AddGroupView(chatModel: ChatModel, close: () -> Unit) {
+  AddGroupLayout(
+    chatModel.incognito.value,
+    createGroup = { groupProfile ->
+      withApi {
+        val groupInfo = chatModel.controller.apiNewGroup(groupProfile)
+        if (groupInfo != null) {
+          chatModel.addChat(Chat(chatInfo = ChatInfo.Group(groupInfo), chatItems = listOf()))
+          chatModel.chatItems.clear()
+          chatModel.chatId.value = groupInfo.id
+          setGroupMembers(groupInfo, chatModel)
+          close.invoke()
+          ModalManager.shared.showCustomModal { close ->
+            ModalView(
+              close = close, modifier = Modifier,
+              background = if (isInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight
+            ) {
+              AddGroupMembersView(groupInfo, chatModel, close)
+            }
+          }
+        }
+      }
+    },
+    close
+  )
+}
+
+@Composable
+fun AddGroupLayout(chatModelIncognito: Boolean, createGroup: (GroupProfile) -> Unit, close: () -> Unit) {
+  val bottomSheetModalState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
+  val scope = rememberCoroutineScope()
+  val displayName = remember { mutableStateOf("") }
+  val fullName = remember { mutableStateOf("") }
+  val profileImage = remember { mutableStateOf<String?>(null) }
+  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val 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) {
+        Surface(Modifier.background(MaterialTheme.colors.onBackground).fillMaxSize()) {
+          Column(
+            Modifier
+              .verticalScroll(rememberScrollState())
+              .padding(bottom = 16.dp),
+          ) {
+            Text(
+              stringResource(R.string.create_secret_group_title),
+              style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+              modifier = Modifier.padding(vertical = 5.dp)
+            )
+            Text(stringResource(R.string.group_is_decentralized))
+            InfoAboutIncognito(
+              chatModelIncognito,
+              false,
+              generalGetString(R.string.group_unsupported_incognito_main_profile_sent),
+              generalGetString(R.string.group_main_profile_sent)
+            )
+            Box(
+              Modifier
+                .fillMaxWidth()
+                .padding(bottom = 24.dp),
+              contentAlignment = Alignment.Center
+            ) {
+              Box(contentAlignment = Alignment.TopEnd) {
+                Box(contentAlignment = Alignment.Center) {
+                  ProfileImage(size = 192.dp, image = profileImage.value)
+                  EditImageButton { scope.launch { bottomSheetModalState.show() } }
+                }
+                if (profileImage.value != null) {
+                  DeleteImageButton { profileImage.value = null }
+                }
+              }
+            }
+            Text(
+              stringResource(R.string.group_display_name_field),
+              Modifier.padding(bottom = 3.dp)
+            )
+            ProfileNameField(displayName, focusRequester)
+            val errorText = if (!isValidDisplayName(displayName.value)) stringResource(R.string.display_name_cannot_contain_whitespace) else ""
+            Text(
+              errorText,
+              fontSize = 15.sp,
+              color = MaterialTheme.colors.error
+            )
+            Spacer(Modifier.height(3.dp))
+            Text(
+              stringResource(R.string.group_full_name_field),
+              Modifier.padding(bottom = 5.dp)
+            )
+            ProfileNameField(fullName)
+
+            Spacer(Modifier.height(8.dp))
+            val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
+            if (enabled) {
+              CreateGroupButton(MaterialTheme.colors.primary, Modifier
+                .clickable { createGroup(GroupProfile(displayName.value, fullName.value, profileImage.value)) }
+                .padding(8.dp))
+            } else {
+              CreateGroupButton(HighOrLowlight, Modifier.padding(8.dp))
+            }
+            LaunchedEffect(Unit) {
+              focusRequester.requestFocus()
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun CreateGroupButton(color: Color, modifier: Modifier) {
+  Row(
+    Modifier.fillMaxWidth(),
+    horizontalArrangement = Arrangement.End
+  ) {
+    Surface(shape = RoundedCornerShape(20.dp)) {
+      Row(modifier, verticalAlignment = Alignment.CenterVertically) {
+        Text(stringResource(R.string.create_profile_button), style = MaterialTheme.typography.caption, color = color)
+        Icon(Icons.Outlined.ArrowForwardIos, stringResource(R.string.create_profile_button), tint = color)
+      }
+    }
+  }
+}
+
+@Preview
+@Composable
+fun PreviewAddGroupLayout() {
+  SimpleXTheme {
+    AddGroupLayout(
+      chatModelIncognito = false,
+      createGroup = {},
+      close = {}
+    )
+  }
+}

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

@@ -1,8 +1,9 @@
 package chat.simplex.app.views.newchat
 
 import android.Manifest
-import androidx.compose.foundation.clickable
+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.outlined.*
@@ -10,14 +11,17 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.chatlist.ScaffoldController
+import chat.simplex.app.views.helpers.ModalManager
 import chat.simplex.app.views.helpers.withApi
 import com.google.accompanist.permissions.rememberPermissionState
 
@@ -38,80 +42,143 @@ fun NewChatSheet(chatModel: ChatModel, newChatCtrl: ScaffoldController) {
     },
     scanCode = {
       newChatCtrl.collapse()
-      ModalManager.shared.showCustomModal { close -> ConnectContactView(chatModel, close) }
+      ModalManager.shared.showCustomModal { close -> ScanToConnectView(chatModel, close) }
       cameraPermissionState.launchPermissionRequest()
+    },
+    pasteLink = {
+      newChatCtrl.collapse()
+      ModalManager.shared.showCustomModal { close -> PasteToConnectView(chatModel, close) }
+    },
+    createGroup = {
+      newChatCtrl.collapse()
+      ModalManager.shared.showCustomModal { close -> AddGroupView(chatModel, close) }
     }
   )
 }
 
 @Composable
-fun NewChatSheetLayout(addContact: () -> Unit, scanCode: () -> Unit) {
-  Row(
-    Modifier
-      .fillMaxWidth()
-      .padding(horizontal = 8.dp, vertical = 48.dp),
-    horizontalArrangement = Arrangement.SpaceEvenly
-  ) {
-    Box(
-      Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Add contact", "(create QR code\nor link)",
-        Icons.Outlined.PersonAdd, click = addContact
+fun NewChatSheetLayout(
+  addContact: () -> Unit,
+  scanCode: () -> Unit,
+  pasteLink: () -> Unit,
+  createGroup: () -> Unit
+) {
+  Column(horizontalAlignment = Alignment.CenterHorizontally) {
+    Text(
+      stringResource(R.string.add_contact_or_create_group),
+      modifier = Modifier.padding(horizontal = 4.dp).padding(top = 20.dp, bottom = 20.dp),
+      style = MaterialTheme.typography.body2
+    )
+    val boxModifier = Modifier.fillMaxWidth().height(80.dp).padding(horizontal = 0.dp)
+    Divider(Modifier.padding(horizontal = 8.dp))
+    Box(boxModifier) {
+      ActionRowButton(
+        stringResource(R.string.create_one_time_link),
+        stringResource(R.string.to_share_with_your_contact),
+        Icons.Outlined.AddLink,
+        click = addContact
       )
     }
-    Box(
-      Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Scan QR code", "(in person or in video call)",
-        Icons.Outlined.QrCode, click = scanCode
+    Divider(Modifier.padding(horizontal = 8.dp))
+    Box(boxModifier) {
+      ActionRowButton(
+        stringResource(R.string.paste_received_link),
+        stringResource(R.string.paste_received_link_from_clipboard),
+        Icons.Outlined.Article,
+        click = pasteLink
       )
     }
-    Box(
-      Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Create Group", "(coming soon!)",
-        Icons.Outlined.GroupAdd, disabled = true
+    Divider(Modifier.padding(horizontal = 8.dp))
+    Box(boxModifier) {
+      ActionRowButton(
+        stringResource(R.string.scan_QR_code),
+        stringResource(R.string.in_person_or_in_video_call__bracketed),
+        Icons.Outlined.QrCode,
+        click = scanCode
+      )
+    }
+    Divider(Modifier.padding(horizontal = 8.dp))
+    Box(boxModifier) {
+      ActionRowButton(
+        stringResource(R.string.create_group),
+        stringResource(R.string.only_stored_on_members_devices),
+        icon = Icons.Outlined.Group,
+        click = createGroup
       )
     }
   }
 }
 
 @Composable
-fun ActionButton(text: String?, comment: String?, icon: ImageVector, disabled: Boolean = false,
-                 click: () -> Unit = {}) {
-  Column(
-    Modifier
-      .clickable(onClick = click)
-      .padding(horizontal = 8.dp),
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
-    Icon(icon, text,
-      tint = tint,
-      modifier = Modifier
-        .size(40.dp)
-        .padding(bottom = 8.dp))
-    if (text != null) {
-      Text(
-        text,
-        textAlign = TextAlign.Center,
-        fontWeight = FontWeight.Bold,
-        color = tint,
-        modifier = Modifier.padding(bottom = 4.dp)
-      )
+fun ActionRowButton(
+  text: String, comment: String? = null, icon: ImageVector, disabled: Boolean = false,
+  click: () -> Unit = {}
+) {
+  Surface(Modifier.fillMaxSize()) {
+    Row(
+      Modifier.clickable(onClick = click).size(48.dp).padding(8.dp),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+      Icon(icon, text, tint = tint, modifier = Modifier.size(48.dp).padding(start = 4.dp, end = 16.dp))
+
+      Column {
+        Text(
+          text,
+          textAlign = TextAlign.Center,
+          fontWeight = FontWeight.Bold,
+          color = tint
+        )
+
+        if (comment != null) {
+          Text(
+            comment,
+            textAlign = TextAlign.Center,
+            style = MaterialTheme.typography.body2
+          )
+        }
+      }
     }
-    if (comment != null) {
-      Text(
-        comment,
-        textAlign = TextAlign.Center,
-        style = MaterialTheme.typography.body2
-      )
+  }
+}
+
+@Composable
+fun ActionButton(
+  text: String?,
+  comment: String?,
+  icon: ImageVector,
+  disabled: Boolean = false,
+  click: () -> Unit = {}
+) {
+  Surface(shape = RoundedCornerShape(18.dp)) {
+    Column(
+      Modifier
+        .clickable(onClick = click)
+        .padding(8.dp),
+      horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+      val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+      Icon(icon, text,
+        tint = tint,
+        modifier = Modifier
+          .size(40.dp)
+          .padding(bottom = 8.dp))
+      if (text != null) {
+        Text(
+          text,
+          textAlign = TextAlign.Center,
+          fontWeight = FontWeight.Bold,
+          color = tint,
+          modifier = Modifier.padding(bottom = 4.dp)
+        )
+      }
+      if (comment != null) {
+        Text(
+          comment,
+          textAlign = TextAlign.Center,
+          style = MaterialTheme.typography.body2
+        )
+      }
     }
   }
 }
@@ -122,7 +189,9 @@ fun PreviewNewChatSheet() {
   SimpleXTheme {
     NewChatSheetLayout(
       addContact = {},
-      scanCode = {}
+      scanCode = {},
+      pasteLink = {},
+      createGroup = {}
     )
   }
 }

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

@@ -0,0 +1,136 @@
+package chat.simplex.app.views.newchat
+
+import android.content.ClipboardManager
+import android.content.res.Configuration
+import android.net.Uri
+import androidx.activity.compose.BackHandler
+import 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.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat.getSystemService
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.SimpleButton
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.*
+
+@Composable
+fun PasteToConnectView(chatModel: ChatModel, close: () -> Unit) {
+  val connectionLink = remember { mutableStateOf("")}
+  val context = LocalContext.current
+  val clipboard = getSystemService(context, ClipboardManager::class.java)
+  BackHandler(onBack = close)
+  PasteToConnectLayout(
+    chatModel.incognito.value,
+    connectionLink = connectionLink,
+    pasteFromClipboard = {
+      connectionLink.value = clipboard?.primaryClip?.getItemAt(0)?.coerceToText(context) as String
+    },
+    connectViaLink = { connReqUri ->
+      try {
+        val uri = Uri.parse(connReqUri)
+        withUriAction(uri) { action ->
+          connectViaUri(chatModel, action, uri)
+        }
+      } catch (e: RuntimeException) {
+        AlertManager.shared.showAlertMsg(
+          title = generalGetString(R.string.invalid_connection_link),
+          text = generalGetString(R.string.this_string_is_not_a_connection_link)
+        )
+      }
+      close()
+    },
+    close = close
+  )
+}
+
+@Composable
+fun PasteToConnectLayout(
+  chatModelIncognito: Boolean,
+  connectionLink: MutableState<String>,
+  pasteFromClipboard: () -> Unit,
+  connectViaLink: (String) -> Unit,
+  close: () -> Unit
+) {
+  ModalView(close) {
+    Column(
+      Modifier.padding(bottom = 16.dp),
+      verticalArrangement = Arrangement.SpaceBetween,
+    ) {
+      Text(
+        stringResource(R.string.connect_via_link),
+        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        modifier = Modifier.padding(vertical = 5.dp)
+      )
+      Text(stringResource(R.string.paste_connection_link_below_to_connect))
+
+      InfoAboutIncognito(
+        chatModelIncognito,
+        true,
+        generalGetString(R.string.incognito_random_profile_from_contact_description),
+        generalGetString(R.string.profile_will_be_sent_to_contact_sending_link)
+      )
+
+      Box(Modifier.padding(top = 16.dp, bottom = 6.dp)) {
+        TextEditor(Modifier.height(180.dp), text = connectionLink)
+      }
+
+      Row(
+        Modifier.fillMaxWidth().padding(bottom = 6.dp),
+        horizontalArrangement = Arrangement.Start,
+      ) {
+        if (connectionLink.value == "") {
+          SimpleButton(text = "Paste", icon = Icons.Outlined.ContentPaste) {
+            pasteFromClipboard()
+          }
+        } else {
+          SimpleButton(text = "Clear", icon = Icons.Outlined.Clear) {
+            connectionLink.value = ""
+          }
+        }
+        Spacer(Modifier.weight(1f).fillMaxWidth())
+        SimpleButton(text = "Connect", icon = Icons.Outlined.Link) {
+          connectViaLink(connectionLink.value)
+        }
+      }
+
+      Text(annotatedStringResource(R.string.you_can_also_connect_by_clicking_the_link))
+    }
+  }
+}
+
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewPasteToConnectTextbox() {
+  SimpleXTheme {
+    PasteToConnectLayout(
+      chatModelIncognito = false,
+      connectionLink = remember { mutableStateOf("") },
+      pasteFromClipboard = {},
+      connectViaLink = { link ->
+        try {
+          println(link)
+  //        withApi { chatModel.controller.apiConnect(link) }
+        } catch (e: Exception) {
+          e.printStackTrace()
+        }
+      },
+      close = {}
+    )
+  }
+}

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

@@ -1,36 +1,32 @@
 package chat.simplex.app.views.newchat
 
 import android.graphics.Bitmap
-import android.graphics.Color
 import androidx.compose.foundation.Image
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
+import boofcv.alg.fiducial.qrcode.QrCodeEncoder
+import boofcv.alg.fiducial.qrcode.QrCodeGeneratorImage
+import boofcv.android.ConvertBitmap
+import chat.simplex.app.R
 import chat.simplex.app.ui.theme.SimpleXTheme
-import com.google.zxing.BarcodeFormat
-import com.google.zxing.EncodeHintType
-import com.google.zxing.qrcode.QRCodeWriter
 
 @Composable
 fun QRCode(connReq: String, modifier: Modifier = Modifier) {
   Image(
     bitmap = qrCodeBitmap(connReq, 1024).asImageBitmap(),
-    contentDescription = "QR Code",
+    contentDescription = stringResource(R.string.image_descr_qr_code),
     modifier = modifier
   )
 }
 
 fun qrCodeBitmap(content: String, size: Int): Bitmap {
-  val hints = hashMapOf<EncodeHintType, Int>().also { it[EncodeHintType.MARGIN] = 1 }
-  val bits = QRCodeWriter().encode(content, BarcodeFormat.QR_CODE, size, size, hints)
-  return Bitmap.createBitmap(size, size, Bitmap.Config.RGB_565).also {
-    for (x in 0 until size) {
-      for (y in 0 until size) {
-        it.setPixel(x, y, if (bits[x, y]) Color.BLACK else Color.WHITE)
-      }
-    }
-  }
+  val qrCode = QrCodeEncoder().addAutomatic(content).fixate()
+  val renderer = QrCodeGeneratorImage(5)
+  renderer.render(qrCode)
+  return ConvertBitmap.grayToBitmap(renderer.gray, Bitmap.Config.RGB_565)
 }
 
 @Preview

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

@@ -1,5 +1,6 @@
 package chat.simplex.app.views.newchat
 
+import android.annotation.SuppressLint
 import android.util.Log
 import android.view.ViewGroup
 import androidx.camera.core.*
@@ -10,21 +11,34 @@ import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalLifecycleOwner
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.core.content.ContextCompat
+import boofcv.abst.fiducial.QrCodeDetector
+import boofcv.alg.color.ColorFormat
+import boofcv.android.ConvertCameraImage
+import boofcv.factory.fiducial.FactoryFiducial
+import boofcv.struct.image.GrayU8
 import chat.simplex.app.TAG
 import com.google.common.util.concurrent.ListenableFuture
-import com.google.mlkit.vision.barcode.BarcodeScannerOptions
-import com.google.mlkit.vision.barcode.BarcodeScanning
-import com.google.mlkit.vision.barcode.common.Barcode
-import com.google.mlkit.vision.common.InputImage
 import java.util.concurrent.*
 
-// Bar code scanner adapted from https://github.com/MakeItEasyDev/Jetpack-Compose-BarCode-Scanner
+// Adapted from learntodroid - https://gist.github.com/learntodroid/8f839be0b29d0378f843af70607bd7f5
 
 @Composable
 fun QRCodeScanner(onBarcode: (String) -> Unit) {
   val context = LocalContext.current
   val lifecycleOwner = LocalLifecycleOwner.current
   var preview by remember { mutableStateOf<Preview?>(null) }
+  var lastAnalyzedTimeStamp = 0L
+  var contactLink = ""
+
+  val cameraProviderFuture by produceState<ListenableFuture<ProcessCameraProvider>?>(initialValue = null) {
+    value = ProcessCameraProvider.getInstance(context)
+  }
+
+  DisposableEffect(lifecycleOwner) {
+    onDispose {
+      cameraProviderFuture?.get()?.unbindAll()
+    }
+  }
 
   AndroidView(
     factory = { AndroidViewContext ->
@@ -36,74 +50,56 @@ fun QRCodeScanner(onBarcode: (String) -> Unit) {
         )
         implementationMode = PreviewView.ImplementationMode.COMPATIBLE
       }
-    },
-//    modifier = Modifier.fillMaxSize(),
-    update = { previewView ->
-      val cameraSelector: CameraSelector = CameraSelector.Builder()
-        .requireLensFacing(CameraSelector.LENS_FACING_BACK)
-        .build()
-      val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
-      val cameraProviderFuture: ListenableFuture<ProcessCameraProvider> =
-        ProcessCameraProvider.getInstance(context)
-
-      cameraProviderFuture.addListener({
-        preview = Preview.Builder().build().also {
-          it.setSurfaceProvider(previewView.surfaceProvider)
-        }
-        val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
-        val barcodeAnalyser = BarCodeAnalyser { barcodes ->
-          barcodes.firstOrNull()?.rawValue?.let(onBarcode)
-        }
-        val imageAnalysis: ImageAnalysis = ImageAnalysis.Builder()
-          .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
-          .build()
-          .also { it.setAnalyzer(cameraExecutor, barcodeAnalyser) }
-
-        try {
-          cameraProvider.unbindAll()
-          cameraProvider.bindToLifecycle(lifecycleOwner, cameraSelector, preview, imageAnalysis)
-        } catch (e: Exception) {
-          Log.d(TAG, "CameraPreview: ${e.localizedMessage}")
-        }
-      }, ContextCompat.getMainExecutor(context))
     }
-  )
-}
-
-class BarCodeAnalyser(
-  private val onBarcodeDetected: (barcodes: List<Barcode>) -> Unit,
-): ImageAnalysis.Analyzer {
-  private var lastAnalyzedTimeStamp = 0L
-
-  @ExperimentalGetImage
-  override fun analyze(image: ImageProxy) {
-    val currentTimestamp = System.currentTimeMillis()
-    if (currentTimestamp - lastAnalyzedTimeStamp >= TimeUnit.SECONDS.toMillis(1)) {
-      image.image?.let { imageToAnalyze ->
-        val options = BarcodeScannerOptions.Builder()
-          .setBarcodeFormats(Barcode.FORMAT_ALL_FORMATS)
-          .build()
-        val barcodeScanner = BarcodeScanning.getClient(options)
-        val imageToProcess = InputImage.fromMediaImage(imageToAnalyze, image.imageInfo.rotationDegrees)
-
-        barcodeScanner.process(imageToProcess)
-          .addOnSuccessListener { barcodes ->
-            if (barcodes.isNotEmpty()) {
-              onBarcodeDetected(barcodes)
-            } else {
-              Log.d(TAG, "BarcodeAnalyser: No barcode Scanned")
+  ) { previewView ->
+    val cameraSelector: CameraSelector = CameraSelector.Builder()
+      .requireLensFacing(CameraSelector.LENS_FACING_BACK)
+      .build()
+    val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    cameraProviderFuture?.addListener({
+      preview = Preview.Builder().build().also {
+        it.setSurfaceProvider(previewView.surfaceProvider)
+      }
+      val detector: QrCodeDetector<GrayU8> = FactoryFiducial.qrcode(null, GrayU8::class.java)
+      fun getQR(imageProxy: ImageProxy) {
+        val currentTimeStamp = System.currentTimeMillis()
+        if (currentTimeStamp - lastAnalyzedTimeStamp >= TimeUnit.SECONDS.toMillis(1)) {
+          detector.process(imageProxyToGrayU8(imageProxy))
+          val found = detector.detections
+          val qr = found.firstOrNull()
+          if (qr != null) {
+            if (qr.message != contactLink) {
+              // Make sure link is new and not a repeat
+              contactLink = qr.message
+              onBarcode(contactLink)
             }
           }
-          .addOnFailureListener { exception ->
-            Log.e(TAG, "BarcodeAnalyser: Something went wrong $exception")
-          }
-          .addOnCompleteListener {
-            image.close()
-          }
+        }
+        imageProxy.close()
       }
-      lastAnalyzedTimeStamp = currentTimestamp
-    } else {
-      image.close()
-    }
+      val imageAnalyzer = ImageAnalysis.Analyzer { proxy -> getQR(proxy) }
+      val imageAnalysis: ImageAnalysis = ImageAnalysis.Builder()
+        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+        .setImageQueueDepth(1)
+        .build()
+        .also { it.setAnalyzer(cameraExecutor, imageAnalyzer) }
+      try {
+        cameraProviderFuture?.get()?.unbindAll()
+        cameraProviderFuture?.get()?.bindToLifecycle(lifecycleOwner, cameraSelector, preview, imageAnalysis)
+      } catch (e: Exception) {
+        Log.d(TAG, "CameraPreview: ${e.localizedMessage}")
+      }
+    }, ContextCompat.getMainExecutor(context))
   }
 }
+
+@SuppressLint("UnsafeOptInUsageError")
+private fun imageProxyToGrayU8(img: ImageProxy) : GrayU8? {
+  val image = img.image
+  if (image != null) {
+    val outImg = GrayU8()
+    ConvertCameraImage.imageToBoof(image, ColorFormat.GRAY, outImg, null)
+    return outImg
+  }
+  return null
+}

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

@@ -8,20 +8,20 @@ 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.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.helpers.*
 
 @Composable
-fun ConnectContactView(chatModel: ChatModel, close: () -> Unit) {
+fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
   BackHandler(onBack = close)
   ConnectContactLayout(
+    chatModelIncognito = chatModel.incognito.value,
     qrCodeScanner = {
       QRCodeScanner { connReqUri ->
         try {
@@ -31,8 +31,8 @@ fun ConnectContactView(chatModel: ChatModel, close: () -> Unit) {
           }
         } catch (e: RuntimeException) {
           AlertManager.shared.showAlertMsg(
-            title = "Invalid QR code",
-            text = "This QR code is not a link!"
+            title = generalGetString(R.string.invalid_QR_code),
+            text = generalGetString(R.string.this_QR_code_is_not_a_link)
           )
         }
         close()
@@ -48,8 +48,8 @@ fun withUriAction(uri: Uri, run: suspend (String) -> Unit) {
     withApi { run(action) }
   } else {
     AlertManager.shared.showAlertMsg(
-      title = "Invalid link!",
-      text = "This link is not a valid connection link!"
+      title = generalGetString(R.string.invalid_contact_link),
+      text = generalGetString(R.string.this_link_is_not_a_valid_connection_link)
     )
   }
 }
@@ -57,32 +57,32 @@ fun withUriAction(uri: Uri, run: suspend (String) -> Unit) {
 suspend fun connectViaUri(chatModel: ChatModel, action: String, uri: Uri) {
   val r = chatModel.controller.apiConnect(uri.toString())
   if (r) {
-    val whenConnected =
-      if (action == "contact") "your connection request is accepted"
-      else "your contact's device is online"
     AlertManager.shared.showAlertMsg(
-      title = "Connection request sent!",
-      text = "You will be connected when $whenConnected, please wait or check later!"
+      title = generalGetString(R.string.connection_request_sent),
+      text =
+        if (action == "contact") generalGetString(R.string.you_will_be_connected_when_your_connection_request_is_accepted)
+        else generalGetString(R.string.you_will_be_connected_when_your_contacts_device_is_online)
     )
   }
 }
 
 @Composable
-fun ConnectContactLayout(qrCodeScanner: @Composable () -> Unit, close: () -> Unit) {
+fun ConnectContactLayout(chatModelIncognito: Boolean, qrCodeScanner: @Composable () -> Unit, close: () -> Unit) {
   ModalView(close) {
     Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
+      Modifier.padding(bottom = 16.dp),
       verticalArrangement = Arrangement.spacedBy(12.dp)
     ) {
       Text(
-        "Scan QR code",
+        generalGetString(R.string.scan_QR_code),
         style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        modifier = Modifier.padding(vertical = 5.dp)
       )
-      Text(
-        "Your chat profile will be sent\nto your contact",
-        style = MaterialTheme.typography.h3,
-        textAlign = TextAlign.Center,
-        modifier = Modifier.padding(bottom = 4.dp)
+      InfoAboutIncognito(
+        chatModelIncognito,
+        true,
+        generalGetString(R.string.incognito_random_profile_description),
+        generalGetString(R.string.your_profile_will_be_sent)
       )
       Box(
         Modifier
@@ -90,18 +90,8 @@ fun ConnectContactLayout(qrCodeScanner: @Composable () -> Unit, close: () -> Uni
           .aspectRatio(ratio = 1F)
       ) { qrCodeScanner() }
       Text(
-        buildAnnotatedString {
-          append("If you cannot meet in person, you can ")
-          withStyle(SpanStyle(fontWeight = FontWeight.Bold)) {
-            append("scan QR code in the video call")
-          }
-          append(", or you can create the invitation link.")
-        },
-        textAlign = TextAlign.Center,
-        style = MaterialTheme.typography.caption,
-        modifier = Modifier
-          .padding(horizontal = 16.dp)
-          .padding(top = 4.dp)
+        annotatedStringResource(R.string.if_you_cannot_meet_in_person_scan_QR_in_video_call_or_ask_for_invitation_link),
+        lineHeight = 22.sp
       )
     }
   }
@@ -117,6 +107,7 @@ fun ConnectContactLayout(qrCodeScanner: @Composable () -> Unit, close: () -> Uni
 fun PreviewConnectContactLayout() {
   SimpleXTheme {
     ConnectContactLayout(
+      chatModelIncognito = false,
       qrCodeScanner = { Surface {} },
       close = {},
     )

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

@@ -0,0 +1,70 @@
+package chat.simplex.app.views.onboarding
+
+import android.content.res.Configuration
+import androidx.annotation.StringRes
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalUriHandler
+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.User
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.ModalManager
+import chat.simplex.app.views.helpers.annotatedStringResource
+
+@Composable
+fun HowItWorks(user: User?, onboardingStage: MutableState<OnboardingStage?>? = null) {
+  Column(Modifier.fillMaxHeight(), horizontalAlignment = Alignment.Start) {
+    Text(stringResource(R.string.how_simplex_works), style = MaterialTheme.typography.h1, modifier = Modifier.padding(bottom = 8.dp))
+    ReadableText(R.string.many_people_asked_how_can_it_deliver)
+    ReadableText(R.string.to_protect_privacy_simplex_has_ids_for_queues)
+    ReadableText(R.string.you_control_servers_to_receive_your_contacts_to_send)
+    ReadableText(R.string.only_client_devices_store_contacts_groups_e2e_encrypted_messages)
+    if (onboardingStage == null) {
+      val uriHandler = LocalUriHandler.current
+      Text(
+        annotatedStringResource(R.string.read_more_in_github_with_link),
+        modifier = Modifier.padding(bottom = 12.dp).clickable { uriHandler.openUri("https://github.com/simplex-chat/simplex-chat#readme") },
+        lineHeight = 22.sp
+      )
+    } else {
+      ReadableText(R.string.read_more_in_github)
+    }
+
+    Spacer(Modifier.fillMaxHeight().weight(1f))
+
+    if (onboardingStage != null) {
+      Box(Modifier.fillMaxWidth().padding(bottom = 16.dp), contentAlignment = Alignment.Center) {
+        OnboardingActionButton(user, onboardingStage, onclick = { ModalManager.shared.closeModal() })
+      }
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+    }
+  }
+}
+
+@Composable
+fun ReadableText(@StringRes stringResId: Int) {
+  Text(annotatedStringResource(stringResId), modifier = Modifier.padding(bottom = 12.dp), lineHeight = 22.sp)
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewHowItWorks() {
+  SimpleXTheme {
+    HowItWorks(user = null)
+  }
+}

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

@@ -0,0 +1,172 @@
+package chat.simplex.app.views.onboarding
+
+import android.Manifest
+import android.content.res.Configuration
+import androidx.annotation.StringRes
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+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.vector.ImageVector
+import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.model.User
+import chat.simplex.app.ui.theme.SimpleButton
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.newchat.*
+import chat.simplex.app.views.usersettings.simplexTeamUri
+import com.google.accompanist.permissions.rememberPermissionState
+
+@Composable
+fun MakeConnection(chatModel: ChatModel) {
+  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
+  MakeConnectionLayout(
+    chatModel.currentUser.value,
+    createLink = {
+      withApi {
+        //        show spinner
+        chatModel.connReqInvitation = chatModel.controller.apiAddContact()
+        //        hide spinner
+        if (chatModel.connReqInvitation != null) {
+          ModalManager.shared.showModal { AddContactView(chatModel) }
+        }
+      }
+    },
+    pasteLink = {
+      ModalManager.shared.showCustomModal { close -> PasteToConnectView(chatModel, close) }
+    },
+    scanCode = {
+      ModalManager.shared.showCustomModal { close -> ScanToConnectView(chatModel, close) }
+      cameraPermissionState.launchPermissionRequest()
+    },
+    about = {
+      chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+    }
+  )
+}
+
+@Composable
+fun MakeConnectionLayout(
+  user: User?,
+  createLink: () -> Unit,
+  pasteLink: () -> Unit,
+  scanCode: () -> Unit,
+  about: () -> Unit
+) {
+  Surface {
+    Column(
+      Modifier
+        .fillMaxSize()
+        .background(color = MaterialTheme.colors.background)
+        .padding(20.dp)
+    ) {
+      Text(
+        if (user == null) stringResource(R.string.make_private_connection)
+        else String.format(stringResource(R.string.personal_welcome), user.profile.displayName),
+        style = MaterialTheme.typography.h1,
+        modifier = Modifier.padding(bottom = 8.dp)
+      )
+      Text(
+        annotatedStringResource(R.string.to_make_your_first_private_connection_choose),
+        modifier = Modifier.padding(bottom = 16.dp)
+      )
+      ActionRow(
+        Icons.Outlined.AddLink,
+        R.string.create_1_time_link_qr_code,
+        R.string.it_s_secure_to_share__only_one_contact_can_use_it,
+        createLink
+      )
+      ActionRow(
+        Icons.Outlined.Article,
+        R.string.paste_the_link_you_received,
+        R.string.or_open_the_link_in_the_browser_and_tap_open_in_mobile,
+        pasteLink
+      )
+      ActionRow(
+        Icons.Outlined.QrCode,
+        R.string.scan_contact_s_qr_code,
+        R.string.in_person_or_via_a_video_call__the_most_secure_way_to_connect,
+        scanCode
+      )
+      Box(Modifier.fillMaxWidth().padding(bottom = 16.dp), contentAlignment = Alignment.Center) {
+        Text(stringResource(R.string.or))
+      }
+      val uriHandler = LocalUriHandler.current
+      ActionRow(
+        Icons.Outlined.Tag,
+        R.string.connect_with_the_developers,
+        R.string.to_ask_any_questions_and_to_receive_simplex_chat_updates,
+        { uriHandler.openUri(simplexTeamUri) }
+      )
+      Spacer(Modifier.fillMaxHeight().weight(1f))
+      SimpleButton(
+        text = stringResource(R.string.about_simplex),
+        icon = Icons.Outlined.ArrowBackIosNew,
+        click = about
+      )
+    }
+  }
+}
+
+@Composable
+private fun ActionRow(icon: ImageVector, @StringRes titleId: Int, @StringRes textId: Int, action: () -> Unit) {
+  Row(
+    Modifier
+      .clickable { action() }
+      .padding(bottom = 16.dp)
+  ) {
+    Icon(icon, stringResource(titleId), tint = MaterialTheme.colors.primary,
+      modifier = Modifier.padding(end = 10.dp).size(40.dp))
+    Column {
+      Text(stringResource(titleId), color = MaterialTheme.colors.primary)
+      Text(annotatedStringResource(textId))
+    }
+  }
+//  Button(action: action, label: {
+//    HStack(alignment: .top, spacing: 20) {
+//    Image(systemName: icon)
+//      .resizable()
+//      .scaledToFit()
+//      .frame(width: 30, height: 30)
+//    .padding(.leading, 4)
+//    .padding(.top, 6)
+//    VStack(alignment: .leading) {
+//    Group {
+//      Text(title).font(.headline)
+//      Text(text).foregroundColor(.primary)
+//    }
+//      .multilineTextAlignment(.leading)
+//  }
+//  }
+//  })
+//  .padding(.bottom)
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewMakeConnection() {
+  SimpleXTheme {
+    MakeConnectionLayout(
+      user = User.sampleData,
+      createLink = {},
+      pasteLink = {},
+      scanCode = {},
+      about = {}
+    )
+  }
+}

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

@@ -0,0 +1,47 @@
+package chat.simplex.app.views.onboarding
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material.MaterialTheme
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.views.CreateProfilePanel
+import chat.simplex.app.views.helpers.getKeyboardState
+import com.google.accompanist.insets.ProvideWindowInsets
+import kotlinx.coroutines.launch
+
+enum class OnboardingStage {
+  Step1_SimpleXInfo,
+  Step2_CreateProfile,
+  OnboardingComplete
+}
+
+@Composable
+fun CreateProfile(chatModel: ChatModel) {
+  val scope = rememberCoroutineScope()
+  val scrollState = rememberScrollState()
+  val keyboardState by getKeyboardState()
+  var savedKeyboardState by remember { mutableStateOf(keyboardState) }
+
+  ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
+    Box(
+      modifier = Modifier
+        .fillMaxSize()
+        .background(color = MaterialTheme.colors.background)
+        .padding(20.dp)
+    ) {
+      CreateProfilePanel(chatModel)
+      if (savedKeyboardState != keyboardState) {
+        LaunchedEffect(keyboardState) {
+          scope.launch {
+            savedKeyboardState = keyboardState
+            scrollState.animateScrollTo(scrollState.maxValue)
+          }
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,144 @@
+package chat.simplex.app.views.onboarding
+
+import android.content.res.Configuration
+import androidx.annotation.StringRes
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.ArrowForwardIos
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.model.User
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.ModalManager
+
+@Composable
+fun SimpleXInfo(chatModel: ChatModel, onboarding: Boolean = true) {
+  SimpleXInfoLayout(
+    user = chatModel.currentUser.value,
+    onboardingStage = if (onboarding) chatModel.onboardingStage else null,
+    showModal = { modalView -> { ModalManager.shared.showModal { modalView(chatModel) } } },
+  )
+}
+
+@Composable
+fun SimpleXInfoLayout(
+  user: User?,
+  onboardingStage: MutableState<OnboardingStage?>?,
+  showModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
+) {
+  Column(Modifier.fillMaxHeight(), horizontalAlignment = Alignment.Start) {
+    SimpleXLogo()
+
+    Text(stringResource(R.string.next_generation_of_private_messaging), style = MaterialTheme.typography.h2, modifier = Modifier.padding(bottom = 16.dp))
+
+    InfoRow("🎭", R.string.privacy_redefined, R.string.first_platform_without_user_ids)
+    InfoRow("📭", R.string.immune_to_spam_and_abuse, R.string.people_can_connect_only_via_links_you_share)
+    InfoRow("🤝", R.string.decentralized, R.string.opensource_protocol_and_code_anybody_can_run_servers)
+
+    Spacer(
+      Modifier
+        .fillMaxHeight()
+        .weight(1f))
+
+    if (onboardingStage != null) {
+      Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
+        OnboardingActionButton(user, onboardingStage)
+      }
+      Spacer(
+        Modifier
+          .fillMaxHeight()
+          .weight(1f))
+    }
+
+    Box(
+      Modifier
+        .fillMaxWidth()
+        .padding(bottom = 16.dp), contentAlignment = Alignment.Center) {
+      SimpleButton(text = stringResource(R.string.how_it_works), icon = Icons.Outlined.Info,
+        click = showModal { HowItWorks(user, onboardingStage) })
+    }
+  }
+}
+
+@Composable
+fun SimpleXLogo() {
+  Image(
+    painter = painterResource(if (isInDarkTheme()) R.drawable.logo_light else R.drawable.logo),
+    contentDescription = stringResource(R.string.image_descr_simplex_logo),
+    modifier = Modifier
+      .padding(vertical = 20.dp)
+      .fillMaxWidth(0.80f)
+  )
+}
+
+@Composable
+private fun InfoRow(emoji: String, @StringRes titleId: Int, @StringRes textId: Int) {
+  Row(Modifier.padding(bottom = 20.dp), verticalAlignment = Alignment.Top) {
+    Text(emoji, fontSize = 36.sp, modifier = Modifier
+      .width(60.dp)
+      .padding(end = 16.dp))
+    Column(horizontalAlignment = Alignment.Start) {
+      Text(stringResource(titleId), fontWeight = FontWeight.Bold, style = MaterialTheme.typography.h3, lineHeight = 24.sp)
+      Text(stringResource(textId), lineHeight = 24.sp, style = MaterialTheme.typography.caption)
+    }
+  }
+}
+
+
+@Composable
+fun OnboardingActionButton(user: User?, onboardingStage: MutableState<OnboardingStage?>, onclick: (() -> Unit)? = null) {
+  if (user == null) {
+    ActionButton(R.string.create_your_profile, onboarding = OnboardingStage.Step2_CreateProfile, onboardingStage, onclick)
+  } else {
+    ActionButton(R.string.make_private_connection, onboarding = OnboardingStage.OnboardingComplete, onboardingStage, onclick)
+  }
+}
+
+@Composable
+private fun ActionButton(
+  @StringRes labelId: Int,
+  onboarding: OnboardingStage?,
+  onboardingStage: MutableState<OnboardingStage?>,
+  onclick: (() -> Unit)?
+) {
+  SimpleButtonFrame(click = {
+    onclick?.invoke()
+    onboardingStage.value = onboarding
+  }) {
+    Text(stringResource(labelId), style = MaterialTheme.typography.h2, color = MaterialTheme.colors.primary)
+    Icon(
+      Icons.Outlined.ArrowForwardIos, "next stage", tint = MaterialTheme.colors.primary,
+      modifier = Modifier.padding(end = 8.dp)
+    )
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewSimpleXInfo() {
+  SimpleXTheme {
+    SimpleXInfoLayout(
+      user = null,
+      onboardingStage = null,
+      showModal = {{}}
+    )
+  }
+}

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

@@ -0,0 +1,432 @@
+package chat.simplex.app.views.usersettings
+
+import SectionCustomFooter
+import SectionDivider
+import SectionItemView
+import SectionSpacer
+import SectionView
+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.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 chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import java.text.DecimalFormat
+
+@Composable
+fun AdvancedNetworkSettingsView(chatModel: ChatModel) {
+  val currentCfg = remember { mutableStateOf(chatModel.controller.getNetCfg()) }
+  val currentCfgVal = currentCfg.value // used only on initialization
+  val networkTCPConnectTimeout = remember { mutableStateOf(currentCfgVal.tcpConnectTimeout) }
+  val networkTCPTimeout = remember { mutableStateOf(currentCfgVal.tcpTimeout) }
+  val networkSMPPingInterval = remember { mutableStateOf(currentCfgVal.smpPingInterval) }
+  val networkEnableKeepAlive = remember { mutableStateOf(currentCfgVal.enableKeepAlive) }
+  val networkTCPKeepIdle: MutableState<Int>
+  val networkTCPKeepIntvl: MutableState<Int>
+  val networkTCPKeepCnt: MutableState<Int>
+  if (currentCfgVal.tcpKeepAlive != null) {
+    networkTCPKeepIdle = remember { mutableStateOf(currentCfgVal.tcpKeepAlive.keepIdle) }
+    networkTCPKeepIntvl = remember { mutableStateOf(currentCfgVal.tcpKeepAlive.keepIntvl) }
+    networkTCPKeepCnt = remember { mutableStateOf(currentCfgVal.tcpKeepAlive.keepCnt) }
+  } else {
+    networkTCPKeepIdle = remember { mutableStateOf(KeepAliveOpts.defaults.keepIdle) }
+    networkTCPKeepIntvl = remember { mutableStateOf(KeepAliveOpts.defaults.keepIntvl) }
+    networkTCPKeepCnt = remember { mutableStateOf(KeepAliveOpts.defaults.keepCnt) }
+  }
+
+  fun buildCfg(): NetCfg {
+    val socksProxy = currentCfg.value.socksProxy
+    val tcpConnectTimeout = networkTCPConnectTimeout.value
+    val tcpTimeout = networkTCPTimeout.value
+    val smpPingInterval = networkSMPPingInterval.value
+    val enableKeepAlive = networkEnableKeepAlive.value
+    val tcpKeepAlive = if (enableKeepAlive) {
+      val keepIdle = networkTCPKeepIdle.value
+      val keepIntvl = networkTCPKeepIntvl.value
+      val keepCnt = networkTCPKeepCnt.value
+      KeepAliveOpts(keepIdle = keepIdle, keepIntvl = keepIntvl, keepCnt = keepCnt)
+    } else {
+      null
+    }
+    return NetCfg(
+      socksProxy = socksProxy,
+      tcpConnectTimeout = tcpConnectTimeout,
+      tcpTimeout = tcpTimeout,
+      tcpKeepAlive = tcpKeepAlive,
+      smpPingInterval = smpPingInterval
+    )
+  }
+
+  fun updateView(cfg: NetCfg) {
+    networkTCPConnectTimeout.value = cfg.tcpConnectTimeout
+    networkTCPTimeout.value = cfg.tcpTimeout
+    networkSMPPingInterval.value = cfg.smpPingInterval
+    networkEnableKeepAlive.value = cfg.enableKeepAlive
+    if (cfg.tcpKeepAlive != null) {
+      networkTCPKeepIdle.value = cfg.tcpKeepAlive.keepIdle
+      networkTCPKeepIntvl.value = cfg.tcpKeepAlive.keepIntvl
+      networkTCPKeepCnt.value = cfg.tcpKeepAlive.keepCnt
+    } else {
+      networkTCPKeepIdle.value = KeepAliveOpts.defaults.keepIdle
+      networkTCPKeepIntvl.value = KeepAliveOpts.defaults.keepIntvl
+      networkTCPKeepCnt.value = KeepAliveOpts.defaults.keepCnt
+    }
+  }
+
+  fun saveCfg(cfg: NetCfg) {
+    withApi {
+      chatModel.controller.apiSetNetworkConfig(cfg)
+      currentCfg.value = cfg
+      chatModel.controller.setNetCfg(cfg)
+    }
+  }
+
+  fun reset() {
+    val newCfg = if (currentCfg.value.useSocksProxy) NetCfg.proxyDefaults else NetCfg.defaults
+    updateView(newCfg)
+    saveCfg(newCfg)
+  }
+
+  fun updateSettingsDialog(action: () -> Unit) {
+    AlertManager.shared.showAlertMsg(
+      title = generalGetString(R.string.update_network_settings_question),
+      text = generalGetString(R.string.updating_settings_will_reconnect_client_to_all_servers),
+      confirmText = generalGetString(R.string.update_network_settings_confirmation),
+      onConfirm = action
+    )
+  }
+
+  AdvancedNetworkSettingsLayout(
+    networkTCPConnectTimeout,
+    networkTCPTimeout,
+    networkSMPPingInterval,
+    networkEnableKeepAlive,
+    networkTCPKeepIdle,
+    networkTCPKeepIntvl,
+    networkTCPKeepCnt,
+    resetDisabled = if (currentCfg.value.useSocksProxy) currentCfg.value == NetCfg.proxyDefaults else currentCfg.value == NetCfg.defaults,
+    reset = { updateSettingsDialog(::reset) },
+    footerDisabled = buildCfg() == currentCfg.value,
+    revert = { updateView(currentCfg.value) },
+    save = { updateSettingsDialog { saveCfg(buildCfg()) } }
+  )
+}
+
+@Composable fun AdvancedNetworkSettingsLayout(
+  networkTCPConnectTimeout: MutableState<Long>,
+  networkTCPTimeout: MutableState<Long>,
+  networkSMPPingInterval: MutableState<Long>,
+  networkEnableKeepAlive: MutableState<Boolean>,
+  networkTCPKeepIdle: MutableState<Int>,
+  networkTCPKeepIntvl: MutableState<Int>,
+  networkTCPKeepCnt: MutableState<Int>,
+  resetDisabled: Boolean,
+  reset: () -> Unit,
+  footerDisabled: Boolean,
+  revert: () -> Unit,
+  save: () -> Unit
+) {
+  val secondsLabel = stringResource(R.string.network_option_seconds_label)
+
+  Column(
+    Modifier
+      .fillMaxWidth()
+      .verticalScroll(rememberScrollState()),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    Text(
+      stringResource(R.string.network_settings_title),
+      Modifier.padding(start = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+    SectionSpacer()
+
+    SectionView {
+      SectionItemView {
+        ResetToDefaultsButton(reset, disabled = resetDisabled)
+      }
+      SectionDivider()
+      SectionItemView {
+        TimeoutSettingRow(
+          stringResource(R.string.network_option_tcp_connection_timeout), networkTCPConnectTimeout,
+          listOf(2_500000, 5_000000, 7_500000, 10_000000, 15_000000, 20_000000), secondsLabel
+        )
+      }
+      SectionDivider()
+      SectionItemView {
+        TimeoutSettingRow(
+          stringResource(R.string.network_option_protocol_timeout), networkTCPTimeout,
+          listOf(1_500000, 3_000000, 5_000000, 7_000000, 10_000000, 15_000000), secondsLabel
+        )
+      }
+      SectionDivider()
+      SectionItemView {
+        TimeoutSettingRow(
+          stringResource(R.string.network_option_ping_interval), networkSMPPingInterval,
+          listOf(120_000000, 300_000000, 600_000000, 1200_000000, 2400_000000), secondsLabel
+        )
+      }
+      SectionDivider()
+      SectionItemView {
+        EnableKeepAliveSwitch(networkEnableKeepAlive)
+      }
+      SectionDivider()
+      if (networkEnableKeepAlive.value) {
+        SectionItemView {
+          IntSettingRow("TCP_KEEPIDLE", networkTCPKeepIdle, listOf(15, 30, 60, 120, 180), secondsLabel)
+        }
+        SectionDivider()
+        SectionItemView {
+          IntSettingRow("TCP_KEEPINTVL", networkTCPKeepIntvl, listOf(5, 10, 15, 30, 60), secondsLabel)
+        }
+        SectionDivider()
+        SectionItemView {
+          IntSettingRow("TCP_KEEPCNT", networkTCPKeepCnt, listOf(1, 2, 4, 6, 8), "")
+        }
+      } else {
+        SectionItemView {
+          Text("TCP_KEEPIDLE", color = HighOrLowlight)
+        }
+        SectionDivider()
+        SectionItemView {
+          Text("TCP_KEEPINTVL", color = HighOrLowlight)
+        }
+        SectionDivider()
+        SectionItemView {
+          Text("TCP_KEEPCNT", color = HighOrLowlight)
+        }
+      }
+    }
+    SectionCustomFooter {
+      SettingsSectionFooter(revert, save, footerDisabled)
+    }
+    SectionSpacer()
+  }
+}
+
+@Composable
+fun ResetToDefaultsButton(reset: () -> Unit, disabled: Boolean) {
+  val modifier = if (disabled) Modifier else Modifier.clickable { reset() }
+  Row(
+    modifier.fillMaxSize(),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    val color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+    Text(stringResource(R.string.network_options_reset_to_defaults), color = color)
+  }
+}
+
+@Composable
+fun EnableKeepAliveSwitch(
+  networkEnableKeepAlive: MutableState<Boolean>
+) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    Text(stringResource(R.string.network_option_enable_tcp_keep_alive))
+    Switch(
+      checked = networkEnableKeepAlive.value,
+      onCheckedChange = { networkEnableKeepAlive.value = it },
+      colors = SwitchDefaults.colors(
+        checkedThumbColor = MaterialTheme.colors.primary,
+        uncheckedThumbColor = HighOrLowlight
+      ),
+    )
+  }
+}
+
+@Composable
+fun IntSettingRow(title: String, selection: MutableState<Int>, values: List<Int>, label: String) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    var expanded by remember { mutableStateOf(false) }
+
+    Text(title)
+
+    ExposedDropdownMenuBox(
+      expanded = expanded,
+      onExpandedChange = {
+        expanded = !expanded
+      }
+    ) {
+      Row(
+        Modifier.width(140.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.End
+      ) {
+        Text(
+          "${selection.value} $label",
+          maxLines = 1,
+          overflow = TextOverflow.Ellipsis,
+          color = HighOrLowlight
+        )
+        Spacer(Modifier.size(4.dp))
+        Icon(
+          if (!expanded) Icons.Outlined.ExpandMore else Icons.Outlined.ExpandLess,
+          generalGetString(R.string.invite_to_group_button),
+          modifier = Modifier.padding(start = 8.dp),
+          tint = HighOrLowlight
+        )
+      }
+      ExposedDropdownMenu(
+        expanded = expanded,
+        onDismissRequest = {
+          expanded = false
+        }
+      ) {
+        values.forEach { selectionOption ->
+          DropdownMenuItem(
+            onClick = {
+              selection.value = selectionOption
+              expanded = false
+            }
+          ) {
+            Text(
+              "$selectionOption $label",
+              maxLines = 1,
+              overflow = TextOverflow.Ellipsis,
+            )
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun TimeoutSettingRow(title: String, selection: MutableState<Long>, values: List<Long>, label: String) {
+  Row(
+    Modifier.fillMaxWidth(),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceBetween
+  ) {
+    var expanded by remember { mutableStateOf(false) }
+
+    Text(title)
+
+    ExposedDropdownMenuBox(
+      expanded = expanded,
+      onExpandedChange = {
+        expanded = !expanded
+      }
+    ) {
+      val df = DecimalFormat("#.#")
+
+      Row(
+        Modifier.width(140.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.End
+      ) {
+        Text(
+          "${df.format(selection.value / 1_000_000.toDouble())} $label",
+          maxLines = 1,
+          overflow = TextOverflow.Ellipsis,
+          color = HighOrLowlight
+        )
+        Spacer(Modifier.size(4.dp))
+        Icon(
+          if (!expanded) Icons.Outlined.ExpandMore else Icons.Outlined.ExpandLess,
+          generalGetString(R.string.invite_to_group_button),
+          modifier = Modifier.padding(start = 8.dp),
+          tint = HighOrLowlight
+        )
+      }
+      ExposedDropdownMenu(
+        expanded = expanded,
+        onDismissRequest = {
+          expanded = false
+        }
+      ) {
+        values.forEach { selectionOption ->
+          DropdownMenuItem(
+            onClick = {
+              selection.value = selectionOption
+              expanded = false
+            }
+          ) {
+            Text(
+              "${df.format(selectionOption / 1_000_000.toDouble())} $label",
+              maxLines = 1,
+              overflow = TextOverflow.Ellipsis,
+            )
+          }
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun SettingsSectionFooter(revert: () -> Unit, save: () -> Unit, disabled: Boolean) {
+  Row(
+    Modifier.fillMaxWidth(),
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    FooterButton(Icons.Outlined.Replay, stringResource(R.string.network_options_revert), revert, disabled)
+    FooterButton(Icons.Outlined.Check, stringResource(R.string.network_options_save), save, disabled)
+  }
+}
+
+@Composable
+fun FooterButton(icon: ImageVector, title: String, action: () -> Unit, disabled: Boolean) {
+  Surface(
+    shape = RoundedCornerShape(20.dp),
+    color = Color.Black.copy(alpha = 0f)
+  ) {
+    val modifier = if (disabled) Modifier else Modifier.clickable { action() }
+    Row(
+      modifier.padding(8.dp),
+      horizontalArrangement = Arrangement.spacedBy(8.dp)
+    ) {
+      Icon(
+        icon,
+        title,
+        tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+      )
+      Text(
+        title,
+        color = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
+      )
+    }
+  }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewAdvancedNetworkSettingsLayout() {
+  SimpleXTheme {
+    AdvancedNetworkSettingsLayout(
+      networkTCPConnectTimeout = remember { mutableStateOf(10_000000) },
+      networkTCPTimeout = remember { mutableStateOf(10_000000) },
+      networkSMPPingInterval = remember { mutableStateOf(10_000000) },
+      networkEnableKeepAlive = remember { mutableStateOf(true) },
+      networkTCPKeepIdle = remember { mutableStateOf(10) },
+      networkTCPKeepIntvl = remember { mutableStateOf(10) },
+      networkTCPKeepCnt = remember { mutableStateOf(10) },
+      resetDisabled = false,
+      reset = {},
+      footerDisabled = false,
+      revert = {},
+      save = {}
+    )
+  }
+}

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

@@ -0,0 +1,215 @@
+package chat.simplex.app.views.usersettings
+
+import SectionCustomFooter
+import SectionItemViewSpaceBetween
+import SectionSpacer
+import SectionView
+import android.content.ComponentName
+import android.content.pm.PackageManager
+import android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
+import android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.material.*
+import androidx.compose.material.MaterialTheme.colors
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Circle
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.graphics.*
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.core.graphics.drawable.toBitmap
+import chat.simplex.app.*
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+import chat.simplex.app.ui.theme.*
+import chat.simplex.app.views.helpers.*
+import com.godaddy.android.colorpicker.*
+
+enum class AppIcon(val resId: Int) {
+  DEFAULT(R.mipmap.icon),
+  DARK_BLUE(R.mipmap.icon_dark_blue),
+}
+
+@Composable
+fun AppearanceView(
+  showCustomModal: (@Composable (ChatModel, () -> Unit) -> Unit) -> (() -> Unit),
+) {
+  val appIcon = remember { mutableStateOf(findEnabledIcon()) }
+
+  fun setAppIcon(newIcon: AppIcon) {
+    if (appIcon.value == newIcon) return
+    val newComponent = ComponentName(BuildConfig.APPLICATION_ID, "chat.simplex.app.MainActivity_${newIcon.name.lowercase()}")
+    val oldComponent = ComponentName(BuildConfig.APPLICATION_ID, "chat.simplex.app.MainActivity_${appIcon.value.name.lowercase()}")
+    SimplexApp.context.packageManager.setComponentEnabledSetting(
+      newComponent,
+      COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP
+    )
+
+    SimplexApp.context.packageManager.setComponentEnabledSetting(
+      oldComponent,
+      PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP
+    )
+
+    appIcon.value = newIcon
+  }
+
+  AppearanceLayout(
+    appIcon,
+    changeIcon = ::setAppIcon,
+    showThemeSelector = showCustomModal { _, close ->
+      ModalView(
+        close = close, modifier = Modifier,
+        background = if (isInDarkTheme()) colors.background else SettingsBackgroundLight
+      ) { ThemeSelectorView() }
+    },
+    editPrimaryColor = { primary ->
+      showCustomModal { _, close ->
+        ModalView(
+          close = close, modifier = Modifier,
+          background = if (isInDarkTheme()) colors.background else SettingsBackgroundLight
+        ) { ColorEditor(primary, close) }
+      }()
+    },
+  )
+}
+
+@Composable fun AppearanceLayout(
+  icon: MutableState<AppIcon>,
+  changeIcon: (AppIcon) -> Unit,
+  showThemeSelector: () -> Unit,
+  editPrimaryColor: (Color) -> Unit,
+) {
+  Column(
+    Modifier.fillMaxWidth(),
+    horizontalAlignment = Alignment.Start,
+  ) {
+    Text(
+      stringResource(R.string.appearance_settings),
+      Modifier.padding(start = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+    SectionView(stringResource(R.string.settings_section_title_icon)) {
+      LazyRow {
+        items(AppIcon.values().size, { index -> AppIcon.values()[index] }) { index ->
+          val item = AppIcon.values()[index]
+          val mipmap = ContextCompat.getDrawable(LocalContext.current, item.resId)!!
+          Image(
+            bitmap = mipmap.toBitmap().asImageBitmap(),
+            contentDescription = "",
+            contentScale = ContentScale.Fit,
+            modifier = Modifier
+              .shadow(if (item == icon.value) 1.dp else 0.dp, ambientColor = colors.secondary)
+              .size(70.dp)
+              .clickable { changeIcon(item) }
+              .padding(10.dp)
+          )
+
+          if (index + 1 != AppIcon.values().size) {
+            Spacer(Modifier.padding(horizontal = 4.dp))
+          }
+        }
+      }
+    }
+
+    SectionSpacer()
+    val currentTheme by CurrentColors.collectAsState()
+    SectionView(stringResource(R.string.settings_section_title_themes)) {
+      Column(
+        Modifier.padding(horizontal = 8.dp)
+      ) {
+        SectionItemViewSpaceBetween(showThemeSelector, padding = PaddingValues()) {
+          Text(generalGetString(R.string.theme))
+        }
+        Spacer(Modifier.padding(horizontal = 4.dp))
+
+        SectionItemViewSpaceBetween({ editPrimaryColor(currentTheme.first.primary) }, padding = PaddingValues()) {
+          val title = generalGetString(R.string.color_primary)
+          Text(title)
+          Icon(Icons.Filled.Circle, title, tint = colors.primary)
+        }
+      }
+    }
+    if (currentTheme.first.primary != LightColorPalette.primary) {
+      SectionCustomFooter(PaddingValues(start = 7.dp, end = 7.dp, top = 5.dp)) {
+        TextButton(
+          onClick = {
+            ThemeManager.saveAndApplyPrimaryColor(LightColorPalette.primary)
+          },
+        ) {
+          Text(generalGetString(R.string.reset_color))
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun ColorEditor(
+  initialColor: Color,
+  close: () -> Unit,
+) {
+  Column(
+    Modifier
+      .fillMaxWidth()
+  ) {
+    var currentColor by remember { mutableStateOf(initialColor) }
+    ColorPicker(initialColor) {
+      currentColor = it
+    }
+
+    SectionSpacer()
+
+    TextButton(
+      onClick = {
+        ThemeManager.saveAndApplyPrimaryColor(currentColor)
+        close()
+      },
+      Modifier.align(Alignment.CenterHorizontally),
+      colors = ButtonDefaults.textButtonColors(contentColor = currentColor)
+    ) {
+      Text(generalGetString(R.string.save_color))
+    }
+  }
+}
+
+@Composable
+fun ColorPicker(initialColor: Color, onColorChanged: (Color) -> Unit) {
+  ClassicColorPicker(
+    color = initialColor,
+    modifier = Modifier
+      .fillMaxWidth()
+      .height(300.dp),
+    showAlphaBar = false,
+    onColorChanged = { color: HsvColor ->
+      onColorChanged(color.toColor())
+    }
+  )
+}
+
+private fun findEnabledIcon(): AppIcon = AppIcon.values().first { icon ->
+  SimplexApp.context.packageManager.getComponentEnabledSetting(
+    ComponentName(BuildConfig.APPLICATION_ID, "chat.simplex.app.MainActivity_${icon.name.lowercase()}")
+  ).let { it == COMPONENT_ENABLED_STATE_DEFAULT || it == COMPONENT_ENABLED_STATE_ENABLED }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewAppearanceSettings() {
+  SimpleXTheme {
+    AppearanceLayout(
+      icon = remember { mutableStateOf(AppIcon.DARK_BLUE) },
+      changeIcon = {},
+      showThemeSelector = {},
+      editPrimaryColor = {},
+    )
+  }
+}

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

@@ -0,0 +1,133 @@
+package chat.simplex.app.views.usersettings
+
+import SectionDivider
+import SectionItemView
+import SectionView
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.*
+import chat.simplex.app.ui.theme.HighOrLowlight
+
+@Composable
+fun CallSettingsView(m: ChatModel) {
+  CallSettingsLayout(
+    webrtcPolicyRelay = m.controller.appPrefs.webrtcPolicyRelay,
+    callOnLockScreen = m.controller.appPrefs.callOnLockScreen
+  )
+}
+
+@Composable
+fun CallSettingsLayout(
+  webrtcPolicyRelay: Preference<Boolean>,
+  callOnLockScreen: Preference<CallOnLockScreen>,
+) {
+  Column(
+    Modifier.fillMaxWidth(),
+    horizontalAlignment = Alignment.Start,
+    verticalArrangement = Arrangement.spacedBy(8.dp)
+  ) {
+    val lockCallState = remember { mutableStateOf(callOnLockScreen.get()) }
+    Text(
+      stringResource(R.string.your_calls),
+      Modifier.padding(start = 16.dp, bottom = 24.dp),
+      style = MaterialTheme.typography.h1
+    )
+    SectionView(stringResource(R.string.settings_section_title_settings)) {
+      SectionItemView() {
+        SharedPreferenceToggle(stringResource(R.string.connect_calls_via_relay), webrtcPolicyRelay)
+      }
+      SectionDivider()
+
+      Column(Modifier.padding(start = 10.dp, top = 12.dp)) {
+        Text(stringResource(R.string.call_on_lock_screen))
+        Row {
+          SharedPreferenceRadioButton(stringResource(R.string.no_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.DISABLE)
+          Spacer(Modifier.fillMaxWidth().weight(1f))
+          SharedPreferenceRadioButton(stringResource(R.string.show_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.SHOW)
+          Spacer(Modifier.fillMaxWidth().weight(1f))
+          SharedPreferenceRadioButton(stringResource(R.string.accept_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.ACCEPT)
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun SharedPreferenceToggle(
+  text: String,
+  preference: Preference<Boolean>,
+  preferenceState: MutableState<Boolean>? = null
+) {
+  val prefState = preferenceState ?: remember { mutableStateOf(preference.get()) }
+  Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+    Text(text, Modifier.padding(end = 24.dp))
+    Spacer(Modifier.fillMaxWidth().weight(1f))
+    Switch(
+      checked = prefState.value,
+      onCheckedChange = {
+        preference.set(it)
+        prefState.value = it
+      },
+      colors = SwitchDefaults.colors(
+        checkedThumbColor = MaterialTheme.colors.primary,
+        uncheckedThumbColor = HighOrLowlight
+      )
+    )
+  }
+}
+
+@Composable
+fun SharedPreferenceToggleWithIcon(
+  text: String,
+  icon: ImageVector,
+  stopped: Boolean = false,
+  onClickInfo: () -> Unit,
+  preference: Preference<Boolean>,
+  preferenceState: MutableState<Boolean>? = null
+) {
+  val prefState = preferenceState ?: remember { mutableStateOf(preference.get()) }
+  Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
+    Text(text, Modifier.padding(end = 4.dp))
+    Icon(
+      icon,
+      null,
+      Modifier.clickable(onClick = onClickInfo),
+      tint = MaterialTheme.colors.primary
+    )
+    Spacer(Modifier.fillMaxWidth().weight(1f))
+    Switch(
+      checked = prefState.value,
+      onCheckedChange = {
+        preference.set(it)
+        prefState.value = it
+      },
+      colors = SwitchDefaults.colors(
+        checkedThumbColor = MaterialTheme.colors.primary,
+        uncheckedThumbColor = HighOrLowlight
+      ),
+      enabled = !stopped
+    )
+  }
+}
+
+@Composable
+fun <T>SharedPreferenceRadioButton(text: String, prefState: MutableState<T>, preference: Preference<T>, value: T) {
+  Row(verticalAlignment = Alignment.CenterVertically) {
+    Text(text)
+    val colors = RadioButtonDefaults.colors(selectedColor = MaterialTheme.colors.primary)
+    RadioButton(selected = prefState.value == value, colors = colors, onClick = {
+      preference.set(value)
+      prefState.value = value
+    })
+  }
+}

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

@@ -0,0 +1,33 @@
+package chat.simplex.app.views.usersettings
+
+import SectionView
+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.Videocam
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
+import chat.simplex.app.model.ChatModel
+
+@Composable
+fun ExperimentalFeaturesView(chatModel: ChatModel, enableCalls: MutableState<Boolean>) {
+  Column(
+    Modifier.fillMaxWidth(),
+    horizontalAlignment = Alignment.Start
+  ) {
+    Text(
+      stringResource(R.string.settings_experimental_features),
+      style = MaterialTheme.typography.h1,
+      modifier = Modifier.padding(start = 16.dp, bottom = 24.dp)
+    )
+    SectionView("") {
+      SettingsPreferenceItem(Icons.Outlined.Videocam, stringResource(R.string.settings_audio_video_calls), chatModel.controller.appPrefs.experimentalCalls, enableCalls)
+    }
+  }
+}

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

@@ -3,16 +3,20 @@ package chat.simplex.app.views.usersettings
 import android.content.res.Configuration
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.MaterialTheme
 import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.chat.ChatHelpView
+import chat.simplex.app.views.chatlist.ChatHelpView
 
 @Composable
 fun HelpView(chatModel: ChatModel) {
@@ -24,9 +28,14 @@ fun HelpView(chatModel: ChatModel) {
 
 @Composable
 fun HelpLayout(displayName: String) {
-  Column(horizontalAlignment = Alignment.Start) {
+  Column(
+    Modifier
+      .verticalScroll(rememberScrollState())
+      .padding(bottom = 16.dp),
+    horizontalAlignment = Alignment.Start
+  ){
     Text(
-      "Welcome $displayName!",
+      String.format(stringResource(R.string.personal_welcome), displayName),
       Modifier.padding(bottom = 24.dp),
       style = MaterialTheme.typography.h1,
     )