5.5-beta.0: ios 187, android 168, desktop 21

* ios: show secrets on tap

* android: show secrets on tap/click

* android: clickable links in group descriptions

* android: hide secrets one by one

* ios: clickable links in welcome message preview

* refactor

* refactor2

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,68 @@
+name: Bug
+description: File a bug report/issue
+title: "[Bug]: "
+labels: ["bug", "triage"]
+body:
+- type: checkboxes
+  attributes:
+    label: Is there an existing issue for this?
+    description: Please search to see if an issue already exists for the bug you encountered.
+    options:
+    - label: I have searched the existing issues
+      required: true
+- type: dropdown
+  attributes:
+    label: Platform
+    description: Multiple selections are possible.
+    multiple: true
+    options:
+      - Linux
+      - Mac
+      - Windows
+      - Android
+      - iOS
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: OS version
+    description: Specify the OS version
+    placeholder: ex. Android 12, Ubuntu 20.04
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: App version
+    description: Specify the SimpleX version
+    placeholder: ex. 4.3.2
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Current Behavior
+    description: A concise description of what you're experiencing.
+    placeholder: Bug happened!
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Expected Behavior
+    description: A concise description of what you expected to happen.
+    placeholder: No bug should happen!
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Steps To Reproduce
+    description: Steps to reproduce the behavior.
+    placeholder: |
+      1. Go to ...
+      3. Click on ...
+      4. See error...
+  validations:
+    required: true
+- type: textarea
+  attributes:
+    label: Relevant log output
+    description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+    render: shell

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: true

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,40 @@
+name: Feature
+description: Suggest your feature
+title: "[Feature]: "
+labels: ["enhancement", "triage"]
+body:
+- type: checkboxes
+  attributes:
+    label: Is there an existing issue for this?
+    description: Please search to see if an issue already exists for the bug you encountered.
+    options:
+    - label: I have searched the existing issues
+      required: true
+- type: dropdown
+  attributes:
+    label: Platform
+    description: Multiple selections are possible. If selected input is "all", this considered to be a general feature.
+    multiple: true
+    options:
+      - Linux
+      - Mac
+      - Windows
+      - Android
+      - iOS
+      - all
+  validations:
+    required: true
+- type: input
+  attributes:
+    label: App version
+    description: Specify the SimpleX version
+    placeholder: ex. 4.3.2
+  validations:
+    required: false
+- type: textarea
+  attributes:
+    label: Feature
+    description: Describe the feature you would like to see added
+    placeholder: SimpleX Chat should make me coffee! 
+  validations:
+    required: true

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,16 @@
+name: Question
+description: Ask your question
+title: "[Q]: "
+labels: ["question", "triage"]
+body:
+- type: markdown
+  attributes:
+    value: |
+      Generally, we encourage you to ask questions in our [official group](https://simplex.chat/invitation/#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3Dsimplex:/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D), but you can do it anyway :)
+- type: textarea
+  attributes:
+    label: Question
+    description: Please ask your question in plain english.
+    placeholder: Is SimpleX - chat?
+  validations:
+    required: true

.github/workflows/build.yml

@@ -5,8 +5,10 @@ on:
     branches:
       - master
       - stable
+      - users
     tags:
       - "v*"
+      - "!*-fdroid"
   pull_request:
 
 jobs:
@@ -15,11 +17,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Clone project
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Build changelog
         id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v1
+        uses: mikepenz/release-changelog-builder-action@v4
         with:
           configuration: .github/changelog_conf.json
           failOnError: true
@@ -40,7 +42,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
   build:
-    name: build-${{ matrix.os }}
+    name: build-${{ matrix.os }}-${{ matrix.ghc }}
     if: always()
     needs: prepare-release
     runs-on: ${{ matrix.os }}
@@ -49,79 +51,329 @@ jobs:
       matrix:
         include:
           - os: ubuntu-20.04
-            cache_path: ~/.stack
+            ghc: "8.10.7"
+            cache_path: ~/.cabal/store
+          - os: ubuntu-20.04
+            ghc: "9.6.3"
+            cache_path: ~/.cabal/store
             asset_name: simplex-chat-ubuntu-20_04-x86-64
-          - os: ubuntu-18.04
-            cache_path: ~/.stack
-            asset_name: simplex-chat-ubuntu-18_04-x86-64
+            desktop_asset_name: simplex-desktop-ubuntu-20_04-x86_64.deb
+          - os: ubuntu-22.04
+            ghc: "9.6.3"
+            cache_path: ~/.cabal/store
+            asset_name: simplex-chat-ubuntu-22_04-x86-64
+            desktop_asset_name: simplex-desktop-ubuntu-22_04-x86_64.deb
           - os: macos-latest
-            cache_path: ~/.stack
+            ghc: "9.6.3"
+            cache_path: ~/.cabal/store
             asset_name: simplex-chat-macos-x86-64
+            desktop_asset_name: simplex-desktop-macos-x86_64.dmg
           - os: windows-latest
-            cache_path: C:/sr
+            ghc: "9.6.3"
+            cache_path: C:/cabal
             asset_name: simplex-chat-windows-x86-64
+            desktop_asset_name: simplex-desktop-windows-x86_64.msi
     steps:
+      - name: Configure pagefile (Windows)
+        if: matrix.os == 'windows-latest'
+        uses: al-cheb/configure-pagefile-action@v1.3
+        with:
+          minimum-size: 16GB
+          maximum-size: 16GB
+          disk-root: "C:"
+
       - name: Clone project
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
-      - name: Setup Stack
-        uses: haskell/actions/setup@v1
+      - name: Setup Haskell
+        uses: haskell-actions/setup@v2
         with:
-          ghc-version: '8.10.7'
-          enable-stack: true
-          stack-version: 'latest'
+          ghc-version: ${{ matrix.ghc }}
+          cabal-version: "3.10.1.0"
 
-      - name: Cache dependencies
-        uses: actions/cache@v2
+      - name: Restore cached build
+        id: restore_cache
+        uses: actions/cache/restore@v3
         with:
-          path: ${{ matrix.cache_path }}
-          key: ${{ matrix.os }}-${{ hashFiles('stack.yaml') }}
+          path: |
+            ${{ matrix.cache_path }}
+            dist-newstyle
+          key: ${{ matrix.os }}-ghc${{ matrix.ghc }}-${{ hashFiles('cabal.project', 'simplex-chat.cabal') }}
 
       # / Unix
 
-      - name: Unix build
-        id: unix_build
+      - name: Unix prepare cabal.project.local for Mac
+        if: matrix.os == 'macos-latest'
+        shell: bash
+        run: |
+          echo "ignore-project: False"                                      >> cabal.project.local
+          echo "package direct-sqlcipher"                                   >> cabal.project.local
+          echo "    extra-include-dirs: /usr/local/opt/openssl@1.1/include" >> cabal.project.local
+          echo "    extra-lib-dirs: /usr/local/opt/openssl@1.1/lib"         >> cabal.project.local
+          echo "    flags: +openssl"                                        >> cabal.project.local
+
+      - name: Install AppImage dependencies
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os == 'ubuntu-20.04'
+        run: sudo apt install -y desktop-file-utils
+
+      - name: Install pkg-config for Mac
+        if: matrix.os == 'macos-latest'
+        run: brew install pkg-config
+
+      - name: Unix prepare cabal.project.local for Ubuntu
+        if: matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-22.04'
+        shell: bash
+        run: |
+          echo "ignore-project: False"    >> cabal.project.local
+          echo "package direct-sqlcipher" >> cabal.project.local
+          echo "    flags: +openssl"      >> cabal.project.local
+
+      - name: Unix build CLI
+        id: unix_cli_build
         if: matrix.os != 'windows-latest'
         shell: bash
         run: |
-          stack build --test
-          echo "::set-output name=local_install_root::$(stack path --local-install-root)"
+          cabal build --enable-tests
+          path=$(cabal list-bin simplex-chat)
+          echo "bin_path=$path" >> $GITHUB_OUTPUT
+          echo "bin_hash=$(echo SHA2-512\(${{ matrix.asset_name }}\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
 
-      - name: Unix upload binary to release
-        if: startsWith(github.ref, 'refs/tags/v') && matrix.os != 'windows-latest'
+      - name: Unix upload CLI binary to release
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os != 'windows-latest'
         uses: svenstaro/upload-release-action@v2
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ${{ steps.unix_build.outputs.local_install_root }}/bin/simplex-chat
+          file: ${{ steps.unix_cli_build.outputs.bin_path }}
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 
+      - name: Unix update CLI binary hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os != 'windows-latest'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.unix_cli_build.outputs.bin_hash }}
+
+      - name: Setup Java
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'corretto'
+          java-version: '17'
+          cache: 'gradle'
+
+      - name: Linux build desktop
+        id: linux_desktop_build
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && (matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-22.04')
+        shell: bash
+        run: |
+          scripts/desktop/build-lib-linux.sh
+          cd apps/multiplatform
+          ./gradlew packageDeb
+          path=$(echo $PWD/release/main/deb/simplex_*_amd64.deb)
+          echo "package_path=$path" >> $GITHUB_OUTPUT
+          echo "package_hash=$(echo SHA2-512\(${{ matrix.desktop_asset_name }}\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
+
+      - name: Linux make AppImage
+        id: linux_appimage_build
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os == 'ubuntu-20.04'
+        shell: bash
+        run: |
+          scripts/desktop/make-appimage-linux.sh
+          path=$(echo $PWD/apps/multiplatform/release/main/*imple*.AppImage)
+          echo "appimage_path=$path" >> $GITHUB_OUTPUT
+          echo "appimage_hash=$(echo SHA2-512\(simplex-desktop-x86_64.AppImage\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
+
+      - name: Mac build desktop
+        id: mac_desktop_build
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'macos-latest'
+        shell: bash
+        env:
+          APPLE_SIMPLEX_SIGNING_KEYCHAIN: ${{ secrets.APPLE_SIMPLEX_SIGNING_KEYCHAIN }}
+          APPLE_SIMPLEX_NOTARIZATION_APPLE_ID: ${{ secrets.APPLE_SIMPLEX_NOTARIZATION_APPLE_ID }}
+          APPLE_SIMPLEX_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_SIMPLEX_NOTARIZATION_PASSWORD }}
+        run: |
+          scripts/ci/build-desktop-mac.sh
+          path=$(echo $PWD/apps/multiplatform/release/main/dmg/SimpleX-*.dmg)
+          echo "package_path=$path" >> $GITHUB_OUTPUT
+          echo "package_hash=$(echo SHA2-512\(${{ matrix.desktop_asset_name }}\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
+
+      - name: Linux upload desktop package to release
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && (matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-22.04')
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: ${{ steps.linux_desktop_build.outputs.package_path }}
+          asset_name: ${{ matrix.desktop_asset_name }}
+          tag: ${{ github.ref }}
+
+      - name: Linux update desktop package hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && (matrix.os == 'ubuntu-20.04' || matrix.os == 'ubuntu-22.04')
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.linux_desktop_build.outputs.package_hash }}
+
+      - name: Linux upload AppImage to release
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os == 'ubuntu-20.04'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: ${{ steps.linux_appimage_build.outputs.appimage_path }}
+          asset_name: simplex-desktop-x86_64.AppImage
+          tag: ${{ github.ref }}
+
+      - name: Linux update AppImage hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.asset_name && matrix.os == 'ubuntu-20.04'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.linux_appimage_build.outputs.appimage_hash }}
+
+      - name: Mac upload desktop package to release
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'macos-latest'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: ${{ steps.mac_desktop_build.outputs.package_path }}
+          asset_name: ${{ matrix.desktop_asset_name }}
+          tag: ${{ github.ref }}
+
+      - name: Mac update desktop package hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'macos-latest'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.mac_desktop_build.outputs.package_hash }}
+
+      - name: Cache unix build
+        uses: actions/cache/save@v3
+        if: matrix.os != 'windows-latest'
+        with:
+          path: |
+            ${{ matrix.cache_path }}
+            dist-newstyle
+          key: ${{ steps.restore_cache.outputs.cache-primary-key }}
+
+      - name: Unix test
+        if: matrix.os != 'windows-latest'
+        timeout-minutes: 30
+        shell: bash
+        run: cabal test --test-show-details=direct
+
       # Unix /
 
       # / Windows
+      # rm -rf dist-newstyle/src/direct-sq* is here because of the bug in cabal's dependency which prevents second build from finishing
+
+      - name: 'Setup MSYS2'
+        if: matrix.os == 'windows-latest'
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ucrt64
+          update: true
+          install: >-
+            git
+            perl
+            make
+          pacboy: >-
+            toolchain:p
+            cmake:p
 
-      # * In powershell multiline commands do not fail if individual commands fail - https://github.community/t/multiline-commands-on-windows-do-not-fail-if-individual-commands-fail/16753
-      # * And GitHub Actions does not support parameterizing shell in a matrix job - https://github.community/t/using-matrix-to-specify-shell-is-it-possible/17065
-      # * So we're running a separate set of actions for Windows build
 
-      # TODO run tests on Windows
       - name: Windows build
         id: windows_build
         if: matrix.os == 'windows-latest'
-        shell: cmd
+        shell: msys2 {0}
         run: |
-          stack build
-          stack path --local-install-root > tmp_file
-          set /p local_install_root= < tmp_file
-          echo ::set-output name=local_install_root::%local_install_root%
+          export PATH=$PATH:/c/ghcup/bin
+          scripts/desktop/prepare-openssl-windows.sh
+          openssl_windows_style_path=$(echo `pwd`/dist-newstyle/openssl-1.1.1w | sed 's#/\([a-zA-Z]\)#\1:#' | sed 's#/#\\#g')
+          rm cabal.project.local 2>/dev/null || true
+          echo "ignore-project: False" >> cabal.project.local
+          echo "package direct-sqlcipher" >> cabal.project.local
+          echo "    flags: +openssl" >> cabal.project.local
+          echo "    extra-include-dirs: $openssl_windows_style_path\include" >> cabal.project.local
+          echo "    extra-lib-dirs: $openssl_windows_style_path" >> cabal.project.local
 
-      - name: Windows upload binary to release
+          rm -rf dist-newstyle/src/direct-sq*
+          sed -i "s/, unix /--, unix /" simplex-chat.cabal
+          cabal build --enable-tests
+          rm -rf dist-newstyle/src/direct-sq*
+          path=$(cabal list-bin simplex-chat | tail -n 1)
+          echo "bin_path=$path" >> $GITHUB_OUTPUT
+          echo "bin_hash=$(echo SHA2-512\(${{ matrix.asset_name }}\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
+
+      - name: Windows upload CLI binary to release
         if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
         uses: svenstaro/upload-release-action@v2
         with:
           repo_token: ${{ secrets.GITHUB_TOKEN }}
-          file: ${{ steps.windows_build.outputs.local_install_root }}\bin\simplex-chat.exe
+          file: ${{ steps.windows_build.outputs.bin_path }}
           asset_name: ${{ matrix.asset_name }}
           tag: ${{ github.ref }}
 
+      - name: Windows update CLI binary hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.windows_build.outputs.bin_hash }}
+
+      - name: Windows build desktop
+        id: windows_desktop_build
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
+        shell: msys2 {0}
+        run: |
+          export PATH=$PATH:/c/ghcup/bin
+          scripts/desktop/build-lib-windows.sh
+          cd apps/multiplatform
+          ./gradlew packageMsi
+          path=$(echo $PWD/release/main/msi/*imple*.msi | sed 's#/\([a-z]\)#\1:#' | sed 's#/#\\#g')
+          echo "package_path=$path" >> $GITHUB_OUTPUT
+          echo "package_hash=$(echo SHA2-512\(${{ matrix.desktop_asset_name }}\)= $(openssl sha512 $path | cut -d' ' -f 2))" >> $GITHUB_OUTPUT
+
+      - name: Windows upload desktop package to release
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
+        uses: svenstaro/upload-release-action@v2
+        with:
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
+          file: ${{ steps.windows_desktop_build.outputs.package_path }}
+          asset_name: ${{ matrix.desktop_asset_name }}
+          tag: ${{ github.ref }}
+
+      - name: Windows update desktop package hash
+        if: startsWith(github.ref, 'refs/tags/v') && matrix.os == 'windows-latest'
+        uses: softprops/action-gh-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          append_body: true
+          body: |
+            ${{ steps.windows_desktop_build.outputs.package_hash }}
+
+      - name: Cache windows build
+        uses: actions/cache/save@v3
+        if: matrix.os == 'windows-latest'
+        with:
+          path: |
+            ${{ matrix.cache_path }}
+            dist-newstyle
+          key: ${{ steps.restore_cache.outputs.cache-primary-key }}
+
       # Windows /

.github/workflows/web.yml

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

.gitignore

@@ -42,3 +42,38 @@ stack.yaml.lock
 
 # Temporary test files
 tests/tmp
+tests/tmp*
+logs/
+
+*.devcontainer
+# for website
+website/node_modules/
+website/src/blog/
+website/src/docs/
+website/translations.json
+website/src/img/images/
+website/src/images/
+website/src/js/lottie.min.js
+# Generated files
+website/package/generated*
+
+# Ignore build tool output, e.g. code coverage
+website/.nyc_output/
+website/coverage/
+
+# Ignore API documentation
+website/api-docs/
+
+# Ignore folders from source code editors
+website/.vscode
+website/.idea
+
+# Ignore eleventy output when doing manual tests
+website/_site/
+
+website/package-lock.json
+
+# Ignore test files
+website/.cache
+website/test/stubs-layout-cache/_includes/*.js
+apps/android/app/release

Dockerfile

@@ -1,10 +1,32 @@
-FROM haskell:8.10.4 AS build-stage
-# if you encounter "version `GLIBC_2.28' not found" error when running
-# chat client executable, build with the following base image instead:
-# FROM haskell:8.10.4-stretch AS build-stage
+FROM ubuntu:focal AS build
+
+# Install curl and simplex-chat-related dependencies
+RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev libssl-dev
+
+# Install ghcup
+RUN a=$(arch); curl https://downloads.haskell.org/~ghcup/$a-linux-ghcup -o /usr/bin/ghcup && \
+    chmod +x /usr/bin/ghcup
+
+# Install ghc
+RUN ghcup install ghc 9.6.3
+# Install cabal
+RUN ghcup install cabal 3.10.1.0
+# Set both as default
+RUN ghcup set ghc 9.6.3 && \
+    ghcup set cabal 3.10.1.0
+
 COPY . /project
 WORKDIR /project
-RUN stack install
+
+# Adjust PATH
+ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
+
+# Adjust build
+RUN cp ./scripts/cabal.project.local.linux ./cabal.project.local
+
+# Compile simplex-chat
+RUN cabal update
+RUN cabal install
 
 FROM scratch AS export-stage
-COPY --from=build-stage /root/.local/bin/simplex-chat /
+COPY --from=build /root/.cabal/bin/simplex-chat /

PRIVACY.md

@@ -1,28 +1,68 @@
 # SimpleX Chat Terms & Privacy Policy
 
-SimpleX Chat is the first chat platform that is 100% private by design - not only it has no access to your messages (thanks to open-source double-ratchet end-to-end encryption protocol and additional encryption layers), it also has no access to your profile and contacts - we do not have access to your connections graph.
+SimpleX Chat is the first communication platform that has no user profile IDs of any kind, not even random numbers. Not only it has no access to your messages (thanks to open-source double-ratchet end-to-end encryption protocol and additional encryption layers), it also has no access to your profile and contacts - we cannot observe your connections graph.
+
+If you believe that some of the clauses in this document are not aligned with our mission or principles, please raise it with us via [email](chat@simplex.chat) or [chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion).
 
 ## Privacy Policy
 
-SimpleX Chat Ltd. ("SimpleX Chat") uses the best industry practices for security and end-to-end encryption to provide secure end-to-end encrypted messaging via private connections. SimpleX Chat is built on top of SimpleX messaging and application platform that uses a new message routing protocol that allows establishing private connection without having any kind of addresses that identify its users - we don't use emails, phone numbers, usernames, identity keys or any other user identifiers to pass messages between the users.
+SimpleX Chat Ltd. ("SimpleX Chat") uses the best industry practices for security and encryption to provide secure [end-to-end encrypted](./docs/GLOSSARY.md#end-to-end-encryption) messaging via private connections. This encryption cannot be compromised by the servers via [man-in-the-middle attack](./docs/GLOSSARY.md#man-in-the-middle-attack).
+
+SimpleX Chat is built on top of SimpleX messaging and application platform that uses a new message routing protocol allowing to establish private connections without having any kind of addresses that identify its users - we don't use emails, phone numbers, usernames, identity keys or any other user identifiers to pass messages between the users.
+
+SimpleX Chat security assessment was done in October 2022 by [Trail of Bits](https://www.trailofbits.com/about), and most fixes were released in v4.2.0 – see [the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
 
 ### Information you provide
 
-We do not store user profiles. The profile you create in the app is local to your device. When you create a user profile, no records are created on our servers, and we have no access to any part of your profile information, and even to the fact that you created a profile - it is a local record stored only on your device. That means that if you delete the app, and have no backup, you will permanently lose all the data and the private connections you create with other users.
+#### User profiles
 
-Messages. SimpleX Chat cannot decrypt or otherwise access the content or size of your messages (each message is padded to a fixed size of 16kb). SimpleX Chat temporarily stores end-to-end encrypted messages on its servers for delivery to the devices that are temporarily offline. Your message history is stored only on your own devices.
+We do not store user profiles. The profile you create in the app is local to your device.
 
-Connections with other users. When you create a connection with another user, two messaging queues are created on our servers (we use separate queues for direct and response messages, that can be on two different servers), or on the servers that you configured in the app, in case it allows such configuration. At the time of updating this document only our terminal app allows configuring the servers, our mobile apps will allow such configuration in the near future. Our servers do not store information about which queues are linked to your profile on the device, and they do not have any information in common that allow us to establish that these queues are related to your device or your profile - the access to each queue is authorized by a set of unique encryption keys, different for each queue, and separate for sender and recipient of the messages that are transmitted through the queue.
+When you create a user profile, no records are created on our servers, and we have no access to any part of your profile information, and even to the fact that you created a profile - it is a local record stored only on your device. That means that if you delete the app, and have no backup, you will permanently lose all the data and the private connections you create with other users.
+
+#### Messages and Files
+
+SimpleX Chat cannot decrypt or otherwise access the content or even the size of your messages and files you send or receive. Each message is padded to a fixed size of 16kb. Each file is sent in chunks of 256kb, 1mb or 8mb via all or some of the configured file servers. Both messages and files are sent end-to-end encrypted, and the servers do not have technical means to compromise this encryption, because part of the [key exchange](./docs/GLOSSARY.md#key-exchange) happens out-of-band.
+
+Your message history is stored only on your own device and the devices of your contacts. While the recipients' devices are offline SimpleX Chat temporarily stores end-to-end encrypted messages on the messaging (SMP) servers that are preset in the app or chosen by the users.
+
+The messages are permanently removed from the preset servers as soon as they are delivered. Undelivered messages are deleted after the time that is configured in the messaging servers you use (21 days for preset messaging servers).
+
+The files are stored on file (XFTP) servers for the time configured in the file servers you use (48 hours for preset file servers).
+
+If a messaging or file servers are restarted, the encrypted message or the record of the file can be stored in a backup file until it is overwritten by the next restart (usually within 1 week).
+
+#### Connections with other users
+
+When you create a connection with another user, two messaging queues (you can think about them as about mailboxes) are created on chosen messaging servers, that can be the preset servers or the servers that you configured in the app, in case it allows such configuration. SimpleX uses separate queues for direct and response messages, that the client applications prefer to create on two different servers, in case you have more than one server configured in the app, which is the default.
+
+At the time of updating this document all our client applications allow configuring the servers. Our servers do not store information about which queues are linked to your profile on the device, and they do not collect any information that would allow us to establish that these queues are related to your device or your profile - the access to each queue is authorized by two anonymous unique cryptographic keys, different for each queue, and separate for sender and recipient of the messages.
+
+#### iOS Push Notifications
+
+When you choose to use instant push notifications in SimpleX iOS app, because the design of push notifications requires storing the device token on notification server, the notifications server can observe how many messaging queues your device has notifications enabled for, and approximately how many messages are sent to each queue.
+
+Notification server cannot observe the actual addresses of these queues, as a separate address is used to subscribe to the notifications. It also cannot observe who, or even how many contacts, send messages to you, as notifications are delivered to your device end-to-end encrypted by the messaging servers.
+
+It also does not allow to see message content or sizes, as the actual messages are not sent via the notification server, only the fact that the message is available and where it can be received from (the latter information is encrypted, so that the notification server cannot observe it). You can read more about the design of iOS push notifications [here](https://simplex.chat/blog/20220404-simplex-chat-instant-notifications.html#our-ios-approach-has-one-trade-off).
+
+#### Another information stored on the servers
 
 Additional technical information can be stored on our servers, including randomly generated authentication tokens, keys, push tokens, and other material that is necessary to transmit messages. SimpleX Chat limits this additional technical information to the minimum required to operate the Services.
 
-User Support. If you contact SimpleX Chat any personal data you may share with us is kept only for the purposes of researching the issue and contacting you about your case. We recommend contacting support via chat, when it is possible.
+#### SimpleX Directory Service
+
+[SimpleX directory service](./docs/DIRECTORY.md) stores: your search requests, the messages and the members profiles in the group. You can connect to SimpleX Directory Service via [this address](https://simplex.chat/contact#/?v=1-4&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2FeXSPwqTkKyDO3px4fLf1wx3MvPdjdLW3%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAaiv6MkMH44L2TcYrt_CsX3ZvM11WgbMEUn0hkIKTOho%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion).
+
+#### User Support.
+
+If you contact SimpleX Chat any personal data you may share with us is kept only for the purposes of researching the issue and contacting you about your case. We recommend contacting support [via chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion), when it is possible.
 
 ### Information we may share
 
 We operate our Services using third parties. While we do not share any user data, these third party may access the encrypted user data as it is stored or transmitted via our servers.
 
-We use Third party to provide email services - if you ask for support via email, your and SimpleX Chat email providers may access these emails according their privacy policies and terms of service.
+We use a third party for email services - if you ask for support via email, your and SimpleX Chat email providers may access these emails according to their privacy policies and terms of service.
 
 The cases when SimpleX Chat may need to share the data we temporarily store on the servers:
 
@@ -31,23 +71,25 @@ The cases when SimpleX Chat may need to share the data we temporarily store on t
 - To detect, prevent, or otherwise address fraud, security, or technical issues.
 - To protect against harm to the rights, property, or safety of SimpleX Chat, our users, or the public as required or permitted by law.
 
+At the time of updating this document, we have never provided or have been requested the access to our servers or any information from our servers by any third parties. If we are ever requested to provide such access or information, we will follow the due legal process.
+
 ### Updates
 
-We will update this privacy policy as needed so that it is current, accurate, and as clear as possible. Your continued use of our Services confirms your acceptance of our updated Privacy Policy.
+We will update this Privacy Policy as needed so that it is current, accurate, and as clear as possible. Your continued use of our Services confirms your acceptance of our updated Privacy Policy.
 
-Please also read our Terms of Service.
+Please also read our Terms of Service below.
 
-If you have questions about our Privacy Policy please contact us at chat@simplex.chat.
+If you have questions about our Privacy Policy please contact us via [email](chat@simplex.chat) or [chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion).
 
 ## Terms of Service
 
-You accept to our Terms of Service ("Terms") by installing or using any of our apps or services ("Services").
+You accept our Terms of Service ("Terms") by installing or using any of our apps or services ("Services").
 
 **Minimal age**. You must be at least 13 years old to use our Services. The minimum age to use our Services without parental approval may be higher in your country.
 
-**Accessing the servers**. For the efficiency of the network access, the apps access all queues you create on any server via the same network (TCP/IP) connection. Our servers do not collect information about which queues were accessed via the same connection, so we do cannot establish which queues belong to the same users. Whoever might observe your network traffic would know which servers you use, and how much data you send, but not to whom it is sent - the data that leaves the servers is always different from the data they receive - there are no identifiers or cyphertext in common. Please refer to our [technical design document](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information about our privacy model and known security and privacy risks.
+**Accessing the servers**. For the efficiency of the network access, the apps access all queues you create on any server via the same network (TCP/IP) connection. Our servers do not collect information about which queues were accessed via the same connection, so we cannot establish which queues belong to the same users. Whoever might observe your network traffic would know which servers you use, and how much data you send, but not to whom it is sent - the data that leaves the servers is always different from the data they receive - there are no identifiers or ciphertext in common. Please refer to our [technical design document](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information about our privacy model and known security and privacy risks.
 
-**Privacy of user data**. We do not retain any data we transmit for any longer than necessary to provide the Services. We only collect aggregate statistics across all users, not per users - we do not have information about how many people use SimpleX Chat (we only know an approximate number of app installations and the aggregate traffic through our servers). In any case, we do not and will not sell or in any way monetize user data.
+**Privacy of user data**. We do not retain any data we transmit for any longer than necessary to provide the Services. We only collect aggregate statistics across all users, not per user - we do not have information about how many people use SimpleX Chat (we only know an approximate number of app installations and the aggregate traffic through our servers). In any case, we do not and will not sell or in any way monetize user data.
 
 **Operating our services**. For the purpose of operating our Services, you agree that your end-to-end encrypted messages are transferred via our servers in the United Kingdom, the United States and other countries where we have or use facilities and service providers or partners.
 
@@ -61,15 +103,17 @@ You accept to our Terms of Service ("Terms") by installing or using any of our a
 
 **Keeping your data secure**. SimpleX Chat is the first messaging platform that is 100% private by design - we neither have ability to access your messages, nor we have information about who you communicate with. That means that you are solely responsible for keeping your device and your user profile safe and secure. If you lose your phone or remove the app, you will not be able to recover the lost data, unless you made a back up.
 
-**Storing the messages on the device**. Currently the messages are stored in the database on your device without encryption. It means that if you make a backup of the app and store it unecrypted, the backup provider may be able to access the messages.
+**Storing the messages on the device**. The messages are stored in the encrypted database on your device. Whether and how database passphrase is stored is determined by the configuration of the application you use. Legacy databases created prior to 2023 or in CLI (terminal) app may remain unencrypted, and it will be indicated in the app. In this case, if you make a backup of the app data and store it unencrypted, the backup provider may be able to access the messages. Please note, that the beta version of desktop app currently stores the database passphrase in the configuration file in plaintext, so you may need to remove passphrase from the device via the app configuration.
+
+**Storing the files on the device**. The files are stored on your device unencrypted. If you make a backup of the app data and store it unencrypted, the backup provider will be able to access the files.
 
 **No Access to Emergency Services**. Our Services do not provide access to emergency service providers like the police, fire department, hospitals, or other public safety organizations. Make sure you can contact emergency service providers through a mobile, fixed-line telephone, or other service.
 
 **Third-party services**. Our Services may allow you to access, use, or interact with third-party websites, apps, content, and other products and services. When you use third-party services, their terms and privacy policies govern your use of those services.
 
-**Your Rights**. You own the mesasges and information you transmit through our Services. Your recipients are able to retain the messages you receive from you; there is no technical ability to delete data from their devices.
+**Your Rights**. You own the messages and the information you transmit through our Services. Your recipients are able to retain the messages you receive from you; there is no technical ability to delete data from their devices. While there are various app features that allow deleting messages from the recipients' devices, such as _disappearing messages_ and _full message deletion_, their functioning on your recipients' devices cannot be guaranteed or enforced, as the device may be offline or have a modified version of the app.
 
-**License**. SimpleX Chat grants you a limited, revocable, non-exclusive, and non-transferable license to use our Services in accordance with these Terms. The source-code of services is available and can be used under [AGPL v3 licence](https://github.com/simplex-chat/simplex-chat/blob/stable/LICENSE)
+**License**. SimpleX Chat grants you a limited, revocable, non-exclusive, and non-transferable license to use our Services in accordance with these Terms. The source-code of services is available and can be used under [AGPL v3 license](https://github.com/simplex-chat/simplex-chat/blob/stable/LICENSE)
 
 **SimpleX Chat Rights**. We own all copyrights, trademarks, domains, logos, trade secrets, and other intellectual property rights associated with our Services. You may not use our copyrights, trademarks, domains, logos, and other intellectual property rights unless you have our written permission, and unless under an open-source license distributed together with the source code. To report copyright, trademark, or other intellectual property infringement, please contact chat@simplex.chat.
 
@@ -87,4 +131,4 @@ You accept to our Terms of Service ("Terms") by installing or using any of our a
 
 **Ending these Terms**. You may end these Terms with SimpleX Chat at any time by deleting SimpleX Chat app(s) from your device and discontinuing use of our Services. The provisions related to Licenses, Disclaimers, Limitation of Liability, Resolving dispute, Availability, Changes to the terms, Enforcing the terms, and Ending these Terms will survive termination of your relationship with SimpleX Chat.
 
-Updated March 1, 2022
+Updated August 17, 2023

README.md

@@ -1,12 +1,28 @@
+[![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
+[![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
+[![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
+[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
+<a rel="me" href="https://mastodon.social/@simplex">![Follow on Mastodon](https://img.shields.io/mastodon/follow/108619463746856738?domain=https%3A%2F%2Fmastodon.social&style=social)</a>
+
+| 30/03/2023 | EN, [FR](/docs/lang/fr/README.md), [CZ](/docs/lang/cs/README.md) |
+
 <img src="images/simplex-chat-logo.svg" alt="SimpleX logo" width="100%">
 
 # SimpleX - the first messaging platform that has no user identifiers of any kind - 100% private by design!
 
-[![build](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml/badge.svg?branch=stable)](https://github.com/simplex-chat/simplex-chat/actions/workflows/build.yml)
-[![GitHub downloads](https://img.shields.io/github/downloads/simplex-chat/simplex-chat/total)](https://github.com/simplex-chat/simplex-chat/releases)
-[![GitHub release](https://img.shields.io/github/v/release/simplex-chat/simplex-chat)](https://github.com/simplex-chat/simplex-chat/releases)
-[![Follow on Twitter](https://img.shields.io/twitter/follow/SimpleXChat?style=social)](https://twitter.com/SimpleXChat)
-[![Join on Reddit](https://img.shields.io/reddit/subreddit-subscribers/SimpleXChat?style=social)](https://www.reddit.com/r/SimpleXChat)
+[<img src="./images/trail-of-bits.jpg" height="100">](http://simplex.chat/blog/20221108-simplex-chat-v4.2-security-audit-new-website.html) &nbsp;&nbsp;&nbsp; [<img src="./images/privacy-guides.jpg" height="80">](https://www.privacyguides.org/en/real-time-communication/#simplex-chat) &nbsp;&nbsp;&nbsp; [<img src="./images/kuketz-blog.jpg" height="80">](https://www.kuketz-blog.de/simplex-eindruecke-vom-messenger-ohne-identifier/)
+
+## Welcome to SimpleX Chat!
+
+1. 📲 [Install the app](#install-the-app).
+2. ↔️ [Connect to the team](#connect-to-the-team), [join user groups](#join-user-groups) and [follow our updates](#follow-our-updates).
+3. 🤝 [Make a private connection](#make-a-private-connection) with a friend.
+4. 🔤 [Help translating SimpleX Chat](#help-translating-simplex-chat).
+5. ⚡️ [Contribute](#contribute) and [help us with donations](#help-us-with-donations).
+
+[Learn more about SimpleX Chat](#contents).
+
+## Install the app
 
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apple_store.svg" alt="iOS app" height="42">](https://apps.apple.com/us/app/simplex-chat/id1605771084)
 &nbsp;
@@ -16,13 +32,150 @@
 &nbsp;
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/testflight.png" alt="iOS TestFlight" height="41">](https://testflight.apple.com/join/DWuT2LQu)
 &nbsp;
-[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)
 
 - 🖲 Protects your messages and metadata - who you talk to and when.
 - 🔐 Double ratchet end-to-end encryption, with additional encryption layer.
-- 📱 Mobile apps for Android ([Google Play](https://play.google.com/store/apps/details?id=chat.simplex.app), [APK](https://github.com/simplex-chat/website/raw/master/simplex.apk)) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084).
+- 📱 Mobile apps for Android ([Google Play](https://play.google.com/store/apps/details?id=chat.simplex.app), [APK](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084).
 - 🚀 [TestFlight preview for iOS](https://testflight.apple.com/join/DWuT2LQu) with the new features 1-2 weeks earlier - **limited to 10,000 users**!
-- 🖥 Available as a terminal (console) app / CLI on Linux, MacOS, Windows.
+- 🖥 Available as a terminal (console) [app / CLI](#zap-quick-installation-of-a-terminal-app) on Linux, MacOS, Windows.
+
+## Connect to the team
+
+You can connect to the team via the app using "chat with the developers button" available when you have no conversations in the profile, "Send questions and ideas" in the app settings or via our [SimpleX address](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion). Please connect to:
+
+- to ask any questions
+- to suggest any improvements
+- to share anything relevant
+
+We are replying the questions manually, so it is not instant – it can take up to 24 hours.
+
+If you are interested in helping us to integrate open-source language models, and in [joining our team](./docs/JOIN_TEAM.md), please get in touch.
+
+## Join user groups
+
+You can join the groups created by other users via the new [directory service](https://simplex.chat/contact#/?v=1-4&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2FeXSPwqTkKyDO3px4fLf1wx3MvPdjdLW3%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAaiv6MkMH44L2TcYrt_CsX3ZvM11WgbMEUn0hkIKTOho%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion). We are not responsible for the content shared in these groups.
+
+**Please note**: The groups below are created for the users to be able to ask questions, make suggestions and ask questions about SimpleX Chat only.
+
+You also can:
+- criticize the app, and make comparisons with other messengers.
+- share new messengers you think could be interesting for privacy, as long as you don't spam.
+- share some privacy related publications, infrequently.
+- having preliminary approved with the admin in direct message, share the link to a group you created, but only once. Once the group has more than 10 members it can be submitted to [SimpleX Directory Service](./docs/DIRECTORY.md) where the new users will be able to discover it.
+
+You must:
+- be polite to other users
+- avoid spam (too frequent messages, even if they are relevant)
+- avoid any personal attacks or hostility.
+- avoid sharing any content that is not relevant to the above (that includes, but is not limited to, discussing politics or any aspects of society other than privacy, security, technology and communications, sharing any content that may be found offensive by other users, etc.).
+
+Messages not following these rules will be deleted, the right to send messages may be revoked, and the access to the new members to the group may be temporarily restricted, to prevent re-joining under a different name - our imperfect group moderation does not have a better solution at the moment.
+
+You can join an English-speaking users group if you want to ask any questions: [#SimpleX-Group-4](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2Fw2GlucRXtRVgYnbt_9ZP-kmt76DekxxS%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA0tJhTyMGUxznwmjb7aT24P1I1Wry_iURTuhOFlMb1Eo%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22WoPxjFqGEDlVazECOSi2dg%3D%3D%22%7D)
+
+There is also a group [#simplex-devs](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F6eHqy7uAbZPOcA6qBtrQgQquVlt4Ll91%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAqV_pg3FF00L98aCXp4D3bOs4Sxv_UmSd-gb0juVoQVs%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22XonlixcHBIb2ijCehbZoiw%3D%3D%22%7D) for developers who build on SimpleX platform:
+
+- chat bots and automations
+- integrations with other apps
+- social apps and services
+- etc.
+
+There are groups in other languages, that we have the apps interface translated into. These groups are for testing, and asking questions to other SimpleX Chat users:
+
+[\#SimpleX-DE](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FkIEl7OQzcp-J6aDmjdlQbRJwqkcZE7XR%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAR16PCu02MobRmKAsjzhDWMZcWP9hS8l5AUZi-Gs8z18%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22puYPMCQt11yPUvgmI5jCiw%3D%3D%22%7D) (German-speaking), [\#SimpleX-ES](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FaJ8O1O8A8GbeoaHTo_V8dcefaCl7ouPb%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEA034qWTA3sWcTsi6aWhNf9BA34vKVCFaEBdP2R66z6Ao%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22wiZ1v_wNjLPlT-nCSB-bRA%3D%3D%22%7D) (Spanish-speaking), [\#SimpleX-FR](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fhpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg%3D%40smp5.simplex.im%2FvIHQDxTor53nwnWWTy5cHNwQQAdWN5Hw%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAPdgK1eBnETmgiqEQufbUkydKBJafoRx4iRrtrC2NAGc%253D%26srv%3Djjbyvoemxysm7qxap7m5d5m35jzv5qq6gnlv7s4rsn7tdwwmuqciwpid.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%221FyUryBPza-1ZFFE80Ekbg%3D%3D%22%7D) (French-speaking), [\#SimpleX-RU](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FXZyt3hJmWsycpN7Dqve_wbrAqb6myk1R%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAMFVIoytozTEa_QXOgoZFq_oe0IwZBYKvW50trSFXzXo%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22xz05ngjA3pNIxLZ32a8Vxg%3D%3D%22%7D) (Russian-speaking), [\#SimpleX-IT](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F0weR-ZgDUl7ruOtI_8TZwEsnJP6UiImA%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAq4PSThO9Fvb5ydF48wB0yNbpzCbuQJCW3vZ9BGUfcxk%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22e-iceLA0SctC62eARgYDWg%3D%3D%22%7D) (Italian-speaking).
+
+You can join either by opening these links in the app or by opening them in a desktop browser and scanning the QR code.
+
+## Follow our updates
+
+We publish our updates and releases via:
+
+- [Reddit](https://www.reddit.com/r/SimpleXChat/), [Twitter](https://twitter.com/SimpleXChat), [Lemmy](https://lemmy.ml/c/simplex), [Mastodon](https://mastodon.social/@simplex) and [Nostr](https://snort.social/p/npub1exv22uulqnmlluszc4yk92jhs2e5ajcs6mu3t00a6avzjcalj9csm7d828).
+- SimpleX Chat [team profile](#connect-to-the-team).
+- [blog](https://simplex.chat/blog/) and [RSS feed](https://simplex.chat/feed.rss).
+- [mailing list](https://simplex.chat/#join-simplex), very rarely.
+
+## Make a private connection
+
+You need to share a link with your friend or scan a QR code from their phone, in person or during a video call, to make a connection and start messaging.
+
+The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
+
+<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app1.png" alt="Make a private connection" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app2.png" alt="Conversation" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/arrow.png" height="360"> <img src="https://github.com/simplex-chat/.github/blob/master/profile/images/app3.png" alt="Video call" height="360">
+
+After you connect, you can [verify connection security code](./blog/20230103-simplex-chat-v4.4-disappearing-messages.md#connection-security-verification).
+
+## User guide (NEW)
+
+Read about the app features and settings in the new [User guide](./docs/guide/README.md).
+
+## Help translating SimpleX Chat
+
+Thanks to our users and [Weblate](https://hosted.weblate.org/engage/simplex-chat/), SimpleX Chat apps, website and documents are translated to many other languages.
+
+Join our translators to help SimpleX grow!
+
+|locale|language |contributor|[Android](https://play.google.com/store/apps/details?id=chat.simplex.app) and [iOS](https://apps.apple.com/us/app/simplex-chat/id1605771084)|[website](https://simplex.chat)|Github docs|
+|:----:|:-------:|:---------:|:---------:|:---------:|:---------:|
+|🇬🇧 en|English   | |✓|✓|✓|✓|
+|ar|العربية   |[jermanuts](https://github.com/jermanuts)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/ar/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/ar/)<br>-|[![website](https://hosted.weblate.org/widgets/simplex-chat/ar/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/ar/)||
+|🇧🇬 bg|Български | |[![android app](https://hosted.weblate.org/widgets/simplex-chat/bg/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/bg/)<br>[![ios app](https://hosted.weblate.org/widget/simplex-chat/ios/bg/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/bg/)|||
+|🇨🇿 cs|Čeština   |[zen0bit](https://github.com/zen0bit)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/cs/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/cs/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/cs/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/cs/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/cs/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/cs/)|[✓](https://github.com/simplex-chat/simplex-chat/tree/master/docs/lang/cs)|
+|🇩🇪 de|Deutsch   |[mlanp](https://github.com/mlanp)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/de/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/de/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/de/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/de/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/de/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/de/)||
+|🇪🇸 es|Español   |[Mateyhv](https://github.com/Mateyhv)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/es/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/es/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/es/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/es/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/es/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/es/)||
+|🇫🇮 fi|Suomi     | |[![android app](https://hosted.weblate.org/widgets/simplex-chat/fi/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/fi/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/fi/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/fi/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/fi/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/fi/)||
+|🇫🇷 fr|Français  |[ishi_sama](https://github.com/ishi-sama)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/fr/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/fr/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/fr/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/fr/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/fr/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/fr/)|[✓](https://github.com/simplex-chat/simplex-chat/tree/master/docs/lang/fr)|
+|🇮🇱 he|עִברִית     | |[![android app](https://hosted.weblate.org/widgets/simplex-chat/he/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/he/)<br>-|||
+|🇮🇹 it|Italiano  |[unbranched](https://github.com/unbranched)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/it/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/it/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/it/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/it/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/it/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/it/)||
+|🇯🇵 ja|日本語     | |[![android app](https://hosted.weblate.org/widgets/simplex-chat/ja/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/ja/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/ja/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/ja/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/ja/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/ja/)||
+|🇳🇱 nl|Nederlands|[mika-nl](https://github.com/mika-nl)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/nl/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/nl/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/nl/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/nl/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/nl/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/nl/)||
+|🇵🇱 pl|Polski    |[BxOxSxS](https://github.com/BxOxSxS)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/pl/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/pl/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/pl/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/pl/)|||
+|🇧🇷 pt-BR|Português||[![android app](https://hosted.weblate.org/widgets/simplex-chat/pt_BR/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/pt_BR/)<br>-|[![website](https://hosted.weblate.org/widgets/simplex-chat/pt_BR/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/pt_BR/)||
+|🇷🇺 ru|Русский   ||[![android app](https://hosted.weblate.org/widgets/simplex-chat/ru/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/ru/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/ru/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/ru/)|||
+|🇹🇭 th|ภาษาไทย   |[titapa-punpun](https://github.com/titapa-punpun)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/th/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/th/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/th/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/th/)|||
+|🇺🇦 uk|Українська| |[![android app](https://hosted.weblate.org/widgets/simplex-chat/uk/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/uk/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/uk/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/uk/)|[![website](https://hosted.weblate.org/widgets/simplex-chat/uk/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/uk/)||
+|🇨🇳 zh-CHS|简体中文|[sith-on-mars](https://github.com/sith-on-mars)<br><br>[Float-hu](https://github.com/Float-hu)|[![android app](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/android/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/android/zh_Hans/)<br>[![ios app](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/ios/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/ios/zh_Hans/)<br>&nbsp;|<br><br>[![website](https://hosted.weblate.org/widgets/simplex-chat/zh_Hans/website/svg-badge.svg)](https://hosted.weblate.org/projects/simplex-chat/website/zh_Hans/)||
+
+Languages in progress: Arabic, Japanese, Korean, Portuguese and [others](https://hosted.weblate.org/projects/simplex-chat/#languages). We will be adding more languages as some of the already added are completed – please suggest new languages, review the [translation guide](./docs/TRANSLATIONS.md) and get in touch with us!
+
+## Contribute
+
+We would love to have you join the development! You can help us with:
+
+- [share the color theme](./docs/THEMES.md) you use in Android app!
+- writing a tutorial or recipes about hosting servers, chat bot automations, etc.
+- contributing to SimpleX Chat knowledge-base.
+- developing features - please connect to us via chat so we can help you get started.
+
+## Help us with donations
+
+Huge thank you to everybody who donated to SimpleX Chat!
+
+We are prioritizing users privacy and security - it would be impossible without your support.
+
+Our pledge to our users is that SimpleX protocols are and will remain open, and in public domain, - so anybody can build the future implementations of the clients and the servers. We are building SimpleX platform based on the same principles as email and web, but much more private and secure.
+
+Your donations help us raise more funds – any amount, even the price of the cup of coffee, would make a big difference for us.
+
+It is possible to donate via:
+
+- [GitHub](https://github.com/sponsors/simplex-chat) - it is commission-free for us.
+- [OpenCollective](https://opencollective.com/simplex-chat) - it charges a commission, and also accepts donations in crypto-currencies.
+- Monero: 8568eeVjaJ1RQ65ZUn9PRQ8ENtqeX9VVhcCYYhnVLxhV4JtBqw42so2VEUDQZNkFfsH5sXCuV7FN8VhRQ21DkNibTZP57Qt
+- Bitcoin: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+- BCH: 1bpefFkzuRoMY3ZuBbZNZxycbg7NYPYTG
+- USDT:
+  - BNB Smart Chain: 0x83fd788f7241a2be61780ea9dc72d2151e6843e2
+  - Tron: TNnTrKLBmdy2Wn3cAQR98dAVvWhLskQGfW
+- Ethereum: 0x83fd788f7241a2be61780ea9dc72d2151e6843e2
+- Solana: 43tWFWDczgAcn4Rzwkpqg2mqwnQETSiTwznmCgA2tf1L
+
+Thank you,
+
+Evgeny
+
+SimpleX Chat founder
 
 ## Contents
 
@@ -34,12 +187,12 @@
   - [Users own SimpleX network](#users-own-simplex-network)
 - [Frequently asked questions](#frequently-asked-questions)
 - [News and updates](#news-and-updates)
-- [Make a private connection](#make-a-private-connection)
 - [Quick installation of a terminal app](#zap-quick-installation-of-a-terminal-app)
 - [SimpleX Platform design](#simplex-platform-design)
+- [Privacy and security: technical details and limitations](#privacy-and-security-technical-details-and-limitations)
 - [For developers](#for-developers)
 - [Roadmap](#roadmap)
-- [Disclaimer, License](#disclaimer)
+- [Disclaimers, Security contact, License](#disclaimers)
 
 ## Why privacy matters
 
@@ -69,32 +222,34 @@ You can use SimpleX with your own servers and still communicate with people usin
 
 ## Frequently asked questions
 
-1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release annoucement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
+1. _How SimpleX can deliver messages without any user identifiers?_ See [v2 release announcement](./blog/20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers) explaining how SimpleX works.
 
-2. _Why should I not just use Signal?_ This [post](https://github.com/dessalines/essays/blob/master/why_not_signal.md) shows why Signal cannot be considered a private messenger. Signal is a centralised platform that uses phone numbers to identify its users and their contacts.
+2. _Why should I not just use Signal?_ Signal is a centralized platform that uses phone numbers to identify its users and their contacts. It means that while the content of your messages on Signal is protected with robust end-to-end encryption, there is a large amount of meta-data visible to Signal - who you talk with and when.
 
-3. _How is it different from Matrix, Session, Ricochet, Cwtch, etc., that also don't require user identites?_ Although these platforms do not require a _real identity_, they do rely on anonymous user identities to deliver messages – it can be, for example, an identity key or a random number. Using a persistent user identity, even anonymous, creates a risk that user's connection graph becomes known to the observers and/or service providers, and it can lead to de-anonymizing some users. If the same user profile is used to connect to two different people via any messenger other than SimpleX, these two people can confirm if they are connected to the same person - they would use the same user identifier in the messages. With SimpleX there is no meta-data in common between your conversations with different contacts - the quality that no other messaging platform has.
+3. _How is it different from Matrix, Session, Ricochet, Cwtch, etc., that also don't require user identities?_ Although these platforms do not require a _real identity_, they do rely on anonymous user identities to deliver messages – it can be, for example, an identity key or a random number. Using a persistent user identity, even anonymous, creates a risk that user's connection graph becomes known to the observers and/or service providers, and it can lead to de-anonymizing some users. If the same user profile is used to connect to two different people via any messenger other than SimpleX, these two people can confirm if they are connected to the same person - they would use the same user identifier in the messages. With SimpleX there is no meta-data in common between your conversations with different contacts - the quality that no other messaging platform has.
 
 ## News and updates
 
-[Jun 4, 2022. v2.2: the new Privacy and Security settings](./blog/20220604-simplex-chat-new-privacy-security-settings.md)
+Recent and important updates:
 
-[May 11, 2022. v2.0 released - sending images and files in mobile apps](./blog/20220511-simplex-chat-v2-images-files.md)
+[Nov 25, 2023. SimpleX Chat v5.4 released: link mobile and desktop apps via quantum resistant protocol, and much better groups](./blog/20231125-simplex-chat-v5-4-link-mobile-desktop-quantum-resistant-better-groups.md).
 
-[Mar 08, 2022 Mobile apps for iOS and Android released](./blog/20220308-simplex-chat-mobile-apps.md)
+[Sep 25, 2023. SimpleX Chat v5.3 released: desktop app, local file encryption, improved groups and directory service](./blog/20230925-simplex-chat-v5-3-desktop-app-local-file-encryption-directory-service.md).
 
-[Jan 12, 2022. SimpleX v1 released: the only messaging and application platform without user identities](./20220112-simplex-chat-v1-released.md)
+[Jul 22, 2023. SimpleX Chat: v5.2 released with message delivery receipts](./blog/20230722-simplex-chat-v5-2-message-delivery-receipts.md).
+
+[May 23, 2023. SimpleX Chat: v5.1 released with message reactions and self-destruct passcode](./blog/20230523-simplex-chat-v5-1-message-reactions-self-destruct-passcode.md).
+
+[Apr 22, 2023. SimpleX Chat: vision and funding, v5.0 released with videos and files up to 1gb](./blog/20230422-simplex-chat-vision-funding-v5-videos-files-passcode.md).
+
+[Mar 1, 2023. SimpleX File Transfer Protocol – send large files efficiently, privately and securely, soon to be integrated into SimpleX Chat apps.](./blog/20230301-simplex-file-transfer-protocol.md).
+
+[Nov 8, 2022. Security audit by Trail of Bits, the new website and v4.2 released](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
+
+[Sep 28, 2022. v4.0: encrypted local chat database and many other changes](./blog/20220928-simplex-chat-v4-encrypted-database.md).
 
 [All updates](./blog)
 
-## Make a private connection
-
-You need to share a link or scan a QR code (in person or during a video call) to make a connection and start messaging.
-
-The channel through which you share the link does not have to be secure - it is enough that you can confirm who sent you the message and that your SimpleX connection is established.
-
-<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/conversation.png" alt="Make a private connection" width="594" height="360">
-
 ## :zap: Quick installation of a terminal app
 
 ```sh
@@ -117,19 +272,54 @@ Unlike federated networks, the server nodes **do not have records of the users**
 
 Only the client devices have information about users, their contacts and groups.
 
-See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) for more information on platform objectives and technical design.
+See [SimpleX whitepaper](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/overview-tjr.md) for more information on platform objectives and technical design.
+
+See [SimpleX Chat Protocol](./docs/protocol/simplex-chat.md) for the format of messages sent between chat clients over [SimpleX Messaging Protocol](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/simplex-messaging.md).
+
+## Privacy and security: technical details and limitations
+
+SimpleX Chat is a work in progress – we are releasing improvements as they are ready. You have to decide if the current state is good enough for your usage scenario.
+
+We compiled a [glossary of terms](./docs/GLOSSARY.md) used to describe communication systems to help understand some terms below and to help compare advantages and disadvantages of various communication systems.
+
+What is already implemented:
+
+1. Instead of user profile identifiers used by all other platforms, even the most private ones, SimpleX uses [pairwise per-queue identifiers](./docs/GLOSSARY.md#pairwise-pseudonymous-identifier) (2 addresses for each unidirectional message queue, with an optional 3rd address for push notifications on iOS, 2 queues in each connection between the users). It makes observing the network graph on the application level more difficult, as for `n` users there can be up to `n * (n-1)` message queues.
+2. [End-to-end encryption](./docs/GLOSSARY.md#end-to-end-encryption) in each message queue using [NaCl cryptobox](https://nacl.cr.yp.to/box.html). This is added to allow redundancy in the future (passing each message via several servers), to avoid having the same ciphertext in different queues (that would only be visible to the attacker if TLS is compromised). The encryption keys used for this encryption are not rotated, instead we are planning to rotate the queues. Curve25519 keys are used for key negotiation.
+3. [Double ratchet](./docs/GLOSSARY.md#double-ratchet-algorithm) end-to-end encryption in each conversation between two users (or group members). This is the same algorithm that is used in Signal and many other messaging apps; it provides OTR messaging with [forward secrecy](./docs/GLOSSARY.md#forward-secrecy) (each message is encrypted by its own ephemeral key) and [break-in recovery](./docs/GLOSSARY.md#post-compromise-security) (the keys are frequently re-negotiated as part of the message exchange). Two pairs of Curve448 keys are used for the initial [key agreement](./docs/GLOSSARY.md#key-agreement-protocol), initiating party passes these keys via the connection link, accepting side - in the header of the confirmation message.
+4. Additional layer of encryption using NaCL cryptobox for the messages delivered from the server to the recipient. This layer avoids having any ciphertext in common between sent and received traffic of the server inside TLS (and there are no identifiers in common as well).
+5. Several levels of [content padding](./docs/GLOSSARY.md#message-padding) to frustrate message size attacks.
+6. All message metadata, including the time when the message was received by the server (rounded to a second) is sent to the recipients inside an encrypted envelope, so even if TLS is compromised it cannot be observed.
+7. Only TLS 1.2/1.3 are allowed for client-server connections, limited to cryptographic algorithms: CHACHA20POLY1305_SHA256, Ed25519/Ed448, Curve25519/Curve448.
+8. To protect against replay attacks SimpleX servers require [tlsunique channel binding](https://www.rfc-editor.org/rfc/rfc5929.html) as session ID in each client command signed with per-queue ephemeral key.
+9. To protect your IP address all SimpleX Chat clients support accessing messaging servers via Tor - see [v3.1 release announcement](./blog/20220808-simplex-chat-v3.1-chat-groups.md) for more details.
+10. Local database encryption with passphrase - your contacts, groups and all sent and received messages are stored encrypted. If you used SimpleX Chat before v4.0 you need to enable the encryption via the app settings.
+11. Transport isolation - different TCP connections and Tor circuits are used for traffic of different user profiles, optionally - for different contacts and group member connections.
+12. Manual messaging queue rotations to move conversation to another SMP relay.
+13. Sending end-to-end encrypted files using [XFTP protocol](https://simplex.chat/blog/20230301-simplex-file-transfer-protocol.html).
+14. Local files encryption, except videos (to be added later).
+
+We plan to add:
+
+1. Senders' SMP relays and recipients' XFTP relays to reduce traffic and conceal IP addresses from the relays chosen, and potentially controlled, by another party.
+2. Post-quantum resistant key exchange in double ratchet protocol.
+3. Automatic message queue rotation and redundancy. Currently the queues created between two users are used until the queue is manually changed by the user or contact is deleted. We are planning to add automatic queue rotation to make these identifiers temporary and rotate based on some schedule TBC (e.g., every X messages, or every X hours/days).
+4. Message "mixing" - adding latency to message delivery, to protect against traffic correlation by message time.
+5. Reproducible builds – this is the limitation of the development stack, but we will be investing into solving this problem. Users can still build all applications and services from the source code.
 
 ## For developers
 
-We plan that the SimpleX platform will grow into the platform supporting any distributed Internet application. This will allow you to build any service that people can access via chat, with custom web-based UI widgets that anybody with basic HTML/CSS/JavaScript knowledge can create in a few hours.
+You can:
 
-You already can:
-
-- use SimpleX Chat library to integrate chat functionality into your apps.
-- use SimpleX Chat bot templates in Haskell to build your own chat bot services (TypeScript SDK is coming soon).
+- use SimpleX Chat library to integrate chat functionality into your mobile apps.
+- create chat bots and services in Haskell - see [simple](./apps/simplex-bot/) and more [advanced chat bot example](./apps/simplex-bot-advanced/).
+- create chat bots and services in any language running SimpleX Chat terminal CLI as a local WebSocket server. See [TypeScript SimpleX Chat client](./packages/simplex-chat-client/) and [JavaScript chat bot example](./packages/simplex-chat-client/typescript/examples/squaring-bot.js).
+- run [simplex-chat terminal CLI](./docs/CLI.md) to execute individual chat commands, e.g. to send messages as part of shell script execution.
 
 If you are considering developing with SimpleX platform please get in touch for any advice and support.
 
+Please also join [#simplex-devs](https://simplex.chat/contact#/?v=1-2&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2F6eHqy7uAbZPOcA6qBtrQgQquVlt4Ll91%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAqV_pg3FF00L98aCXp4D3bOs4Sxv_UmSd-gb0juVoQVs%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion&data=%7B%22type%22%3A%22group%22%2C%22groupLinkId%22%3A%22XonlixcHBIb2ijCehbZoiw%3D%3D%22%7D) group to ask any questions and share your success stories.
+
 ## Roadmap
 
 - ✅ Easy to deploy SimpleX server with in-memory message storage, without any dependencies.
@@ -141,28 +331,84 @@ If you are considering developing with SimpleX platform please get in touch for
 - ✅ Haskell chat bot templates.
 - ✅ v2.0 - supporting images and files in mobile apps.
 - ✅ Manual chat history deletion.
-- 🚀 End-to-end encrypted audio and video calls via the mobile apps (enable via Experimental Features).
-- 🏗 Privacy preserving instant notifications for iOS using Apple Push Notification service (in progress).
-- 🏗 Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (in progress).
-- 🏗 Chat database portability and encryption.
-- Groups support for mobile apps.
-- Disappearing messages, with mutual agreement.
+- ✅ End-to-end encrypted WebRTC audio and video calls via the mobile apps.
+- ✅ Privacy preserving instant notifications for iOS using Apple Push Notification service.
+- ✅ Chat database export and import.
+- ✅ Chat groups in mobile apps.
+- ✅ Connecting to messaging servers via Tor.
+- ✅ Dual server addresses to access messaging servers as v3 hidden services.
+- ✅ Chat server and TypeScript client SDK to develop chat interfaces, integrations and chat bots (ready for announcement).
+- ✅ Incognito mode to share a new random name with each contact.
+- ✅ Chat database encryption.
+- ✅ Automatic chat history deletion.
+- ✅ Links to join groups and improve groups stability.
+- ✅ Voice messages (with recipient opt-out per contact).
+- ✅ Basic authentication for SMP servers (to authorize creating new queues).
+- ✅ View deleted messages, full message deletion by sender (with recipient opt-in per contact).
+- ✅ Block screenshots and view in recent apps.
+- ✅ Advanced server configuration.
+- ✅ Disappearing messages (with recipient opt-in per-contact).
+- ✅ "Live" messages.
+- ✅ Contact verification via a separate out-of-band channel.
+- ✅ Multiple user profiles in the same chat database.
+- ✅ Optionally avoid re-using the same TCP session for multiple connections.
+- ✅ Preserve message drafts.
+- ✅ File server to optimize for efficient and private sending of large files.
+- ✅ Improved audio & video calls.
+- ✅ Support older Android OS and 32-bit CPUs.
+- ✅ Hidden chat profiles.
+- ✅ Sending and receiving large files via [XFTP protocol](./blog/20230301-simplex-file-transfer-protocol.md).
+- ✅ Video messages.
+- ✅ App access passcode.
+- ✅ Improved Android app UI design.
+- ✅ Optional alternative access password.
+- ✅ Message reactions
+- ✅ Message editing history
+- ✅ Reduced battery and traffic usage in large groups.
+- ✅ Message delivery confirmation (with sender opt-out per contact).
+- ✅ Desktop client.
+- ✅ Encryption of local files stored in the app.
+- ✅ Using mobile profiles from the desktop app.
+- 🏗 Improve experience for the new users.
+- 🏗 Post-quantum resistant key exchange in double ratchet protocol.
+- 🏗 Large groups, communities and public channels.
+- Message delivery relay for senders (to conceal IP address from the recipients' servers and to reduce the traffic).
+- Privacy & security slider - a simple way to set all settings at once.
+- Improve sending videos (including encryption of locally stored videos).
+- SMP queue redundancy and rotation (manual is supported).
+- Include optional message into connection request sent via contact address.
+- Improved navigation and search in the conversation (expand and scroll to quoted message, scroll to search results, etc.).
+- Feeds/broadcasts.
+- Ephemeral/disappearing/OTR conversations with the existing contacts.
+- Privately share your location.
 - Web widgets for custom interactivity in the chats.
-- SMP protocol improvements:
-  - SMP queue redundancy and rotation.
-  - Message delivery confirmation.
-  - Supporting the same profile on multiple devices.
+- Programmable chat automations / rules (automatic replies/forward/deletion/sending, reminders, etc.).
 - 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.
+- High capacity multi-node SMP relays.
 
-## Disclaimer
+## Disclaimers
 
-[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed and had many improvements in v1.0.0; we are currently arranging for the independent implementation audit.
+[SimpleX protocols and security model](https://github.com/simplex-chat/simplexmq/blob/master/protocol/overview-tjr.md) was reviewed, and had many breaking changes and improvements in v1.0.0.
 
-You are likely to discover some bugs - we would really appreciate if you use it and let us know anything that needs to be fixed or improved.
+The security audit was performed in October 2022 by [Trail of Bits](https://www.trailofbits.com/about), and most fixes were released in v4.2.0 – see [the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
+
+SimpleX Chat is still a relatively early stage platform (the mobile apps were released in March 2022), so you may discover some bugs and missing features. We would really appreciate if you let us know anything that needs to be fixed or improved.
+
+The default servers configured in the app are provided on the best effort basis. We are currently not guaranteeing any SLAs, although historically our servers had over 99.9% uptime each.
+
+We have never provided or have been requested access to our servers or any information from our servers by any third parties. If we are ever requested to provide such access or information, we will be following due legal process.
+
+We do not log IP addresses of the users and we do not perform any traffic correlation on our servers. If transport level security is critical you must use Tor or some other similar network to access messaging servers. We will be improving the client applications to reduce the opportunities for traffic correlation.
+
+Please read more in [Terms & privacy policy](./PRIVACY.md).
+
+## Security contact
+
+To report a security vulnerability, please send us email to chat@simplex.chat. We will coordinate the fix and disclosure. Please do NOT report security vulnerabilities via GitHub issues.
+
+Please treat any findings of possible traffic correlation attacks allowing to correlate two different conversations to the same user, other than covered in [the threat model](https://github.com/simplex-chat/simplexmq/blob/stable/protocol/overview-tjr.md#threat-model), as security vulnerabilities, and follow this disclosure process.
 
 ## License
 
@@ -176,4 +422,4 @@ You are likely to discover some bugs - we would really appreciate if you use it
 &nbsp;
 [<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/testflight.png" alt="iOS TestFlight" height="41">](https://testflight.apple.com/join/DWuT2LQu)
 &nbsp;
-[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/website/raw/master/simplex.apk)
+[<img src="https://github.com/simplex-chat/.github/blob/master/profile/images/apk_icon.png" alt="APK" height="41">](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk)

apps/android/.gitignore

@@ -1,17 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-/.idea/deploymentTargetDropDown.xml
-/.idea/misc.xml
-.DS_Store
-/build
-/captures
-.externalNativeBuild
-.cxx
-local.properties

apps/android/.idea/.name

@@ -1 +0,0 @@
-SimpleX

apps/android/.idea/compiler.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="11" />
-  </component>
-</project>

apps/android/.idea/gradle.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="GradleMigrationSettings" migrationVersion="1" />
-  <component name="GradleSettings">
-    <option name="linkedExternalProjectsSettings">
-      <GradleProjectSettings>
-        <option name="testRunner" value="GRADLE" />
-        <option name="distributionType" value="DEFAULT_WRAPPED" />
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-            <option value="$PROJECT_DIR$/app" />
-          </set>
-        </option>
-      </GradleProjectSettings>
-    </option>
-  </component>
-</project>

apps/android/.idea/inspectionProfiles/Project_Default.xml

@@ -1,20 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="PreviewAnnotationInFunctionWithParameters" enabled="true" level="ERROR" enabled_by_default="true">
-      <option name="previewFile" value="true" />
-    </inspection_tool>
-    <inspection_tool class="PreviewDimensionRespectsLimit" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="previewFile" value="true" />
-    </inspection_tool>
-    <inspection_tool class="PreviewMultipleParameterProviders" enabled="true" level="ERROR" enabled_by_default="true">
-      <option name="previewFile" value="true" />
-    </inspection_tool>
-    <inspection_tool class="PreviewMustBeTopLevelFunction" enabled="true" level="ERROR" enabled_by_default="true">
-      <option name="previewFile" value="true" />
-    </inspection_tool>
-    <inspection_tool class="PreviewNeedsComposableAnnotation" enabled="true" level="ERROR" enabled_by_default="true">
-      <option name="previewFile" value="true" />
-    </inspection_tool>
-  </profile>
-</component>

apps/android/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/../.." vcs="Git" />
-  </component>
-</project>

apps/android/app/build.gradle

@@ -1,115 +0,0 @@
-plugins {
-    id 'com.android.application'
-    id 'org.jetbrains.kotlin.android'
-    id 'org.jetbrains.kotlin.plugin.serialization'
-}
-
-android {
-    compileSdk 32
-
-    defaultConfig {
-        applicationId "chat.simplex.app"
-        minSdk 29
-        targetSdk 32
-        versionCode 36
-        versionName "2.2"
-
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        ndk {
-            abiFilters 'arm64-v8a'
-        }
-        vectorDrawables {
-            useSupportLibrary true
-        }
-        externalNativeBuild {
-            cmake {
-                cppFlags ''
-            }
-        }
-    }
-
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-    }
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
-    }
-    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 {
-            path file('src/main/cpp/CMakeLists.txt')
-            version '3.10.2'
-        }
-    }
-    buildFeatures {
-        compose true
-    }
-    composeOptions {
-        kotlinCompilerExtensionVersion compose_version
-    }
-    packagingOptions {
-        resources {
-            excludes += '/META-INF/{AL2.0,LGPL2.1}'
-        }
-    }
-}
-
-dependencies {
-    implementation 'androidx.core:core-ktx:1.7.0'
-    implementation "androidx.compose.ui:ui:$compose_version"
-    implementation "androidx.compose.material:material:$compose_version"
-    implementation "androidx.compose.ui:ui-tooling-preview:$compose_version"
-    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.4.1'
-    implementation 'androidx.lifecycle:lifecycle-process:2.4.1'
-    implementation 'androidx.activity:activity-compose:1.4.0'
-    implementation 'androidx.fragment:fragment:1.4.1'
-    implementation 'org.jetbrains.kotlinx:kotlinx-datetime:0.3.2'
-    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2'
-    implementation "androidx.compose.material:material-icons-extended:$compose_version"
-    implementation "androidx.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"
-    implementation "androidx.work:work-multiprocess:$work_version"
-
-    def camerax_version = "1.1.0-beta01"
-    implementation "androidx.camera:camera-core:${camerax_version}"
-    implementation "androidx.camera:camera-camera2:${camerax_version}"
-    implementation "androidx.camera:camera-lifecycle:${camerax_version}"
-    implementation "androidx.camera:camera-view:${camerax_version}"
-
-    //Barcode
-    implementation 'org.boofcv:boofcv-android:0.40.1'
-    implementation 'org.boofcv:boofcv-core:0.40.1'
-
-    //Camera Permission
-    implementation "com.google.accompanist:accompanist-permissions:0.23.0"
-
-    // Link Previews
-    implementation 'org.jsoup:jsoup:1.13.1'
-
-    // Biometric authentication
-    implementation 'androidx.biometric:biometric:1.2.0-alpha04'
-
-    testImplementation 'junit:junit:4.13.2'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
-    androidTestImplementation "androidx.compose.ui:ui-test-junit4:$compose_version"
-    debugImplementation "androidx.compose.ui:ui-tooling:$compose_version"
-}

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

@@ -1,50 +0,0 @@
-#include <jni.h>
-
-// from the RTS
-void hs_init(int * argc, char **argv[]);
-
-// from android-support
-void setLineBuffering(void);
-int pipe_std_to_socket(const char * name);
-
-JNIEXPORT jint JNICALL
-Java_chat_simplex_app_SimplexAppKt_pipeStdOutToSocket(JNIEnv *env, __unused jclass clazz, jstring socket_name) {
-    const char *name = (*env)->GetStringUTFChars(env, socket_name, JNI_FALSE);
-    int ret = pipe_std_to_socket(name);
-    (*env)->ReleaseStringUTFChars(env, socket_name, name);
-    return ret;
-}
-
-JNIEXPORT void JNICALL
-Java_chat_simplex_app_SimplexAppKt_initHS(__unused JNIEnv *env, __unused jclass clazz) {
-    hs_init(NULL, NULL);
-    setLineBuffering();
-}
-
-// from simplex-chat
-typedef void* chat_ctrl;
-
-extern chat_ctrl chat_init(const char * path);
-extern char *chat_send_cmd(chat_ctrl ctrl, const char *cmd);
-extern char *chat_recv_msg(chat_ctrl ctrl);
-
-JNIEXPORT jlong JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatInit(JNIEnv *env, __unused jclass clazz, jstring datadir) {
-    const char *_data = (*env)->GetStringUTFChars(env, datadir, JNI_FALSE);
-    jlong res = (jlong)chat_init(_data);
-    (*env)->ReleaseStringUTFChars(env, datadir, _data);
-    return res;
-}
-
-JNIEXPORT jstring JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatSendCmd(JNIEnv *env, __unused jclass clazz, jlong controller, jstring msg) {
-    const char *_msg = (*env)->GetStringUTFChars(env, msg, JNI_FALSE);
-    jstring res = (*env)->NewStringUTF(env, chat_send_cmd((void*)controller, _msg));
-    (*env)->ReleaseStringUTFChars(env, msg, _msg);
-    return res;
-}
-
-JNIEXPORT jstring JNICALL
-Java_chat_simplex_app_SimplexAppKt_chatRecvMsg(JNIEnv *env, __unused jclass clazz, jlong controller) {
-    return (*env)->NewStringUTF(env, chat_recv_msg((void*)controller));
-}

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

@@ -1,400 +0,0 @@
-package chat.simplex.app
-
-import android.app.Application
-import android.content.Intent
-import android.net.Uri
-import android.os.Bundle
-import android.os.SystemClock.elapsedRealtime
-import android.util.Log
-import androidx.activity.compose.setContent
-import androidx.activity.viewModels
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Replay
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.fragment.app.FragmentActivity
-import androidx.lifecycle.*
-import androidx.work.*
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.model.NtfManager
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.SplashView
-import chat.simplex.app.views.call.ActiveCallView
-import chat.simplex.app.views.call.IncomingCallAlertView
-import chat.simplex.app.views.chat.ChatView
-import chat.simplex.app.views.chatlist.ChatListView
-import chat.simplex.app.views.chatlist.openChat
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.connectViaUri
-import chat.simplex.app.views.newchat.withUriAction
-import chat.simplex.app.views.onboarding.*
-import kotlinx.coroutines.delay
-import java.util.concurrent.TimeUnit
-
-class MainActivity: FragmentActivity(), LifecycleEventObserver {
-  private val vm by viewModels<SimplexViewModel>()
-  private val chatController by lazy { (application as SimplexApp).chatController }
-  private val userAuthorized = mutableStateOf<Boolean?>(null)
-  private val enteredBackground = mutableStateOf<Long?>(null)
-  private val laFailed = mutableStateOf(false)
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
-    // testJson()
-    val m = vm.chatModel
-    processNotificationIntent(intent, m)
-    setContent {
-      SimpleXTheme {
-        Surface(
-          Modifier
-            .background(MaterialTheme.colors.background)
-            .fillMaxSize()
-        ) {
-          MainPage(
-            m,
-            userAuthorized,
-            laFailed,
-            ::runAuthenticate,
-            ::setPerformLA,
-            showLANotice = { m.controller.showLANotice(this) }
-          )
-        }
-      }
-    }
-    schedulePeriodicServiceRestartWorker()
-  }
-
-  override fun onNewIntent(intent: Intent?) {
-    super.onNewIntent(intent)
-    processIntent(intent, vm.chatModel)
-  }
-
-  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
-    withApi {
-      when (event) {
-        Lifecycle.Event.ON_STOP -> {
-          enteredBackground.value = elapsedRealtime()
-        }
-        Lifecycle.Event.ON_START -> {
-          val enteredBackgroundVal = enteredBackground.value
-          if (enteredBackgroundVal == null || elapsedRealtime() - enteredBackgroundVal >= 30 * 1e+3) {
-            runAuthenticate()
-          }
-        }
-      }
-    }
-  }
-
-  private fun runAuthenticate() {
-    val m = vm.chatModel
-    if (!m.controller.appPrefs.performLA.get()) {
-      userAuthorized.value = true
-    } else {
-      userAuthorized.value = false
-      ModalManager.shared.closeModals()
-      authenticate(
-        generalGetString(R.string.auth_unlock),
-        generalGetString(R.string.auth_log_in_using_credential),
-        this@MainActivity,
-        completed = { laResult ->
-          when (laResult) {
-            LAResult.Success -> {
-              userAuthorized.value = true
-            }
-            is LAResult.Error -> {
-              laFailed.value = true
-              laErrorToast(applicationContext, laResult.errString)
-            }
-            LAResult.Failed -> {
-              laFailed.value = true
-              laFailedToast(applicationContext)
-            }
-            LAResult.Unavailable -> {
-              userAuthorized.value = true
-              m.performLA.value = false
-              m.controller.appPrefs.performLA.set(false)
-              laUnavailableTurningOffAlert()
-            }
-          }
-        }
-      )
-    }
-  }
-
-  private fun schedulePeriodicServiceRestartWorker() {
-    val workerVersion = chatController.appPrefs.autoRestartWorkerVersion.get()
-    val workPolicy = if (workerVersion == SimplexService.SERVICE_START_WORKER_VERSION) {
-      Log.d(TAG, "ServiceStartWorker version matches: choosing KEEP as existing work policy")
-      ExistingPeriodicWorkPolicy.KEEP
-    } else {
-      Log.d(TAG, "ServiceStartWorker version DOES NOT MATCH: choosing REPLACE as existing work policy")
-      chatController.appPrefs.autoRestartWorkerVersion.set(SimplexService.SERVICE_START_WORKER_VERSION)
-      ExistingPeriodicWorkPolicy.REPLACE
-    }
-    val work = PeriodicWorkRequestBuilder<SimplexService.ServiceStartWorker>(SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES, TimeUnit.MINUTES)
-      .addTag(SimplexService.TAG)
-      .addTag(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC)
-      .build()
-    Log.d(TAG, "ServiceStartWorker: Scheduling period work every ${SimplexService.SERVICE_START_WORKER_INTERVAL_MINUTES} minutes")
-    WorkManager.getInstance(this)?.enqueueUniquePeriodicWork(SimplexService.SERVICE_START_WORKER_WORK_NAME_PERIODIC, workPolicy, work)
-  }
-
-  private fun setPerformLA(on: Boolean) {
-    vm.chatModel.controller.appPrefs.laNoticeShown.set(true)
-    if (on) {
-      enableLA()
-    } else {
-      disableLA()
-    }
-  }
-
-  private fun enableLA() {
-    val m = vm.chatModel
-    authenticate(
-      generalGetString(R.string.auth_enable_simplex_lock),
-      generalGetString(R.string.auth_confirm_credential),
-      this@MainActivity,
-      completed = { laResult ->
-        val prefPerformLA = m.controller.appPrefs.performLA
-        when (laResult) {
-          LAResult.Success -> {
-            m.performLA.value = true
-            prefPerformLA.set(true)
-            laTurnedOnAlert()
-          }
-          is LAResult.Error -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-            laErrorToast(applicationContext, laResult.errString)
-          }
-          LAResult.Failed -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-            laFailedToast(applicationContext)
-          }
-          LAResult.Unavailable -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-            laUnavailableInstructionAlert()
-          }
-        }
-      }
-    )
-  }
-
-  private fun disableLA() {
-    val m = vm.chatModel
-    authenticate(
-      generalGetString(R.string.auth_disable_simplex_lock),
-      generalGetString(R.string.auth_confirm_credential),
-      this@MainActivity,
-      completed = { laResult ->
-        val prefPerformLA = m.controller.appPrefs.performLA
-        when (laResult) {
-          LAResult.Success -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-          }
-          is LAResult.Error -> {
-            m.performLA.value = true
-            prefPerformLA.set(true)
-            laErrorToast(applicationContext, laResult.errString)
-          }
-          LAResult.Failed -> {
-            m.performLA.value = true
-            prefPerformLA.set(true)
-            laFailedToast(applicationContext)
-          }
-          LAResult.Unavailable -> {
-            m.performLA.value = false
-            prefPerformLA.set(false)
-            laUnavailableTurningOffAlert()
-          }
-        }
-      }
-    )
-  }
-}
-
-class SimplexViewModel(application: Application): AndroidViewModel(application) {
-  val app = getApplication<SimplexApp>()
-  val chatModel = app.chatModel
-}
-
-@Composable
-fun MainPage(
-  chatModel: ChatModel,
-  userAuthorized: MutableState<Boolean?>,
-  laFailed: MutableState<Boolean>,
-  runAuthenticate: () -> Unit,
-  setPerformLA: (Boolean) -> Unit,
-  showLANotice: () -> Unit
-) {
-  // this with LaunchedEffect(userAuthorized.value) fixes bottom sheet visibly collapsing after authentication
-  var chatsAccessAuthorized by remember { mutableStateOf(false) }
-  LaunchedEffect(userAuthorized.value) {
-    if (chatModel.controller.appPrefs.performLA.get()) {
-      delay(500L)
-    }
-    chatsAccessAuthorized = userAuthorized.value == true
-  }
-  var showAdvertiseLAAlert by remember { mutableStateOf(false) }
-  LaunchedEffect(showAdvertiseLAAlert) {
-    if (
-      !chatModel.controller.appPrefs.laNoticeShown.get()
-      && showAdvertiseLAAlert
-      && chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete
-      && chatModel.chats.isNotEmpty()
-      && chatModel.activeCallInvitation.value == null
-    ) {
-      showLANotice()
-    }
-  }
-  LaunchedEffect(chatModel.showAdvertiseLAUnavailableAlert.value) {
-    if (chatModel.showAdvertiseLAUnavailableAlert.value) {
-      laUnavailableInstructionAlert()
-    }
-  }
-  LaunchedEffect(chatModel.clearOverlays.value) {
-    if (chatModel.clearOverlays.value) {
-      ModalManager.shared.closeModals()
-      chatModel.clearOverlays.value = false
-    }
-  }
-
-  @Composable
-  fun retryAuthView() {
-    Box(
-      Modifier.fillMaxSize(),
-      contentAlignment = Alignment.Center
-    ) {
-      SimpleButton(
-        stringResource(R.string.auth_retry),
-        icon = Icons.Outlined.Replay,
-        click = {
-          laFailed.value = false
-          runAuthenticate()
-        }
-      )
-    }
-  }
-
-  Box {
-    val onboarding = chatModel.onboardingStage.value
-    val userCreated = chatModel.userCreated.value
-    when {
-      onboarding == null || userCreated == null -> SplashView()
-      !chatsAccessAuthorized -> {
-        if (chatModel.controller.appPrefs.performLA.get() && laFailed.value) {
-          retryAuthView()
-        } else {
-          SplashView()
-        }
-      }
-      onboarding == OnboardingStage.OnboardingComplete && userCreated -> {
-        Box {
-          if (chatModel.showCallView.value) ActiveCallView(chatModel)
-          else {
-            showAdvertiseLAAlert = true
-            if (chatModel.chatId.value == null) ChatListView(chatModel, setPerformLA = { setPerformLA(it) })
-            else ChatView(chatModel)
-          }
-        }
-      }
-      onboarding == OnboardingStage.Step1_SimpleXInfo ->
-        Box(Modifier.padding(horizontal = 20.dp)) {
-          SimpleXInfo(chatModel, onboarding = true)
-        }
-      onboarding == OnboardingStage.Step2_CreateProfile -> CreateProfile(chatModel)
-    }
-    ModalManager.shared.showInView()
-    val invitation = chatModel.activeCallInvitation.value
-    if (invitation != null) IncomingCallAlertView(invitation, chatModel)
-    AlertManager.shared.showInView()
-  }
-}
-
-fun processNotificationIntent(intent: Intent?, chatModel: ChatModel) {
-  when (intent?.action) {
-    NtfManager.OpenChatAction -> {
-      val chatId = intent.getStringExtra("chatId")
-      Log.d(TAG, "processNotificationIntent: OpenChatAction $chatId")
-      if (chatId != null) {
-        val cInfo = chatModel.getChat(chatId)?.chatInfo
-        chatModel.clearOverlays.value = true
-        if (cInfo != null) withApi { openChat(cInfo, chatModel) }
-      }
-    }
-    NtfManager.ShowChatsAction -> {
-      Log.d(TAG, "processNotificationIntent: ShowChatsAction")
-      chatModel.chatId.value = null
-      chatModel.clearOverlays.value = true
-    }
-    NtfManager.AcceptCallAction -> {
-      val chatId = intent.getStringExtra("chatId")
-      if (chatId == null || chatId == "") return
-      Log.d(TAG, "processNotificationIntent: AcceptCallAction $chatId")
-      chatModel.clearOverlays.value = true
-      val invitation = chatModel.callInvitations[chatId]
-      if (invitation == null) {
-        AlertManager.shared.showAlertMsg(generalGetString(R.string.call_already_ended))
-      } else {
-        chatModel.callManager.acceptIncomingCall(invitation = invitation)
-      }
-    }
-  }
-}
-
-fun processIntent(intent: Intent?, chatModel: ChatModel) {
-  when (intent?.action) {
-    "android.intent.action.VIEW" -> {
-      val uri = intent.data
-      if (uri != null) connectIfOpenedViaUri(uri, chatModel)
-    }
-  }
-}
-
-fun connectIfOpenedViaUri(uri: Uri, chatModel: ChatModel) {
-  Log.d(TAG, "connectIfOpenedViaUri: opened via link")
-  if (chatModel.currentUser.value == null) {
-    // TODO open from chat list view
-    chatModel.appOpenUrl.value = uri
-  } else {
-    withUriAction(uri) { action ->
-      val title = when (action) {
-        "contact" -> generalGetString(R.string.connect_via_contact_link)
-        "invitation" -> generalGetString(R.string.connect_via_invitation_link)
-        else -> {
-          Log.e(TAG, "URI has unexpected action. Alert shown.")
-          action
-        }
-      }
-      AlertManager.shared.showAlertMsg(
-        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")
-            connectViaUri(chatModel, action, uri)
-          }
-        }
-      )
-    }
-  }
-}
-//fun testJson() {
-//  val str: String = """
-//  """.trimIndent()
-//
-//  println(json.decodeFromString<APIResponse>(str))
-//}

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

@@ -1,122 +0,0 @@
-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.*
-import java.util.concurrent.Semaphore
-import kotlin.concurrent.thread
-
-const val TAG = "SIMPLEX"
-
-// ghc's rts
-external fun initHS()
-// android-support
-external fun pipeStdOutToSocket(socketName: String) : Int
-
-// SimpleX API
-typealias ChatCtrl = Long
-external fun chatInit(path: String): ChatCtrl
-external fun chatSendCmd(ctrl: ChatCtrl, msg: String) : String
-external fun chatRecvMsg(ctrl: ChatCtrl) : String
-
-class SimplexApp: Application(), LifecycleEventObserver {
-  val chatController: ChatController by lazy {
-    val ctrl = chatInit(getFilesDirectory(applicationContext))
-    ChatController(ctrl, ntfManager, applicationContext, appPreferences)
-  }
-
-  val chatModel: ChatModel by lazy {
-    chatController.chatModel
-  }
-
-  private val ntfManager: NtfManager by lazy {
-    NtfManager(applicationContext, appPreferences)
-  }
-
-  private val appPreferences: AppPreferences by lazy {
-    AppPreferences(applicationContext)
-  }
-
-  override fun onCreate() {
-    super.onCreate()
-    context = this
-    ProcessLifecycleOwner.get().lifecycle.addObserver(this)
-    withApi {
-      val user = chatController.apiGetActiveUser()
-      if (user == null) {
-        chatModel.onboardingStage.value = OnboardingStage.Step1_SimpleXInfo
-      } else {
-        chatController.startChat(user)
-        SimplexService.start(applicationContext)
-        chatController.showBackgroundServiceNoticeIfNeeded()
-      }
-    }
-  }
-
-  override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
-    Log.d(TAG, "onStateChanged: $event")
-    withApi {
-      when (event) {
-        Lifecycle.Event.ON_STOP ->
-          if (!appPreferences.runServiceInBackground.get()) SimplexService.stop(applicationContext)
-        Lifecycle.Event.ON_START ->
-          SimplexService.start(applicationContext)
-        Lifecycle.Event.ON_RESUME ->
-          if (chatModel.onboardingStage.value == OnboardingStage.OnboardingComplete) {
-            chatController.showBackgroundServiceNoticeIfNeeded()
-          }
-      }
-    }
-  }
-
-  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")
-        val server = LocalServerSocket(socketName)
-        Log.d(TAG, "started server")
-        s.release()
-        val receiver = server.accept()
-        Log.d(TAG, "started receiver")
-        val logbuffer = FifoQueue<String>(500)
-        if (receiver != null) {
-          val inStream = receiver.inputStream
-          val inStreamReader = InputStreamReader(inStream)
-          val input = BufferedReader(inStreamReader)
-
-          while (true) {
-            val line = input.readLine() ?: break
-            Log.w("$TAG (stdout/stderr)", line)
-            logbuffer.add(line)
-          }
-        }
-      }
-
-      System.loadLibrary("app-lib")
-
-      s.acquire()
-      pipeStdOutToSocket(socketName)
-
-      initHS()
-    }
-  }
-}
-
-class FifoQueue<E>(private var capacity: Int) : LinkedList<E>() {
-  override fun add(element: E): Boolean {
-    if(size > capacity) removeFirst()
-    return super.add(element)
-  }
-}

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

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

@@ -1,180 +0,0 @@
-package chat.simplex.app.model
-
-import android.app.*
-import android.content.*
-import android.graphics.BitmapFactory
-import android.media.AudioAttributes
-import android.net.Uri
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import chat.simplex.app.*
-import chat.simplex.app.views.call.*
-import chat.simplex.app.views.helpers.base64ToBitmap
-import chat.simplex.app.views.helpers.generalGetString
-import kotlinx.datetime.Clock
-
-class NtfManager(val context: Context, private val appPreferences: AppPreferences) {
-  companion object {
-    const val MessageChannel: String = "chat.simplex.app.MESSAGE_NOTIFICATION"
-    const val MessageGroup: String = "chat.simplex.app.MESSAGE_NOTIFICATION"
-    const val OpenChatAction: String = "chat.simplex.app.OPEN_CHAT"
-    const val ShowChatsAction: String = "chat.simplex.app.SHOW_CHATS"
-
-    // DO NOT change notification channel settings / names
-    const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION"
-    const val LockScreenCallChannel: String = "chat.simplex.app.LOCK_SCREEN_CALL_NOTIFICATION"
-    const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
-    const val CallNotificationId: Int = -1
-  }
-
-  private val manager: NotificationManager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-  private var prevNtfTime = mutableMapOf<String, Long>()
-  private val msgNtfTimeoutMs = 30000L
-
-  init {
-    manager.createNotificationChannel(NotificationChannel(MessageChannel, "SimpleX Chat messages", NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(NotificationChannel(LockScreenCallChannel, "SimpleX Chat calls (lock screen)", NotificationManager.IMPORTANCE_HIGH))
-    manager.createNotificationChannel(callNotificationChannel())
-  }
-
-  private fun callNotificationChannel(): NotificationChannel {
-    val callChannel = NotificationChannel(CallChannel, "SimpleX Chat calls", NotificationManager.IMPORTANCE_HIGH)
-    val attrs = AudioAttributes.Builder()
-      .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
-      .setUsage(AudioAttributes.USAGE_NOTIFICATION)
-      .build()
-    val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
-    Log.d(TAG,"callNotificationChannel sound: $soundUri")
-    callChannel.setSound(soundUri, attrs)
-    callChannel.enableVibration(true)
-    return callChannel
-  }
-
-  fun cancelNotificationsForChat(chatId: String) {
-    prevNtfTime.remove(chatId)
-    manager.cancel(chatId.hashCode())
-    val msgNtfs = manager.activeNotifications.filter {
-      ntf -> ntf.notification.channelId == MessageChannel
-    }
-    if (msgNtfs.count() == 1) {
-      // Have a group notification with no children so cancel it
-      manager.cancel(0)
-    }
-  }
-
-  fun notifyMessageReceived(cInfo: ChatInfo, cItem: ChatItem) {
-    notifyMessageReceived(chatId = cInfo.id, displayName = cInfo.displayName, msgText = hideSecrets(cItem))
-  }
-
-  fun notifyMessageReceived(chatId: String, displayName: String, msgText: String) {
-    Log.d(TAG, "notifyMessageReceived $chatId")
-    val now = Clock.System.now().toEpochMilliseconds()
-    val recentNotification = (now - prevNtfTime.getOrDefault(chatId, 0) < msgNtfTimeoutMs)
-    prevNtfTime[chatId] = now
-
-    val notification = NotificationCompat.Builder(context, MessageChannel)
-      .setContentTitle(displayName)
-      .setContentText(msgText)
-      .setPriority(NotificationCompat.PRIORITY_HIGH)
-      .setGroup(MessageGroup)
-      .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
-      .setSmallIcon(R.drawable.ntf_icon)
-      .setColor(0x88FFFF)
-      .setAutoCancel(true)
-      .setContentIntent(chatPendingIntent(OpenChatAction, chatId))
-      .setSilent(recentNotification)
-      .build()
-
-    val summary = NotificationCompat.Builder(context, MessageChannel)
-      .setSmallIcon(R.drawable.ntf_icon)
-      .setColor(0x88FFFF)
-      .setGroup(MessageGroup)
-      .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
-      .setGroupSummary(true)
-      .setContentIntent(chatPendingIntent(ShowChatsAction))
-      .build()
-
-    with(NotificationManagerCompat.from(context)) {
-      // using cInfo.id only shows one notification per chat and updates it when the message arrives
-      notify(chatId.hashCode(), notification)
-      notify(0, summary)
-    }
-  }
-
-  fun notifyCallInvitation(invitation: CallInvitation) {
-    if (isAppOnForeground(context)) return
-    val contactId = invitation.contact.id
-    Log.d(TAG, "notifyCallInvitation $contactId")
-    val keyguardManager = getKeyguardManager(context)
-    val image = invitation.contact.image
-    var ntfBuilder =
-      if (keyguardManager.isDeviceLocked && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
-        val fullScreenIntent = Intent(context, IncomingCallActivity::class.java)
-        val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        NotificationCompat.Builder(context, LockScreenCallChannel)
-          .setFullScreenIntent(fullScreenPendingIntent, true)
-          .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-          .setSilent(true)
-      } else {
-        val soundUri = Uri.parse(ContentResolver.SCHEME_ANDROID_RESOURCE + "://" + context.packageName + "/" + R.raw.ring_once)
-        NotificationCompat.Builder(context, CallChannel)
-          .setContentIntent(chatPendingIntent(OpenChatAction, invitation.contact.id))
-          .addAction(R.drawable.ntf_icon, generalGetString(R.string.accept), chatPendingIntent(AcceptCallAction, contactId))
-          .setSound(soundUri)
-      }
-    val text = generalGetString(
-      if (invitation.peerMedia == CallMediaType.Video) {
-        if (invitation.sharedKey == null) R.string.video_call_no_encryption else R.string.encrypted_video_call
-      } else {
-        if (invitation.sharedKey == null) R.string.audio_call_no_encryption else R.string.encrypted_audio_call
-      }
-    )
-    ntfBuilder = ntfBuilder
-      .setContentTitle(invitation.contact.displayName)
-      .setContentText(text)
-      .setPriority(NotificationCompat.PRIORITY_HIGH)
-      .setCategory(NotificationCompat.CATEGORY_CALL)
-      .setSmallIcon(R.drawable.ntf_icon)
-      .setLargeIcon(if (image == null) BitmapFactory.decodeResource(context.resources, R.drawable.icon) else base64ToBitmap(image))
-      .setColor(0x88FFFF)
-      .setAutoCancel(true)
-    with(NotificationManagerCompat.from(context)) {
-      notify(CallNotificationId, ntfBuilder.build())
-    }
-  }
-
-  fun cancelCallNotification() {
-    manager.cancel(CallNotificationId)
-  }
-
-  private fun hideSecrets(cItem: ChatItem) : String {
-    val md = cItem.formattedText
-    return if (md == null) {
-      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 chatPendingIntent(intentAction: String, chatId: String? = null): PendingIntent {
-    Log.d(TAG, "chatPendingIntent for $intentAction")
-    val uniqueInt = (System.currentTimeMillis() and 0xfffffff).toInt()
-    var intent = Intent(context, MainActivity::class.java)
-      .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-      .setAction(intentAction)
-    if (chatId != null) intent = intent.putExtra("chatId", chatId)
-    return TaskStackBuilder.create(context).run {
-      addNextIntentWithParentStack(intent)
-      getPendingIntent(uniqueInt, PendingIntent.FLAG_IMMUTABLE)
-    }
-  }
-}

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

@@ -1,47 +0,0 @@
-package chat.simplex.app.ui.theme
-
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.graphics.Color
-
-private val DarkColorPalette = darkColors(
-  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
-  primaryVariant = SimplexGreen,
-  secondary = DarkGray,
-//  background = Color.Black,
-//  surface = Color.Black,
-//  background = Color(0xFF121212),
-//  surface = Color(0xFF121212),
-//  error = Color(0xFFCF6679),
-  onBackground = Color(0xFFFFFBFA),
-  onSurface = Color(0xFFFFFBFA),
-//  onError: Color = Color.Black,
-)
-private val LightColorPalette = lightColors(
-  primary = SimplexBlue,  // If this value changes also need to update #0088ff in string resource files
-  primaryVariant = SimplexGreen,
-  secondary = LightGray,
-//  background = Color.White,
-//  surface = Color.White
-//  onPrimary = Color.White,
-//  onSecondary = Color.Black,
-//  onBackground = Color.Black,
-//  onSurface = Color.Black,
-)
-
-@Composable
-fun SimpleXTheme(darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
-  val colors = if (darkTheme) {
-    DarkColorPalette
-  } else {
-    LightColorPalette
-  }
-
-  MaterialTheme(
-    colors = colors,
-    typography = Typography,
-    shapes = Shapes,
-    content = content
-  )
-}

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

@@ -1,128 +0,0 @@
-package chat.simplex.app.views
-
-import android.content.res.Configuration
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.*
-import androidx.compose.foundation.text.selection.SelectionContainer
-import androidx.compose.material.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import 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.*
-import com.google.accompanist.insets.ProvideWindowInsets
-import com.google.accompanist.insets.navigationBarsWithImePadding
-import kotlinx.coroutines.launch
-
-@Composable
-fun TerminalView(chatModel: ChatModel, close: () -> Unit) {
-  val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) }
-  BackHandler(onBack = close)
-  TerminalLayout(
-    chatModel.terminalItems,
-    composeState,
-    sendCommand = {
-      withApi {
-        // show "in progress"
-        chatModel.controller.sendCmd(CC.Console(composeState.value.message))
-        composeState.value = ComposeState(useLinkPreviews = false)
-        // hide "in progress"
-      }
-    },
-    close
-  )
-}
-
-@Composable
-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 = {
-        Box(Modifier.padding(horizontal = 8.dp)) {
-          SendMsgView(composeState, sendCommand, ::onMessageChange, textStyle)
-        }
-      },
-      modifier = Modifier.navigationBarsWithImePadding()
-    ) { contentPadding ->
-      Surface(
-        modifier = Modifier
-          .padding(contentPadding)
-          .fillMaxWidth()
-          .background(MaterialTheme.colors.background)
-      ) {
-        TerminalLog(terminalItems)
-      }
-    }
-  }
-}
-
-@Composable
-fun TerminalLog(terminalItems: List<TerminalItem>) {
-  val listState = rememberLazyListState()
-  val scope = rememberCoroutineScope()
-  LazyColumn(state = listState) {
-    items(terminalItems) { item ->
-      Text("${item.date.toString().subSequence(11, 19)} ${item.label}",
-        style = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 18.sp, color = MaterialTheme.colors.primary),
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-        modifier = Modifier
-          .padding(horizontal = 8.dp, vertical = 4.dp)
-          .clickable {
-            ModalManager.shared.showModal {
-              SelectionContainer(modifier = Modifier.verticalScroll(rememberScrollState())) {
-                Text(item.details)
-              }
-            }
-          }
-      )
-    }
-    val len = terminalItems.count()
-    if (len > 1) {
-      scope.launch {
-        listState.animateScrollToItem(len - 1)
-      }
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewTerminalLayout() {
-  SimpleXTheme {
-    TerminalLayout(
-      terminalItems = TerminalItem.sampleData,
-      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = false)) },
-      sendCommand = {},
-      close = {}
-    )
-  }
-}

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

@@ -1,144 +0,0 @@
-package chat.simplex.app.views
-
-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.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 chat.simplex.app.views.onboarding.OnboardingStage
-import chat.simplex.app.views.onboarding.ReadableText
-import com.google.accompanist.insets.navigationBarsWithImePadding
-
-fun isValidDisplayName(name: String) : Boolean {
-  return (name.firstOrNull { it.isWhitespace() }) == null
-}
-
-@Composable
-fun CreateProfilePanel(chatModel: ChatModel) {
-  val displayName = remember { mutableStateOf("") }
-  val fullName = remember { mutableStateOf("") }
-  val focusRequester = remember { FocusRequester() }
-
-  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 }
-
-        Spacer(Modifier.fillMaxWidth().weight(1f))
-
-        val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
-        val createModifier: Modifier
-        val createColor: Color
-        if (enabled) {
-          createModifier = Modifier.clickable { createProfile(chatModel, displayName.value, fullName.value) }.padding(8.dp)
-          createColor = MaterialTheme.colors.primary
-        } else {
-          createModifier = Modifier.padding(8.dp)
-          createColor = HighOrLowlight
-        }
-        Surface(shape = RoundedCornerShape(20.dp)) {
-          Row(verticalAlignment = Alignment.CenterVertically, modifier = createModifier) {
-            Text(stringResource(R.string.create_profile_button), style = MaterialTheme.typography.caption, color = createColor)
-            Icon(Icons.Outlined.ArrowForwardIos, stringResource(R.string.create_profile_button), tint = createColor)
-          }
-        }
-      }
-
-      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)
-    chatModel.controller.showBackgroundServiceNoticeIfNeeded()
-    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

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

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

@@ -1,108 +0,0 @@
-package chat.simplex.app.views.call
-
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.scale
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.model.Contact
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.usersettings.ProfilePreview
-import kotlinx.datetime.Clock
-
-@Composable
-fun IncomingCallAlertView(invitation: CallInvitation, chatModel: ChatModel) {
-  val cm = chatModel.callManager
-  val cxt = LocalContext.current
-  val scope = rememberCoroutineScope()
-  LaunchedEffect(true) { SoundPlayer.shared.start(cxt, scope, sound = !chatModel.showCallView.value) }
-  DisposableEffect(true) { onDispose { SoundPlayer.shared.stop() } }
-  IncomingCallAlertLayout(
-    invitation,
-    rejectCall = { cm.endCall(invitation = invitation) },
-    ignoreCall = { chatModel.activeCallInvitation.value = null },
-    acceptCall = { cm.acceptIncomingCall(invitation = invitation) }
-  )
-}
-
-@Composable
-fun IncomingCallAlertLayout(
-  invitation: CallInvitation,
-  rejectCall: () -> Unit,
-  ignoreCall: () -> Unit,
-  acceptCall: () -> Unit
-) {
-  val color = if (isSystemInDarkTheme()) IncomingCallDark else IncomingCallLight
-  Column(Modifier.background(color).padding(top = 16.dp, bottom = 16.dp, start = 16.dp, end = 8.dp)) {
-    IncomingCallInfo(invitation)
-    Spacer(Modifier.height(8.dp))
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      ProfilePreview(profileOf = invitation.contact, size = 64.dp, color = Color.White)
-      Spacer(Modifier.fillMaxWidth().weight(1f))
-      CallButton(stringResource(R.string.reject), Icons.Filled.CallEnd, Color.Red, rejectCall)
-      CallButton(stringResource(R.string.ignore), Icons.Filled.Close, MaterialTheme.colors.primary, ignoreCall)
-      CallButton(stringResource(R.string.accept), Icons.Filled.Check, SimplexGreen, acceptCall)
-    }
-  }
-}
-
-@Composable
-fun IncomingCallInfo(invitation: CallInvitation) {
-  @Composable fun CallIcon(icon: ImageVector, descr: String) = Icon(icon, descr, tint = SimplexGreen)
-  Row {
-    if (invitation.peerMedia == CallMediaType.Video) CallIcon(Icons.Filled.Videocam, stringResource(R.string.icon_descr_video_call))
-    else CallIcon(Icons.Filled.Phone, stringResource(R.string.icon_descr_audio_call))
-    Spacer(Modifier.width(4.dp))
-    Text(invitation.callTypeText)
-  }
-}
-
-@Composable
-private fun CallButton(text: String, icon: ImageVector, color: Color, action: () -> Unit) {
-  Surface(
-    shape = RoundedCornerShape(10.dp),
-    color = Color.Transparent
-  ) {
-    Column(
-      Modifier
-        .clickable(onClick = action)
-        .defaultMinSize(minWidth = 50.dp)
-        .padding(4.dp),
-      horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-      Icon(icon, text, tint = color, modifier = Modifier.scale(1.2f))
-      Text(text, style = MaterialTheme.typography.body2, color = HighOrLowlight)
-    }
-  }
-}
-
-@Preview
-@Composable
-fun PreviewIncomingCallAlertLayout() {
-  SimpleXTheme {
-    IncomingCallAlertLayout(
-      invitation = CallInvitation(
-        contact = Contact.sampleData,
-        peerMedia = CallMediaType.Audio,
-        sharedKey = null,
-        callTs = Clock.System.now()
-      ),
-      rejectCall = {},
-      ignoreCall = {},
-      acceptCall = {}
-    )
-  }
-}

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

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

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

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

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

@@ -1,195 +0,0 @@
-package chat.simplex.app.views.chat
-
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.*
-import androidx.compose.material.icons.outlined.*
-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.*
-
-@Composable
-fun ChatInfoView(chatModel: ChatModel, close: () -> Unit) {
-  BackHandler(onBack = close)
-  val chat = chatModel.chats.firstOrNull { it.id == chatModel.chatId.value }
-  if (chat != null) {
-    ChatInfoLayout(
-      chat,
-      close = close,
-      deleteContact = { deleteContactDialog(chat.chatInfo, chatModel, close) },
-      clearChat = { clearChatDialog(chat.chatInfo, chatModel, close) }
-    )
-  }
-}
-
-fun deleteContactDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.delete_contact__question),
-    text = generalGetString(R.string.delete_contact_all_messages_deleted_cannot_undo_warning),
-    confirmText = generalGetString(R.string.delete_verb),
-    onConfirm = {
-      withApi {
-        val r = chatModel.controller.apiDeleteChat(chatInfo.chatType, chatInfo.apiId)
-        if (r) {
-          chatModel.removeChat(chatInfo.id)
-          chatModel.chatId.value = null
-          chatModel.controller.ntfManager.cancelNotificationsForChat(chatInfo.id)
-          close?.invoke()
-        }
-      }
-    }
-  )
-}
-
-fun clearChatDialog(chatInfo: ChatInfo, chatModel: ChatModel, close: (() -> Unit)? = null) {
-  AlertManager.shared.showAlertMsg(
-    title = generalGetString(R.string.clear_chat_question),
-    text = generalGetString(R.string.clear_chat_warning),
-    confirmText = generalGetString(R.string.clear_verb),
-    onConfirm = {
-      withApi {
-        val updatedChatInfo = chatModel.controller.apiClearChat(chatInfo.chatType, chatInfo.apiId)
-        if (updatedChatInfo != null) {
-          chatModel.clearChat(updatedChatInfo)
-          chatModel.controller.ntfManager.cancelNotificationsForChat(chatInfo.id)
-          close?.invoke()
-        }
-      }
-    }
-  )
-}
-
-@Composable
-fun ChatInfoLayout(
-  chat: Chat,
-  close: () -> Unit,
-  deleteContact: () -> Unit,
-  clearChat: () -> Unit
-) {
-  Column(
-    Modifier
-      .fillMaxSize()
-      .background(MaterialTheme.colors.background)
-      .padding(horizontal = 8.dp),
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    CloseSheetBar(close)
-    Spacer(Modifier.size(48.dp))
-    val cInfo = chat.chatInfo
-    ChatInfoImage(cInfo, size = 192.dp)
-    Text(
-      cInfo.displayName, style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      color = MaterialTheme.colors.onBackground,
-      modifier = Modifier
-        .padding(top = 32.dp)
-        .padding(bottom = 8.dp)
-    )
-    Text(
-      cInfo.fullName, style = MaterialTheme.typography.h2,
-      color = MaterialTheme.colors.onBackground,
-      modifier = Modifier.padding(bottom = 16.dp)
-    )
-
-    if (cInfo is ChatInfo.Direct) {
-      Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        Row(Modifier.padding(horizontal = 32.dp)) {
-          ServerImage(chat)
-          Text(
-            chat.serverInfo.networkStatus.statusString,
-            textAlign = TextAlign.Center,
-            color = MaterialTheme.colors.onBackground,
-            modifier = Modifier.padding(start = 8.dp)
-          )
-        }
-        Text(
-          chat.serverInfo.networkStatus.statusExplanation,
-          style = MaterialTheme.typography.body2,
-          color = MaterialTheme.colors.onBackground,
-          textAlign = TextAlign.Center,
-          modifier = Modifier
-            .padding(top = 16.dp)
-            .padding(horizontal = 16.dp)
-        )
-      }
-
-      Spacer(Modifier.weight(1F))
-
-      Box(Modifier.padding(4.dp)) {
-        SimpleButton(
-          stringResource(R.string.clear_chat_button),
-          icon = Icons.Outlined.Restore,
-          color = WarningOrange,
-          click = clearChat
-        )
-      }
-      Box(
-        Modifier
-          .padding(4.dp)
-          .padding(bottom = 32.dp)
-      ) {
-        SimpleButton(
-          stringResource(R.string.button_delete_contact),
-          icon = Icons.Outlined.Delete,
-          color = Color.Red,
-          click = deleteContact
-        )
-      }
-    } else if (cInfo is ChatInfo.Group) {
-      Spacer(Modifier.weight(1F))
-
-      Box(
-        Modifier
-          .padding(4.dp)
-          .padding(bottom = 32.dp)
-      ) {
-        SimpleButton(
-          stringResource(R.string.clear_chat_button),
-          icon = Icons.Outlined.Restore,
-          color = WarningOrange,
-          click = clearChat
-        )
-      }
-    }
-  }
-}
-
-@Composable
-fun ServerImage(chat: Chat) {
-  when (chat.serverInfo.networkStatus) {
-    is Chat.NetworkStatus.Connected ->
-      Icon(Icons.Filled.Circle, stringResource(R.string.icon_descr_server_status_connected), tint = MaterialTheme.colors.primaryVariant)
-    is Chat.NetworkStatus.Disconnected ->
-      Icon(Icons.Filled.Pending, stringResource(R.string.icon_descr_server_status_disconnected), tint = HighOrLowlight)
-    is Chat.NetworkStatus.Error ->
-      Icon(Icons.Filled.Error, stringResource(R.string.icon_descr_server_status_error), tint = HighOrLowlight)
-    else -> Icon(Icons.Outlined.Circle, stringResource(R.string.icon_descr_server_status_pending), tint = HighOrLowlight)
-  }
-}
-
-@Preview
-@Composable
-fun PreviewChatInfoLayout() {
-  SimpleXTheme {
-    ChatInfoLayout(
-      chat = Chat(
-        chatInfo = ChatInfo.Direct.sampleData,
-        chatItems = arrayListOf(),
-        serverInfo = Chat.ServerInfo(Chat.NetworkStatus.Error("agent BROKER TIMEOUT"))
-      ),
-      close = {}, deleteContact = {}, clearChat = {}
-    )
-  }
-}

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

@@ -1,441 +0,0 @@
-package chat.simplex.app.views.chat
-
-import android.content.res.Configuration
-import android.util.Log
-import androidx.activity.compose.BackHandler
-import androidx.annotation.StringRes
-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.*
-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.graphics.vector.ImageVector
-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.TAG
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.call.*
-import chat.simplex.app.views.chat.item.ChatItemView
-import chat.simplex.app.views.chatlist.openChat
-import chat.simplex.app.views.helpers.*
-import com.google.accompanist.insets.ProvideWindowInsets
-import com.google.accompanist.insets.navigationBarsWithImePadding
-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 }
-  val user = chatModel.currentUser.value
-  val useLinkPreviews = chatModel.controller.appPrefs.privacyLinkPreviews.get()
-  val enableCalls = chatModel.controller.appPrefs.experimentalCalls.get()
-  val composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = useLinkPreviews)) }
-  val attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) }
-  val attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden)
-  val scope = rememberCoroutineScope()
-
-  if (chat == null || user == null) {
-    chatModel.chatId.value = null
-  } else {
-    BackHandler { chatModel.chatId.value = null }
-    // TODO a more advanced version would mark as read only if in view
-    LaunchedEffect(chat.chatItems) {
-      Log.d(TAG, "ChatView ${chatModel.chatId.value}: LaunchedEffect")
-      delay(750L)
-      if (chat.chatItems.isNotEmpty()) {
-        chatModel.markChatItemsRead(chat.chatInfo)
-        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
-        withApi {
-          chatModel.controller.apiChatRead(
-            chat.chatInfo.chatType,
-            chat.chatInfo.apiId,
-            CC.ItemRange(chat.chatStats.minUnreadItemId, chat.chatItems.last().id)
-          )
-        }
-      }
-    }
-    ChatLayout(
-      user,
-      chat,
-      composeState,
-      composeView = {
-        ComposeView(
-          chatModel, chat, composeState, attachmentOption,
-          showChooseAttachment = { scope.launch { attachmentBottomSheetState.show() } }
-        )
-      },
-      attachmentOption,
-      scope,
-      attachmentBottomSheetState,
-      chatModel.chatItems,
-      useLinkPreviews = useLinkPreviews,
-      enableCalls = enableCalls,
-      back = { chatModel.chatId.value = null },
-      info = { ModalManager.shared.showCustomModal { close -> ChatInfoView(chatModel, close) } },
-      openDirectChat = { contactId ->
-        val c = chatModel.chats.firstOrNull {
-          it.chatInfo is ChatInfo.Direct && it.chatInfo.contact.contactId == contactId
-        }
-        if (c != null) withApi { openChat(c.chatInfo, chatModel) }
-      },
-      deleteMessage = { itemId, mode ->
-        withApi {
-          val cInfo = chat.chatInfo
-          val toItem = chatModel.controller.apiDeleteChatItem(
-            type = cInfo.chatType,
-            id = cInfo.apiId,
-            itemId = itemId,
-            mode = mode
-          )
-          if (toItem != null) chatModel.removeChatItem(cInfo, toItem.chatItem)
-        }
-      },
-      receiveFile = { fileId ->
-        withApi { chatModel.controller.receiveFile(fileId) }
-      },
-      startCall = { media ->
-        val cInfo = chat.chatInfo
-        if (cInfo is ChatInfo.Direct) {
-          chatModel.activeCall.value = Call(contact = cInfo.contact, callState = CallState.WaitCapabilities, localMedia = media)
-          chatModel.showCallView.value = true
-          chatModel.callCommand.value = WCallCommand.Capabilities
-        }
-      },
-      acceptCall = { contact ->
-        val invitation = chatModel.callInvitations.remove(contact.id)
-        if (invitation == null) {
-          AlertManager.shared.showAlertMsg("Call already ended!")
-        } else {
-          chatModel.callManager.acceptIncomingCall(invitation = invitation)
-        }
-      }
-    )
-  }
-}
-
-@Composable
-fun ChatLayout(
-  user: User,
-  chat: Chat,
-  composeState: MutableState<ComposeState>,
-  composeView: (@Composable () -> Unit),
-  attachmentOption: MutableState<AttachmentOption?>,
-  scope: CoroutineScope,
-  attachmentBottomSheetState: ModalBottomSheetState,
-  chatItems: List<ChatItem>,
-  useLinkPreviews: Boolean,
-  enableCalls: Boolean = false,
-  back: () -> Unit,
-  info: () -> Unit,
-  openDirectChat: (Long) -> Unit,
-  deleteMessage: (Long, CIDeleteMode) -> Unit,
-  receiveFile: (Long) -> Unit,
-  startCall: (CallMediaType) -> Unit,
-  acceptCall: (Contact) -> Unit
-) {
-  Surface(
-    Modifier
-      .fillMaxWidth()
-      .background(MaterialTheme.colors.background)
-  ) {
-    ProvideWindowInsets(windowInsetsAnimationsEnabled = true) {
-      ModalBottomSheetLayout(
-        scrimColor = Color.Black.copy(alpha = 0.12F),
-        modifier = Modifier.navigationBarsWithImePadding(),
-        sheetContent = {
-          ChooseAttachmentView(
-            attachmentOption,
-            hide = { scope.launch { attachmentBottomSheetState.hide() } }
-          )
-        },
-        sheetState = attachmentBottomSheetState,
-        sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp)
-      ) {
-        Scaffold(
-          topBar = { ChatInfoToolbar(chat, enableCalls, back, info, startCall) },
-          bottomBar = composeView,
-          modifier = Modifier.navigationBarsWithImePadding()
-        ) { contentPadding ->
-          Box(Modifier.padding(contentPadding)) {
-            ChatItemsList(user, chat, composeState, chatItems, useLinkPreviews, openDirectChat, deleteMessage, receiveFile, acceptCall)
-          }
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun ChatInfoToolbar(chat: Chat, enableCalls: Boolean, back: () -> Unit, info: () -> Unit, startCall: (CallMediaType) -> Unit) {
-  @Composable fun toolbarButton(icon: ImageVector, @StringRes textId: Int, modifier: Modifier = Modifier.padding(0.dp), onClick: () -> Unit) {
-    IconButton(onClick, modifier = modifier) {
-      Icon(icon, stringResource(textId), tint = MaterialTheme.colors.primary)
-    }
-  }
-  Column {
-    Box(
-      Modifier
-        .fillMaxWidth()
-        .height(52.dp)
-        .background(if (isSystemInDarkTheme()) ToolbarDark else ToolbarLight)
-        .padding(horizontal = 4.dp),
-      contentAlignment = Alignment.CenterStart,
-    ) {
-      val cInfo = chat.chatInfo
-      toolbarButton(Icons.Outlined.ArrowBackIos, R.string.back, onClick = back)
-      if (cInfo is ChatInfo.Direct && enableCalls) {
-        Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
-          Box(Modifier.width(85.dp), contentAlignment = Alignment.CenterStart) {
-            toolbarButton(Icons.Outlined.Phone, R.string.icon_descr_audio_call) {
-              startCall(CallMediaType.Audio)
-            }
-          }
-          toolbarButton(Icons.Outlined.Videocam, R.string.icon_descr_video_call) {
-            startCall(CallMediaType.Video)
-          }
-        }
-      }
-      Row(
-        Modifier
-          .padding(horizontal = 80.dp)
-          .fillMaxWidth()
-          .clickable(onClick = info),
-        horizontalArrangement = Arrangement.Center,
-        verticalAlignment = Alignment.CenterVertically
-      ) {
-        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()
-  }
-}
-
-data class CIListState(val scrolled: Boolean, val itemCount: Int, val keyboardState: KeyboardState)
-
-val CIListStateSaver = run {
-  val scrolledKey = "scrolled"
-  val countKey = "itemCount"
-  val keyboardKey = "keyboardState"
-  mapSaver(
-    save = { mapOf(scrolledKey to it.scrolled, countKey to it.itemCount, keyboardKey to it.keyboardState) },
-    restore = { CIListState(it[scrolledKey] as Boolean, it[countKey] as Int, it[keyboardKey] as KeyboardState) }
-  )
-}
-
-@Composable
-fun ChatItemsList(
-  user: User,
-  chat: Chat,
-  composeState: MutableState<ComposeState>,
-  chatItems: List<ChatItem>,
-  useLinkPreviews: Boolean,
-  openDirectChat: (Long) -> Unit,
-  deleteMessage: (Long, CIDeleteMode) -> Unit,
-  receiveFile: (Long) -> Unit,
-  acceptCall: (Contact) -> 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) {
-    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, chat.chatInfo, cItem, composeState, cxt, uriHandler, showMember = showMember, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, acceptCall = acceptCall)
-          }
-        } else {
-          Box(Modifier.padding(start = 86.dp, end = 12.dp)) {
-            ChatItemView(user, chat.chatInfo, cItem, composeState, cxt, uriHandler, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, acceptCall = acceptCall)
-          }
-        }
-      } 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, chat.chatInfo, cItem, composeState, cxt, uriHandler, useLinkPreviews = useLinkPreviews, deleteMessage = deleteMessage, receiveFile = receiveFile, acceptCall = acceptCall)
-        }
-      }
-    }
-    val len = chatItems.count()
-    if (len > 1 && (keyboardState != ciListState.value.keyboardState || !ciListState.value.scrolled || len != ciListState.value.itemCount)) {
-      scope.launch {
-        ciListState.value = CIListState(true, len, keyboardState)
-        listState.animateScrollToItem(len - 1)
-      }
-    }
-  }
-}
-
-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,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatLayout() {
-  SimpleXTheme {
-    val chatItems = listOf(
-      ChatItem.getSampleData(
-        1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      ),
-      ChatItem.getSampleData(
-        2, CIDirection.DirectRcv(), Clock.System.now(), "hello"
-      ),
-      ChatItem.getDeletedContentSampleData(3),
-      ChatItem.getSampleData(
-        4, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      ),
-      ChatItem.getSampleData(
-        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(useLinkPreviews = true)) },
-      composeView = {},
-      attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
-      scope = rememberCoroutineScope(),
-      attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
-      chatItems = chatItems,
-      useLinkPreviews = true,
-      back = {},
-      info = {},
-      openDirectChat = {},
-      deleteMessage = { _, _ -> },
-      receiveFile = {},
-      startCall = {},
-      acceptCall = { _ ->  }
-    )
-  }
-}
-
-@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(useLinkPreviews = true)) },
-      composeView = {},
-      attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
-      scope = rememberCoroutineScope(),
-      attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
-      chatItems = chatItems,
-      useLinkPreviews = true,
-      back = {},
-      info = {},
-      openDirectChat = {},
-      deleteMessage = { _, _ -> },
-      receiveFile = {},
-      startCall = {},
-      acceptCall = { _ ->  }
-    )
-  }
-}

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

@@ -1,47 +0,0 @@
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Close
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.asImageBitmap
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.views.chat.item.SentColorLight
-import chat.simplex.app.views.helpers.base64ToBitmap
-
-@Composable
-fun ComposeImageView(image: String, cancelImage: () -> Unit, cancelEnabled: Boolean) {
-  Row(
-    Modifier
-      .fillMaxWidth()
-      .padding(top = 8.dp)
-      .background(SentColorLight),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    val imageBitmap = base64ToBitmap(image).asImageBitmap()
-    Image(
-      imageBitmap,
-      "preview image",
-      modifier = Modifier
-        .width(80.dp)
-        .height(60.dp)
-        .padding(end = 8.dp)
-    )
-    Spacer(Modifier.weight(1f))
-    if (cancelEnabled) {
-      IconButton(onClick = cancelImage, modifier = Modifier.padding(0.dp)) {
-        Icon(
-          Icons.Outlined.Close,
-          contentDescription = stringResource(R.string.icon_descr_cancel_image_preview),
-          tint = MaterialTheme.colors.primary,
-          modifier = Modifier.padding(10.dp)
-        )
-      }
-    }
-  }
-}

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

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

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

@@ -1,79 +0,0 @@
-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.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,
-      )
-      MarkdownText(
-        contextItem.text, contextItem.formattedText,
-        sender = contextItem.memberDisplayName, senderBold = true, maxLines = 3
-      )
-    }
-    IconButton(onClick = cancelContextItem) {
-      Icon(
-        Icons.Outlined.Close,
-        contentDescription = stringResource(R.string.cancel_verb),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-  }
-}
-
-@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

@@ -1,162 +0,0 @@
-package chat.simplex.app.views.chat
-
-import android.content.res.Configuration
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Check
-import androidx.compose.material.icons.outlined.ArrowUpward
-import androidx.compose.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.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(
-  composeState: MutableState<ComposeState>,
-  sendMessage: () -> Unit,
-  onMessageChange: (String) -> Unit,
-  textStyle: MutableState<TextStyle>
-) {
-  val cs = composeState.value
-  BasicTextField(
-    value = cs.message,
-    onValueChange = onMessageChange,
-    textStyle = textStyle.value,
-    maxLines = 16,
-    keyboardOptions = KeyboardOptions.Default.copy(
-      capitalization = KeyboardCapitalization.Sentences,
-      autoCorrect = true
-    ),
-    modifier = Modifier.padding(vertical = 8.dp),
-    cursorBrush = SolidColor(HighOrLowlight),
-    decorationBox = { innerTextField ->
-      Surface(
-        shape = RoundedCornerShape(18.dp),
-        border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
-      ) {
-        Row(
-          Modifier.background(MaterialTheme.colors.background),
-          verticalAlignment = Alignment.Bottom
-        ) {
-          Box(
-            Modifier
-              .weight(1f)
-              .padding(horizontal = 12.dp)
-              .padding(top = 5.dp)
-              .padding(bottom = 7.dp)
-          ) {
-            innerTextField()
-          }
-          val icon = if (cs.editing) Icons.Filled.Check else Icons.Outlined.ArrowUpward
-          val color = if (cs.sendEnabled()) MaterialTheme.colors.primary else HighOrLowlight
-          if (cs.inProgress
-            && (cs.preview is ComposePreview.ImagePreview || cs.preview is ComposePreview.FilePreview)
-          ) {
-            CircularProgressIndicator(
-              Modifier
-                .size(36.dp)
-                .padding(4.dp),
-              color = HighOrLowlight,
-              strokeWidth = 3.dp
-            )
-          } else {
-            Icon(
-              icon,
-              stringResource(R.string.icon_descr_send_message),
-              tint = Color.White,
-              modifier = Modifier
-                .size(36.dp)
-                .padding(4.dp)
-                .clip(CircleShape)
-                .background(color)
-                .clickable {
-                  if (cs.sendEnabled()) {
-                    sendMessage()
-                  }
-                }
-            )
-          }
-        }
-      }
-    }
-  )
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewSendMsgView() {
-  val smallFont = MaterialTheme.typography.body1.copy(color = MaterialTheme.colors.onBackground)
-  val textStyle = remember { mutableStateOf(smallFont) }
-  SimpleXTheme {
-    SendMsgView(
-      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      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(), useLinkPreviews = true)
-  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, useLinkPreviews = 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

@@ -1,211 +0,0 @@
-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 PreviewCIFileFramedItemView(@PreviewParameter(ChatItemProvider::class) chatItem: ChatItem) {
-  val showMenu = remember { mutableStateOf(false) }
-  SimpleXTheme {
-    FramedItemView(User.sampleData, chatItem, showMenu = showMenu, receiveFile = {})
-  }
-}

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

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

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

@@ -1,158 +0,0 @@
-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.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.HighOrLowlight
-import chat.simplex.app.ui.theme.SimplexBlue
-import kotlinx.datetime.Clock
-
-@Composable
-fun CIMetaView(chatItem: ChatItem, metaColor: Color = HighOrLowlight) {
-  Row(verticalAlignment = Alignment.CenterVertically) {
-    if (!chatItem.isDeletedContent) {
-      if (chatItem.meta.itemEdited) {
-        Icon(
-          Icons.Filled.Edit,
-          modifier = Modifier.height(12.dp).padding(end = 1.dp),
-          contentDescription = stringResource(R.string.icon_descr_edited),
-          tint = metaColor,
-        )
-      }
-      CIStatusView(chatItem.meta.itemStatus, metaColor)
-    }
-    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
-@Composable
-fun PreviewCIMetaView() {
-  CIMetaView(
-    chatItem = ChatItem.getSampleData(
-      1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-    )
-  )
-}
-
-@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,233 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import android.content.Context
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
-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.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(
-  user: User,
-  cInfo: ChatInfo,
-  cItem: ChatItem,
-  composeState: MutableState<ComposeState>,
-  cxt: Context,
-  uriHandler: UriHandler? = null,
-  showMember: Boolean = false,
-  useLinkPreviews: Boolean,
-  deleteMessage: (Long, CIDeleteMode) -> Unit,
-  receiveFile: (Long) -> Unit,
-  acceptCall: (Contact) -> 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(),
-    contentAlignment = alignment,
-  ) {
-    Column(
-      Modifier
-        .clip(RoundedCornerShape(18.dp))
-        .combinedClickable(onLongClick = { showMenu.value = true }, onClick = {})
-    ) {
-      @Composable fun ContentItem() {
-        if (cItem.file == null && cItem.quotedItem == null && isShortEmoji(cItem.content.text)) {
-          EmojiItemView(cItem)
-        } else {
-          FramedItemView(user, cItem, uriHandler, showMember = showMember, showMenu, receiveFile)
-        }
-        DropdownMenu(
-          expanded = showMenu.value,
-          onDismissRequest = { showMenu.value = false },
-          Modifier.width(220.dp)
-        ) {
-          ItemAction(stringResource(R.string.reply_verb), Icons.Outlined.Reply, onClick = {
-            if (composeState.value.editing) {
-              composeState.value = ComposeState(contextItem = ComposeContextItem.QuotedItem(cItem), useLinkPreviews = useLinkPreviews)
-            } else {
-              composeState.value = composeState.value.copy(contextItem = ComposeContextItem.QuotedItem(cItem))
-            }
-            showMenu.value = false
-          })
-          ItemAction(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.meta.editable) {
-            ItemAction(stringResource(R.string.edit_verb), Icons.Filled.Edit, onClick = {
-              composeState.value = ComposeState(editingItem = cItem, useLinkPreviews = useLinkPreviews)
-              showMenu.value = false
-            })
-          }
-          ItemAction(
-            stringResource(R.string.delete_verb),
-            Icons.Outlined.Delete,
-            onClick = {
-              showMenu.value = false
-              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
-            },
-            color = Color.Red
-          )
-        }
-      }
-
-      @Composable fun DeletedItem() {
-        DeletedItemView(cItem, showMember = showMember)
-        DropdownMenu(
-          expanded = showMenu.value,
-          onDismissRequest = { showMenu.value = false },
-          Modifier.width(220.dp)
-        ) {
-          ItemAction(
-            stringResource(R.string.delete_verb),
-            Icons.Outlined.Delete,
-            onClick = {
-              showMenu.value = false
-              deleteMessageAlertDialog(cItem, deleteMessage = deleteMessage)
-            },
-            color = Color.Red
-          )
-        }
-      }
-
-      @Composable fun CallItem(status: CICallStatus, duration: Int) {
-        CICallItemView(cInfo, cItem, status, duration, acceptCall)
-      }
-
-      when (val c = cItem.content) {
-        is CIContent.SndMsgContent -> ContentItem()
-        is CIContent.RcvMsgContent -> ContentItem()
-        is CIContent.SndDeleted -> DeletedItem()
-        is CIContent.RcvDeleted -> DeletedItem()
-        is CIContent.SndCall -> CallItem(c.status, c.duration)
-        is CIContent.RcvCall -> CallItem(c.status, c.duration)
-        is CIContent.RcvIntegrityError -> IntegrityErrorItemView(cItem, showMember = showMember)
-      }
-    }
-  }
-}
-
-@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(
-      User.sampleData,
-      ChatInfo.Direct.sampleData,
-      ChatItem.getSampleData(
-        1, CIDirection.DirectSnd(), Clock.System.now(), "hello"
-      ),
-      useLinkPreviews = true,
-      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      cxt = LocalContext.current,
-      deleteMessage = { _, _ -> },
-      receiveFile = {},
-      acceptCall = { _ -> }
-    )
-  }
-}
-
-@Preview
-@Composable
-fun PreviewChatItemViewDeletedContent() {
-  SimpleXTheme {
-    ChatItemView(
-      User.sampleData,
-      ChatInfo.Direct.sampleData,
-      ChatItem.getDeletedContentSampleData(),
-      useLinkPreviews = true,
-      composeState = remember { mutableStateOf(ComposeState(useLinkPreviews = true)) },
-      cxt = LocalContext.current,
-      deleteMessage = { _, _ -> },
-      receiveFile = {},
-      acceptCall = { _ -> }
-    )
-  }
-}

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

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

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

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

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

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

@@ -1,89 +0,0 @@
-package chat.simplex.app.views.chat.item
-
-import androidx.compose.foundation.text.ClickableText
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.runtime.Composable
-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.unit.sp
-import chat.simplex.app.model.*
-
-val reserveTimestampStyle = SpanStyle(color = Color.Transparent)
-val boldFont = SpanStyle(fontWeight = FontWeight.Medium)
-
-fun appendGroupMember(b: AnnotatedString.Builder, chatItem: ChatItem, groupMemberBold: Boolean) {
-  if (chatItem.chatDir is CIDirection.GroupRcv) {
-    val name = chatItem.chatDir.groupMember.memberProfile.displayName
-    if (groupMemberBold) b.withStyle(boldFont) { append(name) }
-    else b.append(name)
-    b.append(": ")
-  }
-}
-
-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 (
-  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,
-  senderBold: Boolean = false,
-  modifier: Modifier = Modifier
-) {
-  val reserve = if (edited) "        " else "    "
-  if (formattedText == null) {
-    val annotatedText = buildAnnotatedString {
-      appendSender(this, sender, senderBold)
-      append(text)
-      if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
-    }
-    Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
-  } else {
-    var hasLinks = false
-    val annotatedText = buildAnnotatedString {
-      appendSender(this, sender, senderBold)
-      for (ft in formattedText) {
-        if (ft.format == null) append(ft.text)
-        else {
-          val link = ft.link
-          if (link != null) {
-            hasLinks = true
-            withAnnotation(tag = "URL", annotation = link) {
-              withStyle(ft.format.style) { append(ft.text) }
-            }
-          } else {
-            withStyle(ft.format.style) { append(ft.text) }
-          }
-        }
-      }
-      if (metaText != null) withStyle(reserveTimestampStyle) { append(reserve + metaText) }
-    }
-    if (hasLinks && uriHandler != null) {
-      ClickableText(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow,
-        onClick = { offset ->
-          annotatedText.getStringAnnotations(tag = "URL", start = offset, end = offset)
-            .firstOrNull()?.let { annotation -> uriHandler.openUri(annotation.item) }
-        }
-      )
-    } else {
-      Text(annotatedText, style = style, modifier = modifier, maxLines = maxLines, overflow = overflow)
-    }
-  }
-}

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

@@ -1,93 +0,0 @@
-package chat.simplex.app.views.chatlist
-
-import android.content.res.Configuration
-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.PersonAdd
-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.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)
-
-@Composable
-fun ChatHelpView(addContact: (() -> Unit)? = null) {
-  Column(
-    horizontalAlignment = Alignment.Start,
-    verticalArrangement = Arrangement.spacedBy(10.dp)
-  ) {
-    val uriHandler = LocalUriHandler.current
-
-    Text(stringResource(R.string.thank_you_for_installing_simplex), lineHeight = 22.sp)
-    Text(
-      annotatedStringResource(R.string.you_can_connect_to_simplex_chat_founder),
-      modifier = Modifier.clickable(onClick = {
-        uriHandler.openUri(simplexTeamUri)
-      }),
-      lineHeight = 22.sp
-    )
-
-    Column(
-      Modifier.padding(top = 24.dp),
-      horizontalAlignment = Alignment.Start,
-      verticalArrangement = Arrangement.spacedBy(10.dp)
-    ) {
-      Text(
-        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(stringResource(R.string.chat_help_tap_button))
-        Icon(
-          Icons.Outlined.PersonAdd,
-          stringResource(R.string.add_contact),
-          modifier = if (addContact != null) Modifier.clickable(onClick = addContact) else Modifier,
-        )
-        Text(stringResource(R.string.above_then_preposition_continuation))
-      }
-      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(
-      Modifier.padding(top = 24.dp),
-      horizontalAlignment = Alignment.Start,
-      verticalArrangement = Arrangement.spacedBy(10.dp)
-    ) {
-      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)
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatHelpLayout() {
-  SimpleXTheme {
-    ChatHelpView {}
-  }
-}

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

@@ -1,409 +0,0 @@
-package chat.simplex.app.views.chatlist
-
-import android.content.res.Configuration
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.ui.theme.WarningOrange
-import chat.simplex.app.views.chat.clearChatDialog
-import chat.simplex.app.views.chat.deleteContactDialog
-import chat.simplex.app.views.chat.item.ItemAction
-import chat.simplex.app.views.helpers.*
-import kotlinx.coroutines.delay
-import kotlinx.datetime.Clock
-
-@Composable
-fun ChatListNavLinkView(chat: Chat, chatModel: ChatModel) {
-  val showMenu = remember { mutableStateOf(false) }
-  var showMarkRead by remember { mutableStateOf(false) }
-  LaunchedEffect(chat.id, chat.chatStats.unreadCount > 0) {
-    showMenu.value = false
-    delay(500L)
-    showMarkRead = chat.chatStats.unreadCount > 0
-  }
-  when (chat.chatInfo) {
-    is ChatInfo.Direct ->
-      ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat) },
-        click = { openOrPendingChat(chat.chatInfo, chatModel) },
-        dropdownMenuItems = { ContactMenuItems(chat, chatModel, showMenu, showMarkRead) },
-        showMenu
-      )
-    is ChatInfo.Group ->
-      ChatListNavLinkLayout(
-        chatLinkPreview = { ChatPreviewView(chat) },
-        click = { openOrPendingChat(chat.chatInfo, chatModel) },
-        dropdownMenuItems = { GroupMenuItems(chat, chatModel, showMenu, showMarkRead) },
-        showMenu
-      )
-    is ChatInfo.ContactRequest ->
-      ChatListNavLinkLayout(
-        chatLinkPreview = { ContactRequestView(chat.chatInfo) },
-        click = { contactRequestAlertDialog(chat.chatInfo, chatModel) },
-        dropdownMenuItems = { ContactRequestMenuItems(chat.chatInfo, chatModel, showMenu) },
-        showMenu
-      )
-    is ChatInfo.ContactConnection ->
-      ChatListNavLinkLayout(
-        chatLinkPreview = { ContactConnectionView(chat.chatInfo.contactConnection) },
-        click = { contactConnectionAlertDialog(chat.chatInfo.contactConnection, chatModel) },
-        dropdownMenuItems = { ContactConnectionMenuItems(chat.chatInfo, chatModel, showMenu) },
-        showMenu
-      )
-  }
-}
-
-fun openOrPendingChat(chatInfo: ChatInfo, chatModel: ChatModel) {
-  if (chatInfo.ready) {
-    withApi { openChat(chatInfo, chatModel) }
-  } else {
-    pendingContactAlertDialog(chatInfo, chatModel)
-  }
-}
-
-suspend fun openChat(chatInfo: ChatInfo, chatModel: ChatModel) {
-  val chat = chatModel.controller.apiGetChat(chatInfo.chatType, chatInfo.apiId)
-  if (chat != null) {
-    chatModel.chatItems.clear()
-    chatModel.chatItems.addAll(chat.chatItems)
-    chatModel.chatId.value = chatInfo.id
-  }
-}
-
-@Composable
-fun ContactMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
-  if (showMarkRead) {
-    ItemAction(
-      stringResource(R.string.mark_read),
-      Icons.Outlined.Check,
-      onClick = {
-        markChatRead(chat, chatModel)
-        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
-        showMenu.value = false
-      }
-    )
-  }
-  ItemAction(
-    stringResource(R.string.clear_verb),
-    Icons.Outlined.Restore,
-    onClick = {
-      clearChatDialog(chat.chatInfo, chatModel)
-      showMenu.value = false
-    },
-    color = WarningOrange
-  )
-  ItemAction(
-    stringResource(R.string.delete_verb),
-    Icons.Outlined.Delete,
-    onClick = {
-      deleteContactDialog(chat.chatInfo as ChatInfo.Direct, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
-@Composable
-fun GroupMenuItems(chat: Chat, chatModel: ChatModel, showMenu: MutableState<Boolean>, showMarkRead: Boolean) {
-  if (showMarkRead) {
-    ItemAction(
-      stringResource(R.string.mark_read),
-      Icons.Outlined.Check,
-      onClick = {
-        markChatRead(chat, chatModel)
-        chatModel.controller.ntfManager.cancelNotificationsForChat(chat.id)
-        showMenu.value = false
-      }
-    )
-  }
-  ItemAction(
-    stringResource(R.string.clear_verb),
-    Icons.Outlined.Restore,
-    onClick = {
-      clearChatDialog(chat.chatInfo, chatModel)
-      showMenu.value = false
-    },
-    color = WarningOrange
-  )
-}
-
-@Composable
-fun ContactRequestMenuItems(chatInfo: ChatInfo.ContactRequest, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  ItemAction(
-    stringResource(R.string.accept_contact_button),
-    Icons.Outlined.Check,
-    onClick = {
-      acceptContactRequest(chatInfo, chatModel)
-      showMenu.value = false
-    }
-  )
-  ItemAction(
-    stringResource(R.string.reject_contact_button),
-    Icons.Outlined.Close,
-    onClick = {
-      rejectContactRequest(chatInfo, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
-@Composable
-fun ContactConnectionMenuItems(chatInfo: ChatInfo.ContactConnection, chatModel: ChatModel, showMenu: MutableState<Boolean>) {
-  ItemAction(
-    stringResource(R.string.delete_verb),
-    Icons.Outlined.Delete,
-    onClick = {
-      deleteContactConnectionAlert(chatInfo.contactConnection, chatModel)
-      showMenu.value = false
-    },
-    color = Color.Red
-  )
-}
-
-fun markChatRead(chat: Chat, chatModel: ChatModel) {
-  chatModel.markChatItemsRead(chat.chatInfo)
-  withApi {
-    chatModel.controller.apiChatRead(
-      chat.chatInfo.chatType,
-      chat.chatInfo.apiId,
-      CC.ItemRange(chat.chatStats.minUnreadItemId, chat.chatItems.last().id)
-    )
-  }
-}
-
-fun contactRequestAlertDialog(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
-  AlertManager.shared.showAlertDialog(
-    title = generalGetString(R.string.accept_connection_request__question),
-    text = generalGetString(R.string.if_you_choose_to_reject_the_sender_will_not_be_notified),
-    confirmText = generalGetString(R.string.accept_contact_button),
-    onConfirm = { acceptContactRequest(contactRequest, chatModel) },
-    dismissText = generalGetString(R.string.reject_contact_button),
-    onDismiss = { rejectContactRequest(contactRequest, chatModel) }
-  )
-}
-
-fun acceptContactRequest(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
-  withApi {
-    val contact = chatModel.controller.apiAcceptContactRequest(contactRequest.apiId)
-    if (contact != null) {
-      val chat = Chat(ChatInfo.Direct(contact), listOf())
-      chatModel.replaceChat(contactRequest.id, chat)
-    }
-  }
-}
-
-fun rejectContactRequest(contactRequest: ChatInfo.ContactRequest, chatModel: ChatModel) {
-  withApi {
-    chatModel.controller.apiRejectContactRequest(contactRequest.apiId)
-    chatModel.removeChat(contactRequest.id)
-  }
-}
-
-fun contactConnectionAlertDialog(connection: PendingContactConnection, chatModel: ChatModel) {
-  AlertManager.shared.showAlertDialogButtons(
-    title = generalGetString(
-      if (connection.initiated) R.string.you_invited_your_contact
-      else R.string.you_accepted_connection
-    ),
-    text = generalGetString(
-      if (connection.viaContactUri) R.string.you_will_be_connected_when_your_connection_request_is_accepted
-      else R.string.you_will_be_connected_when_your_contacts_device_is_online
-    ),
-    buttons = {
-      Row(
-        Modifier
-          .fillMaxWidth()
-          .padding(horizontal = 8.dp, vertical = 2.dp),
-        horizontalArrangement = Arrangement.End,
-      ) {
-        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(
-  chatLinkPreview: @Composable () -> Unit,
-  click: () -> Unit,
-  dropdownMenuItems: (@Composable () -> Unit)?,
-  showMenu: MutableState<Boolean>
-) {
-  Surface(
-    modifier = Modifier
-      .fillMaxWidth()
-      .combinedClickable(
-        onClick = click,
-        onLongClick = { showMenu.value = true }
-      )
-      .height(88.dp)
-  ) {
-    Row(
-      modifier = Modifier
-        .fillMaxWidth()
-        .padding(vertical = 8.dp)
-        .padding(start = 8.dp)
-        .padding(end = 12.dp),
-      verticalAlignment = Alignment.Top
-    ) {
-      chatLinkPreview()
-    }
-    if (dropdownMenuItems != null) {
-      Box(Modifier.padding(horizontal = 16.dp)) {
-        DropdownMenu(
-          expanded = showMenu.value,
-          onDismissRequest = { showMenu.value = false },
-          Modifier.width(220.dp)
-        ) {
-          dropdownMenuItems()
-        }
-      }
-    }
-  }
-  Divider(Modifier.padding(horizontal = 8.dp))
-}
-
-@Preview
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatListNavLinkDirect() {
-  SimpleXTheme {
-    ChatListNavLinkLayout(
-      chatLinkPreview = {
-        ChatPreviewView(
-          chat = Chat(
-            chatInfo = ChatInfo.Direct.sampleData,
-            chatItems = listOf(
-              ChatItem.getSampleData(
-                1,
-                CIDirection.DirectSnd(),
-                Clock.System.now(),
-                "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat."
-              )
-            ),
-            chatStats = Chat.ChatStats()
-          )
-        )
-      },
-      click = {},
-      dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) }
-    )
-  }
-}
-
-@Preview
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatListNavLinkGroup() {
-  SimpleXTheme {
-    ChatListNavLinkLayout(
-      chatLinkPreview = {
-        ChatPreviewView(
-          Chat(
-            chatInfo = ChatInfo.Group.sampleData,
-            chatItems = listOf(
-              ChatItem.getSampleData(
-                1,
-                CIDirection.DirectSnd(),
-                Clock.System.now(),
-                "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat."
-              )
-            ),
-            chatStats = Chat.ChatStats()
-          )
-        )
-      },
-      click = {},
-      dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) }
-    )
-  }
-}
-
-@Preview
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatListNavLinkContactRequest() {
-  SimpleXTheme {
-    ChatListNavLinkLayout(
-      chatLinkPreview = {
-        ContactRequestView(ChatInfo.ContactRequest.sampleData)
-      },
-      click = {},
-      dropdownMenuItems = null,
-      showMenu = remember { mutableStateOf(false) }
-    )
-  }
-}

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

@@ -1,150 +0,0 @@
-package chat.simplex.app.views.chatlist
-
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.items
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Menu
-import androidx.compose.material.icons.outlined.PersonAdd
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.ToolbarDark
-import chat.simplex.app.ui.theme.ToolbarLight
-import chat.simplex.app.views.newchat.NewChatSheet
-import chat.simplex.app.views.onboarding.MakeConnection
-import chat.simplex.app.views.usersettings.SettingsView
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-
-class ScaffoldController(val scope: CoroutineScope) {
-  lateinit var state: BottomSheetScaffoldState
-  val expanded = mutableStateOf(false)
-
-  fun expand() {
-    expanded.value = true
-    scope.launch { state.bottomSheetState.expand() }
-  }
-
-  fun collapse() {
-    expanded.value = false
-    scope.launch { state.bottomSheetState.collapse() }
-  }
-
-  fun toggleSheet() {
-    if (state.bottomSheetState.isExpanded) collapse() else expand()
-  }
-
-  fun toggleDrawer() = scope.launch {
-    state.drawerState.apply { if (isClosed) open() else close() }
-  }
-}
-
-@Composable
-fun scaffoldController(): ScaffoldController {
-  val ctrl = ScaffoldController(scope = rememberCoroutineScope())
-  val bottomSheetState = rememberBottomSheetState(
-    BottomSheetValue.Collapsed,
-    confirmStateChange = {
-      ctrl.expanded.value = it == BottomSheetValue.Expanded
-      true
-    }
-  )
-  ctrl.state = rememberBottomSheetScaffoldState(bottomSheetState = bottomSheetState)
-  return ctrl
-}
-
-@Composable
-fun ChatListView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit) {
-  val scaffoldCtrl = scaffoldController()
-  LaunchedEffect(chatModel.clearOverlays.value) {
-    if (chatModel.clearOverlays.value && scaffoldCtrl.expanded.value) scaffoldCtrl.collapse()
-  }
-  BottomSheetScaffold(
-    scaffoldState = scaffoldCtrl.state,
-    drawerContent = { SettingsView(chatModel, setPerformLA) },
-    sheetPeekHeight = 0.dp,
-    sheetContent = { NewChatSheet(chatModel, scaffoldCtrl) },
-    sheetShape = RoundedCornerShape(topStart = 18.dp, topEnd = 18.dp),
-  ) {
-    Box {
-      Column(
-        modifier = Modifier
-          .fillMaxSize()
-          .background(MaterialTheme.colors.background)
-      ) {
-        ChatListToolbar(scaffoldCtrl)
-        Divider()
-        if (chatModel.chats.isNotEmpty()) {
-          ChatList(chatModel)
-        } else {
-          MakeConnection(chatModel)
-        }
-      }
-      if (scaffoldCtrl.expanded.value) {
-        Surface(
-          Modifier
-            .fillMaxSize()
-            .clickable { scaffoldCtrl.collapse() },
-          color = Color.Black.copy(alpha = 0.12F)
-        ) {}
-      }
-    }
-  }
-}
-
-@Composable
-fun ChatListToolbar(scaffoldCtrl: ScaffoldController) {
-  Row(
-    horizontalArrangement = Arrangement.SpaceBetween,
-    verticalAlignment = Alignment.CenterVertically,
-    modifier = Modifier
-      .fillMaxWidth()
-      .height(52.dp)
-      .background(if (isSystemInDarkTheme()) ToolbarDark else ToolbarLight)
-      .padding(horizontal = 8.dp)
-  ) {
-    IconButton(onClick = { scaffoldCtrl.toggleDrawer() }) {
-      Icon(
-        Icons.Outlined.Menu,
-        stringResource(R.string.icon_descr_settings),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-    Text(
-      stringResource(R.string.your_chats),
-      color = MaterialTheme.colors.onBackground,
-      fontWeight = FontWeight.SemiBold,
-      modifier = Modifier.padding(5.dp)
-    )
-    IconButton(onClick = { scaffoldCtrl.toggleSheet() }) {
-      Icon(
-        Icons.Outlined.PersonAdd,
-        stringResource(R.string.add_contact),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-  }
-}
-
-@Composable
-fun ChatList(chatModel: ChatModel) {
-  LazyColumn(
-    modifier = Modifier.fillMaxWidth()
-  ) {
-    items(chatModel.chats) { chat ->
-      ChatListNavLinkView(chat, chatModel)
-    }
-  }
-}

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

@@ -1,136 +0,0 @@
-package chat.simplex.app.views.chatlist
-
-import android.content.res.Configuration
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.ErrorOutline
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.chat.item.MarkdownText
-import chat.simplex.app.views.helpers.ChatInfoImage
-import chat.simplex.app.views.helpers.badgeLayout
-
-@Composable
-fun ChatPreviewView(chat: Chat) {
-  Row {
-    val cInfo = chat.chatInfo
-    ChatInfoImage(cInfo, size = 72.dp)
-    Column(
-      modifier = Modifier
-        .padding(horizontal = 8.dp)
-        .weight(1F)
-    ) {
-      Text(
-        cInfo.chatViewName,
-        maxLines = 1,
-        overflow = TextOverflow.Ellipsis,
-        style = MaterialTheme.typography.h3,
-        fontWeight = FontWeight.Bold,
-        color = if (cInfo.ready) Color.Unspecified else HighOrLowlight
-      )
-      if (cInfo.ready) {
-        val ci = chat.chatItems.lastOrNull()
-        if (ci != null) {
-          MarkdownText(
-            ci.text, ci.formattedText, ci.memberDisplayName,
-            metaText = ci.timestampText,
-            maxLines = 2,
-            overflow = TextOverflow.Ellipsis,
-            style = MaterialTheme.typography.body1.copy(color = if (isSystemInDarkTheme()) MessagePreviewDark else MessagePreviewLight, lineHeight = 22.sp),
-          )
-        }
-      } else {
-        Text(stringResource(R.string.contact_connection_pending), color = HighOrLowlight)
-      }
-    }
-    val ts = chat.chatItems.lastOrNull()?.timestampText ?: getTimestampText(chat.chatInfo.updatedAt)
-
-    Box(
-      contentAlignment = Alignment.TopEnd
-    ) {
-      Text(
-        ts,
-        color = HighOrLowlight,
-        style = MaterialTheme.typography.body2,
-        modifier = Modifier.padding(bottom = 5.dp)
-      )
-      val n = chat.chatStats.unreadCount
-      if (n > 0) {
-        Box(
-          Modifier.padding(top = 24.dp),
-          contentAlignment = Alignment.Center
-        ) {
-          Text(
-            if (n < 1000) "$n" else "${n / 1000}" + stringResource(R.string.thousand_abbreviation),
-            color = MaterialTheme.colors.onPrimary,
-            fontSize = 11.sp,
-            modifier = Modifier
-              .background(MaterialTheme.colors.primary, shape = CircleShape)
-              .badgeLayout()
-              .padding(horizontal = 3.dp)
-              .padding(vertical = 1.dp)
-          )
-        }
-      }
-      if (cInfo is ChatInfo.Direct) {
-        Box(
-          Modifier.padding(top = 52.dp),
-          contentAlignment = Alignment.Center
-        ) {
-          ChatStatusImage(chat)
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun ChatStatusImage(chat: Chat) {
-  val s = chat.serverInfo.networkStatus
-  val descr = s.statusString
-  if (s is Chat.NetworkStatus.Error) {
-    Icon(
-      Icons.Outlined.ErrorOutline,
-      contentDescription = descr,
-      tint = HighOrLowlight,
-      modifier = Modifier
-        .size(19.dp)
-    )
-  } else if (s !is Chat.NetworkStatus.Connected) {
-    CircularProgressIndicator(
-      Modifier
-        .padding(horizontal = 2.dp)
-        .size(15.dp),
-      color = HighOrLowlight,
-      strokeWidth = 1.5.dp
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewChatPreviewView() {
-  SimpleXTheme {
-    ChatPreviewView(Chat.sampleData)
-  }
-}

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

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

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

@@ -1,99 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import android.util.Log
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import chat.simplex.app.R
-import chat.simplex.app.TAG
-
-class AlertManager {
-  var alertView = mutableStateOf<(@Composable () -> Unit)?>(null)
-  var presentAlert = mutableStateOf<Boolean>(false)
-
-  fun showAlert(alert: @Composable () -> Unit) {
-    Log.d(TAG, "AlertManager.showAlert")
-    alertView.value = alert
-    presentAlert.value = true
-  }
-
-  fun hideAlert() {
-    presentAlert.value = false
-    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 = generalGetString(R.string.ok),
-    onConfirm: (() -> Unit)? = null,
-    dismissText: String = generalGetString(R.string.cancel_verb),
-    onDismiss: (() -> Unit)? = null
-  ) {
-    val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
-    showAlert {
-      AlertDialog(
-        onDismissRequest = this::hideAlert,
-        title = { Text(title) },
-        text = alertText,
-        confirmButton = {
-          Button(onClick = {
-            onConfirm?.invoke()
-            hideAlert()
-          }) { Text(confirmText) }
-        },
-        dismissButton = {
-          Button(onClick = {
-            onDismiss?.invoke()
-            hideAlert()
-          }) { Text(dismissText) }
-        }
-      )
-    }
-  }
-
-  fun showAlertMsg(
-    title: String, text: String? = null,
-    confirmText: String = generalGetString(R.string.ok), onConfirm: (() -> Unit)? = null
-  ) {
-    val alertText: (@Composable () -> Unit)? = if (text == null) null else { -> Text(text) }
-    showAlert {
-      AlertDialog(
-        onDismissRequest = this::hideAlert,
-        title = { Text(title) },
-        text = alertText,
-        confirmButton = {
-          Button(onClick = {
-            onConfirm?.invoke()
-            hideAlert()
-          }) { Text(confirmText) }
-        }
-      )
-    }
-  }
-
-  @Composable
-  fun showInView() {
-    if (presentAlert.value) alertView.value?.invoke()
-  }
-
-  companion object {
-    val shared = AlertManager()
-  }
-}

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

@@ -1,70 +0,0 @@
-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
-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.Color
-import androidx.compose.ui.graphics.asImageBitmap
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.layout.ContentScale
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatInfo
-import chat.simplex.app.ui.theme.SimpleXTheme
-
-@Composable
-fun ChatInfoImage(chatInfo: ChatInfo, size: Dp) {
-  val icon =
-    if (chatInfo is ChatInfo.Group) Icons.Filled.SupervisedUserCircle
-                                    else Icons.Filled.AccountCircle
-  ProfileImage(size, chatInfo.image, icon)
-}
-
-@Composable
-fun ProfileImage(
-  size: Dp,
-  image: String? = null,
-  icon: ImageVector = Icons.Filled.AccountCircle,
-  color: Color = MaterialTheme.colors.secondary
-) {
-  Box(Modifier.size(size)) {
-    if (image == null) {
-      Icon(
-        icon,
-        contentDescription = stringResource(R.string.icon_descr_profile_image_placeholder),
-        tint = color,
-        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)
-      )
-    }
-  }
-}
-
-@Preview
-@Composable
-fun PreviewChatInfoImage() {
-  SimpleXTheme {
-    ChatInfoImage(
-      chatInfo = ChatInfo.Direct.sampleData,
-      size = 55.dp
-    )
-  }
-}

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

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

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

@@ -1,48 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Close
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.ui.theme.SimpleXTheme
-
-@Composable
-fun CloseSheetBar(close: () -> Unit) {
-  Row (
-    Modifier
-      .fillMaxWidth()
-      .height(60.dp),
-    horizontalArrangement = Arrangement.End,
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    IconButton(onClick = close) {
-      Icon(
-        Icons.Outlined.Close,
-        stringResource(R.string.icon_descr_close_button),
-        tint = MaterialTheme.colors.primary,
-        modifier = Modifier.padding(10.dp)
-      )
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewCloseSheetBar() {
-  SimpleXTheme {
-    CloseSheetBar(close = {})
-  }
-}

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

@@ -1,213 +0,0 @@
-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.Collections
-import androidx.compose.material.icons.outlined.PhotoCamera
-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,
-  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()
-    }
-  }
-
-  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()
-      }
-    }
-  }
-}

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

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

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

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

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

@@ -1,65 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import android.util.Log
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Surface
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.TAG
-
-@Composable
-fun ModalView(
-  close: () -> Unit,
-  background: Color = MaterialTheme.colors.background,
-  modifier: Modifier = Modifier.padding(horizontal = 16.dp),
-  content: @Composable () -> Unit,
-) {
-  BackHandler(onBack = close)
-  Surface(Modifier.fillMaxSize()) {
-    Column(Modifier.background(background)) {
-      CloseSheetBar(close)
-      Box(modifier) { content() }
-    }
-  }
-}
-
-class ModalManager {
-  private val modalViews = arrayListOf<(@Composable (close: () -> Unit) -> Unit)?>()
-  private val modalCount = mutableStateOf(0)
-
-  fun showModal(content: @Composable () -> Unit) {
-    showCustomModal { close -> ModalView(close, content = content) }
-  }
-
-  fun showCustomModal(modal: @Composable (close: () -> Unit) -> Unit) {
-    Log.d(TAG, "ModalManager.showModal")
-    modalViews.add(modal)
-    modalCount.value = modalViews.count()
-  }
-
-  fun closeModal() {
-    if (modalViews.isNotEmpty()) {
-      modalViews.removeAt(modalViews.count() - 1)
-    }
-    modalCount.value = modalViews.count()
-  }
-
-  fun closeModals() {
-    while (modalViews.isNotEmpty()) closeModal()
-  }
-
-  @Composable
-  fun showInView() {
-    if (modalCount.value > 0) modalViews.lastOrNull()?.invoke(::closeModal)
-  }
-
-  companion object {
-    val shared = ModalManager()
-  }
-}

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

@@ -1,17 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.layout.layout
-
-fun Modifier.badgeLayout() =
-  layout { measurable, constraints ->
-    val placeable = measurable.measure(constraints)
-
-    // based on the expectation of only one line of text
-    val minPadding = placeable.height / 4
-
-    val width = maxOf(placeable.width + minPadding, placeable.height)
-    layout(width, placeable.height) {
-      placeable.place((width - placeable.width) / 2, 0)
-    }
-  }

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

@@ -1,77 +0,0 @@
-package chat.simplex.app.views.helpers
-
-import android.content.*
-import android.net.Uri
-import android.provider.MediaStore
-import android.widget.Toast
-import androidx.activity.compose.ManagedActivityResultLauncher
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.runtime.Composable
-import androidx.core.content.ContextCompat
-import chat.simplex.app.R
-import chat.simplex.app.model.CIFile
-import java.io.BufferedOutputStream
-import java.io.File
-
-fun shareText(cxt: Context, text: String) {
-  val sendIntent: Intent = Intent().apply {
-    action = Intent.ACTION_SEND
-    putExtra(Intent.EXTRA_TEXT, text)
-    type = "text/plain"
-  }
-  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

@@ -1,49 +0,0 @@
-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
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-
-@Composable
-fun SimpleButton(text: String, icon: ImageVector,
-                 color: Color = MaterialTheme.colors.primary,
-                 click: () -> Unit) {
-  SimpleButtonFrame(click) {
-    Icon(
-      icon, text, tint = color,
-      modifier = Modifier.padding(end = 8.dp)
-    )
-    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() }
-  }
-}
-
-@Preview
-@Composable
-fun PreviewCloseSheetBar() {
-  SimpleXTheme {
-    SimpleButton(text = "Share", icon = Icons.Outlined.Share, click = {})
-  }
-}

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

@@ -1,58 +0,0 @@
-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,347 +0,0 @@
-package chat.simplex.app.views.helpers
-
-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.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 = withScope(GlobalScope, action)
-
-fun withScope(scope: CoroutineScope, action: suspend CoroutineScope.() -> Unit): Job =
-  scope.launch { withContext(Dispatchers.Main, action) }
-
-enum class KeyboardState {
-  Opened, Closed
-}
-
-@Composable
-fun getKeyboardState(): State<KeyboardState> {
-  val keyboardState = remember { mutableStateOf(KeyboardState.Closed) }
-  val view = LocalView.current
-  DisposableEffect(view) {
-    val onGlobalListener = ViewTreeObserver.OnGlobalLayoutListener {
-      val rect = Rect()
-      view.getWindowVisibleDisplayFrame(rect)
-      val screenHeight = view.rootView.height
-      val keypadHeight = screenHeight - rect.bottom
-      keyboardState.value = if (keypadHeight > screenHeight * 0.15) {
-        KeyboardState.Opened
-      } else {
-        KeyboardState.Closed
-      }
-    }
-    view.viewTreeObserver.addOnGlobalLayoutListener(onGlobalListener)
-
-    onDispose {
-      view.viewTreeObserver.removeOnGlobalLayoutListener(onGlobalListener)
-    }
-  }
-
-  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

@@ -1,88 +0,0 @@
-package chat.simplex.app.views.newchat
-
-import android.content.res.Configuration
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Share
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-import chat.simplex.app.ui.theme.SimpleButton
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.shareText
-
-@Composable
-fun AddContactView(chatModel: ChatModel) {
-  val connReq = chatModel.connReqInvitation
-  if (connReq != null) {
-    val cxt = LocalContext.current
-    AddContactLayout(
-      connReq = connReq,
-      share = { shareText(cxt, connReq) }
-    )
-  }
-}
-
-@Composable
-fun AddContactLayout(connReq: String, share: () -> Unit) {
-  BoxWithConstraints {
-    val screenHeight = maxHeight
-    Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.SpaceBetween,
-    ) {
-      Text(
-        stringResource(R.string.add_contact),
-        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      )
-      Text(
-        stringResource(R.string.show_QR_code_for_your_contact_to_scan_from_the_app__multiline),
-        style = MaterialTheme.typography.h3,
-        textAlign = TextAlign.Center,
-      )
-      QRCode(
-        connReq, Modifier
-          .weight(1f, fill = false)
-          .aspectRatio(1f)
-          .padding(vertical = 3.dp)
-      )
-      Text(
-        stringResource(R.string.if_you_cannot_meet_in_person_show_QR_in_video_call_or_via_another_channel),
-        textAlign = TextAlign.Center,
-        lineHeight = 22.sp,
-        modifier = Modifier
-          .padding(horizontal = 16.dp)
-          .padding(bottom = if (screenHeight > 600.dp) 16.dp else 8.dp)
-      )
-      SimpleButton(stringResource(R.string.share_invitation_link), icon = Icons.Outlined.Share, click = share)
-      Spacer(Modifier.height(10.dp))
-    }
-  }
-}
-
-@Preview
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewAddContactView() {
-  SimpleXTheme {
-    AddContactLayout(
-      connReq = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D",
-      share = {}
-    )
-  }
-}

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

@@ -1,154 +0,0 @@
-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.*
-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
-
-@Composable
-fun NewChatSheet(chatModel: ChatModel, newChatCtrl: ScaffoldController) {
-  val cameraPermissionState = rememberPermissionState(permission = Manifest.permission.CAMERA)
-  NewChatSheetLayout(
-    addContact = {
-      withApi {
-        //        show spinner
-        chatModel.connReqInvitation = chatModel.controller.apiAddContact()
-        //        hide spinner
-        if (chatModel.connReqInvitation != null) {
-          newChatCtrl.collapse()
-          ModalManager.shared.showModal { AddContactView(chatModel) }
-        }
-      }
-    },
-    scanCode = {
-      newChatCtrl.collapse()
-      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, pasteLink: () -> Unit) {
-  Column(
-    horizontalAlignment = Alignment.CenterHorizontally
-  ) {
-    Text(
-      stringResource(R.string.add_contact_to_start_new_chat),
-      modifier = Modifier.padding(horizontal = 8.dp).padding(top = 32.dp)
-    )
-    Row(
-      Modifier
-        .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,
-                 click: () -> Unit = {}) {
-  Surface(shape = RoundedCornerShape(18.dp)) {
-    Column(
-      Modifier
-        .clickable(onClick = click)
-        .padding(8.dp),
-      horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-      val tint = if (disabled) HighOrLowlight else MaterialTheme.colors.primary
-      Icon(icon, text,
-        tint = tint,
-        modifier = Modifier
-          .size(40.dp)
-          .padding(bottom = 8.dp))
-      if (text != null) {
-        Text(
-          text,
-          textAlign = TextAlign.Center,
-          fontWeight = FontWeight.Bold,
-          color = tint,
-          modifier = Modifier.padding(bottom = 4.dp)
-        )
-      }
-      if (comment != null) {
-        Text(
-          comment,
-          textAlign = TextAlign.Center,
-          style = MaterialTheme.typography.body2
-        )
-      }
-    }
-  }
-}
-
-@Preview
-@Composable
-fun PreviewNewChatSheet() {
-  SimpleXTheme {
-    NewChatSheetLayout(
-      addContact = {},
-      scanCode = {},
-      pasteLink = {}
-    )
-  }
-}

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

@@ -1,127 +0,0 @@
-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,38 +0,0 @@
-package chat.simplex.app.views.newchat
-
-import android.graphics.Bitmap
-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
-
-@Composable
-fun QRCode(connReq: String, modifier: Modifier = Modifier) {
-  Image(
-    bitmap = qrCodeBitmap(connReq, 1024).asImageBitmap(),
-    contentDescription = stringResource(R.string.image_descr_qr_code),
-    modifier = modifier
-  )
-}
-
-fun qrCodeBitmap(content: String, size: Int): Bitmap {
-  val qrCode = QrCodeEncoder().addAutomatic(content).fixate()
-  val renderer = QrCodeGeneratorImage(5)
-  renderer.render(qrCode)
-  return ConvertBitmap.grayToBitmap(renderer.gray, Bitmap.Config.RGB_565)
-}
-
-@Preview
-@Composable
-fun PreviewQRCode() {
-  SimpleXTheme {
-    QRCode(connReq = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D")
-  }
-}

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

@@ -1,99 +0,0 @@
-package chat.simplex.app.views.newchat
-
-import android.annotation.SuppressLint
-import android.util.Log
-import android.view.ViewGroup
-import androidx.camera.core.*
-import androidx.camera.lifecycle.ProcessCameraProvider
-import androidx.camera.view.PreviewView
-import androidx.compose.runtime.*
-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 java.util.concurrent.*
-
-// 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 ->
-      PreviewView(AndroidViewContext).apply {
-        this.scaleType = PreviewView.ScaleType.FILL_CENTER
-        layoutParams = ViewGroup.LayoutParams(
-          ViewGroup.LayoutParams.MATCH_PARENT,
-          ViewGroup.LayoutParams.MATCH_PARENT,
-        )
-        implementationMode = PreviewView.ImplementationMode.COMPATIBLE
-      }
-    }
-  ) { 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 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)
-            }
-          }
-        }
-        imageProxy.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

@@ -1,113 +0,0 @@
-package chat.simplex.app.views.newchat
-
-import android.content.res.Configuration
-import android.net.Uri
-import androidx.activity.compose.BackHandler
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.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.*
-
-@Composable
-fun ScanToConnectView(chatModel: ChatModel, close: () -> Unit) {
-  BackHandler(onBack = close)
-  ConnectContactLayout(
-    qrCodeScanner = {
-      QRCodeScanner { 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_QR_code),
-            text = generalGetString(R.string.this_QR_code_is_not_a_link)
-          )
-        }
-        close()
-      }
-    },
-    close = close
-  )
-}
-
-fun withUriAction(uri: Uri, run: suspend (String) -> Unit) {
-  val action = uri.path?.drop(1)
-  if (action == "contact" || action == "invitation") {
-    withApi { run(action) }
-  } else {
-    AlertManager.shared.showAlertMsg(
-      title = generalGetString(R.string.invalid_contact_link),
-      text = generalGetString(R.string.this_link_is_not_a_valid_connection_link)
-    )
-  }
-}
-
-suspend fun connectViaUri(chatModel: ChatModel, action: String, uri: Uri) {
-  val r = chatModel.controller.apiConnect(uri.toString())
-  if (r) {
-    AlertManager.shared.showAlertMsg(
-      title = generalGetString(R.string.connection_request_sent),
-      text =
-        if (action == "contact") generalGetString(R.string.you_will_be_connected_when_your_connection_request_is_accepted)
-        else generalGetString(R.string.you_will_be_connected_when_your_contacts_device_is_online)
-    )
-  }
-}
-
-@Composable
-fun ConnectContactLayout(qrCodeScanner: @Composable () -> Unit, close: () -> Unit) {
-  ModalView(close) {
-    Column(
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.spacedBy(12.dp)
-    ) {
-      Text(
-        generalGetString(R.string.scan_QR_code),
-        style = MaterialTheme.typography.h1.copy(fontWeight = FontWeight.Normal),
-      )
-      Text(
-        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)
-      )
-      Box(
-        Modifier
-          .fillMaxWidth()
-          .aspectRatio(ratio = 1F)
-      ) { qrCodeScanner() }
-      Text(
-        annotatedStringResource(R.string.if_you_cannot_meet_in_person_scan_QR_in_video_call_or_ask_for_invitation_link),
-        lineHeight = 22.sp
-      )
-    }
-  }
-}
-
-@Preview
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewConnectContactLayout() {
-  SimpleXTheme {
-    ConnectContactLayout(
-      qrCodeScanner = { Surface {} },
-      close = {},
-    )
-  }
-}

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

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

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

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

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

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

@@ -1,94 +0,0 @@
-package chat.simplex.app.views.usersettings
-
-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.res.stringResource
-import androidx.compose.ui.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.HighOrLowlight
-
-@Composable
-fun CallSettingsView(m: ChatModel) {
-  CallSettingsLayout(
-    webrtcPolicyRelay = m.controller.appPrefs.webrtcPolicyRelay,
-    callOnLockScreen = m.controller.appPrefs.callOnLockScreen
-  )
-}
-
-@Composable
-fun CallSettingsLayout(
-  webrtcPolicyRelay: Preference<Boolean>,
-  callOnLockScreen: Preference<CallOnLockScreen>,
-) {
-  Column(
-    Modifier.fillMaxWidth(),
-    horizontalAlignment = Alignment.Start,
-    verticalArrangement = Arrangement.spacedBy(8.dp)
-  ) {
-    @Composable fun divider() = Divider(Modifier.padding(horizontal = 8.dp))
-    val lockCallState = remember { mutableStateOf(callOnLockScreen.get()) }
-    Text(
-      stringResource(R.string.your_calls),
-      Modifier.padding(start = 16.dp, bottom = 24.dp),
-      style = MaterialTheme.typography.h1
-    )
-    SettingsSectionView(stringResource(R.string.settings_section_title_settings)) {
-      Box(Modifier.padding(start = 10.dp)) {
-        SharedPreferenceToggle(stringResource(R.string.connect_calls_via_relay), webrtcPolicyRelay)
-      }
-      divider()
-
-      Column(Modifier.padding(start = 10.dp, top = 12.dp)) {
-        Text(stringResource(R.string.call_on_lock_screen))
-        Row {
-          SharedPreferenceRadioButton(stringResource(R.string.no_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.DISABLE)
-          Spacer(Modifier.fillMaxWidth().weight(1f))
-          SharedPreferenceRadioButton(stringResource(R.string.show_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.SHOW)
-          Spacer(Modifier.fillMaxWidth().weight(1f))
-          SharedPreferenceRadioButton(stringResource(R.string.accept_call_on_lock_screen), lockCallState, callOnLockScreen, CallOnLockScreen.ACCEPT)
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun SharedPreferenceToggle(
-  text: String,
-  preference: Preference<Boolean>,
-  preferenceState: MutableState<Boolean>? = null
-) {
-  val prefState = preferenceState ?: remember { mutableStateOf(preference.get()) }
-  Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) {
-    Text(text, Modifier.padding(end = 24.dp))
-    Spacer(Modifier.fillMaxWidth().weight(1f))
-    Switch(
-      checked = prefState.value,
-      onCheckedChange = {
-        preference.set(it)
-        prefState.value = it
-      },
-      colors = SwitchDefaults.colors(
-        checkedThumbColor = MaterialTheme.colors.primary,
-        uncheckedThumbColor = HighOrLowlight
-      ),
-      modifier = Modifier.padding(end = 6.dp)
-    )
-  }
-}
-
-@Composable
-fun <T>SharedPreferenceRadioButton(text: String, prefState: MutableState<T>, preference: Preference<T>, value: T) {
-  Row(verticalAlignment = Alignment.CenterVertically) {
-    Text(text)
-    val colors = RadioButtonDefaults.colors(selectedColor = MaterialTheme.colors.primary)
-    RadioButton(selected = prefState.value == value, colors = colors, onClick = {
-      preference.set(value)
-      prefState.value = value
-    })
-  }
-}

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

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

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

@@ -1,57 +0,0 @@
-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.chatlist.ChatHelpView
-
-@Composable
-fun HelpView(chatModel: ChatModel) {
-  val user = chatModel.currentUser.value
-  if (user != null) {
-    HelpLayout(displayName = user.profile.displayName)
-  }
-}
-
-@Composable
-fun HelpLayout(displayName: String) {
-  Column(
-    Modifier
-      .verticalScroll(rememberScrollState())
-      .padding(bottom = 16.dp),
-    horizontalAlignment = Alignment.Start
-  ){
-    Text(
-      String.format(stringResource(R.string.personal_welcome), displayName),
-      Modifier.padding(bottom = 24.dp),
-      style = MaterialTheme.typography.h1,
-    )
-    ChatHelpView()
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewHelpView() {
-  SimpleXTheme {
-    HelpLayout(displayName = "Alice")
-  }
-}

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

@@ -1,39 +0,0 @@
-package chat.simplex.app.views.usersettings
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.Image
-import androidx.compose.material.icons.outlined.TravelExplore
-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.unit.dp
-import chat.simplex.app.R
-import chat.simplex.app.model.ChatModel
-
-@Composable
-fun PrivacySettingsView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit) {
-  @Composable fun divider() = Divider(Modifier.padding(horizontal = 8.dp))
-  Column(
-    Modifier.fillMaxWidth(),
-    horizontalAlignment = Alignment.Start
-  ) {
-    Text(
-      stringResource(R.string.your_privacy),
-      style = MaterialTheme.typography.h1,
-      modifier = Modifier.padding(start = 16.dp, bottom = 24.dp)
-    )
-    SettingsSectionView(stringResource(R.string.settings_section_title_device)) {
-      ChatLockItem(chatModel.performLA, setPerformLA)
-    }
-    Spacer(Modifier.height(30.dp))
-
-    SettingsSectionView(stringResource(R.string.settings_section_title_chats)) {
-      SettingsPreferenceItem(Icons.Outlined.Image, stringResource(R.string.auto_accept_images), chatModel.controller.appPrefs.privacyAcceptImages)
-      divider()
-      SettingsPreferenceItem(Icons.Outlined.TravelExplore, stringResource(R.string.send_link_previews), chatModel.controller.appPrefs.privacyLinkPreviews)
-    }
-  }
-}

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

@@ -1,261 +0,0 @@
-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.selection.SelectionContainer
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-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.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.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.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.*
-
-@Composable
-fun SMPServersView(chatModel: ChatModel) {
-  val userSMPServers = chatModel.userSMPServers.value
-  if (userSMPServers != null) {
-    var isUserSMPServers by remember { mutableStateOf(userSMPServers.isNotEmpty()) }
-    var editSMPServers by remember { mutableStateOf(!isUserSMPServers) }
-    val userSMPServersStr = remember { mutableStateOf(if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else "") }
-    fun saveSMPServers(smpServers: List<String>) {
-      withApi {
-        val r = chatModel.controller.setUserSMPServers(smpServers = smpServers)
-        if (r) {
-          chatModel.userSMPServers.value = smpServers
-          if (smpServers.isEmpty()) {
-            isUserSMPServers = false
-            editSMPServers = true
-          } else {
-            editSMPServers = false
-          }
-        }
-      }
-    }
-
-    SMPServersLayout(
-      isUserSMPServers = isUserSMPServers,
-      editSMPServers = editSMPServers,
-      userSMPServersStr = userSMPServersStr,
-      isUserSMPServersOnOff = { switch ->
-        if (switch) {
-          isUserSMPServers = true
-        } else {
-          val userSMPServers = chatModel.userSMPServers.value
-          if (userSMPServers != null) {
-            if (userSMPServers.isNotEmpty()) {
-              AlertManager.shared.showAlertMsg(
-                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.value = ""
-                }
-              )
-            } else {
-              isUserSMPServers = false
-              userSMPServersStr.value = ""
-            }
-          }
-        }
-      },
-      cancelEdit = {
-        val userSMPServers = chatModel.userSMPServers.value
-        if (userSMPServers != null) {
-          isUserSMPServers = userSMPServers.isNotEmpty()
-          editSMPServers = !isUserSMPServers
-          userSMPServersStr.value = if (isUserSMPServers) userSMPServers.joinToString(separator = "\n") else ""
-        }
-      },
-      saveSMPServers = { saveSMPServers(it) },
-      editOn = { editSMPServers = true },
-    )
-  }
-}
-
-@Composable
-fun SMPServersLayout(
-  isUserSMPServers: Boolean,
-  editSMPServers: Boolean,
-  userSMPServersStr: MutableState<String>,
-  isUserSMPServersOnOff: (Boolean) -> Unit,
-  cancelEdit: () -> Unit,
-  saveSMPServers: (List<String>) -> Unit,
-  editOn: () -> Unit,
-) {
-  Column(
-    Modifier.fillMaxWidth(),
-    horizontalAlignment = Alignment.Start,
-    verticalArrangement = Arrangement.spacedBy(8.dp)
-  ) {
-    Text(
-      stringResource(R.string.your_SMP_servers),
-      Modifier.padding(bottom = 24.dp),
-      style = MaterialTheme.typography.h1
-    )
-    Row(
-      verticalAlignment = Alignment.CenterVertically
-    ) {
-      Text(stringResource(R.string.configure_SMP_servers), Modifier.padding(end = 24.dp))
-      Switch(
-        checked = isUserSMPServers,
-        onCheckedChange = isUserSMPServersOnOff,
-        colors = SwitchDefaults.colors(
-          checkedThumbColor = MaterialTheme.colors.primary,
-          uncheckedThumbColor = HighOrLowlight
-        ),
-      )
-    }
-
-    if (!isUserSMPServers) {
-      Text(stringResource(R.string.using_simplex_chat_servers), lineHeight = 22.sp)
-    } else {
-      Text(stringResource(R.string.enter_one_SMP_server_per_line))
-      if (editSMPServers) {
-        TextEditor(Modifier.height(160.dp), text = userSMPServersStr)
-
-        Row(
-          Modifier.fillMaxWidth(),
-          horizontalArrangement = Arrangement.SpaceBetween,
-          verticalAlignment = Alignment.CenterVertically
-        ) {
-          Column(horizontalAlignment = Alignment.Start) {
-            Row {
-              Text(
-                stringResource(R.string.cancel_verb),
-                color = MaterialTheme.colors.primary,
-                modifier = Modifier
-                  .clickable(onClick = cancelEdit)
-              )
-              Spacer(Modifier.padding(horizontal = 8.dp))
-              Text(
-                stringResource(R.string.save_servers_button),
-                color = MaterialTheme.colors.primary,
-                modifier = Modifier.clickable(onClick = {
-                  val servers = userSMPServersStr.value.split("\n")
-                  saveSMPServers(servers)
-                })
-              )
-            }
-          }
-          Column(horizontalAlignment = Alignment.End) {
-            howToButton()
-          }
-        }
-      } else {
-        Surface(
-          modifier = Modifier
-            .height(160.dp)
-            .fillMaxWidth(),
-          shape = RoundedCornerShape(10.dp),
-          border = BorderStroke(1.dp, MaterialTheme.colors.secondary)
-        ) {
-          SelectionContainer(
-            Modifier.verticalScroll(rememberScrollState())
-          ) {
-            Text(
-              userSMPServersStr.value,
-              Modifier
-                .padding(vertical = 5.dp, horizontal = 7.dp),
-              style = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 14.sp),
-            )
-          }
-        }
-        Row(
-          Modifier.fillMaxWidth(),
-          horizontalArrangement = Arrangement.SpaceBetween,
-          verticalAlignment = Alignment.CenterVertically
-        ) {
-          Column(horizontalAlignment = Alignment.Start) {
-            Text(
-              stringResource(R.string.edit_verb),
-              color = MaterialTheme.colors.primary,
-              modifier = Modifier
-                .clickable(onClick = editOn)
-            )
-          }
-          Column(horizontalAlignment = Alignment.End) {
-            howToButton()
-          }
-        }
-      }
-    }
-  }
-}
-
-@Composable
-fun howToButton() {
-  val uriHandler = LocalUriHandler.current
-  Row(
-    verticalAlignment = Alignment.CenterVertically,
-    modifier = Modifier.clickable { uriHandler.openUri("https://github.com/simplex-chat/simplexmq#using-smp-server-and-smp-agent") }
-  ) {
-    Text(stringResource(R.string.how_to), color = MaterialTheme.colors.primary)
-    Icon(
-      Icons.Outlined.OpenInNew, stringResource(R.string.how_to), tint = MaterialTheme.colors.primary,
-      modifier = Modifier.padding(horizontal = 5.dp)
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Composable
-fun PreviewSMPServersLayoutDefaultServers() {
-  SimpleXTheme {
-    SMPServersLayout(
-      isUserSMPServers = false,
-      editSMPServers = true,
-      userSMPServersStr = remember { mutableStateOf("") },
-      isUserSMPServersOnOff = {},
-      cancelEdit = {},
-      saveSMPServers = {},
-      editOn = {},
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Composable
-fun PreviewSMPServersLayoutUserServersEditOn() {
-  SimpleXTheme {
-    SMPServersLayout(
-      isUserSMPServers = true,
-      editSMPServers = true,
-      userSMPServersStr = remember { mutableStateOf("smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im") },
-      isUserSMPServersOnOff = {},
-      cancelEdit = {},
-      saveSMPServers = {},
-      editOn = {},
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Composable
-fun PreviewSMPServersLayoutUserServersEditOff() {
-  SimpleXTheme {
-    SMPServersLayout(
-      isUserSMPServers = true,
-      editSMPServers = false,
-      userSMPServersStr = remember { mutableStateOf("smp://u2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU=@smp4.simplex.im\nsmp://hpq7_4gGJiilmz5Rf-CswuU5kZGkm_zOIooSw6yALRg=@smp5.simplex.im") },
-      isUserSMPServersOnOff = {},
-      cancelEdit = {},
-      saveSMPServers = {},
-      editOn = {},
-    )
-  }
-}

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

@@ -1,313 +0,0 @@
-package chat.simplex.app.views.usersettings
-
-import android.content.res.Configuration
-import androidx.compose.foundation.*
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalUriHandler
-import androidx.compose.ui.platform.UriHandler
-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.*
-import chat.simplex.app.BuildConfig
-import chat.simplex.app.R
-import chat.simplex.app.model.*
-import chat.simplex.app.ui.theme.*
-import chat.simplex.app.views.TerminalView
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.onboarding.SimpleXInfo
-
-@Composable
-fun SettingsView(chatModel: ChatModel, setPerformLA: (Boolean) -> Unit) {
-  val user = chatModel.currentUser.value
-
-  fun setRunServiceInBackground(on: Boolean) {
-    chatModel.controller.appPrefs.runServiceInBackground.set(on)
-    if (on && !chatModel.controller.isIgnoringBatteryOptimizations(chatModel.controller.appContext)) {
-      chatModel.controller.appPrefs.backgroundServiceNoticeShown.set(false)
-    }
-    chatModel.controller.showBackgroundServiceNoticeIfNeeded()
-    chatModel.runServiceInBackground.value = on
-  }
-
-  if (user != null) {
-    SettingsLayout(
-      profile = user.profile,
-      runServiceInBackground = chatModel.runServiceInBackground,
-      setRunServiceInBackground = ::setRunServiceInBackground,
-      setPerformLA = setPerformLA,
-      enableCalls = remember { mutableStateOf(chatModel.controller.appPrefs.experimentalCalls.get()) },
-      showModal = { modalView -> { ModalManager.shared.showModal { modalView(chatModel) } } },
-      showSettingsModal = { modalView -> { ModalManager.shared.showCustomModal { close ->
-        ModalView(close = close, modifier = Modifier,
-          background = if (isSystemInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight) {
-          modalView(chatModel)
-        }
-      } } },
-      showCustomModal = { modalView -> { ModalManager.shared.showCustomModal { close -> modalView(chatModel, close) } } },
-      showTerminal = { ModalManager.shared.showCustomModal { close -> TerminalView(chatModel, close) } }
-//      showVideoChatPrototype = { ModalManager.shared.showCustomModal { close -> CallViewDebug(close) } },
-    )
-  }
-}
-
-val simplexTeamUri =
-  "simplex:/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D"
-
-@Composable
-fun SettingsLayout(
-  profile: Profile,
-  runServiceInBackground: MutableState<Boolean>,
-  setRunServiceInBackground: (Boolean) -> Unit,
-  setPerformLA: (Boolean) -> Unit,
-  enableCalls: MutableState<Boolean>,
-  showModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
-  showSettingsModal: (@Composable (ChatModel) -> Unit) -> (() -> Unit),
-  showCustomModal: (@Composable (ChatModel, () -> Unit) -> Unit) -> (() -> Unit),
-  showTerminal: () -> Unit,
-//  showVideoChatPrototype: () -> Unit
-) {
-  val uriHandler = LocalUriHandler.current
-  Surface(Modifier.fillMaxSize().verticalScroll(rememberScrollState())) {
-    Column(
-      Modifier
-        .fillMaxSize()
-        .background(if (isSystemInDarkTheme()) MaterialTheme.colors.background else SettingsBackgroundLight)
-        .padding(top = 16.dp)
-    ) {
-      @Composable fun divider() = Divider(Modifier.padding(horizontal = 8.dp))
-      @Composable fun spacer() = Spacer(Modifier.height(30.dp))
-      Text(
-        stringResource(R.string.your_settings),
-        style = MaterialTheme.typography.h1,
-        modifier = Modifier.padding(start = 16.dp)
-      )
-      Spacer(Modifier.height(30.dp))
-
-      SettingsSectionView(stringResource(R.string.settings_section_title_you)) {
-        SettingsItemView(showCustomModal { chatModel, close -> UserProfileView(chatModel, close) }, 80.dp) {
-          ProfilePreview(profile)
-        }
-        divider()
-        SettingsActionItem(Icons.Outlined.QrCode, stringResource(R.string.your_simplex_contact_address), showModal { UserAddressView(it) })
-      }
-      spacer()
-
-      SettingsSectionView(stringResource(R.string.settings_section_title_settings)) {
-        if (enableCalls.value) {
-          SettingsActionItem(Icons.Outlined.Videocam, stringResource(R.string.settings_audio_video_calls), showSettingsModal { CallSettingsView(it) })
-          divider()
-        }
-        SettingsActionItem(Icons.Outlined.Lock, stringResource(R.string.privacy_and_security), showSettingsModal { PrivacySettingsView(it, setPerformLA) })
-        divider()
-        PrivateNotificationsItem(runServiceInBackground, setRunServiceInBackground)
-        divider()
-        SettingsActionItem(Icons.Outlined.Dns, stringResource(R.string.smp_servers), showModal { SMPServersView(it) })
-      }
-      spacer()
-
-      SettingsSectionView(stringResource(R.string.settings_section_title_help)) {
-        SettingsActionItem(Icons.Outlined.HelpOutline, stringResource(R.string.how_to_use_simplex_chat), showModal { HelpView(it) })
-        divider()
-        SettingsActionItem(Icons.Outlined.Info, stringResource(R.string.about_simplex_chat), showModal { SimpleXInfo(it, onboarding = false) })
-        divider()
-        SettingsActionItem(Icons.Outlined.TextFormat, stringResource(R.string.markdown_in_messages), showModal { MarkdownHelpView() })
-        divider()
-        SettingsActionItem(Icons.Outlined.Tag, stringResource(R.string.chat_with_the_founder), { uriHandler.openUri(simplexTeamUri) }, textColor = MaterialTheme.colors.primary)
-        divider()
-        SettingsActionItem(Icons.Outlined.Email, stringResource(R.string.send_us_an_email), { uriHandler.openUri("mailto:chat@simplex.chat") }, textColor = MaterialTheme.colors.primary)
-      }
-      spacer()
-
-      SettingsSectionView(stringResource(R.string.settings_section_title_develop)) {
-        ChatConsoleItem(showTerminal)
-        divider()
-        InstallTerminalAppItem(uriHandler)
-        divider()
-        SettingsActionItem(Icons.Outlined.Science, stringResource(R.string.settings_experimental_features), showSettingsModal { ExperimentalFeaturesView(it, enableCalls) })
-        divider()
-        AppVersionItem()
-      }
-    }
-  }
-}
-
-@Composable fun SettingsSectionView(title: String, content: (@Composable () -> Unit)) {
-  Column {
-    Text(title, color = HighOrLowlight, style = MaterialTheme.typography.body2,
-      modifier = Modifier.padding(start = 16.dp, bottom = 5.dp), fontSize = 12.sp)
-    Surface(color = if (isSystemInDarkTheme()) GroupDark else MaterialTheme.colors.background) {
-      Column(Modifier.padding(horizontal = 6.dp)) { content() }
-    }
-  }
-}
-
-@Composable private fun PrivateNotificationsItem(
-  runServiceInBackground: MutableState<Boolean>,
-  setRunServiceInBackground: (Boolean) -> Unit
-) {
-  SettingsItemView() {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      Icon(
-        Icons.Outlined.Bolt,
-        contentDescription = stringResource(R.string.private_notifications),
-        tint = HighOrLowlight,
-      )
-      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 = 6.dp)
-      )
-    }
-  }
-}
-
-@Composable fun ChatLockItem(performLA: MutableState<Boolean>, setPerformLA: (Boolean) -> Unit) {
-  SettingsItemView() {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      Icon(
-        Icons.Outlined.Lock,
-        contentDescription = stringResource(R.string.chat_lock),
-        tint = HighOrLowlight,
-      )
-      Spacer(Modifier.padding(horizontal = 4.dp))
-      Text(
-        stringResource(R.string.chat_lock), Modifier
-          .padding(end = 24.dp)
-          .fillMaxWidth()
-          .weight(1F)
-      )
-      Switch(
-        checked = performLA.value,
-        onCheckedChange = { setPerformLA(it) },
-        colors = SwitchDefaults.colors(
-          checkedThumbColor = MaterialTheme.colors.primary,
-          uncheckedThumbColor = HighOrLowlight
-        ),
-        modifier = Modifier.padding(end = 6.dp)
-      )
-    }
-  }
-}
-
-@Composable private fun ChatConsoleItem(showTerminal: () -> Unit) {
-  SettingsItemView(showTerminal) {
-    Icon(
-      painter = painterResource(id = R.drawable.ic_outline_terminal),
-      contentDescription = stringResource(R.string.chat_console),
-      tint = HighOrLowlight,
-    )
-    Spacer(Modifier.padding(horizontal = 4.dp))
-    Text(stringResource(R.string.chat_console))
-  }
-}
-
-@Composable private fun InstallTerminalAppItem(uriHandler: UriHandler) {
-  SettingsItemView({ uriHandler.openUri("https://github.com/simplex-chat/simplex-chat") }) {
-    Icon(
-      painter = painterResource(id = R.drawable.ic_github),
-      contentDescription = "GitHub",
-      tint = HighOrLowlight,
-    )
-    Spacer(Modifier.padding(horizontal = 4.dp))
-    Text(annotatedStringResource(R.string.install_simplex_chat_for_terminal))
-  }
-}
-
-@Composable private fun AppVersionItem() {
-  SettingsItemView() {
-    Text("v${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})")
-  }
-}
-
-@Composable fun ProfilePreview(profileOf: NamedChat, size: Dp = 60.dp, color: Color = MaterialTheme.colors.secondary) {
-  ProfileImage(size = size, image = profileOf.image, color = color)
-  Spacer(Modifier.padding(horizontal = 4.dp))
-  Column {
-    Text(
-      profileOf.displayName,
-      style = MaterialTheme.typography.caption,
-      fontWeight = FontWeight.Bold,
-    )
-    Text(profileOf.fullName)
-  }
-}
-
-@Composable
-fun SettingsItemView(click: (() -> Unit)? = null, height: Dp = 46.dp, content: (@Composable () -> Unit)) {
-  val modifier = Modifier
-    .padding(start = 8.dp)
-    .fillMaxWidth()
-    .height(height)
-  Row(
-    if (click == null) modifier else modifier.clickable(onClick = click),
-    verticalAlignment = Alignment.CenterVertically
-  ) {
-    content()
-  }
-}
-
-@Composable
-fun SettingsActionItem(icon: ImageVector, text: String, click: (() -> Unit)? = null, textColor: Color = Color.Unspecified) {
-  SettingsItemView(click) {
-    Icon(icon, text, tint = HighOrLowlight)
-    Spacer(Modifier.padding(horizontal = 4.dp))
-    Text(text, color = textColor)
-  }
-}
-
-@Composable
-fun SettingsPreferenceItem(icon: ImageVector, text: String, pref: Preference<Boolean>, prefState: MutableState<Boolean>? = null) {
-  SettingsItemView() {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-      Icon(icon, text, tint = HighOrLowlight)
-      Spacer(Modifier.padding(horizontal = 4.dp))
-      SharedPreferenceToggle(text, pref, prefState)
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewSettingsLayout() {
-  SimpleXTheme {
-    SettingsLayout(
-      profile = Profile.sampleData,
-      runServiceInBackground = remember { mutableStateOf(true) },
-      setRunServiceInBackground = {},
-      setPerformLA = {},
-      enableCalls = remember { mutableStateOf(true) },
-      showModal = { {} },
-      showSettingsModal = { {} },
-      showCustomModal = { {} },
-      showTerminal = {},
-//      showVideoChatPrototype = {}
-    )
-  }
-}

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

@@ -1,142 +0,0 @@
-package chat.simplex.app.views.usersettings
-
-import android.content.res.Configuration
-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.Composable
-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
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.newchat.QRCode
-
-@Composable
-fun UserAddressView(chatModel: ChatModel) {
-  val cxt = LocalContext.current
-  UserAddressLayout(
-    userAddress = chatModel.userAddress.value,
-    createAddress = {
-      withApi {
-        chatModel.userAddress.value = chatModel.controller.apiCreateUserAddress()
-      }
-    },
-    share = { userAddress: String -> shareText(cxt, userAddress) },
-    deleteAddress = {
-      AlertManager.shared.showAlertMsg(
-        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()
-            chatModel.userAddress.value = null
-          }
-        }
-      )
-    }
-  )
-}
-
-@Composable
-fun UserAddressLayout(
-  userAddress: String?,
-  createAddress: () -> Unit,
-  share: (String) -> Unit,
-  deleteAddress: () -> Unit
-) {
-  Column(
-    horizontalAlignment = Alignment.Start,
-    verticalArrangement = Arrangement.Top
-  ) {
-    Text(
-      stringResource(R.string.your_chat_address),
-      Modifier.padding(bottom = 16.dp),
-      style = MaterialTheme.typography.h1,
-    )
-    Text(
-      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(),
-      horizontalAlignment = Alignment.CenterHorizontally,
-      verticalArrangement = Arrangement.SpaceEvenly
-    ) {
-      if (userAddress == null) {
-        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(
-          horizontalArrangement = Arrangement.spacedBy(10.dp),
-          verticalAlignment = Alignment.CenterVertically,
-          modifier = Modifier.padding(vertical = 10.dp)
-        ) {
-          SimpleButton(
-            stringResource(R.string.share_link),
-            icon = Icons.Outlined.Share,
-            click = { share(userAddress) })
-          SimpleButton(
-            stringResource(R.string.delete_address),
-            icon = Icons.Outlined.Delete,
-            color = Color.Red,
-            click = deleteAddress
-          )
-        }
-      }
-    }
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewUserAddressLayoutNoAddress() {
-  SimpleXTheme {
-    UserAddressLayout(
-      userAddress = null,
-      createAddress = {},
-      share = { _ -> },
-      deleteAddress = {},
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewUserAddressLayoutAddressCreated() {
-  SimpleXTheme {
-    UserAddressLayout(
-      userAddress = "https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23MCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%3D",
-      createAddress = {},
-      share = { _ -> },
-      deleteAddress = {},
-    )
-  }
-}

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

@@ -1,305 +0,0 @@
-package chat.simplex.app.views.usersettings
-
-import android.content.res.Configuration
-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.*
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.*
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.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.HighOrLowlight
-import chat.simplex.app.ui.theme.SimpleXTheme
-import chat.simplex.app.views.helpers.*
-import chat.simplex.app.views.isValidDisplayName
-import com.google.accompanist.insets.ProvideWindowInsets
-import com.google.accompanist.insets.navigationBarsWithImePadding
-import kotlinx.coroutines.launch
-
-@Composable
-fun UserProfileView(chatModel: ChatModel, close: () -> Unit) {
-  val user = chatModel.currentUser.value
-  if (user != null) {
-    val editProfile = remember { mutableStateOf(false) }
-    var profile by remember { mutableStateOf(user.profile) }
-    UserProfileLayout(
-      close = close,
-      editProfile = editProfile,
-      profile = profile,
-      saveProfile = { displayName, fullName, image ->
-        withApi {
-          val p = Profile(displayName, fullName, image)
-          val newProfile = chatModel.controller.apiUpdateProfile(p)
-          if (newProfile != null) {
-            chatModel.updateUserProfile(newProfile)
-            profile = newProfile
-          }
-          editProfile.value = false
-        }
-      }
-    )
-  }
-}
-
-@Composable
-fun UserProfileLayout(
-  close: () -> Unit,
-  editProfile: MutableState<Boolean>,
-  profile: Profile,
-  saveProfile: (String, String, String?) -> Unit,
-) {
-  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(
-            stringResource(R.string.your_chat_profile),
-            Modifier.padding(bottom = 24.dp),
-            style = MaterialTheme.typography.h1,
-            color = MaterialTheme.colors.onBackground
-          )
-          Text(
-            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 }
-                  }
-                }
-              }
-              Box {
-                if (!isValidDisplayName(displayName.value)) {
-                  Icon(Icons.Outlined.Info, tint = Color.Red, contentDescription = stringResource(R.string.display_name_cannot_contain_whitespace))
-                }
-                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))
-                val enabled = displayName.value.isNotEmpty() && isValidDisplayName(displayName.value)
-                val saveModifier: Modifier
-                val saveColor: Color
-                if (enabled) {
-                  saveModifier = Modifier
-                    .clickable { saveProfile(displayName.value, fullName.value, profileImage.value) }
-                  saveColor = MaterialTheme.colors.primary
-                } else {
-                  saveModifier = Modifier
-                  saveColor = HighOrLowlight
-                }
-                Text(
-                  stringResource(R.string.save_and_notify_contacts),
-                  modifier = saveModifier,
-                  color = saveColor
-                )
-              }
-            }
-          } 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)
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-@Composable
-private fun ProfileNameTextField(name: MutableState<String>) {
-  BasicTextField(
-    value = name.value,
-    onValueChange = { name.value = it },
-    modifier = Modifier
-      .padding(bottom = 24.dp)
-      .padding(start = 28.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,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewUserProfileLayoutEditOff() {
-  SimpleXTheme {
-    UserProfileLayout(
-      close = {},
-      profile = Profile.sampleData,
-      editProfile = remember { mutableStateOf(false) },
-      saveProfile = { _, _, _ -> }
-    )
-  }
-}
-
-@Preview(showBackground = true)
-@Preview(
-  uiMode = Configuration.UI_MODE_NIGHT_YES,
-  showBackground = true,
-  name = "Dark Mode"
-)
-@Composable
-fun PreviewUserProfileLayoutEditOn() {
-  SimpleXTheme {
-    UserProfileLayout(
-      close = {},
-      profile = Profile.sampleData,
-      editProfile = remember { mutableStateOf(true) },
-      saveProfile = { _, _, _ -> }
-    )
-  }
-}

apps/android/app/src/main/res/drawable/ic_github.xml

@@ -1,22 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-    Android drawable generated by fa5ad-free project:
-    https://github.com/diwanoczko/fa5ad-free
-
-    Resource generated base on Font Awesome 5 Free icons set:
-    https://fontawesome.com/
-
-    All brand icons are trademarks of their respective owners.
-    Please do not use brand logos for any purpose except to represent the
-    company, product, or service to which they refer.
--->
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="23.25dp"
-    android:height="24dp"
-    android:viewportWidth="496"
-    android:viewportHeight="512">
-    <path
-        android:fillColor="#FF000000"
-        android:pathData="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"
-    />
-</vector>

apps/android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-  android:width="108dp"
-  android:height="108dp"
-  android:viewportWidth="108"
-  android:viewportHeight="108">
-  <path
-    android:fillColor="#3DDC84"
-    android:pathData="M0,0h108v108h-108z" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M9,0L9,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,0L19,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M29,0L29,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M39,0L39,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M49,0L49,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M59,0L59,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M69,0L69,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M79,0L79,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M89,0L89,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M99,0L99,108"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,9L108,9"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,19L108,19"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,29L108,29"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,39L108,39"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,49L108,49"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,59L108,59"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,69L108,69"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,79L108,79"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,89L108,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M0,99L108,99"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,29L89,29"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,39L89,39"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,49L89,49"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,59L89,59"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,69L89,69"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M19,79L89,79"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M29,19L29,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M39,19L39,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M49,19L49,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M59,19L59,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M69,19L69,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-  <path
-    android:fillColor="#00000000"
-    android:pathData="M79,19L79,89"
-    android:strokeWidth="0.8"
-    android:strokeColor="#33FFFFFF" />
-</vector>

apps/android/app/src/main/res/drawable/ic_outline_terminal.xml

@@ -1,10 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24"
-    android:tint="?attr/colorControlNormal">
-  <path
-      android:fillColor="@android:color/white"
-      android:pathData="M20,4H4C2.89,4 2,4.9 2,6v12c0,1.1 0.89,2 2,2h16c1.1,0 2,-0.9 2,-2V6C22,4.9 21.11,4 20,4zM20,18H4V8h16V18zM18,17h-6v-2h6V17zM7.5,17l-1.41,-1.41L8.67,13l-2.59,-2.59L7.5,9l4,4L7.5,17z"/>
-</vector>

apps/android/app/src/main/res/mipmap-anydpi-v26/icon_round.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/white"/>
-    <foreground android:drawable="@color/white"/>
-</adaptive-icon>