terminal: version 2.0.0 (#634)

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

.github/CODEOWNERS

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

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)
@@ -12,285 +12,129 @@
 &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="iOS TestFlight" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/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.
+## Why privacy of communications matter
 
-### :zap: Quick installation of a terminal app
+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 unique approach to privacy and security
+
+### Full 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).
+
+## For developers
+
+We plan that the SimpleX platform will grow into the platform supporting any distributed Internet application. This will allow you to build any service that people can access via chat, with custom web-based UI widgets that anybody with basic HTML/CSS/JavaScript knowledge can create in a few hours.
+
+You already can:
+
+- use SimpleX Chat library to integrate chat functionality into your apps.
+- use SimpleX Chat bot templates in Haskell to build your own chat bot services (TypeScript SDK is coming soon).
+
+If you are considering developing with SimpleX platform please get in touch for any advice and support.
+
+## News and updates
+
+[Apr 04, 2022. Instant notifications for SimpleX Chat mobile apps](./blog/20220404-simplex-chat-instant-notifications.md). We would really appreciate any feedback on the design we are implementing.
+
+[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.md)
+
+[Feb 14, 2022. SimpleX Chat: join our public beta for iOS](./blog/20220214-simplex-chat-ios-public-beta.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
-
-SimpleX is a client-server network that uses redundant, disposable nodes to asynchronously pass messages via message queues, providing receiver and sender anonymity.
-
-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).
-
-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.
-
-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.
-
-## Terminal chat features
-
-- 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.
-
-Public keys involved in key exchange are not used as identity, they are randomly generated for each contact.
-
-See [Encryption Primitives Used](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md#encryption-primitives-used) for technical details.
-
-<a name="🚀-installation"></a>
-
-## 🚀 Installation
-
-### Download chat client
-
-#### 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;
-```
+See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information on platform objectives and technical design.
 
 ## 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.
+- 🏗 End-to-end encrypted audio and video calls via the mobile apps.
+- 🏗 Automatic chat history deletion.
+- 🏗 Privacy preserving instant notifications for iOS using Apple Push Notification service (in progress).
+- 🏗 Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (in progress).
+- Groups support for mobile apps.
+- Chat database portability and encryption.
+- 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.
+- Media server to optimize sending large files to groups.
+- Channels server for large groups and broadcast channels.
+
+## 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
 

apps/android/app/build.gradle

@@ -11,8 +11,8 @@ android {
         applicationId "chat.simplex.app"
         minSdk 29
         targetSdk 32
-        versionCode 11
-        versionName "1.2"
+        versionCode 30
+        versionName "2.0"
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         ndk {
@@ -41,11 +41,13 @@ android {
     kotlinOptions {
         jvmTarget = '1.8'
         freeCompilerArgs += "-opt-in=kotlinx.coroutines.DelicateCoroutinesApi"
+        freeCompilerArgs += "-opt-in=androidx.compose.foundation.ExperimentalFoundationApi"
         freeCompilerArgs += "-opt-in=androidx.compose.ui.text.ExperimentalTextApi"
         freeCompilerArgs += "-opt-in=androidx.compose.material.ExperimentalMaterialApi"
         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 {
@@ -79,6 +81,7 @@ dependencies {
     implementation "androidx.compose.material:material-icons-extended:$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'
 
     def work_version = "2.7.1"
     implementation "androidx.work:work-runtime-ktx:$work_version"
@@ -89,12 +92,17 @@ 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'
+
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.3'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'

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

@@ -1,38 +1,97 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-  package="chat.simplex.app">
+    package="chat.simplex.app">
 
   <uses-feature android:name="android.hardware.camera" />
+
   <uses-permission android:name="android.permission.CAMERA" />
+  <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" />
 
   <application
-    android:name="SimplexApp"
-    android:allowBackup="true"
-    android:icon="@mipmap/icon"
-    android:label="@string/app_name"
-    android:supportsRtl="true"
-    android:theme="@style/Theme.SimpleX">
-    <activity
-      android:name=".MainActivity"
-      android:exported="true"
+      android:name="SimplexApp"
+      android:allowBackup="true"
+      android:icon="@mipmap/icon"
       android:label="@string/app_name"
-      android:windowSoftInputMode="adjustResize"
+      android:supportsRtl="true"
       android:theme="@style/Theme.SimpleX">
+
+    <!-- Main activity -->
+    <activity
+        android:name=".MainActivity"
+        android:launchMode="singleTask"
+        android:exported="true"
+        android:label="@string/app_name"
+        android:windowSoftInputMode="adjustResize"
+        android:theme="@style/Theme.SimpleX">
       <intent-filter>
         <action android:name="android.intent.action.MAIN" />
         <category android:name="android.intent.category.LAUNCHER" />
       </intent-filter>
 
+      <!-- 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>
-    </activity>
-  </application>
+      <intent-filter android:autoVerify="true">
+        <action android:name="android.intent.action.VIEW" />
 
-</manifest>
+        <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>
+
+    <provider
+        android:name="androidx.core.content.FileProvider"
+        android:authorities="chat.simplex.app.provider"
+        android:exported="false"
+        android:grantUriPermissions="true">
+      <meta-data
+          android:name="android.support.FILE_PROVIDER_PATHS"
+          android:resource="@xml/file_paths" />
+    </provider>
+
+    <!-- SimplexService foreground service -->
+    <service
+        android:name=".SimplexService"
+        android:enabled="true"
+        android:exported="false"
+        android:stopWithTask="false"></service>
+
+    <!-- SimplexService restart on reboot -->
+    <receiver
+        android:name=".SimplexService$StartReceiver"
+        android:enabled="true"
+        android:exported="true">
+      <intent-filter>
+        <action android:name="android.intent.action.BOOT_COMPLETED" />
+      </intent-filter>
+    </receiver>
+
+    <!-- SimplexService restart on destruction -->
+    <receiver
+        android:name=".SimplexService$AutoRestartReceiver"
+        android:enabled="true"
+        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,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link href="./style.css" rel="stylesheet" />
+  </head>
+  <body>
+    <video id="remote-video-stream" autoplay playsinline></video>
+    <video id="local-video-stream" muted autoplay playsinline></video>
+  </body>
+  <footer>
+    <script src="./call.js"></script>
+  </footer>
+</html>

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

@@ -0,0 +1,469 @@
+"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 = {}));
+const keyAlgorithm = {
+    name: "AES-GCM",
+    length: 256,
+};
+const keyUsages = ["encrypt", "decrypt"];
+let activeCall;
+const IV_LENGTH = 12;
+const initialPlainTextRequired = {
+    key: 10,
+    delta: 3,
+    undefined: 1,
+};
+function defaultCallConfig(encodedInsertableStreams) {
+    return {
+        peerConnectionConfig: {
+            iceServers: [{ urls: ["stun:stun.l.google.com:19302"] }],
+            iceCandidatePoolSize: 10,
+            encodedInsertableStreams,
+        },
+        iceCandidates: {
+            delay: 2000,
+            extrasInterval: 2000,
+            extrasTimeout: 8000,
+        },
+    };
+}
+async function initializeCall(config, mediaType, aesKey) {
+    const conn = new RTCPeerConnection(config.peerConnectionConfig);
+    const remoteStream = new MediaStream();
+    const localStream = await navigator.mediaDevices.getUserMedia(callMediaConstraints(mediaType));
+    await setUpMediaStreams(conn, localStream, remoteStream, aesKey);
+    conn.addEventListener("connectionstatechange", connectionStateChange);
+    const iceCandidates = 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 = candidates.map((c) => JSON.stringify(c));
+            candidates = [];
+            resolve(iceCandidates);
+        }
+        function sendIceCandidates() {
+            if (candidates.length === 0)
+                return;
+            const iceCandidates = candidates.map((c) => JSON.stringify(c));
+            candidates = [];
+            sendMessageToNative({ resp: { type: "ice", iceCandidates } });
+        }
+    });
+    return { connection: conn, iceCandidates, localMedia: mediaType, localStream };
+    function connectionStateChange() {
+        sendMessageToNative({
+            resp: {
+                type: "connection",
+                state: {
+                    connectionState: conn.connectionState,
+                    iceConnectionState: conn.iceConnectionState,
+                    iceGatheringState: conn.iceGatheringState,
+                    signalingState: conn.signalingState,
+                },
+            },
+        });
+        if (conn.connectionState == "disconnected" || conn.connectionState == "failed") {
+            conn.removeEventListener("connectionstatechange", connectionStateChange);
+            sendMessageToNative({ resp: { type: "ended" } });
+            conn.close();
+            activeCall = undefined;
+            resetVideoElements();
+        }
+    }
+}
+var sendMessageToNative = (msg) => console.log(JSON.stringify(msg));
+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":
+                const encryption = supportsInsertableStreams();
+                resp = { type: "capabilities", capabilities: { encryption } };
+                break;
+            case "start":
+                console.log("starting call");
+                if (activeCall) {
+                    resp = { type: "error", message: "start: call already started" };
+                }
+                else if (!supportsInsertableStreams() && command.aesKey) {
+                    resp = { type: "error", message: "start: encryption is not supported" };
+                }
+                else {
+                    const encryption = supportsInsertableStreams();
+                    const { media, aesKey } = command;
+                    activeCall = await initializeCall(defaultCallConfig(encryption && !!aesKey), media, encryption ? aesKey : undefined);
+                    const pc = activeCall.connection;
+                    const offer = await pc.createOffer();
+                    await pc.setLocalDescription(offer);
+                    // for debugging, returning the command for callee to use
+                    // resp = {type: "accept", offer: JSON.stringify(offer), iceCandidates: await iceCandidates, media, aesKey}
+                    resp = {
+                        type: "offer",
+                        offer: JSON.stringify(offer),
+                        iceCandidates: await activeCall.iceCandidates,
+                        capabilities: { encryption },
+                    };
+                }
+                break;
+            case "accept":
+                if (activeCall) {
+                    resp = { type: "error", message: "accept: call already started" };
+                }
+                else if (!supportsInsertableStreams() && command.aesKey) {
+                    resp = { type: "error", message: "accept: encryption is not supported" };
+                }
+                else {
+                    const offer = JSON.parse(command.offer);
+                    const remoteIceCandidates = command.iceCandidates.map((c) => JSON.parse(c));
+                    activeCall = await initializeCall(defaultCallConfig(!!command.aesKey), command.media, command.aesKey);
+                    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: JSON.stringify(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 = JSON.parse(command.answer);
+                    const remoteIceCandidates = command.iceCandidates.map((c) => JSON.parse(c));
+                    await pc.setRemoteDescription(new RTCSessionDescription(answer));
+                    addIceCandidates(pc, remoteIceCandidates);
+                    resp = { type: "ok" };
+                }
+                break;
+            case "ice":
+                if (pc) {
+                    const remoteIceCandidates = command.iceCandidates.map((c) => JSON.parse(c));
+                    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 "end":
+                if (pc) {
+                    pc.close();
+                    activeCall = undefined;
+                    resetVideoElements();
+                    resp = { type: "ok" };
+                }
+                else {
+                    resp = { type: "error", message: "end: call not started" };
+                }
+                break;
+            default:
+                resp = { type: "error", message: "unknown command" };
+                break;
+        }
+    }
+    catch (e) {
+        resp = { type: "error", message: e.message };
+    }
+    const apiResp = { corrId, resp, command };
+    sendMessageToNative(apiResp);
+    return apiResp;
+}
+function addIceCandidates(conn, iceCandidates) {
+    for (const c of iceCandidates) {
+        conn.addIceCandidate(new RTCIceCandidate(c));
+    }
+}
+async function setUpMediaStreams(pc, localStream, remoteStream, aesKey) {
+    var _a;
+    const videos = getVideoElements();
+    if (!videos)
+        throw Error("no video elements");
+    let key;
+    if (aesKey) {
+        const keyData = decodeBase64(encodeAscii(aesKey));
+        if (keyData)
+            key = await crypto.subtle.importKey("raw", keyData, keyAlgorithm, false, keyUsages);
+    }
+    for (const track of localStream.getTracks()) {
+        pc.addTrack(track, localStream);
+    }
+    if (key) {
+        console.log("set up encryption for sending");
+        for (const sender of pc.getSenders()) {
+            setupPeerTransform(sender, encodeFunction(key));
+        }
+    }
+    // Pull tracks from remote stream as they arrive add them to remoteStream video
+    pc.ontrack = (event) => {
+        if (key) {
+            console.log("set up decryption for receiving");
+            setupPeerTransform(event.receiver, decodeFunction(key));
+        }
+        for (const track of event.streams[0].getTracks()) {
+            remoteStream.addTrack(track);
+        }
+    };
+    // 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
+    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 pc.getTransceivers()) {
+            if (((_a = t.sender.track) === null || _a === void 0 ? void 0 : _a.kind) === "video") {
+                t.setCodecPreferences(codecs);
+            }
+        }
+    }
+    // setupVideoElement(videos.local)
+    // setupVideoElement(videos.remote)
+    videos.local.srcObject = localStream;
+    videos.remote.srcObject = remoteStream;
+}
+function callMediaConstraints(mediaType) {
+    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,
+                },
+            };
+    }
+}
+function supportsInsertableStreams() {
+    return "createEncodedStreams" in RTCRtpSender.prototype && "createEncodedStreams" in RTCRtpReceiver.prototype;
+}
+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;
+}
+/* Stream Transforms */
+function setupPeerTransform(peer, transform) {
+    const streams = peer.createEncodedStreams();
+    streams.readable.pipeThrough(new TransformStream({ transform })).pipeTo(streams.writable);
+}
+/* Cryptography */
+function encodeFunction(key) {
+    return async (frame, controller) => {
+        const data = new Uint8Array(frame.data);
+        const n = frame instanceof RTCEncodedVideoFrame ? initialPlainTextRequired[frame.type] : 0;
+        const iv = randomIV();
+        const initial = data.subarray(0, n);
+        const plaintext = data.subarray(n, data.byteLength);
+        try {
+            const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, key, plaintext);
+            frame.data = concatN(initial, new Uint8Array(ciphertext), iv).buffer;
+            controller.enqueue(frame);
+        }
+        catch (e) {
+            console.log(`encryption error ${e}`);
+            throw e;
+        }
+    };
+}
+function decodeFunction(key) {
+    return async (frame, controller) => {
+        const data = new Uint8Array(frame.data);
+        const n = frame instanceof RTCEncodedVideoFrame ? initialPlainTextRequired[frame.type] : 0;
+        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 = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+            frame.data = concatN(initial, new Uint8Array(plaintext)).buffer;
+            controller.enqueue(frame);
+        }
+        catch (e) {
+            console.log(`decryption error ${e}`);
+            throw e;
+        }
+    };
+}
+class RTCEncodedVideoFrame {
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+}
+function randomIV() {
+    return crypto.getRandomValues(new Uint8Array(IV_LENGTH));
+}
+const char_equal = "=".charCodeAt(0);
+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 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;
+}
+const base64chars = new Uint8Array("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").map((c) => c.charCodeAt(0)));
+const base64lookup = new Array(256);
+base64chars.forEach((c, i) => (base64lookup[c] = i));
+function encodeBase64(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++] = base64chars[a[i] >> 2];
+        b64[j++] = base64chars[((a[i] & 3) << 4) | (a[i + 1] >> 4)];
+        b64[j++] = base64chars[((a[i + 1] & 15) << 2) | (a[i + 2] >> 6)];
+        b64[j++] = base64chars[a[i + 2] & 63];
+    }
+    if (len % 3)
+        b64[b64len - 1] = char_equal;
+    if (len % 3 === 1)
+        b64[b64len - 2] = char_equal;
+    return b64;
+}
+function decodeBase64(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 = base64lookup[b64[i++]];
+        const enc2 = i < len ? base64lookup[b64[i++]] : 0;
+        const enc3 = i < len ? base64lookup[b64[i++]] : 0;
+        const enc4 = i < len ? base64lookup[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;
+}
+//# sourceMappingURL=call.js.map

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

@@ -0,0 +1,26 @@
+video::-webkit-media-controls {
+  display: none;
+}
+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;
+  bottom: 0;
+  right: 0;
+}

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

@@ -9,35 +9,36 @@ 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.ui.Modifier
+import androidx.compose.ui.unit.dp
 import androidx.lifecycle.AndroidViewModel
+import androidx.work.*
 import chat.simplex.app.model.ChatModel
 import chat.simplex.app.model.NtfManager
 import chat.simplex.app.ui.theme.SimpleXTheme
 import chat.simplex.app.views.SplashView
-import chat.simplex.app.views.WelcomeView
 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 java.util.concurrent.TimeUnit
 
 //import kotlinx.serialization.decodeFromString
 
 class MainActivity: ComponentActivity() {
   private val vm by viewModels<SimplexViewModel>()
+  private val chatController by lazy { (application as SimplexApp).chatController }
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
 //    testJson()
-    processIntent(intent, vm.chatModel)
-//    vm.app.initiateBackgroundWork()
     setContent {
       SimpleXTheme {
         Surface(
@@ -49,6 +50,30 @@ class MainActivity: ComponentActivity() {
         }
       }
     }
+    schedulePeriodicServiceRestartWorker()
+  }
+
+  override fun onNewIntent(intent: Intent?) {
+    super.onNewIntent(intent)
+    processIntent(intent, vm.chatModel)
+  }
+
+  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
+    }
+    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)
   }
 }
 
@@ -60,12 +85,18 @@ class SimplexViewModel(application: Application): AndroidViewModel(application)
 @Composable
 fun MainPage(chatModel: ChatModel) {
   Box {
-    when (chatModel.userCreated.value) {
-      null -> SplashView()
-      false -> WelcomeView(chatModel)
-      true ->
+    val onboarding = chatModel.onboardingStage.value
+    val userCreated = chatModel.userCreated.value
+    when {
+      onboarding == null || userCreated == null -> SplashView()
+      onboarding == OnboardingStage.OnboardingComplete && userCreated ->
         if (chatModel.chatId.value == null) ChatListView(chatModel)
         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()
     AlertManager.shared.showInView()
@@ -79,9 +110,14 @@ fun processIntent(intent: Intent?, chatModel: ChatModel) {
       Log.d(TAG, "processIntent: OpenChatAction $chatId")
       if (chatId != null) {
         val cInfo = chatModel.getChat(chatId)?.chatInfo
+        chatModel.clearOverlays.value = true
         if (cInfo != null) withApi { openChat(chatModel, cInfo) }
       }
     }
+    NtfManager.ShowChatsAction -> {
+      Log.d(TAG, "processIntent: ShowChatsAction")
+      chatModel.clearOverlays.value = true
+    }
     "android.intent.action.VIEW" -> {
       val uri = intent.data
       if (uri != null) connectIfOpenedViaUri(uri, chatModel)
@@ -96,10 +132,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")
@@ -112,9 +156,8 @@ fun connectIfOpenedViaUri(uri: Uri, chatModel: ChatModel) {
 }
 
 //fun testJson() {
-//  val str = """
-//    {}
+//  val str: String = """
 //  """.trimIndent()
 //
-//  println(json.decodeFromString<ChatItem>(str))
+//  println(json.decodeFromString<APIResponse>(str))
 //}

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

@@ -3,8 +3,11 @@ package chat.simplex.app
 import android.app.Application
 import android.net.LocalServerSocket
 import android.util.Log
+import androidx.lifecycle.*
 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 java.io.BufferedReader
 import java.io.InputStreamReader
 import java.util.*
@@ -24,37 +27,53 @@ external fun chatInit(path: String): ChatCtrl
 external fun chatSendCmd(ctrl: ChatCtrl, msg: String) : String
 external fun chatRecvMsg(ctrl: ChatCtrl) : String
 
-//class SimplexApp: Application(), LifecycleEventObserver {
-class SimplexApp: Application() {
-  private lateinit var controller: ChatController
-  lateinit var chatModel: ChatModel
-  private lateinit var ntfManager: NtfManager
+class SimplexApp: Application(), LifecycleEventObserver {
+  val chatController: ChatController by lazy {
+    val ctrl = chatInit(getFilesDirectory(applicationContext))
+    ChatController(ctrl, ntfManager, applicationContext)
+  }
+
+  val chatModel: ChatModel by lazy {
+    chatController.chatModel
+  }
+
+  private val ntfManager: NtfManager by lazy {
+    NtfManager(applicationContext)
+  }
 
   override fun onCreate() {
     super.onCreate()
-//    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
-    ntfManager = NtfManager(applicationContext)
-    val ctrl = chatInit(applicationContext.filesDir.toString())
-    controller = ChatController(ctrl, ntfManager, applicationContext)
-    chatModel = controller.chatModel
+    context = this
+    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
     withApi {
-      val user = controller.apiGetActiveUser()
-      if (user != null) controller.startChat(user)
+      val user = chatController.apiGetActiveUser()
+      if (user == null) {
+        chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+      } else {
+        chatController.startChat(user)
+        SimplexService.start(applicationContext)
+        chatController.showBackgroundServiceNotice()
+      }
     }
   }
 
-//  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
-//    Log.d(TAG, "onStateChanged: $event")
-//    if (event == Lifecycle.Event.ON_STOP) {
-//      Log.e(TAG, "BGManager schedule ${Clock.System.now()}")
-//      BGManager.schedule(applicationContext)
-//    }
-//  }
+  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
+    Log.d(TAG, "onStateChanged: $event")
+    withApi {
+      when (event) {
+        Lifecycle.Event.ON_STOP ->
+          if (!chatController.getRunServiceInBackground()) SimplexService.stop(applicationContext)
+        Lifecycle.Event.ON_START ->
+          SimplexService.start(applicationContext)
+      }
+    }
+  }
 
   companion object {
+    lateinit var context: SimplexApp private set
+
     init {
       val socketName = "local.socket.address.listen.native.cmd2"
-
       val s = Semaphore(0)
       thread(name="stdout/stderr pipe") {
         Log.d(TAG, "starting server")
@@ -69,7 +88,7 @@ class SimplexApp: Application() {
           val inStreamReader = InputStreamReader(inStream)
           val input = BufferedReader(inStreamReader)
 
-          while(true) {
+          while (true) {
             val line = input.readLine() ?: break
             Log.w("$TAG (stdout/stderr)", line)
             logbuffer.add(line)

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

@@ -0,0 +1,245 @@
+package chat.simplex.app
+
+import android.app.*
+import android.content.*
+import android.os.*
+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
+
+// based on:
+// https://robertohuertas.com/2019/06/29/android_foreground_services/
+// https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/java/io/heckel/ntfy/service/SubscriberService.kt
+
+class SimplexService: Service() {
+  private var wakeLock: PowerManager.WakeLock? = null
+  private var isServiceStarted = false
+  private var isStartingService = false
+  private var notificationManager: NotificationManager? = null
+  private var serviceNotification: Notification? = null
+  private val chatController by lazy { (application as SimplexApp).chatController }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    Log.d(TAG, "onStartCommand startId: $startId")
+    if (intent != null) {
+      val action = intent.action
+      Log.d(TAG, "intent action $action")
+      when (action) {
+        Action.START.name -> startService()
+        Action.STOP.name -> stopService()
+        else -> Log.e(TAG, "No action in the intent")
+      }
+    } else {
+      Log.d(TAG, "null intent. Probably restarted by the system.")
+    }
+    return START_STICKY // to restart if killed
+  }
+
+  override fun onCreate() {
+    super.onCreate()
+    Log.d(TAG, "Simplex service created")
+    val title = getString(R.string.simplex_service_notification_title)
+    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!
+    super.onDestroy()
+  }
+
+  private fun startService() {
+    Log.d(TAG, "SimplexService startService")
+    if (isServiceStarted || isStartingService) return
+    val self = this
+    isStartingService = true
+    withApi {
+      try {
+        val user = chatController.apiGetActiveUser()
+        if (user == null) {
+          chatController.chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
+        } else {
+          Log.w(TAG, "Starting foreground service")
+          chatController.startChat(user)
+          chatController.startReceiver()
+          isServiceStarted = true
+          saveServiceState(self, ServiceState.STARTED)
+          wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
+            newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
+              acquire()
+            }
+          }
+        }
+      } finally {
+        isStartingService = false
+      }
+    }
+  }
+
+  private fun stopService() {
+    Log.d(TAG, "Stopping foreground service")
+    try {
+      wakeLock?.let {
+        while (it.isHeld) it.release() // release all, in case acquired more than once
+      }
+      wakeLock = null
+      stopForeground(true)
+      stopSelf()
+    } catch (e: Exception) {
+      Log.d(TAG, "Service stopped without being started: ${e.message}")
+    }
+
+    isServiceStarted = false
+    saveServiceState(this, ServiceState.STOPPED)
+  }
+
+  private fun createNotificationChannel(): NotificationManager? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+      val channel = NotificationChannel(NOTIFICATION_CHANNEL_ID, NOTIFICATION_CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW).let {
+        it.setShowBadge(false) // no long-press badge
+        it
+      }
+      notificationManager.createNotificationChannel(channel)
+      return notificationManager
+    }
+    return null
+  }
+
+  private fun createNotification(title: String, text: String): Notification {
+    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)
+      .setColor(0x88FFFF)
+      .setContentTitle(title)
+      .setContentText(text)
+      .setContentIntent(pendingIntent)
+      .setSound(null)
+      .setShowWhen(false) // no date/time
+      .build()
+  }
+
+  override fun onBind(intent: Intent): IBinder? {
+    return null // no binding
+  }
+
+  // re-schedules the task when "Clear recent apps" is pressed
+  override fun onTaskRemoved(rootIntent: Intent) {
+    val restartServiceIntent = Intent(applicationContext, SimplexService::class.java).also {
+      it.setPackage(packageName)
+    };
+    val restartServicePendingIntent: PendingIntent = PendingIntent.getService(this, 1, restartServiceIntent, PendingIntent.FLAG_ONE_SHOT or PendingIntent.FLAG_IMMUTABLE);
+    applicationContext.getSystemService(Context.ALARM_SERVICE);
+    val alarmService: AlarmManager = applicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager;
+    alarmService.set(AlarmManager.ELAPSED_REALTIME, SystemClock.elapsedRealtime() + 1000, restartServicePendingIntent);
+  }
+
+  // restart on reboot
+  class StartReceiver: BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      Log.d(TAG, "StartReceiver: onReceive called")
+      scheduleStart(context)
+    }
+  }
+
+  // restart on destruction
+  class AutoRestartReceiver: BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+      Log.d(TAG, "AutoRestartReceiver: onReceive called")
+      scheduleStart(context)
+    }
+  }
+
+  class ServiceStartWorker(private val context: Context, params: WorkerParameters): CoroutineWorker(context, params) {
+    override suspend fun doWork(): Result {
+      val id = this.id
+      if (context.applicationContext !is Application) {
+        Log.d(TAG, "ServiceStartWorker: Failed, no application found (work ID: $id)")
+        return Result.failure()
+      }
+      if (getServiceState(context) == ServiceState.STARTED) {
+        Log.d(TAG, "ServiceStartWorker: Starting foreground service (work ID: $id)")
+        start(context)
+      }
+      return Result.success()
+    }
+  }
+
+  enum class Action {
+    START,
+    STOP
+  }
+
+  enum class ServiceState {
+    STARTED,
+    STOPPED,
+  }
+
+  companion object {
+    const val TAG = "SIMPLEX_SERVICE"
+    const val NOTIFICATION_CHANNEL_ID = "chat.simplex.app.SIMPLEX_SERVICE_NOTIFICATION"
+    const val NOTIFICATION_CHANNEL_NAME = "SimpleX Chat service"
+    const val SIMPLEX_SERVICE_ID = 6789
+    const val SERVICE_START_WORKER_VERSION = BuildConfig.VERSION_CODE
+    const val SERVICE_START_WORKER_INTERVAL_MINUTES = 3 * 60L
+    const val SERVICE_START_WORKER_WORK_NAME_PERIODIC = "SimplexAutoRestartWorkerPeriodic" // Do not change!
+
+    private const val WAKE_LOCK_TAG = "SimplexService::lock"
+    private const val SHARED_PREFS_ID = "chat.simplex.app.SIMPLEX_SERVICE_PREFS"
+    private const val SHARED_PREFS_SERVICE_STATE = "SIMPLEX_SERVICE_STATE"
+    private const val WORK_NAME_ONCE = "ServiceStartWorkerOnce"
+
+    fun scheduleStart(context: Context) {
+      Log.d(TAG, "Enqueuing work to start subscriber service")
+      val workManager = WorkManager.getInstance(context)
+      val startServiceRequest = OneTimeWorkRequest.Builder(ServiceStartWorker::class.java).build()
+      workManager.enqueueUniqueWork(WORK_NAME_ONCE, ExistingWorkPolicy.KEEP, startServiceRequest) // Unique avoids races!
+    }
+
+    suspend fun start(context: Context) = serviceAction(context, Action.START)
+
+    suspend fun stop(context: Context) = serviceAction(context, Action.STOP)
+
+    private suspend fun serviceAction(context: Context, action: Action) {
+      Log.d(TAG, "SimplexService serviceAction: ${action.name}")
+      withContext(Dispatchers.IO) {
+        Intent(context, SimplexService::class.java).also {
+          it.action = action.name
+          ContextCompat.startForegroundService(context, it)
+        }
+      }
+    }
+
+    fun restart(context: Context) {
+      Intent(context, SimplexService::class.java).also { intent ->
+        context.stopService(intent) // Service will auto-restart
+      }
+    }
+
+    fun saveServiceState(context: Context, state: ServiceState) {
+      getPreferences(context).edit()
+        .putString(SHARED_PREFS_SERVICE_STATE, state.name)
+        .apply()
+    }
+
+    fun getServiceState(context: Context): ServiceState {
+      val value = getPreferences(context)
+        .getString(SHARED_PREFS_SERVICE_STATE, ServiceState.STOPPED.name)
+      return ServiceState.valueOf(value!!)
+    }
+
+    private fun getPreferences(context: Context): SharedPreferences = context.getSharedPreferences(SHARED_PREFS_ID, Context.MODE_PRIVATE)
+  }
+}

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

@@ -1,46 +0,0 @@
-package chat.simplex.app.model
-
-import android.content.Context
-import android.util.Log
-import androidx.work.*
-import chat.simplex.app.TAG
-import chat.simplex.app.chatRecvMsg
-import kotlinx.datetime.Clock
-import java.time.Duration
-import java.util.concurrent.TimeUnit
-
-class BGManager(appContext: Context, workerParams: WorkerParameters): //, ctrl: ChatCtrl):
-  Worker(appContext, workerParams) {
-//  val controller = ctrl
-
-  init {}
-
-  override fun doWork(): Result {
-    Log.e(TAG, "BGManager doWork ${Clock.System.now()}")
-    schedule(applicationContext)
-    getNewItems()
-    return Result.success()
-  }
-
-  private fun getNewItems() {
-    Log.e(TAG, "BGManager getNewItems")
-//    val json = chatRecvMsg(controller)
-//    val r = APIResponse.decodeStr(json).resp
-//    Log.d(TAG, "chatRecvMsg: ${r.responseType}")
-  }
-
-  companion object {
-    val constraints = Constraints.Builder()
-      .setRequiredNetworkType(NetworkType.CONNECTED)
-      .build()
-
-    fun schedule(appContext: Context) {
-      val request = OneTimeWorkRequestBuilder<BGManager>()
-        .setInitialDelay(Duration.ofMinutes(10))
-        .setConstraints(constraints)
-        .build()
-      WorkManager.getInstance(appContext)
-        .enqueue(request)
-    }
-  }
-}

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

@@ -14,6 +14,7 @@ class NtfManager(val context: Context) {
     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"
   }
 
   private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -28,6 +29,18 @@ class NtfManager(val context: Context) {
     ))
   }
 
+  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}")
     val now = Clock.System.now().toEpochMilliseconds()
@@ -36,7 +49,7 @@ class NtfManager(val context: Context) {
 
     val notification = NotificationCompat.Builder(context, MessageChannel)
       .setContentTitle(cInfo.displayName)
-      .setContentText(cItem.content.text)
+      .setContentText(hideSecrets(cItem))
       .setPriority(NotificationCompat.PRIORITY_HIGH)
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
@@ -53,6 +66,7 @@ class NtfManager(val context: Context) {
       .setGroup(MessageGroup)
       .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
       .setGroupSummary(true)
+      .setContentIntent(getSummaryNtfIntent())
       .build()
 
     with(NotificationManagerCompat.from(context)) {
@@ -62,6 +76,23 @@ class NtfManager(val context: Context) {
     }
   }
 
+  private fun hideSecrets(cItem: ChatItem) : String {
+    val md = cItem.formattedText
+    return if (md == null) {
+      if (cItem.content.text != "") {
+        cItem.content.text
+      } else {
+        cItem.file?.fileName ?: ""
+      }
+    } else {
+      var res = ""
+      for (ft in md) {
+        res += if (ft.format is Format.Secret) "..." else ft.text
+      }
+      res
+    }
+  }
+
   private fun getMsgPendingIntent(cInfo: ChatInfo) : PendingIntent{
     Log.d(TAG, "getMsgPendingIntent ${cInfo.id}")
     val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
@@ -74,4 +105,16 @@ class NtfManager(val context: Context) {
       getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
     }
   }
+
+  private fun getSummaryNtfIntent() : PendingIntent{
+    Log.d(TAG, "getSummaryNtfIntent")
+    val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
+    val intent = Intent(context, MainActivity::class.java)
+      .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+      .setAction(ShowChatsAction)
+    return TaskStackBuilder.create(context).run {
+      addNextIntentWithParentStack(intent)
+      getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
+    }
+  }
 }

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

@@ -3,11 +3,21 @@ package chat.simplex.app.model
 import android.app.ActivityManager
 import android.app.ActivityManager.RunningAppProcessInfo
 import android.content.Context
+import android.content.SharedPreferences
 import android.util.Log
-import androidx.compose.runtime.mutableStateOf
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Bolt
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
 import chat.simplex.app.*
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.R
+import chat.simplex.app.views.call.*
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.onboarding.OnboardingStage
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlinx.datetime.Clock
@@ -19,19 +29,27 @@ import kotlin.concurrent.thread
 
 typealias ChatCtrl = Long
 
-open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val appContext: Context) {
+open class ChatController(private val ctrl: ChatCtrl, private val ntfManager: NtfManager, val appContext: Context) {
   var chatModel = ChatModel(this)
+  private val sharedPreferences: SharedPreferences = appContext.getSharedPreferences(SHARED_PREFS_ID, Context.MODE_PRIVATE)
 
-  suspend fun startChat(u: User) {
-    Log.d(TAG, "user: $u")
+  init {
+    chatModel.runServiceInBackground.value = getRunServiceInBackground()
+  }
+
+  suspend fun startChat(user: User) {
+    Log.d(TAG, "user: $user")
     try {
       apiStartChat()
+      apiSetFilesFolder(getAppFilesDirectory(appContext))
       chatModel.userAddress.value = apiGetUserAddress()
       chatModel.userSMPServers.value = getUserSMPServers()
-      chatModel.chats.addAll(apiGetChats())
-      chatModel.currentUser = mutableStateOf(u)
+      val chats = apiGetChats()
+      chatModel.chats.clear()
+      chatModel.chats.addAll(chats)
+      chatModel.currentUser.value = user
       chatModel.userCreated.value = true
-      startReceiver()
+      chatModel.onboardingStage.value = OnboardingStage.OnboardingComplete
       Log.d(TAG, "started chat")
     } catch(e: Error) {
       Log.e(TAG, "failed starting chat $e")
@@ -40,6 +58,7 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
   }
 
   fun startReceiver() {
+    Log.d(TAG, "ChatController startReceiver")
     thread(name="receiver") {
       withApi { recvMspLoop() }
     }
@@ -57,18 +76,26 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
     return false
   }
 
+  fun cancelNotificationsForChat(chatId: String) {
+    ntfManager.cancelNotificationsForChat(chatId)
+  }
+
   suspend fun sendCmd(cmd: CC): CR {
     return withContext(Dispatchers.IO) {
       val c = cmd.cmdString
-      chatModel.terminalItems.add(TerminalItem.cmd(cmd))
+      if (cmd !is CC.ApiParseMarkdown) {
+        chatModel.terminalItems.add(TerminalItem.cmd(cmd))
+        Log.d(TAG, "sendCmd: ${cmd.cmdType}")
+      }
       val json = chatSendCmd(ctrl, c)
-      Log.d(TAG, "sendCmd: ${cmd.cmdType}")
       val r = APIResponse.decodeStr(json)
       Log.d(TAG, "sendCmd response type ${r.resp.responseType}")
       if (r.resp is CR.Response || r.resp is CR.Invalid) {
         Log.d(TAG, "sendCmd response json $json")
       }
-      chatModel.terminalItems.add(TerminalItem.resp(r.resp))
+      if (r.resp !is CR.ParsedMarkdown) {
+        chatModel.terminalItems.add(TerminalItem.resp(r.resp))
+      }
       r.resp
     }
   }
@@ -105,10 +132,16 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
 
   suspend fun apiStartChat() {
     val r = sendCmd(CC.StartChat())
-    if (r is CR.ChatStarted ) return
+    if (r is CR.ChatStarted || r is CR.ChatRunning) return
     throw Error("failed starting chat: ${r.responseType} ${r.details}")
   }
 
+  suspend fun apiSetFilesFolder(filesFolder: String) {
+    val r = sendCmd(CC.SetFilesFolder(filesFolder))
+    if (r is CR.CmdOk) return
+    throw Error("failed to set files folder: ${r.responseType} ${r.details}")
+  }
+
   suspend fun apiGetChats(): List<Chat> {
     val r = sendCmd(CC.ApiGetChats())
     if (r is CR.ApiChats ) return r.chats
@@ -122,13 +155,28 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
     return null
   }
 
-  suspend fun apiSendMessage(type: ChatType, id: Long, mc: MsgContent): AChatItem? {
-    val r = sendCmd(CC.ApiSendMessage(type, id, mc))
+  suspend fun apiSendMessage(type: ChatType, id: Long, file: String? = null, quotedItemId: Long? = null, mc: MsgContent): AChatItem? {
+    val cmd = CC.ApiSendMessage(type, id, file, quotedItemId, mc)
+    val r = sendCmd(cmd)
     if (r is CR.NewChatItem ) return r.chatItem
     Log.e(TAG, "apiSendMessage bad response: ${r.responseType} ${r.details}")
     return null
   }
 
+  suspend fun apiUpdateChatItem(type: ChatType, id: Long, itemId: Long, mc: MsgContent): AChatItem? {
+    val r = sendCmd(CC.ApiUpdateChatItem(type, id, itemId, mc))
+    if (r is CR.ChatItemUpdated) return r.chatItem
+    Log.e(TAG, "apiUpdateChatItem bad response: ${r.responseType} ${r.details}")
+    return null
+  }
+
+  suspend fun apiDeleteChatItem(type: ChatType, id: Long, itemId: Long, mode: CIDeleteMode): AChatItem? {
+    val r = sendCmd(CC.ApiDeleteChatItem(type, id, itemId, mode))
+    if (r is CR.ChatItemDeleted) return r.toChatItem
+    Log.e(TAG, "apiDeleteChatItem bad response: ${r.responseType} ${r.details}")
+    return null
+  }
+
   suspend fun getUserSMPServers(): List<String>? {
     val r = sendCmd(CC.GetUserSMPServers())
     if (r is CR.UserSMPServers) return r.smpServers
@@ -143,8 +191,8 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
       else -> {
         Log.e(TAG, "setUserSMPServers bad response: ${r.responseType} ${r.details}")
         AlertManager.shared.showAlertMsg(
-          "Error saving SMP servers",
-          "Make sure SMP server addresses are in correct format, line separated and are not duplicated"
+          generalGetString(R.string.error_saving_smp_servers),
+          generalGetString(R.string.ensure_smp_server_address_are_correct_format_and_unique)
         )
         false
       }
@@ -163,15 +211,26 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
     when {
       r is CR.SentConfirmation || r is CR.SentInvitation -> return true
       r is CR.ContactAlreadyExists -> {
-        AlertManager.shared.showAlertMsg("Contact already exists",
-          "You are already connected to ${r.contact.displayName} via this link"
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.contact_already_exists),
+          String.format(generalGetString(R.string.you_are_already_connected_to_vName_via_this_link), r.contact.displayName)
         )
         return false
       }
       r is CR.ChatCmdError && r.chatError is ChatError.ChatErrorChat
           && r.chatError.errorType is ChatErrorType.InvalidConnReq -> {
-        AlertManager.shared.showAlertMsg("Invalid connection link",
-          "Please check that you used the correct link or ask your contact to send you another one."
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.invalid_connection_link),
+          generalGetString(R.string.please_check_correct_link_and_maybe_ask_for_a_new_one)
+        )
+        return false
+      }
+      r is CR.ChatCmdError && r.chatError is ChatError.ChatErrorAgent
+          && r.chatError.agentError is AgentErrorType.SMP
+          && r.chatError.agentError.smpErr is SMPErrorType.AUTH -> {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.connection_error_auth),
+          generalGetString(R.string.connection_error_auth_desc)
         )
         return false
       }
@@ -184,30 +243,46 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
 
   suspend fun apiDeleteChat(type: ChatType, id: Long): Boolean {
     val r = sendCmd(CC.ApiDeleteChat(type, id))
-    when (r) {
-      is CR.ContactDeleted -> return true // TODO groups
-      is CR.ChatCmdError -> {
+    when {
+      r is CR.ContactDeleted && type == ChatType.Direct -> return true
+      r is CR.ContactConnectionDeleted && type == ChatType.ContactConnection -> return true
+      r is CR.ChatCmdError -> {
         val e = r.chatError
         if (e is ChatError.ChatErrorChat && e.errorType is ChatErrorType.ContactGroups) {
           AlertManager.shared.showAlertMsg(
-            "Can't delete contact!",
-            "Contact ${e.errorType.contact.displayName} cannot be deleted, it is a member of the group(s) ${e.errorType.groupNames}"
+            generalGetString(R.string.cannot_delete_contact),
+            String.format(generalGetString(R.string.contact_cannot_be_deleted_as_they_are_in_groups), e.errorType.contact.displayName, e.errorType.groupNames)
           )
         }
       }
-      else -> apiErrorAlert("apiDeleteChat", "Error deleting ${type.chatTypeName}", r)
+      else -> {
+        val titleId = when (type) {
+          ChatType.Direct -> R.string.error_deleting_contact
+          ChatType.Group -> R.string.error_deleting_group
+          ChatType.ContactRequest -> R.string.error_deleting_contact_request
+          ChatType.ContactConnection -> R.string.error_deleting_pending_contact_connection
+        }
+        apiErrorAlert("apiDeleteChat", generalGetString(titleId), r)
+      }
     }
     return false
   }
 
   suspend fun apiUpdateProfile(profile: Profile): Profile? {
-    val r = sendCmd(CC.UpdateProfile(profile))
+    val r = sendCmd(CC.ApiUpdateProfile(profile))
     if (r is CR.UserProfileNoChange) return profile
     if (r is CR.UserProfileUpdated) return r.toProfile
     Log.e(TAG, "apiUpdateProfile bad response: ${r.responseType} ${r.details}")
     return null
   }
 
+  suspend fun apiParseMarkdown(text: String): List<FormattedText>? {
+    val r = sendCmd(CC.ApiParseMarkdown(text))
+    if (r is CR.ParsedMarkdown) return r.formattedText
+    Log.e(TAG, "apiParseMarkdown bad response: ${r.responseType} ${r.details}")
+    return null
+  }
+
   suspend fun apiCreateUserAddress(): String? {
     val r = sendCmd(CC.CreateMyAddress())
     if (r is CR.UserContactLinkCreated) return r.connReqContact
@@ -247,6 +322,51 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
     return false
   }
 
+  suspend fun apiSendCallInvitation(contact: Contact, callType: CallType): Boolean {
+    val r = sendCmd(CC.ApiSendCallInvitation(contact, callType))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiRejectCall(contact: Contact): Boolean {
+    val r = sendCmd(CC.ApiRejectCall(contact))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiSendCallOffer(contact: Contact, rtcSession: String, rtcIceCandidates: List<String>, media: CallMediaType, capabilities: CallCapabilities): Boolean {
+    val webRtcSession = WebRTCSession(rtcSession, rtcIceCandidates)
+    val callOffer = WebRTCCallOffer(CallType(media, capabilities), webRtcSession)
+    val r = sendCmd(CC.ApiSendCallOffer(contact, callOffer))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiSendCallAnswer(contact: Contact, rtcSession: String, rtcIceCandidates: List<String>): Boolean {
+    val answer = WebRTCSession(rtcSession, rtcIceCandidates)
+    val r = sendCmd(CC.ApiSendCallAnswer(contact, answer))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiSendCallExtraInfo(contact: Contact, rtcIceCandidates: List<String>): Boolean {
+    val extraInfo = WebRTCExtraInfo(rtcIceCandidates)
+    val r = sendCmd(CC.ApiSendCallExtraInfo(contact, extraInfo))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiEndCall(contact: Contact): Boolean {
+    val r = sendCmd(CC.ApiEndCall(contact))
+    return r is CR.CmdOk
+  }
+
+  suspend fun apiCallStatus(contact: Contact, status: String): Boolean {
+    try {
+      val callStatus = WebRTCCallStatus.valueOf(status)
+      val r = sendCmd(CC.ApiCallStatus(contact, callStatus))
+      return r is CR.CmdOk
+    } catch (e: Error) {
+      Log.d(TAG,"apiCallStatus: call status $status not used")
+      return false
+    }
+  }
+
   suspend fun apiChatRead(type: ChatType, id: Long, range: CC.ItemRange): Boolean {
     val r = sendCmd(CC.ApiChatRead(type, id, range))
     if (r is CR.CmdOk) return true
@@ -254,6 +374,13 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
     return false
   }
 
+  suspend fun apiReceiveFile(fileId: Long): AChatItem? {
+    val r = sendCmd(CC.ReceiveFile(fileId))
+    if (r is CR.RcvFileAccepted) return r.chatItem
+    Log.e(TAG, "receiveFile bad response: ${r.responseType} ${r.details}")
+    return null
+  }
+
   fun apiErrorAlert(method: String, title: String, r: CR) {
     val errMsg = "${r.responseType}: ${r.details}"
     Log.e(TAG, "$method bad response: $errMsg")
@@ -263,11 +390,22 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
   fun processReceivedMsg(r: CR) {
     chatModel.terminalItems.add(TerminalItem.resp(r))
     when (r) {
+      is CR.NewContactConnection -> {
+        chatModel.updateContactConnection(r.connection)
+      }
+      is CR.ContactConnectionDeleted -> {
+        chatModel.removeChat(r.connection.id)
+      }
       is CR.ContactConnected -> {
         chatModel.updateContact(r.contact)
-        chatModel.updateNetworkStatus(r.contact, Chat.NetworkStatus.Connected())
+        chatModel.removeChat(r.contact.activeConn.id)
+        chatModel.updateNetworkStatus(r.contact.id, Chat.NetworkStatus.Connected())
 //        NtfManager.shared.notifyContactConnected(contact)
       }
+      is CR.ContactConnecting -> {
+        chatModel.updateContact(r.contact)
+        chatModel.removeChat(r.contact.activeConn.id)
+      }
       is CR.ReceivedContactRequest -> {
         val contactRequest = r.contactRequest
         val cInfo = ChatInfo.ContactRequest(contactRequest)
@@ -280,41 +418,96 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
           chatModel.updateChatInfo(cInfo)
         }
       }
-      is CR.ContactSubscribed -> processContactSubscribed(r.contact)
-      is CR.ContactDisconnected -> {
-        chatModel.updateContact(r.contact)
-        chatModel.updateNetworkStatus(r.contact, Chat.NetworkStatus.Disconnected())
-      }
+      is CR.ContactsSubscribed -> updateContactsStatus(r.contactRefs, Chat.NetworkStatus.Connected())
+      is CR.ContactsDisconnected -> updateContactsStatus(r.contactRefs, Chat.NetworkStatus.Disconnected())
       is CR.ContactSubError -> processContactSubError(r.contact, r.chatError)
       is CR.ContactSubSummary -> {
         for (sub in r.contactSubscriptions) {
           val err = sub.contactError
-          if (err == null) processContactSubscribed(sub.contact)
-          else processContactSubError(sub.contact, sub.contactError)
+          if (err == null) {
+            chatModel.updateContact(sub.contact)
+            chatModel.updateNetworkStatus(sub.contact.id, Chat.NetworkStatus.Connected())
+          } else {
+            processContactSubError(sub.contact, sub.contactError)
+          }
         }
       }
       is CR.NewChatItem -> {
         val cInfo = r.chatItem.chatInfo
         val cItem = r.chatItem.chatItem
         chatModel.addChatItem(cInfo, cItem)
+        val file = cItem.file
+        if (cItem.content.msgContent is MsgContent.MCImage && file != null && file.fileSize <= MAX_IMAGE_SIZE) {
+          withApi {
+            val chatItem = apiReceiveFile(file.fileId)
+            if (chatItem != null) {
+              chatItemSimpleUpdate(chatItem)
+            }
+          }
+        }
         if (!isAppOnForeground(appContext) || chatModel.chatId.value != cInfo.id) {
           ntfManager.notifyMessageReceived(cInfo, cItem)
         }
       }
-//        case let .chatItemUpdated(aChatItem):
-  //        let cInfo = aChatItem.chatInfo
-  //            let cItem = aChatItem.chatItem
-  //            if chatModel.upsertChatItem(cInfo, cItem) {
-  //              NtfManager.shared.notifyMessageReceived(cInfo, cItem)
-  //            }
+      is CR.ChatItemStatusUpdated -> {
+        val cInfo = r.chatItem.chatInfo
+        val cItem = r.chatItem.chatItem
+        var res = false
+        if (!cItem.isDeletedContent) {
+          res = chatModel.upsertChatItem(cInfo, cItem)
+        }
+        if (res) {
+          ntfManager.notifyMessageReceived(cInfo, cItem)
+        }
+      }
+      is CR.ChatItemUpdated ->
+        chatItemSimpleUpdate(r.chatItem)
+      is CR.ChatItemDeleted -> {
+        val cInfo = r.toChatItem.chatInfo
+        val cItem = r.toChatItem.chatItem
+        if (cItem.meta.itemDeleted) {
+          chatModel.removeChatItem(cInfo, cItem)
+        } else {
+          // currently only broadcast deletion of rcv message can be received, and only this case should happen
+          chatModel.upsertChatItem(cInfo, cItem)
+        }
+      }
+      is CR.RcvFileStart ->
+        chatItemSimpleUpdate(r.chatItem)
+      is CR.RcvFileComplete ->
+        chatItemSimpleUpdate(r.chatItem)
+      is CR.SndFileStart ->
+        chatItemSimpleUpdate(r.chatItem)
+      is CR.SndFileComplete -> {
+        chatItemSimpleUpdate(r.chatItem)
+        val cItem = r.chatItem.chatItem
+        val mc = cItem.content.msgContent
+        val fileName = cItem.file?.fileName
+        if (
+          r.chatItem.chatInfo.chatType == ChatType.Direct
+          && mc is MsgContent.MCFile
+          && fileName != null
+        ) {
+          removeFile(appContext, fileName)
+        }
+      }
       else ->
         Log.d(TAG , "unsupported event: ${r.responseType}")
     }
   }
 
-  fun processContactSubscribed(contact: Contact) {
-    chatModel.updateContact(contact)
-    chatModel.updateNetworkStatus(contact, Chat.NetworkStatus.Connected())
+  private fun chatItemSimpleUpdate(aChatItem: AChatItem) {
+    val cInfo = aChatItem.chatInfo
+    val cItem = aChatItem.chatItem
+    if (chatModel.upsertChatItem(cInfo, cItem)) {
+      ntfManager.notifyMessageReceived(cInfo, cItem)
+    }
+  }
+
+  fun updateContactsStatus(contactRefs: List<ContactRef>, status: Chat.NetworkStatus) {
+    for (c in contactRefs) {
+      chatModel.updateNetworkStatus(c.id, status)
+    }
   }
 
   fun processContactSubError(contact: Contact, chatError: ChatError) {
@@ -330,7 +523,67 @@ open class ChatController(val ctrl: ChatCtrl, val ntfManager: NtfManager, val ap
         }
       }
       else e.string
-    chatModel.updateNetworkStatus(contact, Chat.NetworkStatus.Error(err))
+    chatModel.updateNetworkStatus(contact.id, Chat.NetworkStatus.Error(err))
+  }
+
+  fun showBackgroundServiceNotice() {
+    if (!getBackgroundServiceNoticeShown()) {
+      AlertManager.shared.showAlert {
+        AlertDialog(
+          onDismissRequest = AlertManager.shared::hideAlert,
+          title = {
+            Row {
+              Icon(
+                Icons.Outlined.Bolt,
+                contentDescription = stringResource(R.string.icon_descr_instant_notifications),
+              )
+              Text(stringResource(R.string.private_instant_notifications), fontWeight = FontWeight.Bold)
+            }
+          },
+          text = {
+            Column {
+              Text(
+                annotatedStringResource(R.string.to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery),
+                Modifier.padding(bottom = 8.dp)
+              )
+              Text(annotatedStringResource(R.string.it_can_disabled_via_settings_notifications_still_shown))
+            }
+          },
+          confirmButton = {
+            Button(onClick = AlertManager.shared::hideAlert) { Text(stringResource(R.string.ok)) }
+          }
+        )
+      }
+      setBackgroundServiceNoticeShown()
+    }
+  }
+
+  fun getAutoRestartWorkerVersion(): Int = sharedPreferences.getInt(SHARED_PREFS_AUTO_RESTART_WORKER_VERSION, 0)
+
+  fun setAutoRestartWorkerVersion(version: Int) =
+    sharedPreferences.edit()
+      .putInt(SHARED_PREFS_AUTO_RESTART_WORKER_VERSION, version)
+      .apply()
+
+  fun getRunServiceInBackground(): Boolean = sharedPreferences.getBoolean(SHARED_PREFS_RUN_SERVICE_IN_BACKGROUND, true)
+
+  fun setRunServiceInBackground(runService: Boolean) =
+    sharedPreferences.edit()
+      .putBoolean(SHARED_PREFS_RUN_SERVICE_IN_BACKGROUND, runService)
+      .apply()
+
+  fun getBackgroundServiceNoticeShown(): Boolean = sharedPreferences.getBoolean(SHARED_PREFS_SERVICE_NOTICE_SHOWN, false)
+
+  fun setBackgroundServiceNoticeShown() =
+    sharedPreferences.edit()
+      .putBoolean(SHARED_PREFS_SERVICE_NOTICE_SHOWN, true)
+      .apply()
+
+  companion object {
+    private const val SHARED_PREFS_ID = "chat.simplex.app.SIMPLEX_APP_PREFS"
+    private const val SHARED_PREFS_AUTO_RESTART_WORKER_VERSION = "AutoRestartWorkerVersion"
+    private const val SHARED_PREFS_RUN_SERVICE_IN_BACKGROUND = "RunServiceInBackground"
+    private const val SHARED_PREFS_SERVICE_NOTICE_SHOWN = "BackgroundServiceNoticeShown"
   }
 }
 
@@ -340,42 +593,66 @@ sealed class CC {
   class ShowActiveUser: CC()
   class CreateActiveUser(val profile: Profile): CC()
   class StartChat: CC()
+  class SetFilesFolder(val filesFolder: String): CC()
   class ApiGetChats: CC()
   class ApiGetChat(val type: ChatType, val id: Long): CC()
-  class ApiSendMessage(val type: ChatType, val id: Long, val mc: MsgContent): CC()
+  class ApiSendMessage(val type: ChatType, val id: Long, val file: String?, val quotedItemId: Long?, val mc: MsgContent): CC()
+  class ApiUpdateChatItem(val type: ChatType, val id: Long, val itemId: Long, val mc: MsgContent): CC()
+  class ApiDeleteChatItem(val type: ChatType, val id: Long, val itemId: Long, val mode: CIDeleteMode): CC()
   class GetUserSMPServers(): CC()
   class SetUserSMPServers(val smpServers: List<String>): CC()
   class AddContact: CC()
   class Connect(val connReq: String): CC()
   class ApiDeleteChat(val type: ChatType, val id: Long): CC()
-  class UpdateProfile(val profile: Profile): CC()
+  class ApiUpdateProfile(val profile: Profile): CC()
+  class ApiParseMarkdown(val text: String): CC()
   class CreateMyAddress: CC()
   class DeleteMyAddress: CC()
   class ShowMyAddress: CC()
+  class ApiSendCallInvitation(val contact: Contact, val callType: CallType): CC()
+  class ApiRejectCall(val contact: Contact): CC()
+  class ApiSendCallOffer(val contact: Contact, val callOffer: WebRTCCallOffer): CC()
+  class ApiSendCallAnswer(val contact: Contact, val answer: WebRTCSession): CC()
+  class ApiSendCallExtraInfo(val contact: Contact, val extraInfo: WebRTCExtraInfo): CC()
+  class ApiEndCall(val contact: Contact): CC()
+  class ApiCallStatus(val contact: Contact, val callStatus: WebRTCCallStatus): CC()
   class ApiAcceptContact(val contactReqId: Long): CC()
   class ApiRejectContact(val contactReqId: Long): CC()
   class ApiChatRead(val type: ChatType, val id: Long, val range: ItemRange): CC()
+  class ReceiveFile(val fileId: Long): CC()
 
   val cmdString: String get() = when (this) {
     is Console -> cmd
     is ShowActiveUser -> "/u"
     is CreateActiveUser -> "/u ${profile.displayName} ${profile.fullName}"
     is StartChat -> "/_start"
-    is ApiGetChats -> "/_get chats"
+    is SetFilesFolder -> "/_files_folder $filesFolder"
+    is ApiGetChats -> "/_get chats pcc=on"
     is ApiGetChat -> "/_get chat ${chatRef(type, id)} count=100"
-    is ApiSendMessage -> "/_send ${chatRef(type, id)} ${mc.cmdString}"
+    is ApiSendMessage -> "/_send ${chatRef(type, id)} json ${json.encodeToString(ComposedMessage(file, quotedItemId, mc))}"
+    is ApiUpdateChatItem -> "/_update item ${chatRef(type, id)} $itemId ${mc.cmdString}"
+    is ApiDeleteChatItem -> "/_delete item ${chatRef(type, id)} $itemId ${mode.deleteMode}"
     is GetUserSMPServers -> "/smp_servers"
     is SetUserSMPServers -> "/smp_servers ${smpServersStr(smpServers)}"
     is AddContact -> "/connect"
     is Connect -> "/connect $connReq"
     is ApiDeleteChat -> "/_delete ${chatRef(type, id)}"
-    is UpdateProfile -> "/profile ${profile.displayName} ${profile.fullName}"
+    is ApiUpdateProfile -> "/_profile ${json.encodeToString(profile)}"
+    is ApiParseMarkdown -> "/_parse $text"
     is CreateMyAddress -> "/address"
     is DeleteMyAddress -> "/delete_address"
     is ShowMyAddress -> "/show_address"
     is ApiAcceptContact -> "/_accept $contactReqId"
     is ApiRejectContact -> "/_reject $contactReqId"
+    is ApiSendCallInvitation -> "/_call invite @${contact.apiId} ${json.encodeToString(callType)}"
+    is ApiRejectCall -> "/_call reject @${contact.apiId}"
+    is ApiSendCallOffer -> "/_call offer @${contact.apiId} ${json.encodeToString(callOffer)}"
+    is ApiSendCallAnswer -> "/_call answer @${contact.apiId} ${json.encodeToString(answer)}"
+    is ApiSendCallExtraInfo -> "/_call extra @${contact.apiId} ${json.encodeToString(extraInfo)}"
+    is ApiEndCall -> "/_call end @${contact.apiId}"
+    is ApiCallStatus -> "/_call status @${contact.apiId} ${callStatus}"
     is ApiChatRead -> "/_read chat ${chatRef(type, id)} from=${range.from} to=${range.to}"
+    is ReceiveFile -> "/freceive $fileId"
   }
 
   val cmdType: String get() = when (this) {
@@ -383,21 +660,33 @@ sealed class CC {
     is ShowActiveUser -> "showActiveUser"
     is CreateActiveUser -> "createActiveUser"
     is StartChat -> "startChat"
+    is SetFilesFolder -> "setFilesFolder"
     is ApiGetChats -> "apiGetChats"
     is ApiGetChat -> "apiGetChat"
     is ApiSendMessage -> "apiSendMessage"
+    is ApiUpdateChatItem -> "apiUpdateChatItem"
+    is ApiDeleteChatItem -> "apiDeleteChatItem"
     is GetUserSMPServers -> "getUserSMPServers"
     is SetUserSMPServers -> "setUserSMPServers"
     is AddContact -> "addContact"
     is Connect -> "connect"
     is ApiDeleteChat -> "apiDeleteChat"
-    is UpdateProfile -> "updateProfile"
+    is ApiUpdateProfile -> "updateProfile"
+    is ApiParseMarkdown -> "apiParseMarkdown"
     is CreateMyAddress -> "createMyAddress"
     is DeleteMyAddress -> "deleteMyAddress"
     is ShowMyAddress -> "showMyAddress"
     is ApiAcceptContact -> "apiAcceptContact"
     is ApiRejectContact -> "apiRejectContact"
+    is ApiSendCallInvitation -> "apiSendCallInvitation"
+    is ApiRejectCall -> "apiRejectCall"
+    is ApiSendCallOffer -> "apiSendCallOffer"
+    is ApiSendCallAnswer -> "apiSendCallAnswer"
+    is ApiSendCallExtraInfo -> "apiSendCallExtraInfo"
+    is ApiEndCall -> "apiEndCall"
+    is ApiCallStatus -> "apiCallStatus"
     is ApiChatRead -> "apiChatRead"
+    is ReceiveFile -> "receiveFile"
   }
 
   class ItemRange(val from: Long, val to: Long)
@@ -409,6 +698,9 @@ sealed class CC {
   }
 }
 
+@Serializable
+class ComposedMessage(val filePath: String?, val quotedItemId: Long?, val msgContent: MsgContent)
+
 val json = Json {
   prettyPrint = true
   ignoreUnknownKeys = true
@@ -422,6 +714,7 @@ class APIResponse(val resp: CR, val corr: String? = null) {
         json.decodeFromString(str)
       } catch(e: Exception) {
         try {
+          Log.d(TAG, e.localizedMessage ?: "")
           val data = json.parseToJsonElement(str).jsonObject
           APIResponse(
             resp = CR.Response(data["resp"]!!.jsonObject["type"]?.toString() ?: "invalid", json.encodeToString(data)),
@@ -451,16 +744,18 @@ sealed class CR {
   @Serializable @SerialName("contactDeleted") class ContactDeleted(val contact: Contact): CR()
   @Serializable @SerialName("userProfileNoChange") class UserProfileNoChange: CR()
   @Serializable @SerialName("userProfileUpdated") class UserProfileUpdated(val fromProfile: Profile, val toProfile: Profile): CR()
+  @Serializable @SerialName("apiParsedMarkdown") class ParsedMarkdown(val formattedText: List<FormattedText>? = null): CR()
   @Serializable @SerialName("userContactLink") class UserContactLink(val connReqContact: String): CR()
   @Serializable @SerialName("userContactLinkCreated") class UserContactLinkCreated(val connReqContact: String): CR()
   @Serializable @SerialName("userContactLinkDeleted") class UserContactLinkDeleted: CR()
   @Serializable @SerialName("contactConnected") class ContactConnected(val contact: Contact): CR()
+  @Serializable @SerialName("contactConnecting") class ContactConnecting(val contact: Contact): CR()
   @Serializable @SerialName("receivedContactRequest") class ReceivedContactRequest(val contactRequest: UserContactRequest): CR()
   @Serializable @SerialName("acceptingContactRequest") class AcceptingContactRequest(val contact: Contact): CR()
   @Serializable @SerialName("contactRequestRejected") class ContactRequestRejected: CR()
   @Serializable @SerialName("contactUpdated") class ContactUpdated(val toContact: Contact): CR()
-  @Serializable @SerialName("contactSubscribed") class ContactSubscribed(val contact: Contact): CR()
-  @Serializable @SerialName("contactDisconnected") class ContactDisconnected(val contact: Contact): CR()
+  @Serializable @SerialName("contactsSubscribed") class ContactsSubscribed(val server: String, val contactRefs: List<ContactRef>): CR()
+  @Serializable @SerialName("contactsDisconnected") class ContactsDisconnected(val server: String, val contactRefs: List<ContactRef>): CR()
   @Serializable @SerialName("contactSubError") class ContactSubError(val contact: Contact, val chatError: ChatError): CR()
   @Serializable @SerialName("contactSubSummary") class ContactSubSummary(val contactSubscriptions: List<ContactSubStatus>): CR()
   @Serializable @SerialName("groupSubscribed") class GroupSubscribed(val group: GroupInfo): CR()
@@ -468,7 +763,24 @@ sealed class CR {
   @Serializable @SerialName("groupEmpty") class GroupEmpty(val group: GroupInfo): CR()
   @Serializable @SerialName("userContactLinkSubscribed") class UserContactLinkSubscribed: CR()
   @Serializable @SerialName("newChatItem") class NewChatItem(val chatItem: AChatItem): CR()
+  @Serializable @SerialName("chatItemStatusUpdated") class ChatItemStatusUpdated(val chatItem: AChatItem): CR()
   @Serializable @SerialName("chatItemUpdated") class ChatItemUpdated(val chatItem: AChatItem): CR()
+  @Serializable @SerialName("chatItemDeleted") class ChatItemDeleted(val deletedChatItem: AChatItem, val toChatItem: AChatItem): CR()
+  @Serializable @SerialName("rcvFileAccepted") class RcvFileAccepted(val chatItem: AChatItem): CR()
+  @Serializable @SerialName("rcvFileStart") class RcvFileStart(val chatItem: AChatItem): CR()
+  @Serializable @SerialName("rcvFileComplete") class RcvFileComplete(val chatItem: AChatItem): CR()
+  @Serializable @SerialName("sndFileStart") class SndFileStart(val chatItem: AChatItem, val sndFileTransfer: SndFileTransfer): CR()
+  @Serializable @SerialName("sndFileComplete") class SndFileComplete(val chatItem: AChatItem, val sndFileTransfer: SndFileTransfer): CR()
+  @Serializable @SerialName("sndFileCancelled") class SndFileCancelled(val chatItem: AChatItem, val sndFileTransfer: SndFileTransfer): CR()
+  @Serializable @SerialName("sndFileRcvCancelled") class SndFileRcvCancelled(val chatItem: AChatItem, val sndFileTransfer: SndFileTransfer): CR()
+  @Serializable @SerialName("sndGroupFileCancelled") class SndGroupFileCancelled(val chatItem: AChatItem, val fileTransferMeta: FileTransferMeta, val sndFileTransfers: List<SndFileTransfer>): CR()
+  @Serializable @SerialName("callInvitation") class CallInvitation(val contact: Contact, val callType: CallType, val sharedKey: String?): CR()
+  @Serializable @SerialName("callOffer") class CallOffer(val contact: Contact, val callType: CallType, val offer: WebRTCSession, val sharedKey: String?, val askConfirmation: Boolean): CR()
+  @Serializable @SerialName("callAnswer") class CallAnswer(val contact: Contact, val answer: WebRTCSession): CR()
+  @Serializable @SerialName("callExtraInfo") class CallExtraInfo(val contact: Contact, val extraInfo: WebRTCExtraInfo): CR()
+  @Serializable @SerialName("callEnded") class CallEnded(val contact: Contact): CR()
+  @Serializable @SerialName("newContactConnection") class NewContactConnection(val connection: PendingContactConnection): CR()
+  @Serializable @SerialName("contactConnectionDeleted") class ContactConnectionDeleted(val connection: PendingContactConnection): CR()
   @Serializable @SerialName("cmdOk") class CmdOk: CR()
   @Serializable @SerialName("chatCmdError") class ChatCmdError(val chatError: ChatError): CR()
   @Serializable @SerialName("chatError") class ChatRespError(val chatError: ChatError): CR()
@@ -489,16 +801,18 @@ sealed class CR {
     is ContactDeleted -> "contactDeleted"
     is UserProfileNoChange -> "userProfileNoChange"
     is UserProfileUpdated -> "userProfileUpdated"
+    is ParsedMarkdown -> "apiParsedMarkdown"
     is UserContactLink -> "userContactLink"
     is UserContactLinkCreated -> "userContactLinkCreated"
     is UserContactLinkDeleted -> "userContactLinkDeleted"
     is ContactConnected -> "contactConnected"
+    is ContactConnecting -> "contactConnecting"
     is ReceivedContactRequest -> "receivedContactRequest"
     is AcceptingContactRequest -> "acceptingContactRequest"
     is ContactRequestRejected -> "contactRequestRejected"
     is ContactUpdated -> "contactUpdated"
-    is ContactSubscribed -> "contactSubscribed"
-    is ContactDisconnected -> "contactDisconnected"
+    is ContactsSubscribed -> "contactsSubscribed"
+    is ContactsDisconnected -> "contactsDisconnected"
     is ContactSubError -> "contactSubError"
     is ContactSubSummary -> "contactSubSummary"
     is GroupSubscribed -> "groupSubscribed"
@@ -506,7 +820,24 @@ sealed class CR {
     is GroupEmpty -> "groupEmpty"
     is UserContactLinkSubscribed -> "userContactLinkSubscribed"
     is NewChatItem -> "newChatItem"
+    is ChatItemStatusUpdated -> "chatItemStatusUpdated"
     is ChatItemUpdated -> "chatItemUpdated"
+    is ChatItemDeleted -> "chatItemDeleted"
+    is RcvFileAccepted -> "rcvFileAccepted"
+    is RcvFileStart -> "rcvFileStart"
+    is RcvFileComplete -> "rcvFileComplete"
+    is SndFileCancelled -> "sndFileCancelled"
+    is SndFileComplete -> "sndFileComplete"
+    is SndFileRcvCancelled -> "sndFileRcvCancelled"
+    is SndFileStart -> "sndFileStart"
+    is SndGroupFileCancelled -> "sndGroupFileCancelled"
+    is CallInvitation -> "callInvitation"
+    is CallOffer -> "callOffer"
+    is CallAnswer -> "callAnswer"
+    is CallExtraInfo -> "callExtraInfo"
+    is CallEnded -> "callEnded"
+    is NewContactConnection -> "newContactConnection"
+    is ContactConnectionDeleted -> "contactConnectionDeleted"
     is CmdOk -> "cmdOk"
     is ChatCmdError -> "chatCmdError"
     is ChatRespError -> "chatError"
@@ -528,16 +859,18 @@ sealed class CR {
     is ContactDeleted -> json.encodeToString(contact)
     is UserProfileNoChange -> noDetails()
     is UserProfileUpdated -> json.encodeToString(toProfile)
+    is ParsedMarkdown -> json.encodeToString(formattedText)
     is UserContactLink -> connReqContact
     is UserContactLinkCreated -> connReqContact
     is UserContactLinkDeleted -> noDetails()
     is ContactConnected -> json.encodeToString(contact)
+    is ContactConnecting -> json.encodeToString(contact)
     is ReceivedContactRequest -> json.encodeToString(contactRequest)
     is AcceptingContactRequest -> json.encodeToString(contact)
     is ContactRequestRejected -> noDetails()
     is ContactUpdated -> json.encodeToString(toContact)
-    is ContactSubscribed -> json.encodeToString(contact)
-    is ContactDisconnected -> json.encodeToString(contact)
+    is ContactsSubscribed -> "server: $server\ncontacts:\n${json.encodeToString(contactRefs)}"
+    is ContactsDisconnected -> "server: $server\ncontacts:\n${json.encodeToString(contactRefs)}"
     is ContactSubError -> "error:\n${chatError.string}\ncontact:\n${json.encodeToString(contact)}"
     is ContactSubSummary -> json.encodeToString(contactSubscriptions)
     is GroupSubscribed -> json.encodeToString(group)
@@ -545,7 +878,24 @@ sealed class CR {
     is GroupEmpty -> json.encodeToString(group)
     is UserContactLinkSubscribed -> noDetails()
     is NewChatItem -> json.encodeToString(chatItem)
+    is ChatItemStatusUpdated -> json.encodeToString(chatItem)
     is ChatItemUpdated -> json.encodeToString(chatItem)
+    is ChatItemDeleted -> "deletedChatItem:\n${json.encodeToString(deletedChatItem)}\ntoChatItem:\n${json.encodeToString(toChatItem)}"
+    is RcvFileAccepted -> json.encodeToString(chatItem)
+    is RcvFileStart -> json.encodeToString(chatItem)
+    is RcvFileComplete -> json.encodeToString(chatItem)
+    is SndFileCancelled -> json.encodeToString(chatItem)
+    is SndFileComplete -> json.encodeToString(chatItem)
+    is SndFileRcvCancelled -> json.encodeToString(chatItem)
+    is SndFileStart -> json.encodeToString(chatItem)
+    is SndGroupFileCancelled -> json.encodeToString(chatItem)
+    is CallInvitation -> "contact: ${contact.id}\ncallType: $callType\nsharedKey: ${sharedKey ?: ""}"
+    is CallOffer -> "contact: ${contact.id}\ncallType: $callType\nsharedKey: ${sharedKey ?: ""}\naskConfirmation: $askConfirmation\noffer: ${json.encodeToString(offer)}"
+    is CallAnswer -> "contact: ${contact.id}\nanswer: ${json.encodeToString(answer)}"
+    is CallExtraInfo -> "contact: ${contact.id}\nextraInfo: ${json.encodeToString(extraInfo)}"
+    is CallEnded -> "contact: ${contact.id}"
+    is NewContactConnection -> json.encodeToString(connection)
+    is ContactConnectionDeleted -> json.encodeToString(connection)
     is CmdOk -> noDetails()
     is ChatCmdError -> chatError.string
     is ChatRespError -> chatError.string
@@ -553,7 +903,7 @@ sealed class CR {
     is Invalid -> str
   }
 
-  fun noDetails(): String ="${responseType}: no details"
+  fun noDetails(): String ="${responseType}: " + generalGetString(R.string.no_details)
 }
 
 abstract class TerminalItem {
@@ -600,7 +950,9 @@ sealed class ChatErrorType {
   val string: String get() = when (this) {
     is InvalidConnReq -> "invalidConnReq"
     is ContactGroups -> "groupNames $groupNames"
+    is NoActiveUser -> "noActiveUser"
   }
+  @Serializable @SerialName("noActiveUser") class NoActiveUser: ChatErrorType()
   @Serializable @SerialName("invalidConnReq") class InvalidConnReq: ChatErrorType()
   @Serializable @SerialName("contactGroups") class ContactGroups(val contact: Contact, val groupNames: List<String>): ChatErrorType()
 }

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

@@ -7,9 +7,14 @@ val Purple500 = Color(0xFF6200EE)
 val Purple700 = Color(0xFF3700B3)
 val Teal200 = Color(0xFF03DAC5)
 val Gray = Color(0x22222222)
-val SimplexBlue = Color(0, 136, 255, 255)
+val SimplexBlue = Color(0, 136, 255, 255)  // If this value changes also need to update #0088ff in string resource files
 val SimplexGreen = Color(98, 196, 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 WarningOrange = Color(255, 149, 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

@@ -5,7 +5,7 @@ import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 
 private val DarkColorPalette = darkColors(
-  primary = SimplexBlue,
+  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = DarkGray,
 //  background = Color.Black,
@@ -20,7 +20,7 @@ private val DarkColorPalette = darkColors(
 //  onError: Color = Color.Black,
 )
 private val LightColorPalette = lightColors(
-  primary = SimplexBlue,
+  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
   primaryVariant = SimplexGreen,
   secondary = LightGray,
 //  background = Color.White,

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

@@ -2,45 +2,54 @@ package chat.simplex.app.ui.theme
 
 import androidx.compose.material.Typography
 import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.font.*
 import androidx.compose.ui.unit.sp
+import chat.simplex.app.R
+
+// https://github.com/rsms/inter
+val Inter = FontFamily(
+  Font(R.font.inter_regular),
+  Font(R.font.inter_italic, style = FontStyle.Italic),
+  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),
+)
 
 // Set of Material typography styles to start with
 val Typography = Typography(
   h1 = TextStyle(
-    fontFamily = FontFamily.Default,
-    fontWeight = FontWeight.Normal,
+    fontFamily = Inter,
+    fontWeight = FontWeight.Bold,
     fontSize = 32.sp,
   ),
   h2 = TextStyle(
-    fontFamily = FontFamily.Default,
+    fontFamily = Inter,
     fontWeight = FontWeight.Normal,
     fontSize = 24.sp
   ),
   h3 = TextStyle(
-    fontFamily = FontFamily.Default,
+    fontFamily = Inter,
     fontWeight = FontWeight.Normal,
     fontSize = 19.sp
   ),
   body1 = TextStyle(
-    fontFamily = FontFamily.Default,
-    fontWeight = FontWeight.Normal,
-    fontSize = 17.sp
-  ),
-  body2 = TextStyle(
-    fontFamily = FontFamily.Default,
+    fontFamily = Inter,
     fontWeight = FontWeight.Normal,
     fontSize = 16.sp
   ),
+  body2 = TextStyle(
+    fontFamily = Inter,
+    fontWeight = FontWeight.Normal,
+    fontSize = 14.sp
+  ),
   button = TextStyle(
-    fontFamily = FontFamily.Default,
+    fontFamily = Inter,
     fontWeight = FontWeight.Normal,
     fontSize = 16.sp,
   ),
   caption = TextStyle(
-    fontFamily = FontFamily.Default,
+    fontFamily = Inter,
     fontWeight = FontWeight.Normal,
-    fontSize = 20.sp
+    fontSize = 18.sp
   )
-)
+)

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

@@ -3,13 +3,11 @@ 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.Composable
-import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.*
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
@@ -19,32 +17,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.ComposeState
 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.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()) }
   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))
+        // 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(sendCommand) },
+      bottomBar = {
+        Box(Modifier.padding(horizontal = 8.dp)) {
+          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
+        }
+      },
       modifier = Modifier.navigationBarsWithImePadding()
     ) { contentPadding ->
       Surface(
@@ -100,8 +119,9 @@ fun PreviewTerminalLayout() {
   SimpleXTheme {
     TerminalLayout(
       terminalItems = TerminalItem.sampleData,
-      close = {},
-      sendCommand = {}
+      composeState = remember { mutableStateOf(ComposeState()) },
+      sendCommand = {},
+      close = {}
     )
   }
 }

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

@@ -1,159 +1,145 @@
 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
 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)
-        )
-        chatModel.controller.startChat(user)
+        val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
+        val createModifier: Modifier
+        val createColor: Color
+        if (enabled) {
+          createModifier = Modifier.padding(8.dp).clickable { createProfile(chatModel, displayName.value, fullName.value) }
+          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)
+    SimplexService.start(chatModel.controller.appContext)
+    // TODO show it later?
+    chatModel.controller.showBackgroundServiceNotice()
+    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/CallView.kt

@@ -0,0 +1,156 @@
+package chat.simplex.app.views.call
+
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.util.Log
+import android.view.ViewGroup
+import android.webkit.*
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalLifecycleOwner
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.webkit.WebViewAssetLoader
+import androidx.webkit.WebViewClientCompat
+import chat.simplex.app.TAG
+import chat.simplex.app.views.helpers.TextEditor
+import com.google.accompanist.permissions.rememberMultiplePermissionsState
+
+@SuppressLint("SetJavaScriptEnabled")
+@Composable
+fun VideoCallView(close: () -> Unit) {
+  BackHandler(onBack = close)
+  lateinit var wv: WebView
+  val context = LocalContext.current
+  val clipboard = ContextCompat.getSystemService(context, ClipboardManager::class.java)
+  val permissionsState = rememberMultiplePermissionsState(
+    permissions = listOf(
+      Manifest.permission.CAMERA,
+      Manifest.permission.RECORD_AUDIO,
+      Manifest.permission.MODIFY_AUDIO_SETTINGS,
+      Manifest.permission.INTERNET
+    )
+  )
+  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 {
+      wv.evaluateJavascript("endCall()", null)
+      lifecycleOwner.lifecycle.removeObserver(observer)
+    }
+  }
+  val localContext = LocalContext.current
+  val commandToShow = remember { mutableStateOf("processCommand({command: {type: 'start', media: 'video'}})") } //, aesKey: 'FwW+t6UbnwHoapYOfN4mUBUuqR7UtvYWxW16iBqM29U='})") }
+  val assetLoader = WebViewAssetLoader.Builder()
+    .addPathHandler("/assets/www/", WebViewAssetLoader.AssetsPathHandler(localContext))
+    .build()
+
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally,
+    verticalArrangement = Arrangement.spacedBy(12.dp),
+    modifier = Modifier
+      .background(MaterialTheme.colors.background)
+      .fillMaxSize()
+  ) {
+    if (permissionsState.allPermissionsGranted) {
+      Box(
+        Modifier
+          .fillMaxWidth()
+          .aspectRatio(ratio = 1F)
+      ) {
+        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()
+                  }
+                }
+
+                override fun onConsoleMessage(consoleMessage: ConsoleMessage?): Boolean {
+                  val rtnValue = super.onConsoleMessage(consoleMessage)
+                  val msg = consoleMessage?.message() as String
+                  if (msg.startsWith("{")) {
+                    commandToShow.value = "processCommand($msg)"
+                  }
+                  return rtnValue
+                }
+              }
+              this.webViewClient = LocalContentWebViewClient(assetLoader)
+              this.clearHistory()
+              this.clearCache(true)
+//              this.addJavascriptInterface(JavascriptInterface(), "Android")
+              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 = it
+        }
+      }
+    } else {
+      Text("NEED PERMISSIONS")
+    }
+
+    TextEditor(Modifier.height(180.dp), text = commandToShow)
+
+    Row(
+      Modifier
+        .fillMaxWidth()
+        .padding(bottom = 6.dp),
+      horizontalArrangement = Arrangement.SpaceBetween
+    ) {
+      Button( onClick = {
+        val clip: ClipData = ClipData.newPlainText("js command", commandToShow.value)
+        clipboard?.setPrimaryClip(clip)
+      }) {Text("Copy")}
+      Button( onClick = {
+        println("sending: ${commandToShow.value}")
+        wv.evaluateJavascript(commandToShow.value, null)
+        commandToShow.value = ""
+      }) {Text("Send")}
+      Button( onClick = {
+        commandToShow.value = ""
+      }) {Text("Clear")}
+    }
+  }
+}
+
+private class LocalContentWebViewClient(private val assetLoader: WebViewAssetLoader) : WebViewClientCompat() {
+  override fun shouldInterceptRequest(
+    view: WebView,
+    request: WebResourceRequest
+  ): WebResourceResponse? {
+    return assetLoader.shouldInterceptRequest(request.url)
+  }
+}

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

@@ -0,0 +1,96 @@
+package chat.simplex.app.views.call
+
+import chat.simplex.app.R
+import chat.simplex.app.model.Contact
+import chat.simplex.app.views.helpers.generalGetString
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+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 encrypted: Boolean get() = (localCapabilities?.encryption ?: false) && sharedKey != null
+}
+
+enum class CallState {
+  WaitCapabilities,
+  InvitationSent,
+  InvitationReceived,
+  OfferSent,
+  OfferReceived,
+  Negotiated,
+  Connected;
+
+  val text: String get() = when(this) {
+    WaitCapabilities -> generalGetString(R.string.callstate_starting)
+    InvitationSent -> generalGetString(R.string.callstate_waiting_for_answer)
+    InvitationReceived -> generalGetString(R.string.callstate_starting)
+    OfferSent -> generalGetString(R.string.callstate_waiting_for_confirmation)
+    OfferReceived -> generalGetString(R.string.callstate_received_answer)
+    Negotiated -> generalGetString(R.string.callstate_connecting)
+    Connected -> generalGetString(R.string.callstate_connected)
+  }
+}
+
+@Serializable class WVAPICall(val corrId: Int? = null, val command: WCallCommand)
+@Serializable class WVAPIMessage(val corrId: Int? = null, val resp: WCallResponse, val command: WCallCommand?)
+
+@Serializable
+sealed class WCallCommand {
+  @Serializable @SerialName("capabilities") class Capabilities(): WCallCommand()
+  @Serializable @SerialName("start") class Start(val media: CallMediaType, val aesKey: String? = null): WCallCommand()
+  @Serializable @SerialName("accept") class Accept(val offer: String, val iceCandidates: List<String>, val media: CallMediaType, val aesKey: String? = null): WCallCommand()
+  @Serializable @SerialName("answer") class Answer (val answer: String, val iceCandidates: List<String>): WCallCommand()
+  @Serializable @SerialName("ice") class Ice(val iceCandidates: List<String>): WCallCommand()
+  @Serializable @SerialName("media") class Media(val media: CallMediaType, val enable: Boolean): WCallCommand()
+  @Serializable @SerialName("end") class 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: List<String>): WCallResponse()
+  // TODO remove accept, it is needed for debugging
+  @Serializable @SerialName("accept") class Accept(val offer: String, val iceCandidates: List<String>, val media: CallMediaType, val aesKey: String? = null): WCallResponse()
+  @Serializable @SerialName("answer") class Answer(val answer: String, val iceCandidates: List<String>): WCallResponse()
+  @Serializable @SerialName("ice") class Ice(val iceCandidates: List<String>): WCallResponse()
+  @Serializable @SerialName("connection") class Connection(val state: ConnectionState): WCallResponse()
+  @Serializable @SerialName("ended") class Ended(): WCallResponse()
+  @Serializable @SerialName("ok") class Ok(): WCallResponse()
+  @Serializable @SerialName("error") class Error(val message: String): WCallResponse()
+  @Serializable class Invalid(val str: String): WCallResponse()
+}
+
+@Serializable class WebRTCCallOffer(val callType: CallType, val rtcSession: WebRTCSession)
+@Serializable class WebRTCSession(val rtcSession: String, val rtcIceCandidates: List<String>)
+@Serializable class WebRTCExtraInfo(val rtcIceCandidates: List<String>)
+@Serializable class CallType(val media: CallMediaType, val capabilities: CallCapabilities)
+@Serializable class CallInvitation(val peerMedia: CallMediaType?, val sharedKey: String?)
+@Serializable class CallCapabilities(val encryption: Boolean)
+
+enum class WebRTCCallStatus(val status: String) {
+  Connected("connected"),
+  Disconnected("disconnected"),
+  Failed("failed")
+}
+
+@Serializable
+enum class CallMediaType(val media: String) {
+  Video("video"),
+  Audio("audio")
+}
+
+@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

@@ -12,9 +12,12 @@ 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.TextAlign
 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.*
@@ -28,9 +31,9 @@ fun ChatInfoView(chatModel: ChatModel, close: () -> Unit) {
       close = close,
       deleteContact = {
         AlertManager.shared.showAlertMsg(
-          title = "Delete contact?",
-          text = "Contact and all messages will be deleted - this cannot be undone!",
-          confirmText = "Delete",
+          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 = {
             val cInfo = chat.chatInfo
             withApi {
@@ -58,10 +61,10 @@ fun ChatInfoLayout(chat: Chat, close: () -> Unit, deleteContact: () -> Unit) {
   ) {
     CloseSheetBar(close)
     Spacer(Modifier.size(48.dp))
-    ChatInfoImage(chat, size = 192.dp)
     val cInfo = chat.chatInfo
+    ChatInfoImage(cInfo, size = 192.dp)
     Text(
-      cInfo.displayName, style = MaterialTheme.typography.h1,
+      cInfo.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
       color = MaterialTheme.colors.onBackground,
       modifier = Modifier.padding(top = 32.dp).padding(bottom = 8.dp)
     )
@@ -95,7 +98,8 @@ fun ChatInfoLayout(chat: Chat, close: () -> Unit, deleteContact: () -> Unit) {
 
       Box(Modifier.padding(48.dp)) {
         SimpleButton(
-          "Delete contact", icon = Icons.Outlined.Delete,
+          stringResource(R.string.button_delete_contact),
+          icon = Icons.Outlined.Delete,
           color = Color.Red,
           click = deleteContact
         )
@@ -109,13 +113,13 @@ fun ServerImage(chat: Chat) {
   val status = chat.serverInfo.networkStatus
   when {
     status is Chat.NetworkStatus.Connected ->
-      Icon(Icons.Filled.Circle, "Connected", tint = MaterialTheme.colors.primaryVariant)
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_server_status_connected), tint = MaterialTheme.colors.primaryVariant)
     status is Chat.NetworkStatus.Disconnected ->
-      Icon(Icons.Filled.Pending, "Disconnected", tint = HighOrLowlight)
+      Icon(Icons.Filled.Pending, stringResource(R.string.icon_descr_server_status_disconnected), tint = HighOrLowlight)
     status is Chat.NetworkStatus.Error ->
-      Icon(Icons.Filled.Error, "Error", tint = HighOrLowlight)
+      Icon(Icons.Filled.Error, stringResource(R.string.icon_descr_server_status_error), tint = HighOrLowlight)
     else ->
-      Icon(Icons.Outlined.Circle, "Pending", tint = HighOrLowlight)
+      Icon(Icons.Outlined.Circle, stringResource(R.string.icon_descr_server_status_pending), tint = HighOrLowlight)
   }
 }
 

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

@@ -1,41 +1,56 @@
 package chat.simplex.app.views.chat
 
 import android.content.res.Configuration
+import android.graphics.Bitmap
+import android.net.Uri
 import android.util.Log
 import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.ArrowBack
+import androidx.compose.material.icons.outlined.ArrowBackIos
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.mapSaver
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalUriHandler
+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.SimplexApp.Companion.context
 import chat.simplex.app.TAG
 import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.ui.theme.*
 import chat.simplex.app.views.chat.item.ChatItemView
+import chat.simplex.app.views.chatlist.openChat
 import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.ModalManager
 import com.google.accompanist.insets.ProvideWindowInsets
 import com.google.accompanist.insets.navigationBarsWithImePadding
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
+import kotlinx.coroutines.*
 import kotlinx.datetime.Clock
 
 @Composable
 fun ChatView(chatModel: ChatModel) {
   val chat: Chat? = chatModel.chats.firstOrNull { chat -> chat.chatInfo.id == chatModel.chatId.value }
-  if (chat == null) {
+  val user = chatModel.currentUser.value
+  val composeState = remember { mutableStateOf(ComposeState()) }
+  val attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
+  val scope = rememberCoroutineScope()
+  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val chosenFile = remember { mutableStateOf<Uri?>(null) }
+
+  if (chat == null || user == null) {
     chatModel.chatId.value = null
   } else {
     BackHandler { chatModel.chatId.value = null }
@@ -45,6 +60,7 @@ fun ChatView(chatModel: ChatModel) {
       delay(1000L)
       if (chat.chatItems.count() > 0) {
         chatModel.markChatItemsRead(chat.chatInfo)
+        chatModel.controller.cancelNotificationsForChat(chat.id)
         withApi {
           chatModel.controller.apiChatRead(
             chat.chatInfo.chatType,
@@ -54,20 +70,52 @@ fun ChatView(chatModel: ChatModel) {
         }
       }
     }
-    ChatLayout(chat, chatModel.chatItems,
+    ChatLayout(
+      user,
+      chat,
+      composeState,
+      composeView = {
+        ComposeView(
+          chatModel,
+          chat,
+          composeState,
+          chosenImage,
+          chosenFile,
+          showAttachmentBottomSheet = { scope.launch { attachmentBottomSheetState.show() } })
+      },
+      chosenImage,
+      chosenFile,
+      scope,
+      attachmentBottomSheetState,
+      chatModel.chatItems,
       back = { chatModel.chatId.value = null },
       info = { ModalManager.shared.showCustomModal { close -> ChatInfoView(chatModel, close) } },
-      sendMessage = { msg ->
+      openDirectChat = { contactId ->
+        val c = chatModel.chats.firstOrNull {
+          it.chatInfo is ChatInfo.Direct && it.chatInfo.contact.contactId == contactId
+        }
+        if (c != null) withApi { openChat(chatModel, c.chatInfo) }
+      },
+      deleteMessage = { itemId, mode ->
         withApi {
-          // show "in progress"
           val cInfo = chat.chatInfo
-          val newItem = chatModel.controller.apiSendMessage(
+          val toItem = chatModel.controller.apiDeleteChatItem(
             type = cInfo.chatType,
             id = cInfo.apiId,
-            mc = MsgContent.MCText(msg)
+            itemId = itemId,
+            mode = mode
           )
-          // hide "in progress"
-          if (newItem != null) chatModel.addChatItem(cInfo, newItem.chatItem)
+          if (toItem != null) chatModel.removeChatItem(cInfo, toItem.chatItem)
+        }
+      },
+      receiveFile = { fileId ->
+        withApi {
+          val chatItem = chatModel.controller.apiReceiveFile(fileId)
+          if (chatItem != null) {
+            val cInfo = chatItem.chatInfo
+            val cItem = chatItem.chatItem
+            chatModel.upsertChatItem(cInfo, cItem)
+          }
         }
       }
     )
@@ -76,23 +124,62 @@ fun ChatView(chatModel: ChatModel) {
 
 @Composable
 fun ChatLayout(
-  chat: Chat, chatItems: List<ChatItem>,
+  user: User,
+  chat: Chat,
+  composeState: MutableState<ComposeState>,
+  composeView: (@Composable () -> Unit),
+  chosenImage: MutableState<Bitmap?>,
+  chosenFile: MutableState<Uri?>,
+  scope: CoroutineScope,
+  attachmentBottomSheetState: ModalBottomSheetState,
+  chatItems: List<ChatItem>,
   back: () -> Unit,
   info: () -> Unit,
-  sendMessage: (String) -> Unit
+  openDirectChat: (Long) -> Unit,
+  deleteMessage: (Long, CIDeleteMode) -> Unit,
+  receiveFile: (Long) -> Unit
 ) {
+  fun onImageChange(bitmap: Bitmap) {
+    val imagePreview = resizeImageToStrSize(bitmap, maxDataSize = 14000)
+    composeState.value = composeState.value.copy(preview = ComposePreview.ImagePreview(imagePreview))
+  }
+  fun onFileChange(uri: Uri) {
+    val fileName = getFileName(context, uri)
+    if (fileName != null) {
+      composeState.value = composeState.value.copy(preview = ComposePreview.FilePreview(fileName))
+    }
+  }
+
   Surface(
     Modifier
       .fillMaxWidth()
-      .background(MaterialTheme.colors.background)) {
+      .background(MaterialTheme.colors.background)
+  ) {
     ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
-      Scaffold(
-        topBar = { ChatInfoToolbar(chat, back, info) },
-        bottomBar = { SendMsgView(sendMessage) },
-        modifier = Modifier.navigationBarsWithImePadding()
-      ) { contentPadding ->
-        Box(Modifier.padding(contentPadding)) {
-          ChatItemsList(chatItems)
+      ModalBottomSheetLayout(
+        scrimColor = Color.Black.copy(alpha = 0.12F),
+        modifier = Modifier.navigationBarsWithImePadding(),
+        sheetContent = {
+          GetImageBottomSheet(
+            chosenImage,
+            ::onImageChange,
+            chosenFile,
+            ::onFileChange,
+            hideBottomSheet = {
+              scope.launch { attachmentBottomSheetState.hide() }
+            })
+        },
+        sheetState = attachmentBottomSheetState,
+        sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp)
+      ) {
+        Scaffold(
+          topBar = { ChatInfoToolbar(chat, back, info) },
+          bottomBar = composeView,
+          modifier = Modifier.navigationBarsWithImePadding()
+        ) { contentPadding ->
+          Box(Modifier.padding(contentPadding)) {
+            ChatItemsList(user, chat, composeState, chatItems, openDirectChat, deleteMessage, receiveFile)
+          }
         }
       }
     }
@@ -101,41 +188,51 @@ fun ChatLayout(
 
 @Composable
 fun ChatInfoToolbar(chat: Chat, back: () -> Unit, info: () -> Unit) {
-  Box(
-    Modifier
-      .height(60.dp)
-      .padding(horizontal = 8.dp),
-    contentAlignment = Alignment.CenterStart
-  ) {
-    IconButton(onClick = back) {
-      Icon(
-        Icons.Outlined.ArrowBack,
-        "Back",
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-    Row(
+  Column {
+    Box(
       Modifier
-        .padding(horizontal = 68.dp)
         .fillMaxWidth()
-        .clickable(onClick = info),
-      horizontalArrangement = Arrangement.Center,
-      verticalAlignment = Alignment.CenterVertically
+        .height(52.dp)
+        .background(if (isSystemInDarkTheme()) ToolbarDark else ToolbarLight)
+        .padding(horizontal = 8.dp),
+      contentAlignment = Alignment.CenterStart,
     ) {
-      val cInfo = chat.chatInfo
-      ChatInfoImage(chat, size = 40.dp)
-      Column(Modifier.padding(start = 8.dp),
-        horizontalAlignment = Alignment.CenterHorizontally
+      IconButton(onClick = back) {
+        Icon(
+          Icons.Outlined.ArrowBackIos,
+          stringResource(R.string.back),
+          tint = MaterialTheme.colors.primary,
+          modifier = Modifier.padding(10.dp)
+        )
+      }
+      Row(
+        Modifier
+          .padding(horizontal = 68.dp)
+          .fillMaxWidth()
+          .clickable(onClick = info),
+        horizontalArrangement = Arrangement.Center,
+        verticalAlignment = Alignment.CenterVertically
       ) {
-        Text(cInfo.displayName, fontWeight = FontWeight.Bold,
-          maxLines = 1, overflow = TextOverflow.Ellipsis)
-        if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName) {
-          Text(cInfo.fullName,
-            maxLines = 1, overflow = TextOverflow.Ellipsis)
+        val cInfo = chat.chatInfo
+        ChatInfoImage(cInfo, size = 40.dp)
+        Column(
+          Modifier.padding(start = 8.dp),
+          horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+          Text(
+            cInfo.displayName, fontWeight = FontWeight.SemiBold,
+            maxLines = 1, overflow = TextOverflow.Ellipsis
+          )
+          if (cInfo.fullName != "" && cInfo.fullName != cInfo.displayName) {
+            Text(
+              cInfo.fullName,
+              maxLines = 1, overflow = TextOverflow.Ellipsis
+            )
+          }
         }
       }
     }
+    Divider()
   }
 }
 
@@ -152,20 +249,72 @@ val CIListStateSaver = run {
 }
 
 @Composable
-fun ChatItemsList(chatItems: List<ChatItem>) {
-  val listState = rememberLazyListState()
+fun ChatItemsList(
+  user: User,
+  chat: Chat,
+  composeState: MutableState<ComposeState>,
+  chatItems: List<ChatItem>,
+  openDirectChat: (Long) -> Unit,
+  deleteMessage: (Long, CIDeleteMode) -> Unit,
+  receiveFile: (Long) -> Unit
+) {
+  val listState = rememberLazyListState(initialFirstVisibleItemIndex = chatItems.size - chatItems.count { it.isRcvNew })
   val keyboardState by getKeyboardState()
   val ciListState = rememberSaveable(stateSaver = CIListStateSaver) {
     mutableStateOf(CIListState(false, chatItems.count(), keyboardState))
   }
   val scope = rememberCoroutineScope()
   val uriHandler = LocalUriHandler.current
+  val cxt = LocalContext.current
   LazyColumn(state = listState) {
-    items(chatItems) { cItem ->
-      ChatItemView(cItem, uriHandler)
+    itemsIndexed(chatItems) { i, cItem ->
+      if (i == 0) {
+        Spacer(Modifier.size(8.dp))
+      }
+      if (chat.chatInfo is ChatInfo.Group) {
+        if (cItem.chatDir is CIDirection.GroupRcv) {
+          val prevItem = if (i > 0) chatItems[i - 1] else null
+          val member = cItem.chatDir.groupMember
+          val showMember = showMemberImage(member, prevItem)
+          Row(Modifier.padding(start = 8.dp, end = 66.dp)) {
+            if (showMember) {
+              val contactId = member.memberContactId
+              if (contactId == null) {
+                MemberImage(member)
+              } else {
+                Box(
+                  Modifier
+                    .clip(CircleShape)
+                    .clickable { openDirectChat(contactId) }
+                ) {
+                  MemberImage(member)
+                }
+              }
+              Spacer(Modifier.size(4.dp))
+            } else {
+              Spacer(Modifier.size(42.dp))
+            }
+            ChatItemView(user, cItem, composeState, cxt, uriHandler, showMember = showMember, deleteMessage = deleteMessage, receiveFile = receiveFile)
+          }
+        } else {
+          Box(Modifier.padding(start = 86.dp, end = 12.dp)) {
+            ChatItemView(user, cItem, composeState, cxt, uriHandler, deleteMessage = deleteMessage, receiveFile = receiveFile)
+          }
+        }
+      } else { // direct message
+        val sent = cItem.chatDir.sent
+        Box(
+          Modifier.padding(
+            start = if (sent) 76.dp else 12.dp,
+            end = if (sent) 12.dp else 76.dp,
+          )
+        ) {
+          ChatItemView(user, cItem, composeState, cxt, uriHandler, deleteMessage = deleteMessage, receiveFile = receiveFile)
+        }
+      }
     }
     val len = chatItems.count()
-    if (keyboardState != ciListState.value.keyboardState || !ciListState.value.scrolled || len != ciListState.value.itemCount) {
+    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)
@@ -174,6 +323,16 @@ fun ChatItemsList(chatItems: List<ChatItem>) {
   }
 }
 
+fun showMemberImage(member: GroupMember, prevItem: ChatItem?): Boolean {
+  return prevItem == null || prevItem.chatDir is CIDirection.GroupSnd ||
+      (prevItem.chatDir is CIDirection.GroupRcv && prevItem.chatDir.groupMember.groupMemberId != member.groupMemberId)
+}
+
+@Composable
+fun MemberImage(member: GroupMember) {
+  ProfileImage(38.dp, member.memberProfile.image)
+}
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,
@@ -190,26 +349,81 @@ fun PreviewChatLayout() {
       ChatItem.getSampleData(
         2, CIDirection.DirectRcv(), Clock.System.now(), "hello"
       ),
-      ChatItem.getSampleData(
-        3, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      ),
+      ChatItem.getDeletedContentSampleData(3),
       ChatItem.getSampleData(
         4, CIDirection.DirectSnd(), Clock.System.now(), "hello"
       ),
       ChatItem.getSampleData(
-        5, CIDirection.DirectRcv(), Clock.System.now(), "hello"
+        5, CIDirection.DirectSnd(), Clock.System.now(), "hello"
+      ),
+      ChatItem.getSampleData(
+        6, CIDirection.DirectRcv(), Clock.System.now(), "hello"
       )
     )
     ChatLayout(
+      user = User.sampleData,
       chat = Chat(
         chatInfo = ChatInfo.Direct.sampleData,
         chatItems = chatItems,
         chatStats = Chat.ChatStats()
       ),
+      composeState = remember { mutableStateOf(ComposeState()) },
+      composeView = {},
+      chosenFile = remember { mutableStateOf(null) },
+      chosenImage = remember { mutableStateOf(null) },
+      scope = rememberCoroutineScope(),
+      attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
       chatItems = chatItems,
       back = {},
       info = {},
-      sendMessage = {}
+      openDirectChat = {},
+      deleteMessage = { _, _ -> },
+      receiveFile = {}
+    )
+  }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun PreviewGroupChatLayout() {
+  SimpleXTheme {
+    val chatItems = listOf(
+      ChatItem.getSampleData(
+        1, CIDirection.GroupSnd(), Clock.System.now(), "hello"
+      ),
+      ChatItem.getSampleData(
+        2, CIDirection.GroupRcv(GroupMember.sampleData), Clock.System.now(), "hello"
+      ),
+      ChatItem.getDeletedContentSampleData(3),
+      ChatItem.getSampleData(
+        4, CIDirection.GroupRcv(GroupMember.sampleData), Clock.System.now(), "hello"
+      ),
+      ChatItem.getSampleData(
+        5, CIDirection.GroupSnd(), Clock.System.now(), "hello"
+      ),
+      ChatItem.getSampleData(
+        6, CIDirection.GroupRcv(GroupMember.sampleData), Clock.System.now(), "hello"
+      )
+    )
+    ChatLayout(
+      user = User.sampleData,
+      chat = Chat(
+        chatInfo = ChatInfo.Group.sampleData,
+        chatItems = chatItems,
+        chatStats = Chat.ChatStats()
+      ),
+      composeState = remember { mutableStateOf(ComposeState()) },
+      composeView = {},
+      chosenImage = remember { mutableStateOf(null) },
+      chosenFile = remember { mutableStateOf(null) },
+      scope = rememberCoroutineScope(),
+      attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
+      chatItems = chatItems,
+      back = {},
+      info = {},
+      openDirectChat = {},
+      deleteMessage = { _, _ -> },
+      receiveFile = {}
     )
   }
 }

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

@@ -0,0 +1,61 @@
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.*
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+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 (isSystemInDarkTheme()) 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

@@ -0,0 +1,361 @@
+package chat.simplex.app.views.chat
+
+import ComposeFileView
+import ComposeImageView
+import android.graphics.Bitmap
+import android.net.Uri
+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 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
+
+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
+) {
+  constructor(editingItem: ChatItem): this(
+    editingItem.content.text,
+    chatItemPreview(editingItem),
+    ComposeContextItem.EditingItem(editingItem)
+  )
+
+  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 -> true
+      }
+  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(
+  chatModel: ChatModel,
+  chat: Chat,
+  composeState: MutableState<ComposeState>,
+  chosenImage: MutableState<Bitmap?>,
+  chosenFile: MutableState<Uri?>,
+  showAttachmentBottomSheet: () -> Unit
+) {
+  val context = LocalContext.current
+  val linkUrl = remember { mutableStateOf<String?>(null) }
+  val prevLinkUrl = remember { mutableStateOf<String?>(null) }
+  val pendingLinkUrl = remember { mutableStateOf<String?>(null) }
+  val cancelledLinks = remember { mutableSetOf<String>() }
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+
+  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) {
+      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 (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()
+    chosenImage.value = null
+    chosenFile.value = null
+    linkUrl.value = null
+    prevLinkUrl.value = null
+    pendingLinkUrl.value = null
+    cancelledLinks.clear()
+  }
+
+  fun sendMessage() {
+    withApi {
+      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) {
+            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)
+          }
+        }
+        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) {
+            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()
+    }
+  }
+
+  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)
+    }
+    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) {
+                showAttachmentBottomSheet()
+              }
+            }
+        )
+      }
+      SendMsgView(
+        composeState,
+        sendMessage = {
+          sendMessage()
+          resetLinkPreview()
+        },
+        ::onMessageChange,
+        textStyle
+      )
+    }
+  }
+}

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

@@ -0,0 +1,92 @@
+package chat.simplex.app.views.chat
+
+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.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.buildAnnotatedString
+import androidx.compose.ui.text.withStyle
+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: ChatItem,
+  contextIcon: ImageVector,
+  cancelContextItem: () -> Unit
+) {
+  val sent = contextItem.chatDir.sent
+  Row(
+    Modifier
+      .padding(top = 8.dp)
+      .background(if (sent) SentColorLight else ReceivedColorLight),
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Row(
+      Modifier
+        .padding(vertical = 12.dp)
+        .fillMaxWidth()
+        .weight(1F),
+      verticalAlignment = Alignment.CenterVertically
+    ) {
+      Icon(
+        contextIcon,
+        modifier = Modifier
+          .padding(horizontal = 8.dp)
+          .height(20.dp)
+          .width(20.dp),
+        contentDescription = stringResource(R.string.icon_descr_context),
+        tint = HighOrLowlight,
+      )
+      ContextItemText(contextItem)
+    }
+    IconButton(onClick = cancelContextItem) {
+      Icon(
+        Icons.Outlined.Close,
+        contentDescription = stringResource(R.string.cancel_verb),
+        tint = MaterialTheme.colors.primary,
+        modifier = Modifier.padding(10.dp)
+      )
+    }
+  }
+}
+
+@Composable
+private fun ContextItemText(cxtItem: ChatItem) {
+  val member = cxtItem.memberDisplayName
+  if (member == null) {
+    Text(cxtItem.text, maxLines = 3)
+  } else {
+    val annotatedText = buildAnnotatedString {
+      withStyle(boldFont) { append(member) }
+      append(": ${cxtItem.text}")
+    }
+    Text(annotatedText, maxLines = 3)
+  }
+}
+
+@Preview
+@Composable
+fun PreviewContextItemView() {
+  SimpleXTheme {
+    ContextItemView(
+      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

@@ -9,6 +9,7 @@ import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Check
 import androidx.compose.material.icons.outlined.ArrowUpward
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
@@ -16,25 +17,34 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.SolidColor
+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
 
 @Composable
-fun SendMsgView(sendMessage: (String) -> Unit) {
-  var cmd by remember { mutableStateOf("") }
+fun SendMsgView(
+  composeState: MutableState<ComposeState>,
+  sendMessage: () -> Unit,
+  onMessageChange: (String) -> Unit,
+  textStyle: MutableState<TextStyle>
+) {
+  val cs = composeState.value
   BasicTextField(
-    value = cmd,
-    onValueChange = { cmd = it },
-    textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
+    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),
     cursorBrush = SolidColor(HighOrLowlight),
     decorationBox = { innerTextField ->
       Surface(
@@ -54,23 +64,35 @@ fun SendMsgView(sendMessage: (String) -> Unit) {
           ) {
             innerTextField()
           }
-          val color = if (cmd.isNotEmpty()) MaterialTheme.colors.primary else Color.Gray
-          Icon(
-            Icons.Outlined.ArrowUpward,
-            "Send Message",
-            tint = Color.White,
-            modifier = Modifier
-              .size(36.dp)
-              .padding(4.dp)
-              .clip(CircleShape)
-              .background(color)
-              .clickable {
-                if (cmd.isNotEmpty()) {
-                  sendMessage(cmd)
-                  cmd = ""
+          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()
+                  }
                 }
-              }
-          )
+            )
+          }
         }
       }
     }
@@ -85,9 +107,56 @@ fun SendMsgView(sendMessage: (String) -> Unit) {
 )
 @Composable
 fun PreviewSendMsgView() {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
   SimpleXTheme {
     SendMsgView(
-      sendMessage = { msg -> println(msg) }
+      composeState = remember { mutableStateOf(ComposeState()) },
+      sendMessage = {},
+      onMessageChange = { _ -> },
+      textStyle = textStyle
+    )
+  }
+}
+
+@Preview(showBackground = true)
+@Preview(
+  uiMode = Configuration.UI_MODE_NIGHT_YES,
+  showBackground = true,
+  name = "Dark Mode"
+)
+@Composable
+fun PreviewSendMsgViewEditing() {
+  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
+  val textStyle = remember { mutableStateOf(smallFont) }
+  val composeStateEditing = ComposeState(editingItem = ChatItem.getSampleData())
+  SimpleXTheme {
+    SendMsgView(
+      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)
+  SimpleXTheme {
+    SendMsgView(
+      composeState = remember { mutableStateOf(composeStateInProgress) },
+      sendMessage = {},
+      onMessageChange = { _ -> },
+      textStyle = textStyle
     )
   }
 }

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

@@ -0,0 +1,211 @@
+package chat.simplex.app.views.chat.item
+
+import android.widget.Toast
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+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 (isSystemInDarkTheme()) 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 (isSystemInDarkTheme()) 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 PreviewTextItemViewSnd(@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/CIImageView.kt

@@ -0,0 +1,110 @@
+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>
+) {
+  @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 && file.fileStatus == CIFileStatus.RcvAccepted)
+          AlertManager.shared.showAlertMsg(
+            generalGetString(R.string.waiting_for_image),
+            generalGetString(R.string.image_will_be_received_when_contact_is_online)
+          )
+      })
+    }
+    loadingIndicator()
+  }
+}

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

@@ -1,21 +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.icons.Icons
+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 chat.simplex.app.ui.theme.SimplexBlue
 import kotlinx.datetime.Clock
 
 @Composable
-fun CIMetaView(chatItem: ChatItem) {
-  Text(
-    chatItem.timestampText,
-    color = HighOrLowlight,
-    fontSize = 14.sp
-  )
+fun CIMetaView(chatItem: ChatItem, metaColor: Color = HighOrLowlight) {
+  Row(verticalAlignment = Alignment.CenterVertically) {
+    if (!chatItem.isDeletedContent) {
+      if (chatItem.meta.itemEdited) {
+        Icon(
+          Icons.Filled.Edit,
+          modifier = Modifier.height(12.dp).padding(end = 1.dp),
+          contentDescription = stringResource(R.string.icon_descr_edited),
+          tint = metaColor,
+        )
+      }
+      CIStatusView(chatItem.meta.itemStatus, metaColor)
+    }
+    Text(
+      chatItem.timestampText,
+      color = metaColor,
+      fontSize = 14.sp,
+      modifier = Modifier.padding(start = 3.dp)
+    )
+  }
+}
+
+
+@Composable
+fun CIStatusView(status: CIStatus, metaColor: Color = HighOrLowlight) {
+  when (status) {
+    is CIStatus.SndSent -> {
+      Icon(Icons.Filled.Check, stringResource(R.string.icon_descr_sent_msg_status_sent), Modifier.height(12.dp), tint = metaColor)
+    }
+    is CIStatus.SndErrorAuth -> {
+      Icon(Icons.Filled.Close,  stringResource(R.string.icon_descr_sent_msg_status_unauthorized_send), Modifier.height(12.dp), tint = Color.Red)
+    }
+    is CIStatus.SndError -> {
+      Icon(Icons.Filled.WarningAmber, stringResource(R.string.icon_descr_sent_msg_status_send_failed), Modifier.height(12.dp), tint = Color.Yellow)
+    }
+    is CIStatus.RcvNew -> {
+      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_received_msg_status_unread), Modifier.height(12.dp), tint = SimplexBlue)
+    }
+    else -> {}
+  }
 }
 
 @Preview
@@ -27,3 +71,88 @@ 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() {
+  CIMetaView(
+    chatItem = ChatItem.getSampleData(
+      1, CIDirection.DirectSnd(), Clock.System.now(), "hello",
+      itemEdited = true
+    )
+  )
+}
+
+@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() {
+  CIMetaView(
+    chatItem = ChatItem.getDeletedContentSampleData()
+  )
+}

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

@@ -1,44 +1,197 @@
 package chat.simplex.app.views.chat.item
 
+import android.content.Context
+import androidx.compose.foundation.combinedClickable
 import androidx.compose.foundation.layout.*
-import androidx.compose.runtime.Composable
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Edit
+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.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-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.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(chatItem: ChatItem, uriHandler: UriHandler? = null) {
-  val sent = chatItem.chatDir.sent
+fun ChatItemView(
+  user: User,
+  cItem: ChatItem,
+  composeState: MutableState<ComposeState>,
+  cxt: Context,
+  uriHandler: UriHandler? = null,
+  showMember: Boolean = false,
+  deleteMessage: (Long, CIDeleteMode) -> Unit,
+  receiveFile: (Long) -> Unit
+) {
+  val context = LocalContext.current
+  val sent = cItem.chatDir.sent
   val alignment = if (sent) Alignment.CenterEnd else Alignment.CenterStart
-
+  val showMenu = remember { mutableStateOf(false) }
+  val saveFileLauncher = rememberSaveFileLauncher(cxt = context, ciFile = cItem.file)
   Box(
     modifier = Modifier
       .padding(bottom = 4.dp)
-      .fillMaxWidth()
-      .padding(
-        start = if (sent) 60.dp else 16.dp,
-        end = if (sent) 16.dp else 60.dp,
-      ),
+      .fillMaxWidth(),
     contentAlignment = alignment,
   ) {
-    TextItemView(chatItem, uriHandler)
+    Column(
+      Modifier
+        .clip(RoundedCornerShape(18.dp))
+        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
+    ) {
+      if (cItem.isMsgContent) {
+        if (cItem.file == null && cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
+          EmojiItemView(cItem)
+        } else {
+          FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile)
+        }
+      } else if (cItem.isDeletedContent) {
+        DeletedItemView(cItem, showMember = showMember)
+      } else if (cItem.isCall) {
+        FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile)
+      }
+      if (cItem.isMsgContent) {
+        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))
+            } else {
+              composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
+            }
+            showMenu.value = false
+          })
+          ItemAction(stringResource(R.string.share_verb), Icons.Outlined.Share, onClick = {
+            shareText(cxt, cItem.content.text)
+            showMenu.value = false
+          })
+          ItemAction(stringResource(R.string.copy_verb), Icons.Outlined.ContentCopy, onClick = {
+            copyText(cxt, cItem.content.text)
+            showMenu.value = false
+          })
+          if (cItem.content.msgContent is MsgContent.MCImage || cItem.content.msgContent is MsgContent.MCFile) {
+            val filePath = getLoadedFilePath(context, cItem.file)
+            if (filePath != null) {
+              ItemAction(stringResource(R.string.save_verb), Icons.Outlined.SaveAlt, onClick = {
+                when (cItem.content.msgContent) {
+                  is MsgContent.MCImage -> saveImage(context, cItem.file)
+                  is MsgContent.MCFile -> saveFileLauncher.launch(cItem.file?.fileName)
+                  else -> {}
+                }
+                showMenu.value = false
+              })
+            }
+          }
+          if (cItem.chatDir.sent && cItem.meta.editable) {
+            ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
+              composeState.value = ComposeState(editingItem = cItem)
+              showMenu.value = false
+            })
+          }
+          ItemAction(
+            stringResource(R.string.delete_verb),
+            Icons.Outlined.Delete,
+            onClick = {
+              showMenu.value = false
+              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
+            },
+            color = Color.Red
+          )
+        }
+      }
+    }
   }
 }
 
+@Composable
+fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Color = MaterialTheme.colors.onBackground) {
+  DropdownMenuItem(onClick) {
+    Row {
+      Text(
+        text,
+        modifier = Modifier
+          .fillMaxWidth()
+          .weight(1F),
+        color = color
+      )
+      Icon(icon, text, tint = color)
+    }
+  }
+}
+
+fun deleteMessageAlertDialog(chatItem: ChatItem, deleteMessage: (Long, CIDeleteMode) -> Unit) {
+  AlertManager.shared.showAlertDialogButtons(
+    title = generalGetString(R.string.delete_message__question),
+    text = generalGetString(R.string.delete_message_cannot_be_undone_warning),
+    buttons = {
+      Row(
+        Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 8.dp, vertical = 2.dp),
+        horizontalArrangement = Arrangement.End,
+      ) {
+        Button(onClick = {
+          deleteMessage(chatItem.id, CIDeleteMode.cidmInternal)
+          AlertManager.shared.hideAlert()
+        }) { Text(stringResource(R.string.for_me_only)) }
+        if (chatItem.meta.editable) {
+          Spacer(Modifier.padding(horizontal = 4.dp))
+          Button(onClick = {
+            deleteMessage(chatItem.id, CIDeleteMode.cidmBroadcast)
+            AlertManager.shared.hideAlert()
+          }) { Text(stringResource(R.string.for_everybody)) }
+        }
+      }
+    }
+  )
+}
+
 @Preview
 @Composable
 fun PreviewChatItemView() {
   SimpleXTheme {
     ChatItemView(
-      chatItem = ChatItem.getSampleData(
+      User.sampleData,
+      ChatItem.getSampleData(
         1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      )
+      ),
+      composeState = remember { mutableStateOf(ComposeState()) },
+      cxt = LocalContext.current,
+      deleteMessage = { _, _ -> },
+      receiveFile = {}
+    )
+  }
+}
+
+@Preview
+@Composable
+fun PreviewChatItemViewDeletedContent() {
+  SimpleXTheme {
+    ChatItemView(
+      User.sampleData,
+      ChatItem.getDeletedContentSampleData(),
+      composeState = remember { mutableStateOf(ComposeState()) },
+      cxt = LocalContext.current,
+      deleteMessage = { _, _ -> },
+      receiveFile = {}
     )
   }
 }

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

@@ -0,0 +1,55 @@
+package chat.simplex.app.views.chat.item
+
+import android.content.res.Configuration
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.*
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.*
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.model.ChatItem
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleXTheme
+
+@Composable
+fun DeletedItemView(ci: ChatItem, showMember: Boolean = false) {
+  Surface(
+    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 = HighOrLowlight)) { 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 PreviewDeletedItemView() {
+  SimpleXTheme {
+    DeletedItemView(
+      ChatItem.getDeletedContentSampleData()
+    )
+  }
+}

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

@@ -0,0 +1,42 @@
+package chat.simplex.app.views.chat.item
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import chat.simplex.app.model.ChatItem
+
+val largeEmojiFont: TextStyle = TextStyle(fontSize = 48.sp)
+val mediumEmojiFont: TextStyle = TextStyle(fontSize = 36.sp)
+
+@Composable
+fun EmojiItemView(chatItem: ChatItem) {
+  Column(
+    Modifier.padding(vertical = 8.dp, horizontal = 12.dp),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    EmojiText(chatItem.content.text)
+    CIMetaView(chatItem)
+  }
+}
+
+@Composable
+fun EmojiText(text: String) {
+  val s = text.trim()
+  Text(s, style = if (s.codePoints().count() < 4) largeEmojiFont else mediumEmojiFont)
+}
+
+private fun isSimpleEmoji(c: Int): Boolean = c > 0x238C
+
+fun isEmoji(c: Int): Boolean = isSimpleEmoji(c) // || isCombinedIntoEmoji(c)
+
+// TODO count perceived emojis, possibly using icu4j
+fun isShortEmoji(str: String): Boolean {
+  val s = str.trim()
+  return s.codePoints().count() in 1..5 && s.codePoints().allMatch(::isEmoji)
+}

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

@@ -0,0 +1,30 @@
+import android.graphics.Bitmap
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.*
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+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.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)
+  ) {
+    Image(
+      imageBitmap.asImageBitmap(),
+      contentDescription = stringResource(R.string.image_descr),
+      modifier = Modifier.fillMaxSize(),
+      contentScale = ContentScale.Fit,
+    )
+  }
+}

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

@@ -1,48 +1,17 @@
 package chat.simplex.app.views.chat.item
 
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.ClickableText
-import androidx.compose.foundation.text.selection.SelectionContainer
-import androidx.compose.material.*
+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.graphics.Color
 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.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.ui.theme.SimpleXTheme
-import kotlinx.datetime.Clock
-
-// TODO move to theme
-val SentColorLight = Color(0x1E45B8FF)
-val ReceivedColorLight = Color(0x1EB1B0B5)
-
-@Composable
-fun TextItemView(chatItem: ChatItem, uriHandler: UriHandler? = null) {
-  val sent = chatItem.chatDir.sent
-  Surface(
-    shape = RoundedCornerShape(18.dp),
-    color = if (sent) SentColorLight else ReceivedColorLight
-  ) {
-    Box(
-      modifier = Modifier.padding(vertical = 6.dp, horizontal = 12.dp)
-    ) {
-      Box(contentAlignment = Alignment.BottomEnd) {
-        MarkdownText(chatItem, uriHandler = uriHandler, groupMemberBold = true)
-        CIMetaView(chatItem)
-      }
-    }
-  }
-}
+import chat.simplex.app.model.*
 
 val reserveTimestampStyle = SpanStyle(color = Color.Transparent)
 val boldFont = SpanStyle(fontWeight = FontWeight.Medium)
@@ -56,33 +25,46 @@ fun appendGroupMember(b: AnnotatedString.Builder, chatItem: ChatItem, groupMembe
   }
 }
 
+fun appendSender(b: AnnotatedString.Builder, sender: String?, senderBold: Boolean) {
+  if (sender != null) {
+    if (senderBold) b.withStyle(boldFont) { append(sender) }
+    else b.append(sender)
+    b.append(": ")
+  }
+}
+
 @Composable
 fun MarkdownText (
-  chatItem: ChatItem,
+  text: String,
+  formattedText: List<FormattedText>? = null,
+  sender: String? = null,
+  metaText: String? = null,
+  edited: Boolean = false,
   style: TextStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onSurface, lineHeight = 22.sp),
   maxLines: Int = Int.MAX_VALUE,
   overflow: TextOverflow = TextOverflow.Clip,
   uriHandler: UriHandler? = null,
-  groupMemberBold: Boolean = false,
+  senderBold: Boolean = false,
   modifier: Modifier = Modifier
 ) {
-  if (chatItem.formattedText == null) {
+  val reserve = if (edited) "        " else "    "
+  if (formattedText == null) {
     val annotatedText = buildAnnotatedString {
-      appendGroupMember(this, chatItem, groupMemberBold)
-      append(chatItem.content.text)
-      withStyle(reserveTimestampStyle) { append("  ${chatItem.timestampText}") }
-    }
-    SelectionContainer {
-      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
+      appendSender(this, sender, senderBold)
+      append(text)
+      if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
     }
+    Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
   } else {
+    var hasLinks = false
     val annotatedText = buildAnnotatedString {
-      appendGroupMember(this, chatItem, groupMemberBold)
-      for (ft in chatItem.formattedText) {
+      appendSender(this, sender, senderBold)
+      for (ft in formattedText) {
         if (ft.format == null) append(ft.text)
         else {
           val link = ft.link
           if (link != null) {
+            hasLinks = true
             withAnnotation(tag = "URL", annotation = link) {
               withStyle(ft.format.style) { append(ft.text) }
             }
@@ -91,60 +73,17 @@ fun MarkdownText (
           }
         }
       }
-      withStyle(reserveTimestampStyle) { append("  ${chatItem.timestampText}") }
+      if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
     }
-    if (uriHandler != null) {
-      SelectionContainer {
-        ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
-          onClick = { offset ->
-            annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
-              .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
-          }
-        )
-      }
+    if (hasLinks && uriHandler != null) {
+      ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
+        onClick = { offset ->
+          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
+            .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
+        }
+      )
     } else {
-      SelectionContainer {
-        Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
-      }
+      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
     }
   }
 }
-
-@Preview
-@Composable
-fun PreviewTextItemViewSnd() {
-  SimpleXTheme {
-    TextItemView(
-      chatItem = ChatItem.getSampleData(
-        1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      )
-    )
-  }
-}
-
-@Preview
-@Composable
-fun PreviewTextItemViewRcv() {
-  SimpleXTheme {
-    TextItemView(
-      chatItem = ChatItem.getSampleData(
-        1, CIDirection.DirectRcv(), Clock.System.now(), "hello"
-      )
-    )
-  }
-}
-
-@Preview
-@Composable
-fun PreviewTextItemViewLong() {
-  SimpleXTheme {
-    TextItemView(
-      chatItem = 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. 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."
-      )
-    )
-  }
-}

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 team")
-        }
-        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,21 +1,23 @@
 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.outlined.Delete
+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.views.chat.item.ItemAction
+import chat.simplex.app.views.helpers.*
 import kotlinx.datetime.Clock
 
 @Composable
@@ -23,28 +25,51 @@ 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) }
+      when (chat.chatInfo) {
+        is ChatInfo.ContactRequest -> contactRequestAlertDialog(chat.chatInfo, chatModel)
+        is ChatInfo.ContactConnection -> contactConnectionAlertDialog(chat.chatInfo.contactConnection, chatModel)
+        else ->
+          if (chat.chatInfo.ready) {
+            withApi { openChat(chatModel, chat.chatInfo) }
+          } else {
+            pendingContactAlertDialog(chat.chatInfo, chatModel)
+          }
       }
-    }
+    },
+    deleteContact = {
+      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 = {
+          val cInfo = chat.chatInfo
+          withApi {
+            val r = chatModel.controller.apiDeleteChat(cInfo.chatType, cInfo.apiId)
+            if (r) {
+              chatModel.removeChat(cInfo.id)
+              chatModel.chatId.value = null
+            }
+          }
+        }
+      )
+    },
   )
 }
 
 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.chatItems.clear()
+    chatModel.chatItems.addAll(chat.chatItems)
     chatModel.chatId.value = cInfo.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",
+    title = generalGetString(R.string.accept_connection_request__question),
+    text = generalGetString(R.string.if_you_choose_to_reject_the_sender_will_not_be_notified),
+    confirmText = generalGetString(R.string.accept_contact_button),
     onConfirm = {
       withApi {
         val contact = chatModel.controller.apiAcceptContactRequest(contactRequest.apiId)
@@ -54,7 +79,7 @@ fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel
         }
       }
     },
-    dismissText = "Reject",
+    dismissText = generalGetString(R.string.reject_contact_button),
     onDismiss = {
       withApi {
         chatModel.controller.apiRejectContactRequest(contactRequest.apiId)
@@ -64,12 +89,85 @@ fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel
   )
 }
 
+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,
+      ) {
+        Button(onClick = {
+          AlertManager.shared.hideAlert()
+          deleteContactConnectionAlert(connection, chatModel)
+        }) {
+          Text(stringResource(R.string.delete_verb))
+        }
+        Spacer(Modifier.padding(horizontal = 4.dp))
+        Button(onClick = { AlertManager.shared.hideAlert() }) {
+          Text(stringResource(R.string.ok))
+        }
+      }
+    }
+  )
+}
+
+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),
+  )
+}
+
 @Composable
-fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit) {
+fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit, deleteContact: () -> Unit) {
+  val showMenu = remember { mutableStateOf(false) }
   Surface(
     modifier = Modifier
       .fillMaxWidth()
-      .clickable(onClick = click)
+      .combinedClickable(
+        onClick = click,
+        onLongClick = { if (chat.chatInfo is ChatInfo.Direct) showMenu.value = true }
+      )
       .height(88.dp)
   ) {
     Row(
@@ -80,10 +178,28 @@ fun ChatListNavLinkLayout(chat: Chat, click: () -> Unit) {
         .padding(end = 12.dp),
       verticalAlignment = Alignment.Top
     ) {
-      if (chat.chatInfo is ChatInfo.ContactRequest) {
-        ContactRequestView(chat)
-      } else {
-        ChatPreviewView(chat)
+      when (chat.chatInfo) {
+        is ChatInfo.Direct -> ChatPreviewView(chat)
+        is ChatInfo.Group -> ChatPreviewView(chat)
+        is ChatInfo.ContactRequest -> ContactRequestView(chat.chatInfo)
+        is ChatInfo.ContactConnection -> ContactConnectionView(chat.chatInfo.contactConnection)
+      }
+    }
+    if (chat.chatInfo is ChatInfo.Direct) {
+      DropdownMenu(
+        expanded = showMenu.value,
+        onDismissRequest = { showMenu.value = false },
+        Modifier.width(220.dp)
+      ) {
+        ItemAction(
+          stringResource(R.string.delete_verb),
+          Icons.Outlined.Delete,
+          onClick = {
+            deleteContact()
+            showMenu.value = false
+          },
+          color = Color.Red
+        )
       }
     }
   }
@@ -112,7 +228,8 @@ fun PreviewChatListNavLinkDirect() {
         ),
         chatStats = Chat.ChatStats()
       ),
-      click = {}
+      click = {},
+      deleteContact = {}
     )
   }
 }
@@ -139,7 +256,8 @@ fun PreviewChatListNavLinkGroup() {
         ),
         chatStats = Chat.ChatStats()
       ),
-      click = {}
+      click = {},
+      deleteContact = {}
     )
   }
 }
@@ -159,7 +277,8 @@ fun PreviewChatListNavLinkContactRequest() {
         chatItems = listOf(),
         chatStats = Chat.ChatStats()
       ),
-      click = {}
+      click = {},
+      deleteContact = {}
     )
   }
 }

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

@@ -1,7 +1,6 @@
 package chat.simplex.app.views.chatlist
 
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
+import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
@@ -13,11 +12,16 @@ 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.views.chat.ChatHelpView
+import chat.simplex.app.ui.theme.ToolbarDark
+import chat.simplex.app.ui.theme.ToolbarLight
+import chat.simplex.app.views.helpers.ModalManager
 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
@@ -62,6 +66,11 @@ fun scaffoldController(): ScaffoldController {
 @Composable
 fun ChatListView(chatModel: ChatModel) {
   val scaffoldCtrl = scaffoldController()
+  if (chatModel.clearOverlays.value) {
+    scaffoldCtrl.collapse()
+    ModalManager.shared.closeModal()
+    chatModel.clearOverlays.value = false
+  }
   BottomSheetScaffold(
     scaffoldState = scaffoldCtrl.state,
     drawerContent = { SettingsView(chatModel) },
@@ -76,11 +85,11 @@ fun ChatListView(chatModel: ChatModel) {
           .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) {
@@ -99,28 +108,32 @@ fun ChatListView(chatModel: ChatModel) {
 fun Help(scaffoldCtrl: ScaffoldController, displayName: String?) {
   Column(
     Modifier
+      .verticalScroll(rememberScrollState())
       .fillMaxWidth()
-      .padding(8.dp)
+      .padding(16.dp)
   ) {
+    val welcomeMsg = if (displayName != null) {
+      String.format(stringResource(R.string.personal_welcome), displayName)
+    } else stringResource(R.string.welcome)
     Text(
-      text = if (displayName != null) "Welcome ${displayName}!" else "Welcome!",
+      text = welcomeMsg,
       Modifier.padding(bottom = 24.dp),
       style = MaterialTheme.typography.h1,
       color = MaterialTheme.colors.onBackground
     )
-    ChatHelpView({ scaffoldCtrl.toggleSheet() })
+    ChatHelpView { scaffoldCtrl.toggleSheet() }
     Row(
       Modifier.padding(top = 30.dp),
       verticalAlignment = Alignment.CenterVertically,
       horizontalArrangement = Arrangement.spacedBy(8.dp)
     ) {
       Text(
-        "This text is available in settings",
+        stringResource(R.string.this_text_is_available_in_settings),
         color = MaterialTheme.colors.onBackground
       )
       Icon(
         Icons.Outlined.Settings,
-        "Settings",
+        stringResource(R.string.icon_descr_settings),
         tint = MaterialTheme.colors.onBackground,
         modifier = Modifier.clickable(onClick = { scaffoldCtrl.toggleDrawer() })
       )
@@ -135,27 +148,28 @@ fun ChatListToolbar(scaffoldCtrl: ScaffoldController) {
     verticalAlignment = Alignment.CenterVertically,
     modifier = Modifier
       .fillMaxWidth()
+      .height(52.dp)
+      .background(if (isSystemInDarkTheme()) ToolbarDark else ToolbarLight)
       .padding(horizontal = 8.dp)
-      .height(60.dp)
   ) {
     IconButton(onClick = { scaffoldCtrl.toggleDrawer() }) {
       Icon(
         Icons.Outlined.Menu,
-        "Settings",
+        stringResource(R.string.icon_descr_settings),
         tint = MaterialTheme.colors.primary,
         modifier = Modifier.padding(10.dp)
       )
     }
     Text(
-      "Your chats",
+      stringResource(R.string.your_chats),
       color = MaterialTheme.colors.onBackground,
-      fontWeight = FontWeight.Bold,
+      fontWeight = FontWeight.SemiBold,
       modifier = Modifier.padding(5.dp)
     )
     IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
       Icon(
         Icons.Outlined.PersonAdd,
-        "Add Contact",
+        stringResource(R.string.add_contact),
         tint = MaterialTheme.colors.primary,
         modifier = Modifier.padding(10.dp)
       )
@@ -165,7 +179,6 @@ fun ChatListToolbar(scaffoldCtrl: ScaffoldController) {
 
 @Composable
 fun ChatList(chatModel: ChatModel) {
-  Divider(Modifier.padding(horizontal = 8.dp))
   LazyColumn(
     modifier = Modifier.fillMaxWidth()
   ) {

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

@@ -4,18 +4,22 @@ 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.Circle
+import androidx.compose.material.icons.filled.MoreHoriz
 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.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.item.MarkdownText
@@ -25,26 +29,38 @@ import chat.simplex.app.views.helpers.badgeLayout
 @Composable
 fun ChatPreviewView(chat: Chat) {
   Row {
-    ChatInfoImage(chat, size = 72.dp)
+    val cInfo = chat.chatInfo
+    Box(contentAlignment = Alignment.BottomStart) {
+      ChatInfoImage(cInfo, size = 72.dp)
+      if (cInfo is ChatInfo.Direct) {
+        ChatStatusImage(chat)
+      }
+    }
     Column(
       modifier = Modifier
         .padding(horizontal = 8.dp)
         .weight(1F)
     ) {
       Text(
-        chat.chatInfo.chatViewName,
+        cInfo.chatViewName,
         maxLines = 1,
         overflow = TextOverflow.Ellipsis,
         style = MaterialTheme.typography.h3,
-        fontWeight = FontWeight.Bold
+        fontWeight = FontWeight.Bold,
+        color = if (cInfo.ready) Color.Unspecified else HighOrLowlight
       )
-
-      if (chat.chatItems.count() > 0) {
-        MarkdownText(
-          chat.chatItems.last(),
-          maxLines = 2,
-          overflow = TextOverflow.Ellipsis
-        )
+      if (cInfo.ready) {
+        val ci = chat.chatItems.lastOrNull()
+        if (ci != null) {
+          MarkdownText(
+            ci.text, ci.formattedText, ci.memberDisplayName,
+            metaText = ci.timestampText,
+            maxLines = 2,
+            overflow = TextOverflow.Ellipsis
+          )
+        }
+      } else {
+        Text(stringResource(R.string.contact_connection_pending), color = HighOrLowlight)
       }
     }
     val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.createdAt)
@@ -61,7 +77,7 @@ fun ChatPreviewView(chat: Chat) {
       val n = chat.chatStats.unreadCount
       if (n > 0) {
         Text(
-          if (n < 1000) "$n" else "${n / 1000}k",
+          if (n < 1000) "$n" else "${n / 1000}" + stringResource(R.string.thousand_abbreviation),
           color = MaterialTheme.colors.onPrimary,
           fontSize = 14.sp,
           modifier = Modifier
@@ -76,6 +92,27 @@ fun ChatPreviewView(chat: Chat) {
   }
 }
 
+@Composable
+fun ChatStatusImage(chat: Chat) {
+  val s = chat.serverInfo.networkStatus
+  val descr = s.statusString
+  if (s is Chat.NetworkStatus.Error) {
+    Icon(
+      Icons.Filled.Circle,
+      contentDescription = descr,
+      tint = HighOrLowlight,
+      modifier = Modifier.padding(start = 6.dp).padding(bottom = 4.dp).size(6.dp)
+    )
+  } else if (!(s is Chat.NetworkStatus.Connected)) {
+    Icon(
+      Icons.Filled.MoreHoriz,
+      contentDescription = descr,
+      tint = HighOrLowlight,
+      modifier = Modifier.width(19.dp).padding(start = 6.dp)
+    )
+  }
+}
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,

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.HighOrLowlight
+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 = HighOrLowlight)
+    }
+    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,36 @@ 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.R
+import chat.simplex.app.model.ChatInfo
 import chat.simplex.app.model.getTimestampText
 import chat.simplex.app.ui.theme.HighOrLowlight
 import chat.simplex.app.views.helpers.ChatInfoImage
 
 @Composable
-fun ContactRequestView(chat: Chat) {
+fun ContactRequestView(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
-      )
+      Text(stringResource(R.string.contact_wants_to_connect_with_you), maxLines = 2)
     }
-    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/helpers/AlertManager.kt

@@ -4,6 +4,7 @@ import android.util.Log
 import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.mutableStateOf
+import chat.simplex.app.R
 import chat.simplex.app.TAG
 
 class AlertManager {
@@ -21,12 +22,28 @@ class AlertManager {
     alertView.value = null
   }
 
+  fun showAlertDialogButtons(
+    title: String,
+    text: String? = null,
+    buttons: @Composable () -> Unit,
+  ) {
+    val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
+    showAlert {
+      AlertDialog(
+        onDismissRequest = this::hideAlert,
+        title = { Text(title) },
+        text = alertText,
+        buttons = buttons
+      )
+    }
+  }
+
   fun showAlertDialog(
     title: String,
     text: String? = null,
-    confirmText: String = "Ok",
+    confirmText: String = generalGetString(R.string.ok),
     onConfirm: (() -> Unit)? = null,
-    dismissText: String = "Cancel",
+    dismissText: String = generalGetString(R.string.cancel_verb),
     onDismiss: (() -> Unit)? = null
   ) {
     val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
@@ -53,7 +70,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 {

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

@@ -1,6 +1,8 @@
 package chat.simplex.app.views.helpers
 
+import androidx.compose.foundation.Image
 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
@@ -8,24 +10,49 @@ import androidx.compose.material.icons.filled.AccountCircle
 import androidx.compose.material.icons.filled.SupervisedUserCircle
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+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) {
   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, chatInfo.image, icon)
+}
+
+@Composable
+fun ProfileImage(
+  size: Dp,
+  image: String? = null,
+  icon: ImageVector = Icons.Filled.AccountCircle
+) {
   Box(Modifier.size(size)) {
-    Icon(icon,
-      contentDescription = "Avatar Placeholder",
-      tint = MaterialTheme.colors.secondary,
-      modifier = Modifier.fillMaxSize()
-    )
+    if (image == null) {
+      Icon(
+        icon,
+        contentDescription = stringResource(R.string.icon_descr_profile_image_placeholder),
+        tint = MaterialTheme.colors.secondary,
+        modifier = Modifier.fillMaxSize()
+      )
+    } else {
+      val imageBitmap = base64ToBitmap(image).asImageBitmap()
+      Image(
+        imageBitmap,
+        stringResource(R.string.image_descr_profile_image),
+        contentScale = ContentScale.Crop,
+        modifier = Modifier.size(size).padding(size / 12).clip(CircleShape)
+      )
+    }
   }
 }
 
@@ -34,7 +61,7 @@ fun ChatInfoImage(chat: Chat, size: Dp) {
 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/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/GetImageView.kt

@@ -0,0 +1,237 @@
+package chat.simplex.app.views.helpers
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.graphics.*
+import android.net.Uri
+import android.provider.MediaStore
+import android.util.Base64
+import android.util.Log
+import android.widget.Toast
+import androidx.activity.compose.ManagedActivityResultLauncher
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.CallSuper
+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.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.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 cropToSquare(image: Bitmap): Bitmap {
+  var xOffset = 0
+  var yOffset = 0
+  val side = min(image.height, image.width)
+  if (image.height < image.width) {
+    xOffset = (image.width - side) / 2
+  } else {
+    yOffset = (image.height - side) / 2
+  }
+  return Bitmap.createBitmap(image, xOffset, yOffset, side, side)
+}
+
+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
+}
+
+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)
+}
+
+class CustomTakePicturePreview: ActivityResultContract<Void?, Bitmap?>() {
+  private var uri: Uri? = null
+  private var tmpFile: File? = null
+  lateinit var externalContext: Context
+
+  @CallSuper
+  override fun createIntent(context: Context, input: Void?): Intent {
+    externalContext = context
+    tmpFile = File.createTempFile("image", ".bmp", context.filesDir)
+    uri = FileProvider.getUriForFile(context, "${BuildConfig.APPLICATION_ID}.provider", tmpFile!!)
+    return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
+      .putExtra(MediaStore.EXTRA_OUTPUT, uri)
+  }
+
+  override fun getSynchronousResult(
+    context: Context,
+    input: Void?
+  ): SynchronousResult<Bitmap?>? = null
+
+  override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
+    return if (resultCode == Activity.RESULT_OK && uri != null) {
+      val source = ImageDecoder.createSource(externalContext.contentResolver, uri!!)
+      val bitmap = ImageDecoder.decodeBitmap(source)
+      tmpFile?.delete()
+      bitmap
+    } else {
+      Log.e(TAG, "Getting image from camera cancelled or failed.")
+      tmpFile?.delete()
+      null
+    }
+  }
+}
+
+//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)
+
+@Composable
+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(
+  imageBitmap: MutableState<Bitmap?>,
+  onImageChange: (Bitmap) -> Unit,
+  fileUri: MutableState<Uri?>? = null,
+  onFileChange: ((Uri) -> Unit)? = null,
+  hideBottomSheet: () -> Unit
+) {
+  val context = LocalContext.current
+  val galleryLauncher = rememberGetContentLauncher { uri: Uri? ->
+    if (uri != null) {
+      val source = ImageDecoder.createSource(context.contentResolver, uri)
+      val bitmap = ImageDecoder.decodeBitmap(source)
+      imageBitmap.value = bitmap
+      onImageChange(bitmap)
+    }
+  }
+  val cameraLauncher = rememberCameraLauncher { bitmap: Bitmap? ->
+    if (bitmap != null) {
+      imageBitmap.value = bitmap
+      onImageChange(bitmap)
+    }
+  }
+  val permissionLauncher = rememberPermissionLauncher { isGranted: Boolean ->
+    if (isGranted) {
+      cameraLauncher.launch(null)
+      hideBottomSheet()
+    } else {
+      Toast.makeText(context, generalGetString(R.string.toast_permission_denied), Toast.LENGTH_SHORT).show()
+    }
+  }
+  val filesLauncher = rememberGetContentLauncher { uri: Uri? ->
+    if (uri != null && fileUri != null && onFileChange != null) {
+      val fileSize = getFileSize(context, uri)
+      if (fileSize != null && fileSize <= MAX_FILE_SIZE) {
+        fileUri.value = uri
+        onFileChange(uri)
+      } else {
+        AlertManager.shared.showAlertMsg(
+          generalGetString(R.string.large_file),
+          String.format(generalGetString(R.string.maximum_supported_file_size), formatBytes(MAX_FILE_SIZE))
+        )
+      }
+    }
+  }
+
+  Box(
+    modifier = Modifier
+      .fillMaxWidth()
+      .wrapContentHeight()
+      .onFocusChanged { focusState ->
+        if (!focusState.hasFocus) hideBottomSheet()
+      }
+  ) {
+    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) {
+        when (PackageManager.PERMISSION_GRANTED) {
+          ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) -> {
+            cameraLauncher.launch(null)
+            hideBottomSheet()
+          }
+          else -> {
+            permissionLauncher.launch(Manifest.permission.CAMERA)
+          }
+        }
+      }
+      ActionButton(null, stringResource(R.string.from_gallery_button), icon = Icons.Outlined.Collections) {
+        galleryLauncher.launch("image/*")
+        hideBottomSheet()
+      }
+      if (fileUri != null && onFileChange != null) {
+        ActionButton(null, stringResource(R.string.choose_file), icon = Icons.Outlined.InsertDriveFile) {
+          filesLauncher.launch("*/*")
+          hideBottomSheet()
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,142 @@
+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
+  ) {
+    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) { -> }
+  }
+}

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
@@ -11,7 +11,6 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.ui.Modifier
 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) {
@@ -43,7 +42,7 @@ class ModalManager {
   }
 
   fun closeModal() {
-    if (!modalViews.isEmpty()) {
+    if (modalViews.isNotEmpty()) {
       modalViews.removeAt(modalViews.count() - 1)
     }
     modalCount.value = modalViews.count()

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.Context
-import android.content.Intent
+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 {
@@ -12,3 +23,55 @@ fun shareText(cxt: Context, text: String) {
   val shareIntent = Intent.createChooser(sendIntent, null)
   cxt.startActivity(shareIntent)
 }
+
+fun copyText(cxt: Context, text: String) {
+  val clipboard = ContextCompat.getSystemService(cxt, ClipboardManager::class.java)
+  clipboard?.setPrimaryClip(ClipData.newPlainText("text", text))
+}
+
+@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,24 @@ 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, content: @Composable () -> Unit) {
+  Surface(shape = RoundedCornerShape(20.dp)) {
+    Row(
+      verticalAlignment = Alignment.CenterVertically,
+      modifier = Modifier
+        .clickable { click() }
+        .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,10 +1,38 @@
 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.File
+import java.io.FileOutputStream
+import java.text.SimpleDateFormat
+import java.util.*
+import kotlin.math.log2
+import kotlin.math.pow
 
 fun withApi(action: suspend CoroutineScope.() -> Unit): Job =
   GlobalScope.launch { withContext(Dispatchers.Main, action) }
@@ -38,3 +66,280 @@ 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 = BitmapFactory.decodeFileDescriptor(fileDescriptor)
+      parcelFileDescriptor?.close()
+      image
+    } catch (e: Exception) {
+      null
+    }
+  } else {
+    null
+  }
+}
+
+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

@@ -10,12 +10,13 @@ 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
@@ -42,12 +43,12 @@ fun AddContactLayout(connReq: String, share: () -> Unit) {
       verticalArrangement = Arrangement.SpaceBetween,
     ) {
       Text(
-        "Add contact",
-        style = MaterialTheme.typography.h1,
+        stringResource(R.string.add_contact),
+        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
       )
       Text(
-        "Show QR code to your contact\nto scan from the app",
-        style = MaterialTheme.typography.h2.copy(fontSize = if(screenHeight > 600.dp) 26.sp else 20.sp),
+        stringResource(R.string.show_QR_code_for_your_contact_to_scan_from_the_app__multiline),
+        style = MaterialTheme.typography.h3,
         textAlign = TextAlign.Center,
       )
       QRCode(
@@ -57,20 +58,14 @@ 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.")
-        },
+        stringResource(R.string.if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel),
         textAlign = TextAlign.Center,
-        style = MaterialTheme.typography.caption.copy(fontSize=if(screenHeight > 600.dp) 20.sp else 16.sp),
+        lineHeight = 22.sp,
         modifier = Modifier
           .padding(horizontal = 16.dp)
-          .padding(bottom = if(screenHeight > 600.dp) 16.dp else 8.dp)
+          .padding(bottom = if (screenHeight > 600.dp) 16.dp else 8.dp)
       )
-      SimpleButton("Share invitation link", icon = Icons.Outlined.Share, click = share)
+      SimpleButton(stringResource(R.string.share_invitation_link), icon = Icons.Outlined.Share, click = share)
       Spacer(Modifier.height(10.dp))
     }
   }

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

@@ -3,6 +3,7 @@ package chat.simplex.app.views.newchat
 import android.Manifest
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
@@ -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,75 +42,102 @@ 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) }
     }
   )
 }
 
 @Composable
-fun NewChatSheetLayout(addContact: () -> Unit, scanCode: () -> Unit) {
-  Row(
-    Modifier
-      .fillMaxWidth()
-      .padding(horizontal = 8.dp, vertical = 48.dp),
-    horizontalArrangement = Arrangement.SpaceEvenly
+fun NewChatSheetLayout(addContact: () -> Unit, scanCode: () -> Unit, pasteLink: () -> Unit) {
+  Column(
+    horizontalAlignment = Alignment.CenterHorizontally
   ) {
-    Box(
+    Text(
+      stringResource(R.string.add_contact_to_start_new_chat),
+      modifier = Modifier.padding(horizontal = 8.dp).padding(top = 32.dp)
+    )
+    Row(
       Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Add contact", "(create QR code\nor link)",
-        Icons.Outlined.PersonAdd, click = addContact
-      )
-    }
-    Box(
-      Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Scan QR code", "(in person or in video call)",
-        Icons.Outlined.QrCode, click = scanCode
-      )
-    }
-    Box(
-      Modifier
-        .weight(1F)
-        .fillMaxWidth()) {
-      ActionButton(
-        "Create Group", "(coming soon!)",
-        Icons.Outlined.GroupAdd, disabled = true
-      )
+        .fillMaxWidth()
+        .padding(horizontal = 8.dp)
+        .padding(top = 24.dp, bottom = 40.dp),
+      horizontalArrangement = Arrangement.SpaceEvenly
+    ) {
+      Box(
+        Modifier
+          .weight(1F)
+          .fillMaxWidth()) {
+        ActionButton(
+          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(
+          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(
+          stringResource(R.string.scan_QR_code),
+          stringResource(R.string.in_person_or_in_video_call__bracketed),
+          Icons.Outlined.QrCode,
+          click = scanCode
+        )
+      }
     }
   }
 }
 
 @Composable
-fun ActionButton(text: String, comment: String, icon: ImageVector, disabled: Boolean = false,
+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))
-    Text(text,
-      textAlign = TextAlign.Center,
-      fontWeight = FontWeight.Bold,
-      color = tint,
-      modifier = Modifier.padding(bottom = 4.dp)
-    )
-    Text(comment,
-      textAlign = TextAlign.Center,
-      style = MaterialTheme.typography.body2
-    )
+  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
+        )
+      }
+    }
   }
 }
 
@@ -116,7 +147,8 @@ fun PreviewNewChatSheet() {
   SimpleXTheme {
     NewChatSheetLayout(
       addContact = {},
-      scanCode = {}
+      scanCode = {},
+      pasteLink = {}
     )
   }
 }

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

@@ -0,0 +1,127 @@
+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(
+    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(
+  connectionLink: MutableState<String>,
+  pasteFromClipboard: () -> Unit,
+  connectViaLink: (String) -> Unit,
+  close: () -> Unit
+) {
+  ModalView(close) {
+    Column(
+      horizontalAlignment = Alignment.CenterHorizontally,
+      verticalArrangement = Arrangement.SpaceBetween,
+    ) {
+      Text(
+        stringResource(R.string.connect_via_link),
+        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
+        modifier = Modifier.padding(bottom = 16.dp)
+      )
+      Text(stringResource(R.string.paste_connection_link_below_to_connect))
+      Text(stringResource(R.string.profile_will_be_sent_to_contact_sending_link))
+
+      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(
+      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,24 @@ 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 = ""
 
   AndroidView(
     factory = { AndroidViewContext ->
@@ -36,74 +40,60 @@ 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))
     }
-  )
-}
+  ) { previewView ->
+    val cameraSelector: CameraSelector = CameraSelector.Builder()
+      .requireLensFacing(CameraSelector.LENS_FACING_BACK)
+      .build()
+    val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+    val cameraProviderFuture: ListenableFuture<ProcessCameraProvider> =
+      ProcessCameraProvider.getInstance(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")
+    cameraProviderFuture.addListener({
+      preview = Preview.Builder().build().also {
+        it.setSurfaceProvider(previewView.surfaceProvider)
+      }
+      val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
+      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 {
+        cameraProvider.unbindAll()
+        cameraProvider.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,18 +8,18 @@ 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(
     qrCodeScanner = {
@@ -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,12 +57,11 @@ 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)
     )
   }
 }
@@ -75,12 +74,12 @@ fun ConnectContactLayout(qrCodeScanner: @Composable () -> Unit, close: () -> Uni
       verticalArrangement = Arrangement.spacedBy(12.dp)
     ) {
       Text(
-        "Scan QR code",
-        style = MaterialTheme.typography.h1,
+        generalGetString(R.string.scan_QR_code),
+        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
       )
       Text(
-        "Your chat profile will be sent\nto your contact",
-        style = MaterialTheme.typography.h2,
+        generalGetString(R.string.your_chat_profile_will_be_sent_to_your_contact),
+        style = MaterialTheme.typography.h3,
         textAlign = TextAlign.Center,
         modifier = Modifier.padding(bottom = 4.dp)
       )
@@ -90,18 +89,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
       )
     }
   }

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,139 @@
+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) {
+    Image(
+      painter = painterResource(R.drawable.logo),
+      contentDescription = stringResource(R.string.image_descr_simplex_logo),
+      modifier = Modifier
+        .padding(vertical = 20.dp)
+        .fillMaxWidth(0.80f)
+    )
+
+    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
+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/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,
     )

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

@@ -7,32 +7,41 @@ 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.*
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import chat.simplex.app.R
 import chat.simplex.app.model.Format
 import chat.simplex.app.model.FormatColor
 import chat.simplex.app.ui.theme.SimpleXTheme
 
 @Composable
 fun MarkdownHelpView() {
-  Column(Modifier.padding(horizontal = 16.dp)) {
+  Column {
     Text(
-      "How to use markdown",
+      stringResource(R.string.how_to_use_markdown),
       style = MaterialTheme.typography.h1,
     )
     Text(
-      "You can use markdown to format messages:",
+      stringResource(R.string.you_can_use_markdown_to_format_messages__prompt),
       Modifier.padding(vertical = 16.dp)
     )
-    MdFormat("*bold*", "bold", Format.Bold())
-    MdFormat("_italic_", "italic", Format.Italic())
-    MdFormat("~strike~", "strike", Format.StrikeThrough())
-    MdFormat("`a + b`", "a + b", Format.Snippet())
+    val bold = stringResource(R.string.bold)
+    val italic = stringResource(R.string.italic)
+    val strikethrough = stringResource(R.string.strikethrough)
+    val equation = stringResource(R.string.a_plus_b)
+    val colored = stringResource(R.string.colored)
+    val secret = stringResource(R.string.secret)
+
+    MdFormat("*$bold*", bold, Format.Bold())
+    MdFormat("_${italic}_", italic, Format.Italic())
+    MdFormat("~$strikethrough~", strikethrough, Format.StrikeThrough())
+    MdFormat("`$equation`", equation, Format.Snippet())
     Row {
-      MdSyntax("!1 colored!")
+      MdSyntax("!1 $colored!")
       Text(buildAnnotatedString {
-        withStyle(Format.Colored(FormatColor.red).style) { append("colored") }
+        withStyle(Format.Colored(FormatColor.red).style) { append(colored) }
         append(" (")
         appendColor(this, "1", FormatColor.red, ", ")
         appendColor(this, "2", FormatColor.green, ", ")
@@ -43,10 +52,10 @@ fun MarkdownHelpView() {
       })
     }
     Row {
-      MdSyntax("#secret#")
+      MdSyntax("#$secret#")
       SelectionContainer {
         Text(buildAnnotatedString {
-          withStyle(Format.Secret().style) { append("secret") }
+          withStyle(Format.Secret().style) { append(secret) }
         })
       }
     }
@@ -56,7 +65,7 @@ fun MarkdownHelpView() {
 @Composable
 fun MdSyntax(markdown: String) {
   Text(markdown, Modifier
-    .width(100.dp)
+    .width(120.dp)
     .padding(bottom = 4.dp))
 }
 

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

@@ -3,8 +3,6 @@ package chat.simplex.app.views.usersettings
 import androidx.compose.foundation.*
 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.foundation.text.selection.SelectionContainer
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
@@ -12,18 +10,18 @@ import androidx.compose.material.icons.outlined.OpenInNew
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.SolidColor
 import androidx.compose.ui.platform.LocalUriHandler
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.TextStyle
 import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.input.KeyboardCapitalization
 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.*
-import chat.simplex.app.views.helpers.AlertManager
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.ui.theme.HighOrLowlight
+import chat.simplex.app.ui.theme.SimpleXTheme
+import chat.simplex.app.views.helpers.*
 
 @Composable
 fun SMPServersView(chatModel: ChatModel) {
@@ -31,7 +29,7 @@ fun SMPServersView(chatModel: ChatModel) {
   if (userSMPServers != null) {
     var isUserSMPServers by remember { mutableStateOf(userSMPServers.isNotEmpty()) }
     var editSMPServers by remember { mutableStateOf(!isUserSMPServers) }
-    var userSMPServersStr by remember { mutableStateOf(if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else "") }
+    var userSMPServersStr = remember { mutableStateOf(if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else "") }
     fun saveSMPServers(smpServers: List<String>) {
       withApi {
         val r = chatModel.controller.setUserSMPServers(smpServers = smpServers)
@@ -59,29 +57,28 @@ fun SMPServersView(chatModel: ChatModel) {
           if (userSMPServers != null) {
             if (userSMPServers.isNotEmpty()) {
               AlertManager.shared.showAlertMsg(
-                title = "Use SimpleX Chat servers?",
-                text = "Saved SMP servers will be removed",
-                confirmText = "Confirm",
+                title = generalGetString(R.string.use_simplex_chat_servers__question),
+                text = generalGetString(R.string.saved_SMP_servers_will_br_removed),
+                confirmText = generalGetString(R.string.confirm_verb),
                 onConfirm = {
                   saveSMPServers(listOf())
                   isUserSMPServers = false
-                  userSMPServersStr = ""
+                  userSMPServersStr.value = ""
                 }
               )
             } else {
               isUserSMPServers = false
-              userSMPServersStr = ""
+              userSMPServersStr.value = ""
             }
           }
         }
       },
-      editUserSMPServersStr = { userSMPServersStr = it },
       cancelEdit = {
         val userSMPServers = chatModel.userSMPServers.value
         if (userSMPServers != null) {
           isUserSMPServers = userSMPServers.isNotEmpty()
           editSMPServers = !isUserSMPServers
-          userSMPServersStr = if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else ""
+          userSMPServersStr.value = if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else ""
         }
       },
       saveSMPServers = { saveSMPServers(it) },
@@ -94,9 +91,8 @@ fun SMPServersView(chatModel: ChatModel) {
 fun SMPServersLayout(
   isUserSMPServers: Boolean,
   editSMPServers: Boolean,
-  userSMPServersStr: String,
+  userSMPServersStr: MutableState<String>,
   isUserSMPServersOnOff: (Boolean) -> Unit,
-  editUserSMPServersStr: (String) -> Unit,
   cancelEdit: () -> Unit,
   saveSMPServers: (List<String>) -> Unit,
   editOn: () -> Unit,
@@ -107,14 +103,14 @@ fun SMPServersLayout(
     verticalArrangement = Arrangement.spacedBy(8.dp)
   ) {
     Text(
-      "Your SMP servers",
+      stringResource(R.string.your_SMP_servers),
       Modifier.padding(bottom = 24.dp),
       style = MaterialTheme.typography.h1
     )
     Row(
       verticalAlignment = Alignment.CenterVertically
     ) {
-      Text("Configure SMP servers", Modifier.padding(end = 24.dp))
+      Text(stringResource(R.string.configure_SMP_servers), Modifier.padding(end = 24.dp))
       Switch(
         checked = isUserSMPServers,
         onCheckedChange = isUserSMPServersOnOff,
@@ -126,43 +122,11 @@ fun SMPServersLayout(
     }
 
     if (!isUserSMPServers) {
-      Text("Using SimpleX Chat servers.")
+      Text(stringResource(R.string.using_simplex_chat_servers), lineHeight = 22.sp)
     } else {
-      Text("Enter one SMP server per line:")
+      Text(stringResource(R.string.enter_one_SMP_server_per_line))
       if (editSMPServers) {
-        BasicTextField(
-          value = userSMPServersStr,
-          onValueChange = editUserSMPServersStr,
-          textStyle = TextStyle(
-            fontFamily = FontFamily.Monospace, fontSize = 14.sp,
-            color = MaterialTheme.colors.onBackground
-          ),
-          keyboardOptions = KeyboardOptions.Default.copy(
-            capitalization = KeyboardCapitalization.None,
-            autoCorrect = false
-          ),
-          modifier = Modifier.height(160.dp),
-          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()
-                }
-              }
-            }
-          }
-        )
+        TextEditor(Modifier.height(160.dp), text = userSMPServersStr)
 
         Row(
           Modifier.fillMaxWidth(),
@@ -172,17 +136,17 @@ fun SMPServersLayout(
           Column(horizontalAlignment = Alignment.Start) {
             Row {
               Text(
-                "Cancel",
+                stringResource(R.string.cancel_verb),
                 color = MaterialTheme.colors.primary,
                 modifier = Modifier
                   .clickable(onClick = cancelEdit)
               )
               Spacer(Modifier.padding(horizontal = 8.dp))
               Text(
-                "Save",
+                stringResource(R.string.save_servers_button),
                 color = MaterialTheme.colors.primary,
                 modifier = Modifier.clickable(onClick = {
-                  val servers = userSMPServersStr.split("\n")
+                  val servers = userSMPServersStr.value.split("\n")
                   saveSMPServers(servers)
                 })
               )
@@ -204,7 +168,7 @@ fun SMPServersLayout(
             Modifier.verticalScroll(rememberScrollState())
           ) {
             Text(
-              userSMPServersStr,
+              userSMPServersStr.value,
               Modifier
                 .padding(vertical = 5.dp, horizontal = 7.dp),
               style = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 14.sp),
@@ -218,7 +182,7 @@ fun SMPServersLayout(
         ) {
           Column(horizontalAlignment = Alignment.Start) {
             Text(
-              "Edit",
+              stringResource(R.string.edit_verb),
               color = MaterialTheme.colors.primary,
               modifier = Modifier
                 .clickable(onClick = editOn)
@@ -240,9 +204,9 @@ fun howToButton() {
     verticalAlignment = Alignment.CenterVertically,
     modifier = Modifier.clickable { uriHandler.openUri("https://github.com/simplex-chat/simplexmq#using-smp-server-and-smp-agent") }
   ) {
-    Text("How to", color = MaterialTheme.colors.primary)
+    Text(stringResource(R.string.how_to), color = MaterialTheme.colors.primary)
     Icon(
-      Icons.Outlined.OpenInNew, "How to", tint = MaterialTheme.colors.primary,
+      Icons.Outlined.OpenInNew, stringResource(R.string.how_to), tint = MaterialTheme.colors.primary,
       modifier = Modifier.padding(horizontal = 5.dp)
     )
   }
@@ -255,9 +219,8 @@ fun PreviewSMPServersLayoutDefaultServers() {
     SMPServersLayout(
       isUserSMPServers = false,
       editSMPServers = true,
-      userSMPServersStr = "",
+      userSMPServersStr = remember { mutableStateOf("") },
       isUserSMPServersOnOff = {},
-      editUserSMPServersStr = {},
       cancelEdit = {},
       saveSMPServers = {},
       editOn = {},
@@ -272,9 +235,8 @@ fun PreviewSMPServersLayoutUserServersEditOn() {
     SMPServersLayout(
       isUserSMPServers = true,
       editSMPServers = true,
-      userSMPServersStr = "smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im",
+      userSMPServersStr = remember { mutableStateOf("smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im") },
       isUserSMPServersOnOff = {},
-      editUserSMPServersStr = {},
       cancelEdit = {},
       saveSMPServers = {},
       editOn = {},
@@ -289,9 +251,8 @@ fun PreviewSMPServersLayoutUserServersEditOff() {
     SMPServersLayout(
       isUserSMPServers = true,
       editSMPServers = false,
-      userSMPServersStr = "smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im",
+      userSMPServersStr = remember { mutableStateOf("smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im") },
       isUserSMPServersOnOff = {},
-      editUserSMPServersStr = {},
       cancelEdit = {},
       saveSMPServers = {},
       editOn = {},

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

@@ -7,22 +7,26 @@ import androidx.compose.foundation.layout.*
 import androidx.compose.material.*
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.Composable
+import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.*
+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.dp
+import chat.simplex.app.BuildConfig
 import chat.simplex.app.R
 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.SimpleXTheme
 import chat.simplex.app.views.TerminalView
-import chat.simplex.app.views.newchat.ModalManager
+import chat.simplex.app.views.call.VideoCallView
+import chat.simplex.app.views.helpers.*
+import chat.simplex.app.views.onboarding.SimpleXInfo
 
 @Composable
 fun SettingsView(chatModel: ChatModel) {
@@ -30,8 +34,15 @@ fun SettingsView(chatModel: ChatModel) {
   if (user != null) {
     SettingsLayout(
       profile = user.profile,
+      runServiceInBackground = chatModel.runServiceInBackground,
+      setRunServiceInBackground = { on ->
+        chatModel.controller.setRunServiceInBackground(on)
+        chatModel.runServiceInBackground.value = on
+      },
       showModal = { modalView -> { ModalManager.shared.showModal { modalView(chatModel) } } },
-      showTerminal = { ModalManager.shared.showCustomModal { close -> TerminalView(chatModel, close) } }
+      showCustomModal = { modalView -> { ModalManager.shared.showCustomModal { close -> modalView(chatModel, close) } } },
+      showTerminal = { ModalManager.shared.showCustomModal { close -> TerminalView(chatModel, close) } },
+      showVideoChatPrototype = { ModalManager.shared.showCustomModal { close -> VideoCallView(close) } },
     )
   }
 }
@@ -42,8 +53,12 @@ val simplexTeamUri =
 @Composable
 fun SettingsLayout(
   profile: Profile,
+  runServiceInBackground: MutableState<Boolean>,
+  setRunServiceInBackground: (Boolean) -> Unit,
   showModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
-  showTerminal: () -> Unit
+  showCustomModal: (@Composable (ChatModel, () -> Unit) -> Unit) -> (() -> Unit),
+  showTerminal: () -> Unit,
+  showVideoChatPrototype: () -> Unit
 ) {
   val uriHandler = LocalUriHandler.current
   Surface(
@@ -59,17 +74,14 @@ fun SettingsLayout(
         .padding(top = 16.dp)
     ) {
       Text(
-        "Your Settings",
+        stringResource(R.string.your_settings),
         style = MaterialTheme.typography.h1,
         modifier = Modifier.padding(start = 8.dp)
       )
       Spacer(Modifier.height(30.dp))
 
-      SettingsSectionView(showModal { UserProfileView(it) }, 60.dp) {
-        Icon(
-          Icons.Outlined.AccountCircle,
-          contentDescription = "Avatar Placeholder",
-        )
+      SettingsSectionView(showCustomModal { chatModel, close -> UserProfileView(chatModel, close) }, 80.dp) {
+        ProfileImage(size = 60.dp, profile.image)
         Spacer(Modifier.padding(horizontal = 4.dp))
         Column {
           Text(
@@ -84,39 +96,48 @@ fun SettingsLayout(
       SettingsSectionView(showModal { UserAddressView(it) }) {
         Icon(
           Icons.Outlined.QrCode,
-          contentDescription = "Address",
+          contentDescription = stringResource(R.string.icon_descr_address),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text("Your SimpleX contact address")
+        Text(stringResource(R.string.your_simplex_contact_address))
       }
       Spacer(Modifier.height(24.dp))
 
       SettingsSectionView(showModal { HelpView(it) }) {
         Icon(
           Icons.Outlined.HelpOutline,
-          contentDescription = "Chat help",
+          contentDescription = stringResource(R.string.icon_descr_help),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text("How to use SimpleX Chat")
+        Text(stringResource(R.string.how_to_use_simplex_chat))
+      }
+      Divider(Modifier.padding(horizontal = 8.dp))
+      SettingsSectionView(showModal { SimpleXInfo(it, onboarding = false) }) {
+        Icon(
+          Icons.Outlined.Info,
+          contentDescription = stringResource(R.string.icon_descr_help),
+        )
+        Spacer(Modifier.padding(horizontal = 4.dp))
+        Text(stringResource(R.string.about_simplex_chat))
       }
       Divider(Modifier.padding(horizontal = 8.dp))
       SettingsSectionView(showModal { MarkdownHelpView() }) {
         Icon(
           Icons.Outlined.TextFormat,
-          contentDescription = "Markdown help",
+          contentDescription = stringResource(R.string.markdown_help),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text("Markdown in messages")
+        Text(stringResource(R.string.markdown_in_messages))
       }
       Divider(Modifier.padding(horizontal = 8.dp))
       SettingsSectionView({ uriHandler.openUri(simplexTeamUri) }) {
         Icon(
           Icons.Outlined.Tag,
-          contentDescription = "SimpleX Team",
+          contentDescription = stringResource(R.string.icon_descr_simplex_team),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
         Text(
-          "Get help & advice via chat",
+          stringResource(R.string.chat_with_the_founder),
           color = MaterialTheme.colors.primary
         )
       }
@@ -124,11 +145,11 @@ fun SettingsLayout(
       SettingsSectionView({ uriHandler.openUri("mailto:chat@simplex.chat") }) {
         Icon(
           Icons.Outlined.Email,
-          contentDescription = "Email",
+          contentDescription = stringResource(R.string.icon_descr_email),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
         Text(
-          "Ask questions via email",
+          stringResource(R.string.send_us_an_email),
           color = MaterialTheme.colors.primary
         )
       }
@@ -137,19 +158,41 @@ fun SettingsLayout(
       SettingsSectionView(showModal { SMPServersView(it) }) {
         Icon(
           Icons.Outlined.Dns,
-          contentDescription = "SMP servers",
+          contentDescription = stringResource(R.string.smp_servers),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text("SMP servers")
+        Text(stringResource(R.string.smp_servers))
+      }
+      Divider(Modifier.padding(horizontal = 8.dp))
+      SettingsSectionView() {
+        Icon(
+          Icons.Outlined.Bolt,
+          contentDescription = stringResource(R.string.private_notifications),
+        )
+        Spacer(Modifier.padding(horizontal = 4.dp))
+        Text(
+          stringResource(R.string.private_notifications), Modifier
+            .padding(end = 24.dp)
+            .fillMaxWidth()
+            .weight(1F))
+        Switch(
+          checked = runServiceInBackground.value,
+          onCheckedChange = { setRunServiceInBackground(it) },
+          colors = SwitchDefaults.colors(
+            checkedThumbColor = MaterialTheme.colors.primary,
+            uncheckedThumbColor = HighOrLowlight
+          ),
+          modifier = Modifier.padding(end = 8.dp)
+        )
       }
       Divider(Modifier.padding(horizontal = 8.dp))
       SettingsSectionView(showTerminal) {
         Icon(
           painter = painterResource(id = R.drawable.ic_outline_terminal),
-          contentDescription = "Chat console",
+          contentDescription = stringResource(R.string.chat_console),
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text("Chat console")
+        Text(stringResource(R.string.chat_console))
       }
       Divider(Modifier.padding(horizontal = 8.dp))
       SettingsSectionView({ uriHandler.openUri("https://github.com/simplex-chat/simplex-chat") }) {
@@ -158,30 +201,28 @@ fun SettingsLayout(
           contentDescription = "GitHub",
         )
         Spacer(Modifier.padding(horizontal = 4.dp))
-        Text(
-          buildAnnotatedString {
-            append("Install ")
-            withStyle(SpanStyle(color = MaterialTheme.colors.primary)) {
-              append("SimpleX Chat for terminal")
-            }
-          }
-        )
+        Text(annotatedStringResource(R.string.install_simplex_chat_for_terminal))
+      }
+      Divider(Modifier.padding(horizontal = 8.dp))
+//      SettingsSectionView(showVideoChatPrototype) {
+      SettingsSectionView() {
+        Text("v${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})")
       }
     }
   }
 }
 
 @Composable
-fun SettingsSectionView(click: () -> Unit, height: Dp = 48.dp, content: (@Composable () -> Unit)) {
+fun SettingsSectionView(click: (() -> Unit)? = null, height: Dp = 46.dp, content: (@Composable () -> Unit)) {
+  val modifier = Modifier
+    .padding(start = 8.dp)
+    .fillMaxWidth()
+    .height(height)
   Row(
-    Modifier
-      .padding(start = 8.dp)
-      .fillMaxWidth()
-      .clickable(onClick = click)
-      .height(height),
+    if (click == null) modifier else modifier.clickable(onClick = click),
     verticalAlignment = Alignment.CenterVertically
   ) {
-    content.invoke()
+    content()
   }
 }
 
@@ -196,8 +237,12 @@ fun PreviewSettingsLayout() {
   SimpleXTheme {
     SettingsLayout(
       profile = Profile.sampleData,
+      runServiceInBackground = remember { mutableStateOf(true) },
+      setRunServiceInBackground = {},
       showModal = {{}},
-      showTerminal = {}
+      showCustomModal = {{}},
+      showTerminal = {},
+      showVideoChatPrototype = {}
     )
   }
 }

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

@@ -11,8 +11,11 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
+import androidx.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
@@ -32,9 +35,9 @@ fun UserAddressView(chatModel: ChatModel) {
     share = { userAddress: String -> shareText(cxt, userAddress) },
     deleteAddress = {
       AlertManager.shared.showAlertMsg(
-        title = "Delete address?",
-        text = "All your contacts will remain connected",
-        confirmText = "Delete",
+        title = generalGetString(R.string.delete_address__question),
+        text = generalGetString(R.string.all_your_contacts_will_remain_connected),
+        confirmText = generalGetString(R.string.delete_verb),
         onConfirm = {
           withApi {
             chatModel.controller.apiDeleteUserAddress()
@@ -58,14 +61,14 @@ fun UserAddressLayout(
     verticalArrangement = Arrangement.Top
   ) {
     Text(
-      "Your chat address",
+      stringResource(R.string.your_chat_address),
       Modifier.padding(bottom = 16.dp),
       style = MaterialTheme.typography.h1,
     )
     Text(
-      "You can share your address as a link or as a QR code - anybody will be able to connect to you, " +
-          "and if you later delete it - you won't lose your contacts.",
+      stringResource(R.string.you_can_share_your_address_anybody_will_be_able_to_connect),
       Modifier.padding(bottom = 12.dp),
+      lineHeight = 22.sp
     )
     Column(
       Modifier.fillMaxWidth(),
@@ -73,7 +76,12 @@ fun UserAddressLayout(
       verticalArrangement = Arrangement.SpaceEvenly
     ) {
       if (userAddress == null) {
-        SimpleButton("Create address", icon = Icons.Outlined.QrCode, click = createAddress)
+        Text(
+          stringResource(R.string.if_you_delete_address_you_wont_lose_contacts),
+          Modifier.padding(bottom = 12.dp),
+          lineHeight = 22.sp
+        )
+        SimpleButton(stringResource(R.string.create_address), icon = Icons.Outlined.QrCode, click = createAddress)
       } else {
         QRCode(userAddress, Modifier.weight(1f, fill = false).aspectRatio(1f))
         Row(
@@ -82,11 +90,11 @@ fun UserAddressLayout(
           modifier = Modifier.padding(vertical = 10.dp)
         ) {
           SimpleButton(
-            "Share link",
+            stringResource(R.string.share_link),
             icon = Icons.Outlined.Share,
             click = { share(userAddress) })
           SimpleButton(
-            "Delete address",
+            stringResource(R.string.delete_address),
             icon = Icons.Outlined.Delete,
             color = Color.Red,
             click = deleteAddress

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

@@ -1,45 +1,55 @@
 package chat.simplex.app.views.usersettings
 
 import android.content.res.Configuration
-import androidx.compose.foundation.clickable
+import android.graphics.Bitmap
+import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.text.BasicTextField
 import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
+import androidx.compose.material.*
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Close
+import androidx.compose.material.icons.outlined.PhotoCamera
 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.input.KeyboardCapitalization
 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.Profile
 import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.withApi
+import chat.simplex.app.views.helpers.*
+import com.google.accompanist.insets.ProvideWindowInsets
+import com.google.accompanist.insets.navigationBarsWithImePadding
+import kotlinx.coroutines.launch
 
 @Composable
-fun UserProfileView(chatModel: ChatModel) {
+fun UserProfileView(chatModel: ChatModel, close: () -> Unit) {
   val user = chatModel.currentUser.value
   if (user != null) {
-    var editProfile by remember { mutableStateOf(false) }
+    val editProfile = remember { mutableStateOf(false) }
     var profile by remember { mutableStateOf(user.profile) }
     UserProfileLayout(
+      close = close,
       editProfile = editProfile,
       profile = profile,
-      editProfileOff = { editProfile = false },
-      editProfileOn = { editProfile = true },
-      saveProfile = { displayName: String, fullName: String ->
+      saveProfile = { displayName, fullName, image ->
         withApi {
-          val newProfile = chatModel.controller.apiUpdateProfile(
-            profile = Profile(displayName, fullName)
-          )
+          val p = Profile(displayName, fullName, image)
+          val newProfile = chatModel.controller.apiUpdateProfile(p)
           if (newProfile != null) {
             chatModel.updateUserProfile(newProfile)
             profile = newProfile
           }
-          editProfile = false
+          editProfile.value = false
         }
       }
     )
@@ -48,119 +58,196 @@ fun UserProfileView(chatModel: ChatModel) {
 
 @Composable
 fun UserProfileLayout(
-  editProfile: Boolean,
+  close: () -> Unit,
+  editProfile: MutableState<Boolean>,
   profile: Profile,
-  editProfileOff: () -> Unit,
-  editProfileOn: () -> Unit,
-  saveProfile: (String, String) -> Unit,
+  saveProfile: (String, String, String?) -> Unit,
 ) {
-  Column(horizontalAlignment = Alignment.Start) {
-    Text(
-      "Your chat profile",
-      Modifier.padding(bottom = 24.dp),
-      style = MaterialTheme.typography.h1,
-      color = MaterialTheme.colors.onBackground
-    )
-    Text(
-      "Your profile is stored on your device and shared only with your contacts.\n" +
-          "SimpleX servers cannot see your profile.",
-      Modifier.padding(bottom = 24.dp),
-      color = MaterialTheme.colors.onBackground
-    )
-    if (editProfile) {
-      var displayName by remember { mutableStateOf(profile.displayName) }
-      var fullName by remember { mutableStateOf(profile.fullName) }
-      Column(
-        modifier = Modifier.fillMaxWidth(),
-        horizontalAlignment = Alignment.Start
-      ) {
-        // TODO hints
-        BasicTextField(
-          value = displayName,
-          onValueChange = { displayName = it },
-          modifier = Modifier
-            .padding(bottom = 24.dp)
-            .fillMaxWidth(),
-          textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
-          keyboardOptions = KeyboardOptions(
-            capitalization = KeyboardCapitalization.None,
-            autoCorrect = false
-          ),
-          singleLine = true
-        )
-        BasicTextField(
-          value = fullName,
-          onValueChange = { fullName = it },
-          modifier = Modifier
-            .padding(bottom = 24.dp)
-            .fillMaxWidth(),
-          textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
-          keyboardOptions = KeyboardOptions(
-            capitalization = KeyboardCapitalization.None,
-            autoCorrect = false
-          ),
-          singleLine = true
-        )
-        Row {
-          Text(
-            "Cancel",
-            color = MaterialTheme.colors.primary,
-            modifier = Modifier
-              .clickable(onClick = editProfileOff),
-          )
-          Spacer(Modifier.padding(horizontal = 8.dp))
-          Text(
-            "Save (and notify contacts)",
-            color = MaterialTheme.colors.primary,
-            modifier = Modifier
-              .clickable(onClick = { saveProfile(displayName, fullName) })
-          )
-        }
-      }
-    } else {
-      Column(
-        modifier = Modifier.fillMaxWidth(),
-        horizontalAlignment = Alignment.Start
-      ) {
-        Row(
-          Modifier.padding(bottom = 24.dp)
+  val bottomSheetModalState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
+  val displayName = remember { mutableStateOf(profile.displayName) }
+  val fullName = remember { mutableStateOf(profile.fullName) }
+  val chosenImage = remember { mutableStateOf<Bitmap?>(null) }
+  val profileImage = remember { mutableStateOf(profile.image) }
+  val scope = rememberCoroutineScope()
+  val scrollState = rememberScrollState()
+  val keyboardState by getKeyboardState()
+  var savedKeyboardState by remember { mutableStateOf(keyboardState) }
+
+  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(
-            "Display name:",
+            stringResource(R.string.your_chat_profile),
+            Modifier.padding(bottom = 24.dp),
+            style = MaterialTheme.typography.h1,
             color = MaterialTheme.colors.onBackground
           )
-          Spacer(Modifier.padding(horizontal = 4.dp))
           Text(
-            profile.displayName,
-            fontWeight = FontWeight.Bold,
-            color = MaterialTheme.colors.onBackground
+            stringResource(R.string.your_profile_is_stored_on_device_and_shared_only_with_contacts_simplex_cannot_see_it),
+            Modifier.padding(bottom = 24.dp),
+            color = MaterialTheme.colors.onBackground,
+            lineHeight = 22.sp
           )
+          if (editProfile.value) {
+            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 }
+                  }
+                }
+              }
+              ProfileNameTextField(displayName)
+              ProfileNameTextField(fullName)
+              Row {
+                TextButton(stringResource(R.string.cancel_verb)) {
+                  displayName.value = profile.displayName
+                  fullName.value = profile.fullName
+                  profileImage.value = profile.image
+                  editProfile.value = false
+                }
+                Spacer(Modifier.padding(horizontal = 8.dp))
+                TextButton(stringResource(R.string.save_and_notify_contacts)) {
+                  saveProfile(displayName.value, fullName.value, profileImage.value)
+                }
+              }
+            }
+          } else {
+            Column(
+              modifier = Modifier.fillMaxWidth(),
+              horizontalAlignment = Alignment.Start
+            ) {
+              Box(
+                Modifier
+                  .fillMaxWidth()
+                  .padding(bottom = 24.dp), contentAlignment = Alignment.Center
+              ) {
+                ProfileImage(192.dp, profile.image)
+                if (profile.image == null) {
+                  EditImageButton {
+                    editProfile.value = true
+                    scope.launch { bottomSheetModalState.show() }
+                  }
+                }
+              }
+              ProfileNameRow(stringResource(R.string.display_name__field), profile.displayName)
+              ProfileNameRow(stringResource(R.string.full_name__field), profile.fullName)
+              TextButton(stringResource(R.string.edit_verb)) { editProfile.value = true }
+            }
+          }
+          if (savedKeyboardState != keyboardState) {
+            LaunchedEffect(keyboardState) {
+              scope.launch {
+                savedKeyboardState = keyboardState
+                scrollState.animateScrollTo(scrollState.maxValue)
+              }
+            }
+          }
         }
-        Row(
-          Modifier.padding(bottom = 24.dp)
-        ) {
-          Text(
-            "Full name:",
-            color = MaterialTheme.colors.onBackground
-          )
-          Spacer(Modifier.padding(horizontal = 4.dp))
-          Text(
-            profile.fullName,
-            fontWeight = FontWeight.Bold,
-            color = MaterialTheme.colors.onBackground
-          )
-        }
-        Text(
-          "Edit",
-          color = MaterialTheme.colors.primary,
-          modifier = Modifier
-            .clickable(onClick = editProfileOn)
-        )
       }
     }
   }
 }
 
+@Composable
+private fun ProfileNameTextField(name: MutableState<String>) {
+  BasicTextField(
+    value = name.value,
+    onValueChange = { name.value = it },
+    modifier = Modifier
+      .padding(bottom = 24.dp)
+      .fillMaxWidth(),
+    textStyle = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground),
+    keyboardOptions = KeyboardOptions(
+      capitalization = KeyboardCapitalization.None,
+      autoCorrect = false
+    ),
+    singleLine = true
+  )
+}
+
+@Composable
+private fun ProfileNameRow(label: String, text: String) {
+  Row(Modifier.padding(bottom = 24.dp)) {
+    Text(
+      label,
+      color = MaterialTheme.colors.onBackground
+    )
+    Spacer(Modifier.padding(horizontal = 4.dp))
+    Text(
+      text,
+      fontWeight = FontWeight.Bold,
+      color = MaterialTheme.colors.onBackground
+    )
+  }
+}
+
+@Composable
+private fun TextButton(text: String, click: () -> Unit) {
+  Text(
+    text,
+    color = MaterialTheme.colors.primary,
+    modifier = Modifier.clickable(onClick = click),
+  )
+}
+
+@Composable
+fun EditImageButton(click: () -> Unit) {
+  IconButton(
+    onClick = click,
+    modifier = Modifier.background(Color(1f, 1f, 1f, 0.2f), shape = CircleShape)
+  ) {
+    Icon(
+      Icons.Outlined.PhotoCamera,
+      contentDescription = stringResource(R.string.edit_image),
+      tint = MaterialTheme.colors.primary,
+      modifier = Modifier.size(36.dp)
+    )
+  }
+}
+
+@Composable
+fun DeleteImageButton(click: () -> Unit) {
+  IconButton(onClick = click) {
+    Icon(
+      Icons.Outlined.Close,
+      contentDescription = stringResource(R.string.delete_image),
+      tint = MaterialTheme.colors.primary,
+    )
+  }
+}
+
 @Preview(showBackground = true)
 @Preview(
   uiMode = Configuration.UI_MODE_NIGHT_YES,
@@ -171,11 +258,10 @@ fun UserProfileLayout(
 fun PreviewUserProfileLayoutEditOff() {
   SimpleXTheme {
     UserProfileLayout(
+      close = {},
       profile = Profile.sampleData,
-      editProfile = false,
-      editProfileOff = {},
-      editProfileOn = {},
-      saveProfile = { _, _ -> }
+      editProfile = remember { mutableStateOf(false) },
+      saveProfile = { _, _, _ -> }
     )
   }
 }
@@ -190,11 +276,10 @@ fun PreviewUserProfileLayoutEditOff() {
 fun PreviewUserProfileLayoutEditOn() {
   SimpleXTheme {
     UserProfileLayout(
+      close = {},
       profile = Profile.sampleData,
-      editProfile = true,
-      editProfileOff = {},
-      editProfileOn = {},
-      saveProfile = { _, _ -> }
+      editProfile = remember { mutableStateOf(true) },
+      saveProfile = { _, _, _ -> }
     )
   }
 }

apps/android/app/src/main/res/values-ru/strings.xml

@@ -0,0 +1,332 @@
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name"><xliff:g id="appName">SimpleX</xliff:g></string>
+
+    <string name="thousand_abbreviation">т</string>
+
+    <!-- Connect via Link - MainActivity.kt -->
+    <string name="connect_via_contact_link">Соединиться через ссылку-контакт?</string>
+    <string name="connect_via_invitation_link">Соединиться через ссылку-приглашение?</string>
+    <string name="profile_will_be_sent_to_contact_sending_link">Ваш профиль будет отправлен контакту, от которого вы получили эту ссылку.</string>
+    <string name="connect_via_link_verb">Соединиться</string>
+
+    <!-- Server info - ChatModel.kt -->
+    <string name="server_connected">Соединение установлено</string>
+    <string name="server_connecting">Соединение устанавливается…</string>
+    <string name="connected_to_server_to_receive_messages_from_contact">Установлено соединение с сервером, через который вы получаете сообщения от этого контакта.</string>
+    <string name="trying_to_connect_to_server_to_receive_messages_with_error">Устанавливается соединение с сервером, через который вы получаете сообщения от этого контакта (ошибка: <xliff:g id="errorMsg">%1$s</xliff:g>).</string>
+    <string name="trying_to_connect_to_server_to_receive_messages">Устанавливается соединение с сервером, через который вы получаете сообщения от этого контакта.</string>
+
+    <!-- Item Content - ChatModel.kt -->
+    <string name="deleted_description">удалено</string>
+    <string name="sending_files_not_yet_supported">отправка файлов не поддерживается</string>
+    <string name="receiving_files_not_yet_supported">получение файлов не поддерживается</string>
+    <string name="sender_you_pronoun">вы</string>
+    <string name="unknown_message_format">неизвестный формат сообщения</string>
+    <string name="invalid_message_format">неверный формат сообщения</string>
+
+    <!-- PendingContactConnection - ChatModel.kt -->
+    <string name="connection_local_display_name">connection <xliff:g id="connection ID" example="1">%1$d</xliff:g></string>
+    <string name="display_name_connection_established">соединение установлено</string>
+    <string name="display_name_invited_to_connect">приглашение соединиться</string>
+    <string name="display_name_connecting">соединяется…</string>
+    <string name="description_you_shared_one_time_link">вы создали одноразовую ссылку</string>
+    <string name="description_via_contact_address_link">через ссылку-контакт</string>
+    <string name="description_via_one_time_link">через одноразовую ссылку</string>
+
+    <!-- SMP Server Information - SimpleXAPI.kt -->
+    <string name="error_saving_smp_servers">Ошибка при сохранении SMP серверов</string>
+    <string name="ensure_smp_server_address_are_correct_format_and_unique">Пожалуйста, проверьте, что адреса SMP серверов имеют правильный формат, каждый адрес на отдельной строке и не повторяется.</string>
+
+    <!-- API Error Responses - SimpleXAPI.kt -->
+    <string name="contact_already_exists">Существующий контакт</string>
+    <string name="you_are_already_connected_to_vName_via_this_link">Вы уже соединены с <xliff:g id="contactName" example="Alice">%1$s!</xliff:g> через эту ссылку.</string>
+    <string name="invalid_connection_link">Ошибка в ссылке контакта</string>
+    <string name="please_check_correct_link_and_maybe_ask_for_a_new_one">Пожалуйста, проверьте, что вы использовали правильную ссылку, или попросите ваш контакт отправить вам новую.</string>
+    <string name="connection_error_auth">Ошибка соединения (AUTH)</string>
+    <string name="connection_error_auth_desc">Возможно, ваш контакт удалил ссылку, или она уже была использована. Если это не так, то это может быть ошибкой - пожалуйста, сообщите нам об этом.\nЧтобы установить соединение, попросите ваш контакт создать еще одну ссылку и проверьте ваше соединение с сетью.</string>
+    <string name="cannot_delete_contact">Невозможно удалить контакт!</string>
+    <string name="contact_cannot_be_deleted_as_they_are_in_groups">Контакт <xliff:g id="contactName" example="Jane Doe">%1$s!</xliff:g> не может быть удален, так как является членом групп(ы) <xliff:g id="groups" example="[team, chess club]">%2$s</xliff:g>.</string>
+    <string name="icon_descr_instant_notifications">Мгновенные уведомления</string>
+    <string name="error_deleting_contact">Ошибка удаления контакта</string>
+    <string name="error_deleting_group">Ошибка удаления группы</string>
+    <string name="error_deleting_contact_request">Ошибка удаления запроса</string>
+    <string name="error_deleting_pending_contact_connection">Ошибка удаления ожидаемого соединения</string>
+
+    <!-- background service notice - SimpleXAPI.kt -->
+    <string name="private_instant_notifications">Приватные мгновенные уведомления!</string>
+    <string name="to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery">Чтобы защитить ваши личные данные, вместо уведомлений от сервера приложение запускает <b>фоновый сервис <xliff:g id="appName">SimpleX</xliff:g></b>, который потребляет несколько процентов батареи в день.</string>
+    <string name="it_can_disabled_via_settings_notifications_still_shown"><b>Он может быть выключен через Настройки</b> – вы продолжите получать уведомления о сообщениях пока приложение запущено.</string>
+
+    <!-- SimpleX Chat foreground Service -->
+    <string name="simplex_service_notification_title"><xliff:g id="appNameFull">SimpleX Chat</xliff:g> сервис</string>
+    <string name="simplex_service_notification_text">Приём сообщений…</string>
+
+    <!-- Chat Actions - ChatItemView.kt (and general) -->
+    <string name="reply_verb">Ответить</string>
+    <string name="share_verb">Поделиться</string>
+    <string name="copy_verb">Копировать</string>
+    <string name="save_verb">Сохранить</string>
+    <string name="edit_verb">Редактировать</string>
+    <string name="delete_verb">Удалить</string>
+    <string name="delete_message__question">Удалить сообщение?</string>
+    <string name="delete_message_cannot_be_undone_warning">Сообщение будет удалено – это действие нельзя отменить!</string>
+    <string name="for_me_only">Только для меня</string>
+    <string name="for_everybody">Для всех</string>
+
+    <!-- CIMetaView.kt -->
+    <string name="icon_descr_edited">отредактировано</string>
+    <string name="icon_descr_sent_msg_status_sent">отправлено</string>
+    <string name="icon_descr_sent_msg_status_unauthorized_send">ошибка авторизации при отправке</string>
+    <string name="icon_descr_sent_msg_status_send_failed">ошибка при отправке</string>
+    <string name="icon_descr_received_msg_status_unread">не прочитано</string>
+
+    <!-- ChatListView.kt -->
+    <string name="personal_welcome">Здравствуйте <xliff:g>%1$s</xliff:g>!</string>
+    <string name="welcome">Здравствуйте!</string>
+    <string name="this_text_is_available_in_settings">Этот текст можно найти в Настройках</string>
+    <string name="your_chats">Ваши чаты</string>
+    <string name="contact_connection_pending">соединяется…</string>
+
+    <!-- ComposeView.kt, helpers -->
+    <string name="attach">Прикрепить</string>
+    <string name="icon_descr_context">Значок контекста</string>
+    <string name="icon_descr_cancel_image_preview">Удалить превью изображения</string>
+    <string name="icon_descr_cancel_file_preview">Удалить превью файла</string>
+
+    <!-- Images - CIImageView.kt -->
+    <string name="image_descr">Изображение</string>
+    <string name="icon_descr_waiting_for_image">Ожидается прием изображения</string>
+    <string name="icon_descr_image_snd_complete">Изображение отправлено</string>
+    <string name="waiting_for_image">Ожидается прием изображения</string>
+    <string name="image_will_be_received_when_contact_is_online">Изображение будет принято, когда ваш контакт будет в сети, подождите или проверьте позже!</string>
+    <string name="image_saved">Изображение сохранено в Галерею</string>
+
+    <!-- Files - CIFileView.kt -->
+    <string name="icon_descr_file">Файл</string>
+    <string name="large_file">Большой файл!</string>
+    <string name="contact_sent_large_file">Ваш контакт отправил файл, размер которого превышает поддерживаемый в настоящее время максимальный размер (<xliff:g id="maxFileSize">%1$s</xliff:g>).</string>
+    <string name="maximum_supported_file_size">В настоящее время максимальный поддерживаемый размер файла составляет <xliff:g id="maxFileSize">%1$s</xliff:g>.</string>
+    <string name="waiting_for_file">Ожидается прием файла</string>
+    <string name="file_will_be_received_when_contact_is_online">Файл будет принят, когда ваш контакт будет в сети, подождите или проверьте позже!</string>
+    <string name="file_saved">Файл сохранен</string>
+    <string name="file_not_found">Файл не найден</string>
+    <string name="error_saving_file">Ошибка сохранения файла</string>
+
+    <!-- Chat Info Actions - ChatInfoView.kt -->
+    <string name="delete_contact__question">Удалить контакт?</string>
+    <string name="delete_contact_all_messages_deleted_cannot_undo_warning">Контакт и все сообщения будут удалены - это действие нельзя отменить!</string>
+    <string name="button_delete_contact">Удалить контакт</string>
+    <string name="icon_descr_server_status_connected">Соединение с сервером установлено</string>
+    <string name="icon_descr_server_status_disconnected">Соединение с сервером не установлено</string>
+    <string name="icon_descr_server_status_error">Ошибка соединения с сервером</string>
+    <string name="icon_descr_server_status_pending">Ожидается соединение с сервером</string>
+
+    <!-- Message Actions - SendMsgView.kt -->
+    <string name="icon_descr_send_message">Отправить сообщение</string>
+
+    <!-- General Actions / Responses -->
+    <string name="back">Назад</string>
+    <string name="cancel_verb">Отменить</string>
+    <string name="confirm_verb">Подтвердить</string>
+    <string name="ok">Oк</string>
+    <string name="no_details">нет описания</string>
+    <string name="add_contact">Добавить контакт</string>
+
+    <!-- NewChatSheet -->
+    <string name="create_one_time_link">Создать одноразовую ссылку</string>
+    <string name="paste_received_link">Вставить полученную ссылку</string>
+    <string name="scan_QR_code">Сканировать QR код</string>
+    <string name="to_share_with_your_contact">(чтобы отправить вашему контакту)</string>
+    <string name="in_person_or_in_video_call__bracketed">(при встрече или через видеозвонок)</string>
+    <string name="paste_received_link_from_clipboard">(вставить ссылку из буфера обмена)</string>
+
+    <!-- GetImageView -->
+    <string name="toast_permission_denied">Разрешение не получено!</string>
+    <string name="use_camera_button">Камера</string>
+    <string name="from_gallery_button">Галерея</string>
+    <string name="choose_file">Файлы\n(v2.0)</string>
+
+    <!-- help - ChatHelpView.kt -->
+    <string name="thank_you_for_installing_simplex">Спасибо, что установили <xliff:g id="appNameFull">SimpleX Chat</xliff:g>!</string>
+    <string name="you_can_connect_to_simplex_chat_founder">Вы можете <font color="#0088ff">соединиться с разработчиками</font>, чтобы задать любые вопросы или получать уведомления о новых версиях.</string>
+    <string name="to_start_a_new_chat_help_header">Чтобы начать новый чат</string>
+    <string name="chat_help_tap_button">Нажмите кнопку</string>
+    <string name="above_then_preposition_continuation">сверху, затем:</string>
+    <string name="add_new_contact_to_create_one_time_QR_code"><b>Добавить новый контакт</b>: чтобы создать одноразовый QR код/ссылку для вашего контакта.</string>
+    <string name="scan_QR_code_to_connect_to_contact_who_shows_QR_code"><b>Сканировать QR код</b>: чтобы соединиться с контактом, который показывает вам QR код.</string>
+    <string name="to_connect_via_link_title">Чтобы соединиться через ссылку</string>
+    <string name="if_you_received_simplex_invitation_link_you_can_open_in_browser">Если вы получили ссылку с приглашением из <xliff:g id="appName">SimpleX Chat</xliff:g>, вы можете открыть ее в браузере:</string>
+    <string name="desktop_scan_QR_code_from_app_via_scan_QR_code">💻 на компьютере: сосканируйте показанный QR код из приложения через <b>Сканировать QR код</b>.</string>
+    <string name="mobile_tap_open_in_mobile_app_then_tap_connect_in_app">📱 на мобильном: намжите кнопку <b>Open in mobile app</b> на веб странице, затем нажмите <b>Соединиться</b> в приложении.</string>
+
+    <!-- Contact Request Alert Dialogue - CharListNavLinkView.kt -->
+    <string name="accept_connection_request__question">Принять запрос на соединение?</string>
+    <string name="if_you_choose_to_reject_the_sender_will_not_be_notified">Отправителю НЕ будет послано уведомление, если вы отклоните запрос на соединение.</string>
+    <string name="accept_contact_button">Принять</string>
+    <string name="reject_contact_button">Отклонить</string>
+
+    <!-- Pending contact connection alert dialogues -->
+    <string name="you_invited_your_contact">Вы пригласили ваш контакт</string>
+    <string name="you_accepted_connection">Вы приняли приглашение соединиться</string>
+    <string name="delete_pending_connection__question">Удалить ожидаемое соединение?</string>
+    <string name="contact_you_shared_link_with_wont_be_able_to_connect">Контакт, которому вы отправили эту ссылку, не сможет соединиться!</string>
+    <string name="connection_you_accepted_will_be_cancelled">Подтвержденное соединение будет отменено!</string>
+
+    <!-- Connection Pending Alert Dialogue - ChatListNavLinkView.kt -->
+    <string name="alert_title_contact_connection_pending">Соединение еще не установлено!</string>
+    <string name="alert_text_connection_pending_they_need_to_be_online_can_delete_and_retry">Ваш контакт должен быть в сети чтобы установить соединение.\nВы можете отменить соединение и удалить контакт (и попробовать позже с другой ссылкой).</string>
+
+    <!-- Contact Request Information - ContactRequestView.kt -->
+    <string name="contact_wants_to_connect_with_you">хочет соединиться с вами!</string>
+
+    <!-- Image Placeholder - ChatInfoImage.kt -->
+    <string name="icon_descr_profile_image_placeholder">аватар не установлен</string>
+    <string name="image_descr_profile_image">аватар</string>
+
+    <!-- Content Descriptions -->
+    <string name="icon_descr_close_button">закрыть</string>
+    <string name="image_descr_link_preview">изображение превью ссылки</string>
+    <string name="icon_descr_cancel_link_preview">удалить превью ссылки</string>
+    <string name="icon_descr_settings">Настройки</string>
+    <string name="image_descr_qr_code">QR код</string>
+    <string name="icon_descr_address"><xliff:g id="appName">SimpleX</xliff:g> адрес</string>
+    <string name="icon_descr_help">Помощь</string>
+    <string name="icon_descr_simplex_team"><xliff:g id="appName">SimpleX</xliff:g> команда</string>
+    <string name="image_descr_simplex_logo"><xliff:g id="appName">SimpleX</xliff:g> логотип</string>
+    <string name="icon_descr_email">Email</string>
+
+    <!-- Add Contact - AddContactView.kt -->
+    <string name="invalid_QR_code">Неверный QR код</string>
+    <string name="this_QR_code_is_not_a_link">Этот QR код не является ссылкой!</string>
+    <string name="invalid_contact_link">Неверная ссылка!</string>
+    <string name="this_link_is_not_a_valid_connection_link">Эта ссылка не является ссылкой-приглашением!</string>
+    <string name="connection_request_sent">Запрос на соединение послан!</string>
+    <string name="you_will_be_connected_when_your_connection_request_is_accepted">Соединение будет установлено когда ваш запрос будет принят. Пожалуйста, подождите или проверьте позже!</string>
+    <string name="you_will_be_connected_when_your_contacts_device_is_online">Соединение будет установлено когда ваш контакт будет онлайн. Пожалуйста, подождите или проверьте позже!</string>
+    <string name="show_QR_code_for_your_contact_to_scan_from_the_app__multiline">Покажите QR код вашему контакту, чтобы сосканировать его из приложения</string>
+    <string name="if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel">Если вы не можете встретиться лично, вы можете <b>показать QR код во время видеозвонка</b> или отправить ссылку через любой другой канал связи.</string>
+    <string name="your_chat_profile_will_be_sent_to_your_contact">Ваш профиль будет отправлен\nвашему контакту</string>
+    <string name="if_you_cannot_meet_in_person_scan_QR_in_video_call_or_ask_for_invitation_link">Если вы не можете встретиться лично, вы можете <b>сосканировать QR код во время видеозвонка</b>, или ваш контакт может отправить вам ссылку.</string>
+    <string name="share_invitation_link">Поделиться ссылкой</string>
+    <string name="paste_connection_link_below_to_connect">Чтобы соединиться, вставьте в это поле ссылку, полученную от вашего контакта.</string>
+
+
+    <!-- settings - SettingsView.kt -->
+    <string name="your_settings">Настройки</string>
+    <string name="your_simplex_contact_address">Ваш <xliff:g id="appName">SimpleX</xliff:g> адрес</string>
+    <string name="about_simplex_chat">Информация о <xliff:g id="appNameFull">SimpleX Chat</xliff:g></string>
+    <string name="how_to_use_simplex_chat">Как использовать</string>
+    <string name="markdown_help">Форматирование сообщений</string>
+    <string name="markdown_in_messages">Форматирование сообщений</string>
+    <string name="chat_with_the_founder">Соединиться с разработчиками</string>
+    <string name="send_us_an_email">Отправить email</string>
+    <string name="private_notifications">Приватные уведомления</string>
+    <string name="chat_console">Консоль</string>
+    <string name="smp_servers">SMP серверы</string>
+    <string name="install_simplex_chat_for_terminal"><font color="#0088ff"><xliff:g id="appNameFull">SimpleX Chat</xliff:g> для терминала</font></string>
+    <string name="use_simplex_chat_servers__question">Использовать серверы предосталенные <xliff:g id="appNameFull">SimpleX Chat</xliff:g>?</string>
+    <string name="saved_SMP_servers_will_br_removed">Сохраненные SMP серверы будут удалены.</string>
+    <string name="your_SMP_servers">Ваши SMP серверы</string>
+    <string name="configure_SMP_servers">Настройка SMP серверов</string>
+    <string name="using_simplex_chat_servers">Используются серверы предоставленные <xliff:g id="appNameFull">SimpleX Chat</xliff:g>.</string>
+    <string name="enter_one_SMP_server_per_line">Введите SMP серверы, каждый сервер в отдельной строке:</string>
+    <string name="how_to">Инфо</string>
+    <string name="save_servers_button">Сохранить</string>
+
+    <!-- Address Items - UserAddressView.kt -->
+    <string name="create_address">Создать адрес</string>
+    <string name="delete_address__question">Удалить адрес?</string>
+    <string name="all_your_contacts_will_remain_connected">Все контакты, которые соединились через этот адрес, сохранятся.</string>
+    <string name="your_chat_address">Ваш <xliff:g id="appName">SimpleX</xliff:g> адрес</string>
+    <string name="you_can_share_your_address_anybody_will_be_able_to_connect">Вы можете использовать адрес как ссылку или как QR код - через него можно с вами соединиться.</string>
+    <string name="if_you_delete_address_you_wont_lose_contacts">Вы сможете удалить адрес, сохранив контакты, которые через него соединились.</string>
+    <string name="share_link">Поделиться\nссылкой</string>
+    <string name="delete_address">Удалить\nадрес</string>
+
+    <!-- User profile details - UserProfileView.kt -->
+    <string name="display_name__field">Имя профиля:</string>
+    <string name="full_name__field">"Полное имя:</string>
+    <string name="your_chat_profile">Ваш профиль</string>
+    <string name="your_profile_is_stored_on_device_and_shared_only_with_contacts_simplex_cannot_see_it">Ваш профиль хранится на вашем устройстве и отправляется только вашим контактам.\n\n<xliff:g id="appName">SimpleX</xliff:g> серверы не могут получить доступ к вашему профилю.</string>
+    <string name="edit_image">Поменять аватар</string>
+    <string name="delete_image">Удалить аватар</string>
+    <string name="save_and_notify_contacts">Сохранить (и послать обновление контактам)</string>
+
+    <!-- Welcome Prompts - WelcomeView.kt -->
+    <string name="you_control_your_chat">Вы котролируете ваш чат!</string>
+    <string name="the_messaging_and_app_platform_protecting_your_privacy_and_security">Платформа для сообщений и приложений, которая защищает вашу личную информацию и безопасность.</string>
+    <string name="we_do_not_store_contacts_or_messages_on_servers">Мы не храним ваши контакты и сообщения (после доставки) на серверах.</string>
+    <string name="create_profile">Создать профиль</string>
+    <string name="your_profile_is_stored_on_your_device">Ваш профиль, контакты и доставленные сообщения хранятся на вашем устройстве.</string>
+    <string name="profile_is_only_shared_with_your_contacts">Профиль отправляется только вашим контактам.</string>
+    <string name="display_name_cannot_contain_whitespace">Имя профиля не может содержать пробелы.</string>
+    <string name="display_name">Имя профиля</string>
+    <string name="full_name_optional__prompt">Полное имя (не обязательно)</string>
+    <string name="create_profile_button">Создать</string>
+    <string name="about_simplex">О SimpleX</string>
+
+    <!-- markdown demo - MarkdownHelpView.kt -->
+    <string name="how_to_use_markdown">Как форматировать</string>
+    <string name="you_can_use_markdown_to_format_messages__prompt">Вы можете форматировать сообщения:</string>
+    <string name="bold">жирный</string>
+    <string name="italic">курсив</string>
+    <string name="strikethrough">зачеркнуть</string>
+    <string name="a_plus_b">a + b</string>
+    <string name="colored">цвет</string>
+    <string name="secret">секрет</string>
+    <string name="connect_via_link">Соединиться через ссылку</string>
+    <string name="this_string_is_not_a_connection_link">Эта строка не является ссылкой-приглашением!</string>
+    <string name="you_can_also_connect_by_clicking_the_link">Вы также можете соединиться, открыв ссылку там, где вы её получили. Если ссылка откроется в браузере, нажмите кнопку <b>Open in mobile app</b>.</string>
+    <string name="add_contact_to_start_new_chat">Добавьте контакт, чтобы начать разговор:</string>
+
+    <!-- CICallStatus -->
+    <string name="callstatus_calling">входящий звонок…</string>
+    <string name="callstatus_missed">пропущенный звонок</string>
+    <string name="callstatus_rejected">отклоненный звонок</string>
+    <string name="callstatus_accepted">принятый звонок</string>
+    <string name="callstatus_connecting">соединяется…</string>
+    <string name="callstatus_in_progress">активный звонок</string>
+    <string name="callstatus_ended">звонок завершён <xliff:g id="duration" example="01:15">%1$s!</xliff:g></string>
+    <string name="callstatus_error">ошибка соединения</string>
+
+    <!-- CallState -->
+    <string name="callstate_starting">инициализация…</string>
+    <string name="callstate_waiting_for_answer">ожидается ответ…</string>
+    <string name="callstate_waiting_for_confirmation">ожидается подтверждение…</string>
+    <string name="callstate_received_answer">получен ответ…</string>
+    <string name="callstate_connecting">соединяется…</string>
+    <string name="callstate_connected">соединено</string>
+
+    <!-- SimpleXInfo -->
+    <string name="next_generation_of_private_messaging">Новое поколение приватных сообщений</string>
+    <string name="privacy_redefined">Более конфиденциальный</string>
+    <string name="first_platform_without_user_ids">Первая в мире платформа без идентификаторов пользователей.</string>
+    <string name="immune_to_spam_and_abuse">Защищен от спама</string>
+    <string name="people_can_connect_only_via_links_you_share">С вами можно соединиться только через созданные вами ссылки.</string>
+    <string name="decentralized">Децентрализованный</string>
+    <string name="opensource_protocol_and_code_anybody_can_run_servers">Открытый протокол и код - кто угодно может запустить сервер.</string>
+    <string name="create_your_profile">Создать профиль</string>
+    <string name="make_private_connection">Добавьте контакт</string>
+    <string name="how_it_works">Как это работает</string>
+
+    <!-- How SimpleX Works -->
+    <string name="how_simplex_works">Как <xliff:g id="appName">SimpleX</xliff:g> работает</string>
+    <string name="many_people_asked_how_can_it_deliver">Много пользователей спросили: <i>как <xliff:g id="appName">SimpleX</xliff:g> доставляет сообщения без идентификаторов пользователей?</i></string>
+    <string name="to_protect_privacy_simplex_has_ids_for_queues">Чтобы защитить вашу конфиденциальность, вместо ID пользователей, которые есть в других платформах, <xliff:g id="appName">SimpleX</xliff:g> использует ID для очередей сообщений, разные для каждого контакта.</string>
+    <string name="you_control_servers_to_receive_your_contacts_to_send">Вы определяете через какие серверы вы <b>получаете сообщения</b>, ваши контакты - серверы, которые вы используете для отправки.</string>
+    <string name="only_client_devices_store_contacts_groups_e2e_encrypted_messages">Только пользовательские устройства хранят контакты, группы и сообщения, которые отправляются <b>с двухуровневым end-to-end шифрованием</b>.</string>
+    <string name="read_more_in_github">Узнайте больше из нашего GitHub репозитория.</string>
+    <string name="read_more_in_github_with_link">Узнайте больше из нашего <font color="#0088ff">GitHub репозитория</font>.</string>
+
+    <!-- MakeConnection -->
+    <string name="to_make_your_first_private_connection_choose">Чтобы добавить ваш первый контакт, выберите <b>одно из</b>:</string>
+    <string name="create_1_time_link_qr_code">Создать ссылку / QR код</string>
+    <string name="it_s_secure_to_share__only_one_contact_can_use_it">Ей безопасно поделиться - только один контакт может использовать её.</string>
+    <string name="paste_the_link_you_received">Вставьте полученную ссылку</string>
+    <string name="or_open_the_link_in_the_browser_and_tap_open_in_mobile">Или откройте ссылку в браузере и нажмите <b>Open in mobile</b>.</string>
+    <string name="scan_contact_s_qr_code">Сосканировать QR код контакта</string>
+    <string name="in_person_or_via_a_video_call__the_most_secure_way_to_connect">При встрече или в видеозвонке – самый безопасный способ установить соединение</string>
+    <string name="or">или</string>
+    <string name="connect_with_the_developers">Соединиться с разработчиками</string>
+    <string name="to_ask_any_questions_and_to_receive_simplex_chat_updates">Чтобы задать вопросы и получать уведомления о <xliff:g id="appNameFull">SimpleX Chat</xliff:g>.</string>
+</resources>

apps/android/app/src/main/res/values/strings.xml

@@ -1,3 +1,333 @@
-<resources>
-  <string name="app_name">SimpleX</string>
-</resources>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="app_name"><xliff:g id="appName">SimpleX</xliff:g></string>
+
+  <string name="thousand_abbreviation">k</string>
+
+  <!-- Connect via Link - MainActivity.kt -->
+  <string name="connect_via_contact_link">Connect via contact link?</string>
+  <string name="connect_via_invitation_link">Connect via invitation link?</string>
+  <string name="profile_will_be_sent_to_contact_sending_link">Your profile will be sent to the contact that you received this link from.</string>
+  <string name="connect_via_link_verb">Connect</string>
+
+  <!-- Server info - ChatModel.kt -->
+  <string name="server_connected">Server connected</string>
+  <string name="server_connecting">Connecting server…</string>
+  <string name="connected_to_server_to_receive_messages_from_contact">You are connected to the server used to receive messages from this contact.</string>
+  <string name="trying_to_connect_to_server_to_receive_messages_with_error">Trying to connect to the server used to receive messages from this contact (error: <xliff:g id="errorMsg">%1$s</xliff:g>).</string>
+  <string name="trying_to_connect_to_server_to_receive_messages">Trying to connect to the server used to receive messages from this contact.</string>
+
+  <!-- Item Content - ChatModel.kt -->
+  <string name="deleted_description">deleted</string>
+  <string name="sending_files_not_yet_supported">sending files is not supported yet</string>
+  <string name="receiving_files_not_yet_supported">receiving files is not supported yet</string>
+  <string name="sender_you_pronoun">you</string>
+  <string name="unknown_message_format">unknown message format</string>
+  <string name="invalid_message_format">invalid message format</string>
+
+  <!-- PendingContactConnection - ChatModel.kt -->
+  <string name="connection_local_display_name">connection <xliff:g id="connection ID" example="1">%1$d</xliff:g></string>
+  <string name="display_name_connection_established">connection established</string>
+  <string name="display_name_invited_to_connect">invited to connect</string>
+  <string name="display_name_connecting">connecting…</string>
+  <string name="description_you_shared_one_time_link">you shared one-time link</string>
+  <string name="description_via_contact_address_link">via contact address link</string>
+  <string name="description_via_one_time_link">via one-time link</string>
+
+  <!-- SMP Server Information - SimpleXAPI.kt -->
+  <string name="error_saving_smp_servers">Error saving SMP servers</string>
+  <string name="ensure_smp_server_address_are_correct_format_and_unique">Make sure SMP server addresses are in correct format, line separated and are not duplicated.</string>
+
+  <!-- API Error Responses - SimpleXAPI.kt -->
+  <string name="contact_already_exists">Contact already exists</string>
+  <string name="you_are_already_connected_to_vName_via_this_link">You are already connected to <xliff:g id="contactName" example="Alice">%1$s!</xliff:g> via this link.</string>
+  <string name="invalid_connection_link">Invalid connection link</string>
+  <string name="please_check_correct_link_and_maybe_ask_for_a_new_one">Please check that you used the correct link or ask your contact to send you another one.</string>
+  <string name="connection_error_auth">Connection error (AUTH)</string>
+  <string name="connection_error_auth_desc">Unless your contact deleted the connection or this link was already used, it might be a bug - please report it.\nTo connect, please ask your contact to create another connection link and check that you have a stable network connection.</string>
+  <string name="cannot_delete_contact">Can\'t delete contact!</string>
+  <string name="contact_cannot_be_deleted_as_they_are_in_groups">Contact <xliff:g id="contactName" example="Jane Doe">%1$s!</xliff:g> cannot be deleted, they are a member of the group(s) <xliff:g id="groups" example="[team, chess club]">%2$s</xliff:g>.</string>
+  <string name="icon_descr_instant_notifications">Instant notifications</string>
+  <string name="error_deleting_contact">Error deleting contact</string>
+  <string name="error_deleting_group">Error deleting group</string>
+  <string name="error_deleting_contact_request">Error deleting contact request</string>
+  <string name="error_deleting_pending_contact_connection">Error deleting pending contact connection</string>
+
+  <!-- background service notice - SimpleXAPI.kt -->
+  <string name="private_instant_notifications">Private instant notifications!</string>
+  <string name="to_preserve_privacy_simplex_has_background_service_instead_of_push_notifications_it_uses_a_few_pc_battery">To preserve your privacy, instead of push notifications the app has a <b><xliff:g id="appName">SimpleX</xliff:g> background service</b> – it uses a few percent of the battery per day.</string>
+  <string name="it_can_disabled_via_settings_notifications_still_shown"><b>It can be disabled via settings</b> – notifications will still be shown while the app is running.</string>
+
+  <!-- SimpleX Chat foreground Service -->
+  <string name="simplex_service_notification_title"><xliff:g id="appNameFull">SimpleX Chat</xliff:g> service</string>
+  <string name="simplex_service_notification_text">Receiving messages…</string>
+
+  <!-- Chat Actions - ChatItemView.kt (and general) -->
+  <string name="reply_verb">Reply</string>
+  <string name="share_verb">Share</string>
+  <string name="copy_verb">Copy</string>
+  <string name="save_verb">Save</string>
+  <string name="edit_verb">Edit</string>
+  <string name="delete_verb">Delete</string>
+  <string name="delete_message__question">Delete message?</string>
+  <string name="delete_message_cannot_be_undone_warning">Message will be deleted - this cannot be undone!</string>
+  <string name="for_me_only">For me only</string>
+  <string name="for_everybody">For everyone</string>
+
+  <!-- CIMetaView.kt -->
+  <string name="icon_descr_edited">edited</string>
+  <string name="icon_descr_sent_msg_status_sent">sent</string>
+  <string name="icon_descr_sent_msg_status_unauthorized_send">unauthorized send</string>
+  <string name="icon_descr_sent_msg_status_send_failed">send failed</string>
+  <string name="icon_descr_received_msg_status_unread">unread</string>
+
+  <!-- ChatListView.kt -->
+  <string name="personal_welcome">Welcome <xliff:g>%1$s</xliff:g>!</string>
+  <string name="welcome">Welcome!</string>
+  <string name="this_text_is_available_in_settings">This text is available in settings</string>
+  <string name="your_chats">Your chats</string>
+  <string name="contact_connection_pending">connecting…</string>
+
+  <!-- ComposeView.kt, helpers -->
+  <string name="attach">Attach</string>
+  <string name="icon_descr_context">Context icon</string>
+  <string name="icon_descr_cancel_image_preview">Cancel image preview</string>
+  <string name="icon_descr_cancel_file_preview">Cancel file preview</string>
+
+  <!-- Images - CIImageView.kt -->
+  <string name="image_descr">Image</string>
+  <string name="icon_descr_waiting_for_image">Waiting for image</string>
+  <string name="icon_descr_image_snd_complete">Image sent</string>
+  <string name="waiting_for_image">Waiting for image</string>
+  <string name="image_will_be_received_when_contact_is_online">Image will be received when your contact is online, please wait or check later!</string>
+  <string name="image_saved">Image saved to Gallery</string>
+
+  <!-- Files - CIFileView.kt -->
+  <string name="icon_descr_file">File</string>
+  <string name="large_file">Large file!</string>
+  <string name="contact_sent_large_file">Your contact sent a file that is larger than currently supported maximum size (<xliff:g id="maxFileSize">%1$s</xliff:g>).</string>
+  <string name="maximum_supported_file_size">Currently maximum supported file size is <xliff:g id="maxFileSize">%1$s</xliff:g>.</string>
+  <string name="waiting_for_file">Waiting for file</string>
+  <string name="file_will_be_received_when_contact_is_online">File will be received when your contact is online, please wait or check later!</string>
+  <string name="file_saved">File saved</string>
+  <string name="file_not_found">File not found</string>
+  <string name="error_saving_file">Error saving file</string>
+
+  <!-- Chat Info Actions - ChatInfoView.kt -->
+  <string name="delete_contact__question">Delete contact?</string>
+  <string name="delete_contact_all_messages_deleted_cannot_undo_warning">Contact and all messages will be deleted - this cannot be undone!</string>
+  <string name="button_delete_contact">Delete contact</string>
+  <string name="icon_descr_server_status_connected">Connected</string>
+  <string name="icon_descr_server_status_disconnected">Disconnected</string>
+  <string name="icon_descr_server_status_error">Error</string>
+  <string name="icon_descr_server_status_pending">Pending</string>
+
+  <!-- Message Actions - SendMsgView.kt -->
+  <string name="icon_descr_send_message">Send Message</string>
+
+  <!-- General Actions / Responses -->
+  <string name="back">Back</string>
+  <string name="cancel_verb">Cancel</string>
+  <string name="confirm_verb">Confirm</string>
+  <string name="ok">Ok</string>
+  <string name="no_details">no details</string>
+  <string name="add_contact">Add contact</string>
+
+  <!-- NewChatSheet -->
+  <string name="add_contact_to_start_new_chat">Add contact to start a new chat:</string>
+  <string name="create_one_time_link">Create link / QR code</string>
+  <string name="paste_received_link">Connect via received link</string>
+  <string name="scan_QR_code">Scan QR code</string>
+  <string name="to_share_with_your_contact">(to share with your contact)</string>
+  <string name="in_person_or_in_video_call__bracketed">(in person or in video call)</string>
+  <string name="paste_received_link_from_clipboard">(paste link from clipboard)</string>
+
+  <!-- GetImageView -->
+  <string name="toast_permission_denied">Permission Denied!</string>
+  <string name="use_camera_button">Use Camera</string>
+  <string name="from_gallery_button">From Gallery</string>
+  <string name="choose_file">Choose file\n(new in v2.0)</string>
+
+  <!-- help - ChatHelpView.kt -->
+  <string name="thank_you_for_installing_simplex">Thank you for installing <xliff:g id="appNameFull">SimpleX Chat</xliff:g>!</string>
+  <string name="you_can_connect_to_simplex_chat_founder">You can <font color="#0088ff">connect to <xliff:g id="appNameFull">SimpleX Chat</xliff:g> developers to ask any questions and to receive updates</font>.</string>
+  <string name="to_start_a_new_chat_help_header">To start a new chat</string>
+  <string name="chat_help_tap_button">Tap button</string>
+  <string name="above_then_preposition_continuation">above, then:</string>
+  <string name="add_new_contact_to_create_one_time_QR_code"><b>Add new contact</b>: to create your one-time QR Code for your contact.</string>
+  <string name="scan_QR_code_to_connect_to_contact_who_shows_QR_code"><b>Scan QR code</b>: to connect to your contact who shows QR code to you.</string>
+  <string name="to_connect_via_link_title">To connect via link</string>
+  <string name="if_you_received_simplex_invitation_link_you_can_open_in_browser">If you received <xliff:g id="appName">SimpleX Chat</xliff:g> invitation link, you can open it in your browser:</string>
+  <string name="desktop_scan_QR_code_from_app_via_scan_QR_code">💻 desktop: scan displayed QR code from the app, via <b>Scan QR code</b>.</string>
+  <string name="mobile_tap_open_in_mobile_app_then_tap_connect_in_app">📱 mobile: tap <b>Open in mobile app</b>, then tap <b>Connect</b> in the app.</string>
+
+  <!-- Contact Request Alert Dialogue - ChatListNavLinkView.kt -->
+  <string name="accept_connection_request__question">Accept connection request?</string>
+  <string name="if_you_choose_to_reject_the_sender_will_not_be_notified">If you choose to reject sender will NOT be notified.</string>
+  <string name="accept_contact_button">Accept</string>
+  <string name="reject_contact_button">Reject</string>
+
+  <!-- Pending contact connection alert dialogues -->
+  <string name="you_invited_your_contact">You invited your contact</string>
+  <string name="you_accepted_connection">You accepted connection</string>
+  <string name="delete_pending_connection__question">Delete pending connection?</string>
+  <string name="contact_you_shared_link_with_wont_be_able_to_connect">The contact you shared this link with will NOT be able to connect!</string>
+  <string name="connection_you_accepted_will_be_cancelled">The connection you accepted will be cancelled!</string>
+
+  <!-- Contact Pending Alert Dialogue - ChatListNavLinkView.kt -->
+  <string name="alert_title_contact_connection_pending">Contact is not connected yet!</string>
+  <string name="alert_text_connection_pending_they_need_to_be_online_can_delete_and_retry">Your contact needs to be online for the connection to complete.\nYou can cancel this connection and remove the contact (and try later with a new link).</string>
+
+  <!-- Contact Request Information - ContactRequestView.kt -->
+  <string name="contact_wants_to_connect_with_you">wants to connect to you!</string>
+
+  <!-- Image Placeholder - ChatInfoImage.kt -->
+  <string name="icon_descr_profile_image_placeholder">profile image placeholder</string>
+  <string name="image_descr_profile_image">profile image</string>
+
+  <!-- Content Descriptions -->
+  <string name="icon_descr_close_button">Close button</string>
+  <string name="image_descr_link_preview">link preview image</string>
+  <string name="icon_descr_cancel_link_preview">cancel link preview</string>
+  <string name="icon_descr_settings">Settings</string>
+  <string name="image_descr_qr_code">QR Code</string>
+  <string name="icon_descr_address"><xliff:g id="appName">SimpleX</xliff:g> Address</string>
+  <string name="icon_descr_help">help</string>
+  <string name="icon_descr_simplex_team"><xliff:g id="appName">SimpleX</xliff:g> Team</string>
+  <string name="image_descr_simplex_logo"><xliff:g id="appName">SimpleX</xliff:g> Logo</string>
+  <string name="icon_descr_email">Email</string>
+
+  <!-- Add Contact - AddContactView.kt -->
+  <string name="invalid_QR_code">Invalid QR code</string>
+  <string name="this_QR_code_is_not_a_link">This QR code is not a link!</string>
+  <string name="invalid_contact_link">Invalid link!</string>
+  <string name="this_link_is_not_a_valid_connection_link">This link is not a valid connection link!</string>
+  <string name="connection_request_sent">Connection request sent!</string>
+  <string name="you_will_be_connected_when_your_connection_request_is_accepted">You will be connected when your connection request is accepted, please wait or check later!</string>
+  <string name="you_will_be_connected_when_your_contacts_device_is_online">You will be connected when your contact\'s device is online, please wait or check later!</string>
+  <string name="show_QR_code_for_your_contact_to_scan_from_the_app__multiline">Show QR code for your contact\nto scan from the app</string>
+  <string name="if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel">If you cannot meet in person, you can <b>show QR code in the video call</b>, or you can share the invitation link via any other channel.</string>
+  <string name="your_chat_profile_will_be_sent_to_your_contact">Your chat profile will be sent\nto your contact</string>
+  <string name="if_you_cannot_meet_in_person_scan_QR_in_video_call_or_ask_for_invitation_link">If you cannot meet in person, you can <b>scan QR code in the video call</b>, or your contact can share an invitation link.</string>
+  <string name="share_invitation_link">Share invitation link</string>
+  <string name="paste_connection_link_below_to_connect">Paste the link you received into the box below to connect with your contact.</string>
+
+  <!-- PasteToConnect.kt -->
+  <string name="connect_via_link">Connect via link</string>
+  <string name="this_string_is_not_a_connection_link">This string is not a connection link!</string>
+  <string name="you_can_also_connect_by_clicking_the_link">You can also connect by clicking the link. If it opens in the browser, click <b>Open in mobile app</b> button.</string>
+
+  <!-- settings - SettingsView.kt -->
+  <string name="your_settings">Your settings</string>
+  <string name="your_simplex_contact_address">Your <xliff:g id="appName">SimpleX</xliff:g> contact address</string>
+  <string name="about_simplex_chat">About <xliff:g id="appNameFull">SimpleX Chat</xliff:g></string>
+  <string name="how_to_use_simplex_chat">How to use it</string>
+  <string name="markdown_help">Markdown help</string>
+  <string name="markdown_in_messages">Markdown in messages</string>
+  <string name="chat_with_the_founder">Connect to the developers</string>
+  <string name="send_us_an_email">Send us email</string>
+  <string name="private_notifications">Private notifications</string>
+  <string name="chat_console">Chat console</string>
+  <string name="smp_servers">SMP servers</string>
+  <string name="install_simplex_chat_for_terminal">Install <font color="#0088ff"><xliff:g id="appNameFull">SimpleX Chat</xliff:g> for terminal</font></string>
+  <string name="use_simplex_chat_servers__question">Use <xliff:g id="appNameFull">SimpleX Chat</xliff:g> servers?</string>
+  <string name="saved_SMP_servers_will_br_removed">Saved SMP servers will be removed.</string>
+  <string name="your_SMP_servers">Your SMP servers</string>
+  <string name="configure_SMP_servers">Configure SMP servers</string>
+  <string name="using_simplex_chat_servers">Using <xliff:g id="appNameFull">SimpleX Chat</xliff:g> servers.</string>
+  <string name="enter_one_SMP_server_per_line">Enter one SMP server per line:</string>
+  <string name="how_to">How to</string>
+  <string name="save_servers_button">Save</string>
+
+  <!-- Address Items - UserAddressView.kt -->
+  <string name="create_address">Create address</string>
+  <string name="delete_address__question">Delete address?</string>
+  <string name="all_your_contacts_will_remain_connected">All your contacts will remain connected.</string>
+  <string name="your_chat_address">Your chat address</string>
+  <string name="you_can_share_your_address_anybody_will_be_able_to_connect">You can share your address as a link or as a QR code - anybody will be able to connect to you.</string>
+  <string name="if_you_delete_address_you_wont_lose_contacts">If you later delete it - you won\'t lose your contacts.</string>
+  <string name="share_link">Share link</string>
+  <string name="delete_address">Delete address</string>
+
+  <!-- User profile details - UserProfileView.kt -->
+  <string name="display_name__field">Display name:</string>
+  <string name="full_name__field">"Full name:</string>
+  <string name="your_chat_profile">Your chat profile</string>
+  <string name="your_profile_is_stored_on_device_and_shared_only_with_contacts_simplex_cannot_see_it">Your profile is stored on your device and shared only with your contacts.\n\n<xliff:g id="appName">SimpleX</xliff:g> servers cannot see your profile.</string>
+  <string name="edit_image">Edit image</string>
+  <string name="delete_image">Delete image</string>
+  <string name="save_and_notify_contacts">Save (and notify contacts)</string>
+
+  <!-- Welcome Prompts - WelcomeView.kt -->
+  <string name="you_control_your_chat">You control your chat!</string>
+  <string name="the_messaging_and_app_platform_protecting_your_privacy_and_security">The messaging and application platform protecting your privacy and security.</string>
+  <string name="we_do_not_store_contacts_or_messages_on_servers">We don\'t store any of your contacts or messages (once delivered) on the servers.</string>
+  <string name="create_profile">Create profile</string>
+  <string name="your_profile_is_stored_on_your_device">Your profile, contacts and delivered messages are stored on your device.</string>
+  <string name="profile_is_only_shared_with_your_contacts">The profile is only shared with your contacts.</string>
+  <string name="display_name_cannot_contain_whitespace">Display name cannot contain whitespace.</string>
+  <string name="display_name">Display Name</string>
+  <string name="full_name_optional__prompt">Full Name (optional)</string>
+  <string name="create_profile_button">Create</string>
+  <string name="about_simplex">About SimpleX</string>
+
+  <!-- markdown demo - MarkdownHelpView.kt -->
+  <string name="how_to_use_markdown">How to use markdown</string>
+  <string name="you_can_use_markdown_to_format_messages__prompt">You can use markdown to format messages:</string>
+  <string name="bold">bold</string>
+  <string name="italic">italic</string>
+  <string name="strikethrough">strike</string>
+  <string name="a_plus_b">a + b</string>
+  <string name="colored">colored</string>
+  <string name="secret">secret</string>
+
+  <!-- CICallStatus -->
+  <string name="callstatus_calling">calling…</string>
+  <string name="callstatus_missed">missed</string>
+  <string name="callstatus_rejected">rejected</string>
+  <string name="callstatus_accepted">accepted</string>
+  <string name="callstatus_connecting">connecting…</string>
+  <string name="callstatus_in_progress">in progress</string>
+  <string name="callstatus_ended">ended <xliff:g id="duration" example="01:15">%1$s!</xliff:g></string>
+  <string name="callstatus_error">error</string>
+
+  <!-- CallState -->
+  <string name="callstate_starting">starting…</string>
+  <string name="callstate_waiting_for_answer">waiting for answer…</string>
+  <string name="callstate_waiting_for_confirmation">waiting for confirmation…</string>
+  <string name="callstate_received_answer">received answer…</string>
+  <string name="callstate_connecting">connecting…</string>
+  <string name="callstate_connected">connected</string>
+
+  <!-- SimpleXInfo -->
+  <string name="next_generation_of_private_messaging">The next generation of private messaging</string>
+  <string name="privacy_redefined">Privacy redefined</string>
+  <string name="first_platform_without_user_ids">The 1st platform without any user identifiers – private by design.</string>
+  <string name="immune_to_spam_and_abuse">Immune to spam and abuse</string>
+  <string name="people_can_connect_only_via_links_you_share">People can connect to you only via the links you share.</string>
+  <string name="decentralized">Decentralized</string>
+  <string name="opensource_protocol_and_code_anybody_can_run_servers">Open-source protocol and code – anybody can run the servers.</string>
+  <string name="create_your_profile">Create your profile</string>
+  <string name="make_private_connection">Make a private connection</string>
+  <string name="how_it_works">How it works</string>
+
+  <!-- How SimpleX Works -->
+  <string name="how_simplex_works">How <xliff:g id="appName">SimpleX</xliff:g> works</string>
+  <string name="many_people_asked_how_can_it_deliver">Many people asked: <i>if <xliff:g id="appName">SimpleX</xliff:g> has no user identifiers, how can it deliver messages?</i></string>
+  <string name="to_protect_privacy_simplex_has_ids_for_queues">To protect privacy, instead of user IDs used by all other platforms, <xliff:g id="appName">SimpleX</xliff:g> has identifiers for message queues, separate for each of your contacts.</string>
+  <string name="you_control_servers_to_receive_your_contacts_to_send">You control through which server(s) <b>to receive</b> the messages, your contacts – the servers you use to message them.</string>
+  <string name="only_client_devices_store_contacts_groups_e2e_encrypted_messages">Only client devices store user profiles, contacts, groups, and messages sent with <b>2-layer end-to-end encryption</b>.</string>
+  <string name="read_more_in_github">Read more in our GitHub repository.</string>
+  <string name="read_more_in_github_with_link">Read more in our <font color="#0088ff">GitHub repository</font>.</string>
+
+  <!-- MakeConnection -->
+  <string name="to_make_your_first_private_connection_choose">To make your first private connection, choose <b>one of the following</b>:</string>
+  <string name="create_1_time_link_qr_code">Create 1-time link / QR code</string>
+  <string name="it_s_secure_to_share__only_one_contact_can_use_it">It\'s secure to share - only one contact can use it.</string>
+  <string name="paste_the_link_you_received">Paste the link you received</string>
+  <string name="or_open_the_link_in_the_browser_and_tap_open_in_mobile">Or open the link in the browser and tap <b>Open in mobile</b>.</string>
+  <string name="scan_contact_s_qr_code">Scan contact\'s QR code</string>
+  <string name="in_person_or_via_a_video_call__the_most_secure_way_to_connect">In person or via a video call – the most secure way to connect.</string>
+  <string name="or">or</string>
+  <string name="connect_with_the_developers">Connect with the developers</string>
+  <string name="to_ask_any_questions_and_to_receive_simplex_chat_updates">To ask any questions and to receive <xliff:g id="appNameFull">SimpleX Chat</xliff:g> updates.</string>
+</resources>

apps/android/app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,3 @@
+<paths>
+    <files-path name="my_files" path="/"/>
+</paths>

apps/android/build.gradle

@@ -1,13 +1,13 @@
 buildscript {
     ext {
-        compose_version = '1.1.0'
+        compose_version = '1.1.1'
     }
     repositories {
         google()
         mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:7.1.2'
+        classpath 'com.android.tools.build:gradle:7.1.3'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.6.10"
         classpath "org.jetbrains.kotlin:kotlin-serialization:1.3.2"
 
@@ -16,8 +16,8 @@ buildscript {
     }
 }// Top-level build file where you can add configuration options common to all sub-projects/modules.
 plugins {
-    id 'com.android.application' version '7.1.2' apply false
-    id 'com.android.library' version '7.1.2' apply false
+    id 'com.android.application' version '7.1.3' apply false
+    id 'com.android.library' version '7.1.3' apply false
     id 'org.jetbrains.kotlin.android' version '1.6.10' apply false
     id 'org.jetbrains.kotlin.plugin.serialization' version '1.6.10'
 }

apps/android/readme.md

@@ -0,0 +1,25 @@
+# Android App Development
+
+This readme is currently a stub and as such is in development.
+
+Ultimately, this readme will act as a guide to contributing to the develop of the SimpleX android app.
+
+
+## Gotchas
+
+#### SHA Signature for verification for app links/deep links
+
+In order for the SimpleX app to be automatically adopted for opening links from https://simplex.chat the SHA certificate fingerprint for the App installed on the phone must be in the hosted [assetlinks.json](https://simplex.chat/.well-known/assetlinks.json) file on simplex.chat.
+
+The accepted fingerprints are in the `sha256_cert_fingerprints` list.
+
+To find your SHA certificate fingerprint perform the following steps.
+
+1. Build and install your development version of the app as usual
+2. From the terminal in Android studio run `adb shell pm get-app-links chat.simplex.app`
+3. Copy the signature listed in `signatures` in the result
+4. Add your signature to [assetlinks.json](https://github.com/simplex-chat/website/blob/master/.well-known/assetlinks.json) in the [website repo](https://github.com/simplex-chat/website) and make a PR. On approval, wait a few minutes for the changes to propagate to the public website and then you should be able to verify SimpleX.
+
+More information is available [here](https://developer.android.com/training/app-links/verify-site-associations#manual-verification). If there is no response when running the `pm get-app-links` command, the intents in `AndroidManifest.xml` are likely misspecified. A verification attempt can be triggered using `adb shell pm verify-app-links --re-verify chat.simplex.app`. 
+
+Note that this is not an issue for the app store build of the app as this is signed with our app store credentials and thus there is a stable signature over users. Developers do not have general access to these credentials for development and testing.

apps/ios/.gitignore

@@ -67,3 +67,5 @@ iOSInjectionProject/
 Libraries/
 
 Shared/MyPlayground.playground/*
+
+testpush.sh

apps/ios/LOCALIZATION.md

@@ -0,0 +1,29 @@
+# Localization
+
+## Creating localization keys
+
+There are three ways XCode generates localization keys from strings:
+
+1. Automatically, from the texts used in standard components `Text`, `Label`, `Button`, etc.
+
+2. All strings passed to view variables and function parameters declared as `LocalizedStringKey` type. Only string constants (possibly, with interpolation) or other variables of type `LocalizedStringKey` can be passed to these parameters. See, for example, ContentView.swift.
+
+3. All strings wrapped in `NSLocalizedString`. Please note that such strings do not support swift interpolation, instead formatted strings should be used:
+
+```swift
+String.localizedStringWithFormat(NSLocalizedString("You can now send messages to %@", comment: "notification body"), value)
+```
+
+## Adding strings to the existing localizations
+
+1. Choose `Product -> Export Localizations...` in the menu, choose `ios` folder as the destination and `SimpleX Localizations` as the folder name, confirm to overwrite it (make sure not to save to subfolder).
+2. Add `target` keys to the localizations that were added or changed.
+3. Choose `Product -> Import Localizations...` for any non-English folders - that would update Localizable files.
+
+Localizable files values can be edited directly, the changes will be included in the next export. Following the process above though guarantees that all strings are localized.
+
+## Development
+
+Make sure to enable the option `Show non-localized strings` in `Product -> Scheme -> Edit scheme...` menu - it will be showing all non-localized strings as all caps.
+
+Read more about editing XLIFF and string files here: https://developer.apple.com/documentation/xcode/editing-xliff-and-strings-files

apps/ios/Shared/AppDelegate.swift

@@ -0,0 +1,95 @@
+//
+//  AppDelegate.swift
+//  SimpleX
+//
+//  Created by Evgeny on 30/03/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+import UIKit
+
+class AppDelegate: NSObject, UIApplicationDelegate {
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
+        logger.debug("AppDelegate: didFinishLaunchingWithOptions")
+        application.registerForRemoteNotifications()
+        return true
+    }
+
+    func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+        let token = deviceToken.map { String(format: "%02hhx", $0) }.joined()
+        logger.debug("AppDelegate: didRegisterForRemoteNotificationsWithDeviceToken \(token)")
+        let m = ChatModel.shared
+        m.deviceToken = token
+        UserDefaults.standard.set(false, forKey: DEFAULT_USE_NOTIFICATIONS)
+//        let useNotifications = UserDefaults.standard.bool(forKey: "useNotifications")
+//        if useNotifications {
+//            Task {
+//                do {
+//                    m.tokenStatus = try await apiRegisterToken(token: token)
+//                } catch {
+//                    logger.error("apiRegisterToken error: \(responseError(error))")
+//                }
+//            }
+//        }
+    }
+
+    func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: Error) {
+        logger.error("AppDelegate: didFailToRegisterForRemoteNotificationsWithError \(error.localizedDescription)")
+    }
+
+    func application(_ application: UIApplication,
+                     didReceiveRemoteNotification userInfo: [AnyHashable : Any],
+                     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+        logger.debug("AppDelegate: didReceiveRemoteNotification")
+        if let ntfData = userInfo["notificationData"] as? [AnyHashable : Any],
+           UserDefaults.standard.bool(forKey: "useNotifications") {
+            if let verification = ntfData["verification"] as? String,
+               let nonce = ntfData["nonce"] as? String {
+                if let token = ChatModel.shared.deviceToken {
+                    logger.debug("AppDelegate: didReceiveRemoteNotification: verification, confirming \(verification)")
+                    Task {
+                        let m = ChatModel.shared
+                        do {
+                            if case .active = m.tokenStatus {} else { m.tokenStatus = .confirmed }
+                            try await apiVerifyToken(token: token, code: verification, nonce: nonce)
+                            m.tokenStatus = .active
+                            try await apiIntervalNofication(token: token, interval: 20)
+                        } catch {
+                            if let cr = error as? ChatResponse, case .chatCmdError(.errorAgent(.NTF(.AUTH))) = cr {
+                                m.tokenStatus = .expired
+                            }
+                            logger.error("AppDelegate: didReceiveRemoteNotification: apiVerifyToken or apiIntervalNofication error: \(responseError(error))")
+                        }
+                        completionHandler(.newData)
+                    }
+                } else {
+                    completionHandler(.noData)
+                }
+            } else if let checkMessages = ntfData["checkMessages"] as? Bool, checkMessages {
+                // TODO check if app in background
+                logger.debug("AppDelegate: didReceiveRemoteNotification: checkMessages")
+                // TODO remove
+                NtfManager.shared.notifyCheckingMessages()
+                receiveMessages(completionHandler)
+            } else if let smpQueue = ntfData["checkMessage"] as? String {
+                // TODO check if app in background
+                logger.debug("AppDelegate: didReceiveRemoteNotification: checkMessage \(smpQueue)")
+                receiveMessages(completionHandler)
+            } else {
+                completionHandler(.noData)
+            }
+        } else {
+            completionHandler(.noData)
+        }
+    }
+
+    private func receiveMessages(_ completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
+        let complete = BGManager.shared.completionHandler {
+            logger.debug("AppDelegate: completed BGManager.receiveMessages")
+            completionHandler(.newData)
+        }
+
+        BGManager.shared.receiveMessages(complete)
+    }
+}

apps/ios/Shared/ContentView.swift

@@ -13,30 +13,27 @@ struct ContentView: View {
     @State private var showNotificationAlert = false
 
     var body: some View {
-        if let user = chatModel.currentUser {
-            ChatListView(user: user)
-                .onAppear {
-                    do {
-                        try apiStartChat()
-                        chatModel.userSMPServers = try getUserSMPServers()
-                        chatModel.chats = try apiGetChats()
-                    } catch {
-                        fatalError("Failed to start or load chats: \(error)")
+        ZStack {
+            if let step = chatModel.onboardingStage {
+                if case .onboardingComplete = step,
+                   let user = chatModel.currentUser {
+                    ChatListView(user: user)
+                    .onAppear {
+                        NtfManager.shared.requestAuthorization(onDeny: {
+                            alertManager.showAlert(notificationAlert())
+                        })
                     }
-                    ChatReceiver.shared.start()
-                    NtfManager.shared.requestAuthorization(onDeny: {
-                        alertManager.showAlert(notificationAlert())
-                    })
+                } else {
+                    OnboardingView(onboarding: step)
                 }
-                .alert(isPresented: $alertManager.presentAlert) { alertManager.alertView! }
-        } else {
-            WelcomeView()
+            }
         }
+        .alert(isPresented: $alertManager.presentAlert) { alertManager.alertView! }
     }
 
     func notificationAlert() -> Alert {
         Alert(
-            title: Text("Notification are disabled!"),
+            title: Text("Notifications are disabled!"),
              message: Text("The app can notify you when you receive messages or contact requests - please open settings to enable."),
              primaryButton: .default(Text("Open Settings")) {
                  DispatchQueue.main.async {
@@ -48,6 +45,37 @@ struct ContentView: View {
     }
 }
 
+func connectViaUrl() {
+    let m = ChatModel.shared
+    if let url = m.appOpenUrl {
+        m.appOpenUrl = nil
+        AlertManager.shared.showAlert(connectViaUrlAlert(url))
+    }
+}
+
+func connectViaUrlAlert(_ url: URL) -> Alert {
+    var path = url.path
+    logger.debug("ChatListView.connectViaUrlAlert path: \(path)")
+    if (path == "/contact" || path == "/invitation") {
+        path.removeFirst()
+        let action: ConnReqType = path == "contact" ? .contact : .invitation
+        let link = url.absoluteString.replacingOccurrences(of: "///\(path)", with: "/\(path)")
+        let title: LocalizedStringKey
+        if case .contact = action { title = "Connect via contact link?" }
+        else { title = "Connect via one-time link?" }
+        return Alert(
+            title: Text(title),
+            message: Text("Your profile will be sent to the contact that you received this link from"),
+            primaryButton: .default(Text("Connect")) {
+                connectViaLink(link)
+            },
+            secondaryButton: .cancel()
+        )
+    } else {
+        return Alert(title: Text("Error: URL is invalid"))
+    }
+}
+
 final class AlertManager: ObservableObject {
     static let shared = AlertManager()
     @Published var presentAlert = false
@@ -55,13 +83,13 @@ final class AlertManager: ObservableObject {
 
     func showAlert(_ alert: Alert) {
         logger.debug("AlertManager.showAlert")
-        DispatchQueue.main.async {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
             self.alertView = alert
             self.presentAlert = true
         }
     }
 
-    func showAlertMsg(title: String, message: String? = nil) {
+    func showAlertMsg(title: LocalizedStringKey, message: LocalizedStringKey? = nil) {
         if let message = message {
             showAlert(Alert(title: Text(title), message: Text(message)))
         } else {

apps/ios/Shared/DebugJSON.playground/Contents.swift

@@ -0,0 +1,20 @@
+import UIKit
+
+let s = """
+          {
+            "contactConnection" : {
+              "contactConnection" : {
+                "viaContactUri" : false,
+                "pccConnId" : 456,
+                "pccAgentConnId" : "cTdjbmR4ZzVzSmhEZHdzMQ==",
+                "pccConnStatus" : "new",
+                "updatedAt" : "2022-04-24T11:59:23.703162Z",
+                "createdAt" : "2022-04-24T11:59:23.703162Z"
+              }
+            }
+          }
+"""
+//let s = "\"2022-04-24T11:59:23.703162Z\""
+let json = getJSONDecoder()
+let d = s.data(using: .utf8)!
+print (try! json.decode(ChatInfo.self, from: d))

apps/ios/Shared/DebugJSON.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='ios' buildActiveScheme='true' importAppTypes='true'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

apps/ios/Shared/FileUtils.swift

@@ -0,0 +1,197 @@
+//
+//  FileUtils.swift
+//  SimpleX (iOS)
+//
+//  Created by JRoberts on 15.04.2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+import SwiftUI
+
+// maximum image file size to be auto-accepted
+let maxImageSize: Int64 = 236700
+
+let maxFileSize: Int64 = 8000000
+
+func getDocumentsDirectory() -> URL {
+    FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+}
+
+func getAppFilesDirectory() -> URL {
+    getDocumentsDirectory().appendingPathComponent("app_files", isDirectory: true)
+}
+
+func getAppFilePath(_ fileName: String) -> URL {
+    getAppFilesDirectory().appendingPathComponent(fileName)
+}
+
+func getLoadedFilePath(_ file: CIFile?) -> String? {
+    if let file = file,
+       file.loaded,
+       let savedFile = file.filePath {
+        return getAppFilePath(savedFile).path
+    }
+    return nil
+}
+
+func getLoadedImage(_ file: CIFile?) -> UIImage? {
+    if let filePath = getLoadedFilePath(file) {
+        return UIImage(contentsOfFile: filePath)
+    }
+    return nil
+}
+
+func saveFileFromURL(_ url: URL) -> String? {
+    let savedFile: String?
+    if url.startAccessingSecurityScopedResource() {
+        do {
+            let fileData = try Data(contentsOf: url)
+            let fileName = uniqueCombine(url.lastPathComponent)
+            savedFile = saveFile(fileData, fileName)
+        } catch {
+            logger.error("FileUtils.saveFileFromURL error: \(error.localizedDescription)")
+            savedFile = nil
+        }
+    } else {
+        logger.error("FileUtils.saveFileFromURL startAccessingSecurityScopedResource returned false")
+        savedFile = nil
+    }
+    url.stopAccessingSecurityScopedResource()
+    return savedFile
+}
+
+func saveImage(_ uiImage: UIImage) -> String? {
+    if let imageDataResized = resizeImageToDataSize(uiImage, maxDataSize: maxImageSize) {
+        let timestamp = Date().getFormattedDate("yyyyMMdd_HHmmss")
+        let fileName = uniqueCombine("IMG_\(timestamp).jpg")
+        return saveFile(imageDataResized, fileName)
+    }
+    return nil
+}
+
+extension Date {
+  func getFormattedDate(_ format: String) -> String {
+    let df = DateFormatter()
+      df.dateFormat = format
+      df.locale = Locale(identifier: "US")
+    return df.string(from: self)
+  }
+}
+
+private func saveFile(_ data: Data, _ fileName: String) -> String? {
+    let filePath = getAppFilePath(fileName)
+    do {
+        try data.write(to: filePath)
+        return fileName
+    } catch {
+        logger.error("FileUtils.saveFile error: \(error.localizedDescription)")
+        return nil
+    }
+}
+
+private func uniqueCombine(_ fileName: String) -> String {
+    func tryCombine(_ fileName: String, _ n: Int) -> String {
+        let name = fileName.deletingPathExtension
+        let ext = fileName.pathExtension
+        let suffix = (n == 0) ? "" : "_\(n)"
+        let f = "\(name)\(suffix).\(ext)"
+        return (FileManager.default.fileExists(atPath: getAppFilePath(f).path)) ? tryCombine(fileName, n + 1) : f
+    }
+    return tryCombine(fileName, 0)
+}
+
+private extension String {
+    var ns: NSString {
+        return self as NSString
+    }
+    var pathExtension: String {
+        return ns.pathExtension
+    }
+    var deletingPathExtension: String {
+        return ns.deletingPathExtension
+    }
+}
+
+func removeFile(_ fileName: String) {
+    do {
+        try FileManager.default.removeItem(atPath: getAppFilePath(fileName).path)
+    } catch {
+        logger.error("FileUtils.removeFile error: \(error.localizedDescription)")
+    }
+}
+
+// image utils
+
+func dropImagePrefix(_ s: String) -> String {
+    dropPrefix(dropPrefix(s, "data:image/png;base64,"), "data:image/jpg;base64,")
+}
+
+private func dropPrefix(_ s: String, _ prefix: String) -> String {
+    s.hasPrefix(prefix) ? String(s.dropFirst(prefix.count)) : s
+}
+
+func cropToSquare(_ image: UIImage) -> UIImage {
+    let size = image.size
+    let side = min(size.width, size.height)
+    let newSize = CGSize(width: side, height: side)
+    var origin = CGPoint.zero
+    if size.width > side {
+        origin.x -= (size.width - side) / 2
+    } else if size.height > side {
+        origin.y -= (size.height - side) / 2
+    }
+    return resizeImage(image, newBounds: CGRect(origin: .zero, size: newSize), drawIn: CGRect(origin: origin, size: size))
+}
+
+func resizeImageToDataSize(_ image: UIImage, maxDataSize: Int64) -> Data? {
+    var img = image
+    var data = img.jpegData(compressionQuality: 0.85)
+    var dataSize = data?.count ?? 0
+    while dataSize != 0 && dataSize > maxDataSize {
+        let ratio = sqrt(Double(dataSize) / Double(maxDataSize))
+        let clippedRatio = min(ratio, 2.0)
+        img = reduceSize(img, ratio: clippedRatio)
+        data = img.jpegData(compressionQuality: 0.85)
+        dataSize = data?.count ?? 0
+    }
+    logger.debug("resizeImageToDataSize final \(dataSize)")
+    return data
+}
+
+func resizeImageToStrSize(_ image: UIImage, maxDataSize: Int64) -> String? {
+    var img = image
+    var str = compressImageStr(img)
+    var dataSize = str?.count ?? 0
+    while dataSize != 0 && dataSize > maxDataSize {
+        let ratio = sqrt(Double(dataSize) / Double(maxDataSize))
+        let clippedRatio = min(ratio, 2.0)
+        img = reduceSize(img, ratio: clippedRatio)
+        str = compressImageStr(img)
+        dataSize = str?.count ?? 0
+    }
+    logger.debug("resizeImageToStrSize final \(dataSize)")
+    return str
+}
+
+func compressImageStr(_ image: UIImage, _ compressionQuality: CGFloat = 0.85) -> String? {
+    if let data = image.jpegData(compressionQuality: compressionQuality) {
+        return "data:image/jpg;base64,\(data.base64EncodedString())"
+    }
+    return nil
+}
+
+private func reduceSize(_ image: UIImage, ratio: CGFloat) -> UIImage {
+    let newSize = CGSize(width: floor(image.size.width / ratio), height: floor(image.size.height / ratio))
+    let bounds = CGRect(origin: .zero, size: newSize)
+    return resizeImage(image, newBounds: bounds, drawIn: bounds)
+}
+
+private func resizeImage(_ image: UIImage, newBounds: CGRect, drawIn: CGRect) -> UIImage {
+    let format = UIGraphicsImageRendererFormat()
+    format.scale = 1.0
+    format.opaque = true
+    return UIGraphicsImageRenderer(bounds: newBounds, format: format).image { _ in
+        image.draw(in: drawIn)
+    }
+}

apps/ios/Shared/Model/BGManager.swift

@@ -20,7 +20,7 @@ class BGManager {
     static let shared = BGManager()
     var chatReceiver: ChatReceiver?
     var bgTimer: Timer?
-    var completed = false
+    var completed = true
 
     func register() {
         logger.debug("BGManager.register")
@@ -43,36 +43,48 @@ class BGManager {
     private func handleRefresh(_ task: BGAppRefreshTask) {
         logger.debug("BGManager.handleRefresh")
         schedule()
-        self.completed = false
+        let completeRefresh = completionHandler {
+            task.setTaskCompleted(success: true)
+        }
+        task.expirationHandler = { completeRefresh("expirationHandler") }
+        receiveMessages(completeRefresh)
+    }
 
-        let completeTask: (String) -> Void = { reason in
-            logger.debug("BGManager.handleRefresh completeTask: \(reason)")
+    func completionHandler(_ complete: @escaping () -> Void) -> ((String) -> Void) {
+        { reason in
+            logger.debug("BGManager.completionHandler: \(reason)")
             if !self.completed {
                 self.completed = true
                 self.chatReceiver?.stop()
                 self.chatReceiver = nil
                 self.bgTimer?.invalidate()
                 self.bgTimer = nil
-                task.setTaskCompleted(success: true)
+                complete()
             }
         }
+    }
 
-        task.expirationHandler = { completeTask("expirationHandler") }
+    func receiveMessages(_ completeReceiving: @escaping (String) -> Void) {
+        if (!self.completed) {
+            logger.debug("BGManager.receiveMessages: in progress, exiting")
+            return
+        }
+        self.completed = false
         DispatchQueue.main.async {
             initializeChat()
             if ChatModel.shared.currentUser == nil {
-                completeTask("no current user")
+                completeReceiving("no current user")
                 return
             }
-            logger.debug("BGManager.handleRefresh: starting chat")
+            logger.debug("BGManager.receiveMessages: starting chat")
             let cr = ChatReceiver()
             self.chatReceiver = cr
             cr.start()
             RunLoop.current.add(Timer(timeInterval: 2, repeats: true) { timer in
-                logger.debug("BGManager.handleRefresh: timer")
+                logger.debug("BGManager.receiveMessages: timer")
                 self.bgTimer = timer
                 if cr.lastMsgTime.distance(to: Date.now) >= waitForMessages {
-                    completeTask("timer (no messages after \(waitForMessages) seconds)")
+                    completeReceiving("timer (no messages after \(waitForMessages) seconds)")
                 }
             }, forMode: .default)
         }

apps/ios/Shared/Model/ChatModel.swift

@@ -11,6 +11,7 @@ import Combine
 import SwiftUI
 
 final class ChatModel: ObservableObject {
+    @Published var onboardingStage: OnboardingStage?
     @Published var currentUser: User?
     // list of chat "previews"
     @Published var chats: [Chat] = []
@@ -23,6 +24,13 @@ final class ChatModel: ObservableObject {
     @Published var userAddress: String?
     @Published var userSMPServers: [String]?
     @Published var appOpenUrl: URL?
+    @Published var deviceToken: String?
+    @Published var tokenStatus = NtfTknStatus.new
+    // current WebRTC call
+    @Published var callInvitations: Dictionary<String, CallInvitation> = [:]
+    @Published var activeCallInvitation: ContactRef?
+    @Published var activeCall: Call?
+    @Published var callCommand: WCallCommand?
 
     var messageDelivery: Dictionary<Int64, () -> Void> = [:]
 
@@ -52,18 +60,25 @@ final class ChatModel: ObservableObject {
         }
     }
 
+    func updateContactConnection(_ contactConnection: PendingContactConnection) {
+        updateChat(.contactConnection(contactConnection: contactConnection))
+    }
+
     func updateContact(_ contact: Contact) {
-        let cInfo = ChatInfo.direct(contact: contact)
-        if hasChat(contact.id) {
+        updateChat(.direct(contact: contact))
+    }
+
+    private func updateChat(_ cInfo: ChatInfo) {
+        if hasChat(cInfo.id) {
             updateChatInfo(cInfo)
         } else {
             addChat(Chat(chatInfo: cInfo, chatItems: []))
         }
     }
 
-    func updateNetworkStatus(_ contact: Contact, _ status: Chat.NetworkStatus) {
-        if let ix = getChatIndex(contact.id) {
-            chats[ix].serverInfo.networkStatus = status
+    func updateNetworkStatus(_ id: ChatId, _ status: Chat.NetworkStatus) {
+        if let i = getChatIndex(id) {
+            chats[i].serverInfo.networkStatus = status
         }
     }
 
@@ -101,7 +116,7 @@ final class ChatModel: ObservableObject {
             if case .rcvNew = cItem.meta.itemStatus {
                 DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
                     if self.chatId == cInfo.id {
-                        Task { await SimpleX.markChatItemRead(cInfo, cItem) }
+                        Task { await apiMarkChatItemRead(cInfo, cItem) }
                     }
                 }
             }
@@ -135,6 +150,23 @@ final class ChatModel: ObservableObject {
             return res
         }
     }
+    
+    func removeChatItem(_ cInfo: ChatInfo, _ cItem: ChatItem) {
+        // update previews
+        if let chat = getChat(cInfo.id) {
+            if let pItem = chat.chatItems.last, pItem.id == cItem.id {
+                chat.chatItems = [cItem]
+            }
+        }
+        // remove from current chat
+        if chatId == cInfo.id {
+            if let i = chatItems.firstIndex(where: { $0.id == cItem.id }) {
+                _ = withAnimation {
+                    self.chatItems.remove(at: i)
+                }
+            }
+        }
+    }
 
     func markChatItemsRead(_ cInfo: ChatInfo) {
         // update preview
@@ -164,6 +196,14 @@ final class ChatModel: ObservableObject {
         }
     }
 
+    func getPrevChatItem(_ ci: ChatItem) -> ChatItem? {
+        if let i = chatItems.firstIndex(where: { $0.id == ci.id }), i > 0  {
+            return chatItems[i - 1]
+        } else {
+            return nil
+        }
+    }
+    
     func popChat(_ id: String) {
         if let i = getChatIndex(id) {
             popChat_(i)
@@ -182,155 +222,6 @@ final class ChatModel: ObservableObject {
     }
 }
 
-struct User: Decodable, NamedChat {
-    var userId: Int64
-    var userContactId: Int64
-    var localDisplayName: ContactName
-    var profile: Profile
-    var activeUser: Bool
-
-    var displayName: String { get { profile.displayName } }
-
-    var fullName: String { get { profile.fullName } }
-
-    static let sampleData = User(
-        userId: 1,
-        userContactId: 1,
-        localDisplayName: "alice",
-        profile: Profile.sampleData,
-        activeUser: true
-    )
-}
-
-typealias ContactName = String
-
-typealias GroupName = String
-
-struct Profile: Codable, NamedChat {
-    var displayName: String
-    var fullName: String
-
-    static let sampleData = Profile(
-        displayName: "alice",
-        fullName: "Alice"
-    )
-}
-
-enum ChatType: String {
-    case direct = "@"
-    case group = "#"
-    case contactRequest = "<@"
-}
-
-protocol NamedChat {
-    var displayName: String { get }
-    var fullName: String { get }
-}
-
-extension NamedChat {
-    var chatViewName: String {
-        get { displayName + (fullName == "" || fullName == displayName ? "" : " / \(fullName)") }
-    }
-}
-
-typealias ChatId = String
-
-enum ChatInfo: Identifiable, Decodable, NamedChat {
-    case direct(contact: Contact)
-    case group(groupInfo: GroupInfo)
-    case contactRequest(contactRequest: UserContactRequest)
-    
-    var localDisplayName: String {
-        get {
-            switch self {
-            case let .direct(contact): return contact.localDisplayName
-            case let .group(groupInfo): return groupInfo.localDisplayName
-            case let .contactRequest(contactRequest): return contactRequest.localDisplayName
-            }
-        }
-    }
-
-    var displayName: String {
-        get {
-            switch self {
-            case let .direct(contact): return contact.displayName
-            case let .group(groupInfo): return groupInfo.displayName
-            case let .contactRequest(contactRequest): return contactRequest.displayName
-            }
-        }
-    }
-
-    var fullName: String {
-        get {
-            switch self {
-            case let .direct(contact): return contact.fullName
-            case let .group(groupInfo): return groupInfo.fullName
-            case let .contactRequest(contactRequest): return contactRequest.fullName
-            }
-        }
-    }
-
-    var id: ChatId {
-        get {
-            switch self {
-            case let .direct(contact): return contact.id
-            case let .group(groupInfo): return groupInfo.id
-            case let .contactRequest(contactRequest): return contactRequest.id
-            }
-        }
-    }
-
-    var chatType: ChatType {
-        get {
-            switch self {
-            case .direct: return .direct
-            case .group: return .group
-            case .contactRequest: return .contactRequest
-            }
-        }
-    }
-    
-    var apiId: Int64 {
-        get {
-            switch self {
-            case let .direct(contact): return contact.apiId
-            case let .group(groupInfo): return groupInfo.apiId
-            case let .contactRequest(contactRequest): return contactRequest.apiId
-            }
-        }
-    }
-
-    var ready: Bool {
-        get {
-            switch self {
-            case let .direct(contact): return contact.ready
-            case let .group(groupInfo): return groupInfo.ready
-            case let .contactRequest(contactRequest): return contactRequest.ready
-            }
-        }
-    }
-
-    var createdAt: Date {
-        switch self {
-        case let .direct(contact): return contact.createdAt
-        case let .group(groupInfo): return groupInfo.createdAt
-        case let .contactRequest(contactRequest): return contactRequest.createdAt
-        }
-    }
-
-    struct SampleData {
-        var direct: ChatInfo
-        var group: ChatInfo
-        var contactRequest: ChatInfo
-    }
-
-    static var sampleData: ChatInfo.SampleData = SampleData(
-        direct: ChatInfo.direct(contact: Contact.sampleData),
-        group: ChatInfo.group(groupInfo: GroupInfo.sampleData),
-        contactRequest: ChatInfo.contactRequest(contactRequest: UserContactRequest.sampleData)
-    )
-}
-
 final class Chat: ObservableObject, Identifiable {
     @Published var chatInfo: ChatInfo
     @Published var chatItems: [ChatItem]
@@ -347,7 +238,7 @@ final class Chat: ObservableObject, Identifiable {
         case disconnected
         case error(String)
 
-        var statusString: String {
+        var statusString: LocalizedStringKey {
             get {
                 switch self {
                 case .connected: return "Server connected"
@@ -357,12 +248,12 @@ final class Chat: ObservableObject, Identifiable {
             }
         }
 
-        var statusExplanation: String {
+        var statusExplanation: LocalizedStringKey {
             get {
                 switch self {
-                case .connected: return "You are connected to the server you use to receve messages from this contact."
-                case let .error(err): return "Trying to connect to the server you use to receve messages from this contact (error: \(err))."
-                default: return "Trying to connect to the server you use to receve messages from this contact."
+                case .connected: return "You are connected to the server used to receive messages from this contact."
+                case let .error(err): return "Trying to connect to the server used to receive messages from this contact (error: \(err))."
+                default: return "Trying to connect to the server used to receive messages from this contact."
                 }
             }
         }
@@ -385,333 +276,12 @@ final class Chat: ObservableObject, Identifiable {
         self.chatStats = cData.chatStats
     }
 
-    init(chatInfo: ChatInfo, chatItems: [ChatItem] = [], chatStats: ChatStats = ChatStats()) {
+    init(chatInfo: ChatInfo, chatItems: [ChatItem] = [], chatStats: ChatStats = ChatStats(), serverInfo: ServerInfo = ServerInfo(networkStatus: .unknown)) {
         self.chatInfo = chatInfo
         self.chatItems = chatItems
         self.chatStats = chatStats
+        self.serverInfo = serverInfo
     }
 
     var id: ChatId { get { chatInfo.id } }
 }
-
-struct ChatData: Decodable, Identifiable {
-    var chatInfo: ChatInfo
-    var chatItems: [ChatItem]
-    var chatStats: ChatStats
-
-    var id: ChatId { get { chatInfo.id } }
-}
-
-struct ChatStats: Decodable {
-    var unreadCount: Int = 0
-    var minUnreadItemId: Int64 = 0
-}
-
-struct Contact: Identifiable, Decodable, NamedChat {
-    var contactId: Int64
-    var localDisplayName: ContactName
-    var profile: Profile
-    var activeConn: Connection
-    var viaGroup: Int64?
-    var createdAt: Date
-
-    var id: ChatId { get { "@\(contactId)" } }
-    var apiId: Int64 { get { contactId } }
-    var ready: Bool { get { activeConn.connStatus == "ready" || activeConn.connStatus == "snd-ready" } }
-    var displayName: String { get { profile.displayName } }
-    var fullName: String { get { profile.fullName } }
-
-    static let sampleData = Contact(
-        contactId: 1,
-        localDisplayName: "alice",
-        profile: Profile.sampleData,
-        activeConn: Connection.sampleData,
-        createdAt: .now
-    )
-}
-
-struct ContactSubStatus: Decodable {
-    var contact: Contact
-    var contactError: ChatError?
-}
-
-struct Connection: Decodable {
-    var connStatus: String
-
-    static let sampleData = Connection(connStatus: "ready")
-}
-
-struct UserContactRequest: Decodable, NamedChat {
-    var contactRequestId: Int64
-    var localDisplayName: ContactName
-    var profile: Profile
-    var createdAt: Date
-
-    var id: ChatId { get { "<@\(contactRequestId)" } }
-    var apiId: Int64 { get { contactRequestId } }
-    var ready: Bool { get { true } }
-    var displayName: String { get { profile.displayName } }
-    var fullName: String { get { profile.fullName } }
-
-    static let sampleData = UserContactRequest(
-        contactRequestId: 1,
-        localDisplayName: "alice",
-        profile: Profile.sampleData,
-        createdAt: .now
-    )
-}
-
-struct GroupInfo: Identifiable, Decodable, NamedChat {
-    var groupId: Int64
-    var localDisplayName: GroupName
-    var groupProfile: GroupProfile
-    var createdAt: Date
-    
-    var id: ChatId { get { "#\(groupId)" } }
-    var apiId: Int64 { get { groupId } }
-    var ready: Bool { get { true } }
-    var displayName: String { get { groupProfile.displayName } }
-    var fullName: String { get { groupProfile.fullName } }
-
-    static let sampleData = GroupInfo(
-        groupId: 1,
-        localDisplayName: "team",
-        groupProfile: GroupProfile.sampleData,
-        createdAt: .now
-    )
-}
-
-struct GroupProfile: Codable, NamedChat {
-    var displayName: String
-    var fullName: String
-
-    static let sampleData = GroupProfile(
-        displayName: "team",
-        fullName: "My Team"
-    )
-}
-
-struct GroupMember: Decodable {
-    var groupMemberId: Int64
-    var memberId: String
-//    var memberRole: GroupMemberRole
-//    var memberCategory: GroupMemberCategory
-//    var memberStatus: GroupMemberStatus
-//    var invitedBy: InvitedBy
-    var localDisplayName: ContactName
-    var memberProfile: Profile
-    var memberContactId: Int64?
-//    var activeConn: Connection?
-
-    static let sampleData = GroupMember(
-        groupMemberId: 1,
-        memberId: "abcd",
-        localDisplayName: "alice",
-        memberProfile: Profile.sampleData,
-        memberContactId: 1
-    )
-}
-
-struct MemberSubError: Decodable {
-    var member: GroupMember
-    var memberError: ChatError
-}
-
-struct AChatItem: Decodable {
-    var chatInfo: ChatInfo
-    var chatItem: ChatItem
-}
-
-struct ChatItem: Identifiable, Decodable {
-    var chatDir: CIDirection
-    var meta: CIMeta
-    var content: CIContent
-    var formattedText: [FormattedText]?
-    
-    var id: Int64 { get { meta.itemId } }
-
-    var timestampText: Text { get { meta.timestampText } }
-
-    func isRcvNew() -> Bool {
-        if case .rcvNew = meta.itemStatus { return true }
-        return false
-    }
-
-    static func getSample (_ id: Int64, _ dir: CIDirection, _ ts: Date, _ text: String, _ status: CIStatus = .sndNew) -> ChatItem {
-        ChatItem(
-           chatDir: dir,
-           meta: CIMeta.getSample(id, ts, text, status),
-           content: .sndMsgContent(msgContent: .text(text))
-       )
-    }
-}
-
-enum CIDirection: Decodable {
-    case directSnd
-    case directRcv
-    case groupSnd
-    case groupRcv(groupMember: GroupMember)
-
-    var sent: Bool {
-        get {
-            switch self {
-            case .directSnd: return true
-            case .directRcv: return false
-            case .groupSnd: return true
-            case .groupRcv: return false
-            }
-        }
-    }
-}
-
-struct CIMeta: Decodable {
-    var itemId: Int64
-    var itemTs: Date
-    var itemText: String
-    var itemStatus: CIStatus
-    var createdAt: Date
-
-    var timestampText: Text { get { SimpleX.timestampText(itemTs) } }
-
-    static func getSample(_ id: Int64, _ ts: Date, _ text: String, _ status: CIStatus = .sndNew) -> CIMeta {
-        CIMeta(
-            itemId: id,
-            itemTs: ts,
-            itemText: text,
-            itemStatus: status,
-            createdAt: ts
-        )
-    }
-}
-
-let msgTimeFormat = Date.FormatStyle.dateTime.hour().minute()
-let msgDateFormat = Date.FormatStyle.dateTime.day(.twoDigits).month(.twoDigits)
-
-func timestampText(_ date: Date) -> Text {
-    let now = Calendar.current.dateComponents([.day, .hour], from: .now)
-    let dc = Calendar.current.dateComponents([.day, .hour], from: date)
-    let recent = now.day == dc.day || ((now.day ?? 0) - (dc.day ?? 0) == 1 && (dc.hour ?? 0) >= 18 && (now.hour ?? 0) < 12)
-    return Text(date, format: recent ? msgTimeFormat : msgDateFormat)
-}
-
-enum CIStatus: Decodable {
-    case sndNew
-    case sndSent
-    case sndErrorAuth
-    case sndError(agentError: AgentErrorType)
-    case rcvNew
-    case rcvRead
-}
-
-enum CIContent: Decodable {
-    case sndMsgContent(msgContent: MsgContent)
-    case rcvMsgContent(msgContent: MsgContent)
-    case sndFileInvitation(fileId: Int64, filePath: String)
-    case rcvFileInvitation(rcvFileTransfer: RcvFileTransfer)
-
-    var text: String {
-        get {
-            switch self {
-            case let .sndMsgContent(mc): return mc.text
-            case let .rcvMsgContent(mc): return mc.text
-            case .sndFileInvitation: return "sending files is not supported yet"
-            case .rcvFileInvitation: return  "receiving files is not supported yet"
-            }
-        }
-    }
-}
-
-struct RcvFileTransfer: Decodable {
-
-}
-
-enum MsgContent {
-    case text(String)
-    // TODO include original JSON, possibly using https://github.com/zoul/generic-json-swift
-    case unknown(type: String, text: String)
-
-    var text: String {
-        get {
-            switch self {
-            case let .text(text): return text
-            case let .unknown(_, text): return text
-            }
-        }
-    }
-
-    var cmdString: String {
-        get {
-            switch self {
-            case let .text(text): return "text \(text)"
-            default: return ""
-            }
-        }
-    }
-
-    enum CodingKeys: String, CodingKey {
-        case type
-        case text
-    }
-}
-
-extension MsgContent: Decodable {
-    init(from decoder: Decoder) throws {
-        do {
-            let container = try decoder.container(keyedBy: CodingKeys.self)
-            let type = try container.decode(String.self, forKey: CodingKeys.type)
-            switch type {
-            case "text":
-                let text = try container.decode(String.self, forKey: CodingKeys.text)
-                self = .text(text)
-            default:
-                let text = try? container.decode(String.self, forKey: CodingKeys.text)
-                self = .unknown(type: type, text: text ?? "unknown message format")
-            }
-        } catch {
-            self = .unknown(type: "unknown", text: "invalid message format")
-        }
-    }
-}
-
-struct FormattedText: Decodable {
-    var text: String
-    var format: Format?
-}
-
-enum Format: Decodable {
-    case bold
-    case italic
-    case strikeThrough
-    case snippet
-    case secret
-    case colored(color: FormatColor)
-    case uri
-    case email
-    case phone
-}
-
-enum FormatColor: String, Decodable {
-    case red = "red"
-    case green = "green"
-    case blue = "blue"
-    case yellow = "yellow"
-    case cyan = "cyan"
-    case magenta = "magenta"
-    case black = "black"
-    case white = "white"
-
-    var uiColor: Color {
-        get {
-            switch (self) {
-            case .red: return .red
-            case .green: return .green
-            case .blue: return .blue
-            case .yellow: return .yellow
-            case .cyan: return .cyan
-            case .magenta: return .purple
-            case .black: return .primary
-            case .white: return .primary
-            }
-        }
-    }
-}

apps/ios/Shared/Model/NtfManager.swift

@@ -10,13 +10,9 @@ import Foundation
 import UserNotifications
 import UIKit
 
-let ntfActionAccept = "NTF_ACT_ACCEPT"
-
-let ntfCategoryContactRequest = "NTF_CAT_CONTACT_REQUEST"
-let ntfCategoryContactConnected = "NTF_CAT_CONTACT_CONNECTED"
-let ntfCategoryMessageReceived = "NTF_CAT_MESSAGE_RECEIVED"
-
-let appNotificationId = "chat.simplex.app.notification"
+let ntfActionAcceptContact = "NTF_ACT_ACCEPT_CONTACT"
+let ntfActionAcceptCall = "NTF_ACT_ACCEPT_CALL"
+let ntfActionRejectCall = "NTF_ACT_REJECT_CALL"
 
 private let ntfTimeInterval: TimeInterval = 1
 
@@ -34,10 +30,33 @@ class NtfManager: NSObject, UNUserNotificationCenterDelegate, ObservableObject {
         logger.debug("NtfManager.userNotificationCenter: didReceive")
         let content = response.notification.request.content
         let chatModel = ChatModel.shared
-        if content.categoryIdentifier == ntfCategoryContactRequest && response.actionIdentifier == ntfActionAccept,
+        let action = response.actionIdentifier
+        if content.categoryIdentifier == ntfCategoryContactRequest && action == ntfActionAcceptContact,
            let chatId = content.userInfo["chatId"] as? String,
            case let .contactRequest(contactRequest) = chatModel.getChat(chatId)?.chatInfo {
             Task { await acceptContactRequest(contactRequest) }
+        } else if content.categoryIdentifier == ntfCategoryCallInvitation && (action == ntfActionAcceptCall || action == ntfActionRejectCall),
+                  let chatId = content.userInfo["chatId"] as? String,
+                  case let .direct(contact) = chatModel.getChat(chatId)?.chatInfo,
+                  let invitation = chatModel.callInvitations[chatId] {
+            if action == ntfActionAcceptCall {
+                chatModel.activeCall = Call(contact: contact, callState: .invitationReceived, localMedia: invitation.peerMedia)
+                chatModel.chatId = nil
+                chatModel.callCommand = .start(media: invitation.peerMedia, aesKey: invitation.sharedKey)
+            } else {
+                Task {
+                    do {
+                        try await apiRejectCall(contact)
+                        if chatModel.activeCall?.contact.id == chatId {
+                            DispatchQueue.main.async {
+                                chatModel.callCommand = .end
+                                chatModel.activeCall = nil
+                            }
+                        }
+                    }
+                }
+            }
+            chatModel.callInvitations.removeValue(forKey: chatId)
         } else {
             chatModel.chatId = content.targetContentIdentifier
         }
@@ -67,10 +86,13 @@ class NtfManager: NSObject, UNUserNotificationCenterDelegate, ObservableObject {
                     // in another chat
                     return recentInTheSameChat(content) ? [.banner, .list] : [.sound, .banner, .list]
                 }
+            // this notification is deliverd from the notifications server
+            // when the app is in foreground it does not need to be shown
+            case ntfCategoryCheckMessage: return []
             default: return [.sound, .banner, .list]
             }
         } else {
-            return [.sound, .banner, .list]
+            return content.categoryIdentifier == ntfCategoryCheckMessage ? [] : [.sound, .banner, .list]
         }
     }
 
@@ -91,23 +113,45 @@ class NtfManager: NSObject, UNUserNotificationCenterDelegate, ObservableObject {
             UNNotificationCategory(
                 identifier: ntfCategoryContactRequest,
                 actions: [UNNotificationAction(
-                    identifier: ntfActionAccept,
-                    title: "Accept"
+                    identifier: ntfActionAcceptContact,
+                    title: NSLocalizedString("Accept", comment: "accept contact request via notification")
                 )],
                 intentIdentifiers: [],
-                hiddenPreviewsBodyPlaceholder: "New contact request"
+                hiddenPreviewsBodyPlaceholder: NSLocalizedString("New contact request", comment: "notification")
             ),
             UNNotificationCategory(
                 identifier: ntfCategoryContactConnected,
                 actions: [],
                 intentIdentifiers: [],
-                hiddenPreviewsBodyPlaceholder: "Contact is connected"
+                hiddenPreviewsBodyPlaceholder: NSLocalizedString("Contact is connected", comment: "notification")
             ),
             UNNotificationCategory(
                 identifier: ntfCategoryMessageReceived,
                 actions: [],
                 intentIdentifiers: [],
-                hiddenPreviewsBodyPlaceholder: "New message"
+                hiddenPreviewsBodyPlaceholder: NSLocalizedString("New message", comment: "notification")
+            ),
+            UNNotificationCategory(
+                identifier: ntfCategoryCallInvitation,
+                actions: [
+                    UNNotificationAction(
+                        identifier: ntfActionAcceptCall,
+                        title: NSLocalizedString("Answer", comment: "accept incoming call via notification")
+                    ),
+                    UNNotificationAction(
+                        identifier: ntfActionRejectCall,
+                        title: NSLocalizedString("Ignore", comment: "ignore incoming call via notification")
+                    )
+                ],
+                intentIdentifiers: [],
+                hiddenPreviewsBodyPlaceholder: NSLocalizedString("Incoming call", comment: "notification")
+            ),
+            // TODO remove
+            UNNotificationCategory(
+                identifier: ntfCategoryCheckingMessages,
+                actions: [],
+                intentIdentifiers: [],
+                hiddenPreviewsBodyPlaceholder: NSLocalizedString("Checking new messages...", comment: "notification")
             )
         ])
     }
@@ -137,51 +181,36 @@ class NtfManager: NSObject, UNUserNotificationCenterDelegate, ObservableObject {
 
     func notifyContactRequest(_ contactRequest: UserContactRequest) {
         logger.debug("NtfManager.notifyContactRequest")
-        addNotification(
-            categoryIdentifier: ntfCategoryContactRequest,
-            title: "\(contactRequest.displayName) wants to connect!",
-            body: "Accept contact request from \(contactRequest.chatViewName)?",
-            targetContentIdentifier: nil,
-            userInfo: ["chatId": contactRequest.id, "contactRequestId": contactRequest.apiId]
-        )
+        addNotification(createContactRequestNtf(contactRequest))
     }
 
     func notifyContactConnected(_ contact: Contact) {
         logger.debug("NtfManager.notifyContactConnected")
-        addNotification(
-            categoryIdentifier: ntfCategoryContactConnected,
-            title: "\(contact.displayName) is connected!",
-            body: "You can now send messages to \(contact.chatViewName)",
-            targetContentIdentifier: contact.id
-//            userInfo: ["chatId": contact.id, "contactId": contact.apiId]
-        )
+        addNotification(createContactConnectedNtf(contact))
     }
 
     func notifyMessageReceived(_ cInfo: ChatInfo, _ cItem: ChatItem) {
         logger.debug("NtfManager.notifyMessageReceived")
-        addNotification(
-            categoryIdentifier: ntfCategoryMessageReceived,
-            title: "\(cInfo.chatViewName):",
-            body: cItem.content.text,
-            targetContentIdentifier: cInfo.id
-//            userInfo: ["chatId": cInfo.id, "chatItemId": cItem.id]
-        )
+        addNotification(createMessageReceivedNtf(cInfo, cItem))
     }
 
-    private func addNotification(categoryIdentifier: String, title: String, subtitle: String? = nil, body: String? = nil,
-                                 targetContentIdentifier: String? = nil, userInfo: [AnyHashable : Any] = [:]) {
+    func notifyCallInvitation(_ contact: Contact, _ invitation: CallInvitation) {
+        logger.debug("NtfManager.notifyCallInvitation")
+        addNotification(createCallInvitationNtf(contact, invitation))
+    }
+
+    // TODO remove
+    func notifyCheckingMessages() {
+        logger.debug("NtfManager.notifyCheckingMessages")
+        let content = createNotification(
+            categoryIdentifier: ntfCategoryCheckingMessages,
+            title: NSLocalizedString("Checking new messages...", comment: "notification")
+        )
+        addNotification(content)
+    }
+
+    private func addNotification(_ content: UNMutableNotificationContent) {
         if !granted { return }
-        let content = UNMutableNotificationContent()
-        content.categoryIdentifier = categoryIdentifier
-        content.title = title
-        if let s = subtitle { content.subtitle = s }
-        if let s = body { content.body = s }
-        content.targetContentIdentifier = targetContentIdentifier
-        content.userInfo = userInfo
-        // TODO move logic of adding sound here, so it applies to background notifications too
-        content.sound = .default
-//        content.interruptionLevel = .active
-//        content.relevanceScore = 0.5 // 0-1
         let trigger = UNTimeIntervalNotificationTrigger(timeInterval: ntfTimeInterval, repeats: false)
         let request = UNNotificationRequest(identifier: appNotificationId, content: content, trigger: trigger)
         UNUserNotificationCenter.current().add(request) { error in

apps/ios/Shared/Model/Shared/API.swift

@@ -0,0 +1,66 @@
+//
+//  API.swift
+//  SimpleX NSE
+//
+//  Created by Evgeny on 26/04/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+
+private var chatController: chat_ctrl?
+
+func getChatCtrl() -> chat_ctrl {
+    if let controller = chatController { return controller }
+    let dataDir = getDocumentsDirectory().path + "/mobile_v1"
+    logger.debug("documents directory \(dataDir)")
+    var cstr = dataDir.cString(using: .utf8)!
+    chatController = chat_init(&cstr)
+    logger.debug("getChatCtrl: chat_init")
+    return chatController!
+}
+
+func sendSimpleXCmd(_ cmd: ChatCommand) -> ChatResponse {
+    var c = cmd.cmdString.cString(using: .utf8)!
+    return chatResponse(chat_send_cmd(getChatCtrl(), &c))
+}
+
+func chatResponse(_ cjson: UnsafeMutablePointer<CChar>) -> ChatResponse {
+    let s = String.init(cString: cjson)
+    let d = s.data(using: .utf8)!
+// TODO is there a way to do it without copying the data? e.g:
+//    let p = UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer(cjson))
+//    let d = Data.init(bytesNoCopy: p, count: strlen(cjson), deallocator: .free)
+    do {
+        let r = try jsonDecoder.decode(APIResponse.self, from: d)
+        return r.resp
+    } catch {
+        logger.error("chatResponse jsonDecoder.decode error: \(error.localizedDescription)")
+    }
+
+    var type: String?
+    var json: String?
+    if let j = try? JSONSerialization.jsonObject(with: d) as? NSDictionary {
+        if let j1 = j["resp"] as? NSDictionary, j1.count == 1 {
+            type = j1.allKeys[0] as? String
+        }
+        json = prettyJSON(j)
+    }
+    free(cjson)
+    return ChatResponse.response(type: type ?? "invalid", json: json ?? s)
+}
+
+func prettyJSON(_ obj: NSDictionary) -> String? {
+    if let d = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted) {
+        return String(decoding: d, as: UTF8.self)
+    }
+    return nil
+}
+
+func responseError(_ err: Error) -> String {
+    if let r = err as? ChatResponse {
+        return String(describing: r)
+    } else {
+        return err.localizedDescription
+    }
+}

apps/ios/Shared/Model/Shared/APITypes.swift

@@ -0,0 +1,516 @@
+//
+//  SimpleXAPI.swift
+//  SimpleX NSE
+//
+//  Created by Evgeny on 26/04/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+
+let jsonDecoder = getJSONDecoder()
+let jsonEncoder = getJSONEncoder()
+
+enum ChatCommand {
+    case showActiveUser
+    case createActiveUser(profile: Profile)
+    case startChat
+    case setFilesFolder(filesFolder: String)
+    case apiGetChats
+    case apiGetChat(type: ChatType, id: Int64)
+    case apiSendMessage(type: ChatType, id: Int64, file: String?, quotedItemId: Int64?, msg: MsgContent)
+    case apiUpdateChatItem(type: ChatType, id: Int64, itemId: Int64, msg: MsgContent)
+    case apiDeleteChatItem(type: ChatType, id: Int64, itemId: Int64, mode: CIDeleteMode)
+    case apiRegisterToken(token: String)
+    case apiVerifyToken(token: String, code: String, nonce: String)
+    case apiIntervalNofication(token: String, interval: Int)
+    case apiDeleteToken(token: String)
+    case getUserSMPServers
+    case setUserSMPServers(smpServers: [String])
+    case addContact
+    case connect(connReq: String)
+    case apiDeleteChat(type: ChatType, id: Int64)
+    case apiUpdateProfile(profile: Profile)
+    case apiParseMarkdown(text: String)
+    case createMyAddress
+    case deleteMyAddress
+    case showMyAddress
+    case apiAcceptContact(contactReqId: Int64)
+    case apiRejectContact(contactReqId: Int64)
+    // WebRTC calls
+    case apiSendCallInvitation(contact: Contact, callType: CallType)
+    case apiRejectCall(contact: Contact)
+    case apiSendCallOffer(contact: Contact, callOffer: WebRTCCallOffer)
+    case apiSendCallAnswer(contact: Contact, answer: WebRTCSession)
+    case apiSendCallExtraInfo(contact: Contact, extraInfo: WebRTCExtraInfo)
+    case apiEndCall(contact: Contact)
+    case apiCallStatus(contact: Contact, callStatus: WebRTCCallStatus)
+    case apiChatRead(type: ChatType, id: Int64, itemRange: (Int64, Int64))
+    case receiveFile(fileId: Int64)
+    case string(String)
+
+    var cmdString: String {
+        get {
+            switch self {
+            case .showActiveUser: return "/u"
+            case let .createActiveUser(profile): return "/u \(profile.displayName) \(profile.fullName)"
+            case .startChat: return "/_start"
+            case let .setFilesFolder(filesFolder): return "/_files_folder \(filesFolder)"
+            case .apiGetChats: return "/_get chats pcc=on"
+            case let .apiGetChat(type, id): return "/_get chat \(ref(type, id)) count=100"
+            case let .apiSendMessage(type, id, file, quotedItemId, mc):
+                let msg = encodeJSON(ComposedMessage(filePath: file, quotedItemId: quotedItemId, msgContent: mc))
+                return "/_send \(ref(type, id)) json \(msg)"
+            case let .apiUpdateChatItem(type, id, itemId, mc): return "/_update item \(ref(type, id)) \(itemId) \(mc.cmdString)"
+            case let .apiDeleteChatItem(type, id, itemId, mode): return "/_delete item \(ref(type, id)) \(itemId) \(mode.rawValue)"
+            case let .apiRegisterToken(token): return "/_ntf register apns \(token)"
+            case let .apiVerifyToken(token, code, nonce): return "/_ntf verify apns \(token) \(code) \(nonce)"
+            case let .apiIntervalNofication(token, interval): return "/_ntf interval apns \(token) \(interval)"
+            case let .apiDeleteToken(token): return "/_ntf delete apns \(token)"
+            case .getUserSMPServers: return "/smp_servers"
+            case let .setUserSMPServers(smpServers): return "/smp_servers \(smpServersStr(smpServers: smpServers))"
+            case .addContact: return "/connect"
+            case let .connect(connReq): return "/connect \(connReq)"
+            case let .apiDeleteChat(type, id): return "/_delete \(ref(type, id))"
+            case let .apiUpdateProfile(profile): return "/_profile \(encodeJSON(profile))"
+            case let .apiParseMarkdown(text): return "/_parse \(text)"
+            case .createMyAddress: return "/address"
+            case .deleteMyAddress: return "/delete_address"
+            case .showMyAddress: return "/show_address"
+            case let .apiAcceptContact(contactReqId): return "/_accept \(contactReqId)"
+            case let .apiRejectContact(contactReqId): return "/_reject \(contactReqId)"
+            case let .apiSendCallInvitation(contact, callType): return "/_call invite @\(contact.apiId) \(encodeJSON(callType))"
+            case let .apiRejectCall(contact): return "/_call reject @\(contact.apiId)"
+            case let .apiSendCallOffer(contact, callOffer): return "/_call offer @\(contact.apiId) \(encodeJSON(callOffer))"
+            case let .apiSendCallAnswer(contact, answer): return "/_call answer @\(contact.apiId) \(encodeJSON(answer))"
+            case let .apiSendCallExtraInfo(contact, extraInfo): return "/_call extra @\(contact.apiId) \(encodeJSON(extraInfo))"
+            case let .apiEndCall(contact): return "/_call end @\(contact.apiId)"
+            case let .apiCallStatus(contact, callStatus): return "/_call status @\(contact.apiId) \(callStatus.rawValue)"
+            case let .apiChatRead(type, id, itemRange: (from, to)): return "/_read chat \(ref(type, id)) from=\(from) to=\(to)"
+            case let .receiveFile(fileId): return "/freceive \(fileId)"
+            case let .string(str): return str
+            }
+        }
+    }
+
+    var cmdType: String {
+        get {
+            switch self {
+            case .showActiveUser: return "showActiveUser"
+            case .createActiveUser: return "createActiveUser"
+            case .startChat: return "startChat"
+            case .setFilesFolder: return "setFilesFolder"
+            case .apiGetChats: return "apiGetChats"
+            case .apiGetChat: return "apiGetChat"
+            case .apiSendMessage: return "apiSendMessage"
+            case .apiUpdateChatItem: return "apiUpdateChatItem"
+            case .apiDeleteChatItem: return "apiDeleteChatItem"
+            case .apiRegisterToken: return "apiRegisterToken"
+            case .apiVerifyToken: return "apiVerifyToken"
+            case .apiIntervalNofication: return "apiIntervalNofication"
+            case .apiDeleteToken: return "apiDeleteToken"
+            case .getUserSMPServers: return "getUserSMPServers"
+            case .setUserSMPServers: return "setUserSMPServers"
+            case .addContact: return "addContact"
+            case .connect: return "connect"
+            case .apiDeleteChat: return "apiDeleteChat"
+            case .apiUpdateProfile: return "apiUpdateProfile"
+            case .apiParseMarkdown: return "apiParseMarkdown"
+            case .createMyAddress: return "createMyAddress"
+            case .deleteMyAddress: return "deleteMyAddress"
+            case .showMyAddress: return "showMyAddress"
+            case .apiAcceptContact: return "apiAcceptContact"
+            case .apiRejectContact: return "apiRejectContact"
+            case .apiSendCallInvitation: return "apiSendCallInvitation"
+            case .apiRejectCall: return "apiRejectCall"
+            case .apiSendCallOffer: return "apiSendCallOffer"
+            case .apiSendCallAnswer: return "apiSendCallAnswer"
+            case .apiSendCallExtraInfo: return "apiSendCallExtraInfo"
+            case .apiEndCall: return "apiEndCall"
+            case .apiCallStatus: return "apiCallStatus"
+            case .apiChatRead: return "apiChatRead"
+            case .receiveFile: return "receiveFile"
+            case .string: return "console command"
+            }
+        }
+    }
+
+    func ref(_ type: ChatType, _ id: Int64) -> String {
+        "\(type.rawValue)\(id)"
+    }
+
+    func smpServersStr(smpServers: [String]) -> String {
+        smpServers.isEmpty ? "default" : smpServers.joined(separator: ",")
+    }
+}
+
+struct APIResponse: Decodable {
+    var resp: ChatResponse
+}
+
+enum ChatResponse: Decodable, Error {
+    case response(type: String, json: String)
+    case activeUser(user: User)
+    case chatStarted
+    case chatRunning
+    case apiChats(chats: [ChatData])
+    case apiChat(chat: ChatData)
+    case userSMPServers(smpServers: [String])
+    case invitation(connReqInvitation: String)
+    case sentConfirmation
+    case sentInvitation
+    case contactAlreadyExists(contact: Contact)
+    case contactDeleted(contact: Contact)
+    case userProfileNoChange
+    case userProfileUpdated(fromProfile: Profile, toProfile: Profile)
+    case apiParsedMarkdown(formattedText: [FormattedText]?)
+    case userContactLink(connReqContact: String)
+    case userContactLinkCreated(connReqContact: String)
+    case userContactLinkDeleted
+    case contactConnected(contact: Contact)
+    case contactConnecting(contact: Contact)
+    case receivedContactRequest(contactRequest: UserContactRequest)
+    case acceptingContactRequest(contact: Contact)
+    case contactRequestRejected
+    case contactUpdated(toContact: Contact)
+    case contactsSubscribed(server: String, contactRefs: [ContactRef])
+    case contactsDisconnected(server: String, contactRefs: [ContactRef])
+    case contactSubError(contact: Contact, chatError: ChatError)
+    case contactSubSummary(contactSubscriptions: [ContactSubStatus])
+    case groupSubscribed(groupInfo: GroupInfo)
+    case memberSubErrors(memberSubErrors: [MemberSubError])
+    case groupEmpty(groupInfo: GroupInfo)
+    case userContactLinkSubscribed
+    case newChatItem(chatItem: AChatItem)
+    case chatItemStatusUpdated(chatItem: AChatItem)
+    case chatItemUpdated(chatItem: AChatItem)
+    case chatItemDeleted(deletedChatItem: AChatItem, toChatItem: AChatItem)
+    // receiving file events
+    case rcvFileAccepted(chatItem: AChatItem)
+    case rcvFileStart(chatItem: AChatItem)
+    case rcvFileComplete(chatItem: AChatItem)
+    // sending file events
+    case sndFileStart(chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
+    case sndFileComplete(chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
+    case sndFileCancelled(chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
+    case sndFileRcvCancelled(chatItem: AChatItem, sndFileTransfer: SndFileTransfer)
+    case sndGroupFileCancelled(chatItem: AChatItem, fileTransferMeta: FileTransferMeta, sndFileTransfers: [SndFileTransfer])
+    case callInvitation(contact: Contact, callType: CallType, sharedKey: String?)
+    case callOffer(contact: Contact, callType: CallType, offer: WebRTCSession, sharedKey: String?, askConfirmation: Bool)
+    case callAnswer(contact: Contact, answer: WebRTCSession)
+    case callExtraInfo(contact: Contact, extraInfo: WebRTCExtraInfo)
+    case callEnded(contact: Contact)
+    case ntfTokenStatus(status: NtfTknStatus)
+    case newContactConnection(connection: PendingContactConnection)
+    case contactConnectionDeleted(connection: PendingContactConnection)
+    case cmdOk
+    case chatCmdError(chatError: ChatError)
+    case chatError(chatError: ChatError)
+
+    var responseType: String {
+        get {
+            switch self {
+            case let .response(type, _): return "* \(type)"
+            case .activeUser: return "activeUser"
+            case .chatStarted: return "chatStarted"
+            case .chatRunning: return "chatRunning"
+            case .apiChats: return "apiChats"
+            case .apiChat: return "apiChat"
+            case .userSMPServers: return "userSMPServers"
+            case .invitation: return "invitation"
+            case .sentConfirmation: return "sentConfirmation"
+            case .sentInvitation: return "sentInvitation"
+            case .contactAlreadyExists: return "contactAlreadyExists"
+            case .contactDeleted: return "contactDeleted"
+            case .userProfileNoChange: return "userProfileNoChange"
+            case .userProfileUpdated: return "userProfileUpdated"
+            case .apiParsedMarkdown: return "apiParsedMarkdown"
+            case .userContactLink: return "userContactLink"
+            case .userContactLinkCreated: return "userContactLinkCreated"
+            case .userContactLinkDeleted: return "userContactLinkDeleted"
+            case .contactConnected: return "contactConnected"
+            case .contactConnecting: return "contactConnecting"
+            case .receivedContactRequest: return "receivedContactRequest"
+            case .acceptingContactRequest: return "acceptingContactRequest"
+            case .contactRequestRejected: return "contactRequestRejected"
+            case .contactUpdated: return "contactUpdated"
+            case .contactsSubscribed: return "contactsSubscribed"
+            case .contactsDisconnected: return "contactsDisconnected"
+            case .contactSubError: return "contactSubError"
+            case .contactSubSummary: return "contactSubSummary"
+            case .groupSubscribed: return "groupSubscribed"
+            case .memberSubErrors: return "memberSubErrors"
+            case .groupEmpty: return "groupEmpty"
+            case .userContactLinkSubscribed: return "userContactLinkSubscribed"
+            case .newChatItem: return "newChatItem"
+            case .chatItemStatusUpdated: return "chatItemStatusUpdated"
+            case .chatItemUpdated: return "chatItemUpdated"
+            case .chatItemDeleted: return "chatItemDeleted"
+            case .rcvFileAccepted: return "rcvFileAccepted"
+            case .rcvFileStart: return "rcvFileStart"
+            case .rcvFileComplete: return "rcvFileComplete"
+            case .sndFileStart: return "sndFileStart"
+            case .sndFileComplete: return "sndFileComplete"
+            case .sndFileCancelled: return "sndFileCancelled"
+            case .sndFileRcvCancelled: return "sndFileRcvCancelled"
+            case .sndGroupFileCancelled: return "sndGroupFileCancelled"
+            case .callInvitation: return "callInvitation"
+            case .callOffer: return "callOffer"
+            case .callAnswer: return "callAnswer"
+            case .callExtraInfo: return "callExtraInfo"
+            case .callEnded: return "callEnded"
+            case .ntfTokenStatus: return "ntfTokenStatus"
+            case .newContactConnection: return "newContactConnection"
+            case .contactConnectionDeleted: return "contactConnectionDeleted"
+            case .cmdOk: return "cmdOk"
+            case .chatCmdError: return "chatCmdError"
+            case .chatError: return "chatError"
+            }
+        }
+    }
+
+    var details: String {
+        get {
+            switch self {
+            case let .response(_, json): return json
+            case let .activeUser(user): return String(describing: user)
+            case .chatStarted: return noDetails
+            case .chatRunning: return noDetails
+            case let .apiChats(chats): return String(describing: chats)
+            case let .apiChat(chat): return String(describing: chat)
+            case let .userSMPServers(smpServers): return String(describing: smpServers)
+            case let .invitation(connReqInvitation): return connReqInvitation
+            case .sentConfirmation: return noDetails
+            case .sentInvitation: return noDetails
+            case let .contactAlreadyExists(contact): return String(describing: contact)
+            case let .contactDeleted(contact): return String(describing: contact)
+            case .userProfileNoChange: return noDetails
+            case let .userProfileUpdated(_, toProfile): return String(describing: toProfile)
+            case let .apiParsedMarkdown(formattedText): return String(describing: formattedText)
+            case let .userContactLink(connReq): return connReq
+            case let .userContactLinkCreated(connReq): return connReq
+            case .userContactLinkDeleted: return noDetails
+            case let .contactConnected(contact): return String(describing: contact)
+            case let .contactConnecting(contact): return String(describing: contact)
+            case let .receivedContactRequest(contactRequest): return String(describing: contactRequest)
+            case let .acceptingContactRequest(contact): return String(describing: contact)
+            case .contactRequestRejected: return noDetails
+            case let .contactUpdated(toContact): return String(describing: toContact)
+            case let .contactsSubscribed(server, contactRefs): return "server: \(server)\ncontacts:\n\(String(describing: contactRefs))"
+            case let .contactsDisconnected(server, contactRefs): return "server: \(server)\ncontacts:\n\(String(describing: contactRefs))"
+            case let .contactSubError(contact, chatError): return "contact:\n\(String(describing: contact))\nerror:\n\(String(describing: chatError))"
+            case let .contactSubSummary(contactSubscriptions): return String(describing: contactSubscriptions)
+            case let .groupSubscribed(groupInfo): return String(describing: groupInfo)
+            case let .memberSubErrors(memberSubErrors): return String(describing: memberSubErrors)
+            case let .groupEmpty(groupInfo): return String(describing: groupInfo)
+            case .userContactLinkSubscribed: return noDetails
+            case let .newChatItem(chatItem): return String(describing: chatItem)
+            case let .chatItemStatusUpdated(chatItem): return String(describing: chatItem)
+            case let .chatItemUpdated(chatItem): return String(describing: chatItem)
+            case let .chatItemDeleted(deletedChatItem, toChatItem): return "deletedChatItem:\n\(String(describing: deletedChatItem))\ntoChatItem:\n\(String(describing: toChatItem))"
+            case let .rcvFileAccepted(chatItem): return String(describing: chatItem)
+            case let .rcvFileStart(chatItem): return String(describing: chatItem)
+            case let .rcvFileComplete(chatItem): return String(describing: chatItem)
+            case let .sndFileStart(chatItem, _): return String(describing: chatItem)
+            case let .sndFileComplete(chatItem, _): return String(describing: chatItem)
+            case let .sndFileCancelled(chatItem, _): return String(describing: chatItem)
+            case let .sndFileRcvCancelled(chatItem, _): return String(describing: chatItem)
+            case let .sndGroupFileCancelled(chatItem, _, _): return String(describing: chatItem)
+            case let .callInvitation(contact, callType, sharedKey): return "contact: \(contact.id)\ncallType: \(String(describing: callType))\nsharedKey: \(sharedKey ?? "")"
+            case let .callOffer(contact, callType, offer, sharedKey, askConfirmation): return "contact: \(contact.id)\ncallType: \(String(describing: callType))\nsharedKey: \(sharedKey ?? "")\naskConfirmation: \(askConfirmation)\noffer: \(String(describing: offer))"
+            case let .callAnswer(contact, answer): return "contact: \(contact.id)\nanswer: \(String(describing: answer))"
+            case let .callExtraInfo(contact, extraInfo): return "contact: \(contact.id)\nextraInfo: \(String(describing: extraInfo))"
+            case let .callEnded(contact): return "contact: \(contact.id)"
+            case let .ntfTokenStatus(status): return String(describing: status)
+            case let .newContactConnection(connection): return String(describing: connection)
+            case let .contactConnectionDeleted(connection): return String(describing: connection)
+            case .cmdOk: return noDetails
+            case let .chatCmdError(chatError): return String(describing: chatError)
+            case let .chatError(chatError): return String(describing: chatError)
+            }
+        }
+    }
+
+    private var noDetails: String { get { "\(responseType): no details" } }
+}
+
+struct ComposedMessage: Encodable {
+    var filePath: String?
+    var quotedItemId: Int64?
+    var msgContent: MsgContent
+}
+
+func decodeJSON<T: Decodable>(_ json: String) -> T? {
+    if let data = json.data(using: .utf8) {
+        return try? jsonDecoder.decode(T.self, from: data)
+    }
+    return nil
+}
+
+func decodeCJSON<T: Decodable>(_ cjson: UnsafePointer<CChar>) -> T? {
+    // TODO is there a way to do it without copying the data? e.g:
+    //    let p = UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer(cjson))
+    //    let d = Data.init(bytesNoCopy: p, count: strlen(cjson), deallocator: .free)
+    decodeJSON(String.init(cString: cjson))
+}
+
+private func getJSONObject(_ cjson: UnsafePointer<CChar>) -> NSDictionary? {
+    let s = String.init(cString: cjson)
+    let d = s.data(using: .utf8)!
+    return try? JSONSerialization.jsonObject(with: d) as? NSDictionary
+}
+
+func encodeJSON<T: Encodable>(_ value: T) -> String {
+    let data = try! jsonEncoder.encode(value)
+    return String(decoding: data, as: UTF8.self)
+}
+
+private func encodeCJSON<T: Encodable>(_ value: T) -> [CChar] {
+    encodeJSON(value).cString(using: .utf8)!
+}
+
+enum ChatError: Decodable {
+    case error(errorType: ChatErrorType)
+    case errorAgent(agentError: AgentErrorType)
+    case errorStore(storeError: StoreError)
+}
+
+enum ChatErrorType: Decodable {
+    case noActiveUser
+    case activeUserExists
+    case chatNotStarted
+    case invalidConnReq
+    case invalidChatMessage(message: String)
+    case contactNotReady(contact: Contact)
+    case contactGroups(contact: Contact, groupNames: [GroupName])
+    case groupUserRole
+    case groupContactRole(contactName: ContactName)
+    case groupDuplicateMember(contactName: ContactName)
+    case groupDuplicateMemberId
+    case groupNotJoined(groupInfo: GroupInfo)
+    case groupMemberNotActive
+    case groupMemberUserRemoved
+    case groupMemberNotFound(contactName: ContactName)
+    case groupMemberIntroNotFound(contactName: ContactName)
+    case groupCantResendInvitation(groupInfo: GroupInfo, contactName: ContactName)
+    case groupInternal(message: String)
+    case fileNotFound(message: String)
+    case fileAlreadyReceiving(message: String)
+    case fileAlreadyExists(filePath: String)
+    case fileRead(filePath: String, message: String)
+    case fileWrite(filePath: String, message: String)
+    case fileSend(fileId: Int64, agentError: String)
+    case fileRcvChunk(message: String)
+    case fileInternal(message: String)
+    case invalidQuote
+    case invalidChatItemUpdate
+    case invalidChatItemDelete
+    case agentVersion
+    case commandError(message: String)
+}
+
+enum StoreError: Decodable {
+    case duplicateName
+    case contactNotFound(contactId: Int64)
+    case contactNotFoundByName(contactName: ContactName)
+    case contactNotReady(contactName: ContactName)
+    case duplicateContactLink
+    case userContactLinkNotFound
+    case contactRequestNotFound(contactRequestId: Int64)
+    case contactRequestNotFoundByName(contactName: ContactName)
+    case groupNotFound(groupId: Int64)
+    case groupNotFoundByName(groupName: GroupName)
+    case groupWithoutUser
+    case duplicateGroupMember
+    case groupAlreadyJoined
+    case groupInvitationNotFound
+    case sndFileNotFound(fileId: Int64)
+    case sndFileInvalid(fileId: Int64)
+    case rcvFileNotFound(fileId: Int64)
+    case fileNotFound(fileId: Int64)
+    case rcvFileInvalid(fileId: Int64)
+    case connectionNotFound(agentConnId: String)
+    case pendingConnectionNotFound(connId: Int64)
+    case introNotFound
+    case uniqueID
+    case internalError(message: String)
+    case noMsgDelivery(connId: Int64, agentMsgId: String)
+    case badChatItem(itemId: Int64)
+    case chatItemNotFound(itemId: Int64)
+    case quotedChatItemNotFound
+    case chatItemSharedMsgIdNotFound(sharedMsgId: String)
+    case chatItemNotFoundByFileId(fileId: Int64)
+}
+
+enum AgentErrorType: Decodable {
+    case CMD(cmdErr: CommandErrorType)
+    case CONN(connErr: ConnectionErrorType)
+    case SMP(smpErr: ProtocolErrorType)
+    case NTF(ntfErr: ProtocolErrorType)
+    case BROKER(brokerErr: BrokerErrorType)
+    case AGENT(agentErr: SMPAgentError)
+    case INTERNAL(internalErr: String)
+}
+
+enum CommandErrorType: Decodable {
+    case PROHIBITED
+    case SYNTAX
+    case NO_CONN
+    case SIZE
+    case LARGE
+}
+
+enum ConnectionErrorType: Decodable {
+    case NOT_FOUND
+    case DUPLICATE
+    case SIMPLEX
+    case NOT_ACCEPTED
+    case NOT_AVAILABLE
+}
+
+enum BrokerErrorType: Decodable {
+    case RESPONSE(smpErr: ProtocolErrorType)
+    case UNEXPECTED
+    case NETWORK
+    case TRANSPORT(transportErr: ProtocolTransportError)
+    case TIMEOUT
+}
+
+enum ProtocolErrorType: Decodable {
+    case BLOCK
+    case SESSION
+    case CMD(cmdErr: ProtocolCommandError)
+    case AUTH
+    case QUOTA
+    case NO_MSG
+    case LARGE_MSG
+    case INTERNAL
+}
+
+enum ProtocolCommandError: Decodable {
+    case UNKNOWN
+    case SYNTAX
+    case NO_AUTH
+    case HAS_AUTH
+    case NO_ENTITY
+}
+
+enum ProtocolTransportError: Decodable {
+    case badBlock
+    case largeMsg
+    case badSession
+    case handshake(handshakeErr: SMPHandshakeError)
+}
+
+enum SMPHandshakeError: Decodable {
+    case PARSE
+    case VERSION
+    case IDENTITY
+}
+
+enum SMPAgentError: Decodable {
+    case A_MESSAGE
+    case A_PROHIBITED
+    case A_VERSION
+    case A_ENCRYPTION
+}

apps/ios/Shared/Model/Shared/CallTypes.swift

@@ -0,0 +1,48 @@
+//
+//  CallTypes.swift
+//  SimpleX (iOS)
+//
+//  Created by Evgeny on 05/05/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+
+struct WebRTCCallOffer: Encodable {
+    var callType: CallType
+    var rtcSession: WebRTCSession
+}
+
+struct WebRTCSession: Codable {
+    var rtcSession: String
+    var rtcIceCandidates: [String]
+}
+
+struct WebRTCExtraInfo: Codable {
+    var rtcIceCandidates: [String]
+}
+
+struct CallInvitation {
+    var peerMedia: CallMediaType
+    var sharedKey: String?
+}
+
+struct CallType: Codable {
+    var media: CallMediaType
+    var capabilities: CallCapabilities
+}
+
+enum CallMediaType: String, Codable, Equatable {
+    case video = "video"
+    case audio = "audio"
+}
+
+struct CallCapabilities: Codable, Equatable {
+    var encryption: Bool
+}
+
+enum WebRTCCallStatus: String, Encodable {
+    case connected = "connected"
+    case disconnected = "disconnected"
+    case failed = "failed"
+}

apps/ios/Shared/Model/Shared/ChatTypes.swift

@@ -0,0 +1,878 @@
+//
+//  ChatModel.swift
+//  SimpleX NSE
+//
+//  Created by Evgeny on 26/04/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+import SwiftUI
+
+struct User: Decodable, NamedChat {
+    var userId: Int64
+    var userContactId: Int64
+    var localDisplayName: ContactName
+    var profile: Profile
+    var activeUser: Bool
+
+    var displayName: String { get { profile.displayName } }
+    var fullName: String { get { profile.fullName } }
+    var image: String? { get { profile.image } }
+
+    static let sampleData = User(
+        userId: 1,
+        userContactId: 1,
+        localDisplayName: "alice",
+        profile: Profile.sampleData,
+        activeUser: true
+    )
+}
+
+typealias ContactName = String
+
+typealias GroupName = String
+
+struct Profile: Codable, NamedChat {
+    var displayName: String
+    var fullName: String
+    var image: String?
+
+    static let sampleData = Profile(
+        displayName: "alice",
+        fullName: "Alice"
+    )
+}
+
+enum ChatType: String {
+    case direct = "@"
+    case group = "#"
+    case contactRequest = "<@"
+    case contactConnection = ":"
+}
+
+protocol NamedChat {
+    var displayName: String { get }
+    var fullName: String { get }
+    var image: String? { get }
+}
+
+extension NamedChat {
+    var chatViewName: String {
+        get { displayName + (fullName == "" || fullName == displayName ? "" : " / \(fullName)") }
+    }
+}
+
+typealias ChatId = String
+
+enum ChatInfo: Identifiable, Decodable, NamedChat {
+    case direct(contact: Contact)
+    case group(groupInfo: GroupInfo)
+    case contactRequest(contactRequest: UserContactRequest)
+    case contactConnection(contactConnection: PendingContactConnection)
+
+    var localDisplayName: String {
+        get {
+            switch self {
+            case let .direct(contact): return contact.localDisplayName
+            case let .group(groupInfo): return groupInfo.localDisplayName
+            case let .contactRequest(contactRequest): return contactRequest.localDisplayName
+            case let .contactConnection(contactConnection): return contactConnection.localDisplayName
+            }
+        }
+    }
+
+    var displayName: String {
+        get {
+            switch self {
+            case let .direct(contact): return contact.displayName
+            case let .group(groupInfo): return groupInfo.displayName
+            case let .contactRequest(contactRequest): return contactRequest.displayName
+            case let .contactConnection(contactConnection): return contactConnection.displayName
+            }
+        }
+    }
+
+    var fullName: String {
+        get {
+            switch self {
+            case let .direct(contact): return contact.fullName
+            case let .group(groupInfo): return groupInfo.fullName
+            case let .contactRequest(contactRequest): return contactRequest.fullName
+            case let .contactConnection(contactConnection): return contactConnection.fullName
+            }
+        }
+    }
+
+    var image: String? {
+        get {
+            switch self {
+            case let .direct(contact): return contact.image
+            case let .group(groupInfo): return groupInfo.image
+            case let .contactRequest(contactRequest): return contactRequest.image
+            case let .contactConnection(contactConnection): return contactConnection.image
+            }
+        }
+    }
+
+    var id: ChatId {
+        get {
+            switch self {
+            case let .direct(contact): return contact.id
+            case let .group(groupInfo): return groupInfo.id
+            case let .contactRequest(contactRequest): return contactRequest.id
+            case let .contactConnection(contactConnection): return contactConnection.id
+            }
+        }
+    }
+
+    var chatType: ChatType {
+        get {
+            switch self {
+            case .direct: return .direct
+            case .group: return .group
+            case .contactRequest: return .contactRequest
+            case .contactConnection: return .contactConnection
+            }
+        }
+    }
+
+    var apiId: Int64 {
+        get {
+            switch self {
+            case let .direct(contact): return contact.apiId
+            case let .group(groupInfo): return groupInfo.apiId
+            case let .contactRequest(contactRequest): return contactRequest.apiId
+            case let .contactConnection(contactConnection): return contactConnection.apiId
+            }
+        }
+    }
+
+    var ready: Bool {
+        get {
+            switch self {
+            case let .direct(contact): return contact.ready
+            case let .group(groupInfo): return groupInfo.ready
+            case let .contactRequest(contactRequest): return contactRequest.ready
+            case let .contactConnection(contactConnection): return contactConnection.ready
+            }
+        }
+    }
+
+    var createdAt: Date {
+        switch self {
+        case let .direct(contact): return contact.createdAt
+        case let .group(groupInfo): return groupInfo.createdAt
+        case let .contactRequest(contactRequest): return contactRequest.createdAt
+        case let .contactConnection(contactConnection): return contactConnection.createdAt
+        }
+    }
+
+    struct SampleData {
+        var direct: ChatInfo
+        var group: ChatInfo
+        var contactRequest: ChatInfo
+    }
+
+    static var sampleData: ChatInfo.SampleData = SampleData(
+        direct: ChatInfo.direct(contact: Contact.sampleData),
+        group: ChatInfo.group(groupInfo: GroupInfo.sampleData),
+        contactRequest: ChatInfo.contactRequest(contactRequest: UserContactRequest.sampleData)
+    )
+}
+
+struct ChatData: Decodable, Identifiable {
+    var chatInfo: ChatInfo
+    var chatItems: [ChatItem]
+    var chatStats: ChatStats
+
+    var id: ChatId { get { chatInfo.id } }
+}
+
+struct ChatStats: Decodable {
+    var unreadCount: Int = 0
+    var minUnreadItemId: Int64 = 0
+}
+
+struct Contact: Identifiable, Decodable, NamedChat {
+    var contactId: Int64
+    var localDisplayName: ContactName
+    var profile: Profile
+    var activeConn: Connection
+    var viaGroup: Int64?
+    var createdAt: Date
+
+    var id: ChatId { get { "@\(contactId)" } }
+    var apiId: Int64 { get { contactId } }
+    var ready: Bool { get { activeConn.connStatus == .ready } }
+    var displayName: String { get { profile.displayName } }
+    var fullName: String { get { profile.fullName } }
+    var image: String? { get { profile.image } }
+
+    static let sampleData = Contact(
+        contactId: 1,
+        localDisplayName: "alice",
+        profile: Profile.sampleData,
+        activeConn: Connection.sampleData,
+        createdAt: .now
+    )
+}
+
+struct ContactRef: Decodable, Equatable {
+    var contactId: Int64
+    var localDisplayName: ContactName
+
+    var id: ChatId { get { "@\(contactId)" } }
+}
+
+struct ContactSubStatus: Decodable {
+    var contact: Contact
+    var contactError: ChatError?
+}
+
+struct Connection: Decodable {
+    var connId: Int64
+    var connStatus: ConnStatus
+
+    var id: ChatId { get { ":\(connId)" } }
+
+    static let sampleData = Connection(
+        connId: 1,
+        connStatus: .ready
+    )
+}
+
+struct UserContactRequest: Decodable, NamedChat {
+    var contactRequestId: Int64
+    var localDisplayName: ContactName
+    var profile: Profile
+    var createdAt: Date
+    var updatedAt: Date
+
+    var id: ChatId { get { "<@\(contactRequestId)" } }
+    var apiId: Int64 { get { contactRequestId } }
+    var ready: Bool { get { true } }
+    var displayName: String { get { profile.displayName } }
+    var fullName: String { get { profile.fullName } }
+    var image: String? { get { profile.image } }
+
+    static let sampleData = UserContactRequest(
+        contactRequestId: 1,
+        localDisplayName: "alice",
+        profile: Profile.sampleData,
+        createdAt: .now,
+        updatedAt: .now
+    )
+}
+
+struct PendingContactConnection: Decodable, NamedChat {
+    var pccConnId: Int64
+    var pccAgentConnId: String
+    var pccConnStatus: ConnStatus
+    var viaContactUri: Bool
+    var createdAt: Date
+    var updatedAt: Date
+
+    var id: ChatId { get { ":\(pccConnId)" } }
+    var apiId: Int64 { get { pccConnId } }
+    var ready: Bool { get { false } }
+    var localDisplayName: String {
+        get { String.localizedStringWithFormat(NSLocalizedString("connection:%@", comment: "connection information"), pccConnId) }
+    }
+    var displayName: String {
+        get {
+            if let initiated = pccConnStatus.initiated {
+                return initiated && !viaContactUri
+                ? NSLocalizedString("invited to connect", comment: "chat list item title")
+                : NSLocalizedString("connecting…", comment: "chat list item title")
+            } else {
+                // this should not be in the list
+                return NSLocalizedString("connection established", comment: "chat list item title (it should not be shown")
+            }
+        }
+    }
+    var fullName: String { get { "" } }
+    var image: String? { get { nil } }
+    var initiated: Bool { get { (pccConnStatus.initiated ?? false) && !viaContactUri } }
+
+    var description: String {
+        get {
+            if let initiated = pccConnStatus.initiated {
+                return initiated && !viaContactUri
+                ? NSLocalizedString("you shared one-time link", comment: "chat list item description")
+                : viaContactUri
+                ? NSLocalizedString("via contact address link", comment: "chat list item description")
+                : NSLocalizedString("via one-time link", comment: "chat list item description")
+            } else {
+                return ""
+            }
+        }
+    }
+
+    static func getSampleData(_ status: ConnStatus = .new, viaContactUri: Bool = false) -> PendingContactConnection {
+        PendingContactConnection(
+            pccConnId: 1,
+            pccAgentConnId: "abcd",
+            pccConnStatus: status,
+            viaContactUri: viaContactUri,
+            createdAt: .now,
+            updatedAt: .now
+        )
+    }
+}
+
+enum ConnStatus: String, Decodable {
+    case new = "new"
+    case joined = "joined"
+    case requested = "requested"
+    case accepted = "accepted"
+    case sndReady = "snd-ready"
+    case ready = "ready"
+    case deleted = "deleted"
+
+    var initiated: Bool? {
+        get {
+            switch self {
+            case .new: return true
+            case .joined: return false
+            case .requested: return true
+            case .accepted: return true
+            case .sndReady: return false
+            case .ready: return nil
+            case .deleted: return nil
+            }
+        }
+    }
+}
+
+struct GroupInfo: Identifiable, Decodable, NamedChat {
+    var groupId: Int64
+    var localDisplayName: GroupName
+    var groupProfile: GroupProfile
+    var createdAt: Date
+
+    var id: ChatId { get { "#\(groupId)" } }
+    var apiId: Int64 { get { groupId } }
+    var ready: Bool { get { true } }
+    var displayName: String { get { groupProfile.displayName } }
+    var fullName: String { get { groupProfile.fullName } }
+    var image: String? { get { groupProfile.image } }
+
+    static let sampleData = GroupInfo(
+        groupId: 1,
+        localDisplayName: "team",
+        groupProfile: GroupProfile.sampleData,
+        createdAt: .now
+    )
+}
+
+struct GroupProfile: Codable, NamedChat {
+    var displayName: String
+    var fullName: String
+    var image: String?
+
+    static let sampleData = GroupProfile(
+        displayName: "team",
+        fullName: "My Team"
+    )
+}
+
+struct GroupMember: Decodable {
+    var groupMemberId: Int64
+    var memberId: String
+//    var memberRole: GroupMemberRole
+//    var memberCategory: GroupMemberCategory
+//    var memberStatus: GroupMemberStatus
+//    var invitedBy: InvitedBy
+    var localDisplayName: ContactName
+    var memberProfile: Profile
+    var memberContactId: Int64?
+//    var activeConn: Connection?
+
+    var directChatId: ChatId? {
+        get {
+            if let chatId = memberContactId {
+                return "@\(chatId)"
+            } else {
+                return nil
+            }
+        }
+    }
+
+    static let sampleData = GroupMember(
+        groupMemberId: 1,
+        memberId: "abcd",
+        localDisplayName: "alice",
+        memberProfile: Profile.sampleData,
+        memberContactId: 1
+    )
+}
+
+struct MemberSubError: Decodable {
+    var member: GroupMember
+    var memberError: ChatError
+}
+
+struct AChatItem: Decodable {
+    var chatInfo: ChatInfo
+    var chatItem: ChatItem
+}
+
+struct ChatItem: Identifiable, Decodable {
+    var chatDir: CIDirection
+    var meta: CIMeta
+    var content: CIContent
+    var formattedText: [FormattedText]?
+    var quotedItem: CIQuote?
+    var file: CIFile?
+
+    var id: Int64 { get { meta.itemId } }
+
+    var timestampText: Text { get { meta.timestampText } }
+
+    var text: String {
+        get {
+            switch (content.text, file) {
+            case let ("", .some(file)): return file.fileName
+            default: return content.text
+            }
+        }
+    }
+
+    func isRcvNew() -> Bool {
+        if case .rcvNew = meta.itemStatus { return true }
+        return false
+    }
+
+    func isMsgContent() -> Bool {
+        switch content {
+        case .sndMsgContent: return true
+        case .rcvMsgContent: return true
+        default: return false
+        }
+    }
+
+    func isDeletedContent() -> Bool {
+        switch content {
+        case .sndDeleted: return true
+        case .rcvDeleted: return true
+        default: return false
+        }
+    }
+
+    func isCall() -> Bool {
+        switch content {
+        case .sndCall: return true
+        case .rcvCall: return true
+        default: return false
+        }
+    }
+
+    var memberDisplayName: String? {
+        get {
+            if case let .groupRcv(groupMember) = chatDir {
+                return groupMember.memberProfile.displayName
+            } else {
+                return nil
+            }
+        }
+    }
+
+    static func getSample (_ id: Int64, _ dir: CIDirection, _ ts: Date, _ text: String, _ status: CIStatus = .sndNew, quotedItem: CIQuote? = nil, file: CIFile? = nil, _ itemDeleted: Bool = false, _ itemEdited: Bool = false, _ editable: Bool = true) -> ChatItem {
+        ChatItem(
+            chatDir: dir,
+            meta: CIMeta.getSample(id, ts, text, status, itemDeleted, itemEdited, editable),
+            content: .sndMsgContent(msgContent: .text(text)),
+            quotedItem: quotedItem,
+            file: file
+       )
+    }
+
+    static func getFileMsgContentSample (id: Int64 = 1, text: String = "", fileName: String = "test.txt", fileSize: Int64 = 100, fileStatus: CIFileStatus = .rcvComplete) -> ChatItem {
+        ChatItem(
+            chatDir: .directRcv,
+            meta: CIMeta.getSample(id, .now, text, .rcvRead, false, false, false),
+            content: .rcvMsgContent(msgContent: .file(text)),
+            quotedItem: nil,
+            file: CIFile.getSample(fileName: fileName, fileSize: fileSize, fileStatus: fileStatus)
+       )
+    }
+
+    static func getDeletedContentSample (_ id: Int64 = 1, dir: CIDirection = .directRcv, _ ts: Date = .now, _ text: String = "this item is deleted", _ status: CIStatus = .rcvRead) -> ChatItem {
+        ChatItem(
+            chatDir: dir,
+            meta: CIMeta.getSample(id, ts, text, status, false, false, false),
+            content: .rcvDeleted(deleteMode: .cidmBroadcast),
+            quotedItem: nil,
+            file: nil
+       )
+    }
+}
+
+enum CIDirection: Decodable {
+    case directSnd
+    case directRcv
+    case groupSnd
+    case groupRcv(groupMember: GroupMember)
+
+    var sent: Bool {
+        get {
+            switch self {
+            case .directSnd: return true
+            case .directRcv: return false
+            case .groupSnd: return true
+            case .groupRcv: return false
+            }
+        }
+    }
+}
+
+struct CIMeta: Decodable {
+    var itemId: Int64
+    var itemTs: Date
+    var itemText: String
+    var itemStatus: CIStatus
+    var createdAt: Date
+    var itemDeleted: Bool
+    var itemEdited: Bool
+    var editable: Bool
+
+    var timestampText: Text { get { formatTimestampText(itemTs) } }
+
+    static func getSample(_ id: Int64, _ ts: Date, _ text: String, _ status: CIStatus = .sndNew, _ itemDeleted: Bool = false, _ itemEdited: Bool = false, _ editable: Bool = true) -> CIMeta {
+        CIMeta(
+            itemId: id,
+            itemTs: ts,
+            itemText: text,
+            itemStatus: status,
+            createdAt: ts,
+            itemDeleted: itemDeleted,
+            itemEdited: itemEdited,
+            editable: editable
+        )
+    }
+}
+
+let msgTimeFormat = Date.FormatStyle.dateTime.hour().minute()
+let msgDateFormat = Date.FormatStyle.dateTime.day(.twoDigits).month(.twoDigits)
+
+func formatTimestampText(_ date: Date) -> Text {
+    let now = Calendar.current.dateComponents([.day, .hour], from: .now)
+    let dc = Calendar.current.dateComponents([.day, .hour], from: date)
+    let recent = now.day == dc.day || ((now.day ?? 0) - (dc.day ?? 0) == 1 && (dc.hour ?? 0) >= 18 && (now.hour ?? 0) < 12)
+    return Text(date, format: recent ? msgTimeFormat : msgDateFormat)
+}
+
+enum CIStatus: Decodable {
+    case sndNew
+    case sndSent
+    case sndErrorAuth
+    case sndError(agentError: AgentErrorType)
+    case rcvNew
+    case rcvRead
+}
+
+enum CIDeleteMode: String, Decodable {
+    case cidmBroadcast = "broadcast"
+    case cidmInternal = "internal"
+}
+
+protocol ItemContent {
+    var text: String { get }
+}
+
+enum CIContent: Decodable, ItemContent {
+    case sndMsgContent(msgContent: MsgContent)
+    case rcvMsgContent(msgContent: MsgContent)
+    case sndDeleted(deleteMode: CIDeleteMode)
+    case rcvDeleted(deleteMode: CIDeleteMode)
+    case sndCall(status: CICallStatus, duration: Int)
+    case rcvCall(status: CICallStatus, duration: Int)
+
+    var text: String {
+        get {
+            switch self {
+            case let .sndMsgContent(mc): return mc.text
+            case let .rcvMsgContent(mc): return mc.text
+            case .sndDeleted: return NSLocalizedString("deleted", comment: "deleted chat item")
+            case .rcvDeleted: return NSLocalizedString("deleted", comment: "deleted chat item")
+            case let .sndCall(status, duration): return status.text(duration)
+            case let .rcvCall(status, duration): return status.text(duration)
+            }
+        }
+    }
+
+    var msgContent: MsgContent? {
+        get {
+            switch self {
+            case let .sndMsgContent(mc): return mc
+            case let .rcvMsgContent(mc): return mc
+            default: return nil
+            }
+        }
+    }
+}
+
+struct CIQuote: Decodable, ItemContent {
+    var chatDir: CIDirection?
+    var itemId: Int64?
+    var sharedMsgId: String? = nil
+    var sentAt: Date
+    var content: MsgContent
+    var formattedText: [FormattedText]?
+
+    var text: String { get { content.text } }
+
+    func getSender(_ currentUser: User?) -> String? {
+        switch (chatDir) {
+        case .directSnd: return "you"
+        case .directRcv: return nil
+        case .groupSnd: return currentUser?.displayName
+        case let .groupRcv(member): return member.memberProfile.displayName
+        case nil: return nil
+        }
+    }
+
+    static func getSample(_ itemId: Int64?, _ sentAt: Date, _ text: String, chatDir: CIDirection?, image: String? = nil) -> CIQuote {
+        let mc: MsgContent
+        if let image = image {
+            mc = .image(text: text, image: image)
+        } else {
+            mc = .text(text)
+        }
+        return CIQuote(chatDir: chatDir, itemId: itemId, sentAt: sentAt, content: mc)
+    }
+}
+
+struct CIFile: Decodable {
+    var fileId: Int64
+    var fileName: String
+    var fileSize: Int64
+    var filePath: String?
+    var fileStatus: CIFileStatus
+
+    static func getSample(fileId: Int64 = 1, fileName: String = "test.txt", fileSize: Int64 = 100, filePath: String? = "test.txt", fileStatus: CIFileStatus = .rcvComplete) -> CIFile {
+        CIFile(fileId: fileId, fileName: fileName, fileSize: fileSize, filePath: filePath, fileStatus: fileStatus)
+    }
+
+    var loaded: Bool {
+        get {
+            switch self.fileStatus {
+            case .sndStored: return true
+            case .sndTransfer: return true
+            case .sndComplete: return true
+            case .sndCancelled: return true
+            case .rcvInvitation: return false
+            case .rcvAccepted: return false
+            case .rcvTransfer: return false
+            case .rcvCancelled: return false
+            case .rcvComplete: return true
+            }
+        }
+    }
+}
+
+enum CIFileStatus: String, Decodable {
+    case sndStored = "snd_stored"
+    case sndTransfer = "snd_transfer"
+    case sndComplete = "snd_complete"
+    case sndCancelled = "snd_cancelled"
+    case rcvInvitation = "rcv_invitation"
+    case rcvAccepted = "rcv_accepted"
+    case rcvTransfer = "rcv_transfer"
+    case rcvComplete = "rcv_complete"
+    case rcvCancelled = "rcv_cancelled"
+}
+
+enum MsgContent {
+    case text(String)
+    case link(text: String, preview: LinkPreview)
+    case image(text: String, image: String)
+    case file(String)
+    // TODO include original JSON, possibly using https://github.com/zoul/generic-json-swift
+    case unknown(type: String, text: String)
+
+    var text: String {
+        get {
+            switch self {
+            case let .text(text): return text
+            case let .link(text, _): return text
+            case let .image(text, _): return text
+            case let .file(text): return text
+            case let .unknown(_, text): return text
+            }
+        }
+    }
+
+    var cmdString: String {
+        get {
+            switch self {
+            case let .text(text): return "text \(text)"
+            default: return "json \(encodeJSON(self))"
+            }
+        }
+    }
+
+    func isFile() -> Bool {
+        switch self {
+        case .file: return true
+        default: return false
+        }
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case type
+        case text
+        case preview
+        case image
+    }
+}
+
+extension MsgContent: Decodable {
+    init(from decoder: Decoder) throws {
+        do {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+            let type = try container.decode(String.self, forKey: CodingKeys.type)
+            switch type {
+            case "text":
+                let text = try container.decode(String.self, forKey: CodingKeys.text)
+                self = .text(text)
+            case "link":
+                let text = try container.decode(String.self, forKey: CodingKeys.text)
+                let preview = try container.decode(LinkPreview.self, forKey: CodingKeys.preview)
+                self = .link(text: text, preview: preview)
+            case "image":
+                let text = try container.decode(String.self, forKey: CodingKeys.text)
+                let image = try container.decode(String.self, forKey: CodingKeys.image)
+                self = .image(text: text, image: image)
+            case "file":
+                let text = try container.decode(String.self, forKey: CodingKeys.text)
+                self = .file(text)
+            default:
+                let text = try? container.decode(String.self, forKey: CodingKeys.text)
+                self = .unknown(type: type, text: text ?? "unknown message format")
+            }
+        } catch {
+            self = .unknown(type: "unknown", text: "invalid message format")
+        }
+    }
+}
+
+extension MsgContent: Encodable {
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case let .text(text):
+            try container.encode("text", forKey: .type)
+            try container.encode(text, forKey: .text)
+        case let .link(text, preview):
+            try container.encode("link", forKey: .type)
+            try container.encode(text, forKey: .text)
+            try container.encode(preview, forKey: .preview)
+        case let .image(text, image):
+            try container.encode("image", forKey: .type)
+            try container.encode(text, forKey: .text)
+            try container.encode(image, forKey: .image)
+        case let .file(text):
+            try container.encode("file", forKey: .type)
+            try container.encode(text, forKey: .text)
+        // TODO use original JSON and type
+        case let .unknown(_, text):
+            try container.encode("text", forKey: .type)
+            try container.encode(text, forKey: .text)
+        }
+    }
+}
+
+struct FormattedText: Decodable {
+    var text: String
+    var format: Format?
+}
+
+enum Format: Decodable, Equatable {
+    case bold
+    case italic
+    case strikeThrough
+    case snippet
+    case secret
+    case colored(color: FormatColor)
+    case uri
+    case email
+    case phone
+}
+
+enum FormatColor: String, Decodable {
+    case red = "red"
+    case green = "green"
+    case blue = "blue"
+    case yellow = "yellow"
+    case cyan = "cyan"
+    case magenta = "magenta"
+    case black = "black"
+    case white = "white"
+
+    var uiColor: Color {
+        get {
+            switch (self) {
+            case .red: return .red
+            case .green: return .green
+            case .blue: return .blue
+            case .yellow: return .yellow
+            case .cyan: return .cyan
+            case .magenta: return .purple
+            case .black: return .primary
+            case .white: return .primary
+            }
+        }
+    }
+}
+
+// Struct to use with simplex API
+struct LinkPreview: Codable {
+    var uri: URL
+    var title: String
+    // TODO remove once optional in haskell
+    var description: String = ""
+    var image: String
+}
+
+enum NtfTknStatus: String, Decodable {
+    case new = "NEW"
+    case registered = "REGISTERED"
+    case invalid = "INVALID"
+    case confirmed = "CONFIRMED"
+    case active = "ACTIVE"
+    case expired = "EXPIRED"
+}
+
+struct SndFileTransfer: Decodable {
+
+}
+
+struct FileTransferMeta: Decodable {
+    
+}
+
+enum CICallStatus: String, Decodable {
+    case pending
+    case missed
+    case rejected
+    case accepted
+    case negotiated
+    case progress
+    case ended
+    case error
+
+    func text(_ sec: Int) -> String {
+        switch self {
+        case .pending: return NSLocalizedString("calling…", comment: "call status")
+        case .missed: return NSLocalizedString("missed", comment: "call status")
+        case .rejected: return NSLocalizedString("rejected", comment: "call status")
+        case .accepted: return NSLocalizedString("accepted", comment: "call status")
+        case .negotiated: return NSLocalizedString("connecting…", comment: "call status")
+        case .progress: return NSLocalizedString("in progress", comment: "call status")
+        case .ended: return String.localizedStringWithFormat(NSLocalizedString("ended %02d:%02d", comment: "call status"), sec / 60, sec % 60)
+        case .error: return NSLocalizedString("error", comment: "call status")
+        }
+    }
+}

apps/ios/Shared/Model/Shared/GroupDefaults.swift

@@ -0,0 +1,30 @@
+//
+//  GroupDefaults.swift
+//  SimpleX (iOS)
+//
+//  Created by Evgeny on 26/04/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+import SwiftUI
+
+func getGroupDefaults() -> UserDefaults? {
+    UserDefaults(suiteName: "5NN7GUYB6T.group.chat.simplex.app")
+}
+
+func setAppState(_ phase: ScenePhase) {
+    if let defaults = getGroupDefaults() {
+        defaults.set(phase == .background, forKey: "appInBackground")
+        defaults.synchronize()
+    }
+}
+
+func getAppState() -> ScenePhase {
+    if let defaults = getGroupDefaults() {
+        if defaults.bool(forKey: "appInBackground") {
+            return .background
+        }
+    }
+    return .active
+}

apps/ios/Shared/Model/Shared/Notifications.swift

@@ -0,0 +1,96 @@
+//
+//  Notifications.swift
+//  SimpleX
+//
+//  Created by Evgeny on 28/04/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import Foundation
+import UserNotifications
+
+let ntfCategoryContactRequest = "NTF_CAT_CONTACT_REQUEST"
+let ntfCategoryContactConnected = "NTF_CAT_CONTACT_CONNECTED"
+let ntfCategoryMessageReceived = "NTF_CAT_MESSAGE_RECEIVED"
+let ntfCategoryCallInvitation = "NTF_CAT_CALL_INVITATION"
+let ntfCategoryCheckMessage = "NTF_CAT_CHECK_MESSAGE"
+// TODO remove
+let ntfCategoryCheckingMessages = "NTF_CAT_CHECKING_MESSAGES"
+
+let appNotificationId = "chat.simplex.app.notification"
+
+func createContactRequestNtf(_ contactRequest: UserContactRequest) -> UNMutableNotificationContent {
+    createNotification(
+        categoryIdentifier: ntfCategoryContactRequest,
+        title: String.localizedStringWithFormat(NSLocalizedString("%@ wants to connect!", comment: "notification title"), contactRequest.displayName),
+        body: String.localizedStringWithFormat(NSLocalizedString("Accept contact request from %@?", comment: "notification body"), contactRequest.chatViewName),
+        targetContentIdentifier: nil,
+        userInfo: ["chatId": contactRequest.id, "contactRequestId": contactRequest.apiId]
+    )
+}
+
+func createContactConnectedNtf(_ contact: Contact) -> UNMutableNotificationContent {
+    createNotification(
+        categoryIdentifier: ntfCategoryContactConnected,
+        title: String.localizedStringWithFormat(NSLocalizedString("%@ is connected!", comment: "notification title"), contact.displayName),
+        body: String.localizedStringWithFormat(NSLocalizedString("You can now send messages to %@", comment: "notification body"), contact.chatViewName),
+        targetContentIdentifier: contact.id
+//            userInfo: ["chatId": contact.id, "contactId": contact.apiId]
+    )
+}
+
+func createMessageReceivedNtf(_ cInfo: ChatInfo, _ cItem: ChatItem) -> UNMutableNotificationContent {
+    createNotification(
+        categoryIdentifier: ntfCategoryMessageReceived,
+        title: "\(cInfo.chatViewName):",
+        body: hideSecrets(cItem),
+        targetContentIdentifier: cInfo.id
+//            userInfo: ["chatId": cInfo.id, "chatItemId": cItem.id]
+    )
+}
+
+func createCallInvitationNtf(_ contact: Contact, _ invitation: CallInvitation) -> UNMutableNotificationContent {
+    createNotification(
+        categoryIdentifier: ntfCategoryCallInvitation,
+        title: "\(contact.chatViewName):",
+        body: String.localizedStringWithFormat(NSLocalizedString("Incoming %@ call", comment: "notification body"), invitation.peerMedia.rawValue),
+        targetContentIdentifier: nil,
+        userInfo: ["chatId": contact.id]
+    )
+}
+
+func createNotification(categoryIdentifier: String, title: String, subtitle: String? = nil, body: String? = nil,
+                        targetContentIdentifier: String? = nil, userInfo: [AnyHashable : Any] = [:]) -> UNMutableNotificationContent {
+    let content = UNMutableNotificationContent()
+    content.categoryIdentifier = categoryIdentifier
+    content.title = title
+    if let s = subtitle { content.subtitle = s }
+    if let s = body { content.body = s }
+    content.targetContentIdentifier = targetContentIdentifier
+    content.userInfo = userInfo
+    // TODO move logic of adding sound here, so it applies to background notifications too
+    content.sound = .default
+//        content.interruptionLevel = .active
+//        content.relevanceScore = 0.5 // 0-1
+    return content
+}
+
+func hideSecrets(_ cItem: ChatItem) -> String {
+    if cItem.content.text != "" {
+        if let md = cItem.formattedText {
+            var res = ""
+            for ft in md {
+                if case .secret = ft.format {
+                    res = res + "..."
+                } else {
+                    res = res + ft.text
+                }
+            }
+            return res
+        } else {
+            return cItem.content.text
+        }
+    } else {
+        return cItem.file?.fileName ?? ""
+    }
+}

apps/ios/Shared/Model/SimpleXAPI.swift

@@ -10,217 +10,9 @@ import Foundation
 import UIKit
 import Dispatch
 import BackgroundTasks
+import SwiftUI
 
 private var chatController: chat_ctrl?
-private let jsonDecoder = getJSONDecoder()
-private let jsonEncoder = getJSONEncoder()
-
-enum ChatCommand {
-    case showActiveUser
-    case createActiveUser(profile: Profile)
-    case startChat
-    case apiGetChats
-    case apiGetChat(type: ChatType, id: Int64)
-    case apiSendMessage(type: ChatType, id: Int64, msg: MsgContent)
-    case getUserSMPServers
-    case setUserSMPServers(smpServers: [String])
-    case addContact
-    case connect(connReq: String)
-    case apiDeleteChat(type: ChatType, id: Int64)
-    case updateProfile(profile: Profile)
-    case createMyAddress
-    case deleteMyAddress
-    case showMyAddress
-    case apiAcceptContact(contactReqId: Int64)
-    case apiRejectContact(contactReqId: Int64)
-    case apiChatRead(type: ChatType, id: Int64, itemRange: (Int64, Int64))
-    case string(String)
-
-    var cmdString: String {
-        get {
-            switch self {
-            case .showActiveUser: return "/u"
-            case let .createActiveUser(profile): return "/u \(profile.displayName) \(profile.fullName)"
-            case .startChat: return "/_start"
-            case .apiGetChats: return "/_get chats"
-            case let .apiGetChat(type, id): return "/_get chat \(ref(type, id)) count=100"
-            case let .apiSendMessage(type, id, mc): return "/_send \(ref(type, id)) \(mc.cmdString)"
-            case .getUserSMPServers: return "/smp_servers"
-            case let .setUserSMPServers(smpServers): return "/smp_servers \(smpServersStr(smpServers: smpServers))"
-            case .addContact: return "/connect"
-            case let .connect(connReq): return "/connect \(connReq)"
-            case let .apiDeleteChat(type, id): return "/_delete \(ref(type, id))"
-            case let .updateProfile(profile): return "/profile \(profile.displayName) \(profile.fullName)"
-            case .createMyAddress: return "/address"
-            case .deleteMyAddress: return "/delete_address"
-            case .showMyAddress: return "/show_address"
-            case let .apiAcceptContact(contactReqId): return "/_accept \(contactReqId)"
-            case let .apiRejectContact(contactReqId): return "/_reject \(contactReqId)"
-            case let .apiChatRead(type, id, itemRange: (from, to)): return "/_read chat \(ref(type, id)) from=\(from) to=\(to)"
-            case let .string(str): return str
-            }
-        }
-    }
-
-    var cmdType: String {
-        get {
-            switch self {
-            case .showActiveUser: return "showActiveUser"
-            case .createActiveUser: return "createActiveUser"
-            case .startChat: return "startChat"
-            case .apiGetChats: return "apiGetChats"
-            case .apiGetChat: return "apiGetChat"
-            case .apiSendMessage: return "apiSendMessage"
-            case .getUserSMPServers: return "getUserSMPServers"
-            case .setUserSMPServers: return "setUserSMPServers"
-            case .addContact: return "addContact"
-            case .connect: return "connect"
-            case .apiDeleteChat: return "apiDeleteChat"
-            case .updateProfile: return "updateProfile"
-            case .createMyAddress: return "createMyAddress"
-            case .deleteMyAddress: return "deleteMyAddress"
-            case .showMyAddress: return "showMyAddress"
-            case .apiAcceptContact: return "apiAcceptContact"
-            case .apiRejectContact: return "apiRejectContact"
-            case .apiChatRead: return "apiChatRead"
-            case .string: return "console command"
-            }
-        }
-    }
-
-    func ref(_ type: ChatType, _ id: Int64) -> String {
-        "\(type.rawValue)\(id)"
-    }
-    
-    func smpServersStr(smpServers: [String]) -> String {
-        smpServers.isEmpty ? "default" : smpServers.joined(separator: ",")
-    }
-}
-
-struct APIResponse: Decodable {
-    var resp: ChatResponse
-}
-
-enum ChatResponse: Decodable, Error {
-    case response(type: String, json: String)
-    case activeUser(user: User)
-    case chatStarted
-    case chatRunning
-    case apiChats(chats: [ChatData])
-    case apiChat(chat: ChatData)
-    case userSMPServers(smpServers: [String])
-    case invitation(connReqInvitation: String)
-    case sentConfirmation
-    case sentInvitation
-    case contactDeleted(contact: Contact)
-    case userProfileNoChange
-    case userProfileUpdated(fromProfile: Profile, toProfile: Profile)
-    case userContactLink(connReqContact: String)
-    case userContactLinkCreated(connReqContact: String)
-    case userContactLinkDeleted
-    case contactConnected(contact: Contact)
-    case receivedContactRequest(contactRequest: UserContactRequest)
-    case acceptingContactRequest(contact: Contact)
-    case contactRequestRejected
-    case contactUpdated(toContact: Contact)
-    case contactSubscribed(contact: Contact)
-    case contactDisconnected(contact: Contact)
-    case contactSubError(contact: Contact, chatError: ChatError)
-    case contactSubSummary(contactSubscriptions: [ContactSubStatus])
-    case groupSubscribed(groupInfo: GroupInfo)
-    case memberSubErrors(memberSubErrors: [MemberSubError])
-    case groupEmpty(groupInfo: GroupInfo)
-    case userContactLinkSubscribed
-    case newChatItem(chatItem: AChatItem)
-    case chatItemUpdated(chatItem: AChatItem)
-    case cmdOk
-    case chatCmdError(chatError: ChatError)
-    case chatError(chatError: ChatError)
-
-    var responseType: String {
-        get {
-            switch self {
-            case let .response(type, _): return "* \(type)"
-            case .activeUser: return "activeUser"
-            case .chatStarted: return "chatStarted"
-            case .chatRunning: return "chatRunning"
-            case .apiChats: return "apiChats"
-            case .apiChat: return "apiChat"
-            case .userSMPServers: return "userSMPServers"
-            case .invitation: return "invitation"
-            case .sentConfirmation: return "sentConfirmation"
-            case .sentInvitation: return "sentInvitation"
-            case .contactDeleted: return "contactDeleted"
-            case .userProfileNoChange: return "userProfileNoChange"
-            case .userProfileUpdated: return "userProfileNoChange"
-            case .userContactLink: return "userContactLink"
-            case .userContactLinkCreated: return "userContactLinkCreated"
-            case .userContactLinkDeleted: return "userContactLinkDeleted"
-            case .contactConnected: return "contactConnected"
-            case .receivedContactRequest: return "receivedContactRequest"
-            case .acceptingContactRequest: return "acceptingContactRequest"
-            case .contactRequestRejected: return "contactRequestRejected"
-            case .contactUpdated: return "contactUpdated"
-            case .contactSubscribed: return "contactSubscribed"
-            case .contactDisconnected: return "contactDisconnected"
-            case .contactSubError: return "contactSubError"
-            case .contactSubSummary: return "contactSubSummary"
-            case .groupSubscribed: return "groupSubscribed"
-            case .memberSubErrors: return "memberSubErrors"
-            case .groupEmpty: return "groupEmpty"
-            case .userContactLinkSubscribed: return "userContactLinkSubscribed"
-            case .newChatItem: return "newChatItem"
-            case .chatItemUpdated: return "chatItemUpdated"
-            case .cmdOk: return "cmdOk"
-            case .chatCmdError: return "chatCmdError"
-            case .chatError: return "chatError"
-            }
-        }
-    }
-    
-    var details: String {
-        get {
-            switch self {
-            case let .response(_, json): return json
-            case let .activeUser(user): return String(describing: user)
-            case .chatStarted: return noDetails
-            case .chatRunning: return noDetails
-            case let .apiChats(chats): return String(describing: chats)
-            case let .apiChat(chat): return String(describing: chat)
-            case let .userSMPServers(smpServers): return String(describing: smpServers)
-            case let .invitation(connReqInvitation): return connReqInvitation
-            case .sentConfirmation: return noDetails
-            case .sentInvitation: return noDetails
-            case let .contactDeleted(contact): return String(describing: contact)
-            case .userProfileNoChange: return noDetails
-            case let .userProfileUpdated(_, toProfile): return String(describing: toProfile)
-            case let .userContactLink(connReq): return connReq
-            case let .userContactLinkCreated(connReq): return connReq
-            case .userContactLinkDeleted: return noDetails
-            case let .contactConnected(contact): return String(describing: contact)
-            case let .receivedContactRequest(contactRequest): return String(describing: contactRequest)
-            case let .acceptingContactRequest(contact): return String(describing: contact)
-            case .contactRequestRejected: return noDetails
-            case let .contactUpdated(toContact): return String(describing: toContact)
-            case let .contactSubscribed(contact): return String(describing: contact)
-            case let .contactDisconnected(contact): return String(describing: contact)
-            case let .contactSubError(contact, chatError): return "contact:\n\(String(describing: contact))\nerror:\n\(String(describing: chatError))"
-            case let .contactSubSummary(contactSubscriptions): return String(describing: contactSubscriptions)
-            case let .groupSubscribed(groupInfo): return String(describing: groupInfo)
-            case let .memberSubErrors(memberSubErrors): return String(describing: memberSubErrors)
-            case let .groupEmpty(groupInfo): return String(describing: groupInfo)
-            case .userContactLinkSubscribed: return noDetails
-            case let .newChatItem(chatItem): return String(describing: chatItem)
-            case let .chatItemUpdated(chatItem): return String(describing: chatItem)
-            case .cmdOk: return noDetails
-            case let .chatCmdError(chatError): return String(describing: chatError)
-            case let .chatError(chatError): return String(describing: chatError)
-            }
-        }
-    }
-
-    private var noDetails: String { get { "\(responseType): no details" } }
-}
 
 enum TerminalItem: Identifiable {
     case cmd(Date, ChatCommand)
@@ -254,11 +46,6 @@ enum TerminalItem: Identifiable {
     }
 }
 
-private func _sendCmd(_ cmd: ChatCommand) -> ChatResponse {
-    var c = cmd.cmdString.cString(using: .utf8)!
-    return chatResponse(chat_send_cmd(getChatCtrl(), &c))
-}
-
 private func beginBGTask(_ handler: (() -> Void)? = nil) -> (() -> Void) {
     var id: UIBackgroundTaskIdentifier!
     var running = true
@@ -299,15 +86,17 @@ private func withBGTask(bgDelay: Double? = nil, f: @escaping () -> ChatResponse)
 func chatSendCmdSync(_ cmd: ChatCommand, bgTask: Bool = true, bgDelay: Double? = nil) -> ChatResponse {
     logger.debug("chatSendCmd \(cmd.cmdType)")
     let resp = bgTask
-                ? withBGTask(bgDelay: bgDelay) { _sendCmd(cmd) }
-                : _sendCmd(cmd)
+                ? withBGTask(bgDelay: bgDelay) { sendSimpleXCmd(cmd) }
+                : sendSimpleXCmd(cmd)
     logger.debug("chatSendCmd \(cmd.cmdType): \(resp.responseType)")
     if case let .response(_, json) = resp {
         logger.debug("chatSendCmd \(cmd.cmdType) response: \(json)")
     }
-    DispatchQueue.main.async {
-        ChatModel.shared.terminalItems.append(.cmd(.now, cmd))
-        ChatModel.shared.terminalItems.append(.resp(.now, resp))
+    if case .apiParseMarkdown = cmd {} else {
+        DispatchQueue.main.async {
+            ChatModel.shared.terminalItems.append(.cmd(.now, cmd))
+            ChatModel.shared.terminalItems.append(.resp(.now, resp))
+        }
     }
     return resp
 }
@@ -344,9 +133,18 @@ func apiCreateActiveUser(_ p: Profile) throws -> User {
     throw r
 }
 
-func apiStartChat() throws {
+func apiStartChat() throws -> Bool {
     let r = chatSendCmdSync(.startChat)
-    if case .chatStarted = r { return }
+    switch r {
+    case .chatStarted: return true
+    case .chatRunning: return false
+    default: throw r
+    }
+}
+
+func apiSetFilesFolder(filesFolder: String) throws {
+    let r = chatSendCmdSync(.setFilesFolder(filesFolder: filesFolder))
+    if case .cmdOk = r { return }
     throw r
 }
 
@@ -356,15 +154,15 @@ func apiGetChats() throws -> [Chat] {
     throw r
 }
 
-func apiGetChat(type: ChatType, id: Int64) async throws -> Chat {
-    let r = await chatSendCmd(.apiGetChat(type: type, id: id))
+func apiGetChat(type: ChatType, id: Int64) throws -> Chat {
+    let r = chatSendCmdSync(.apiGetChat(type: type, id: id))
     if case let .apiChat(chat) = r { return Chat.init(chat) }
     throw r
 }
 
-func apiSendMessage(type: ChatType, id: Int64, msg: MsgContent) async throws -> ChatItem {
+func apiSendMessage(type: ChatType, id: Int64, file: String?, quotedItemId: Int64?, msg: MsgContent) async throws -> ChatItem {
     let chatModel = ChatModel.shared
-    let cmd = ChatCommand.apiSendMessage(type: type, id: id, msg: msg)
+    let cmd: ChatCommand = .apiSendMessage(type: type, id: id, file: file, quotedItemId: quotedItemId, msg: msg)
     let r: ChatResponse
     if type == .direct {
         var cItem: ChatItem!
@@ -385,6 +183,36 @@ func apiSendMessage(type: ChatType, id: Int64, msg: MsgContent) async throws ->
     throw r
 }
 
+func apiUpdateChatItem(type: ChatType, id: Int64, itemId: Int64, msg: MsgContent) async throws -> ChatItem {
+    let r = await chatSendCmd(.apiUpdateChatItem(type: type, id: id, itemId: itemId, msg: msg), bgDelay: msgDelay)
+    if case let .chatItemUpdated(aChatItem) = r { return aChatItem.chatItem }
+    throw r
+}
+
+func apiDeleteChatItem(type: ChatType, id: Int64, itemId: Int64, mode: CIDeleteMode) async throws -> ChatItem {
+    let r = await chatSendCmd(.apiDeleteChatItem(type: type, id: id, itemId: itemId, mode: mode), bgDelay: msgDelay)
+    if case let .chatItemDeleted(_, toChatItem) = r { return toChatItem.chatItem }
+    throw r
+}
+
+func apiRegisterToken(token: String) async throws -> NtfTknStatus {
+    let r = await chatSendCmd(.apiRegisterToken(token: token))
+    if case let .ntfTokenStatus(status) = r { return status }
+    throw r
+}
+
+func apiVerifyToken(token: String, code: String, nonce: String) async throws {
+    try await sendCommandOkResp(.apiVerifyToken(token: token, code: code, nonce: nonce))
+}
+
+func apiIntervalNofication(token: String, interval: Int) async throws {
+    try await sendCommandOkResp(.apiIntervalNofication(token: token, interval: interval))
+}
+
+func apiDeleteToken(token: String) async throws {
+    try await sendCommandOkResp(.apiDeleteToken(token: token))
+}
+
 func getUserSMPServers() throws -> [String] {
     let r = chatSendCmdSync(.getUserSMPServers)
     if case let .userSMPServers(smpServers) = r { return smpServers }
@@ -392,9 +220,7 @@ func getUserSMPServers() throws -> [String] {
 }
 
 func setUserSMPServers(smpServers: [String]) async throws {
-    let r = await chatSendCmd(.setUserSMPServers(smpServers: smpServers))
-    if case .cmdOk = r { return }
-    throw r
+    try await sendCommandOkResp(.setUserSMPServers(smpServers: smpServers))
 }
 
 func apiAddContact() throws -> String {
@@ -403,23 +229,65 @@ func apiAddContact() throws -> String {
     throw r
 }
 
-func apiConnect(connReq: String) async throws {
+func apiConnect(connReq: String) async throws -> ConnReqType? {
     let r = await chatSendCmd(.connect(connReq: connReq))
+    let am = AlertManager.shared
     switch r {
-    case .sentConfirmation: return
-    case .sentInvitation: return
+    case .sentConfirmation: return .invitation
+    case .sentInvitation: return .contact
+    case let .contactAlreadyExists(contact):
+        am.showAlertMsg(
+            title: "Contact already exists",
+            message: "You are already connected to \(contact.displayName) via this link."
+        )
+        return nil
+    case .chatCmdError(.error(.invalidConnReq)):
+        am.showAlertMsg(
+            title: "Invalid connection link",
+            message: "Please check that you used the correct link or ask your contact to send you another one."
+        )
+        return nil
+    case .chatCmdError(.errorAgent(.BROKER(.TIMEOUT))):
+        am.showAlertMsg(
+            title: "Connection timeout",
+            message: "Please check your network connection and try again."
+        )
+        return nil
+    case .chatCmdError(.errorAgent(.BROKER(.NETWORK))):
+        am.showAlertMsg(
+            title: "Connection error",
+            message: "Please check your network connection and try again."
+        )
+        return nil
+    case .chatCmdError(.errorAgent(.SMP(.AUTH))):
+        am.showAlertMsg(
+            title: "Connection error (AUTH)",
+            message: "Unless your contact deleted the connection or this link was already used, it might be a bug - please report it.\nTo connect, please ask your contact to create another connection link and check that you have a stable network connection."
+        )
+        return nil
+    case let .chatCmdError(.errorAgent(.INTERNAL(internalErr))):
+        if internalErr == "SEUniqueID" {
+            am.showAlertMsg(
+                title: "Already connected?",
+                message: "It seems like you are already connected via this link. If it is not the case, there was an error (\(responseError(r)))."
+            )
+            return nil
+        } else {
+            throw r
+        }
     default: throw r
     }
 }
 
 func apiDeleteChat(type: ChatType, id: Int64) async throws {
     let r = await chatSendCmd(.apiDeleteChat(type: type, id: id), bgTask: false)
-    if case .contactDeleted = r { return }
+    if case .direct = type, case .contactDeleted = r { return }
+    if case .contactConnection = type, case .contactConnectionDeleted = r { return }
     throw r
 }
 
 func apiUpdateProfile(profile: Profile) async throws -> Profile? {
-    let r = await chatSendCmd(.updateProfile(profile: profile))
+    let r = await chatSendCmd(.apiUpdateProfile(profile: profile))
     switch r {
     case .userProfileNoChange: return nil
     case let .userProfileUpdated(_, toProfile): return toProfile
@@ -427,6 +295,12 @@ func apiUpdateProfile(profile: Profile) async throws -> Profile? {
     }
 }
 
+func apiParseMarkdown(text: String) throws -> [FormattedText]? {
+    let r = chatSendCmdSync(.apiParseMarkdown(text: text))
+    if case let .apiParsedMarkdown(formattedText) = r { return formattedText }
+    throw r
+}
+
 func apiCreateUserAddress() async throws -> String {
     let r = await chatSendCmd(.createMyAddress)
     if case let .userContactLinkCreated(connReq) = r { return connReq }
@@ -439,8 +313,8 @@ func apiDeleteUserAddress() async throws {
     throw r
 }
 
-func apiGetUserAddress() async throws -> String? {
-    let r = await chatSendCmd(.showMyAddress)
+func apiGetUserAddress() throws -> String? {
+    let r = chatSendCmdSync(.showMyAddress)
     switch r {
     case let .userContactLink(connReq):
         return connReq
@@ -463,8 +337,21 @@ func apiRejectContactRequest(contactReqId: Int64) async throws {
 }
 
 func apiChatRead(type: ChatType, id: Int64, itemRange: (Int64, Int64)) async throws {
-    let r = await chatSendCmd(.apiChatRead(type: type, id: id, itemRange: itemRange))
-    if case .cmdOk = r { return }
+    try await sendCommandOkResp(.apiChatRead(type: type, id: id, itemRange: itemRange))
+}
+
+func receiveFile(fileId: Int64) async {
+    do {
+        let chatItem = try await apiReceiveFile(fileId: fileId)
+        DispatchQueue.main.async { chatItemSimpleUpdate(chatItem) }
+    } catch let error {
+        logger.error("receiveFile error: \(responseError(error))")
+    }
+}
+
+func apiReceiveFile(fileId: Int64) async throws -> AChatItem {
+    let r = await chatSendCmd(.receiveFile(fileId: fileId))
+    if case .rcvFileAccepted(let chatItem) = r { return chatItem }
     throw r
 }
 
@@ -474,7 +361,7 @@ func acceptContactRequest(_ contactRequest: UserContactRequest) async {
         let chat = Chat(chatInfo: ChatInfo.direct(contact: contact), chatItems: [])
         DispatchQueue.main.async { ChatModel.shared.replaceChat(contactRequest.id, chat) }
     } catch let error {
-        logger.error("acceptContactRequest error: \(error.localizedDescription)")
+        logger.error("acceptContactRequest error: \(responseError(error))")
     }
 }
 
@@ -483,7 +370,43 @@ func rejectContactRequest(_ contactRequest: UserContactRequest) async {
         try await apiRejectContactRequest(contactReqId: contactRequest.apiId)
         DispatchQueue.main.async { ChatModel.shared.removeChat(contactRequest.id) }
     } catch let error {
-        logger.error("rejectContactRequest: \(error.localizedDescription)")
+        logger.error("rejectContactRequest: \(responseError(error))")
+    }
+}
+
+func apiSendCallInvitation(_ contact: Contact, _ callType: CallType) async throws {
+    try await sendCommandOkResp(.apiSendCallInvitation(contact: contact, callType: callType))
+}
+
+func apiRejectCall(_ contact: Contact) async throws {
+    try await sendCommandOkResp(.apiRejectCall(contact: contact))
+}
+
+func apiSendCallOffer(_ contact: Contact, _ rtcSession: String, _ rtcIceCandidates: [String], media: CallMediaType, capabilities: CallCapabilities) async throws {
+    let webRtcSession = WebRTCSession(rtcSession: rtcSession, rtcIceCandidates: rtcIceCandidates)
+    let callOffer = WebRTCCallOffer(callType: CallType(media: media, capabilities: capabilities), rtcSession: webRtcSession)
+    try await sendCommandOkResp(.apiSendCallOffer(contact: contact, callOffer: callOffer))
+}
+
+func apiSendCallAnswer(_ contact: Contact, _ rtcSession: String, _ rtcIceCandidates: [String]) async throws {
+    let answer = WebRTCSession(rtcSession: rtcSession, rtcIceCandidates: rtcIceCandidates)
+    try await sendCommandOkResp(.apiSendCallAnswer(contact: contact, answer: answer))
+}
+
+func apiSendCallExtraInfo(_ contact: Contact, _ rtcIceCandidates: [String]) async throws {
+    let extraInfo = WebRTCExtraInfo(rtcIceCandidates: rtcIceCandidates)
+    try await sendCommandOkResp(.apiSendCallExtraInfo(contact: contact, extraInfo: extraInfo))
+}
+
+func apiEndCall(_ contact: Contact) async throws {
+    try await sendCommandOkResp(.apiEndCall(contact: contact))
+}
+
+func apiCallStatus(_ contact: Contact, _ status: String) async throws {
+    if let callStatus = WebRTCCallStatus.init(rawValue: status) {
+        try await sendCommandOkResp(.apiCallStatus(contact: contact, callStatus: callStatus))
+    } else {
+        logger.debug("apiCallStatus: call status \(status) not used")
     }
 }
 
@@ -495,27 +418,63 @@ func markChatRead(_ chat: Chat) async {
         try await apiChatRead(type: cInfo.chatType, id: cInfo.apiId, itemRange: itemRange)
         DispatchQueue.main.async { ChatModel.shared.markChatItemsRead(cInfo) }
     } catch {
-        logger.error("markChatRead apiChatRead error: \(error.localizedDescription)")
+        logger.error("markChatRead apiChatRead error: \(responseError(error))")
     }
 }
 
-func markChatItemRead(_ cInfo: ChatInfo, _ cItem: ChatItem) async {
+func apiMarkChatItemRead(_ cInfo: ChatInfo, _ cItem: ChatItem) async {
     do {
         try await apiChatRead(type: cInfo.chatType, id: cInfo.apiId, itemRange: (cItem.id, cItem.id))
         DispatchQueue.main.async { ChatModel.shared.markChatItemRead(cInfo, cItem) }
     } catch {
-        logger.error("markChatItemRead apiChatRead error: \(error.localizedDescription)")
+        logger.error("markChatItemRead apiChatRead error: \(responseError(error))")
     }
 }
 
+private func sendCommandOkResp(_ cmd: ChatCommand) async throws {
+    let r = await chatSendCmd(cmd)
+    if case .cmdOk = r { return }
+    throw r
+}
+
 func initializeChat() {
+    logger.debug("initializeChat")
     do {
-        ChatModel.shared.currentUser = try apiGetActiveUser()
+        let m = ChatModel.shared
+        m.currentUser = try apiGetActiveUser()
+        if m.currentUser == nil {
+            m.onboardingStage = .step1_SimpleXInfo
+        } else {
+            startChat()
+        }
     } catch {
         fatalError("Failed to initialize chat controller or database: \(error)")
     }
 }
 
+func startChat() {
+    logger.debug("startChat")
+    do {
+        let m = ChatModel.shared
+        // TODO set file folder once, before chat is started
+        let justStarted = try apiStartChat()
+        if justStarted {
+            try apiSetFilesFolder(filesFolder: getAppFilesDirectory().path)
+            m.userAddress = try apiGetUserAddress()
+            m.userSMPServers = try getUserSMPServers()
+            m.chats = try apiGetChats()
+            withAnimation {
+                m.onboardingStage = m.chats.isEmpty
+                                    ? .step3_MakeConnection
+                                    : .onboardingComplete
+            }
+        }
+        ChatReceiver.shared.start()
+    } catch {
+        fatalError("Failed to start or load chats: \(error)")
+    }
+}
+
 class ChatReceiver {
     private var receiveLoop: Task<Void, Never>?
     private var receiveMessages = true
@@ -553,31 +512,38 @@ class ChatReceiver {
 }
 
 func processReceivedMsg(_ res: ChatResponse) {
-    let chatModel = ChatModel.shared
+    let m = ChatModel.shared
     DispatchQueue.main.async {
-        chatModel.terminalItems.append(.resp(.now, res))
+        m.terminalItems.append(.resp(.now, res))
         logger.debug("processReceivedMsg: \(res.responseType)")
         switch res {
+        case let .newContactConnection(connection):
+            m.updateContactConnection(connection)
+        case let .contactConnectionDeleted(connection):
+            m.removeChat(connection.id)
         case let .contactConnected(contact):
-            chatModel.updateContact(contact)
-            chatModel.updateNetworkStatus(contact, .connected)
+            m.updateContact(contact)
+            m.removeChat(contact.activeConn.id)
+            m.updateNetworkStatus(contact.id, .connected)
             NtfManager.shared.notifyContactConnected(contact)
+        case let .contactConnecting(contact):
+            m.updateContact(contact)
+            m.removeChat(contact.activeConn.id)
         case let .receivedContactRequest(contactRequest):
-            chatModel.addChat(Chat(
+            m.addChat(Chat(
                 chatInfo: ChatInfo.contactRequest(contactRequest: contactRequest),
                 chatItems: []
             ))
             NtfManager.shared.notifyContactRequest(contactRequest)
         case let .contactUpdated(toContact):
             let cInfo = ChatInfo.direct(contact: toContact)
-            if chatModel.hasChat(toContact.id) {
-                chatModel.updateChatInfo(cInfo)
+            if m.hasChat(toContact.id) {
+                m.updateChatInfo(cInfo)
             }
-        case let .contactSubscribed(contact):
-            processContactSubscribed(contact)
-        case let .contactDisconnected(contact):
-            chatModel.updateContact(contact)
-            chatModel.updateNetworkStatus(contact, .disconnected)
+        case let .contactsSubscribed(_, contactRefs):
+            updateContactsStatus(contactRefs, status: .connected)
+        case let .contactsDisconnected(_, contactRefs):
+            updateContactsStatus(contactRefs, status: .disconnected)
         case let .contactSubError(contact, chatError):
             processContactSubError(contact, chatError)
         case let .contactSubSummary(contactSubscriptions):
@@ -585,20 +551,34 @@ func processReceivedMsg(_ res: ChatResponse) {
                 if let err = sub.contactError {
                     processContactSubError(sub.contact, err)
                 } else {
-                    processContactSubscribed(sub.contact)
+                    m.updateContact(sub.contact)
+                    m.updateNetworkStatus(sub.contact.id, .connected)
                 }
             }
         case let .newChatItem(aChatItem):
             let cInfo = aChatItem.chatInfo
             let cItem = aChatItem.chatItem
-            chatModel.addChatItem(cInfo, cItem)
-            NtfManager.shared.notifyMessageReceived(cInfo, cItem)
-        case let .chatItemUpdated(aChatItem):
+            m.addChatItem(cInfo, cItem)
+            if case .image = cItem.content.msgContent,
+               let file = cItem.file,
+               file.fileSize <= maxImageSize {
+                Task {
+                    await receiveFile(fileId: file.fileId)
+                }
+            }
+            if !cItem.isCall() {
+                NtfManager.shared.notifyMessageReceived(cInfo, cItem)
+            }
+        case let .chatItemStatusUpdated(aChatItem):
             let cInfo = aChatItem.chatInfo
             let cItem = aChatItem.chatItem
-            if chatModel.upsertChatItem(cInfo, cItem) {
+            var res = false
+            if !cItem.isDeletedContent() {
+                res = m.upsertChatItem(cInfo, cItem)
+            }
+            if res {
                 NtfManager.shared.notifyMessageReceived(cInfo, cItem)
-            } else if let endTask = chatModel.messageDelivery[cItem.id] {
+            } else if let endTask = m.messageDelivery[cItem.id] {
                 switch cItem.meta.itemStatus {
                 case .sndSent: endTask()
                 case .sndErrorAuth: endTask()
@@ -606,16 +586,88 @@ func processReceivedMsg(_ res: ChatResponse) {
                 default: break
                 }
             }
+        case let .chatItemUpdated(aChatItem):
+            chatItemSimpleUpdate(aChatItem)
+        case let .chatItemDeleted(_, toChatItem):
+            let cInfo = toChatItem.chatInfo
+            let cItem = toChatItem.chatItem
+            if cItem.meta.itemDeleted {
+                m.removeChatItem(cInfo, cItem)
+            } else {
+                // currently only broadcast deletion of rcv message can be received, and only this case should happen
+                _ = m.upsertChatItem(cInfo, cItem)
+            }
+        case let .rcvFileStart(aChatItem):
+            chatItemSimpleUpdate(aChatItem)
+        case let .rcvFileComplete(aChatItem):
+            chatItemSimpleUpdate(aChatItem)
+        case let .sndFileStart(aChatItem, _):
+            chatItemSimpleUpdate(aChatItem)
+        case let .sndFileComplete(aChatItem, _):
+            chatItemSimpleUpdate(aChatItem)
+            let cItem = aChatItem.chatItem
+            if aChatItem.chatInfo.chatType == .direct,
+               let mc = cItem.content.msgContent,
+               mc.isFile(),
+               let fileName = cItem.file?.filePath {
+                removeFile(fileName)
+            }
+        case let .callInvitation(contact, callType, sharedKey):
+            let invitation = CallInvitation(peerMedia: callType.media, sharedKey: sharedKey)
+            m.callInvitations[contact.id] = invitation
+            if (m.activeCallInvitation == nil) {
+                m.activeCallInvitation = ContactRef(contactId: contact.apiId, localDisplayName: contact.localDisplayName)
+            }
+            NtfManager.shared.notifyCallInvitation(contact, invitation)
+        case let .callOffer(contact, callType, offer, sharedKey, _):
+            // TODO askConfirmation?
+            // TODO check encryption is compatible
+            withCall(contact) { call in
+                m.activeCall = call.copy(callState: .offerReceived, peerMedia: callType.media, sharedKey: sharedKey)
+                m.callCommand = .accept(offer: offer.rtcSession, iceCandidates: offer.rtcIceCandidates, media: callType.media, aesKey: sharedKey)
+            }
+        case let .callAnswer(contact, answer):
+            withCall(contact) { call in
+                m.activeCall = call.copy(callState: .negotiated)
+                m.callCommand = .answer(answer: answer.rtcSession, iceCandidates: answer.rtcIceCandidates)
+            }
+        case let .callExtraInfo(contact, extraInfo):
+            withCall(contact) { _ in
+                m.callCommand = .ice(iceCandidates: extraInfo.rtcIceCandidates)
+            }
+        case let .callEnded(contact):
+            m.activeCallInvitation = nil
+            withCall(contact) { _ in
+                m.callCommand = .end
+            }
         default:
             logger.debug("unsupported event: \(res.responseType)")
         }
+
+        func withCall(_ contact: Contact, _ perform: (Call) -> Void) {
+            if let call = m.activeCall, call.contact.apiId == contact.apiId {
+                perform(call)
+            } else {
+                logger.debug("processReceivedMsg: ignoring \(res.responseType), not in call with the contact \(contact.id)")
+            }
+        }
     }
 }
 
-func processContactSubscribed(_ contact: Contact) {
+func chatItemSimpleUpdate(_ aChatItem: AChatItem) {
     let m = ChatModel.shared
-    m.updateContact(contact)
-    m.updateNetworkStatus(contact, .connected)
+    let cInfo = aChatItem.chatInfo
+    let cItem = aChatItem.chatItem
+    if m.upsertChatItem(cInfo, cItem) {
+        NtfManager.shared.notifyMessageReceived(cInfo, cItem)
+    }
+}
+
+func updateContactsStatus(_ contactRefs: [ContactRef], status: Chat.NetworkStatus) {
+    let m = ChatModel.shared
+    for c in contactRefs {
+        m.updateNetworkStatus(c.id, status)
+    }
 }
 
 func processContactSubError(_ contact: Contact, _ chatError: ChatError) {
@@ -627,214 +679,10 @@ func processContactSubError(_ contact: Contact, _ chatError: ChatError) {
     case .errorAgent(agentError: .SMP(smpErr: .AUTH)): err = "contact deleted"
     default: err = String(describing: chatError)
     }
-    m.updateNetworkStatus(contact, .error(err))
+    m.updateNetworkStatus(contact.id, .error(err))
 }
 
 private struct UserResponse: Decodable {
     var user: User?
     var error: String?
 }
-
-private func chatResponse(_ cjson: UnsafeMutablePointer<CChar>) -> ChatResponse {
-    let s = String.init(cString: cjson)
-    let d = s.data(using: .utf8)!
-// TODO is there a way to do it without copying the data? e.g:
-//    let p = UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer(cjson))
-//    let d = Data.init(bytesNoCopy: p, count: strlen(cjson), deallocator: .free)
-
-// TODO some mechanism to update model without passing it - maybe Publisher / Subscriber?
-
-    do {
-        let r = try jsonDecoder.decode(APIResponse.self, from: d)
-        return r.resp
-    } catch {
-        logger.error("chatResponse jsonDecoder.decode error: \(error.localizedDescription)")
-    }
-        
-    var type: String?
-    var json: String?
-    if let j = try? JSONSerialization.jsonObject(with: d) as? NSDictionary {
-        if let j1 = j["resp"] as? NSDictionary, j1.count == 1 {
-            type = j1.allKeys[0] as? String
-        }
-        json = prettyJSON(j)
-    }
-    free(cjson)
-    return ChatResponse.response(type: type ?? "invalid", json: json ?? s)
-}
-
-func prettyJSON(_ obj: NSDictionary) -> String? {
-    if let d = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted) {
-        return String(decoding: d, as: UTF8.self)
-    }
-    return nil
-}
-
-private func getChatCtrl() -> chat_ctrl {
-    if let controller = chatController { return controller }
-    let dataDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!.path + "/mobile_v1"
-    var cstr = dataDir.cString(using: .utf8)!
-    logger.debug("getChatCtrl: chat_init")
-    ChatModel.shared.terminalItems.append(.cmd(.now, .string("chat_init")))
-    chatController = chat_init(&cstr)
-    ChatModel.shared.terminalItems.append(.resp(.now, .response(type: "chat_controller", json: "chat_controller: no details")))
-    return chatController!
-}
-
-private func decodeCJSON<T: Decodable>(_ cjson: UnsafePointer<CChar>) -> T? {
-    let s = String.init(cString: cjson)
-    let d = s.data(using: .utf8)!
-//    let p = UnsafeMutableRawPointer.init(mutating: UnsafeRawPointer(cjson))
-//    let d = Data.init(bytesNoCopy: p, count: strlen(cjson), deallocator: .free)
-    return try? jsonDecoder.decode(T.self, from: d)
-}
-
-private func getJSONObject(_ cjson: UnsafePointer<CChar>) -> NSDictionary? {
-    let s = String.init(cString: cjson)
-    let d = s.data(using: .utf8)!
-    return try? JSONSerialization.jsonObject(with: d) as? NSDictionary
-}
-
-private func encodeCJSON<T: Encodable>(_ value: T) -> [CChar] {
-    let data = try! jsonEncoder.encode(value)
-    let str = String(decoding: data, as: UTF8.self)
-    return str.cString(using: .utf8)!
-}
-
-enum ChatError: Decodable {
-    case error(errorType: ChatErrorType)
-    case errorAgent(agentError: AgentErrorType)
-    case errorStore(storeError: StoreError)
-}
-
-enum ChatErrorType: Decodable {
-    case noActiveUser
-    case activeUserExists
-    case chatNotStarted
-    case invalidConnReq
-    case invalidChatMessage(message: String)
-    case contactNotReady(contact: Contact)
-    case contactGroups(contact: Contact, groupNames: [GroupName])
-    case groupUserRole
-    case groupContactRole(contactName: ContactName)
-    case groupDuplicateMember(contactName: ContactName)
-    case groupDuplicateMemberId
-    case groupNotJoined(groupInfo: GroupInfo)
-    case groupMemberNotActive
-    case groupMemberUserRemoved
-    case groupMemberNotFound(contactName: ContactName)
-    case groupMemberIntroNotFound(contactName: ContactName)
-    case groupCantResendInvitation(groupInfo: GroupInfo, contactName: ContactName)
-    case groupInternal(message: String)
-    case fileNotFound(message: String)
-    case fileAlreadyReceiving(message: String)
-    case fileAlreadyExists(filePath: String)
-    case fileRead(filePath: String, message: String)
-    case fileWrite(filePath: String, message: String)
-    case fileSend(fileId: Int64, agentError: String)
-    case fileRcvChunk(message: String)
-    case fileInternal(message: String)
-    case agentVersion
-    case commandError(message: String)
-}
-
-enum StoreError: Decodable {
-    case duplicateName
-    case contactNotFound(contactId: Int64)
-    case contactNotFoundByName(contactName: ContactName)
-    case contactNotReady(contactName: ContactName)
-    case duplicateContactLink
-    case userContactLinkNotFound
-    case contactRequestNotFound(contactRequestId: Int64)
-    case contactRequestNotFoundByName(contactName: ContactName)
-    case groupNotFound(groupId: Int64)
-    case groupNotFoundByName(groupName: GroupName)
-    case groupWithoutUser
-    case duplicateGroupMember
-    case groupAlreadyJoined
-    case groupInvitationNotFound
-    case sndFileNotFound(fileId: Int64)
-    case sndFileInvalid(fileId: Int64)
-    case rcvFileNotFound(fileId: Int64)
-    case fileNotFound(fileId: Int64)
-    case rcvFileInvalid(fileId: Int64)
-    case connectionNotFound(agentConnId: String)
-    case introNotFound
-    case uniqueID
-    case internalError(message: String)
-    case noMsgDelivery(connId: Int64, agentMsgId: String)
-    case badChatItem(itemId: Int64)
-    case chatItemNotFound(itemId: Int64)
-}
-
-enum AgentErrorType: Decodable {
-    case CMD(cmdErr: CommandErrorType)
-    case CONN(connErr: ConnectionErrorType)
-    case SMP(smpErr: SMPErrorType)
-    case BROKER(brokerErr: BrokerErrorType)
-    case AGENT(agentErr: SMPAgentError)
-    case INTERNAL(internalErr: String)
-}
-
-enum CommandErrorType: Decodable {
-    case PROHIBITED
-    case SYNTAX
-    case NO_CONN
-    case SIZE
-    case LARGE
-}
-
-enum ConnectionErrorType: Decodable {
-    case NOT_FOUND
-    case DUPLICATE
-    case SIMPLEX
-    case NOT_ACCEPTED
-    case NOT_AVAILABLE
-}
-
-enum BrokerErrorType: Decodable {
-    case RESPONSE(smpErr: SMPErrorType)
-    case UNEXPECTED
-    case NETWORK
-    case TRANSPORT(transportErr: SMPTransportError)
-    case TIMEOUT
-}
-
-enum SMPErrorType: Decodable {
-    case BLOCK
-    case SESSION
-    case CMD(cmdErr: SMPCommandError)
-    case AUTH
-    case QUOTA
-    case NO_MSG
-    case LARGE_MSG
-    case INTERNAL
-}
-
-enum SMPCommandError: Decodable {
-    case UNKNOWN
-    case SYNTAX
-    case NO_AUTH
-    case HAS_AUTH
-    case NO_QUEUE
-}
-
-enum SMPTransportError: Decodable {
-    case badBlock
-    case largeMsg
-    case badSession
-    case handshake(handshakeErr: SMPHandshakeError)
-}
-
-enum SMPHandshakeError: Decodable {
-    case PARSE
-    case VERSION
-    case IDENTITY
-}
-
-enum SMPAgentError: Decodable {
-    case A_MESSAGE
-    case A_PROHIBITED
-    case A_VERSION
-    case A_ENCRYPTION
-}

apps/ios/Shared/SimpleXApp.swift

@@ -12,6 +12,7 @@ let logger = Logger()
 
 @main
 struct SimpleXApp: App {
+    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
     @StateObject private var chatModel = ChatModel.shared
     @Environment(\.scenePhase) var scenePhase
 
@@ -33,6 +34,8 @@ struct SimpleXApp: App {
                     initializeChat()
                 }
                 .onChange(of: scenePhase) { phase in
+                    logger.debug("scenePhase \(String(describing: scenePhase))")
+                    setAppState(phase)
                     if phase == .background {
                         BGManager.shared.schedule()
                     }

apps/ios/Shared/Views/Call/ActiveCallView.swift

@@ -0,0 +1,188 @@
+//
+//  ActiveCallView.swift
+//  SimpleX (iOS)
+//
+//  Created by Evgeny on 05/05/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+import SwiftUI
+
+struct ActiveCallView: View {
+    @EnvironmentObject var chatModel: ChatModel
+    @Environment(\.dismiss) private var dismiss
+    @Binding var showCallView: Bool
+    @State private var coordinator: WebRTCCoordinator? = nil
+    @State private var webViewReady: Bool = false
+    @State private var webViewMsg: WVAPIMessage? = nil
+
+    var body: some View {
+        ZStack(alignment: .bottom) {
+            WebRTCView(coordinator: $coordinator, webViewReady: $webViewReady, webViewMsg: $webViewMsg)
+                .onAppear() { sendCommandToWebView() }
+                .onChange(of: chatModel.callCommand) { _ in sendCommandToWebView() }
+                .onChange(of: webViewReady) { _ in sendCommandToWebView() }
+                .onChange(of: webViewMsg) { _ in processWebViewMessage() }
+                .background(.black)
+            ActiveCallOverlay(call: chatModel.activeCall, dismiss: { dismiss() })
+        }
+    }
+
+    private func sendCommandToWebView() {
+        if chatModel.activeCall != nil && webViewReady,
+           let cmd = chatModel.callCommand,
+           let c = coordinator {
+            chatModel.callCommand = nil
+            logger.debug("ActiveCallView: command \(cmd.cmdType)")
+            c.sendCommand(command: cmd)
+        }
+    }
+
+    private func processWebViewMessage() {
+        let m = chatModel
+        if let msg = webViewMsg,
+           let call = chatModel.activeCall {
+            logger.debug("ActiveCallView: response \(msg.resp.respType)")
+            Task {
+                switch msg.resp {
+                case let .capabilities(capabilities):
+                    let callType = CallType(media: call.localMedia, capabilities: capabilities)
+                    try await apiSendCallInvitation(call.contact, callType)
+                    m.activeCall = call.copy(callState: .invitationSent, localCapabilities: capabilities)
+                case let .offer(offer, iceCandidates, capabilities):
+                    try await apiSendCallOffer(call.contact, offer, iceCandidates,
+                                               media: call.localMedia, capabilities: capabilities)
+                    m.activeCall = call.copy(callState: .offerSent, localCapabilities: capabilities)
+                case let .answer(answer, iceCandidates):
+                    try await apiSendCallAnswer(call.contact, answer, iceCandidates)
+                    m.activeCall = call.copy(callState: .negotiated)
+                case let .ice(iceCandidates):
+                    try await apiSendCallExtraInfo(call.contact, iceCandidates)
+                case let .connection(state):
+                    if let callStatus = WebRTCCallStatus.init(rawValue: state.connectionState),
+                       case .connected = callStatus {
+                        m.activeCall = call.copy(callState: .connected)
+                    }
+                    try await apiCallStatus(call.contact, state.connectionState)
+                case .ended:
+                    m.activeCall = nil
+                    m.activeCallInvitation = nil
+                    m.callCommand = nil
+                    showCallView = false
+                case .ok:
+                    switch msg.command {
+                    case let .media(media, enable):
+                        switch media {
+                        case .video: m.activeCall = call.copy(videoEnabled: enable)
+                        case .audio: m.activeCall = call.copy(audioEnabled: enable)
+                        }
+                    case .end:
+                        m.activeCall = nil
+                        m.activeCallInvitation = nil
+                        m.callCommand = nil
+                        showCallView = false
+                    default: ()
+                    }
+                case let .error(message):
+                    logger.debug("ActiveCallView: command error: \(message)")
+                case let .invalid(type):
+                    logger.debug("ActiveCallView: invalid response: \(type)")
+                }
+            }
+        }
+    }
+}
+
+struct ActiveCallOverlay: View {
+    @EnvironmentObject var chatModel: ChatModel
+    var call: Call?
+    var dismiss: () -> Void
+
+    var body: some View {
+        VStack {
+            if let call = call {
+                switch call.localMedia {
+                case .video:
+                    callInfoView(call, .leading)
+                    .foregroundColor(.white)
+                    .opacity(0.8)
+                    .padding()
+                case .audio:
+                    VStack {
+                        ProfileImage(imageStr: call.contact.profile.image)
+                            .scaledToFit()
+                            .frame(width: 192, height: 192)
+                        callInfoView(call, .center)
+                    }
+                    .foregroundColor(.white)
+                    .opacity(0.8)
+                    .padding()
+                    .frame(maxHeight: .infinity)
+                }
+                Spacer()
+                ZStack(alignment: .bottom) {
+                    VStack(alignment: .leading) {
+                        if call.localMedia == .video {
+                            callButton(call.videoEnabled ? "video.fill" : "video.slash", size: 48) {
+                                chatModel.callCommand = .media(media: .video, enable: !call.videoEnabled)
+                            }
+                            .foregroundColor(.white)
+                            .opacity(0.85)
+                        }
+                        callButton(call.audioEnabled ? "mic.fill" : "mic.slash", size: 48) {
+                            chatModel.callCommand = .media(media: .audio, enable: !call.audioEnabled)
+                        }
+                        .foregroundColor(.white)
+                        .opacity(0.85)
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .padding(.top)
+                    }
+                    callButton("phone.down.fill", size: 60) { dismiss() }
+                    .foregroundColor(.red)
+                }
+                .padding(.bottom, 60)
+                .padding(.horizontal, 48)
+            }
+        }
+        .frame(maxWidth: .infinity)
+    }
+
+    private func callInfoView(_ call: Call, _ alignment: Alignment) -> some View {
+        VStack {
+            Text(call.contact.chatViewName)
+                .lineLimit(1)
+                .font(.title)
+                .frame(maxWidth: .infinity, alignment: alignment)
+            let status = call.callState == .connected
+                            ? call.encrypted
+                               ? "end-to-end encrypted"
+                               : "no end-to-end encryption"
+                            : call.callState.text
+            Text(status)
+                .font(.subheadline)
+                .frame(maxWidth: .infinity, alignment: alignment)
+        }
+    }
+
+    private func callButton(_ imageName: String, size: CGFloat, perform: @escaping () -> Void) -> some View {
+        Button {
+            perform()
+        } label: {
+            Image(systemName: imageName)
+                .resizable()
+                .scaledToFit()
+                .frame(maxWidth: size, maxHeight: size)
+        }
+    }
+}
+
+struct ActiveCallOverlay_Previews: PreviewProvider {
+    static var previews: some View {
+        Group{
+            ActiveCallOverlay(call: Call(contact: Contact.sampleData, callState: .offerSent, localMedia: .video), dismiss: {})
+                .background(.black)
+            ActiveCallOverlay(call: Call(contact: Contact.sampleData, callState: .offerSent, localMedia: .audio), dismiss: {})
+                .background(.black)
+        }
+    }
+}