Merge branch 'stable' into stable-android

* ios: remove passwords if app was reinstalled

* change instead of delete

* Revert "change instead of delete"

This reverts commit 1195ee5b30.

* update name and comments

---------

Co-authored-by: Avently <avently@local>
Co-authored-by: Evgeny Poberezkin <evgeny@poberezkin.com>

.github/workflows/build.yml

@@ -87,7 +87,7 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Setup Haskell
-        uses: haskell-actions/setup@v2
+        uses: haskell/actions/setup@v2
         with:
           ghc-version: ${{ matrix.ghc }}
           cabal-version: "3.10.1.0"
@@ -197,7 +197,7 @@ jobs:
           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
+          scripts/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
@@ -277,7 +277,9 @@ jobs:
       # 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
+
+      # * 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
 
       - name: 'Setup MSYS2'
         if: matrix.os == 'windows-latest'

Dockerfile

@@ -1,41 +1,32 @@
-ARG TAG=22.04
+FROM ubuntu:focal AS build
 
-FROM ubuntu:${TAG} AS build
-
-### Build stage
-
-# Install curl and git and simplex-chat dependencies
-RUN apt-get update && apt-get install -y curl git build-essential libgmp3-dev zlib1g-dev llvm-12 llvm-12-dev libnuma-dev libssl-dev
-
-# Specify bootstrap Haskell versions
-ENV BOOTSTRAP_HASKELL_GHC_VERSION=9.6.3
-ENV BOOTSTRAP_HASKELL_CABAL_VERSION=3.10.1.0
+# 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 curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 sh
-
-# Adjust PATH
-ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
+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 "${BOOTSTRAP_HASKELL_GHC_VERSION}" && \
-    ghcup set cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
+RUN ghcup set ghc 9.6.3 && \
+    ghcup set cabal 3.10.1.0
 
 COPY . /project
 WORKDIR /project
 
+# Adjust PATH
+ENV PATH="/root/.cabal/bin:/root/.ghcup/bin:$PATH"
+
 # Adjust build
 RUN cp ./scripts/cabal.project.local.linux ./cabal.project.local
 
 # Compile simplex-chat
 RUN cabal update
-RUN cabal build exe:simplex-chat
+RUN cabal install
 
-# Strip the binary from debug symbols to reduce size
-RUN bin=$(find /project/dist-newstyle -name "simplex-chat" -type f -executable) && \
-    mv "$bin" ./ && \
-    strip ./simplex-chat
-
-# Copy compiled app from build stage
 FROM scratch AS export-stage
-COPY --from=build /project/simplex-chat /
+COPY --from=build /root/.cabal/bin/simplex-chat /

PRIVACY.md

@@ -1,134 +1,168 @@
-# SimpleX Chat Terms & Privacy Policy
+# SimpleX Chat Privacy Policy and Conditions of Use
 
-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.
+SimpleX Chat is the first communication network based on a new protocol stack that builds on the same ideas of complete openness and decentralization as email and web, with the focus on providing security and privacy of communications, and without compromising on usability.
 
-If you believe that some of the clauses in this document are not aligned with our mission or principles, please raise it with us via [email](chat@simplex.chat) or [chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion).
+SimpleX Chat communication protocol is the first protocol that has no user profile IDs of any kind, not even random numbers, cryptographic keys or hashes that identify the users. SimpleX Chat apps allow their users to send messages and files via relay server infrastructure. Relay server owners and providers do not have any access to your messages, thanks to double-ratchet end-to-end encryption algorithm (also known as Signal algorithm - do not confuse with Signal protocols or platform) and additional encryption layers, and they also have no access to your profile and contacts - as they do not provide any user accounts.
+
+Double ratchet algorithm has such important properties as [forward secrecy](./docs/GLOSSARY.md#forward-secrecy), sender [repudiation](./docs/GLOSSARY.md#) and break-in recovery (also known as [post-compromise security](./docs/GLOSSARY.md#post-compromise-security)).
+
+If you believe that any part of this document is not aligned with our mission or values, 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 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 Ltd uses the best industry practices for security and encryption to provide client and server software for secure [end-to-end encrypted](./docs/GLOSSARY.md#end-to-end-encryption) messaging via private connections. This encryption cannot be compromised by the relays servers, even if they are modified or compromised, via [man-in-the-middle attack](./docs/GLOSSARY.md#man-in-the-middle-attack), unlike most other communication platforms, services and networks.
 
-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 software is built on top of SimpleX messaging and application protocols, based on a new message routing protocol allowing to establish private connections without having any kind of addresses or other identifiers assigned to its users - it does not use emails, phone numbers, usernames, identity keys or any other user profile identifiers to pass messages between the user applications.
 
-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).
+SimpleX Chat software is similar in its design approach to email clients and browsers - it allows you to have full control of your data and freely choose the relay server providers, in the same way you choose which website or email provider to use, or use your own relay servers, simply by changing the configuration of the client software. The only current restriction to that is Apple push notifications - at the moment they can only be delivered via the preset servers that we operate, as explained below. We are exploring the solutions to deliver push notifications to iOS devices via other providers or users' own servers.
 
-### Information you provide
+While SimpleX Chat Ltd is not a communication service provider, and provide public preset relays "as is", as experimental, without any guarantees of availability or data retention, we are committed to maintain a high level of availability, reliability and security of these preset relays. We will be adding alternative preset infrastructure providers to the software in the future, and you will continue to be able to use any other providers or your own servers.
+
+We see users and data sovereignty, and device and provider portability as critically important properties for any communication system.
+
+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 – see [the announcement](./blog/20221108-simplex-chat-v4.2-security-audit-new-website.md).
+
+### Your information
 
 #### User profiles
 
-We do not store user profiles. The profile you create in the app is local to your device.
+Servers used by SimpleX Chat apps do not create, store or identify user profiles. The profiles you can create in the app are local to your device, and can be removed at any time via the app.
 
-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.
+When you create the local profile, no records are created on any of the relay servers, and infrastructure providers, whether SimpleX Chat Ltd or any other, have no access to any part of your 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 your data and the private connections you created with other software users.
+
+You can transfer the profile to another device by creating a backup of the app data and restoring it on the new device, but you cannot use more than one device with the copy of the same profile at the same time - it will disrupt any active conversations on either or both devices, as a security property of end-to-end encryption.
 
 #### 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.
+SimpleX relay servers 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 64kb, 256kb, 1mb or 8mb via all or some of the configured file relay 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.
+Your message history is stored only on your own device and the devices of your contacts. While the recipients' devices are offline, messaging relay servers temporarily store end-to-end encrypted messages – you can configure which relay servers are used to receive the messages from the new contacts, and you can manually change them for the existing contacts too.
 
-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).
+You do not have control over which servers are used to send messages to your contacts - they are chosen by them. To send messages your client needs to connect to these servers, therefore the servers chosen by your contacts can observe your IP address. You can use VPN or some overlay network (e.g., Tor) to hide your IP address from the servers chosen by your contacts. In the near future we will add the layer in the messaging protocol that will route sent message via the relays chosen by you as well.
 
-The files are stored on file (XFTP) servers for the time configured in the file servers you use (48 hours for preset file servers).
+The messages are permanently removed from the used relay servers as soon as they are delivered, as long as these servers used unmodified published code. Undelivered messages are deleted after the time that is configured in the messaging servers you use (21 days for preset messaging 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).
+The files are stored on file relay servers for the time configured in the relay servers you use (48 hours for preset file servers).
+
+If a messaging servers are restarted, the encrypted message can be stored in a backup file until it is overwritten by the next restart (usually within 1 week for preset relay servers).
+
+As this software is fully open-source and provided under AGPLv3 license, all infrastructure providers and owners, and the developers of the client and server applications who use the SimpleX Chat source code, are required to publish any changes to this software under the same AGPLv3 license - including any modifications to the provided servers.
+
+In addition to the AGPLv3 license terms, SimpleX Chat Ltd is committed to the software users that the preset relays that we provide via the apps will always be compiled from the [published open-source code](https://github.com/simplex-chat/simplexmq), without any modifications.
 
 #### 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.
+When you create a connection with another user, two messaging queues (you can think about them as mailboxes) are created on messaging relay servers (chosen by you and your contact each), that can be the preset servers or the servers that you and your contact configured in the app. SimpleX messaging protocol uses separate queues for direct and response messages, and the apps prefer to create these queues on two different relay servers for increased privacy, in case you have more than one relay 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.
+SimpleX relay 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 infrastructure owners and providers 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.
+
+#### Connection links privacy
+
+When you create a connection with another user, the app generates a link/QR code that can be shared with the user to establish the connection via any channel (email, any other messenger, or a video call). This link is safe to share via insecure channels, as long as you can identify the recipient and also trust that this channel did not replace this link (to mitigate the latter risk you can validate the security code via the app).
+
+While the connection "links" contain SimpleX Chat Ltd domain name `simplex.chat`, this site is never accessed by the app, and is only used for these purposes:
+- to direct the new users to the app download instructions,
+- to show connection QR code that can be scanned via the app,
+- to "namespace" these links,
+- to open links directly in the installed app when it is clicked outside of the app.
+
+You can always safely replace the initial part of the link `https://simplex.chat/` either with `simplex:/` (which is a URI scheme provisionally registered with IANA) or with any other domain name where you can self-host the app download instructions and show the connection QR code (but in case it is your domain, it will not open in the app). Also, while the page renders QR code, all the information needed to render it is only available to the browser, as the part of the "link" after `#` symbol is not sent to the website server.
 
 #### 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.
+Preset 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 sends messages to you. Apple push notifications servers can only observe how many notifications are sent to you, but not from how many contacts, or from which messaging relays, as notifications are delivered to your device end-to-end encrypted by one of the preset notification servers - these notifications only contain end-to-end encrypted metadata, not even encrypted message content, and they look completely random to Apple push notification 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).
+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.
+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 design limits this additional technical information to the minimum required to operate the software and servers. To prevent server overloading or attacks, the servers can temporarily store data that can link to particular users or devices, including IP addresses, geographic location, or information related to the transport sessions. This information is not stored for the absolute majority of the app users, even for those who use the servers very actively.
 
-#### SimpleX Directory Service
+#### SimpleX Directory
 
-[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).
+[SimpleX Directory](./docs/DIRECTORY.md) stores: your search requests, the messages and the members profiles in the registered groups. You can connect to SimpleX Directory 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.
+#### 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.
+If you contact SimpleX Chat Ltd, any personal data you 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, and avoid sharing any personal information.
 
 ### 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.
+SimpleX Chat Ltd operates preset relay servers using third parties. While we do not have access and cannot share any user data, these third parties may access the encrypted user messages (but NOT the actual unencrypted message content or size) as it is stored or transmitted via our servers. Hosting providers can also store IP addresses and other transport information as part of their logs.
 
-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.
+We use a third party for email services - if you ask for support via email, your and SimpleX Chat Ltd email providers may access these emails according to their privacy policies and terms. When the request is sensitive, we recommend contacting us via SimpleX Chat or using encrypted email using PGP key published at [openpgp.org](https://keys.openpgp.org/search?q=chat%40simplex.chat).
 
-The cases when SimpleX Chat may need to share the data we temporarily store on the servers:
+The cases when SimpleX Chat Ltd may share the data temporarily stored on the servers:
 
-- To meet any applicable law, regulation, legal process or enforceable governmental request.
-- To enforce applicable Terms, including investigation of potential violations.
+- To meet any applicable law, or enforceable governmental request or court order.
+- To enforce applicable terms, including investigation of potential violations.
 - 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.
+- To protect against harm to the rights, property, or safety of software users, SimpleX Chat Ltd, 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.
+At the time of updating this document, we have never provided or have been requested the access to the preset relay servers or any information from the servers by any third parties. If we are ever requested to provide such access or information, we will follow the due legal process to limit any information shared with the third parties to the minimally required by law.
 
 ### 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 software applications and preset relays infrastructure confirms your acceptance of our updated Privacy Policy.
 
-Please also read our Terms of Service below.
+Please also read our Conditions of Use of Software and Infrastructure below.
 
 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
+## Conditions of Use of Software and Infrastructure
 
-You accept our Terms of Service ("Terms") by installing or using any of our apps or services ("Services").
+You accept the Conditions of Use of Software and Infrastructure ("Conditions") by installing or using any of our software or using any of our server infrastructure (collectively referred to as "Applications"), whether preset in the software or not.
 
-**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.
+**Minimal age**. You must be at least 13 years old to use our Applications. The minimum age to use our Applications 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 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.
+**Infrastructure**. Our Infrastructure includes preset messaging and file relay servers, and iOS push notification servers provided by SimpleX Chat Ltd for public use. Our infrastructure does not have any modifications from the [published open-source code](https://github.com/simplex-chat/simplexmq) available under AGPLv3 license. Any infrastructure provider, whether commercial or not, is required by the Affero clause (named after Affero Inc. company that pioneered the community-based Q&A sites in early 2000s) to publish any modifications under the same license. The statements in relation to Infrastructure and relay servers anywhere in this document assume no modifications to the published code, even in the cases when it is not explicitly stated.
 
-**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.
+**Client applications**. Our client application Software (referred to as "app" or "apps") also has no modifications compared with published open-source code, and any developers of the alternative client apps based on our code are required to publish any modifications under the same AGPLv3 license. Client applications should not include any tracking or analytics code, and do not share any information with SimpleX Chat Ltd or any other third parties. If you ever discover any tracking or analytics code, please report it to us, so we can remove it.
 
-**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.
+**Accessing the infrastructure**. For the efficiency of the network access, the client Software by default accesses all queues your app creates on any relay server within one user profile via the same network (TCP/IP) connection. At the cost of additional traffic this configuration can be changed to use different transport session for each connection. Relay servers do not collect information about which queues were created or accessed via the same connection, so the relay servers cannot establish which queues belong to the same user profile. Whoever might observe your network traffic would know which relay 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, even inside TLS encryption layer. 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.
 
-**Software**. You agree to downloading and installing updates to our Services when they are available; they would only be automatic if you configure your devices in this way.
+**Privacy of user data**. Servers do not retain any data we transmit for any longer than necessary to deliver the messages between apps. SimpleX Chat Ltd collects aggregate statistics across all its servers, as supported by published code and can be enabled by any infrastructure provider, but not any statistics per-user, or per geographic location, or per IP address, or per transport session. We do not have information about how many people use SimpleX Chat applications, we only know an approximate number of app installations and the aggregate traffic through the preset servers. In any case, we do not and will not sell or in any way monetize user data. Our future business model assumes charging for some optional Software features instead, in a transparent and fair way.
 
-**Traffic and device costs**. You are solely responsible for the traffic and device costs on which you use our Services, and any associated taxes.
+**Operating our Infrastructure**. For the purpose of using our Software, if you continue using preset servers, you agree that your end-to-end encrypted messages are transferred via the preset servers in any countries where we have or use facilities and service providers or partners. The information about geographic location of the servers will be made available in the apps in the near future.
 
-**Legal and acceptable usage**. You agree to use our Services only for legal and acceptable purposes. You will not use (or assist others in using) our Services in ways that: 1) violate or infringe the rights of SimpleX Chat, our users, or others, including privacy, publicity, intellectual property, or other proprietary rights; 2) involve sending illegal or impermissible communications, e.g. spam.
+**Software**. You agree to downloading and installing updates to our Applications when they are available; they would only be automatic if you configure your devices in this way.
 
-**Damage to SimpleX Chat**. You must not (or assist others to) access, use, modify, distribute, transfer, or exploit our Services in unauthorized manners, or in ways that harm SimpleX Chat, our Services, or systems. For example, you must not 1) access our Services or systems without authorization, other than by using the apps; 2) disrupt the integrity or performance of our Services; 3) collect information about our users in any manner; or 4) sell, rent, or charge for our Services.
+**Traffic and device costs**. You are solely responsible for the traffic and device costs that you incur while using our Applications, and any associated taxes.
 
-**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.
+**Legal and acceptable usage**. You agree to use our Applications only for legal and acceptable purposes. You will not use (or assist others in using) our Applications in ways that: 1) violate or infringe the rights of Software users, SimpleX Chat Ltd, or others, including privacy, publicity, intellectual property, or other proprietary rights; 2) involve sending illegal or impermissible communications, e.g. spam. While we cannot access content or identify messages or groups, in some cases the links to the illegal or impermissible communications available via our Applications can be shared publicly on social media or websites. We reserve the right to remove such links from the preset servers and disrupt the conversations that send illegal content via our servers, whether they were reported by the users or discovered by our team.
 
-**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.
+**Damage to SimpleX Chat Ltd**. You must not (or assist others to) access, use, modify, distribute, transfer, or exploit our Applications in unauthorized manners, or in ways that harm Software users, SimpleX Chat Ltd, our Infrastructure, or any other systems. For example, you must not 1) access our Infrastructure or systems without authorization, in any way other than by using the Software; 2) disrupt the integrity or performance of our Infrastructure; 3) collect information about our users in any manner; or 4) sell, rent, or charge for our Infrastructure. This does not prohibit you from providing your own Infrastructure to others, whether free or for a fee, as long as you do not violate these Conditions and AGPLv3 license, including the requirement to publish any modifications of the relay server software.
 
-**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.
+**Keeping your data secure**. SimpleX Chat is the first communication software that aims to be 100% private by design - server software neither has the ability to access your messages, nor it has information about who you communicate with. That means that you are solely responsible for keeping your device, your user profile and any data safe and secure. If you lose your phone or remove the Software from the device, you will not be able to recover the lost data, unless you made a back up. To protect the data you need to make regular backups, as using old backups may disrupt your communication with some of the contacts.
 
-**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.
+**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 Software you use. The databases created prior to 2023 or in CLI (terminal) app may remain unencrypted, and it will be indicated in the app interface. In this case, if you make a backup of the data and store it unencrypted, the backup provider may be able to access the messages. Please note, that the desktop apps can be configured to store the database passphrase in the configuration file in plaintext, and unless you set the passphrase when first running the app, a random passphrase will be used and stored on the device. You can remove it from the device via the app settings.
 
-**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.
+**Storing the files on the device**. The files currently sent and received in the apps by default (except CLI app) are stored on your device encrypted using unique keys, different for each file, that are stored in the database. Once the message that the file was attached to is removed, even if the copy of the encrypted file is retained, it should be impossible to recover the key allowing to decrypt the file. This local file encryption may affect app performance, and it can be disabled via the app settings. This change will only affect the new files. If you later re-enable the encryption, it will also affect only the new files. If you make a backup of the app data and store it unencrypted, the backup provider will be able to access any unencrypted files. In any case, irrespective of the storage setting, the files are always sent by all apps end-to-end encrypted.
 
-**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.
+**No Access to Emergency Services**. Our Applications 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.
 
-**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)
+**Third-party services**. Our Applications may allow you to access, use, or interact with our or 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.
 
-**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.
+**Your Rights**. You own the messages and the information you transmit through our Applications. Your recipients are able to retain the messages they 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 Software. At the same time, repudiation property of the end-to-end encryption algorithm allows you to plausibly deny having sent the message, like you can deny what you said in a private face-to-face conversation, as the recipient cannot provide any proof to the third parties, by design.
 
-**Disclaimers**. YOU USE OUR SERVICES AT YOUR OWN RISK AND SUBJECT TO THE FOLLOWING DISCLAIMERS. WE PROVIDE OUR SERVICES ON AN “AS IS” BASIS WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, AND FREEDOM FROM COMPUTER VIRUS OR OTHER HARMFUL CODE. SIMPLEX DOES NOT WARRANT THAT ANY INFORMATION PROVIDED BY US IS ACCURATE, COMPLETE, OR USEFUL, THAT OUR SERVICES WILL BE OPERATIONAL, ERROR-FREE, SECURE, OR SAFE, OR THAT OUR SERVICES WILL FUNCTION WITHOUT DISRUPTIONS, DELAYS, OR IMPERFECTIONS. WE DO NOT CONTROL, AND ARE NOT RESPONSIBLE FOR, CONTROLLING HOW OR WHEN OUR USERS USE OUR SERVICES. WE ARE NOT RESPONSIBLE FOR THE ACTIONS OR INFORMATION (INCLUDING CONTENT) OF OUR USERS OR OTHER THIRD PARTIES. YOU RELEASE US, AFFILIATES, DIRECTORS, OFFICERS, EMPLOYEES, PARTNERS, AND AGENTS ("SIMPLEX PARTIES") FROM ANY CLAIM, COMPLAINT, CAUSE OF ACTION, CONTROVERSY, OR DISPUTE (TOGETHER, "CLAIM") AND DAMAGES, KNOWN AND UNKNOWN, RELATING TO, ARISING OUT OF, OR IN ANY WAY CONNECTED WITH ANY SUCH CLAIM YOU HAVE AGAINST ANY THIRD PARTIES.
+**License**. SimpleX Chat Ltd grants you a limited, revocable, non-exclusive, and non-transferable license to use our Applications in accordance with these Conditions. The source-code of Applications is available and can be used under [AGPL v3 license](https://github.com/simplex-chat/simplex-chat/blob/stable/LICENSE).
 
-**Limitation of liability**. THE SIMPLEX PARTIES WILL NOT BE LIABLE TO YOU FOR ANY LOST PROFITS OR CONSEQUENTIAL, SPECIAL, PUNITIVE, INDIRECT, OR INCIDENTAL DAMAGES RELATING TO, ARISING OUT OF, OR IN ANY WAY IN CONNECTION WITH OUR TERMS, US, OR OUR SERVICES, EVEN IF THE SIMPLEX PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. OUR AGGREGATE LIABILITY RELATING TO, ARISING OUT OF, OR IN ANY WAY IN CONNECTION WITH OUR TERMS, US, OR OUR SERVICES WILL NOT EXCEED ONE DOLLAR ($1). THE FOREGOING DISCLAIMER OF CERTAIN DAMAGES AND LIMITATION OF LIABILITY WILL APPLY TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW. THE LAWS OF SOME JURISDICTIONS MAY NOT ALLOW THE EXCLUSION OR LIMITATION OF CERTAIN DAMAGES, SO SOME OR ALL OF THE EXCLUSIONS AND LIMITATIONS SET FORTH ABOVE MAY NOT APPLY TO YOU. NOTWITHSTANDING ANYTHING TO THE CONTRARY IN OUR TERMS, IN SUCH CASES, THE LIABILITY OF THE SIMPLEX PARTIES WILL BE LIMITED TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+**SimpleX Chat Ltd Rights**. We own all copyrights, trademarks, domains, logos, trade secrets, and other intellectual property rights associated with our Applications. 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.
 
-**Availability**. Our Services may be interrupted, including for maintenance, upgrades, or network or equipment failures. We may discontinue some or all of our Services, including certain features and the support for certain devices and platforms, at any time.
+**Disclaimers**. YOU USE OUR APPLICATIONS AT YOUR OWN RISK AND SUBJECT TO THE FOLLOWING DISCLAIMERS. WE PROVIDE OUR APPLICATIONS ON AN “AS IS” BASIS WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, AND FREEDOM FROM COMPUTER VIRUS OR OTHER HARMFUL CODE. SIMPLEX CHAT LTD DOES NOT WARRANT THAT ANY INFORMATION PROVIDED BY US IS ACCURATE, COMPLETE, OR USEFUL, THAT OUR APPLICATIONS WILL BE OPERATIONAL, ERROR-FREE, SECURE, OR SAFE, OR THAT OUR APPLICATIONS WILL FUNCTION WITHOUT DISRUPTIONS, DELAYS, OR IMPERFECTIONS. WE DO NOT CONTROL, AND ARE NOT RESPONSIBLE FOR, CONTROLLING HOW OR WHEN OUR USERS USE OUR APPLICATIONS. WE ARE NOT RESPONSIBLE FOR THE ACTIONS OR INFORMATION (INCLUDING CONTENT) OF OUR USERS OR OTHER THIRD PARTIES. YOU RELEASE US, AFFILIATES, DIRECTORS, OFFICERS, EMPLOYEES, PARTNERS, AND AGENTS ("SIMPLEX PARTIES") FROM ANY CLAIM, COMPLAINT, CAUSE OF ACTION, CONTROVERSY, OR DISPUTE (TOGETHER, "CLAIM") AND DAMAGES, KNOWN AND UNKNOWN, RELATING TO, ARISING OUT OF, OR IN ANY WAY CONNECTED WITH ANY SUCH CLAIM YOU HAVE AGAINST ANY THIRD PARTIES.
 
-**Resolving disputes**. You agree to resolve any Claim you have with us relating to or arising from our Terms, us, or our Services in the courts of England and Wales. You also agree to submit to the personal jurisdiction of such courts for the purpose of resolving all such disputes. The laws of England govern our Terms, as well as any disputes, whether in court or arbitration, which might arise between SimpleX Chat and you, without regard to conflict of law provisions.
+**Limitation of liability**. THE SIMPLEX PARTIES WILL NOT BE LIABLE TO YOU FOR ANY LOST PROFITS OR CONSEQUENTIAL, SPECIAL, PUNITIVE, INDIRECT, OR INCIDENTAL DAMAGES RELATING TO, ARISING OUT OF, OR IN ANY WAY IN CONNECTION WITH OUR CONDITIONS, US, OR OUR APPLICATIONS, EVEN IF THE SIMPLEX PARTIES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. OUR AGGREGATE LIABILITY RELATING TO, ARISING OUT OF, OR IN ANY WAY IN CONNECTION WITH OUR CONDITIONS, US, OR OUR APPLICATIONS WILL NOT EXCEED ONE DOLLAR ($1). THE FOREGOING DISCLAIMER OF CERTAIN DAMAGES AND LIMITATION OF LIABILITY WILL APPLY TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW. THE LAWS OF SOME JURISDICTIONS MAY NOT ALLOW THE EXCLUSION OR LIMITATION OF CERTAIN DAMAGES, SO SOME OR ALL OF THE EXCLUSIONS AND LIMITATIONS SET FORTH ABOVE MAY NOT APPLY TO YOU. NOTWITHSTANDING ANYTHING TO THE CONTRARY IN OUR CONDITIONS, IN SUCH CASES, THE LIABILITY OF THE SIMPLEX PARTIES WILL BE LIMITED TO THE EXTENT PERMITTED BY APPLICABLE LAW.
 
-**Changes to the terms**. SimpleX Chat may update the Terms from time to time. Your continued use of our Services confirms your acceptance of our updated Terms and supersedes any prior Terms. You will comply with all applicable export control and trade sanctions laws. Our Terms cover the entire agreement between you and SimpleX Chat regarding our Services. If you do not agree with our Terms, you should stop using our Services.
+**Availability**. Our Applications may be disrupted, including for maintenance, upgrades, or network or equipment failures. We may discontinue some or all of our Applications, including certain features and the support for certain devices and platforms, at any time.
 
-**Enforcing the terms**. If we fail to enforce any of our Terms, that does not mean we waive the right to enforce them. If any provision of the Terms is deemed unlawful, void, or unenforceable, that provision shall be deemed severable from our Terms and shall not affect the enforceability of the remaining provisions. Our Services are not intended for distribution to or use in any country where such distribution or use would violate local law or would subject us to any regulations in another country. We reserve the right to limit our Services in any country. If you have specific questions about these Terms, please contact us at chat@simplex.chat.
+**Resolving disputes**. You agree to resolve any Claim you have with us relating to or arising from our Conditions, us, or our Applications in the courts of England and Wales. You also agree to submit to the personal jurisdiction of such courts for the purpose of resolving all such disputes. The laws of England govern our Conditions, as well as any disputes, whether in court or arbitration, which might arise between SimpleX Chat Ltd and you, without regard to conflict of law provisions.
 
-**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.
+**Changes to the conditions**. SimpleX Chat Ltd may update the Conditions from time to time. Your continued use of our Applications confirms your acceptance of our updated Conditions and supersedes any prior Conditions. You will comply with all applicable export control and trade sanctions laws. Our Conditions cover the entire agreement between you and SimpleX Chat Ltd regarding our Applications. If you do not agree with our Conditions, you should stop using our Applications.
 
-Updated August 17, 2023
+**Enforcing the conditions**. If we fail to enforce any of our Conditions, that does not mean we waive the right to enforce them. If any provision of the Conditions is deemed unlawful, void, or unenforceable, that provision shall be deemed severable from our Conditions and shall not affect the enforceability of the remaining provisions. Our Applications are not intended for distribution to or use in any country where such distribution or use would violate local law or would subject us to any regulations in another country. We reserve the right to limit our Applications in any country. If you have specific questions about these Conditions, please contact us at chat@simplex.chat.
+
+**Ending these conditions**. You may end these Conditions with SimpleX Chat Ltd at any time by deleting our Applications from your devices and discontinuing use of our Infrastructure. The provisions related to Licenses, Disclaimers, Limitation of Liability, Resolving dispute, Availability, Changes to the conditions, Enforcing the conditions, and Ending these conditions will survive termination of your relationship with SimpleX Chat Ltd.
+
+Updated February 24, 2024

apps/ios/Shared/AppDelegate.swift

@@ -16,6 +16,7 @@ class AppDelegate: NSObject, UIApplicationDelegate {
         application.registerForRemoteNotifications()
         if #available(iOS 17.0, *) { trackKeyboard() }
         NotificationCenter.default.addObserver(self, selector: #selector(pasteboardChanged), name: UIPasteboard.changedNotification, object: nil)
+        removePasscodesIfReinstalled()
         return true
     }
 
@@ -127,6 +128,19 @@ class AppDelegate: NSObject, UIApplicationDelegate {
         BGManager.shared.receiveMessages(complete)
     }
 
+    private func removePasscodesIfReinstalled() {
+        // Check for the database existence, because app and self destruct passcodes
+        // will be saved and restored by iOS when a user deletes and re-installs the app.
+        // In this case the database and settings will be deleted, but the passcodes won't be.
+        // Deleting passcodes ensures that the user will not get stuck on "Opening app..." screen.
+        if (kcAppPassword.get() != nil || kcSelfDestructPassword.get() != nil) &&
+           !UserDefaults.standard.bool(forKey: DEFAULT_PERFORM_LA) && !hasDatabase() {
+            _ = kcAppPassword.remove()
+            _ = kcSelfDestructPassword.remove()
+            _ = kcDatabasePassword.remove()
+        }
+    }
+
     static func keepScreenOn(_ on: Bool) {
         UIApplication.shared.isIdleTimerDisabled = on
     }

apps/ios/Shared/ContentView.swift

@@ -34,8 +34,6 @@ struct ContentView: View {
     @State private var waitingForOrPassedAuth = true
     @State private var chatListActionSheet: ChatListActionSheet? = nil
 
-    private let callTopPadding: CGFloat = 50
-
     private enum ChatListActionSheet: Identifiable {
         case planAndConnectSheet(sheet: PlanAndConnectActionSheet)
 
@@ -52,28 +50,16 @@ struct ContentView: View {
 
     var body: some View {
         ZStack {
-            let showCallArea = chatModel.activeCall != nil && chatModel.activeCall?.callState != .waitCapabilities && chatModel.activeCall?.callState != .invitationAccepted
             // contentView() has to be in a single branch, so that enabling authentication doesn't trigger re-rendering and close settings.
             // i.e. with separate branches like this settings are closed: `if prefPerformLA { ... contentView() ... } else { contentView() }
             if !prefPerformLA || accessAuthenticated {
                 contentView()
-                    .padding(.top, showCallArea ? callTopPadding : 0)
             } else {
                 lockButton()
-                    .padding(.top, showCallArea ? callTopPadding : 0)
             }
-
-            if showCallArea, let call = chatModel.activeCall {
-                VStack {
-                    activeCallInteractiveArea(call)
-                    Spacer()
-                }
-            }
-
             if chatModel.showCallView, let call = chatModel.activeCall {
                 callView(call)
             }
-
             if !showSettings, let la = chatModel.laRequest {
                 LocalAuthView(authRequest: la)
                     .onDisappear {
@@ -149,11 +135,11 @@ struct ContentView: View {
             if case .onboardingComplete = step,
                chatModel.currentUser != nil {
                 mainView()
-                    .actionSheet(item: $chatListActionSheet) { sheet in
-                        switch sheet {
-                        case let .planAndConnectSheet(sheet): return planAndConnectActionSheet(sheet, dismiss: false)
-                        }
+                .actionSheet(item: $chatListActionSheet) { sheet in
+                    switch sheet {
+                    case let .planAndConnectSheet(sheet): return planAndConnectActionSheet(sheet, dismiss: false)
                     }
+                }
             } else {
                 OnboardingView(onboarding: step)
             }
@@ -177,40 +163,6 @@ struct ContentView: View {
         }
     }
 
-    @ViewBuilder private func activeCallInteractiveArea(_ call: Call) -> some View {
-        HStack {
-            Text(call.contact.displayName).font(.body).foregroundColor(.white)
-            Spacer()
-            CallDuration(call: call)
-        }
-        .padding(.horizontal)
-        .frame(height: callTopPadding - 10)
-        .background(Color(uiColor: UIColor(red: 47/255, green: 208/255, blue: 88/255, alpha: 1)))
-        .onTapGesture {
-            chatModel.activeCallViewIsCollapsed = false
-        }
-    }
-
-    struct CallDuration: View {
-        let call: Call
-        @State var text: String = ""
-        @State var timer: Timer? = nil
-
-        var body: some View {
-            Text(text).frame(minWidth: text.count <= 5 ? 52 : 77, alignment: .leading).offset(x: 4).font(.body).foregroundColor(.white)
-            .onAppear {
-                timer = Timer.scheduledTimer(withTimeInterval: 0.3, repeats: true) { timer in
-                    if let connectedAt = call.connectedAt {
-                        text = durationText(Int(Date.now.timeIntervalSince1970 - connectedAt.timeIntervalSince1970))
-                    }
-                }
-            }
-            .onDisappear {
-                _ = timer?.invalidate()
-            }
-        }
-    }
-
     private func lockButton() -> some View {
         Button(action: authenticateContentViewAccess) { Label("Unlock", systemImage: "lock") }
     }

apps/ios/Shared/Model/ChatModel.swift

@@ -80,7 +80,6 @@ final class ChatModel: ObservableObject {
     @Published var tokenRegistered = false
     @Published var tokenStatus: NtfTknStatus?
     @Published var notificationMode = NotificationsMode.off
-    @Published var notificationServer: String?
     @Published var notificationPreview: NotificationPreviewMode = ntfPreviewModeGroupDefault.get()
     // pending notification actions
     @Published var ntfContactRequest: NTFContactRequest?
@@ -90,7 +89,6 @@ final class ChatModel: ObservableObject {
     @Published var activeCall: Call?
     let callCommand: WebRTCCommandProcessor = WebRTCCommandProcessor()
     @Published var showCallView = false
-    @Published var activeCallViewIsCollapsed = false
     // remote desktop
     @Published var remoteCtrlSession: RemoteCtrlSession?
     // currently showing invitation

apps/ios/Shared/Model/SimpleXAPI.swift

@@ -252,12 +252,6 @@ func apiSetFilesFolder(filesFolder: String) throws {
     throw r
 }
 
-func setXFTPConfig(_ cfg: XFTPFileConfig?) throws {
-    let r = chatSendCmdSync(.apiSetXFTPConfig(config: cfg))
-    if case .cmdOk = r { return }
-    throw r
-}
-
 func apiSetEncryptLocalFiles(_ enable: Bool) throws {
     let r = chatSendCmdSync(.apiSetEncryptLocalFiles(enable: enable))
     if case .cmdOk = r { return }
@@ -412,14 +406,14 @@ func apiDeleteMemberChatItem(groupId: Int64, groupMemberId: Int64, itemId: Int64
     throw r
 }
 
-func apiGetNtfToken() -> (DeviceToken?, NtfTknStatus?, NotificationsMode, String?) {
+func apiGetNtfToken() -> (DeviceToken?, NtfTknStatus?, NotificationsMode) {
     let r = chatSendCmdSync(.apiGetNtfToken)
     switch r {
-    case let .ntfToken(token, status, ntfMode, ntfServer): return (token, status, ntfMode, ntfServer)
-    case .chatCmdError(_, .errorAgent(.CMD(.PROHIBITED))): return (nil, nil, .off, nil)
+    case let .ntfToken(token, status, ntfMode): return (token, status, ntfMode)
+    case .chatCmdError(_, .errorAgent(.CMD(.PROHIBITED))): return (nil, nil, .off)
     default:
         logger.debug("apiGetNtfToken response: \(String(describing: r))")
-        return (nil, nil, .off, nil)
+        return (nil, nil, .off)
     }
 }
 
@@ -1249,7 +1243,6 @@ func initializeChat(start: Bool, confirmStart: Bool = false, dbKey: String? = ni
     }
     try apiSetTempFolder(tempFolder: getTempFilesDirectory().path)
     try apiSetFilesFolder(filesFolder: getAppFilesDirectory().path)
-    try setXFTPConfig(getXFTPCfg())
     try apiSetEncryptLocalFiles(privacyEncryptLocalFilesGroupDefault.get())
     m.chatInitialized = true
     m.currentUser = try apiGetActiveUser()
@@ -1309,7 +1302,7 @@ func startChat(refreshInvitations: Bool = true) throws {
         if (refreshInvitations) {
             try refreshCallInvitations()
         }
-        (m.savedToken, m.tokenStatus, m.notificationMode, m.notificationServer) = apiGetNtfToken()
+        (m.savedToken, m.tokenStatus, m.notificationMode) = apiGetNtfToken()
         // deviceToken is set when AppDelegate.application(didRegisterForRemoteNotificationsWithDeviceToken:) is called,
         // when it is called before startChat
         if let token = m.deviceToken {

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

@@ -12,67 +12,49 @@ import SimpleXChat
 
 struct ActiveCallView: View {
     @EnvironmentObject var m: ChatModel
-    @Environment(\.colorScheme) var colorScheme
     @ObservedObject var call: Call
     @Environment(\.scenePhase) var scenePhase
     @State private var client: WebRTCClient? = nil
     @State private var activeCall: WebRTCClient.Call? = nil
     @State private var localRendererAspectRatio: CGFloat? = nil
     @Binding var canConnectCall: Bool
-    @State var prevColorScheme: ColorScheme = .dark
-    @State var pipShown = false
 
     var body: some View {
-        ZStack(alignment: .topLeading) {
-            ZStack(alignment: .bottom) {
-                if let client = client, [call.peerMedia, call.localMedia].contains(.video), activeCall != nil {
-                    GeometryReader { g in
-                        let width = g.size.width * 0.3
-                        ZStack(alignment: .topTrailing) {
-                            CallViewRemote(client: client, activeCall: $activeCall, activeCallViewIsCollapsed: $m.activeCallViewIsCollapsed, pipShown: $pipShown)
-                            CallViewLocal(client: client, activeCall: $activeCall, localRendererAspectRatio: $localRendererAspectRatio, pipShown: $pipShown)
-                                .cornerRadius(10)
-                                .frame(width: width, height: width / (localRendererAspectRatio ?? 1))
-                                .padding([.top, .trailing], 17)
-                            ZStack(alignment: .center) {
-                                // For some reason, when the view in GeometryReader and ZStack is visible, it steals clicks on a back button, so showing something on top like this with background color helps (.clear color doesn't work)
-                            }
-                            .frame(maxWidth: .infinity, maxHeight: .infinity)
-                            .background(Color.primary.opacity(0.000001))
-                        }
+        ZStack(alignment: .bottom) {
+            if let client = client, [call.peerMedia, call.localMedia].contains(.video), activeCall != nil {
+                GeometryReader { g in
+                    let width = g.size.width * 0.3
+                    ZStack(alignment: .topTrailing) {
+                        CallViewRemote(client: client, activeCall: $activeCall)
+                        CallViewLocal(client: client, activeCall: $activeCall, localRendererAspectRatio: $localRendererAspectRatio)
+                            .cornerRadius(10)
+                            .frame(width: width, height: width / (localRendererAspectRatio ?? 1))
+                            .padding([.top, .trailing], 17)
                     }
                 }
-                if let call = m.activeCall, let client = client, (!pipShown || !call.supportsVideo) {
-                    ActiveCallOverlay(call: call, client: client)
-                }
+            }
+            if let call = m.activeCall, let client = client {
+                ActiveCallOverlay(call: call, client: client)
             }
         }
-        .allowsHitTesting(!m.activeCallViewIsCollapsed)
-        .opacity(m.activeCallViewIsCollapsed ? 0 : 1)
         .onAppear {
             logger.debug("ActiveCallView: appear client is nil \(client == nil), scenePhase \(String(describing: scenePhase)), canConnectCall \(canConnectCall)")
             AppDelegate.keepScreenOn(true)
             createWebRTCClient()
             dismissAllSheets()
-            hideKeyboard()
-            prevColorScheme = colorScheme
         }
         .onChange(of: canConnectCall) { _ in
             logger.debug("ActiveCallView: canConnectCall changed to \(canConnectCall)")
             createWebRTCClient()
         }
-        .onChange(of: m.activeCallViewIsCollapsed) { _ in
-            hideKeyboard()
-        }
         .onDisappear {
             logger.debug("ActiveCallView: disappear")
             Task { await m.callCommand.setClient(nil) }
             AppDelegate.keepScreenOn(false)
             client?.endCall()
         }
-        .background(m.activeCallViewIsCollapsed ? .clear : .black)
-        // Quite a big delay when opening/closing the view when a scheme changes (globally) this way. It's not needed when CallKit is used since status bar is green with white text on it
-        .preferredColorScheme(m.activeCallViewIsCollapsed || CallController.useCallKit() ? prevColorScheme : .dark)
+        .background(.black)
+        .preferredColorScheme(.dark)
     }
 
     private func createWebRTCClient() {
@@ -87,8 +69,8 @@ struct ActiveCallView: View {
     @MainActor
     private func processRtcMessage(msg: WVAPIMessage) {
         if call == m.activeCall,
-           let call = m.activeCall,
-           let client = client {
+            let call = m.activeCall,
+            let client = client {
             logger.debug("ActiveCallView: response \(msg.resp.respType)")
             switch msg.resp {
             case let .capabilities(capabilities):
@@ -108,7 +90,7 @@ struct ActiveCallView: View {
                 Task {
                     do {
                         try await apiSendCallOffer(call.contact, offer, iceCandidates,
-                                                   media: call.localMedia, capabilities: capabilities)
+                                               media: call.localMedia, capabilities: capabilities)
                     } catch {
                         logger.error("apiSendCallOffer \(responseError(error))")
                     }
@@ -140,15 +122,13 @@ struct ActiveCallView: View {
                 if let callStatus = WebRTCCallStatus.init(rawValue: state.connectionState),
                    case .connected = callStatus {
                     call.direction == .outgoing
-                    ? CallController.shared.reportOutgoingCall(call: call, connectedAt: nil)
-                    : CallController.shared.reportIncomingCall(call: call, connectedAt: nil)
+                        ? CallController.shared.reportOutgoingCall(call: call, connectedAt: nil)
+                        : CallController.shared.reportIncomingCall(call: call, connectedAt: nil)
                     call.callState = .connected
-                    call.connectedAt = .now
                 }
                 if state.connectionState == "closed" {
                     closeCallView(client)
                     m.activeCall = nil
-                    m.activeCallViewIsCollapsed = false
                 }
                 Task {
                     do {
@@ -160,7 +140,6 @@ struct ActiveCallView: View {
             case let .connected(connectionInfo):
                 call.callState = .connected
                 call.connectionInfo = connectionInfo
-                call.connectedAt = .now
             case .ended:
                 closeCallView(client)
                 call.callState = .ended
@@ -174,7 +153,6 @@ struct ActiveCallView: View {
                 case .end:
                     closeCallView(client)
                     m.activeCall = nil
-                    m.activeCallViewIsCollapsed = false
                 default: ()
                 }
             case let .error(message):
@@ -203,7 +181,7 @@ struct ActiveCallOverlay: View {
         VStack {
             switch call.localMedia {
             case .video:
-                videoCallInfoView(call)
+                callInfoView(call, .leading)
                 .foregroundColor(.white)
                 .opacity(0.8)
                 .padding()
@@ -230,25 +208,16 @@ struct ActiveCallOverlay: View {
                 .frame(maxWidth: .infinity, alignment: .center)
 
             case .audio:
-                ZStack(alignment: .topLeading) {
-                    Button {
-                        chatModel.activeCallViewIsCollapsed = true
-                    } label: {
-                        Label("Back", systemImage: "chevron.left")
-                            .padding()
-                            .foregroundColor(.white.opacity(0.8))
-                    }
-                    VStack {
-                        ProfileImage(imageStr: call.contact.profile.image)
-                            .scaledToFit()
-                            .frame(width: 192, height: 192)
-                        audioCallInfoView(call)
-                    }
-                    .foregroundColor(.white)
-                    .opacity(0.8)
-                    .padding()
-                    .frame(maxHeight: .infinity)
+                VStack {
+                    ProfileImage(imageStr: call.contact.profile.image)
+                        .scaledToFit()
+                        .frame(width: 192, height: 192)
+                    callInfoView(call, .center)
                 }
+                .foregroundColor(.white)
+                .opacity(0.8)
+                .padding()
+                .frame(maxHeight: .infinity)
 
                 Spacer()
 
@@ -266,12 +235,12 @@ struct ActiveCallOverlay: View {
         .frame(maxWidth: .infinity)
     }
 
-    private func audioCallInfoView(_ call: Call) -> some View {
+    private func callInfoView(_ call: Call, _ alignment: Alignment) -> some View {
         VStack {
             Text(call.contact.chatViewName)
                 .lineLimit(1)
                 .font(.title)
-                .frame(maxWidth: .infinity, alignment: .center)
+                .frame(maxWidth: .infinity, alignment: alignment)
             Group {
                 Text(call.callState.text)
                 HStack {
@@ -282,36 +251,7 @@ struct ActiveCallOverlay: View {
                 }
             }
             .font(.subheadline)
-            .frame(maxWidth: .infinity, alignment: .center)
-        }
-    }
-
-    private func videoCallInfoView(_ call: Call) -> some View {
-        VStack {
-            Button {
-                chatModel.activeCallViewIsCollapsed = true
-            } label: {
-                HStack(alignment: .center, spacing: 16) {
-                    Image(systemName: "chevron.left")
-                        .resizable()
-                        .frame(width: 10, height: 18)
-                    Text(call.contact.chatViewName)
-                        .lineLimit(1)
-                        .font(.title)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                }
-            }
-            Group {
-                Text(call.callState.text)
-                HStack {
-                    Text(call.encryptionStatus)
-                    if let connInfo = call.connectionInfo {
-                        Text("(") + Text(connInfo.text) + Text(")")
-                    }
-                }
-            }
-            .font(.subheadline)
-            .frame(maxWidth: .infinity, alignment: .leading)
+            .frame(maxWidth: .infinity, alignment: alignment)
         }
     }
 

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

@@ -92,7 +92,6 @@ class CallManager {
         if case .ended = call.callState {
             logger.debug("CallManager.endCall: call ended")
             m.activeCall = nil
-            m.activeCallViewIsCollapsed = false
             m.showCallView = false
             completed()
         } else {
@@ -101,7 +100,6 @@ class CallManager {
                 await m.callCommand.processCommand(.end)
                 await MainActor.run {
                     m.activeCall = nil
-                    m.activeCallViewIsCollapsed = false
                     m.showCallView = false
                     completed()
                 }

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

@@ -6,20 +6,14 @@
 import SwiftUI
 import WebRTC
 import SimpleXChat
-import AVKit
 
 struct CallViewRemote: UIViewRepresentable {
     var client: WebRTCClient
     var activeCall: Binding<WebRTCClient.Call?>
-    @State var enablePip: (Bool) -> Void = {_ in }
-    @Binding var activeCallViewIsCollapsed: Bool
-    @Binding var pipShown: Bool
 
-    init(client: WebRTCClient, activeCall: Binding<WebRTCClient.Call?>, activeCallViewIsCollapsed: Binding<Bool>, pipShown: Binding<Bool>) {
+    init(client: WebRTCClient, activeCall: Binding<WebRTCClient.Call?>) {
         self.client = client
         self.activeCall = activeCall
-        self._activeCallViewIsCollapsed = activeCallViewIsCollapsed
-        self._pipShown = pipShown
     }
 
     func makeUIView(context: Context) -> UIView {
@@ -29,120 +23,12 @@ struct CallViewRemote: UIViewRepresentable {
             remoteRenderer.videoContentMode = .scaleAspectFill
             client.addRemoteRenderer(call, remoteRenderer)
             addSubviewAndResize(remoteRenderer, into: view)
-
-            if AVPictureInPictureController.isPictureInPictureSupported() {
-                makeViewWithRTCRenderer(call, remoteRenderer, view, context)
-            }
         }
         return view
     }
-    
-    func makeViewWithRTCRenderer(_ call: WebRTCClient.Call, _ remoteRenderer: RTCMTLVideoView, _ view: UIView, _ context: Context) {
-        let pipRemoteRenderer = RTCMTLVideoView(frame: view.frame)
-        pipRemoteRenderer.videoContentMode = .scaleAspectFill
-        
-        let pipVideoCallViewController = AVPictureInPictureVideoCallViewController()
-        pipVideoCallViewController.preferredContentSize = CGSize(width: 1080, height: 1920)
-        addSubviewAndResize(pipRemoteRenderer, into: pipVideoCallViewController.view)
-        let pipContentSource = AVPictureInPictureController.ContentSource(
-            activeVideoCallSourceView: view,
-            contentViewController: pipVideoCallViewController
-        )
-        
-        let pipController = AVPictureInPictureController(contentSource: pipContentSource)
-        pipController.canStartPictureInPictureAutomaticallyFromInline = true
-        pipController.delegate = context.coordinator
-        context.coordinator.pipController = pipController
-        context.coordinator.willShowHide = { show in
-            if show {
-                client.addRemoteRenderer(call, pipRemoteRenderer)
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                    activeCallViewIsCollapsed = true
-                }
-            } else {
-                DispatchQueue.main.asyncAfter(deadline: .now() + 0.05) {
-                    activeCallViewIsCollapsed = false
-                }
-            }
-        }
-        context.coordinator.didShowHide = { show in
-            if show {
-                remoteRenderer.isHidden = true
-            } else {
-                client.removeRemoteRenderer(call, pipRemoteRenderer)
-                remoteRenderer.isHidden = false
-            }
-            pipShown = show
-        }
-        DispatchQueue.main.async {
-            enablePip = { enable in
-                if enable != pipShown /* pipController.isPictureInPictureActive */ {
-                    if enable {
-                        pipController.startPictureInPicture()
-                    } else {
-                        pipController.stopPictureInPicture()
-                    }
-                }
-            }
-        }
-    }
-    
-    func makeCoordinator() -> Coordinator {
-        Coordinator()
-    }
 
     func updateUIView(_ view: UIView, context: Context) {
         logger.debug("CallView.updateUIView remote")
-        DispatchQueue.main.async {
-            if activeCallViewIsCollapsed != pipShown {
-                enablePip(activeCallViewIsCollapsed)
-            }
-        }
-    }
-    
-    // MARK: - Coordinator
-    class Coordinator: NSObject, AVPictureInPictureControllerDelegate {
-        var pipController: AVPictureInPictureController? = nil
-        var willShowHide: (Bool) -> Void = { _ in }
-        var didShowHide: (Bool) -> Void = { _ in }
-        
-        func pictureInPictureControllerWillStartPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
-            willShowHide(true)
-        }
-
-        func pictureInPictureControllerDidStartPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
-            didShowHide(true)
-        }
-
-        func pictureInPictureController(_ pictureInPictureController: AVPictureInPictureController, failedToStartPictureInPictureWithError error: Error) {
-            logger.error("PiP failed to start: \(error.localizedDescription)")
-        }
-        
-        func pictureInPictureControllerWillStopPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
-            willShowHide(false)
-        }
-        
-        func pictureInPictureControllerDidStopPictureInPicture(_ pictureInPictureController: AVPictureInPictureController) {
-            didShowHide(false)
-        }
-
-        deinit {
-            pipController?.stopPictureInPicture()
-            pipController?.canStartPictureInPictureAutomaticallyFromInline = false
-            pipController?.contentSource = nil
-            pipController?.delegate = nil
-            pipController = nil
-        }
-    }
-    
-    class SampleBufferVideoCallView: UIView {
-        override class var layerClass: AnyClass {
-            get { return AVSampleBufferDisplayLayer.self }
-        }
-        
-        var sampleBufferDisplayLayer: AVSampleBufferDisplayLayer {
-            return layer as! AVSampleBufferDisplayLayer
-        }
     }
 }
 
@@ -150,14 +36,11 @@ struct CallViewLocal: UIViewRepresentable {
     var client: WebRTCClient
     var activeCall: Binding<WebRTCClient.Call?>
     var localRendererAspectRatio: Binding<CGFloat?>
-    @State var pipStateChanged: (Bool) -> Void = {_ in }
-    @Binding var pipShown: Bool
 
-    init(client: WebRTCClient, activeCall: Binding<WebRTCClient.Call?>, localRendererAspectRatio: Binding<CGFloat?>, pipShown: Binding<Bool>) {
+    init(client: WebRTCClient, activeCall: Binding<WebRTCClient.Call?>, localRendererAspectRatio: Binding<CGFloat?>) {
         self.client = client
         self.activeCall = activeCall
         self.localRendererAspectRatio = localRendererAspectRatio
-        self._pipShown = pipShown
     }
 
     func makeUIView(context: Context) -> UIView {
@@ -167,18 +50,12 @@ struct CallViewLocal: UIViewRepresentable {
             client.addLocalRenderer(call, localRenderer)
             client.startCaptureLocalVideo(call)
             addSubviewAndResize(localRenderer, into: view)
-            DispatchQueue.main.async {
-                pipStateChanged = { shown in
-                    localRenderer.isHidden = shown
-                }
-            }
         }
         return view
     }
 
     func updateUIView(_ view: UIView, context: Context) {
         logger.debug("CallView.updateUIView local")
-        pipStateChanged(pipShown)
     }
 }
 

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

@@ -28,7 +28,6 @@ class Call: ObservableObject, Equatable {
     @Published var speakerEnabled = false
     @Published var videoEnabled: Bool
     @Published var connectionInfo: ConnectionInfo?
-    @Published var connectedAt: Date? = nil
 
     init(
         direction: CallDirection,
@@ -60,7 +59,6 @@ class Call: ObservableObject, Equatable {
         }
     }
     var hasMedia: Bool { get { callState == .offerSent || callState == .negotiated || callState == .connected } }
-    var supportsVideo: Bool { get { peerMedia == .video || localMedia == .video } }
 }
 
 enum CallDirection {

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

@@ -331,10 +331,6 @@ final class WebRTCClient: NSObject, RTCVideoViewDelegate, RTCFrameEncryptorDeleg
         activeCall.remoteStream?.add(renderer)
     }
 
-    func removeRemoteRenderer(_ activeCall: Call, _ renderer: RTCVideoRenderer) {
-        activeCall.remoteStream?.remove(renderer)
-    }
-
     func startCaptureLocalVideo(_ activeCall: Call) {
 #if targetEnvironment(simulator)
         guard
@@ -414,7 +410,6 @@ final class WebRTCClient: NSObject, RTCVideoViewDelegate, RTCFrameEncryptorDeleg
         guard let call = activeCall.wrappedValue else { return }
         logger.debug("WebRTCClient: ending the call")
         activeCall.wrappedValue = nil
-        (call.localCamera as? RTCCameraVideoCapturer)?.stopCapture()
         call.connection.close()
         call.connection.delegate = nil
         call.frameEncryptor?.delegate = nil

apps/ios/Shared/Views/Chat/ChatItem/CIImageView.swift

@@ -29,9 +29,6 @@ struct CIImageView: View {
                     FullScreenMediaView(chatItem: chatItem, image: uiImage, showView: $showFullScreenImage, scrollProxy: scrollProxy)
                 }
                 .onTapGesture { showFullScreenImage = true }
-                .onChange(of: m.activeCallViewIsCollapsed) { _ in
-                    showFullScreenImage = false
-                }
             } else if let data = Data(base64Encoded: dropImagePrefix(image)),
                       let uiImage = UIImage(data: data) {
                 imageView(uiImage)

apps/ios/Shared/Views/Chat/ChatItem/CIVideoView.swift

@@ -120,9 +120,6 @@ struct CIVideoView: View {
                         showFullScreenPlayer = urlDecrypted != nil
                     }
                 }
-                .onChange(of: m.activeCallViewIsCollapsed) { _ in
-                    showFullScreenPlayer = false
-                }
                 if !decryptionInProgress {
                     Button {
                         decrypt(file: file) {
@@ -171,9 +168,6 @@ struct CIVideoView: View {
                     default: ()
                     }
                 }
-                .onChange(of: m.activeCallViewIsCollapsed) { _ in
-                    showFullScreenPlayer = false
-                }
                 if !videoPlaying {
                     Button {
                         m.stopPreviousRecPlay = url

apps/ios/Shared/Views/Chat/ChatView.swift

@@ -161,15 +161,11 @@ struct ChatView: View {
                     HStack {
                         let callsPrefEnabled = contact.mergedPreferences.calls.enabled.forUser
                         if callsPrefEnabled {
-                            if chatModel.activeCall == nil {
-                                callButton(contact, .audio, imageName: "phone")
-                                    .disabled(!contact.ready || !contact.active)
-                            } else if let call = chatModel.activeCall, call.contact.id == cInfo.id {
-                                endCallButton(call)
-                            }
+                            callButton(contact, .audio, imageName: "phone")
+                                .disabled(!contact.ready || !contact.active)
                         }
                         Menu {
-                            if callsPrefEnabled && chatModel.activeCall == nil {
+                            if callsPrefEnabled {
                                 Button {
                                     CallController.shared.startCall(contact, .video)
                                 } label: {
@@ -426,19 +422,7 @@ struct ChatView: View {
             Image(systemName: imageName)
         }
     }
-
-    private func endCallButton(_ call: Call) -> some View {
-        Button {
-            if let uuid = call.callkitUUID {
-                CallController.shared.endCall(callUUID: uuid)
-            } else {
-                CallController.shared.endCall(call: call) {}
-            }
-        } label: {
-            Image(systemName: "phone.down.fill").tint(.red)
-        }
-    }
-
+    
     private func searchButton() -> some View {
         Button {
             searchMode = true

apps/ios/Shared/Views/Chat/Group/GroupChatInfoView.swift

@@ -234,29 +234,39 @@ struct GroupChatInfoView: View {
                 Spacer()
                 memberInfo(member)
             }
-            
+
+            // revert from this:
             if user {
                 v
-            } else if groupInfo.membership.memberRole >= .admin {
-                // TODO if there are more actions, refactor with lists of swipeActions
-                let canBlockForAll = member.canBlockForAll(groupInfo: groupInfo)
-                let canRemove = member.canBeRemoved(groupInfo: groupInfo)
-                if canBlockForAll && canRemove {
-                    removeSwipe(member, blockForAllSwipe(member, v))
-                } else if canBlockForAll {
-                    blockForAllSwipe(member, v)
-                } else if canRemove {
-                    removeSwipe(member, v)
-                } else {
-                    v
-                }
+            } else if member.canBeRemoved(groupInfo: groupInfo) {
+                removeSwipe(member, blockSwipe(member, v))
             } else {
-                if !member.blockedByAdmin {
-                    blockSwipe(member, v)
-                } else {
-                    v
-                }
+                blockSwipe(member, v)
             }
+            // revert to this: vvv
+//            if user {
+//                v
+//            } else if groupInfo.membership.memberRole >= .admin {
+//                // TODO if there are more actions, refactor with lists of swipeActions
+//                let canBlockForAll = member.canBlockForAll(groupInfo: groupInfo)
+//                let canRemove = member.canBeRemoved(groupInfo: groupInfo)
+//                if canBlockForAll && canRemove {
+//                    removeSwipe(member, blockForAllSwipe(member, v))
+//                } else if canBlockForAll {
+//                    blockForAllSwipe(member, v)
+//                } else if canRemove {
+//                    removeSwipe(member, v)
+//                } else {
+//                    v
+//                }
+//            } else {
+//                if !member.blockedByAdmin {
+//                    blockSwipe(member, v)
+//                } else {
+//                    v
+//                }
+//            }
+            // ^^^
         }
 
         @ViewBuilder private func memberInfo(_ member: GroupMember) -> some View {

apps/ios/Shared/Views/Chat/Group/GroupMemberInfoView.swift

@@ -168,11 +168,24 @@ struct GroupMemberInfoView: View {
                         }
                     }
 
-                    if groupInfo.membership.memberRole >= .admin {
-                        adminDestructiveSection(member)
-                    } else {
-                        nonAdminBlockSection(member)
+                    // revert from this:
+                    Section {
+                        if member.memberSettings.showMessages {
+                            blockMemberButton(member)
+                        } else {
+                            unblockMemberButton(member)
+                        }
+                        if member.canBeRemoved(groupInfo: groupInfo) {
+                            removeMemberButton(member)
+                        }
                     }
+                    // revert to this: vvv
+//                    if groupInfo.membership.memberRole >= .admin {
+//                        adminDestructiveSection(member)
+//                    } else {
+//                        nonAdminBlockSection(member)
+//                    }
+                    // ^^^
 
                     if developerTools {
                         Section("For console") {

apps/ios/Shared/Views/UserSettings/DeveloperView.swift

@@ -42,25 +42,6 @@ struct DeveloperView: View {
                 } footer: {
                     (developerTools ? Text("Show:") : Text("Hide:")) + Text(" ") + Text("Database IDs and Transport isolation option.")
                 }
-
-//                Section {
-//                    settingsRow("arrow.up.doc") {
-//                        Toggle("Send videos and files via XFTP", isOn: $xftpSendEnabled)
-//                            .onChange(of: xftpSendEnabled) { _ in
-//                                do {
-//                                    try setXFTPConfig(getXFTPCfg())
-//                                } catch {
-//                                    logger.error("setXFTPConfig: cannot set XFTP config \(responseError(error))")
-//                                }
-//                            }
-//                    }
-//                } header: {
-//                    Text("Experimental")
-//                } footer: {
-//                    if xftpSendEnabled {
-//                        Text("v4.6.1+ is required to receive via XFTP.")
-//                    }
-//                }
             }
         }
     }

apps/ios/Shared/Views/UserSettings/NotificationsView.swift

@@ -76,10 +76,6 @@ struct NotificationsView: View {
                         Text(m.notificationPreview.label)
                     }
                 }
-
-                if let server = m.notificationServer {
-                    smpServers("Push server", [server])
-                }
             } header: {
                 Text("Push notifications")
             } footer: {
@@ -91,9 +87,6 @@ struct NotificationsView: View {
             }
         }
         .disabled(legacyDatabase)
-        .onAppear {
-            (m.savedToken, m.tokenStatus, m.notificationMode, m.notificationServer) = apiGetNtfToken()
-        }
     }
 
     private func notificationAlert(_ alert: NotificationAlert, _ token: DeviceToken) -> Alert {
@@ -132,7 +125,6 @@ struct NotificationsView: View {
                         m.tokenStatus = .new
                         notificationMode = .off
                         m.notificationMode = .off
-                        m.notificationServer = nil
                     }
                 } catch let error {
                     await MainActor.run {
@@ -143,13 +135,11 @@ struct NotificationsView: View {
                 }
             default:
                 do {
-                    let _ = try await apiRegisterToken(token: token, notificationMode: mode)
-                    let (_, tknStatus, ntfMode, ntfServer) = apiGetNtfToken()
+                    let status = try await apiRegisterToken(token: token, notificationMode: mode)
                     await MainActor.run {
-                        m.tokenStatus = tknStatus
-                        notificationMode = ntfMode
-                        m.notificationMode = ntfMode
-                        m.notificationServer = ntfServer
+                        m.tokenStatus = status
+                        notificationMode = mode
+                        m.notificationMode = mode
                     }
                 } catch let error {
                     await MainActor.run {

apps/ios/SimpleX NSE/NotificationService.swift

@@ -453,7 +453,6 @@ var receiverStarted = false
 let startLock = DispatchSemaphore(value: 1)
 let suspendLock = DispatchSemaphore(value: 1)
 var networkConfig: NetCfg = getNetCfg()
-let xftpConfig: XFTPFileConfig? = getXFTPCfg()
 
 // startChat uses semaphore startLock to ensure that only one didReceive thread can start chat controller
 // Subsequent calls to didReceive will be waiting on semaphore and won't start chat again, as it will be .active
@@ -499,7 +498,6 @@ func doStartChat() -> DBMigrationResult? {
             try setNetworkConfig(networkConfig)
             try apiSetTempFolder(tempFolder: getTempFilesDirectory().path)
             try apiSetFilesFolder(filesFolder: getAppFilesDirectory().path)
-            try setXFTPConfig(xftpConfig)
             try apiSetEncryptLocalFiles(privacyEncryptLocalFilesGroupDefault.get())
             // prevent suspension while starting chat
             suspendLock.wait()
@@ -733,12 +731,6 @@ func apiSetFilesFolder(filesFolder: String) throws {
     throw r
 }
 
-func setXFTPConfig(_ cfg: XFTPFileConfig?) throws {
-    let r = sendSimpleXCmd(.apiSetXFTPConfig(config: cfg))
-    if case .cmdOk = r { return }
-    throw r
-}
-
 func apiSetEncryptLocalFiles(_ enable: Bool) throws {
     let r = sendSimpleXCmd(.apiSetEncryptLocalFiles(enable: enable))
     if case .cmdOk = r { return }

apps/ios/SimpleX.xcodeproj/project.pbxproj

@@ -90,11 +90,6 @@
 		5CB0BA90282713D900B3292C /* SimpleXInfo.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA8F282713D900B3292C /* SimpleXInfo.swift */; };
 		5CB0BA92282713FD00B3292C /* CreateProfile.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA91282713FD00B3292C /* CreateProfile.swift */; };
 		5CB0BA9A2827FD8800B3292C /* HowItWorks.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB0BA992827FD8800B3292C /* HowItWorks.swift */; };
-		5CB1CE882B8259EB00963938 /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE832B8259EB00963938 /* libgmpxx.a */; };
-		5CB1CE892B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */; };
-		5CB1CE8A2B8259EB00963938 /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE852B8259EB00963938 /* libffi.a */; };
-		5CB1CE8B2B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */; };
-		5CB1CE8C2B8259EB00963938 /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE872B8259EB00963938 /* libgmp.a */; };
 		5CB2084F28DA4B4800D024EC /* RTCServers.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB2084E28DA4B4800D024EC /* RTCServers.swift */; };
 		5CB346E52868AA7F001FD2EF /* SuspendChat.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB346E42868AA7F001FD2EF /* SuspendChat.swift */; };
 		5CB346E72868D76D001FD2EF /* NotificationsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CB346E62868D76D001FD2EF /* NotificationsView.swift */; };
@@ -144,6 +139,11 @@
 		5CEACCED27DEA495000BD591 /* MsgContentView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CEACCEC27DEA495000BD591 /* MsgContentView.swift */; };
 		5CEBD7462A5C0A8F00665FE2 /* KeyboardPadding.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CEBD7452A5C0A8F00665FE2 /* KeyboardPadding.swift */; };
 		5CEBD7482A5F115D00665FE2 /* SetDeliveryReceiptsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CEBD7472A5F115D00665FE2 /* SetDeliveryReceiptsView.swift */; };
+		5CF4416D2B8E14EF00C52786 /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CF441682B8E14EF00C52786 /* libgmpxx.a */; };
+		5CF4416E2B8E14EF00C52786 /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CF441692B8E14EF00C52786 /* libffi.a */; };
+		5CF4416F2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CF4416A2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a */; };
+		5CF441702B8E14EF00C52786 /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CF4416B2B8E14EF00C52786 /* libgmp.a */; };
+		5CF441712B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CF4416C2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a */; };
 		5CF9371E2B23429500E1D781 /* ConcurrentQueue.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CF9371D2B23429500E1D781 /* ConcurrentQueue.swift */; };
 		5CF937202B24DE8C00E1D781 /* SharedFileSubscriber.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CF9371F2B24DE8C00E1D781 /* SharedFileSubscriber.swift */; };
 		5CF937232B2503D000E1D781 /* NSESubscriber.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5CF937212B25034A00E1D781 /* NSESubscriber.swift */; };
@@ -372,11 +372,6 @@
 		5CB0BA8F282713D900B3292C /* SimpleXInfo.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SimpleXInfo.swift; sourceTree = "<group>"; };
 		5CB0BA91282713FD00B3292C /* CreateProfile.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CreateProfile.swift; sourceTree = "<group>"; };
 		5CB0BA992827FD8800B3292C /* HowItWorks.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HowItWorks.swift; sourceTree = "<group>"; };
-		5CB1CE832B8259EB00963938 /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
-		5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a"; sourceTree = "<group>"; };
-		5CB1CE852B8259EB00963938 /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
-		5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a"; sourceTree = "<group>"; };
-		5CB1CE872B8259EB00963938 /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
 		5CB2084E28DA4B4800D024EC /* RTCServers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RTCServers.swift; sourceTree = "<group>"; };
 		5CB2085428DE647400D024EC /* de */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = de; path = de.lproj/Localizable.strings; sourceTree = "<group>"; };
 		5CB346E42868AA7F001FD2EF /* SuspendChat.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SuspendChat.swift; sourceTree = "<group>"; };
@@ -431,6 +426,11 @@
 		5CEACCEC27DEA495000BD591 /* MsgContentView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MsgContentView.swift; sourceTree = "<group>"; };
 		5CEBD7452A5C0A8F00665FE2 /* KeyboardPadding.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeyboardPadding.swift; sourceTree = "<group>"; };
 		5CEBD7472A5F115D00665FE2 /* SetDeliveryReceiptsView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SetDeliveryReceiptsView.swift; sourceTree = "<group>"; };
+		5CF441682B8E14EF00C52786 /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
+		5CF441692B8E14EF00C52786 /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
+		5CF4416A2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a"; sourceTree = "<group>"; };
+		5CF4416B2B8E14EF00C52786 /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
+		5CF4416C2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a"; sourceTree = "<group>"; };
 		5CF9371D2B23429500E1D781 /* ConcurrentQueue.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ConcurrentQueue.swift; sourceTree = "<group>"; };
 		5CF9371F2B24DE8C00E1D781 /* SharedFileSubscriber.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SharedFileSubscriber.swift; sourceTree = "<group>"; };
 		5CF937212B25034A00E1D781 /* NSESubscriber.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NSESubscriber.swift; sourceTree = "<group>"; };
@@ -514,13 +514,13 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				5CB1CE882B8259EB00963938 /* libgmpxx.a in Frameworks */,
-				5CB1CE8C2B8259EB00963938 /* libgmp.a in Frameworks */,
+				5CF4416D2B8E14EF00C52786 /* libgmpxx.a in Frameworks */,
+				5CF441712B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a in Frameworks */,
+				5CF4416F2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a in Frameworks */,
 				5CE2BA93284534B000EC33A6 /* libiconv.tbd in Frameworks */,
 				5CE2BA94284534BB00EC33A6 /* libz.tbd in Frameworks */,
-				5CB1CE8A2B8259EB00963938 /* libffi.a in Frameworks */,
-				5CB1CE892B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a in Frameworks */,
-				5CB1CE8B2B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a in Frameworks */,
+				5CF441702B8E14EF00C52786 /* libgmp.a in Frameworks */,
+				5CF4416E2B8E14EF00C52786 /* libffi.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -582,11 +582,11 @@
 		5C764E5C279C70B7000C6508 /* Libraries */ = {
 			isa = PBXGroup;
 			children = (
-				5CB1CE852B8259EB00963938 /* libffi.a */,
-				5CB1CE872B8259EB00963938 /* libgmp.a */,
-				5CB1CE832B8259EB00963938 /* libgmpxx.a */,
-				5CB1CE862B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE-ghc9.6.3.a */,
-				5CB1CE842B8259EB00963938 /* libHSsimplex-chat-5.5.3.0-1R6yZC1upSP6aXGrPWvhZE.a */,
+				5CF441692B8E14EF00C52786 /* libffi.a */,
+				5CF4416B2B8E14EF00C52786 /* libgmp.a */,
+				5CF441682B8E14EF00C52786 /* libgmpxx.a */,
+				5CF4416A2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7-ghc9.6.3.a */,
+				5CF4416C2B8E14EF00C52786 /* libHSsimplex-chat-5.5.6.0-LWDDfwd7rJr1QA7wWhj0K7.a */,
 			);
 			path = Libraries;
 			sourceTree = "<group>";
@@ -1509,7 +1509,7 @@
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_ENTITLEMENTS = "SimpleX (iOS).entitlements";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -1531,7 +1531,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.simplex.app;
 				PRODUCT_NAME = SimpleX;
 				SDKROOT = iphoneos;
@@ -1552,7 +1552,7 @@
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_ENTITLEMENTS = "SimpleX (iOS).entitlements";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -1574,7 +1574,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.simplex.app;
 				PRODUCT_NAME = SimpleX;
 				SDKROOT = iphoneos;
@@ -1633,7 +1633,7 @@
 				CODE_SIGN_ENTITLEMENTS = "SimpleX NSE/SimpleX NSE.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -1646,7 +1646,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = "chat.simplex.app.SimpleX-NSE";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -1665,7 +1665,7 @@
 				CODE_SIGN_ENTITLEMENTS = "SimpleX NSE/SimpleX NSE.entitlements";
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -1678,7 +1678,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = "chat.simplex.app.SimpleX-NSE";
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				PROVISIONING_PROFILE_SPECIFIER = "";
@@ -1697,7 +1697,7 @@
 				APPLICATION_EXTENSION_API_ONLY = YES;
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -1721,7 +1721,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Libraries/sim",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.simplex.SimpleXChat;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
 				SDKROOT = iphoneos;
@@ -1743,7 +1743,7 @@
 				APPLICATION_EXTENSION_API_ONLY = YES;
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 199;
+				CURRENT_PROJECT_VERSION = 201;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -1767,7 +1767,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Libraries/sim",
 				);
-				MARKETING_VERSION = 5.5.4;
+				MARKETING_VERSION = 5.5.6;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.simplex.SimpleXChat;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
 				SDKROOT = iphoneos;

apps/ios/SimpleXChat/APITypes.swift

@@ -31,7 +31,6 @@ public enum ChatCommand {
     case apiSuspendChat(timeoutMicroseconds: Int)
     case setTempFolder(tempFolder: String)
     case setFilesFolder(filesFolder: String)
-    case apiSetXFTPConfig(config: XFTPFileConfig?)
     case apiSetEncryptLocalFiles(enable: Bool)
     case apiExportArchive(config: ArchiveConfig)
     case apiImportArchive(config: ArchiveConfig)
@@ -162,11 +161,6 @@ public enum ChatCommand {
             case let .apiSuspendChat(timeoutMicroseconds): return "/_app suspend \(timeoutMicroseconds)"
             case let .setTempFolder(tempFolder): return "/_temp_folder \(tempFolder)"
             case let .setFilesFolder(filesFolder): return "/_files_folder \(filesFolder)"
-            case let .apiSetXFTPConfig(cfg): if let cfg = cfg {
-                return "/_xftp on \(encodeJSON(cfg))"
-            } else {
-                return "/_xftp off"
-            }
             case let .apiSetEncryptLocalFiles(enable): return "/_files_encrypt \(onOff(enable))"
             case let .apiExportArchive(cfg): return "/_db export \(encodeJSON(cfg))"
             case let .apiImportArchive(cfg): return "/_db import \(encodeJSON(cfg))"
@@ -311,7 +305,6 @@ public enum ChatCommand {
             case .apiSuspendChat: return "apiSuspendChat"
             case .setTempFolder: return "setTempFolder"
             case .setFilesFolder: return "setFilesFolder"
-            case .apiSetXFTPConfig: return "apiSetXFTPConfig"
             case .apiSetEncryptLocalFiles: return "apiSetEncryptLocalFiles"
             case .apiExportArchive: return "apiExportArchive"
             case .apiImportArchive: return "apiImportArchive"
@@ -613,7 +606,7 @@ public enum ChatResponse: Decodable, Error {
     case callEnded(user: UserRef, contact: Contact)
     case callInvitations(callInvitations: [RcvCallInvitation])
     case ntfTokenStatus(status: NtfTknStatus)
-    case ntfToken(token: DeviceToken, status: NtfTknStatus, ntfMode: NotificationsMode, ntfServer: String)
+    case ntfToken(token: DeviceToken, status: NtfTknStatus, ntfMode: NotificationsMode)
     case ntfMessages(user_: User?, connEntity_: ConnectionEntity?, msgTs: Date?, ntfMessages: [NtfMsgInfo])
     case ntfMessage(user: UserRef, connEntity: ConnectionEntity, ntfMessage: NtfMsgInfo)
     case contactConnectionDeleted(user: UserRef, connection: PendingContactConnection)
@@ -912,7 +905,7 @@ public enum ChatResponse: Decodable, Error {
             case let .callEnded(u, contact): return withUser(u, "contact: \(contact.id)")
             case let .callInvitations(invs): return String(describing: invs)
             case let .ntfTokenStatus(status): return String(describing: status)
-            case let .ntfToken(token, status, ntfMode, ntfServer): return "token: \(token)\nstatus: \(status.rawValue)\nntfMode: \(ntfMode.rawValue)\nntfServer: \(ntfServer)"
+            case let .ntfToken(token, status, ntfMode): return "token: \(token)\nstatus: \(status.rawValue)\nntfMode: \(ntfMode.rawValue)"
             case let .ntfMessages(u, connEntity, msgTs, ntfMessages): return withUser(u, "connEntity: \(String(describing: connEntity))\nmsgTs: \(String(describing: msgTs))\nntfMessages: \(String(describing: ntfMessages))")
             case let .ntfMessage(u, connEntity, ntfMessage): return withUser(u, "connEntity: \(String(describing: connEntity))\nntfMessage: \(String(describing: ntfMessage))")
             case let .contactConnectionDeleted(u, connection): return withUser(u, String(describing: connection))
@@ -1005,10 +998,6 @@ struct ComposedMessage: Encodable {
     var msgContent: MsgContent
 }
 
-public struct XFTPFileConfig: Encodable {
-    var minFileSize: Int64
-}
-
 public struct ArchiveConfig: Encodable {
     var archivePath: String
     var disableCompression: Bool?

apps/ios/SimpleXChat/AppGroup.swift

@@ -265,10 +265,6 @@ public class Default<T> {
     }
 }
 
-public func getXFTPCfg() -> XFTPFileConfig {
-    return XFTPFileConfig(minFileSize: 0)
-}
-
 public func getNetCfg() -> NetCfg {
     let onionHosts = networkUseOnionHostsGroupDefault.get()
     let (hostMode, requiredHostMode) = onionHosts.hostMode

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

@@ -103,14 +103,11 @@
       </intent-filter>
     </activity-alias>
 
-    <activity android:name=".views.call.CallActivity"
+
+    <activity android:name=".views.call.IncomingCallActivity"
         android:showOnLockScreen="true"
         android:exported="false"
-        android:launchMode="singleInstance"
-        android:supportsPictureInPicture="true"
-        android:autoRemoveFromRecents="true"
-        android:screenOrientation="portrait"
-        android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"/>
+        android:launchMode="singleTask"/>
 
     <provider
         android:name="androidx.core.content.FileProvider"
@@ -136,18 +133,6 @@
         android:stopWithTask="false"></service>
 
     <!-- SimplexService restart on reboot -->
-
-    <service
-        android:name=".CallService"
-        android:enabled="true"
-        android:exported="false"
-        android:stopWithTask="false"/>
-
-    <receiver
-        android:name=".CallService$CallActionReceiver"
-        android:enabled="true"
-        android:exported="false" />
-
     <receiver
         android:name=".SimplexService$StartReceiver"
         android:enabled="true"

apps/multiplatform/android/src/main/java/chat/simplex/app/CallService.kt

@@ -1,176 +0,0 @@
-package chat.simplex.app
-
-import android.app.*
-import android.content.*
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.os.*
-import androidx.compose.ui.graphics.asAndroidBitmap
-import androidx.core.app.NotificationCompat
-import androidx.core.content.ContextCompat
-import chat.simplex.app.model.NtfManager.EndCallAction
-import chat.simplex.app.views.call.CallActivity
-import chat.simplex.common.model.NotificationPreviewMode
-import chat.simplex.common.platform.*
-import chat.simplex.common.views.call.CallState
-import chat.simplex.common.views.helpers.*
-import chat.simplex.res.MR
-import kotlinx.datetime.Instant
-
-class CallService: Service() {
-  private var wakeLock: PowerManager.WakeLock? = null
-  private var notificationManager: NotificationManager? = null
-  private var serviceNotification: Notification? = null
-
-  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()
-        else -> Log.e(TAG, "No action in the intent")
-      }
-    } else {
-      Log.d(TAG, "null intent. Probably restarted by the system.")
-    }
-    startForeground(CALL_SERVICE_ID, serviceNotification)
-    return START_STICKY
-  }
-
-  override fun onCreate() {
-    super.onCreate()
-    Log.d(TAG, "Call service created")
-    notificationManager = createNotificationChannel()
-    updateNotification()
-    startForeground(CALL_SERVICE_ID, serviceNotification)
-  }
-
-  override fun onDestroy() {
-    Log.d(TAG, "Call service destroyed")
-    try {
-      wakeLock?.let {
-        while (it.isHeld) it.release() // release all, in case acquired more than once
-      }
-      wakeLock = null
-    } catch (e: Exception) {
-      Log.d(TAG, "Exception while releasing wakelock: ${e.message}")
-    }
-    super.onDestroy()
-  }
-
-  private fun startService() {
-    Log.d(TAG, "CallService startService")
-    if (wakeLock != null) return
-    wakeLock = (getSystemService(Context.POWER_SERVICE) as PowerManager).run {
-      newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKE_LOCK_TAG).apply {
-        acquire()
-      }
-    }
-  }
-
-  fun updateNotification() {
-    val call = chatModel.activeCall.value
-    val previewMode = appPreferences.notificationPreviewMode.get()
-    val title = if (previewMode == NotificationPreviewMode.HIDDEN.name)
-      generalGetString(MR.strings.notification_preview_somebody)
-    else
-      call?.contact?.profile?.displayName ?: ""
-    val text = generalGetString(if (call?.supportsVideo() == true) MR.strings.call_service_notification_video_call else MR.strings.call_service_notification_audio_call)
-    val image = call?.contact?.image
-    val largeIcon = if (image == null || previewMode == NotificationPreviewMode.HIDDEN.name)
-      BitmapFactory.decodeResource(resources, R.drawable.icon)
-    else
-      base64ToBitmap(image).asAndroidBitmap()
-
-    serviceNotification = createNotification(title, text, largeIcon, call?.connectedAt)
-    startForeground(CALL_SERVICE_ID, serviceNotification)
-  }
-
-  private fun createNotificationChannel(): NotificationManager? {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-      val channel = NotificationChannel(CALL_NOTIFICATION_CHANNEL_ID, CALL_NOTIFICATION_CHANNEL_NAME, NotificationManager.IMPORTANCE_DEFAULT)
-      notificationManager.createNotificationChannel(channel)
-      return notificationManager
-    }
-    return null
-  }
-
-  private fun createNotification(title: String, text: String, icon: Bitmap, connectedAt: Instant? = null): Notification {
-    val pendingIntent: PendingIntent = Intent(this, CallActivity::class.java).let { notificationIntent ->
-      PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE)
-    }
-
-    val endCallPendingIntent: PendingIntent = Intent(this, CallActionReceiver::class.java).let { notificationIntent ->
-      notificationIntent.setAction(EndCallAction)
-      PendingIntent.getBroadcast(this, 1, notificationIntent, PendingIntent.FLAG_CANCEL_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-    }
-
-    val builder =  NotificationCompat.Builder(this, CALL_NOTIFICATION_CHANNEL_ID)
-      .setSmallIcon(R.drawable.ntf_icon)
-      .setLargeIcon(icon.clipToCircle())
-      .setColor(0x88FFFF)
-      .setContentTitle(title)
-      .setContentText(text)
-      .setContentIntent(pendingIntent)
-      .setSilent(true)
-      .addAction(R.drawable.ntf_icon, generalGetString(MR.strings.call_service_notification_end_call), endCallPendingIntent)
-    if (connectedAt != null) {
-      builder.setUsesChronometer(true)
-      builder.setWhen(connectedAt.epochSeconds * 1000)
-    }
-
-    return builder.build()
-  }
-
-  override fun onBind(intent: Intent): IBinder {
-    return CallServiceBinder()
-  }
-
-  inner class CallServiceBinder : Binder() {
-    fun getService() = this@CallService
-  }
-
-  enum class Action {
-    START,
-  }
-
-  class CallActionReceiver: BroadcastReceiver() {
-    override fun onReceive(context: Context?, intent: Intent?) {
-      when (intent?.action) {
-        EndCallAction -> {
-          val call = chatModel.activeCall.value
-          if (call != null) {
-            withBGApi {
-              chatModel.callManager.endCall(call)
-            }
-          }
-        }
-        else -> {
-          Log.e(TAG, "Unknown action. Make sure you provided an action")
-        }
-      }
-    }
-  }
-
-companion object {
-    const val TAG = "CALL_SERVICE"
-    const val CALL_NOTIFICATION_CHANNEL_ID = "chat.simplex.app.CALL_SERVICE_NOTIFICATION"
-    const val CALL_NOTIFICATION_CHANNEL_NAME = "SimpleX Chat call service"
-    const val CALL_SERVICE_ID = 6788
-    const val WAKE_LOCK_TAG = "CallService::lock"
-
-    fun startService(): Intent {
-      Log.d(TAG, "CallService start")
-      return Intent(androidAppContext, CallService::class.java).also {
-        it.action = Action.START.name
-        ContextCompat.startForegroundService(androidAppContext, it)
-      }
-    }
-
-    fun stopService() {
-      androidAppContext.stopService(Intent(androidAppContext, CallService::class.java))
-    }
-  }
-}

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

@@ -1,15 +1,14 @@
 package chat.simplex.app
 
-import android.app.*
+import android.app.Application
 import android.content.Context
+import androidx.compose.ui.platform.ClipboardManager
 import chat.simplex.common.platform.Log
-import android.content.Intent
+import android.app.UiModeManager
 import android.os.*
 import androidx.lifecycle.*
 import androidx.work.*
 import chat.simplex.app.model.NtfManager
-import chat.simplex.app.model.NtfManager.AcceptCallAction
-import chat.simplex.app.views.call.CallActivity
 import chat.simplex.common.helpers.APPLICATION_ID
 import chat.simplex.common.helpers.requiresIgnoringBattery
 import chat.simplex.common.model.*
@@ -19,7 +18,6 @@ import chat.simplex.common.platform.*
 import chat.simplex.common.ui.theme.CurrentColors
 import chat.simplex.common.ui.theme.DefaultTheme
 import chat.simplex.common.views.call.RcvCallInvitation
-import chat.simplex.common.views.call.activeCallDestroyWebView
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.views.onboarding.OnboardingStage
 import com.jakewharton.processphoenix.ProcessPhoenix
@@ -186,10 +184,6 @@ class SimplexApp: Application(), LifecycleEventObserver {
         SimplexService.safeStopService()
       }
 
-      override fun androidCallServiceSafeStop() {
-        CallService.stopService()
-      }
-
       override fun androidNotificationsModeChanged(mode: NotificationsMode) {
         if (mode.requiresIgnoringBattery && !SimplexService.isBackgroundAllowed()) {
           appPrefs.backgroundServiceNoticeShown.set(false)
@@ -260,28 +254,6 @@ class SimplexApp: Application(), LifecycleEventObserver {
         uiModeManager.setApplicationNightMode(mode)
       }
 
-      override fun androidStartCallActivity(acceptCall: Boolean, remoteHostId: Long?, chatId: ChatId?) {
-        val context = mainActivity.get() ?: return
-        val intent = Intent(context, CallActivity::class.java)
-          .addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
-        if (acceptCall) {
-          intent.setAction(AcceptCallAction)
-            .putExtra("remoteHostId", remoteHostId)
-            .putExtra("chatId", chatId)
-        }
-        intent.flags += Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT
-        context.startActivity(intent)
-      }
-
-      override fun androidPictureInPictureAllowed(): Boolean {
-        val appOps = androidAppContext.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
-        return appOps.checkOpNoThrow(AppOpsManager.OPSTR_PICTURE_IN_PICTURE, Process.myUid(), packageName) == AppOpsManager.MODE_ALLOWED
-      }
-
-      override fun androidCallEnded() {
-        activeCallDestroyWebView()
-      }
-
       override suspend fun androidAskToAllowBackgroundCalls(): Boolean {
         if (SimplexService.isBackgroundRestricted()) {
           val userChoice: CompletableDeferred<Boolean> = CompletableDeferred()

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

@@ -34,13 +34,12 @@ import kotlin.system.exitProcess
 
 class SimplexService: Service() {
   private var wakeLock: PowerManager.WakeLock? = null
-  private var isCheckingNewMessages = false
+  private var isStartingService = false
   private var notificationManager: NotificationManager? = null
   private var serviceNotification: Notification? = null
 
   override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
     Log.d(TAG, "onStartCommand startId: $startId")
-    isServiceStarting = false
     if (intent != null) {
       val action = intent.action
       Log.d(TAG, "intent action $action")
@@ -72,7 +71,6 @@ class SimplexService: Service() {
       stopForeground(true)
       stopSelf()
     } else {
-      isServiceStarting = false
       isServiceStarted = true
       // In case of self-destruct is enabled the initialization process will not start in SimplexApp, Let's start it here
       if (DatabaseUtils.ksSelfDestructPassword.get() != null && chatModel.chatDbStatus.value == null) {
@@ -91,7 +89,6 @@ class SimplexService: Service() {
     } catch (e: Exception) {
       Log.d(TAG, "Exception while releasing wakelock: ${e.message}")
     }
-    isServiceStarting = false
     isServiceStarted = false
     stopAfterStart = false
     saveServiceState(this, ServiceState.STOPPED)
@@ -104,9 +101,9 @@ class SimplexService: Service() {
 
   private fun startService() {
     Log.d(TAG, "SimplexService startService")
-    if (wakeLock != null || isCheckingNewMessages) return
+    if (wakeLock != null || isStartingService) return
     val self = this
-    isCheckingNewMessages = true
+    isStartingService = true
     withLongRunningApi {
       val chatController = ChatController
       waitDbMigrationEnds(chatController)
@@ -126,7 +123,7 @@ class SimplexService: Service() {
           }
         }
       } finally {
-        isCheckingNewMessages = false
+        isStartingService = false
       }
     }
   }
@@ -265,7 +262,6 @@ class SimplexService: Service() {
     private const val SHARED_PREFS_SERVICE_STATE = "SIMPLEX_SERVICE_STATE"
     private const val WORK_NAME_ONCE = "ServiceStartWorkerOnce"
 
-    var isServiceStarting = false
     var isServiceStarted = false
     private var stopAfterStart = false
 
@@ -285,7 +281,7 @@ class SimplexService: Service() {
     fun safeStopService() {
       if (isServiceStarted) {
         androidAppContext.stopService(Intent(androidAppContext, SimplexService::class.java))
-      } else if (isServiceStarting) {
+      } else {
         stopAfterStart = true
       }
     }
@@ -295,7 +291,6 @@ class SimplexService: Service() {
       withContext(Dispatchers.IO) {
         Intent(androidAppContext, SimplexService::class.java).also {
           it.action = action.name
-          isServiceStarting = true
           ContextCompat.startForegroundService(androidAppContext, it)
         }
       }

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

@@ -13,7 +13,7 @@ import androidx.compose.ui.graphics.asAndroidBitmap
 import androidx.core.app.*
 import chat.simplex.app.*
 import chat.simplex.app.TAG
-import chat.simplex.app.views.call.CallActivity
+import chat.simplex.app.views.call.IncomingCallActivity
 import chat.simplex.app.views.call.getKeyguardManager
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.*
@@ -33,7 +33,6 @@ object NtfManager {
   const val CallChannel: String = "chat.simplex.app.CALL_NOTIFICATION_2"
   const val AcceptCallAction: String = "chat.simplex.app.ACCEPT_CALL"
   const val RejectCallAction: String = "chat.simplex.app.REJECT_CALL"
-  const val EndCallAction: String = "chat.simplex.app.END_CALL"
   const val CallNotificationId: Int = -1
   private const val UserIdKey: String = "userId"
   private const val ChatIdKey: String = "chatId"
@@ -158,7 +157,7 @@ object NtfManager {
     val screenOff = displayManager.displays.all { it.state != Display.STATE_ON }
     var ntfBuilder =
       if ((keyguardManager.isKeyguardLocked || screenOff) && appPreferences.callOnLockScreen.get() != CallOnLockScreen.DISABLE) {
-        val fullScreenIntent = Intent(context, CallActivity::class.java)
+        val fullScreenIntent = Intent(context, IncomingCallActivity::class.java)
         val fullScreenPendingIntent = PendingIntent.getActivity(context, 0, fullScreenIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
         NotificationCompat.Builder(context, CallChannel)
           .setFullScreenIntent(fullScreenPendingIntent, true)

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

@@ -1,18 +1,17 @@
 package chat.simplex.app.views.call
 
-import android.app.*
-import android.content.*
-import android.content.res.Configuration
-import android.graphics.Rect
-import android.os.*
-import android.util.Rational
-import android.view.*
+import android.app.Activity
+import android.app.KeyguardManager
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.Bundle
+import chat.simplex.common.platform.Log
+import android.view.WindowManager
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
-import androidx.activity.trackPipAnimationHintView
 import androidx.compose.desktop.ui.tooling.preview.Preview
 import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
@@ -23,115 +22,33 @@ import androidx.compose.ui.draw.scale
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import androidx.lifecycle.Lifecycle
 import chat.simplex.app.*
 import chat.simplex.app.R
-import chat.simplex.app.TAG
-import chat.simplex.app.model.NtfManager
-import chat.simplex.app.model.NtfManager.AcceptCallAction
 import chat.simplex.common.model.*
-import chat.simplex.common.platform.*
+import chat.simplex.app.model.NtfManager.OpenChatAction
+import chat.simplex.common.platform.ntfManager
 import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.call.*
 import chat.simplex.common.views.helpers.*
 import chat.simplex.res.MR
 import dev.icerock.moko.resources.compose.stringResource
-import kotlinx.coroutines.launch
 import kotlinx.datetime.Clock
-import java.lang.ref.WeakReference
-import chat.simplex.common.platform.chatModel as m
 
-class CallActivity: ComponentActivity(), ServiceConnection {
-
-  var boundService: CallService? = null
+class IncomingCallActivity: ComponentActivity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-    callActivity = WeakReference(this)
-    when (intent?.action) {
-      AcceptCallAction -> {
-        val remoteHostId = intent.getLongExtra("remoteHostId", -1).takeIf { it != -1L }
-        val chatId = intent.getStringExtra("chatId")
-        val invitation = (m.callInvitations.values + m.activeCallInvitation.value).lastOrNull {
-          it?.remoteHostId == remoteHostId && it?.contact?.id == chatId
-        }
-        if (invitation != null) {
-          m.callManager.acceptIncomingCall(invitation = invitation)
-        }
-      }
-    }
-
-    setContent { CallActivityView() }
-
-    if (isOnLockScreenNow()) {
-      unlockForIncomingCall()
-    }
+    setContent { IncomingCallActivityView(ChatModel) }
+    unlockForIncomingCall()
   }
 
   override fun onDestroy() {
     super.onDestroy()
-    if (isOnLockScreenNow()) {
-      lockAfterIncomingCall()
-    }
-    try {
-      unbindService(this)
-    } catch (e: Exception) {
-      Log.i(TAG, "Unable to unbind service: " + e.stackTraceToString())
-    }
-  }
-
-  private fun isOnLockScreenNow() = getKeyguardManager(this).isKeyguardLocked
-
-  fun setPipParams(video: Boolean, sourceRectHint: Rect? = null, viewRatio: Rational? = null) {
-    // By manually specifying source rect we exclude empty background while toggling PiP
-    val builder = PictureInPictureParams.Builder()
-        .setAspectRatio(viewRatio)
-        .setSourceRectHint(sourceRectHint)
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      builder.setAutoEnterEnabled(video)
-    }
-    setPictureInPictureParams(builder.build())
-  }
-
-  override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration) {
-    super.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
-    m.activeCallViewIsCollapsed.value = isInPictureInPictureMode
-    val layoutType = if (!isInPictureInPictureMode) {
-      LayoutType.Default
-    } else {
-      LayoutType.RemoteVideo
-    }
-    m.callCommand.add(WCallCommand.Layout(layoutType))
-  }
-
-  override fun onBackPressed() {
-    if (isOnLockScreenNow()) {
-      super.onBackPressed()
-    } else {
-      m.activeCallViewIsCollapsed.value = true
-    }
-  }
-
-  override fun onPictureInPictureRequested(): Boolean {
-    Log.d(TAG, "Requested picture-in-picture from the system")
-    return super.onPictureInPictureRequested()
-  }
-
-  override fun onUserLeaveHint() {
-    // On Android 12+ PiP is enabled automatically when a user hides the app
-    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.R && callSupportsVideo() && platform.androidPictureInPictureAllowed()) {
-      enterPictureInPictureMode()
-    }
-  }
-
-  override fun onResume() {
-    super.onResume()
-    m.activeCallViewIsCollapsed.value = false
+    lockAfterIncomingCall()
   }
 
   private fun unlockForIncomingCall() {
@@ -155,23 +72,6 @@ class CallActivity: ComponentActivity(), ServiceConnection {
     }
   }
 
-  fun startServiceAndBind() {
-    /**
-     * On Android 12 there is a bug that prevents starting activity after pressing back button
-     * (the error says that it denies to start activity in background).
-     * Workaround is to bind to a service
-     * */
-    bindService(CallService.startService(), this, 0)
-  }
-
-  override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
-    boundService = (service as CallService.CallServiceBinder).getService()
-  }
-
-  override fun onServiceDisconnected(name: ComponentName?) {
-    boundService = null
-  }
-
   companion object {
     const val activityFlags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or WindowManager.LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON
   }
@@ -180,96 +80,38 @@ class CallActivity: ComponentActivity(), ServiceConnection {
 fun getKeyguardManager(context: Context): KeyguardManager =
   context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
 
-private fun callSupportsVideo() = m.activeCall.value?.supportsVideo() == true || m.activeCallInvitation.value?.callType?.media == CallMediaType.Video
-
 @Composable
-fun CallActivityView() {
+fun IncomingCallActivityView(m: ChatModel) {
   val switchingCall = m.switchingCall.value
   val invitation = m.activeCallInvitation.value
-  val call = remember { m.activeCall }.value
+  val call = m.activeCall.value
   val showCallView = m.showCallView.value
-  val activity = LocalContext.current as CallActivity
-  LaunchedEffect(Unit) {
-    snapshotFlow { m.activeCallViewIsCollapsed.value }
-      .collect { collapsed ->
-        when {
-          collapsed -> {
-            if (!platform.androidPictureInPictureAllowed() || !callSupportsVideo()) {
-              activity.moveTaskToBack(true)
-              activity.startActivity(Intent(activity, MainActivity::class.java))
-            } else if (!activity.isInPictureInPictureMode && activity.lifecycle.currentState == Lifecycle.State.RESUMED) {
-              // User pressed back button, show MainActivity
-              activity.startActivity(Intent(activity, MainActivity::class.java))
-              activity.enterPictureInPictureMode()
-            }
-          }
-          callSupportsVideo() && !platform.androidPictureInPictureAllowed() -> {
-            // PiP disabled by user
-            platform.androidStartCallActivity(false)
-          }
-          activity.isInPictureInPictureMode -> {
-            platform.androidStartCallActivity(false)
-          }
-        }
-      }
-  }
-  SimpleXTheme {
-    var prevCall by remember { mutableStateOf(call) }
-    KeyChangeEffect(m.activeCall.value) {
-      if (m.activeCall.value != null) {
-        prevCall = m.activeCall.value
-        activity.boundService?.updateNotification()
-      }
-    }
-    Box(Modifier.background(Color.Black)) {
-      if (call != null) {
-        val view = LocalView.current
-        ActiveCallView()
-        if (callSupportsVideo()) {
-          val scope = rememberCoroutineScope()
-          LaunchedEffect(Unit) {
-            scope.launch {
-              activity.setPipParams(callSupportsVideo(), viewRatio = Rational(view.width, view.height))
-              activity.trackPipAnimationHintView(view)
-            }
-          }
-        }
-      } else if (prevCall != null) {
-        prevCall?.let { ActiveCallOverlayDisabled(it) }
-      }
-      if (invitation != null) {
-        if (call == null) {
-          Surface(
-            Modifier
-              .fillMaxSize(),
-            color = MaterialTheme.colors.background,
-            contentColor = LocalContentColor.current
-          ) {
-            IncomingCallLockScreenAlert(invitation, m)
-          }
-        } else {
-          IncomingCallAlertView(invitation, m)
-        }
-      }
-    }
-  }
-  LaunchedEffect(call == null) {
-    if (call != null) {
-      activity.startServiceAndBind()
-    }
-  }
+  val activity = LocalContext.current as Activity
   LaunchedEffect(invitation, call, switchingCall, showCallView) {
     if (!switchingCall && invitation == null && (!showCallView || call == null)) {
-      Log.d(TAG, "CallActivityView: finishing activity")
+      Log.d(TAG, "IncomingCallActivityView: finishing activity")
       activity.finish()
     }
   }
+  SimpleXTheme {
+    Surface(
+      Modifier
+        .fillMaxSize(),
+      color = MaterialTheme.colors.background,
+      contentColor = LocalContentColor.current
+    ) {
+      if (showCallView) {
+        Box {
+          ActiveCallView()
+          if (invitation != null) IncomingCallAlertView(invitation, m)
+        }
+      } else if (invitation != null) {
+        IncomingCallLockScreenAlert(invitation, m)
+      }
+    }
+  }
 }
 
-/**
-* Related to lockscreen
-* */
-
 @Composable
 fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatModel) {
   val cm = chatModel.callManager
@@ -293,7 +135,7 @@ fun IncomingCallLockScreenAlert(invitation: RcvCallInvitation, chatModel: ChatMo
     acceptCall = { cm.acceptIncomingCall(invitation = invitation) },
     openApp = {
       val intent = Intent(context, MainActivity::class.java)
-        .setAction(NtfManager.OpenChatAction)
+        .setAction(OpenChatAction)
         .putExtra("userId", invitation.user.userId)
         .putExtra("chatId", invitation.contact.id)
       context.startActivity(intent)

apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/AppCommon.android.kt

@@ -4,7 +4,6 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.net.LocalServerSocket
 import android.util.Log
-import androidx.activity.ComponentActivity
 import androidx.fragment.app.FragmentActivity
 import chat.simplex.common.*
 import chat.simplex.common.platform.*
@@ -26,8 +25,7 @@ val defaultLocale: Locale = Locale.getDefault()
 
 @SuppressLint("StaticFieldLeak")
 lateinit var androidAppContext: Context
-var mainActivity: WeakReference<FragmentActivity> = WeakReference(null)
-var callActivity: WeakReference<ComponentActivity> = WeakReference(null)
+lateinit var mainActivity: WeakReference<FragmentActivity>
 
 fun initHaskell() {
   val socketName = "chat.simplex.app.local.socket.address.listen.native.cmd2" + Random.nextLong(100000)

apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/platform/Images.android.kt

@@ -61,16 +61,6 @@ actual fun cropToSquare(image: ImageBitmap): ImageBitmap {
   return Bitmap.createBitmap(image.asAndroidBitmap(), xOffset, yOffset, side, side).asImageBitmap()
 }
 
-fun Bitmap.clipToCircle(): Bitmap {
-  val circle = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
-  val path = android.graphics.Path()
-  path.addCircle(width / 2f, height / 2f, min(width, height) / 2f, android.graphics.Path.Direction.CCW)
-  val canvas = android.graphics.Canvas(circle)
-  canvas.clipPath(path)
-  canvas.drawBitmap(this, 0f, 0f, null)
-  return circle
-}
-
 actual fun compressImageStr(bitmap: ImageBitmap): String {
   val usePng = bitmap.hasAlpha()
   val ext = if (usePng) "png" else "jpg"

apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/call/CallView.android.kt

@@ -28,7 +28,6 @@ import androidx.compose.ui.platform.LocalLifecycleOwner
 import dev.icerock.moko.resources.compose.painterResource
 import dev.icerock.moko.resources.compose.stringResource
 import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.viewinterop.AndroidView
 import androidx.lifecycle.Lifecycle
@@ -51,30 +50,20 @@ import kotlinx.datetime.Clock
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 
-// Should be destroy()'ed and set as null when call is ended. Otherwise, it will be a leak
-@SuppressLint("StaticFieldLeak")
-private var staticWebView: WebView? = null
-
-// WebView methods must be called on Main thread
-fun activeCallDestroyWebView() = withApi {
-  // Stop it when call ended
-  platform.androidCallServiceSafeStop()
-  staticWebView?.destroy()
-  staticWebView = null
-  Log.d(TAG, "CallView: webview was destroyed")
-}
-
 @SuppressLint("SourceLockedOrientationActivity")
 @Composable
 actual fun ActiveCallView() {
+  val chatModel = ChatModel
+  BackHandler(onBack = {
+    val call = chatModel.activeCall.value
+    if (call != null) withBGApi { chatModel.callManager.endCall(call) }
+  })
   val audioViaBluetooth = rememberSaveable { mutableStateOf(false) }
-  val proximityLock = remember {
-    val pm = (androidAppContext.getSystemService(Context.POWER_SERVICE) as PowerManager)
-    if (pm.isWakeLockLevelSupported(PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
-      pm.newWakeLock(PROXIMITY_SCREEN_OFF_WAKE_LOCK, androidAppContext.packageName + ":proximityLock")
-    } else {
-      null
-    }
+  val ntfModeService = remember { chatModel.controller.appPrefs.notificationsMode.get() == NotificationsMode.SERVICE }
+  LaunchedEffect(Unit) {
+    // Start service when call happening since it's not already started.
+    // It's needed to prevent Android from shutting down a microphone after a minute or so when screen is off
+    if (!ntfModeService) platform.androidServiceStart()
   }
   DisposableEffect(Unit) {
     val am = androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
@@ -104,24 +93,22 @@ actual fun ActiveCallView() {
       }
     }
     am.registerAudioDeviceCallback(audioCallback, null)
+    val pm = (androidAppContext.getSystemService(Context.POWER_SERVICE) as PowerManager)
+    val proximityLock = if (pm.isWakeLockLevelSupported(PROXIMITY_SCREEN_OFF_WAKE_LOCK)) {
+      pm.newWakeLock(PROXIMITY_SCREEN_OFF_WAKE_LOCK, androidAppContext.packageName + ":proximityLock")
+    } else {
+      null
+    }
+    proximityLock?.acquire()
     onDispose {
+      // Stop it when call ended
+      if (!ntfModeService) platform.androidServiceSafeStop()
       dropAudioManagerOverrides()
       am.unregisterAudioDeviceCallback(audioCallback)
-      if (proximityLock?.isHeld == true) {
-        proximityLock.release()
-      }
-    }
-  }
-  LaunchedEffect(chatModel.activeCallViewIsCollapsed.value) {
-    if (chatModel.activeCallViewIsCollapsed.value) {
-      if (proximityLock?.isHeld == true) proximityLock.release()
-    } else {
-      delay(1000)
-      if (proximityLock?.isHeld == false) proximityLock.acquire()
+      proximityLock?.release()
     }
   }
   val scope = rememberCoroutineScope()
-  val call = chatModel.activeCall.value
   Box(Modifier.fillMaxSize()) {
     WebRTCView(chatModel.callCommand) { apiMsg ->
       Log.d(TAG, "received from WebRTCView: $apiMsg")
@@ -133,15 +120,15 @@ actual fun ActiveCallView() {
           is WCallResponse.Capabilities -> withBGApi {
             val callType = CallType(call.localMedia, r.capabilities)
             chatModel.controller.apiSendCallInvitation(callRh, call.contact, callType)
-            updateActiveCall(call) { it.copy(callState = CallState.InvitationSent, localCapabilities = r.capabilities) }
+            chatModel.activeCall.value = call.copy(callState = CallState.InvitationSent, localCapabilities = r.capabilities)
           }
           is WCallResponse.Offer -> withBGApi {
             chatModel.controller.apiSendCallOffer(callRh, call.contact, r.offer, r.iceCandidates, call.localMedia, r.capabilities)
-            updateActiveCall(call) { it.copy(callState = CallState.OfferSent, localCapabilities = r.capabilities) }
+            chatModel.activeCall.value = call.copy(callState = CallState.OfferSent, localCapabilities = r.capabilities)
           }
           is WCallResponse.Answer -> withBGApi {
             chatModel.controller.apiSendCallAnswer(callRh, call.contact, r.answer, r.iceCandidates)
-            updateActiveCall(call) { it.copy(callState = CallState.Negotiated) }
+            chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
           }
           is WCallResponse.Ice -> withBGApi {
             chatModel.controller.apiSendCallExtraInfo(callRh, call.contact, r.iceCandidates)
@@ -150,7 +137,7 @@ actual fun ActiveCallView() {
             try {
               val callStatus = json.decodeFromString<WebRTCCallStatus>("\"${r.state.connectionState}\"")
               if (callStatus == WebRTCCallStatus.Connected) {
-                updateActiveCall(call) { it.copy(callState = CallState.Connected, connectedAt = Clock.System.now()) }
+                chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectedAt = Clock.System.now())
                 setCallSound(call.soundSpeaker, audioViaBluetooth)
               }
               withBGApi { chatModel.controller.apiCallStatus(callRh, call.contact, callStatus) }
@@ -158,7 +145,7 @@ actual fun ActiveCallView() {
               Log.d(TAG,"call status ${r.state.connectionState} not used")
             }
           is WCallResponse.Connected -> {
-            updateActiveCall(call) { it.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo) }
+            chatModel.activeCall.value = call.copy(callState = CallState.Connected, connectionInfo = r.connectionInfo)
             scope.launch {
               setCallSound(call.soundSpeaker, audioViaBluetooth)
             }
@@ -167,29 +154,27 @@ actual fun ActiveCallView() {
             withBGApi { chatModel.callManager.endCall(call) }
           }
           is WCallResponse.Ended -> {
-            updateActiveCall(call) { it.copy(callState = CallState.Ended) }
+            chatModel.activeCall.value = call.copy(callState = CallState.Ended)
             withBGApi { chatModel.callManager.endCall(call) }
+            chatModel.showCallView.value = false
           }
           is WCallResponse.Ok -> when (val cmd = apiMsg.command) {
             is WCallCommand.Answer ->
-              updateActiveCall(call) { it.copy(callState = CallState.Negotiated) }
+              chatModel.activeCall.value = call.copy(callState = CallState.Negotiated)
             is WCallCommand.Media -> {
-              updateActiveCall(call) {
-                when (cmd.media) {
-                  CallMediaType.Video -> it.copy(videoEnabled = cmd.enable)
-                  CallMediaType.Audio -> it.copy(audioEnabled = cmd.enable)
-                }
+              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 -> {
-              updateActiveCall(call) { it.copy(localCamera = cmd.camera) }
+              chatModel.activeCall.value = call.copy(localCamera = cmd.camera)
               if (!call.audioEnabled) {
                 chatModel.callCommand.add(WCallCommand.Media(CallMediaType.Audio, enable = false))
               }
             }
-            is WCallCommand.End -> {
-              withBGApi { chatModel.callManager.endCall(call) }
-            }
+            is WCallCommand.End ->
+              chatModel.showCallView.value = false
             else -> {}
           }
           is WCallResponse.Error -> {
@@ -198,16 +183,8 @@ actual fun ActiveCallView() {
         }
       }
     }
-    val showOverlay = when {
-      call == null -> false
-      !platform.androidPictureInPictureAllowed() -> true
-      !call.supportsVideo() -> true
-      !chatModel.activeCallViewIsCollapsed.value -> true
-      else -> false
-    }
-    if (call != null && showOverlay) {
-      ActiveCallOverlay(call, chatModel, audioViaBluetooth)
-    }
+    val call = chatModel.activeCall.value
+    if (call != null)  ActiveCallOverlay(call, chatModel, audioViaBluetooth)
   }
 
   val context = LocalContext.current
@@ -252,20 +229,6 @@ private fun ActiveCallOverlay(call: Call, chatModel: ChatModel, audioViaBluetoot
   )
 }
 
-@Composable
-fun ActiveCallOverlayDisabled(call: Call) {
-  ActiveCallOverlayLayout(
-    call = call,
-    speakerCanBeEnabled = false,
-    enabled = false,
-    dismiss = {},
-    toggleAudio = {},
-    toggleVideo = {},
-    toggleSound = {},
-    flipCamera = {}
-  )
-}
-
 private fun setCallSound(speaker: Boolean, audioViaBluetooth: MutableState<Boolean>) {
   val am = androidAppContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
   Log.d(TAG, "setCallSound: set audio mode, speaker enabled: $speaker")
@@ -308,69 +271,59 @@ private fun dropAudioManagerOverrides() {
 private fun ActiveCallOverlayLayout(
   call: Call,
   speakerCanBeEnabled: Boolean,
-  enabled: Boolean = true,
   dismiss: () -> Unit,
   toggleAudio: () -> Unit,
   toggleVideo: () -> Unit,
   toggleSound: () -> Unit,
   flipCamera: () -> Unit
 ) {
-  Column {
-    val media = call.peerMedia ?: call.localMedia
-    CloseSheetBar({ chatModel.activeCallViewIsCollapsed.value = true }, true, tintColor = Color(0xFFFFFFD8)) {
-      if (media == CallMediaType.Video) {
-        Text(call.contact.chatViewName, Modifier.fillMaxWidth().padding(end = DEFAULT_PADDING), color = Color(0xFFFFFFD8), style = MaterialTheme.typography.h2, overflow = TextOverflow.Ellipsis, maxLines = 1)
-      }
-    }
-    Column(Modifier.padding(horizontal = DEFAULT_PADDING)) {
-      when (media) {
-        CallMediaType.Video -> {
-          VideoCallInfoView(call)
-          Box(Modifier.fillMaxWidth().fillMaxHeight().weight(1f), contentAlignment = Alignment.BottomCenter) {
-            DisabledBackgroundCallsButton()
+  Column(Modifier.padding(DEFAULT_PADDING)) {
+    when (call.peerMedia ?: call.localMedia) {
+      CallMediaType.Video -> {
+        CallInfoView(call, alignment = Alignment.Start)
+        Box(Modifier.fillMaxWidth().fillMaxHeight().weight(1f), contentAlignment = Alignment.BottomCenter) {
+          DisabledBackgroundCallsButton()
+        }
+        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(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
           }
-          Row(Modifier.fillMaxWidth().padding(horizontal = 6.dp), horizontalArrangement = Arrangement.SpaceBetween, verticalAlignment = Alignment.CenterVertically) {
-            ToggleAudioButton(call, enabled, toggleAudio)
-            Spacer(Modifier.size(40.dp))
-            IconButton(onClick = dismiss, enabled = enabled) {
-              Icon(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = if (enabled) Color.Red else MaterialTheme.colors.secondary, modifier = Modifier.size(64.dp))
-            }
-            if (call.videoEnabled) {
-              ControlButton(call, painterResource(MR.images.ic_flip_camera_android_filled), MR.strings.icon_descr_flip_camera, enabled, flipCamera)
-              ControlButton(call, painterResource(MR.images.ic_videocam_filled), MR.strings.icon_descr_video_off, enabled, toggleVideo)
-            } else {
-              Spacer(Modifier.size(48.dp))
-              ControlButton(call, painterResource(MR.images.ic_videocam_off), MR.strings.icon_descr_video_on, enabled, toggleVideo)
-            }
+          if (call.videoEnabled) {
+            ControlButton(call, painterResource(MR.images.ic_flip_camera_android_filled), MR.strings.icon_descr_flip_camera, flipCamera)
+            ControlButton(call, painterResource(MR.images.ic_videocam_filled), MR.strings.icon_descr_video_off, toggleVideo)
+          } else {
+            Spacer(Modifier.size(48.dp))
+            ControlButton(call, painterResource(MR.images.ic_videocam_off), MR.strings.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)
-            AudioCallInfoView(call)
-          }
-          Box(Modifier.fillMaxWidth().fillMaxHeight().weight(1f), contentAlignment = Alignment.BottomCenter) {
-            DisabledBackgroundCallsButton()
-          }
-          Box(Modifier.fillMaxWidth().padding(bottom = DEFAULT_BOTTOM_PADDING), contentAlignment = Alignment.CenterStart) {
-            Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
-              IconButton(onClick = dismiss, enabled = enabled) {
-                Icon(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = if (enabled) Color.Red else MaterialTheme.colors.secondary, modifier = Modifier.size(64.dp))
-              }
+      }
+      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)
+        }
+        Box(Modifier.fillMaxWidth().fillMaxHeight().weight(1f), contentAlignment = Alignment.BottomCenter) {
+          DisabledBackgroundCallsButton()
+        }
+        Box(Modifier.fillMaxWidth().padding(bottom = DEFAULT_BOTTOM_PADDING), contentAlignment = Alignment.CenterStart) {
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
+            IconButton(onClick = dismiss) {
+              Icon(painterResource(MR.images.ic_call_end_filled), stringResource(MR.strings.icon_descr_hang_up), tint = Color.Red, modifier = Modifier.size(64.dp))
             }
-            Box(Modifier.padding(start = 32.dp)) {
-              ToggleAudioButton(call, enabled, toggleAudio)
-            }
-            Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
-              Box(Modifier.padding(end = 32.dp)) {
-                ToggleSoundButton(call, speakerCanBeEnabled && enabled, toggleSound)
-              }
+          }
+          Box(Modifier.padding(start = 32.dp)) {
+            ToggleAudioButton(call, toggleAudio)
+          }
+          Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) {
+            Box(Modifier.padding(end = 32.dp)) {
+              ToggleSoundButton(call, speakerCanBeEnabled, toggleSound)
             }
           }
         }
@@ -380,7 +333,7 @@ private fun ActiveCallOverlayLayout(
 }
 
 @Composable
-private fun ControlButton(call: Call, icon: Painter, iconText: StringResource, enabled: Boolean = true, action: () -> Unit) {
+private fun ControlButton(call: Call, icon: Painter, iconText: StringResource, action: () -> Unit, enabled: Boolean = true) {
   if (call.hasMedia) {
     IconButton(onClick = action, enabled = enabled) {
       Icon(icon, stringResource(iconText), tint = if (enabled) Color(0xFFFFFFD8) else MaterialTheme.colors.secondary, modifier = Modifier.size(40.dp))
@@ -391,26 +344,28 @@ private fun ControlButton(call: Call, icon: Painter, iconText: StringResource, e
 }
 
 @Composable
-private fun ToggleAudioButton(call: Call, enabled: Boolean = true, toggleAudio: () -> Unit) {
+private fun ToggleAudioButton(call: Call, toggleAudio: () -> Unit) {
   if (call.audioEnabled) {
-    ControlButton(call, painterResource(MR.images.ic_mic), MR.strings.icon_descr_audio_off, enabled, toggleAudio)
+    ControlButton(call, painterResource(MR.images.ic_mic), MR.strings.icon_descr_audio_off, toggleAudio)
   } else {
-    ControlButton(call, painterResource(MR.images.ic_mic_off), MR.strings.icon_descr_audio_on, enabled, toggleAudio)
+    ControlButton(call, painterResource(MR.images.ic_mic_off), MR.strings.icon_descr_audio_on, toggleAudio)
   }
 }
 
 @Composable
 private fun ToggleSoundButton(call: Call, enabled: Boolean, toggleSound: () -> Unit) {
   if (call.soundSpeaker) {
-    ControlButton(call, painterResource(MR.images.ic_volume_up), MR.strings.icon_descr_speaker_off, enabled, toggleSound)
+    ControlButton(call, painterResource(MR.images.ic_volume_up), MR.strings.icon_descr_speaker_off, toggleSound, enabled)
   } else {
-    ControlButton(call, painterResource(MR.images.ic_volume_down), MR.strings.icon_descr_speaker_on, enabled, toggleSound)
+    ControlButton(call, painterResource(MR.images.ic_volume_down), MR.strings.icon_descr_speaker_on, toggleSound, enabled)
   }
 }
 
 @Composable
-fun AudioCallInfoView(call: Call) {
-  Column(horizontalAlignment = Alignment.CenterHorizontally) {
+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)
 
@@ -420,21 +375,6 @@ fun AudioCallInfoView(call: Call) {
   }
 }
 
-@Composable
-fun VideoCallInfoView(call: Call) {
-  Column(horizontalAlignment = Alignment.Start) {
-    InfoText(call.callState.text)
-
-    val connInfo = call.connectionInfo
-    val connInfoText = if (connInfo == null) ""  else " (${connInfo.text})"
-    InfoText(call.encryptionStatus + connInfoText)
-  }
-}
-
-@Composable
-fun InfoText(text: String, modifier: Modifier = Modifier, style: TextStyle = MaterialTheme.typography.body2) =
-  Text(text, modifier, color = Color(0xFFFFFFD8), style = style)
-
 @Composable
 private fun DisabledBackgroundCallsButton() {
   var show by remember { mutableStateOf(!platform.androidIsBackgroundCallAllowed()) }
@@ -512,6 +452,7 @@ private fun DisabledBackgroundCallsButton() {
 
 @Composable
 fun WebRTCView(callCommand: SnapshotStateList<WCallCommand>, onResponse: (WVAPIMessage) -> Unit) {
+  val scope = rememberCoroutineScope()
   val webView = remember { mutableStateOf<WebView?>(null) }
   val permissionsState = rememberMultiplePermissionsState(
     permissions = listOf(
@@ -534,10 +475,10 @@ fun WebRTCView(callCommand: SnapshotStateList<WCallCommand>, onResponse: (WVAPIM
     }
     lifecycleOwner.lifecycle.addObserver(observer)
     onDispose {
+      val wv = webView.value
+      if (wv != null) processCommand(wv, WCallCommand.End)
       lifecycleOwner.lifecycle.removeObserver(observer)
-//      val wv = webView.value
-//      if (wv != null) processCommand(wv, WCallCommand.End)
-//      webView.value?.destroy()
+      webView.value?.destroy()
       webView.value = null
     }
   }
@@ -564,7 +505,7 @@ fun WebRTCView(callCommand: SnapshotStateList<WCallCommand>, onResponse: (WVAPIM
     Box(Modifier.fillMaxSize()) {
       AndroidView(
         factory = { AndroidViewContext ->
-          (staticWebView ?: WebView(androidAppContext)).apply {
+          WebView(AndroidViewContext).apply {
             layoutParams = ViewGroup.LayoutParams(
               ViewGroup.LayoutParams.MATCH_PARENT,
               ViewGroup.LayoutParams.MATCH_PARENT,
@@ -589,11 +530,7 @@ fun WebRTCView(callCommand: SnapshotStateList<WCallCommand>, onResponse: (WVAPIM
             webViewSettings.javaScriptEnabled = true
             webViewSettings.mediaPlaybackRequiresUserGesture = false
             webViewSettings.cacheMode = WebSettings.LOAD_NO_CACHE
-            if (staticWebView == null) {
-              this.loadUrl("file:android_asset/www/android/call.html")
-            } else {
-              webView.value = this
-            }
+            this.loadUrl("file:android_asset/www/android/call.html")
           }
         }
       ) { /* WebView */ }
@@ -617,15 +554,6 @@ class WebRTCInterface(private val onResponse: (WVAPIMessage) -> Unit) {
   }
 }
 
-private fun updateActiveCall(initial: Call, transform: (Call) -> Call) {
-  val activeCall = chatModel.activeCall.value
-  if (activeCall != null && activeCall.contact.apiId == initial.contact.apiId) {
-    chatModel.activeCall.value = transform(activeCall)
-  } else {
-    Log.d(TAG, "withActiveCall: ignoring, not in call with the contact ${activeCall?.contact?.id}")
-  }
-}
-
 private class LocalContentWebViewClient(val webView: MutableState<WebView?>, private val assetLoader: WebViewAssetLoader) : WebViewClientCompat() {
   override fun shouldInterceptRequest(
     view: WebView,
@@ -638,7 +566,6 @@ private class LocalContentWebViewClient(val webView: MutableState<WebView?>, pri
     super.onPageFinished(view, url)
     view.evaluateJavascript("sendMessageToNative = (msg) => WebRTCInterface.postMessage(JSON.stringify(msg))", null)
     webView.value = view
-    staticWebView = view
     Log.d(TAG, "WebRTCView: webview ready")
     // for debugging
     // view.evaluateJavascript("sendMessageToNative = ({resp}) => WebRTCInterface.postMessage(JSON.stringify({command: resp}))", null)
@@ -652,7 +579,6 @@ fun PreviewActiveCallOverlayVideo() {
     ActiveCallOverlayLayout(
       call = Call(
         remoteHostId = null,
-        userProfile = Profile.sampleData,
         contact = Contact.sampleData,
         callState = CallState.Negotiated,
         localMedia = CallMediaType.Video,
@@ -679,7 +605,6 @@ fun PreviewActiveCallOverlayAudio() {
     ActiveCallOverlayLayout(
       call = Call(
         remoteHostId = null,
-        userProfile = Profile.sampleData,
         contact = Contact.sampleData,
         callState = CallState.Negotiated,
         localMedia = CallMediaType.Audio,

apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/chatlist/ChatListView.android.kt

@@ -1,112 +1,8 @@
 package chat.simplex.common.views.chatlist
 
-import android.app.Activity
-import androidx.compose.foundation.*
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.*
-import androidx.compose.material.ripple.rememberRipple
 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.toArgb
-import androidx.compose.ui.platform.*
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.common.ANDROID_CALL_TOP_PADDING
-import chat.simplex.common.model.durationText
-import chat.simplex.common.platform.*
-import chat.simplex.common.ui.theme.*
-import chat.simplex.common.views.call.*
 import chat.simplex.common.views.helpers.*
-import chat.simplex.res.MR
-import dev.icerock.moko.resources.compose.painterResource
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.datetime.Clock
-
-private val CALL_INTERACTIVE_AREA_HEIGHT = 74.dp
-private val CALL_TOP_OFFSET = (-10).dp
-private val CALL_TOP_GREEN_LINE_HEIGHT = ANDROID_CALL_TOP_PADDING - CALL_TOP_OFFSET
-private val CALL_BOTTOM_ICON_OFFSET = (-15).dp
-private val CALL_BOTTOM_ICON_HEIGHT = CALL_INTERACTIVE_AREA_HEIGHT + CALL_BOTTOM_ICON_OFFSET
 
 @Composable
-actual fun ActiveCallInteractiveArea(call: Call, newChatSheetState: MutableStateFlow<AnimatedViewState>) {
-  val onClick = { platform.androidStartCallActivity(false) }
-  Box(Modifier.offset(y = CALL_TOP_OFFSET).height(CALL_INTERACTIVE_AREA_HEIGHT)) {
-    val source = remember { MutableInteractionSource() }
-    val indication = rememberRipple(bounded = true, 3000.dp)
-    Box(Modifier.height(CALL_TOP_GREEN_LINE_HEIGHT).clickable(onClick = onClick, indication = indication, interactionSource = source)) {
-      GreenLine(call)
-    }
-    Box(
-      Modifier
-        .offset(y = CALL_BOTTOM_ICON_OFFSET)
-        .size(CALL_BOTTOM_ICON_HEIGHT)
-        .background(SimplexGreen, CircleShape)
-        .clip(CircleShape)
-        .clickable(onClick = onClick, indication = indication, interactionSource = source)
-        .align(Alignment.BottomCenter),
-      contentAlignment = Alignment.Center
-    ) {
-      val media = call.peerMedia ?: call.localMedia
-      if (media == CallMediaType.Video) {
-        Icon(painterResource(MR.images.ic_videocam_filled), null, Modifier.size(27.dp).offset(x = 2.5.dp, y = 2.dp), tint = Color.White)
-      } else {
-        Icon(painterResource(MR.images.ic_call_filled), null, Modifier.size(27.dp).offset(x = -0.5.dp, y = 2.dp), tint = Color.White)
-      }
-    }
-  }
-}
-
-@Composable
-private fun GreenLine(call: Call) {
-  Row(
-    Modifier
-      .fillMaxSize()
-      .background(SimplexGreen)
-      .padding(top = -CALL_TOP_OFFSET)
-      .padding(horizontal = DEFAULT_PADDING),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.Center
-  ) {
-    ContactName(call.contact.displayName)
-    Spacer(Modifier.weight(1f))
-    CallDuration(call)
-  }
-  val window = (LocalContext.current as Activity).window
-  DisposableEffect(Unit) {
-    window.statusBarColor = SimplexGreen.toArgb()
-    onDispose {
-      window.statusBarColor = Color.Black.toArgb()
-    }
-  }
-}
-
-@Composable
-private fun ContactName(name: String) {
-  Text(name, Modifier.width(windowWidth() * 0.35f), color = Color.White, maxLines = 1, overflow = TextOverflow.Ellipsis)
-}
-
-@Composable
-private fun CallDuration(call: Call) {
-  val connectedAt = call.connectedAt
-  if (connectedAt != null) {
-    val time = remember { mutableStateOf(durationText(0)) }
-    LaunchedEffect(Unit) {
-      while (true) {
-        time.value = durationText((Clock.System.now() - connectedAt).inWholeSeconds.toInt())
-        delay(250)
-      }
-    }
-    val text = time.value
-    val sp40Or50 = with(LocalDensity.current) { if (text.length >= 6) 60.sp.toDp() else 42.sp.toDp() }
-    val offset = with(LocalDensity.current) { 7.sp.toDp() }
-    Text(text, Modifier.offset(x = offset).widthIn(min = sp40Or50), color = Color.White)
-  }
-}
+actual fun DesktopActiveCallOverlayLayout(newChatSheetState: MutableStateFlow<AnimatedViewState>) {}

apps/multiplatform/common/src/commonMain/cpp/desktop/CMakeLists.txt

@@ -71,7 +71,7 @@ if(NOT APPLE)
 else()
 	# Without direct linking it can't find hs_init in linking step
 	add_library( rts SHARED IMPORTED )
-	FILE(GLOB RTSLIB ${CMAKE_SOURCE_DIR}/libs/${OS_LIB_PATH}-${OS_LIB_ARCH}/libHSrts*_thr-*.${OS_LIB_EXT})
+	FILE(GLOB RTSLIB ${CMAKE_SOURCE_DIR}/libs/${OS_LIB_PATH}-${OS_LIB_ARCH}/deps/libHSrts*_thr-*.${OS_LIB_EXT})
 	set_target_properties( rts PROPERTIES IMPORTED_LOCATION ${RTSLIB})
 
 	target_link_libraries(app-lib rts simplex)

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/App.kt

@@ -1,19 +1,16 @@
 package chat.simplex.common
 
 import androidx.compose.animation.core.Animatable
-import androidx.compose.foundation.*
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.interaction.MutableInteractionSource
 import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.material.*
-import androidx.compose.material.ripple.rememberRipple
 import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
 import androidx.compose.ui.draw.clipToBounds
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.views.usersettings.SetDeliveryReceiptsView
@@ -23,7 +20,8 @@ import chat.simplex.common.ui.theme.*
 import chat.simplex.common.views.CreateFirstProfile
 import chat.simplex.common.views.helpers.SimpleButton
 import chat.simplex.common.views.SplashView
-import chat.simplex.common.views.call.*
+import chat.simplex.common.views.call.ActiveCallView
+import chat.simplex.common.views.call.IncomingCallAlertView
 import chat.simplex.common.views.chat.ChatView
 import chat.simplex.common.views.chatlist.*
 import chat.simplex.common.views.database.DatabaseErrorView
@@ -171,17 +169,7 @@ fun MainScreen() {
       }
     } else {
       if (chatModel.showCallView.value) {
-        if (appPlatform.isAndroid) {
-          LaunchedEffect(Unit) {
-            // This if prevents running the activity in the following condition:
-            // - the activity already started before and was destroyed by collapsing active call (start audio call, press back button, go to a launcher)
-            if (!chatModel.activeCallViewIsCollapsed.value) {
-              platform.androidStartCallActivity(false)
-            }
-          }
-        } else {
-          ActiveCallView()
-        }
+        ActiveCallView()
       } else {
         // It's needed for privacy settings toggle, so it can be shown even if the app is passcode unlocked
         ModalManager.fullscreen.showPasscodeInView()
@@ -218,13 +206,9 @@ fun MainScreen() {
   }
 }
 
-val ANDROID_CALL_TOP_PADDING = 40.dp
-
 @Composable
 fun AndroidScreen(settingsState: SettingsViewState) {
   BoxWithConstraints {
-    val call = remember { chatModel.activeCall} .value
-    val showCallArea = call != null && call.callState != CallState.WaitCapabilities && call.callState != CallState.InvitationAccepted
     var currentChatId by rememberSaveable { mutableStateOf(chatModel.chatId.value) }
     val offset = remember { Animatable(if (chatModel.chatId.value == null) 0f else maxWidth.value) }
     Box(
@@ -232,7 +216,6 @@ fun AndroidScreen(settingsState: SettingsViewState) {
         .graphicsLayer {
           translationX = -offset.value.dp.toPx()
         }
-        .padding(top = if (showCallArea) ANDROID_CALL_TOP_PADDING else 0.dp)
     ) {
       StartPartOfScreen(settingsState)
     }
@@ -259,17 +242,11 @@ fun AndroidScreen(settingsState: SettingsViewState) {
           }
       }
     }
-    Box(Modifier
-      .graphicsLayer { translationX = maxWidth.toPx() - offset.value.dp.toPx() }
-      .padding(top = if (showCallArea) ANDROID_CALL_TOP_PADDING else 0.dp)
-    ) Box2@{
+    Box(Modifier.graphicsLayer { translationX = maxWidth.toPx() - offset.value.dp.toPx() }) Box2@{
       currentChatId?.let {
         ChatView(it, chatModel, onComposed)
       }
     }
-    if (call != null && showCallArea) {
-      ActiveCallInteractiveArea(call, remember { MutableStateFlow(AnimatedViewState.GONE) })
-    }
   }
 }
 

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/ChatModel.kt

@@ -96,7 +96,6 @@ object ChatModel {
   val activeCallInvitation = mutableStateOf<RcvCallInvitation?>(null)
   val activeCall = mutableStateOf<Call?>(null)
   val activeCallViewIsVisible = mutableStateOf<Boolean>(false)
-  val activeCallViewIsCollapsed = mutableStateOf<Boolean>(false)
   val callCommand = mutableStateListOf<WCallCommand>()
   val showCallView = mutableStateOf(false)
   val switchingCall = mutableStateOf(false)

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/model/SimpleXAPI.kt

@@ -631,12 +631,6 @@ object ChatController {
     throw Error("failed to set remote hosts folder: ${r.responseType} ${r.details}")
   }
 
-  suspend fun apiSetXFTPConfig(cfg: XFTPFileConfig?) {
-    val r = sendCmd(null, CC.ApiSetXFTPConfig(cfg))
-    if (r is CR.CmdOk) return
-    throw Error("apiSetXFTPConfig bad response: ${r.responseType} ${r.details}")
-  }
-
   suspend fun apiSetEncryptLocalFiles(enable: Boolean) = sendCommandOkResp(null, CC.ApiSetEncryptLocalFiles(enable))
 
   suspend fun apiExportArchive(config: ArchiveConfig) {
@@ -1914,8 +1908,10 @@ object ChatController {
         if (invitation != null) {
           chatModel.callManager.reportCallRemoteEnded(invitation = invitation)
         }
-        withCall(r, r.contact) { call ->
-          withBGApi { chatModel.callManager.endCall(call) }
+        withCall(r, r.contact) { _ ->
+          chatModel.callCommand.add(WCallCommand.End)
+          chatModel.activeCall.value = null
+          chatModel.showCallView.value = false
         }
       }
       is CR.ContactSwitch ->
@@ -2171,10 +2167,6 @@ object ChatController {
     }
   }
 
-  fun getXFTPCfg(): XFTPFileConfig {
-    return XFTPFileConfig(minFileSize = 0)
-  }
-
   fun getNetCfg(): NetCfg {
     val useSocksProxy = appPrefs.networkUseSocksProxy.get()
     val proxyHostPort  = appPrefs.networkProxyHostPort.get()
@@ -2283,7 +2275,6 @@ sealed class CC {
   class SetTempFolder(val tempFolder: String): CC()
   class SetFilesFolder(val filesFolder: String): CC()
   class SetRemoteHostsFolder(val remoteHostsFolder: String): CC()
-  class ApiSetXFTPConfig(val config: XFTPFileConfig?): CC()
   class ApiSetEncryptLocalFiles(val enable: Boolean): CC()
   class ApiExportArchive(val config: ArchiveConfig): CC()
   class ApiImportArchive(val config: ArchiveConfig): CC()
@@ -2413,7 +2404,6 @@ sealed class CC {
     is SetTempFolder -> "/_temp_folder $tempFolder"
     is SetFilesFolder -> "/_files_folder $filesFolder"
     is SetRemoteHostsFolder -> "/remote_hosts_folder $remoteHostsFolder"
-    is ApiSetXFTPConfig -> if (config != null) "/_xftp on ${json.encodeToString(config)}" else "/_xftp off"
     is ApiSetEncryptLocalFiles -> "/_files_encrypt ${onOff(enable)}"
     is ApiExportArchive -> "/_db export ${json.encodeToString(config)}"
     is ApiImportArchive -> "/_db import ${json.encodeToString(config)}"
@@ -2548,7 +2538,6 @@ sealed class CC {
     is SetTempFolder -> "setTempFolder"
     is SetFilesFolder -> "setFilesFolder"
     is SetRemoteHostsFolder -> "setRemoteHostsFolder"
-    is ApiSetXFTPConfig -> "apiSetXFTPConfig"
     is ApiSetEncryptLocalFiles -> "apiSetEncryptLocalFiles"
     is ApiExportArchive -> "apiExportArchive"
     is ApiImportArchive -> "apiImportArchive"
@@ -2714,9 +2703,6 @@ sealed class ChatPagination {
 @Serializable
 class ComposedMessage(val fileSource: CryptoFile?, val quotedItemId: Long?, val msgContent: MsgContent)
 
-@Serializable
-class XFTPFileConfig(val minFileSize: Long)
-
 @Serializable
 class ArchiveConfig(val archivePath: String, val disableCompression: Boolean? = null, val parentTempDirectory: String? = null)
 

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/Core.kt

@@ -91,7 +91,6 @@ suspend fun initChatController(useKey: String? = null, confirmMigrations: Migrat
     if (appPlatform.isDesktop) {
       controller.apiSetRemoteHostsFolder(remoteHostsDir.absolutePath)
     }
-    controller.apiSetXFTPConfig(controller.getXFTPCfg())
     controller.apiSetEncryptLocalFiles(controller.appPrefs.privacyEncryptLocalFiles.get())
     // If we migrated successfully means previous re-encryption process on database level finished successfully too
     if (appPreferences.encryptionStartedAt.get() != null) appPreferences.encryptionStartedAt.set(null)

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/platform/Platform.kt

@@ -1,21 +1,16 @@
 package chat.simplex.common.platform
 
-import chat.simplex.common.model.ChatId
 import chat.simplex.common.model.NotificationsMode
 
 interface PlatformInterface {
   suspend fun androidServiceStart() {}
   fun androidServiceSafeStop() {}
-  fun androidCallServiceSafeStop() {}
   fun androidNotificationsModeChanged(mode: NotificationsMode) {}
   fun androidChatStartedAfterBeingOff() {}
   fun androidChatStopped() {}
   fun androidChatInitializedAndStarted() {}
   fun androidIsBackgroundCallAllowed(): Boolean = true
   fun androidSetNightModeIfSupported() {}
-  fun androidStartCallActivity(acceptCall: Boolean, remoteHostId: Long? = null, chatId: ChatId? = null) {}
-  fun androidPictureInPictureAllowed(): Boolean = true
-  fun androidCallEnded() {}
   suspend fun androidAskToAllowBackgroundCalls(): Boolean = true
 }
 /**

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/call/CallManager.kt

@@ -1,6 +1,6 @@
 package chat.simplex.common.views.call
 
-import chat.simplex.common.model.*
+import chat.simplex.common.model.ChatModel
 import chat.simplex.common.platform.*
 import chat.simplex.common.views.helpers.withBGApi
 import kotlinx.datetime.Clock
@@ -23,29 +23,27 @@ class CallManager(val chatModel: ChatModel) {
     }
   }
 
-  fun acceptIncomingCall(invitation: RcvCallInvitation) = withBGApi {
+  fun acceptIncomingCall(invitation: RcvCallInvitation) {
     val call = chatModel.activeCall.value
-    val contactInfo = chatModel.controller.apiContactInfo(invitation.remoteHostId, invitation.contact.contactId)
-    val profile = contactInfo?.second ?: invitation.user.profile.toProfile()
-    // In case the same contact calling while previous call didn't end yet (abnormal ending of call from the other side)
-    if (call == null || (call.remoteHostId == invitation.remoteHostId && call.contact.id == invitation.contact.id)) {
-      justAcceptIncomingCall(invitation = invitation, profile)
+    if (call == null) {
+      justAcceptIncomingCall(invitation = invitation)
     } else {
-      chatModel.switchingCall.value = true
-      try {
-        endCall(call = call)
-        justAcceptIncomingCall(invitation = invitation, profile)
-      } finally {
-        chatModel.switchingCall.value = false
+      withBGApi {
+        chatModel.switchingCall.value = true
+        try {
+          endCall(call = call)
+          justAcceptIncomingCall(invitation = invitation)
+        } finally {
+          chatModel.switchingCall.value = false
+        }
       }
     }
   }
 
-  private fun justAcceptIncomingCall(invitation: RcvCallInvitation, userProfile: Profile) {
+  private fun justAcceptIncomingCall(invitation: RcvCallInvitation) {
     with (chatModel) {
       activeCall.value = Call(
         remoteHostId = invitation.remoteHostId,
-        userProfile = userProfile,
         contact = invitation.contact,
         callState = CallState.InvitationAccepted,
         localMedia = invitation.callType.media,
@@ -70,23 +68,17 @@ class CallManager(val chatModel: ChatModel) {
   }
 
   suspend fun endCall(call: Call) {
-    with(chatModel) {
-      // If there is active call currently and it's with other contact, don't interrupt it
-      if (activeCall.value != null && !(activeCall.value?.remoteHostId == call.remoteHostId && activeCall.value?.contact?.id == call.contact.id)) return
-
-      // Don't destroy WebView if you plan to accept next call right after this one
-      if (!switchingCall.value) {
-        showCallView.value = false
-        activeCall.value = null
-        activeCallViewIsCollapsed.value = false
-        platform.androidCallEnded()
-      }
+    with (chatModel) {
       if (call.callState == CallState.Ended) {
         Log.d(TAG, "CallManager.endCall: call ended")
+        activeCall.value = null
+        showCallView.value = false
       } else {
         Log.d(TAG, "CallManager.endCall: ending call...")
-        //callCommand.add(WCallCommand.End)
+        callCommand.add(WCallCommand.End)
+        showCallView.value = false
         controller.apiEndCall(call.remoteHostId, call.contact)
+        activeCall.value = null
       }
     }
   }

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/call/WebRTC.kt

@@ -7,11 +7,11 @@ import kotlinx.datetime.Instant
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import java.net.URI
+import java.util.*
 import kotlin.collections.ArrayList
 
 data class Call(
   val remoteHostId: Long?,
-  val userProfile: Profile,
   val contact: Contact,
   val callState: CallState,
   val localMedia: CallMediaType,
@@ -23,7 +23,7 @@ data class Call(
   val soundSpeaker: Boolean = localMedia == CallMediaType.Video,
   var localCamera: VideoCamera = VideoCamera.User,
   val connectionInfo: ConnectionInfo? = null,
-  var connectedAt: Instant? = null,
+  var connectedAt: Instant? = null
 ) {
   val encrypted: Boolean get() = localEncrypted && sharedKey != null
   val localEncrypted: Boolean get() = localCapabilities?.encryption ?: false
@@ -36,9 +36,6 @@ data class Call(
   }
 
   val hasMedia: Boolean get() = callState == CallState.OfferSent || callState == CallState.Negotiated || callState == CallState.Connected
-
-  fun supportsVideo(): Boolean = peerMedia == CallMediaType.Video || localMedia == CallMediaType.Video
-
 }
 
 enum class CallState {
@@ -78,7 +75,6 @@ sealed class WCallCommand {
   @Serializable @SerialName("media") data class Media(val media: CallMediaType, val enable: Boolean): WCallCommand()
   @Serializable @SerialName("camera") data class Camera(val camera: VideoCamera): WCallCommand()
   @Serializable @SerialName("description") data class Description(val state: String, val description: String): WCallCommand()
-  @Serializable @SerialName("layout") data class Layout(val layout: LayoutType): WCallCommand()
   @Serializable @SerialName("end") object End: WCallCommand()
 }
 
@@ -171,13 +167,6 @@ enum class VideoCamera {
   val flipped: VideoCamera get() = if (this == User) Environment else User
 }
 
-@Serializable
-enum class LayoutType {
-  @SerialName("default") Default,
-  @SerialName("localVideo") LocalVideo,
-  @SerialName("remoteVideo") RemoteVideo
-}
-
 @Serializable
 data class ConnectionState(
   val connectionState: String,

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/ChatView.kt

@@ -301,9 +301,7 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
             withBGApi {
               val cInfo = chat.chatInfo
               if (cInfo is ChatInfo.Direct) {
-                val contactInfo = chatModel.controller.apiContactInfo(chat.remoteHostId, cInfo.contact.contactId)
-                val profile = contactInfo?.second ?: chatModel.currentUser.value?.profile?.toProfile() ?: return@withBGApi
-                chatModel.activeCall.value = Call(remoteHostId = chatRh, contact = cInfo.contact, callState = CallState.WaitCapabilities, localMedia = media, userProfile = profile)
+                chatModel.activeCall.value = Call(remoteHostId = chatRh, contact = cInfo.contact, callState = CallState.WaitCapabilities, localMedia = media)
                 chatModel.showCallView.value = true
                 chatModel.callCommand.add(WCallCommand.Capabilities(media))
               }
@@ -675,7 +673,7 @@ fun ChatInfoToolbar(
           }
         }
       }
-    } else if (activeCall?.contact?.id == chat.id && appPlatform.isDesktop) {
+    } else if (activeCall?.contact?.id == chat.id) {
       barButtons.add {
         val call = remember { chatModel.activeCall }.value
         val connectedAt = call?.connectedAt

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupChatInfoView.kt

@@ -424,47 +424,69 @@ private fun MemberVerifiedShield() {
 
 @Composable
 private fun DropDownMenuForMember(rhId: Long?, member: GroupMember, groupInfo: GroupInfo, showMenu: MutableState<Boolean>) {
-  if (groupInfo.membership.memberRole >= GroupMemberRole.Admin) {
-    val canBlockForAll = member.canBlockForAll(groupInfo)
-    val canRemove = member.canBeRemoved(groupInfo)
-    if (canBlockForAll || canRemove) {
-      DefaultDropdownMenu(showMenu) {
-        if (canBlockForAll) {
-          if (member.blockedByAdmin) {
-            ItemAction(stringResource(MR.strings.unblock_for_all), painterResource(MR.images.ic_do_not_touch), onClick = {
-              unblockForAllAlert(rhId, groupInfo, member)
-              showMenu.value = false
-            })
-          } else {
-            ItemAction(stringResource(MR.strings.block_for_all), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
-              blockForAllAlert(rhId, groupInfo, member)
-              showMenu.value = false
-            })
-          }
-        }
-        if (canRemove) {
-          ItemAction(stringResource(MR.strings.remove_member_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, onClick = {
-            removeMemberAlert(rhId, groupInfo, member)
-            showMenu.value = false
-          })
-        }
-      }
+  // revert from this:
+  DefaultDropdownMenu(showMenu) {
+    if (member.canBeRemoved(groupInfo)) {
+      ItemAction(stringResource(MR.strings.remove_member_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, onClick = {
+        removeMemberAlert(rhId, groupInfo, member)
+        showMenu.value = false
+      })
     }
-  } else if (!member.blockedByAdmin) {
-    DefaultDropdownMenu(showMenu) {
-      if (member.memberSettings.showMessages) {
-        ItemAction(stringResource(MR.strings.block_member_button), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
-          blockMemberAlert(rhId, groupInfo, member)
-          showMenu.value = false
-        })
-      } else {
-        ItemAction(stringResource(MR.strings.unblock_member_button), painterResource(MR.images.ic_do_not_touch), onClick = {
-          unblockMemberAlert(rhId, groupInfo, member)
-          showMenu.value = false
-        })
-      }
+    if (member.memberSettings.showMessages) {
+      ItemAction(stringResource(MR.strings.block_member_button), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
+        blockMemberAlert(rhId, groupInfo, member)
+        showMenu.value = false
+      })
+    } else {
+      ItemAction(stringResource(MR.strings.unblock_member_button), painterResource(MR.images.ic_do_not_touch), onClick = {
+        unblockMemberAlert(rhId, groupInfo, member)
+        showMenu.value = false
+      })
     }
   }
+  // revert to this: vvv
+//    if (groupInfo.membership.memberRole >= GroupMemberRole.Admin) {
+//      val canBlockForAll = member.canBlockForAll(groupInfo)
+//      val canRemove = member.canBeRemoved(groupInfo)
+//      if (canBlockForAll || canRemove) {
+//        DefaultDropdownMenu(showMenu) {
+//          if (canBlockForAll) {
+//            if (member.blockedByAdmin) {
+//              ItemAction(stringResource(MR.strings.unblock_for_all), painterResource(MR.images.ic_do_not_touch), onClick = {
+//                unblockForAllAlert(rhId, groupInfo, member)
+//                showMenu.value = false
+//              })
+//            } else {
+//              ItemAction(stringResource(MR.strings.block_for_all), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
+//                blockForAllAlert(rhId, groupInfo, member)
+//                showMenu.value = false
+//              })
+//            }
+//          }
+//          if (canRemove) {
+//            ItemAction(stringResource(MR.strings.remove_member_button), painterResource(MR.images.ic_delete), color = MaterialTheme.colors.error, onClick = {
+//              removeMemberAlert(rhId, groupInfo, member)
+//              showMenu.value = false
+//            })
+//          }
+//        }
+//      }
+//    } else if (!member.blockedByAdmin) {
+//      DefaultDropdownMenu(showMenu) {
+//        if (member.memberSettings.showMessages) {
+//          ItemAction(stringResource(MR.strings.block_member_button), painterResource(MR.images.ic_back_hand), color = MaterialTheme.colors.error, onClick = {
+//            blockMemberAlert(rhId, groupInfo, member)
+//            showMenu.value = false
+//          })
+//        } else {
+//          ItemAction(stringResource(MR.strings.unblock_member_button), painterResource(MR.images.ic_do_not_touch), onClick = {
+//            unblockMemberAlert(rhId, groupInfo, member)
+//            showMenu.value = false
+//          })
+//        }
+//      }
+//    }
+  // ^^^
 }
 
 @Composable

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chat/group/GroupMemberInfoView.kt

@@ -387,11 +387,25 @@ fun GroupMemberInfoLayout(
       }
     }
 
-    if (groupInfo.membership.memberRole >= GroupMemberRole.Admin) {
-      AdminDestructiveSection()
-    } else {
-      NonAdminBlockSection()
+    // revert from this:
+    SectionDividerSpaced(maxBottomPadding = false)
+    SectionView {
+      if (member.memberSettings.showMessages) {
+        BlockMemberButton(blockMember)
+      } else {
+        UnblockMemberButton(unblockMember)
+      }
+      if (member.canBeRemoved(groupInfo)) {
+        RemoveMemberButton(removeMember)
+      }
     }
+    // revert to this: vvv
+//    if (groupInfo.membership.memberRole >= GroupMemberRole.Admin) {
+//      AdminDestructiveSection()
+//    } else {
+//      NonAdminBlockSection()
+//    }
+    // ^^^
 
     if (developerTools) {
       SectionDividerSpaced()

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ChatListView.kt

@@ -29,7 +29,6 @@ import chat.simplex.common.views.onboarding.WhatsNewView
 import chat.simplex.common.views.onboarding.shouldShowWhatsNew
 import chat.simplex.common.views.usersettings.SettingsView
 import chat.simplex.common.platform.*
-import chat.simplex.common.views.call.Call
 import chat.simplex.common.views.newchat.*
 import chat.simplex.res.MR
 import kotlinx.coroutines.*
@@ -122,12 +121,7 @@ fun ChatListView(chatModel: ChatModel, settingsState: SettingsViewState, setPerf
     }
   }
   if (searchText.value.text.isEmpty()) {
-    if (appPlatform.isDesktop) {
-      val call = remember { chatModel.activeCall }.value
-      if (call != null) {
-        ActiveCallInteractiveArea(call, newChatSheetState)
-      }
-    }
+    DesktopActiveCallOverlayLayout(newChatSheetState)
     // TODO disable this button and sheet for the duration of the switch
     tryOrShowError("NewChatSheet", error = {}) {
       NewChatSheet(chatModel, newChatSheetState, stopped, hideNewChatSheet)
@@ -320,7 +314,7 @@ private fun ToggleFilterDisabledButton() {
 }
 
 @Composable
-expect fun ActiveCallInteractiveArea(call: Call, newChatSheetState: MutableStateFlow<AnimatedViewState>)
+expect fun DesktopActiveCallOverlayLayout(newChatSheetState: MutableStateFlow<AnimatedViewState>)
 
 fun connectIfOpenedViaUri(rhId: Long?, uri: URI, chatModel: ChatModel) {
   Log.d(TAG, "connectIfOpenedViaUri: opened via link")

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/chatlist/ShareListView.kt

@@ -85,7 +85,7 @@ private fun ShareListToolbar(chatModel: ChatModel, userPickerState: MutableState
           userPickerState.value = AnimatedViewState.VISIBLE
         }
       }
-      else -> NavigationButtonBack(onButtonClicked = { chatModel.sharedContent.value = null })
+      else -> NavigationButtonBack { chatModel.sharedContent.value = null }
     }
   }
   if (chatModel.chats.size >= 8) {
@@ -143,7 +143,7 @@ private fun ShareList(chatModel: ChatModel, search: String) {
   }
   val chats by remember(search) {
     derivedStateOf {
-      if (search.isEmpty()) chatModel.chats.toList().filter { it.chatInfo.ready } else chatModel.chats.toList().filter { it.chatInfo.ready }.filter(filter)
+      if (search.isEmpty()) chatModel.chats.filter { it.chatInfo.ready } else chatModel.chats.filter { it.chatInfo.ready }.filter(filter)
     }
   }
   LazyColumn(

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/CloseSheetBar.kt

@@ -18,7 +18,7 @@ import chat.simplex.res.MR
 import dev.icerock.moko.resources.compose.painterResource
 
 @Composable
-fun CloseSheetBar(close: (() -> Unit)?, showClose: Boolean = true, tintColor: Color = if (close != null) MaterialTheme.colors.primary else MaterialTheme.colors.secondary, endButtons: @Composable RowScope.() -> Unit = {}) {
+fun CloseSheetBar(close: (() -> Unit)?, showClose: Boolean = true, endButtons: @Composable RowScope.() -> Unit = {}) {
   Column(
     Modifier
       .fillMaxWidth()
@@ -35,7 +35,7 @@ fun CloseSheetBar(close: (() -> Unit)?, showClose: Boolean = true, tintColor: Co
           verticalAlignment = Alignment.CenterVertically
         ) {
           if (showClose)  {
-            NavigationButtonBack(tintColor = tintColor, onButtonClicked = close)
+            NavigationButtonBack(onButtonClicked = close)
           } else {
             Spacer(Modifier)
           }

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/DefaultTopAppBar.kt

@@ -44,10 +44,10 @@ fun DefaultTopAppBar(
 }
 
 @Composable
-fun NavigationButtonBack(onButtonClicked: (() -> Unit)?, tintColor: Color = if (onButtonClicked != null) MaterialTheme.colors.primary else MaterialTheme.colors.secondary) {
+fun NavigationButtonBack(onButtonClicked: (() -> Unit)?) {
   IconButton(onButtonClicked ?: {}, enabled = onButtonClicked != null) {
     Icon(
-      painterResource(MR.images.ic_arrow_back_ios_new), stringResource(MR.strings.back), tint = tintColor
+      painterResource(MR.images.ic_arrow_back_ios_new), stringResource(MR.strings.back), tint = if (onButtonClicked != null) MaterialTheme.colors.primary else MaterialTheme.colors.secondary
     )
   }
 }

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/ModalView.kt

@@ -29,7 +29,7 @@ fun ModalView(
   }
   Surface(Modifier.fillMaxSize(), contentColor = LocalContentColor.current) {
     Column(if (background != MaterialTheme.colors.background) Modifier.background(background) else Modifier.themedBackground()) {
-      CloseSheetBar(close, showClose, endButtons = endButtons)
+      CloseSheetBar(close, showClose, endButtons)
       Box(modifier) { content() }
     }
   }

apps/multiplatform/common/src/commonMain/kotlin/chat/simplex/common/views/helpers/Utils.kt

@@ -411,7 +411,7 @@ expect fun ByteArray.toBase64StringForPassphrase(): String
 
 // Android's default implementation that was used before multiplatform, adds non-needed characters at the end of string
 // which can be bypassed by:
-// fun String.toByteArrayFromBase64(): ByteArray = Base64.getMimeDecoder().decode(this.trimEnd { it == '\n' || it == ' ' })
+// fun String.toByteArrayFromBase64(): ByteArray = Base64.getDecoder().decode(this.trimEnd { it == '\n' || it == ' ' })
 expect fun String.toByteArrayFromBase64ForPassphrase(): ByteArray
 
 val LongRange.Companion.saver

apps/multiplatform/common/src/commonMain/resources/MR/base/strings.xml

@@ -177,9 +177,6 @@
   <!-- SimpleX Chat foreground Service -->
   <string name="simplex_service_notification_title">SimpleX Chat service</string>
   <string name="simplex_service_notification_text">Receiving messages…</string>
-  <string name="call_service_notification_audio_call">Audio call</string>
-  <string name="call_service_notification_video_call">Video call</string>
-  <string name="call_service_notification_end_call">End call</string>
   <string name="hide_notification">Hide</string>
 
   <!-- Notification channels -->
@@ -804,10 +801,6 @@
   <string name="callstate_connected">connected</string>
   <string name="callstate_ended">ended</string>
 
-  <!-- CallView -->
-  <string name="unable_to_open_browser_title">Error opening browser</string>
-  <string name="unable_to_open_browser_desc">The default web browser is required for calls. Please configure the default browser in the system, and share more information with the developers.</string>
-
   <!-- SimpleXInfo -->
   <string name="next_generation_of_private_messaging">The next generation of private messaging</string>
   <string name="privacy_redefined">Privacy redefined</string>

apps/multiplatform/common/src/commonMain/resources/assets/www/android/call.html

@@ -8,7 +8,6 @@
   <body>
     <video
       id="remote-video-stream"
-      class="inline"
       autoplay
       playsinline
       poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
@@ -16,7 +15,6 @@
     ></video>
     <video
       id="local-video-stream"
-      class="inline"
       muted
       autoplay
       playsinline

apps/multiplatform/common/src/commonMain/resources/assets/www/android/style.css

@@ -5,14 +5,14 @@ body {
   background-color: black;
 }
 
-#remote-video-stream.inline {
+#remote-video-stream {
   position: absolute;
   width: 100%;
   height: 100%;
   object-fit: cover;
 }
 
-#local-video-stream.inline {
+#local-video-stream {
   position: absolute;
   width: 30%;
   max-width: 30%;
@@ -23,20 +23,6 @@ body {
   right: 0;
 }
 
-#remote-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
-#local-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
 *::-webkit-media-controls {
   display: none !important;
   -webkit-appearance: none !important;

apps/multiplatform/common/src/commonMain/resources/assets/www/call.js

@@ -11,12 +11,6 @@ var VideoCamera;
     VideoCamera["User"] = "user";
     VideoCamera["Environment"] = "environment";
 })(VideoCamera || (VideoCamera = {}));
-var LayoutType;
-(function (LayoutType) {
-    LayoutType["Default"] = "default";
-    LayoutType["LocalVideo"] = "localVideo";
-    LayoutType["RemoteVideo"] = "remoteVideo";
-})(LayoutType || (LayoutType = {}));
 // for debugging
 // var sendMessageToNative = ({resp}: WVApiMessage) => console.log(JSON.stringify({command: resp}))
 var sendMessageToNative = (msg) => console.log(JSON.stringify(msg));
@@ -325,10 +319,6 @@ const processCommand = (function () {
                     localizedDescription = command.description;
                     resp = { type: "ok" };
                     break;
-                case "layout":
-                    changeLayout(command.layout);
-                    resp = { type: "ok" };
-                    break;
                 case "end":
                     endCall();
                     resp = { type: "ok" };
@@ -617,28 +607,6 @@ function toggleMedia(s, media) {
     }
     return res;
 }
-function changeLayout(layout) {
-    const local = document.getElementById("local-video-stream");
-    const remote = document.getElementById("remote-video-stream");
-    switch (layout) {
-        case LayoutType.Default:
-            local.className = "inline";
-            remote.className = "inline";
-            local.style.visibility = "visible";
-            remote.style.visibility = "visible";
-            break;
-        case LayoutType.LocalVideo:
-            local.className = "fullscreen";
-            local.style.visibility = "visible";
-            remote.style.visibility = "hidden";
-            break;
-        case LayoutType.RemoteVideo:
-            remote.className = "fullscreen";
-            local.style.visibility = "hidden";
-            remote.style.visibility = "visible";
-            break;
-    }
-}
 // Cryptography function - it is loaded both in the main window and in worker context (if the worker is used)
 function callCryptoFunction() {
     const initialPlainTextRequired = {

apps/multiplatform/common/src/commonMain/resources/assets/www/desktop/call.html

@@ -9,7 +9,6 @@
   <body>
     <video
       id="remote-video-stream"
-      class="inline"
       autoplay
       playsinline
       poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
@@ -17,7 +16,6 @@
     ></video>
     <video
       id="local-video-stream"
-      class="inline"
       muted
       autoplay
       playsinline

apps/multiplatform/common/src/commonMain/resources/assets/www/desktop/style.css

@@ -5,14 +5,14 @@ body {
   background-color: black;
 }
 
-#remote-video-stream.inline {
+#remote-video-stream {
   position: absolute;
   width: 100%;
   height: 100%;
   object-fit: cover;
 }
 
-#local-video-stream.inline {
+#local-video-stream {
   position: absolute;
   width: 20%;
   max-width: 20%;
@@ -23,20 +23,6 @@ body {
   right: 0;
 }
 
-#remote-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
-#local-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
 *::-webkit-media-controls {
   display: none !important;
   -webkit-appearance: none !important;

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/platform/Images.desktop.kt

@@ -17,14 +17,14 @@ import javax.imageio.stream.MemoryCacheImageOutputStream
 import kotlin.math.sqrt
 
 private fun errorBitmap(): ImageBitmap =
-  ImageIO.read(ByteArrayInputStream(Base64.getMimeDecoder().decode("iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAKVJREFUeF7t1kENACEUQ0FQhnVQ9lfGO+xggITQdvbMzArPey+8fa3tAfwAEdABZQspQStgBssEcgAIkSAJkiAJljtEgiRIgmUCSZAESZAESZAEyx0iQRIkwTKBJEiCv5fgvTd1wDmn7QAP4AeIgA4oW0gJWgEzWCZwbQ7gAA7ggLKFOIADOKBMIAeAEAmSIAmSYLlDJEiCJFgmkARJkARJ8N8S/ADTZUewBvnTOQAAAABJRU5ErkJggg=="))).toComposeImageBitmap()
+  ImageIO.read(ByteArrayInputStream(Base64.getDecoder().decode("iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAKVJREFUeF7t1kENACEUQ0FQhnVQ9lfGO+xggITQdvbMzArPey+8fa3tAfwAEdABZQspQStgBssEcgAIkSAJkiAJljtEgiRIgmUCSZAESZAESZAEyx0iQRIkwTKBJEiCv5fgvTd1wDmn7QAP4AeIgA4oW0gJWgEzWCZwbQ7gAA7ggLKFOIADOKBMIAeAEAmSIAmSYLlDJEiCJFgmkARJkARJ8N8S/ADTZUewBvnTOQAAAABJRU5ErkJggg=="))).toComposeImageBitmap()
 
 actual fun base64ToBitmap(base64ImageString: String): ImageBitmap {
   val imageString = base64ImageString
     .removePrefix("data:image/png;base64,")
     .removePrefix("data:image/jpg;base64,")
   return try {
-    ImageIO.read(ByteArrayInputStream(Base64.getMimeDecoder().decode(imageString))).toComposeImageBitmap()
+    ImageIO.read(ByteArrayInputStream(Base64.getDecoder().decode(imageString))).toComposeImageBitmap()
   } catch (e: IOException) {
     Log.e(TAG, "base64ToBitmap error: $e")
     errorBitmap()
@@ -77,7 +77,7 @@ actual fun compressImageStr(bitmap: ImageBitmap): String {
   return try {
     val encoded  = Base64.getEncoder().encodeToString(compressImageData(bitmap, usePng).toByteArray())
     "data:image/$ext;base64,$encoded"
-  } catch (e: Exception) {
+  } catch (e: IOException) {
     Log.e(TAG, "resizeImageToStrSize error: $e")
     throw e
   }

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/call/CallView.desktop.kt

@@ -146,21 +146,8 @@ private fun SendStateUpdates() {
 @Composable
 fun WebRTCController(callCommand: SnapshotStateList<WCallCommand>, onResponse: (WVAPIMessage) -> Unit) {
   val uriHandler = LocalUriHandler.current
-  val endCall = {
-    val call = chatModel.activeCall.value
-    if (call != null) withBGApi { chatModel.callManager.endCall(call) }
-  }
   val server = remember {
-    try {
-      uriHandler.openUri("http://${SERVER_HOST}:$SERVER_PORT/simplex/call/")
-    } catch (e: Exception) {
-      Log.e(TAG, "Unable to open browser: ${e.stackTraceToString()}")
-      AlertManager.shared.showAlertMsg(
-        title = generalGetString(MR.strings.unable_to_open_browser_title),
-        text = generalGetString(MR.strings.unable_to_open_browser_desc)
-      )
-      endCall()
-    }
+    uriHandler.openUri("http://${SERVER_HOST}:$SERVER_PORT/simplex/call/")
     startServer(onResponse)
   }
   fun processCommand(cmd: WCallCommand) {

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chatlist/ChatListView.desktop.kt

@@ -3,6 +3,7 @@ package chat.simplex.common.views.chatlist
 import androidx.compose.foundation.*
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.Icon
 import androidx.compose.material.MaterialTheme
 import androidx.compose.runtime.*
@@ -12,7 +13,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.theme.*
-import chat.simplex.common.views.call.Call
 import chat.simplex.common.views.call.CallMediaType
 import chat.simplex.common.views.chat.item.ItemAction
 import chat.simplex.common.views.helpers.*
@@ -22,9 +22,10 @@ import dev.icerock.moko.resources.compose.stringResource
 import kotlinx.coroutines.flow.MutableStateFlow
 
 @Composable
-actual fun ActiveCallInteractiveArea(call: Call, newChatSheetState: MutableStateFlow<AnimatedViewState>) {
-  //  if (call.callState == CallState.Connected && !newChatSheetState.collectAsState().value.isVisible()) {
-  if (!newChatSheetState.collectAsState().value.isVisible()) {
+actual fun DesktopActiveCallOverlayLayout(newChatSheetState: MutableStateFlow<AnimatedViewState>) {
+  val call = remember { chatModel.activeCall}.value
+  //  if (call?.callState == CallState.Connected && !newChatSheetState.collectAsState().value.isVisible()) {
+  if (call != null && !newChatSheetState.collectAsState().value.isVisible()) {
       val showMenu = remember { mutableStateOf(false) }
       val media = call.peerMedia ?: call.localMedia
       CompositionLocalProvider(

apps/multiplatform/gradle.properties

@@ -25,11 +25,11 @@ android.nonTransitiveRClass=true
 android.enableJetifier=true
 kotlin.mpp.androidSourceSetLayoutVersion=2
 
-android.version_name=5.5.4
-android.version_code=183
+android.version_name=5.5.6
+android.version_code=187
 
-desktop.version_name=5.5.4
-desktop.version_code=30
+desktop.version_name=5.5.6
+desktop.version_code=32
 
 kotlin.version=1.8.20
 gradle.plugin.version=7.4.2

blog/20210512-simplex-chat-terminal-ui.md

@@ -10,7 +10,7 @@ permalink: "/blog/20210512-simplex-chat-terminal-ui.html"
 
 **Published:** May 12, 2021
 
-For the last six months [me](https://github.com/epoberezkin) and my son [Efim](https://github.com/efim-poberezkin) have been working to bring you a working prototype of SimpleX Chat. We're excited to announce SimpleX Chat terminal client is now available [here](https://github.com/simplex-chat/simplex-chat) on Linux, Windows and Mac (you can either build from source or download the binary for Linux, Windows or Mac from the latest release).
+For the last six months [me](https://github.com/epoberezkin) and my son Efim have been working to bring you a working prototype of SimpleX Chat. We're excited to announce SimpleX Chat terminal client is now available [here](https://github.com/simplex-chat/simplex-chat) on Linux, Windows and Mac (you can either build from source or download the binary for Linux, Windows or Mac from the latest release).
 
 We’ve been using the terminal client between us and a few other people for a couple of months now, eating our own “dog food”, and have developed up to version 0.3.1, with most of the messaging protocol features we originally planned
 

blog/20220928-simplex-chat-v4-encrypted-database.md

@@ -78,7 +78,7 @@ You can run SimpleX Chat CLI as a local WebSockets server on any port, we use 52
 simplex-chat -p 5225
 ```
 
-Then you can create a JavaScript or TypeScript application that would connect to it and control it via a simple WebSocket API. TypeScript SDK defines all necessary types and convenience functions to use in your applications. See this [sample bot](https://github.com/simplex-chat/simplex-chat/blob/stable/packages/simplex-chat-client/typescript/examples/squaring-bot.js) and [README page](https://github.com/simplex-chat/simplex-chat/tree/ep/blog-v4/packages/simplex-chat-client/typescript).
+Then you can create a JavaScript or TypeScript application that would connect to it and control it via a simple WebSocket API. TypeScript SDK defines all necessary types and convenience functions to use in your applications. See this [sample bot](https://github.com/simplex-chat/simplex-chat/blob/stable/packages/simplex-chat-client/typescript/examples/squaring-bot.js) and README page.
 
 SimpleX Chat API allows you to:
 

blog/20221206-simplex-chat-v4.3-voice-messages.md

@@ -18,7 +18,7 @@ Since we published [the security assessment of SimpleX Chat](https://simplex.cha
 
 - Privacy Guides added SimpleX Chat to [the recommended private and secure messengers](https://www.privacyguides.org/real-time-communication/#simplex-chat).
 - Mike Kuketz – a well-known security expert – published [the review of SimpleX Chat](https://www.kuketz-blog.de/simplex-eindruecke-vom-messenger-ohne-identifier/) and added it to [the messenger matrix](https://www.messenger-matrix.de).
-- Supernova published [the review](https://supernova.tilde.team/detailed_reviews.html#simplex) and increased [SimpleX Chat recommendation ratings](https://supernova.tilde.team/messengers.html).
+- Supernova published [the review](https://supernovas.space/detailed_reviews.html#simplex) and increased [SimpleX Chat recommendation ratings](https://supernovas.space/messengers.html).
 
 ## What's new in v4.3
 

blog/README.md

@@ -146,7 +146,7 @@ November reviews:
 - [Privacy Guides](https://www.privacyguides.org/real-time-communication/#simplex-chat) recommendations.
 - [Review by Mike Kuketz](https://www.kuketz-blog.de/simplex-eindruecke-vom-messenger-ohne-identifier/).
 - [The messenger matrix](https://www.messenger-matrix.de).
-- [Supernova review](https://supernova.tilde.team/detailed_reviews.html#simplex) and [messenger ratings](https://supernova.tilde.team/messengers.html).
+- [Supernova review](https://supernovas.space/detailed_reviews.html#simplex) and [messenger ratings](https://supernovas.space/messengers.html).
 
 ---
 

blog/lang/fr-fr/README_fr.md

@@ -26,7 +26,7 @@ Critiques de novembre :
 - Recommandations de [Privacy Guides](https://www.privacyguides.org/real-time-communication/#simplex-chat).
 - [Revue par Mike Kuketz](https://www.kuketz-blog.de/simplex-eindruecke-vom-messenger-ohne-identifier/).
 - [La matrice des messageries](https://www.messenger-matrix.de).
-- [Revue de Supernova](https://supernova.tilde.team/detailed_reviews.html#simplex) et [évaluations des messageries](https://supernova.tilde.team/messengers.html).
+- [Revue de Supernova](https://supernovas.space/detailed_reviews.html#simplex) et [évaluations des messageries](https://supernovas.space/messengers.html).
 
 Sortie de la v4.3 :
 

cabal.project

@@ -12,7 +12,7 @@ constraints: zip +disable-bzip2 +disable-zstd
 source-repository-package
     type: git
     location: https://github.com/simplex-chat/simplexmq.git
-    tag: caeeb2df9ccca29a6bb504886736502d081fba0e
+    tag: 09878959264014f676a47f986a00c0c9fe34bcf1
 
 source-repository-package
     type: git

docs/GLOSSARY.md

@@ -143,6 +143,12 @@ SimpleX Clients also form a network using SMP relays and IP or some other overla
 
 [Wikipedia](https://en.wikipedia.org/wiki/Overlay_network)
 
+# Non-repudiation
+
+The property of the cryptographic or communication system that allows the recipient of the message to prove to any third party that the sender identified by some cryptographic key sent the message. It is the opposite to [repudiation](#repudiation). While in some context non-repudiation may be desirable (e.g., for contractually binding messages), in the context of private communications it may be undesirable.
+
+[Wikipedia](https://en.wikipedia.org/wiki/Non-repudiation)
+
 ## Pairwise pseudonymous identifier
 
 Generalizing [the definition](https://csrc.nist.gov/glossary/term/pairwise_pseudonymous_identifier) from NIST Digital Identity Guidelines, it is an opaque unguessable identifier generated by a service used to access a resource by only one party.
@@ -185,6 +191,12 @@ Network topology of the communication system when peers communicate via proxies
 
 [Post-compromise security](#post-compromise-security).
 
+## Repudiation
+
+The property of the cryptographic or communication system that allows the sender of the message to plausibly deny having sent the message, because while the recipient can verify that the message was sent by the sender, they cannot prove it to any third party - the recipient has a technical ability to forge the same encrypted message. This is an important quality of private communications, as it allows to have the conversation that can later be denied, similarly to having a private face-to-face conversation.
+
+See also [non-repudiation](#non-repudiation).
+
 ## User identity
 
 In a communication system it refers to anything that uniquely identifies the users to the network. Depending on the communication network, it can be a phone number, email address, username, public key or a random opaque identifier. Most messaging networks rely on some form of user identity. SimpleX appears to be the only messaging network that does not rely on any kind of user identity - see [this comparison](https://en.wikipedia.org/wiki/Comparison_of_instant_messaging_protocols).

docs/JOIN_TEAM.md

@@ -70,7 +70,7 @@ Knowledge of Android and Kotlin Multiplatform would be a bonus - we use Kotlin J
 
 ## How to join the team
 
-1. [Install the app](../README.md#install-the-app), try using it with the friends and [join some user groups](https://github.com/simplex-chat/simplex-chat#join-user-groups) – you will discover a lot of things that need improvements.
+1. [Install the app](https://github.com/simplex-chat/simplex-chat#install-the-app), try using it with the friends and [join some user groups](https://github.com/simplex-chat/simplex-chat#join-user-groups) – you will discover a lot of things that need improvements.
 
 2. Also look through [GitHub issues](https://github.com/simplex-chat/simplex-chat/issues) submitted by the users to see what would you want to contribute as a test.
 

docs/rfcs/2023-11-21-inactive-group-members.md

@@ -108,33 +108,3 @@ Sending member builds messages history starting starting from requested/remember
 \***
 
 Same XGrpMsgHistory protocol event could be sent by host to new members, after sending introductions.
-
----
-
-Update 2024-02-12:
-
-### Group "pings"
-
-Alternatively to tracking unanswered messages counts per member, which is complex and in some cases as discussed above ineffective, group members could periodically send group wide pings indicating their active presence.
-
-```haskell
-XGrpPing :: ChatMsgEvent 'Json
-```
-
-Members track:
-
-- inactive flag (as above - set on QUOTA errors as well)
-- last_snd_ts on group
-- last_rcv_ts on group member
-
-Clients run a worker process for checking last_snd_ts in each of their groups, and send pings to groups on a periodic basis.
-
-- part of cleanup manager or separate process?
-- on each worker step, for each group matching criteria to send ping, send ping with a random delay to reduce correlation between groups (spawn a separate thread with a random delay for each group)
-- criteria for sending ping: last_snd_ts earlier than group_ping_interval ago
-- configure group_ping_interval to, for example, 23 hours (so that if user opens app each day at same time client will match criteria to send pings daily)
-
-Clients receiving pings:
-
-- update last_rcv_ts
-- when sending a message to group, check only for timestamp difference (no unanswered snd msg count logic as above)

flake.lock

@@ -16,6 +16,21 @@
         "type": "github"
       }
     },
+    "blank": {
+      "locked": {
+        "lastModified": 1625557891,
+        "narHash": "sha256-O8/MWsPBGhhyPoPLHZAuoZiiHo9q6FLlEeIDEXuj6T4=",
+        "owner": "divnix",
+        "repo": "blank",
+        "rev": "5a5d2684073d9f563072ed07c871d577a6c614a8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "divnix",
+        "repo": "blank",
+        "type": "github"
+      }
+    },
     "cabal-32": {
       "flake": false,
       "locked": {
@@ -83,6 +98,64 @@
         "type": "github"
       }
     },
+    "devshell": {
+      "inputs": {
+        "flake-utils": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "flake-utils"
+        ],
+        "nixpkgs": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1663445644,
+        "narHash": "sha256-+xVlcK60x7VY1vRJbNUEAHi17ZuoQxAIH4S4iUFUGBA=",
+        "owner": "numtide",
+        "repo": "devshell",
+        "rev": "e3dc3e21594fe07bdb24bdf1c8657acaa4cb8f66",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "devshell",
+        "type": "github"
+      }
+    },
+    "dmerge": {
+      "inputs": {
+        "nixlib": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ],
+        "yants": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "yants"
+        ]
+      },
+      "locked": {
+        "lastModified": 1659548052,
+        "narHash": "sha256-fzI2gp1skGA8mQo/FBFrUAtY0GQkAIAaV/V127TJPyY=",
+        "owner": "divnix",
+        "repo": "data-merge",
+        "rev": "d160d18ce7b1a45b88344aa3f13ed1163954b497",
+        "type": "github"
+      },
+      "original": {
+        "owner": "divnix",
+        "repo": "data-merge",
+        "type": "github"
+      }
+    },
     "flake-compat": {
       "flake": false,
       "locked": {
@@ -100,34 +173,74 @@
         "type": "github"
       }
     },
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
+    "flake-compat_2": {
+      "flake": false,
       "locked": {
-        "lastModified": 1698579227,
-        "narHash": "sha256-KVWjFZky+gRuWennKsbo6cWyo7c/z/VgCte5pR9pEKg=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "f76e870d64779109e41370848074ac4eaa1606ec",
+        "lastModified": 1650374568,
+        "narHash": "sha256-Z+s0J8/r907g149rllvwhb4pKi8Wam5ij0st8PwAh+E=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "b4a34015c698c7793d592d66adbab377907a2be8",
         "type": "github"
       },
       "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
+        "owner": "edolstra",
+        "repo": "flake-compat",
         "type": "github"
       }
     },
     "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
       "locked": {
-        "lastModified": 1701680307,
-        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
+        "lastModified": 1676283394,
+        "narHash": "sha256-XX2f9c3iySLCw54rJ/CZs+ZK6IQy7GXNY4nSOyu2QG4=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
+        "rev": "3db36a8b464d0c4532ba1c7dda728f4576d6d073",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "locked": {
+        "lastModified": 1667395993,
+        "narHash": "sha256-nuEHfE/LcWyuSWnS8t12N1wc105Qtau+/OdUAjtQ0rA=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "5aed5285a952e0b949eb3ba02c12fa4fcfef535f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_3": {
+      "locked": {
+        "lastModified": 1653893745,
+        "narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_4": {
+      "locked": {
+        "lastModified": 1659877975,
+        "narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
         "type": "github"
       },
       "original": {
@@ -153,51 +266,33 @@
         "type": "github"
       }
     },
-    "ghc98X": {
-      "flake": false,
+    "gomod2nix": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2",
+        "utils": "utils"
+      },
       "locked": {
-        "lastModified": 1696643148,
-        "narHash": "sha256-E02DfgISH7EvvNAu0BHiPvl1E5FGMDi0pWdNZtIBC9I=",
-        "ref": "ghc-9.8",
-        "rev": "443e870d977b1ab6fc05f47a9a17bc49296adbd6",
-        "revCount": 61642,
-        "submodules": true,
-        "type": "git",
-        "url": "https://gitlab.haskell.org/ghc/ghc"
+        "lastModified": 1655245309,
+        "narHash": "sha256-d/YPoQ/vFn1+GTmSdvbSBSTOai61FONxB4+Lt6w/IVI=",
+        "owner": "tweag",
+        "repo": "gomod2nix",
+        "rev": "40d32f82fc60d66402eb0972e6e368aeab3faf58",
+        "type": "github"
       },
       "original": {
-        "ref": "ghc-9.8",
-        "submodules": true,
-        "type": "git",
-        "url": "https://gitlab.haskell.org/ghc/ghc"
-      }
-    },
-    "ghc99": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1697054644,
-        "narHash": "sha256-kKarOuXUaAH3QWv7ASx+gGFMHaHKe0pK5Zu37ky2AL4=",
-        "ref": "refs/heads/master",
-        "rev": "f383a242c76f90bcca8a4d7ee001dcb49c172a9a",
-        "revCount": 62040,
-        "submodules": true,
-        "type": "git",
-        "url": "https://gitlab.haskell.org/ghc/ghc"
-      },
-      "original": {
-        "submodules": true,
-        "type": "git",
-        "url": "https://gitlab.haskell.org/ghc/ghc"
+        "owner": "tweag",
+        "repo": "gomod2nix",
+        "type": "github"
       }
     },
     "hackage": {
       "flake": false,
       "locked": {
-        "lastModified": 1702513363,
-        "narHash": "sha256-kloro9uEe8aYhPMoMjVNq2rfrXNgMOZhOPwVH5DH2K0=",
+        "lastModified": 1702340598,
+        "narHash": "sha256-CC0HI+6iKPtH+8r/ZfcpW5v/OYvL7zMwpr0xfkXV1zU=",
         "owner": "input-output-hk",
         "repo": "hackage.nix",
-        "rev": "a9d931d0398da67846fa257922a924829233cb91",
+        "rev": "24617c569995e38bf3b83b48eec6628a50fdb4fb",
         "type": "github"
       },
       "original": {
@@ -214,40 +309,33 @@
         "cabal-36": "cabal-36",
         "cardano-shell": "cardano-shell",
         "flake-compat": "flake-compat",
+        "flake-utils": "flake-utils_2",
         "ghc-8.6.5-iohk": "ghc-8.6.5-iohk",
-        "ghc98X": "ghc98X",
-        "ghc99": "ghc99",
         "hackage": [
           "hackage"
         ],
-        "hls-1.10": "hls-1.10",
-        "hls-2.0": "hls-2.0",
-        "hls-2.2": "hls-2.2",
-        "hls-2.3": "hls-2.3",
-        "hls-2.4": "hls-2.4",
         "hpc-coveralls": "hpc-coveralls",
         "hydra": "hydra",
         "iserv-proxy": "iserv-proxy",
         "nixpkgs": [
-          "haskellNix",
-          "nixpkgs-unstable"
+          "nixpkgs"
         ],
         "nixpkgs-2003": "nixpkgs-2003",
         "nixpkgs-2105": "nixpkgs-2105",
         "nixpkgs-2111": "nixpkgs-2111",
         "nixpkgs-2205": "nixpkgs-2205",
         "nixpkgs-2211": "nixpkgs-2211",
-        "nixpkgs-2305": "nixpkgs-2305",
         "nixpkgs-unstable": "nixpkgs-unstable",
         "old-ghc-nix": "old-ghc-nix",
-        "stackage": "stackage"
+        "stackage": "stackage",
+        "tullia": "tullia"
       },
       "locked": {
-        "lastModified": 1701163700,
-        "narHash": "sha256-sOrewUS3LnzV09nGr7+3R6Q6zsgU4smJc61QsHq+4DE=",
+        "lastModified": 1677975916,
+        "narHash": "sha256-dbe8lEEPyfzjdRwpePClv7J9p9lQg7BwbBqAMCw4RLw=",
         "owner": "input-output-hk",
         "repo": "haskell.nix",
-        "rev": "2808bfe3e62e9eb4ee8974cd623a00e1611f302b",
+        "rev": "ab5efd87ce3fd8ade38a01d97693d29a4f1ae7e4",
         "type": "github"
       },
       "original": {
@@ -257,91 +345,6 @@
         "type": "github"
       }
     },
-    "hls-1.10": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1680000865,
-        "narHash": "sha256-rc7iiUAcrHxwRM/s0ErEsSPxOR3u8t7DvFeWlMycWgo=",
-        "owner": "haskell",
-        "repo": "haskell-language-server",
-        "rev": "b08691db779f7a35ff322b71e72a12f6e3376fd9",
-        "type": "github"
-      },
-      "original": {
-        "owner": "haskell",
-        "ref": "1.10.0.0",
-        "repo": "haskell-language-server",
-        "type": "github"
-      }
-    },
-    "hls-2.0": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1687698105,
-        "narHash": "sha256-OHXlgRzs/kuJH8q7Sxh507H+0Rb8b7VOiPAjcY9sM1k=",
-        "owner": "haskell",
-        "repo": "haskell-language-server",
-        "rev": "783905f211ac63edf982dd1889c671653327e441",
-        "type": "github"
-      },
-      "original": {
-        "owner": "haskell",
-        "ref": "2.0.0.1",
-        "repo": "haskell-language-server",
-        "type": "github"
-      }
-    },
-    "hls-2.2": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1693064058,
-        "narHash": "sha256-8DGIyz5GjuCFmohY6Fa79hHA/p1iIqubfJUTGQElbNk=",
-        "owner": "haskell",
-        "repo": "haskell-language-server",
-        "rev": "b30f4b6cf5822f3112c35d14a0cba51f3fe23b85",
-        "type": "github"
-      },
-      "original": {
-        "owner": "haskell",
-        "ref": "2.2.0.0",
-        "repo": "haskell-language-server",
-        "type": "github"
-      }
-    },
-    "hls-2.3": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1695910642,
-        "narHash": "sha256-tR58doOs3DncFehHwCLczJgntyG/zlsSd7DgDgMPOkI=",
-        "owner": "haskell",
-        "repo": "haskell-language-server",
-        "rev": "458ccdb55c9ea22cd5d13ec3051aaefb295321be",
-        "type": "github"
-      },
-      "original": {
-        "owner": "haskell",
-        "ref": "2.3.0.0",
-        "repo": "haskell-language-server",
-        "type": "github"
-      }
-    },
-    "hls-2.4": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1696939266,
-        "narHash": "sha256-VOMf5+kyOeOmfXTHlv4LNFJuDGa7G3pDnOxtzYR40IU=",
-        "owner": "haskell",
-        "repo": "haskell-language-server",
-        "rev": "362fdd1293efb4b82410b676ab1273479f6d17ee",
-        "type": "github"
-      },
-      "original": {
-        "owner": "haskell",
-        "ref": "2.4.0.0",
-        "repo": "haskell-language-server",
-        "type": "github"
-      }
-    },
     "hpc-coveralls": {
       "flake": false,
       "locked": {
@@ -381,14 +384,37 @@
         "type": "indirect"
       }
     },
+    "incl": {
+      "inputs": {
+        "nixlib": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1669263024,
+        "narHash": "sha256-E/+23NKtxAqYG/0ydYgxlgarKnxmDbg6rCMWnOBqn9Q=",
+        "owner": "divnix",
+        "repo": "incl",
+        "rev": "ce7bebaee048e4cd7ebdb4cee7885e00c4e2abca",
+        "type": "github"
+      },
+      "original": {
+        "owner": "divnix",
+        "repo": "incl",
+        "type": "github"
+      }
+    },
     "iserv-proxy": {
       "flake": false,
       "locked": {
-        "lastModified": 1691634696,
-        "narHash": "sha256-MZH2NznKC/gbgBu8NgIibtSUZeJ00HTLJ0PlWKCBHb0=",
+        "lastModified": 1670983692,
+        "narHash": "sha256-avLo34JnI9HNyOuauK5R69usJm+GfW3MlyGlYxZhTgY=",
         "ref": "hkm/remote-iserv",
-        "rev": "43a979272d9addc29fbffc2e8542c5d96e993d73",
-        "revCount": 14,
+        "rev": "50d0abb3317ac439a4e7495b185a64af9b7b9300",
+        "revCount": 10,
         "type": "git",
         "url": "https://gitlab.haskell.org/hamishmack/iserv-proxy.git"
       },
@@ -414,22 +440,32 @@
         "type": "github"
       }
     },
-    "mac2ios": {
+    "n2c": {
       "inputs": {
-        "flake-parts": "flake-parts",
-        "nixpkgs": "nixpkgs_2"
+        "flake-utils": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "flake-utils"
+        ],
+        "nixpkgs": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ]
       },
       "locked": {
-        "lastModified": 1699767871,
-        "narHash": "sha256-kxeCUfwC/Vgh2FvVMlBUq0eVx1JvfHyN+5MPKUik9mE=",
-        "owner": "zw3rk",
-        "repo": "mobile-core-tools",
-        "rev": "4dcb77d5ea896d749381806dfab5358851b08951",
+        "lastModified": 1665039323,
+        "narHash": "sha256-SAh3ZjFGsaCI8FRzXQyp56qcGdAqgKEfJWPCQ0Sr7tQ=",
+        "owner": "nlewo",
+        "repo": "nix2container",
+        "rev": "b008fe329ffb59b67bf9e7b08ede6ee792f2741a",
         "type": "github"
       },
       "original": {
-        "owner": "zw3rk",
-        "repo": "mobile-core-tools",
+        "owner": "nlewo",
+        "repo": "nix2container",
         "type": "github"
       }
     },
@@ -454,6 +490,95 @@
         "type": "github"
       }
     },
+    "nix-nomad": {
+      "inputs": {
+        "flake-compat": "flake-compat_2",
+        "flake-utils": [
+          "haskellNix",
+          "tullia",
+          "nix2container",
+          "flake-utils"
+        ],
+        "gomod2nix": "gomod2nix",
+        "nixpkgs": [
+          "haskellNix",
+          "tullia",
+          "nixpkgs"
+        ],
+        "nixpkgs-lib": [
+          "haskellNix",
+          "tullia",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1658277770,
+        "narHash": "sha256-T/PgG3wUn8Z2rnzfxf2VqlR1CBjInPE0l1yVzXxPnt0=",
+        "owner": "tristanpemble",
+        "repo": "nix-nomad",
+        "rev": "054adcbdd0a836ae1c20951b67ed549131fd2d70",
+        "type": "github"
+      },
+      "original": {
+        "owner": "tristanpemble",
+        "repo": "nix-nomad",
+        "type": "github"
+      }
+    },
+    "nix2container": {
+      "inputs": {
+        "flake-utils": "flake-utils_3",
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1658567952,
+        "narHash": "sha256-XZ4ETYAMU7XcpEeAFP3NOl9yDXNuZAen/aIJ84G+VgA=",
+        "owner": "nlewo",
+        "repo": "nix2container",
+        "rev": "60bb43d405991c1378baf15a40b5811a53e32ffa",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nlewo",
+        "repo": "nix2container",
+        "type": "github"
+      }
+    },
+    "nixago": {
+      "inputs": {
+        "flake-utils": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "flake-utils"
+        ],
+        "nixago-exts": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "blank"
+        ],
+        "nixpkgs": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1661824785,
+        "narHash": "sha256-/PnwdWoO/JugJZHtDUioQp3uRiWeXHUdgvoyNbXesz8=",
+        "owner": "nix-community",
+        "repo": "nixago",
+        "rev": "8c1f9e5f1578d4b2ea989f618588d62a335083c3",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixago",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
         "lastModified": 1657693803,
@@ -520,11 +645,11 @@
     },
     "nixpkgs-2205": {
       "locked": {
-        "lastModified": 1685573264,
-        "narHash": "sha256-Zffu01pONhs/pqH07cjlF10NnMDLok8ix5Uk4rhOnZQ=",
+        "lastModified": 1672580127,
+        "narHash": "sha256-3lW3xZslREhJogoOkjeZtlBtvFMyxHku7I/9IVehhT8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "380be19fbd2d9079f677978361792cb25e8a3635",
+        "rev": "0874168639713f547c05947c76124f78441ea46c",
         "type": "github"
       },
       "original": {
@@ -536,11 +661,11 @@
     },
     "nixpkgs-2211": {
       "locked": {
-        "lastModified": 1688392541,
-        "narHash": "sha256-lHrKvEkCPTUO+7tPfjIcb7Trk6k31rz18vkyqmkeJfY=",
+        "lastModified": 1675730325,
+        "narHash": "sha256-uNvD7fzO5hNlltNQUAFBPlcEjNG5Gkbhl/ROiX+GZU4=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "ea4c80b39be4c09702b0cb3b42eab59e2ba4f24b",
+        "rev": "b7ce17b1ebf600a72178f6302c77b6382d09323f",
         "type": "github"
       },
       "original": {
@@ -550,40 +675,6 @@
         "type": "github"
       }
     },
-    "nixpkgs-2305": {
-      "locked": {
-        "lastModified": 1695416179,
-        "narHash": "sha256-610o1+pwbSu+QuF3GE0NU5xQdTHM3t9wyYhB9l94Cd8=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "715d72e967ec1dd5ecc71290ee072bcaf5181ed6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-23.05-darwin",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "dir": "lib",
-        "lastModified": 1696019113,
-        "narHash": "sha256-X3+DKYWJm93DRSdC5M6K5hLqzSya9BjibtBsuARoPco=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "f5892ddac112a1e9b3612c39af1b72987ee5783a",
-        "type": "github"
-      },
-      "original": {
-        "dir": "lib",
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "nixpkgs-regression": {
       "locked": {
         "lastModified": 1643052045,
@@ -602,11 +693,11 @@
     },
     "nixpkgs-unstable": {
       "locked": {
-        "lastModified": 1695318763,
-        "narHash": "sha256-FHVPDRP2AfvsxAdc+AsgFJevMz5VBmnZglFUMlxBkcY=",
+        "lastModified": 1675758091,
+        "narHash": "sha256-7gFSQbSVAFUHtGCNHPF7mPc5CcqDk9M2+inlVPZSneg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "e12483116b3b51a185a33a272bf351e357ba9a99",
+        "rev": "747927516efcb5e31ba03b7ff32f61f6d47e7d87",
         "type": "github"
       },
       "original": {
@@ -618,20 +709,82 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1698434055,
-        "narHash": "sha256-Phxi5mUKSoL7A0IYUiYtkI9e8NcGaaV5PJEaJApU1Ko=",
+        "lastModified": 1653581809,
+        "narHash": "sha256-Uvka0V5MTGbeOfWte25+tfRL3moECDh1VwokWSZUdoY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1a3c95e3b23b3cdb26750621c08cc2f1560cb883",
+        "rev": "83658b28fe638a170a19b8933aa008b30640fbd1",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixos-23.05",
+        "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }
     },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1654807842,
+        "narHash": "sha256-ADymZpr6LuTEBXcy6RtFHcUZdjKTBRTMYwu19WOx17E=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "fc909087cc3386955f21b4665731dbdaceefb1d8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1665087388,
+        "narHash": "sha256-FZFPuW9NWHJteATOf79rZfwfRn5fE0wi9kRzvGfDHPA=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "95fda953f6db2e9496d2682c4fc7b82f959878f7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_5": {
+      "locked": {
+        "lastModified": 1676726892,
+        "narHash": "sha256-M7OYVR6dKmzmlebIjybFf3l18S2uur8lMyWWnHQooLY=",
+        "owner": "angerman",
+        "repo": "nixpkgs",
+        "rev": "729469087592bdea58b360de59dadf6d58714c42",
+        "type": "github"
+      },
+      "original": {
+        "owner": "angerman",
+        "ref": "release-22.11",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nosys": {
+      "locked": {
+        "lastModified": 1667881534,
+        "narHash": "sha256-FhwJ15uPLRsvaxtt/bNuqE/ykMpNAPF0upozFKhTtXM=",
+        "owner": "divnix",
+        "repo": "nosys",
+        "rev": "2d0d5207f6a230e9d0f660903f8db9807b54814f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "divnix",
+        "repo": "nosys",
+        "type": "github"
+      }
+    },
     "old-ghc-nix": {
       "flake": false,
       "locked": {
@@ -654,21 +807,17 @@
         "flake-utils": "flake-utils",
         "hackage": "hackage",
         "haskellNix": "haskellNix",
-        "mac2ios": "mac2ios",
-        "nixpkgs": [
-          "haskellNix",
-          "nixpkgs-2305"
-        ]
+        "nixpkgs": "nixpkgs_5"
       }
     },
     "stackage": {
       "flake": false,
       "locked": {
-        "lastModified": 1699834215,
-        "narHash": "sha256-g/JKy0BCvJaxPuYDl3QVc4OY8cFEomgG+hW/eEV470M=",
+        "lastModified": 1677888571,
+        "narHash": "sha256-YkhRNOaN6QVagZo1cfykYV8KqkI8/q6r2F5+jypOma4=",
         "owner": "input-output-hk",
         "repo": "stackage.nix",
-        "rev": "47aacd04abcce6bad57f43cbbbd133538380248e",
+        "rev": "cb50e6fabdfb2d7e655059039012ad0623f06a27",
         "type": "github"
       },
       "original": {
@@ -677,18 +826,110 @@
         "type": "github"
       }
     },
-    "systems": {
+    "std": {
+      "inputs": {
+        "arion": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "blank"
+        ],
+        "blank": "blank",
+        "devshell": "devshell",
+        "dmerge": "dmerge",
+        "flake-utils": "flake-utils_4",
+        "incl": "incl",
+        "makes": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "blank"
+        ],
+        "microvm": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "blank"
+        ],
+        "n2c": "n2c",
+        "nixago": "nixago",
+        "nixpkgs": "nixpkgs_4",
+        "nosys": "nosys",
+        "yants": "yants"
+      },
       "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "lastModified": 1674526466,
+        "narHash": "sha256-tMTaS0bqLx6VJ+K+ZT6xqsXNpzvSXJTmogkraBGzymg=",
+        "owner": "divnix",
+        "repo": "std",
+        "rev": "516387e3d8d059b50e742a2ff1909ed3c8f82826",
         "type": "github"
       },
       "original": {
-        "owner": "nix-systems",
-        "repo": "default",
+        "owner": "divnix",
+        "repo": "std",
+        "type": "github"
+      }
+    },
+    "tullia": {
+      "inputs": {
+        "nix-nomad": "nix-nomad",
+        "nix2container": "nix2container",
+        "nixpkgs": [
+          "haskellNix",
+          "nixpkgs"
+        ],
+        "std": "std"
+      },
+      "locked": {
+        "lastModified": 1675695930,
+        "narHash": "sha256-B7rEZ/DBUMlK1AcJ9ajnAPPxqXY6zW2SBX+51bZV0Ac=",
+        "owner": "input-output-hk",
+        "repo": "tullia",
+        "rev": "621365f2c725608f381b3ad5b57afef389fd4c31",
+        "type": "github"
+      },
+      "original": {
+        "owner": "input-output-hk",
+        "repo": "tullia",
+        "type": "github"
+      }
+    },
+    "utils": {
+      "locked": {
+        "lastModified": 1653893745,
+        "narHash": "sha256-0jntwV3Z8//YwuOjzhV2sgJJPt+HY6KhU7VZUL0fKZQ=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "yants": {
+      "inputs": {
+        "nixpkgs": [
+          "haskellNix",
+          "tullia",
+          "std",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1667096281,
+        "narHash": "sha256-wRRec6ze0gJHmGn6m57/zhz/Kdvp9HS4Nl5fkQ+uIuA=",
+        "owner": "divnix",
+        "repo": "yants",
+        "rev": "d18f356ec25cb94dc9c275870c3a7927a10f8c3c",
+        "type": "github"
+      },
+      "original": {
+        "owner": "divnix",
+        "repo": "yants",
         "type": "github"
       }
     }

flake.nix

@@ -1,15 +1,15 @@
 {
   description = "nix flake for simplex-chat";
+  inputs.nixpkgs.url = "github:angerman/nixpkgs/release-22.11";
   inputs.haskellNix.url = "github:input-output-hk/haskell.nix/armv7a";
-  inputs.nixpkgs.follows = "haskellNix/nixpkgs-2305";
-  inputs.mac2ios.url = "github:zw3rk/mobile-core-tools";
+  inputs.haskellNix.inputs.nixpkgs.follows = "nixpkgs";
   inputs.hackage = {
     url = "github:input-output-hk/hackage.nix";
     flake = false;
   };
   inputs.haskellNix.inputs.hackage.follows = "hackage";
   inputs.flake-utils.url = "github:numtide/flake-utils";
-  outputs = { self, haskellNix, nixpkgs, flake-utils, mac2ios, ... }:
+  outputs = { self, haskellNix, nixpkgs, flake-utils, ... }:
     let systems = [ "x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin" ]; in
     flake-utils.lib.eachSystem systems (system:
       # this android26 overlay makes the pkgsCross.{aarch64-android,armv7a-android-prebuilt} to set stdVer to 26 (Android 8).
@@ -30,7 +30,7 @@
       # `appendOverlays` with a singleton is identical to `extend`.
       let pkgs = haskellNix.legacyPackages.${system}.appendOverlays [android26]; in
       let drv' = { extra-modules, pkgs', ... }: pkgs'.haskell-nix.project {
-        compiler-nix-name = "ghc963";
+        compiler-nix-name = "ghc8107";
         index-state = "2023-12-12T00:00:00Z";
         # We need this, to specify we want the cabal project.
         # If the stack.yaml was dropped, this would not be necessary.
@@ -40,12 +40,9 @@
           src = ./.;
         };
         sha256map = import ./scripts/nix/sha256map.nix;
-        modules = [
-        ({ pkgs, lib, ...}: lib.mkIf (!pkgs.stdenv.hostPlatform.isWindows) {
-          # This patch adds `dl` as an extra-library to direct-sqlciper, which is needed
-          # on pretty much all unix platforms, but then blows up on windows m(
+        modules = [{
           packages.direct-sqlcipher.patches = [ ./scripts/nix/direct-sqlcipher-2.3.27.patch ];
-        })
+        }
         ({ pkgs,lib, ... }: lib.mkIf (pkgs.stdenv.hostPlatform.isAndroid) {
           packages.simplex-chat.components.library.ghcOptions = [ "-pie" ];
         })] ++ extra-modules;
@@ -67,9 +64,6 @@
       }); in
       let iosPostInstall = bundleName: ''
         ${pkgs.tree}/bin/tree $out
-        mkdir tmp
-        find ./dist -name "libHS*-ghc*.a" -exec cp {} tmp \;
-        (cd tmp; ${pkgs.tree}/bin/tree .; ar x libHS*.a; for o in *.o; do if /usr/bin/otool -xv $o|grep ldadd ; then echo $o; fi; done; cd ..; rm -fR tmp)
         mkdir -p $out/_pkg
         # copy over includes, we might want those, but maybe not.
         # cp -r $out/lib/*/*/include $out/_pkg/
@@ -80,18 +74,6 @@
         find ${pkgs.gmp6.override { withStatic = true; }}/lib -name "*.a" -exec cp {} $out/_pkg \;
         # There is no static libc
         ${pkgs.tree}/bin/tree $out/_pkg
-        for pkg in $out/_pkg/*.a; do
-          chmod +w $pkg
-          ${mac2ios.packages.${system}.mac2ios}/bin/mac2ios $pkg
-          chmod -w $pkg
-        done
-
-        mkdir tmp
-        find $out/_pkg -name "libHS*-ghc*.a" -exec cp {} tmp \;
-        (cd tmp; ${pkgs.tree}/bin/tree .; ar x libHS*.a; for o in *.o; do if /usr/bin/otool -xv $o|grep ldadd ; then echo $o; fi; done; cd ..; rm -fR tmp)
-
-        sha256sum $out/_pkg/*.a
-
         (cd $out/_pkg; ${pkgs.zip}/bin/zip -r -9 $out/${bundleName}.zip *)
         rm -fR $out/_pkg
         mkdir -p $out/nix-support
@@ -137,149 +119,13 @@
                       hardeningDisable = [ "fortify" ];
                   }
               );in {
-              # STATIC x86_64-linux
               "${pkgs.pkgsCross.musl64.hostPlatform.system}-static:exe:simplex-chat" = (drv pkgs.pkgsCross.musl64).simplex-chat.components.exes.simplex-chat;
-              # STATIC i686-linux
-              "${pkgs.pkgsCross.musl32.hostPlatform.system}-static:exe:simplex-chat" = (drv' {
-                pkgs' = pkgs.pkgsCross.musl32;
-                extra-modules = [{
-                  # 32 bit patches
-                  packages.basement.patches = [
-                    ./scripts/nix/basement-pr-573.patch
-                  ];
-                  packages.memory.patches = [
-                    ./scripts/nix/memory-pr-99.patch
-                  ];
-                }];
-              }).simplex-chat.components.exes.simplex-chat;
-              # WINDOWS x86_64-mingwW64
-              "${pkgs.pkgsCross.mingwW64.hostPlatform.system}:exe:simplex-chat" = (drv' {
-                pkgs' = pkgs.pkgsCross.mingwW64;
-                extra-modules = [{
-                  packages.direct-sqlcipher.flags.openssl = true;
-                  packages.bitvec.flags.simd = false;
-                  packages.direct-sqlcipher.patches = [
-                    ./scripts/nix/direct-sqlcipher-2.3.27-win.patch
-                  ];
-                  packages.direct-sqlcipher.components.library.libs = pkgs.lib.mkForce [
-                    (pkgs.pkgsCross.mingwW64.openssl) #.override) # { static = true; enableKTLS = false; })
-                  ];
-                  packages.simplexmq.components.library.libs = pkgs.lib.mkForce [
-                    (pkgs.pkgsCross.mingwW64.openssl) #.override) # { static = true; enableKTLS = false; })
-                  ];
-                  packages.unix-time.postPatch = ''
-                    sed -i 's/mingwex//g' unix-time.cabal
-                  '';
-                 }];
-                }).simplex-chat.components.exes.simplex-chat.override {
-                postInstall = ''
-                  set -x
-                  ${pkgs.tree}/bin/tree $out
-                  mkdir -p $out/_pkg
-                  cp $out/bin/* $out/_pkg
-                  ${pkgs.tree}/bin/tree $out/_pkg
-                  (cd $out/_pkg; ${pkgs.zip}/bin/zip -r -9 $out/${pkgs.pkgsCross.mingwW64.hostPlatform.system}-simplex-chat.zip *)
-                  rm -fR $out/_pkg
-                  mkdir -p $out/nix-support
-                  echo "file binary-dist \"$(echo $out/*.zip)\"" \
-                      > $out/nix-support/hydra-build-products
-                '';
-              };
-              "${pkgs.pkgsCross.mingwW64.hostPlatform.system}:lib:simplex-chat" = (drv' rec {
-                pkgs' = pkgs.pkgsCross.mingwW64;
-                extra-modules = [{
-                  packages.direct-sqlcipher.flags.openssl = true;
-                  # simd will try to read __cpu_model, which we don't expose
-                  # from the rts (yet!).
-                  packages.bitvec.flags.simd = false;
-                  packages.direct-sqlcipher.patches = [
-                    ./scripts/nix/direct-sqlcipher-2.3.27-win.patch
-                  ];
-                  packages.direct-sqlcipher.components.library.libs = pkgs.lib.mkForce [
-                    pkgs.pkgsCross.mingwW64.openssl
-                  ];
-                  packages.simplexmq.components.library.libs = pkgs.lib.mkForce [
-                    pkgs.pkgsCross.mingwW64.openssl
-                  ];
-                  packages.unix-time.postPatch = ''
-                    sed -i 's/mingwex//g' unix-time.cabal
-                  '';
-                }];
-              }).simplex-chat.components.library
-              .override (p: {
-                # enableShared = false;
-                setupBuildFlags = p.component.setupBuildFlags ++ map (x: "--ghc-option=${x}") [
-                  "-shared"
-                  "-threaded"
-                  "-o" "libsimplex.dll"
-                  # "-optl-lHSrts_thr"
-                  "-optl-lffi"
-                  # "-optl-static-libgcc"
-                  # We can't do -optl-static-libstdc++ with gcc. g++ might
-                  # but then we are chaning the compiler altogether.
-                  "${./libsimplex.dll.def}"
-                ];
-                postInstall = ''
-                  set -x
-                  function deps() {
-                    ${pkgs.binutils}/bin/strings "$1" | grep '.\.dll'|grep -v -E 'Winsock|ADVAPI32|dbghelp|KERNEL32|msvcrt|ntdll|ole32|RPCRT4|SHELL32|USER32|WINMM|WS2_32|kernel32|GDI32'|grep -v "$1"
-                  }
-                  ${pkgs.tree}/bin/tree $out
-                  mkdir -p $out/_pkg
-                  cp libsimplex.dll $out/_pkg
-                  cp libsimplex.dll.a $out/_pkg
-                  mkdir $out/libs
-                  find ${pkgs.lib.getBin pkgs.pkgsCross.mingwW64.openssl}             -name "*.dll" -exec cp {} $out/libs \;
-                  find ${pkgs.lib.getBin pkgs.pkgsCross.mingwW64.libffi}              -name "*.dll" -exec cp {} $out/libs \;
-                  find ${pkgs.lib.getBin pkgs.pkgsCross.mingwW64.gmp}                 -name "*.dll" -exec cp {} $out/libs \;
-                  find ${pkgs.lib.getBin pkgs.pkgsCross.mingwW64.stdenv.cc.cc}        -name "*.dll" -exec cp {} $out/libs \;
-                  find ${pkgs.lib.getBin pkgs.pkgsCross.mingwW64.windows.mcfgthreads} -name "*.dll" -exec cp {} $out/libs \;
-
-                  pushd $out/_pkg
-                  function copyDeps() {
-                    for dep in $(deps "$1"); do
-                      if [ ! -f "$dep" ]; then
-                        if [ ! -f ../libs/"$dep" ]; then
-                          echo "WARN: $1 -> $dep not found!"
-                        else
-                          cp ../libs/"$dep" .
-                          copyDeps "$dep"
-                        fi
-                      fi
-                    done
-                  }
-                  copyDeps libsimplex.dll
-                  popd
-                  ${pkgs.tree}/bin/tree $out/_pkg
-                  (cd $out/_pkg; ${pkgs.zip}/bin/zip -r -9 $out/pkg-${pkgs.pkgsCross.mingwW64.hostPlatform.system}-libsimplex.zip *)
-                  rm -fR $out/_pkg
-                  mkdir -p $out/nix-support
-                  echo "file binary-dist \"$(echo $out/*.zip)\"" \
-                      > $out/nix-support/hydra-build-products
-                '';
-              });
+              "${pkgs.pkgsCross.musl32.hostPlatform.system}-static:exe:simplex-chat" = (drv pkgs.pkgsCross.musl32).simplex-chat.components.exes.simplex-chat;
               # "${pkgs.pkgsCross.muslpi.hostPlatform.system}-static:exe:simplex-chat" = (drv pkgs.pkgsCross.muslpi).simplex-chat.components.exes.simplex-chat;
-
-              # STATIC aarch64-linux
               "${pkgs.pkgsCross.aarch64-multiplatform-musl.hostPlatform.system}-static:exe:simplex-chat" = (drv pkgs.pkgsCross.aarch64-multiplatform-musl).simplex-chat.components.exes.simplex-chat;
-              "armv7a-android:lib:support" = (drv android32Pkgs).android-support.components.library.override (p: {
-                smallAddressSpace = true;
-                # we won't want -dyamic (see aarch64-android:lib:simplex-chat)
-                enableShared = false;
-                # we also do not want to have any dependencies listed (especially no rts!)
-                enableStatic = false;
-
-                # This used to work with 8.10.7...
-                # setupBuildFlags = p.component.setupBuildFlags ++ map (x: "--ghc-option=${x}") [ "-shared" "-o" "libsupport.so" ];
-                # ... but now with 9.6+
-                # we have to do the -shared thing by hand.
-                postBuild = ''
-                  armv7a-unknown-linux-androideabi-ghc -shared -o libsupport.so \
-                    -optl-Wl,-u,setLineBuffering \
-                    -optl-Wl,-u,pipe_std_to_socket \
-                    dist/build/*.a
-                '';
-
+              "armv7a-android:lib:support" = (drv android32Pkgs).android-support.components.library.override {
+                smallAddressSpace = true; enableShared = false;
+                setupBuildFlags = map (x: "--ghc-option=${x}") [ "-shared" "-o" "libsupport.so" ];
                 postInstall = ''
 
                   mkdir -p $out/_pkg
@@ -292,29 +138,14 @@
                   echo "file binary-dist \"$(echo $out/*.zip)\"" \
                         > $out/nix-support/hydra-build-products
                 '';
-              });
-              # The android-support package is at
-              # https://github.com/simplex-chat/android-support
-              "aarch64-android:lib:support" = (drv androidPkgs).android-support.components.library.override (p: {
-                smallAddressSpace = true;
-                # no -dynamic
-                enableShared = false;
-                # but also no -staticlib
-                enableStatic = false;
-
-                # we have to do the -shared thing by hand.
-                postBuild = ''
-                  aarch64-unknown-linux-android-ghc -shared -o libsupport.so \
-                    -optl-Wl,-u,setLineBuffering \
-                    -optl-Wl,-u,pipe_std_to_socket \
-                    dist/build/*.a
-                '';
-
+              };
+              "aarch64-android:lib:support" = (drv androidPkgs).android-support.components.library.override {
+                smallAddressSpace = true; enableShared = false;
+                setupBuildFlags = map (x: "--ghc-option=${x}") [ "-shared" "-o" "libsupport.so" ];
                 postInstall = ''
 
                   mkdir -p $out/_pkg
                   cp libsupport.so $out/_pkg
-                  ls -lah $out/_pkg/*
                   ${pkgs.patchelf}/bin/patchelf --remove-needed libunwind.so.1 $out/_pkg/libsupport.so
                   (cd $out/_pkg; ${pkgs.zip}/bin/zip -r -9 $out/pkg-aarch64-android-libsupport.zip *)
                   rm -fR $out/_pkg
@@ -323,11 +154,10 @@
                   echo "file binary-dist \"$(echo $out/*.zip)\"" \
                         > $out/nix-support/hydra-build-products
                 '';
-              });
+              };
               "armv7a-android:lib:simplex-chat" = (drv' {
                 pkgs' = android32Pkgs;
                 extra-modules = [{
-                  packages.text.flags.simdutf = false;
                   packages.direct-sqlcipher.flags.openssl = true;
                   packages.direct-sqlcipher.components.library.libs = pkgs.lib.mkForce [
                     (android32Pkgs.openssl.override { static = true; enableKTLS = false; })
@@ -338,56 +168,13 @@
                   packages.simplexmq.components.library.libs = pkgs.lib.mkForce [
                     (android32Pkgs.openssl.override { static = true; enableKTLS = false; })
                   ];
-                  # 32 bit patches
-                  packages.basement.patches = [
-                    ./scripts/nix/basement-pr-573.patch
-                  ];
-                  packages.memory.patches = [
-                    ./scripts/nix/memory-pr-99.patch
-                  ];
                 }];
-              }).simplex-chat.components.library.override (p: {
-                smallAddressSpace = true;
-                # we want -shared, but not -dyanmic, hence `enableShared = false`.
-                enableShared = false;
-                # we _do_ want rts, and other libs. Hence `enableStatic = true`.
-                enableStatic = true;
+              }).simplex-chat.components.library.override {
+                smallAddressSpace = true; enableShared = false;
                 # for android we build a shared library, passing these arguments is a bit tricky, as
                 # we want only the threaded rts (HSrts_thr) and ffi to be linked, but not fed into iserv for
                 # template haskell cross compilation. Thus we just pass them as linker options (-optl).
-                setupBuildFlags = p.component.setupBuildFlags
-                # flags to tell GHC we want to produce a -shared object, and we want to also link
-                # - the ffi library (ffi)
-                ++ map (x: "--ghc-option=${x}") [
-                  "-shared" "-o" "libsimplex.so"
-                  "-threaded"
-                  # "-debug"
-                  "-optl-lffi"
-                ]
-                # This is fairly idiotic. LLD will strip out foreign exported
-                # symbols (a GHC bug? Codegen bug?). So we need to pass `-u <sym>`
-                # to ensure they stay in the produced library. Having them
-                # _undefined_ and _lazy_ (lld will tell with -y <sym> that the
-                # symbol is lazy), makes them _defined_. m(
-                ++ map (sym: "--ghc-option=-optl-Wl,-u,${sym}") [
-                  "chat_close_store"
-                  "chat_decrypt_file"
-                  "chat_decrypt_media"
-                  "chat_encrypt_file"
-                  "chat_encrypt_media"
-                  "chat_migrate_init"
-                  "chat_parse_markdown"
-                  "chat_parse_server"
-                  "chat_password_hash"
-                  "chat_read_file"
-                  "chat_recv_msg"
-                  "chat_recv_msg_wait"
-                  "chat_send_cmd"
-                  "chat_send_remote_cmd"
-                  "chat_valid_name"
-                  "chat_json_length"
-                  "chat_write_file"
-                ];
+                setupBuildFlags = map (x: "--ghc-option=${x}") [ "-shared" "-o" "libsimplex.so" "-optl-lHSrts_thr" "-optl-lffi"];
                 postInstall = ''
                   set -x
                   ${pkgs.tree}/bin/tree $out
@@ -431,11 +218,10 @@
                   echo "file binary-dist \"$(echo $out/*.zip)\"" \
                       > $out/nix-support/hydra-build-products
                 '';
-              });
+              };
               "aarch64-android:lib:simplex-chat" = (drv' {
                 pkgs' = androidPkgs;
                 extra-modules = [{
-                  packages.text.flags.simdutf = false;
                   packages.direct-sqlcipher.flags.openssl = true;
                   packages.direct-sqlcipher.components.library.libs = pkgs.lib.mkForce [
                     (androidPkgs.openssl.override { static = true; })
@@ -447,50 +233,12 @@
                     (androidPkgs.openssl.override { static = true; })
                   ];
                 }];
-              }).simplex-chat.components.library.override (p: {
-                smallAddressSpace = true;
-                # we do not want a dynamically linked object, even though we _do_
-                # want to produce a _shared_ object. But `shared` implied -dyanmic
-                # with cabal, so we disable and pass `-shared` explicitly.
-                enableShared = false;
-                # we do want static (e.g. pass all dependencies in, so we get -staticlib)
-                enableStatic = true;
+              }).simplex-chat.components.library.override {
+                smallAddressSpace = true; enableShared = false;
                 # for android we build a shared library, passing these arguments is a bit tricky, as
                 # we want only the threaded rts (HSrts_thr) and ffi to be linked, but not fed into iserv for
                 # template haskell cross compilation. Thus we just pass them as linker options (-optl).
-                setupBuildFlags = p.component.setupBuildFlags
-                # flags to tell GHC we want to produce a -shared object, and we want to also link
-                # - the ffi library (ffi)
-                ++ map (x: "--ghc-option=${x}") [
-                  "-shared" "-o" "libsimplex.so"
-                  "-threaded"
-                  # "-debug"
-                  "-optl-lffi"
-                ]
-                # This is fairly idiotic. LLD will strip out foreign exported
-                # symbols (a GHC bug? Codegen bug?). So we need to pass `-u <sym>`
-                # to ensure they stay in the produced library. Having them
-                # _undefined_ and _lazy_ (lld will tell with -y <sym> that the
-                # symbol is lazy), makes them _defined_. m(
-                ++ map (sym: "--ghc-option=-optl-Wl,-u,${sym}") [
-                  "chat_close_store"
-                  "chat_decrypt_file"
-                  "chat_decrypt_media"
-                  "chat_encrypt_file"
-                  "chat_encrypt_media"
-                  "chat_migrate_init"
-                  "chat_parse_markdown"
-                  "chat_parse_server"
-                  "chat_password_hash"
-                  "chat_read_file"
-                  "chat_recv_msg"
-                  "chat_recv_msg_wait"
-                  "chat_send_cmd"
-                  "chat_send_remote_cmd"
-                  "chat_valid_name"
-                  "chat_json_length"
-                  "chat_write_file"
-                ];
+                setupBuildFlags = map (x: "--ghc-option=${x}") [ "-shared" "-o" "libsimplex.so" "-optl-lHSrts_thr" "-optl-lffi"];
                 postInstall = ''
                   set -x
                   ${pkgs.tree}/bin/tree $out
@@ -534,7 +282,7 @@
                   echo "file binary-dist \"$(echo $out/*.zip)\"" \
                       > $out/nix-support/hydra-build-products
                 '';
-              });
+              };
             };
 
             # builds for iOS and iOS simulator
@@ -548,8 +296,7 @@
                   packages.direct-sqlcipher.flags.commoncrypto = true;
                   packages.entropy.flags.DoNotGetEntropy = true;
                   packages.simplexmq.components.library.libs = pkgs.lib.mkForce [
-                    # TODO: have a cross override for iOS, that sets this.
-                    ((pkgs.openssl.override { static = true; }).overrideDerivation (old: { CFLAGS = "-mcpu=apple-a7 -march=armv8-a+norcpc" ;}))
+                    (pkgs.openssl.override { static = true; })
                   ];
                 }];
               }).simplex-chat.components.library.override (

package.yaml

@@ -1,5 +1,5 @@
 name: simplex-chat
-version: 5.5.3.0
+version: 5.5.6.0
 #synopsis:
 #description:
 homepage: https://github.com/simplex-chat/simplex-chat#readme

packages/simplex-chat-client/typescript/src/command.ts

@@ -12,7 +12,6 @@ export type ChatCommand =
   | APIStopChat
   | SetTempFolder
   | SetFilesFolder
-  | APISetXFTPConfig
   | SetIncognito
   | APIExportArchive
   | APIImportArchive
@@ -112,7 +111,6 @@ type ChatCommandTag =
   | "apiStopChat"
   | "setTempFolder"
   | "setFilesFolder"
-  | "apiSetXFTPConfig"
   | "setIncognito"
   | "apiExportArchive"
   | "apiImportArchive"
@@ -242,15 +240,6 @@ export interface SetFilesFolder extends IChatCommand {
   filePath: string
 }
 
-export interface APISetXFTPConfig extends IChatCommand {
-  type: "apiSetXFTPConfig"
-  config?: XFTPFileConfig
-}
-
-export interface XFTPFileConfig {
-  minFileSize: number
-}
-
 export interface SetIncognito extends IChatCommand {
   type: "setIncognito"
   incognito: boolean
@@ -707,8 +696,6 @@ export function cmdString(cmd: ChatCommand): string {
       return `/_temp_folder ${cmd.tempFolder}`
     case "setFilesFolder":
       return `/_files_folder ${cmd.filePath}`
-    case "apiSetXFTPConfig":
-      return `/_xftp ${onOff(cmd.config)}${maybeJSON(cmd.config)}`
     case "setIncognito":
       return `/incognito ${onOff(cmd.incognito)}`
     case "apiExportArchive":

packages/simplex-chat-webrtc/src/android/call.html

@@ -8,7 +8,6 @@
   <body>
     <video
       id="remote-video-stream"
-      class="inline"
       autoplay
       playsinline
       poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
@@ -16,7 +15,6 @@
     ></video>
     <video
       id="local-video-stream"
-      class="inline"
       muted
       autoplay
       playsinline

packages/simplex-chat-webrtc/src/android/style.css

@@ -5,14 +5,14 @@ body {
   background-color: black;
 }
 
-#remote-video-stream.inline {
+#remote-video-stream {
   position: absolute;
   width: 100%;
   height: 100%;
   object-fit: cover;
 }
 
-#local-video-stream.inline {
+#local-video-stream {
   position: absolute;
   width: 30%;
   max-width: 30%;
@@ -23,20 +23,6 @@ body {
   right: 0;
 }
 
-#remote-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
-#local-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
 *::-webkit-media-controls {
   display: none !important;
   -webkit-appearance: none !important;

packages/simplex-chat-webrtc/src/call.ts

@@ -16,7 +16,6 @@ type WCallCommand =
   | WCEnableMedia
   | WCToggleCamera
   | WCDescription
-  | WCLayout
   | WCEndCall
 
 type WCallResponse =
@@ -32,7 +31,7 @@ type WCallResponse =
   | WRError
   | WCAcceptOffer
 
-type WCallCommandTag = "capabilities" | "start" | "offer" | "answer" | "ice" | "media" | "camera" | "description" | "layout" | "end"
+type WCallCommandTag = "capabilities" | "start" | "offer" | "answer" | "ice" | "media" | "camera" | "description" | "end"
 
 type WCallResponseTag = "capabilities" | "offer" | "answer" | "ice" | "connection" | "connected" | "end" | "ended" | "ok" | "error"
 
@@ -46,12 +45,6 @@ enum VideoCamera {
   Environment = "environment",
 }
 
-enum LayoutType {
-  Default = "default",
-  LocalVideo = "localVideo",
-  RemoteVideo = "remoteVideo",
-}
-
 interface IWCallCommand {
   type: WCallCommandTag
 }
@@ -122,11 +115,6 @@ interface WCDescription extends IWCallCommand {
   description: string
 }
 
-interface WCLayout extends IWCallCommand {
-  type: "layout"
-  layout: LayoutType
-}
-
 interface WRCapabilities extends IWCallResponse {
   type: "capabilities"
   capabilities: CallCapabilities
@@ -527,10 +515,6 @@ const processCommand = (function () {
           localizedDescription = command.description
           resp = {type: "ok"}
           break
-        case "layout":
-          changeLayout(command.layout)
-          resp = {type: "ok"}
-          break
         case "end":
           endCall()
           resp = {type: "ok"}
@@ -840,29 +824,6 @@ function toggleMedia(s: MediaStream, media: CallMediaType): boolean {
   return res
 }
 
-function changeLayout(layout: LayoutType) {
-  const local = document.getElementById("local-video-stream")!
-  const remote = document.getElementById("remote-video-stream")!
-  switch (layout) {
-    case LayoutType.Default:
-      local.className = "inline"
-      remote.className = "inline"
-      local.style.visibility = "visible"
-      remote.style.visibility = "visible"
-      break
-    case LayoutType.LocalVideo:
-      local.className = "fullscreen"
-      local.style.visibility = "visible"
-      remote.style.visibility = "hidden"
-      break
-    case LayoutType.RemoteVideo:
-      remote.className = "fullscreen"
-      local.style.visibility = "hidden"
-      remote.style.visibility = "visible"
-      break
-  }
-}
-
 type TransformFrameFunc = (key: CryptoKey) => (frame: RTCEncodedVideoFrame, controller: TransformStreamDefaultController) => Promise<void>
 
 interface CallCrypto {

packages/simplex-chat-webrtc/src/desktop/call.html

@@ -9,7 +9,6 @@
   <body>
     <video
       id="remote-video-stream"
-      class="inline"
       autoplay
       playsinline
       poster="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAQAAAAnOwc2AAAAEUlEQVR42mNk+M+AARiHsiAAcCIKAYwFoQ8AAAAASUVORK5CYII="
@@ -17,7 +16,6 @@
     ></video>
     <video
       id="local-video-stream"
-      class="inline"
       muted
       autoplay
       playsinline

packages/simplex-chat-webrtc/src/desktop/style.css

@@ -5,14 +5,14 @@ body {
   background-color: black;
 }
 
-#remote-video-stream.inline {
+#remote-video-stream {
   position: absolute;
   width: 100%;
   height: 100%;
   object-fit: cover;
 }
 
-#local-video-stream.inline {
+#local-video-stream {
   position: absolute;
   width: 20%;
   max-width: 20%;
@@ -23,20 +23,6 @@ body {
   right: 0;
 }
 
-#remote-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
-#local-video-stream.fullscreen {
-  position: absolute;
-  height: 100%;
-  width: 100%;
-  object-fit: cover;
-}
-
 *::-webkit-media-controls {
   display: none !important;
   -webkit-appearance: none !important;

scripts/android/build-android.sh

@@ -103,7 +103,7 @@ build() {
 
   for arch in $arches; do
 
-    tag_full="$(git tag --points-at HEAD | head -n1)"
+    tag_full="$(git tag --points-at HEAD)"
     tag_version="${tag_full%%-*}"
 
     if [ "$arch" = "armv7a" ] && [ -n "$tag_full" ] ; then

scripts/ci/prepare-keychain-mac.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-security create-keychain -p "" simplex.keychain
-security set-keychain-settings -u simplex.keychain
-security add-certificates -k simplex.keychain "Developer ID Application: SimpleX Chat Ltd (5NN7GUYB6T).cer"
-security add-certificates -k simplex.keychain "Developer ID Certification Authority.cer"
-# Private key with access from any app
-security import "SimpleX Chat.p12" -P "" -k simplex.keychain -A
-# Public key
-security import "SimpleX Chat.pem" -k simplex.keychain

scripts/desktop/build-desktop-mac-ci.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-trap "rm apps/multiplatform/local.properties 2> /dev/null || true; rm local.properties 2> /dev/null || true; rm /tmp/simplex.keychain" EXIT
+trap "rm apps/multiplatform/local.properties || true; rm local.properties || true; rm /tmp/simplex.keychain || true" EXIT
 echo "desktop.mac.signing.identity=Developer ID Application: SimpleX Chat Ltd (5NN7GUYB6T)" >> apps/multiplatform/local.properties
 echo "desktop.mac.signing.keychain=/tmp/simplex.keychain" >> apps/multiplatform/local.properties
 echo "desktop.mac.notarization.apple_id=$APPLE_SIMPLEX_NOTARIZATION_APPLE_ID" >> apps/multiplatform/local.properties
@@ -10,10 +10,6 @@ echo "desktop.mac.notarization.password=$APPLE_SIMPLEX_NOTARIZATION_PASSWORD" >>
 echo "desktop.mac.notarization.team_id=5NN7GUYB6T" >> apps/multiplatform/local.properties
 echo "$APPLE_SIMPLEX_SIGNING_KEYCHAIN" | base64 --decode - > /tmp/simplex.keychain
 
-security unlock-keychain -p "" /tmp/simplex.keychain
-# Adding keychain to the list of keychains.
-# Otherwise, it can find cert but exits while signing with "error: The specified item could not be found in the keychain."
-security list-keychains -s `security list-keychains | xargs` /tmp/simplex.keychain
 scripts/desktop/build-lib-mac.sh
 cd apps/multiplatform
 ./gradlew packageDmg

scripts/desktop/build-lib-linux.sh

@@ -8,7 +8,7 @@ function readlink() {
 
 OS=linux
 ARCH=${1:-`uname -a | rev | cut -d' ' -f2 | rev`}
-GHC_VERSION=9.6.3
+GHC_VERSION=8.10.7
 
 if [ "$ARCH" == "aarch64" ]; then
     COMPOSE_ARCH=arm64
@@ -25,7 +25,7 @@ for elem in "${exports[@]}"; do count=$(grep -R "$elem$" libsimplex.dll.def | wc
 for elem in "${exports[@]}"; do count=$(grep -R "\"$elem\"" flake.nix | wc -l); if [ $count -ne 2 ]; then echo Wrong exports in flake.nix. Add \"$elem\" in two places of the file; exit 1; fi ; done
 
 rm -rf $BUILD_DIR
-cabal build lib:simplex-chat --ghc-options='-optl-Wl,-rpath,$ORIGIN -flink-rts -threaded'
+cabal build lib:simplex-chat --ghc-options='-optl-Wl,-rpath,$ORIGIN' --ghc-options="-optl-L$(ghc --print-libdir)/rts -optl-Wl,--as-needed,-lHSrts_thr-ghc$GHC_VERSION"
 cd $BUILD_DIR/build
 #patchelf --add-needed libHSrts_thr-ghc${GHC_VERSION}.so libHSsimplex-chat-*-inplace-ghc${GHC_VERSION}.so
 #patchelf --add-rpath '$ORIGIN' libHSsimplex-chat-*-inplace-ghc${GHC_VERSION}.so

scripts/desktop/build-lib-mac.sh

@@ -5,14 +5,13 @@ set -e
 OS=mac
 ARCH="${1:-`uname -a | rev | cut -d' ' -f1 | rev`}"
 COMPOSE_ARCH=$ARCH
-GHC_VERSION=9.6.3
+GHC_VERSION=8.10.7
 
 if [ "$ARCH" == "arm64" ]; then
     ARCH=aarch64
 else
     COMPOSE_ARCH=x64
 fi
-
 LIB_EXT=dylib
 LIB=libHSsimplex-chat-*-inplace-ghc*.$LIB_EXT
 GHC_LIBS_DIR=$(ghc --print-libdir)
@@ -24,26 +23,13 @@ for elem in "${exports[@]}"; do count=$(grep -R "$elem$" libsimplex.dll.def | wc
 for elem in "${exports[@]}"; do count=$(grep -R "\"$elem\"" flake.nix | wc -l); if [ $count -ne 2 ]; then echo Wrong exports in flake.nix. Add \"$elem\" in two places of the file; exit 1; fi ; done
 
 rm -rf $BUILD_DIR
-cabal build lib:simplex-chat lib:simplex-chat --ghc-options="-optl-Wl,-rpath,@loader_path -optl-Wl,-L$GHC_LIBS_DIR/$ARCH-osx-ghc-$GHC_VERSION -optl-lHSrts_thr-ghc$GHC_VERSION -optl-lffi"
+cabal build lib:simplex-chat lib:simplex-chat --ghc-options="-optl-Wl,-rpath,@loader_path -optl-Wl,-L$GHC_LIBS_DIR/rts -optl-lHSrts_thr-ghc8.10.7 -optl-lffi"
 
 cd $BUILD_DIR/build
 mkdir deps 2> /dev/null || true
 
 # It's not included by default for some reason. Compiled lib tries to find system one but it's not always available
-#cp $GHC_LIBS_DIR/libffi.dylib ./deps
-(
-  BUILD=$PWD
-  cp /tmp/libffi-3.4.4/*-apple-darwin*/.libs/libffi.dylib $BUILD/deps || \
-    ( \
-    cd /tmp && \
-    curl --tlsv1.2 "https://gitlab.haskell.org/ghc/libffi-tarballs/-/raw/libffi-3.4.4/libffi-3.4.4.tar.gz?inline=false" -o libffi.tar.gz && \
-    tar -xzvf libffi.tar.gz && \
-    cd "libffi-3.4.4" && \
-    ./configure && \
-    make && \
-    cp *-apple-darwin*/.libs/libffi.dylib $BUILD/deps \
-    )
-)
+cp $GHC_LIBS_DIR/rts/libffi.dylib ./deps
 
 DYLIBS=`otool -L $LIB | grep @rpath | tail -n +2 | cut -d' ' -f 1 | cut -d'/' -f2`
 RPATHS=`otool -l $LIB | grep "path "| cut -d' ' -f11`
@@ -84,8 +70,6 @@ function copy_deps() {
 }
 
 copy_deps $LIB
-# Special case
-cp $(ghc --print-libdir)/$ARCH-osx-ghc-$GHC_VERSION/libHSghc-boot-th-$GHC_VERSION-ghc$GHC_VERSION.dylib deps
 rm deps/`basename $LIB`
 
 cd -

scripts/nix/basement-pr-573.patch

@@ -1,242 +0,0 @@
-From 38be2c93acb6f459d24ed6c626981c35ccf44095 Mon Sep 17 00:00:00 2001
-From: Sylvain Henry <sylvain@haskus.fr>
-Date: Thu, 16 Feb 2023 15:40:45 +0100
-Subject: [PATCH] Fix build on 32-bit architectures
-
----
- Basement/Bits.hs                 |  4 ++++
- Basement/From.hs                 | 24 -----------------------
- Basement/Numerical/Additive.hs   |  4 ++++
- Basement/Numerical/Conversion.hs | 20 +++++++++++++++++++
- Basement/PrimType.hs             |  6 +++++-
- Basement/Types/OffsetSize.hs     | 22 +++++++++++++++++++--
- 6 files changed, 53 insertions(+), 27 deletions(-)
-
-diff --git a/Basement/Bits.hs b/Basement/Bits.hs
-index 7eeea0f5..24520ed7 100644
---- a/Basement/Bits.hs
-+++ b/Basement/Bits.hs
-@@ -54,8 +54,12 @@ import GHC.Int
- import Basement.Compat.Primitive
-
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+import GHC.Exts
-+#else
- import GHC.IntWord64
- #endif
-+#endif
-
- -- | operation over finite bits
- class FiniteBitsOps bits where
-diff --git a/Basement/From.hs b/Basement/From.hs
-index 7bbe141c..80014b3e 100644
---- a/Basement/From.hs
-+++ b/Basement/From.hs
-@@ -272,23 +272,11 @@ instance (NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty)
-     tryFrom = BlockN.toBlockN . UArray.toBlock . BoxArray.mapToUnboxed id
-
- instance (KnownNat n, NatWithinBound Word8 n) => From (Zn64 n) Word8 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . unZn64 where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w))
--#endif
- instance (KnownNat n, NatWithinBound Word16 n) => From (Zn64 n) Word16 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . unZn64 where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w))
--#endif
- instance (KnownNat n, NatWithinBound Word32 n) => From (Zn64 n) Word32 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . unZn64 where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w))
--#endif
- instance From (Zn64 n) Word64 where
-     from = unZn64
- instance From (Zn64 n) Word128 where
-@@ -297,23 +285,11 @@ instance From (Zn64 n) Word256 where
-     from = from . unZn64
-
- instance (KnownNat n, NatWithinBound Word8 n) => From (Zn n) Word8 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W8# (wordToWord8# (word64ToWord# w))
--#endif
- instance (KnownNat n, NatWithinBound Word16 n) => From (Zn n) Word16 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W16# (wordToWord16# (word64ToWord# w))
--#endif
- instance (KnownNat n, NatWithinBound Word32 n) => From (Zn n) Word32 where
--#if __GLASGOW_HASKELL__ >= 904
--    from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# (GHC.Prim.word64ToWord# w)))
--#else
-     from = narrow . naturalToWord64 . unZn where narrow (W64# w) = W32# (wordToWord32# (word64ToWord# w))
--#endif
- instance (KnownNat n, NatWithinBound Word64 n) => From (Zn n) Word64 where
-     from = naturalToWord64 . unZn
- instance (KnownNat n, NatWithinBound Word128 n) => From (Zn n) Word128 where
-diff --git a/Basement/Numerical/Additive.hs b/Basement/Numerical/Additive.hs
-index d0dfb973..8ab65aa0 100644
---- a/Basement/Numerical/Additive.hs
-+++ b/Basement/Numerical/Additive.hs
-@@ -30,8 +30,12 @@ import qualified Basement.Types.Word128 as Word128
- import qualified Basement.Types.Word256 as Word256
-
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+import           GHC.Exts
-+#else
- import           GHC.IntWord64
- #endif
-+#endif
-
- -- | Represent class of things that can be added together,
- -- contains a neutral element and is commutative.
-diff --git a/Basement/Numerical/Conversion.hs b/Basement/Numerical/Conversion.hs
-index db502c07..fddc8232 100644
---- a/Basement/Numerical/Conversion.hs
-+++ b/Basement/Numerical/Conversion.hs
-@@ -26,8 +26,12 @@ import GHC.Word
- import Basement.Compat.Primitive
-
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+import GHC.Exts
-+#else
- import GHC.IntWord64
- #endif
-+#endif
-
- intToInt64 :: Int -> Int64
- #if WORD_SIZE_IN_BITS == 64
-@@ -96,11 +100,22 @@ int64ToWord64 (I64# i) = W64# (int64ToWord64# i)
- #endif
-
- #if WORD_SIZE_IN_BITS == 64
-+#if __GLASGOW_HASKELL__ >= 904
-+word64ToWord# :: Word64# -> Word#
-+word64ToWord# i = word64ToWord# i
-+#else
- word64ToWord# :: Word# -> Word#
- word64ToWord# i = i
-+#endif
- {-# INLINE word64ToWord# #-}
- #endif
-
-+#if WORD_SIZE_IN_BITS < 64
-+word64ToWord32# :: Word64# -> Word32#
-+word64ToWord32# i = wordToWord32# (word64ToWord# i)
-+{-# INLINE word64ToWord32# #-}
-+#endif
-+
- -- | 2 Word32s
- data Word32x2 = Word32x2 {-# UNPACK #-} !Word32
-                          {-# UNPACK #-} !Word32
-@@ -113,9 +128,14 @@ word64ToWord32s (W64# w64) = Word32x2 (W32# (wordToWord32# (uncheckedShiftRL# (G
- word64ToWord32s (W64# w64) = Word32x2 (W32# (wordToWord32# (uncheckedShiftRL# w64 32#))) (W32# (wordToWord32# w64))
- #endif
- #else
-+#if __GLASGOW_HASKELL__ >= 904
-+word64ToWord32s :: Word64 -> Word32x2
-+word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord32# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord32# w64))
-+#else
- word64ToWord32s :: Word64 -> Word32x2
- word64ToWord32s (W64# w64) = Word32x2 (W32# (word64ToWord# (uncheckedShiftRL64# w64 32#))) (W32# (word64ToWord# w64))
- #endif
-+#endif
-
- wordToChar :: Word -> Char
- wordToChar (W# word) = C# (chr# (word2Int# word))
-diff --git a/Basement/PrimType.hs b/Basement/PrimType.hs
-index f8ca2926..a888ec91 100644
---- a/Basement/PrimType.hs
-+++ b/Basement/PrimType.hs
-@@ -54,7 +54,11 @@ import           Basement.Nat
- import qualified Prelude (quot)
-
- #if WORD_SIZE_IN_BITS < 64
--import           GHC.IntWord64
-+#if __GLASGOW_HASKELL__ >= 904
-+import GHC.Exts
-+#else
-+import GHC.IntWord64
-+#endif
- #endif
-
- #ifdef FOUNDATION_BOUNDS_CHECK
-diff --git a/Basement/Types/OffsetSize.hs b/Basement/Types/OffsetSize.hs
-index cd944927..1ea80dad 100644
---- a/Basement/Types/OffsetSize.hs
-+++ b/Basement/Types/OffsetSize.hs
-@@ -70,8 +70,12 @@ import Data.List (foldl')
- import qualified Prelude
-
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+import GHC.Exts
-+#else
- import GHC.IntWord64
- #endif
-+#endif
-
- -- | File size in bytes
- newtype FileSize = FileSize Word64
-@@ -225,20 +229,26 @@ countOfRoundUp alignment (CountOf n) = CountOf ((n + (alignment-1)) .&. compleme
-
- csizeOfSize :: CountOf Word8 -> CSize
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+csizeOfSize (CountOf (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz)))
-+#else
- csizeOfSize (CountOf (I# sz)) = CSize (W32# (int2Word# sz))
-+#endif
- #else
- #if __GLASGOW_HASKELL__ >= 904
- csizeOfSize (CountOf (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz)))
--
- #else
- csizeOfSize (CountOf (I# sz)) = CSize (W64# (int2Word# sz))
--
- #endif
- #endif
-
- csizeOfOffset :: Offset8 -> CSize
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+csizeOfOffset (Offset (I# sz)) = CSize (W32# (wordToWord32# (int2Word# sz)))
-+#else
- csizeOfOffset (Offset (I# sz)) = CSize (W32# (int2Word# sz))
-+#endif
- #else
- #if __GLASGOW_HASKELL__ >= 904
- csizeOfOffset (Offset (I# sz)) = CSize (W64# (wordToWord64# (int2Word# sz)))
-@@ -250,7 +260,11 @@ csizeOfOffset (Offset (I# sz)) = CSize (W64# (int2Word# sz))
- sizeOfCSSize :: CSsize -> CountOf Word8
- sizeOfCSSize (CSsize (-1))      = error "invalid size: CSSize is -1"
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# (int32ToInt# sz))
-+#else
- sizeOfCSSize (CSsize (I32# sz)) = CountOf (I# sz)
-+#endif
- #else
- #if __GLASGOW_HASKELL__ >= 904
- sizeOfCSSize (CSsize (I64# sz)) = CountOf (I# (int64ToInt# sz))
-@@ -261,7 +275,11 @@ sizeOfCSSize (CSsize (I64# sz)) = CountOf (I# sz)
-
- sizeOfCSize :: CSize -> CountOf Word8
- #if WORD_SIZE_IN_BITS < 64
-+#if __GLASGOW_HASKELL__ >= 904
-+sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# (word32ToWord# sz)))
-+#else
- sizeOfCSize (CSize (W32# sz)) = CountOf (I# (word2Int# sz))
-+#endif
- #else
- #if __GLASGOW_HASKELL__ >= 904
- sizeOfCSize (CSize (W64# sz)) = CountOf (I# (word2Int# (word64ToWord# sz)))

scripts/nix/direct-sqlcipher-2.3.27-win.patch

@@ -1,12 +0,0 @@
-diff --git a/direct-sqlcipher.cabal b/direct-sqlcipher.cabal
-index 728ba3e..c63745e 100644
---- a/direct-sqlcipher.cabal
-+++ b/direct-sqlcipher.cabal
-@@ -84,6 +84,8 @@ library
-       cc-options: -DSQLITE_TEMP_STORE=2
-                   -DSQLITE_HAS_CODEC
-
-+    extra-libraries: ws2_32
-+
-     if !os(windows) && !os(android)
-       extra-libraries: pthread

scripts/nix/memory-pr-99.patch

@@ -1,36 +0,0 @@
-From 2738929ce15b4c8704bbbac24a08539b5d4bf30e Mon Sep 17 00:00:00 2001
-From: sternenseemann <sternenseemann@systemli.org>
-Date: Mon, 14 Aug 2023 10:51:30 +0200
-Subject: [PATCH] Data.Memory.Internal.CompatPrim64: fix 32 bit with GHC >= 9.4
-
-Since 9.4, GHC.Prim exports Word64# operations like timesWord64# even on
-i686 whereas GHC.IntWord64 no longer exists. Therefore, we can just use
-the ready made solution.
-
-Closes #98, as it should be the better solution.
----
- Data/Memory/Internal/CompatPrim64.hs | 4 ++++
- 1 file changed, 4 insertions(+)
-
-diff --git a/Data/Memory/Internal/CompatPrim64.hs b/Data/Memory/Internal/CompatPrim64.hs
-index b9eef8a..a134c88 100644
---- a/Data/Memory/Internal/CompatPrim64.hs
-+++ b/Data/Memory/Internal/CompatPrim64.hs
-@@ -150,6 +150,7 @@ w64# :: Word# -> Word# -> Word# -> Word64#
- w64# w _ _ = w
- 
- #elif WORD_SIZE_IN_BITS == 32
-+#if __GLASGOW_HASKELL__ < 904
- import GHC.IntWord64
- import GHC.Prim (Word#)
- 
-@@ -158,6 +159,9 @@ timesWord64# a b =
-     let !ai = word64ToInt64# a
-         !bi = word64ToInt64# b
-      in int64ToWord64# (timesInt64# ai bi)
-+#else
-+import GHC.Prim
-+#endif
- 
- w64# :: Word# -> Word# -> Word# -> Word64#
- w64# _ hw lw =

scripts/nix/sha256map.nix

@@ -1,5 +1,5 @@
 {
-  "https://github.com/simplex-chat/simplexmq.git"."caeeb2df9ccca29a6bb504886736502d081fba0e" = "187avx8h014fhik76qv1l0nifv6db6nrg9kjk2azqia21n4s2m38";
+  "https://github.com/simplex-chat/simplexmq.git"."09878959264014f676a47f986a00c0c9fe34bcf1" = "1w64mh1hjpjxfna48z5cg65cwwqp0w027g7d4wvzlqkf0ny4r6ib";
   "https://github.com/simplex-chat/hs-socks.git"."a30cc7a79a08d8108316094f8f2f82a0c5e1ac51" = "0yasvnr7g91k76mjkamvzab2kvlb1g5pspjyjn2fr6v83swjhj38";
   "https://github.com/simplex-chat/direct-sqlcipher.git"."f814ee68b16a9447fbb467ccc8f29bdd3546bfd9" = "1ql13f4kfwkbaq7nygkxgw84213i0zm7c1a8hwvramayxl38dq5d";
   "https://github.com/simplex-chat/sqlcipher-simple.git"."a46bd361a19376c5211f1058908fc0ae6bf42446" = "1z0r78d8f0812kxbgsm735qf6xx8lvaz27k1a0b4a2m0sshpd5gl";

simplex-chat.cabal

@@ -5,7 +5,7 @@ cabal-version: 1.12
 -- see: https://github.com/sol/hpack
 
 name:           simplex-chat
-version:        5.5.3.0
+version:        5.5.6.0
 category:       Web, System, Services, Cryptography
 homepage:       https://github.com/simplex-chat/simplex-chat#readme
 author:         simplex.chat

src/Simplex/Chat.hs

@@ -81,7 +81,7 @@ import Simplex.Chat.Types.Util
 import Simplex.Chat.Util (encryptFile, shuffle)
 import Simplex.FileTransfer.Client.Main (maxFileSize)
 import Simplex.FileTransfer.Client.Presets (defaultXFTPServers)
-import Simplex.FileTransfer.Description (ValidFileDescription, gb, kb, mb)
+import Simplex.FileTransfer.Description (ValidFileDescription)
 import Simplex.FileTransfer.Protocol (FileParty (..), FilePartyI)
 import Simplex.Messaging.Agent as Agent
 import Simplex.Messaging.Agent.Client (AgentStatsKey (..), SubInfo (..), agentClientStore, getAgentWorkersDetails, getAgentWorkersSummary, temporaryAgentError)
@@ -102,7 +102,6 @@ import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (base64P)
 import Simplex.Messaging.Protocol (AProtoServerWithAuth (..), AProtocolType (..), EntityId, ErrorType (..), MsgBody, MsgFlags (..), NtfServer, ProtoServerWithAuth, ProtocolTypeI, SProtocolType (..), SubscriptionMode (..), UserProtocol, userProtocol)
 import qualified Simplex.Messaging.Protocol as SMP
-import Simplex.Messaging.ServiceScheme (ServiceScheme (..))
 import qualified Simplex.Messaging.TMap as TM
 import Simplex.Messaging.Transport.Client (defaultSocksProxy)
 import Simplex.Messaging.Util
@@ -143,8 +142,6 @@ defaultChatConfig =
       xftpDescrPartSize = 14000,
       inlineFiles = defaultInlineFilesConfig,
       autoAcceptFileSize = 0,
-      xftpFileConfig = Just defaultXFTPFileConfig,
-      tempDir = Nothing,
       showReactions = False,
       showReceipts = False,
       logLevel = CLLImportant,
@@ -172,10 +169,7 @@ _defaultSMPServers =
     ]
 
 _defaultNtfServers :: [NtfServer]
-_defaultNtfServers =
-  [ "ntf://KmpZNNXiVZJx_G2T7jRUmDFxWXM3OAnunz3uLT0tqAA=@ntf3.simplex.im,pxculznuryunjdvtvh6s6szmanyadumpbmvevgdpe4wk5c65unyt4yid.onion",
-    "ntf://CJ5o7X6fCxj2FFYRU2KuCo70y4jSqz7td2HYhLnXWbU=@ntf4.simplex.im,wtvuhdj26jwprmomnyfu5wfuq2hjkzfcc72u44vi6gdhrwxldt6xauad.onion"
-  ]
+_defaultNtfServers = ["ntf://FB-Uop7RTaZZEG0ZLD2CIaTjsPh-Fw0zFAnb7QyA8Ks=@ntf2.simplex.im,ntg7jdjy2i3qbib3sykiho3enekwiaqg3icctliqhtqcg6jmoh6cxiad.onion"]
 
 maxImageSize :: Integer
 maxImageSize = 261120 * 2 -- auto-receive on mobiles
@@ -205,7 +199,7 @@ newChatController :: ChatDatabase -> Maybe User -> ChatConfig -> ChatOpts -> Boo
 newChatController
   ChatDatabase {chatStore, agentStore}
   user
-  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, tempDir, deviceNameForRemote}
+  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, deviceNameForRemote}
   ChatOpts {coreOptions = CoreChatOpts {smpServers, xftpServers, networkConfig, logLevel, logConnections, logServerHosts, logFile, tbqSize, highlyAvailable}, deviceName, optFilesFolder, showReactions, allowInstantFiles, autoAcceptFileSize}
   backgroundMode = do
     let inlineFiles' = if allowInstantFiles || autoAcceptFileSize > 0 then inlineFiles else inlineFiles {sendChunks = 0, receiveInstant = False}
@@ -240,8 +234,7 @@ newChatController
     chatActivated <- newTVarIO True
     showLiveItems <- newTVarIO False
     encryptLocalFiles <- newTVarIO False
-    userXFTPFileConfig <- newTVarIO $ xftpFileConfig cfg
-    tempDirectory <- newTVarIO tempDir
+    tempDirectory <- newTVarIO Nothing
     contactMergeEnabled <- newTVarIO True
     pure
       ChatController
@@ -276,7 +269,6 @@ newChatController
           chatActivated,
           showLiveItems,
           encryptLocalFiles,
-          userXFTPFileConfig,
           tempDirectory,
           logFilePath = logFile,
           contactMergeEnabled
@@ -586,9 +578,6 @@ processChatCommand' vr = \case
     createDirectoryIfMissing True rf
     chatWriteVar remoteHostsFolder $ Just rf
     ok_
-  APISetXFTPConfig cfg -> do
-    asks userXFTPFileConfig >>= atomically . (`writeTVar` cfg)
-    ok_
   APISetEncryptLocalFiles on -> chatWriteVar encryptLocalFiles on >> ok_
   SetContactMergeEnabled onOff -> do
     asks contactMergeEnabled >>= atomically . (`writeTVar` onOff)
@@ -604,7 +593,6 @@ processChatCommand' vr = \case
     pure $ CRArchiveImported fileErrs
   APIDeleteStorage -> withStoreChanged deleteStorage
   APIStorageEncryption cfg -> withStoreChanged $ sqlCipherExport cfg
-  TestStorageEncryption key -> withStoreChanged $ sqlCipherTestKey key
   ExecChatStoreSQL query -> CRSQLResult <$> withStore' (`execSQL` query)
   ExecAgentStoreSQL query -> CRSQLResult <$> withAgent (`execAgentStoreSQL` query)
   SlowSQLQueries -> do
@@ -650,7 +638,7 @@ processChatCommand' vr = \case
           memStatuses -> pure $ Just $ map (uncurry MemberDeliveryStatus) memStatuses
       _ -> pure Nothing
     pure $ CRChatItemInfo user aci ChatItemInfo {itemVersions, memberDeliveryStatuses}
-  APISendMessage (ChatRef cType chatId) live itemTTL (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user@User {userId} -> withChatLock "sendMessage" $ case cType of
+  APISendMessage (ChatRef cType chatId) live itemTTL (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user -> withChatLock "sendMessage" $ case cType of
     CTDirect -> do
       ct@Contact {contactId, contactUsed} <- withStore $ \db -> getContact db user chatId
       assertDirectAllowed user MDSnd ct XMsgNew_
@@ -658,45 +646,19 @@ processChatCommand' vr = \case
       if isVoice mc && not (featureAllowed SCFVoice forUser ct)
         then pure $ chatCmdError (Just user) ("feature not allowed " <> T.unpack (chatFeatureNameText CFVoice))
         else do
-          (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer ct
+          (fInv_, ciFile_) <- L.unzip <$> setupSndFileTransfer ct
           timed_ <- sndContactCITimed live ct itemTTL
           (msgContainer, quotedItem_) <- prepareMsg fInv_ timed_
-          (msg@SndMessage {sharedMsgId}, _) <- sendDirectContactMessage ct (XMsgNew msgContainer)
+          (msg, _) <- sendDirectContactMessage ct (XMsgNew msgContainer)
           ci <- saveSndChatItem' user (CDDirectSnd ct) msg (CISndMsgContent mc) ciFile_ quotedItem_ timed_ live
-          case ft_ of
-            Just ft@FileTransferMeta {fileInline = Just IFMSent} ->
-              sendDirectFileInline ct ft sharedMsgId
-            _ -> pure ()
           forM_ (timed_ >>= timedDeleteAt') $
             startProximateTimedItemThread user (ChatRef CTDirect contactId, chatItemId' ci)
           pure $ CRNewChatItem user (AChatItem SCTDirect SMDSnd (DirectChat ct) ci)
       where
-        setupSndFileTransfer :: Contact -> m (Maybe (FileInvitation, CIFile 'MDSnd, FileTransferMeta))
+        setupSndFileTransfer :: Contact -> m (Maybe (FileInvitation, CIFile 'MDSnd))
         setupSndFileTransfer ct = forM file_ $ \file -> do
-          (fileSize, fileMode) <- checkSndFile mc file 1
-          case fileMode of
-            SendFileSMP fileInline -> smpSndFileTransfer file fileSize fileInline
-            SendFileXFTP -> xftpSndFileTransfer user file fileSize 1 $ CGContact ct
-          where
-            smpSndFileTransfer :: CryptoFile -> Integer -> Maybe InlineFileMode -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
-            smpSndFileTransfer (CryptoFile _ (Just _)) _ _ = throwChatError $ CEFileInternal "locally encrypted files can't be sent via SMP" -- can only happen if XFTP is disabled
-            smpSndFileTransfer (CryptoFile file Nothing) fileSize fileInline = do
-              subMode <- chatReadVar subscriptionMode
-              (agentConnId_, fileConnReq) <-
-                if isJust fileInline
-                  then pure (Nothing, Nothing)
-                  else bimap Just Just <$> withAgent (\a -> createConnection a (aUserId user) True SCMInvitation Nothing subMode)
-              let fileName = takeFileName file
-                  fileInvitation = FileInvitation {fileName, fileSize, fileDigest = Nothing, fileConnReq, fileInline, fileDescr = Nothing}
-              chSize <- asks $ fileChunkSize . config
-              withStore $ \db -> do
-                ft@FileTransferMeta {fileId} <- liftIO $ createSndDirectFileTransfer db userId ct file fileInvitation agentConnId_ chSize subMode
-                fileStatus <- case fileInline of
-                  Just IFMSent -> createSndDirectInlineFT db ct ft $> CIFSSndTransfer 0 1
-                  _ -> pure CIFSSndStored
-                let fileSource = Just $ CF.plain file
-                    ciFile = CIFile {fileId, fileName, fileSize, fileSource, fileStatus, fileProtocol = FPSMP}
-                pure (fileInvitation, ciFile, ft)
+          fileSize <- checkSndFile file
+          xftpSndFileTransfer user file fileSize 1 $ CGContact ct
         prepareMsg :: Maybe FileInvitation -> Maybe CITimed -> m (MsgContainer, Maybe (CIQuote 'CTDirect))
         prepareMsg fInv_ timed_ = case quotedItemId_ of
           Nothing -> pure (MCSimple (ExtMsgContent mc fInv_ (ttl' <$> timed_) (justTrue live)), Nothing)
@@ -723,53 +685,27 @@ processChatCommand' vr = \case
           | isVoice mc && not (groupFeatureAllowed SGFVoice gInfo) = notAllowedError GFVoice
           | not (isVoice mc) && isJust file_ && not (groupFeatureAllowed SGFFiles gInfo) = notAllowedError GFFiles
           | otherwise = do
-              (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
+              (fInv_, ciFile_) <- L.unzip <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
               timed_ <- sndGroupCITimed live gInfo itemTTL
               (msgContainer, quotedItem_) <- prepareGroupMsg user gInfo mc quotedItemId_ fInv_ timed_ live
-              (msg@SndMessage {sharedMsgId}, sentToMembers) <- sendGroupMessage user gInfo ms (XMsgNew msgContainer)
+              (msg, sentToMembers) <- sendGroupMessage user gInfo ms (XMsgNew msgContainer)
               ci <- saveSndChatItem' user (CDGroupSnd gInfo) msg (CISndMsgContent mc) ciFile_ quotedItem_ timed_ live
               withStore' $ \db ->
                 forM_ sentToMembers $ \GroupMember {groupMemberId} ->
                   createGroupSndStatus db (chatItemId' ci) groupMemberId CISSndNew
-              mapM_ (sendGroupFileInline ms sharedMsgId) ft_
               forM_ (timed_ >>= timedDeleteAt') $
                 startProximateTimedItemThread user (ChatRef CTGroup groupId, chatItemId' ci)
               pure $ CRNewChatItem user (AChatItem SCTGroup SMDSnd (GroupChat gInfo) ci)
         notAllowedError f = pure $ chatCmdError (Just user) ("feature not allowed " <> T.unpack (groupFeatureNameText f))
-        setupSndFileTransfer :: Group -> Int -> m (Maybe (FileInvitation, CIFile 'MDSnd, FileTransferMeta))
-        setupSndFileTransfer g@(Group gInfo _) n = forM file_ $ \file -> do
-          (fileSize, fileMode) <- checkSndFile mc file $ fromIntegral n
-          case fileMode of
-            SendFileSMP fileInline -> smpSndFileTransfer file fileSize fileInline
-            SendFileXFTP -> xftpSndFileTransfer user file fileSize n $ CGGroup g
-          where
-            smpSndFileTransfer :: CryptoFile -> Integer -> Maybe InlineFileMode -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
-            smpSndFileTransfer (CryptoFile _ (Just _)) _ _ = throwChatError $ CEFileInternal "locally encrypted files can't be sent via SMP" -- can only happen if XFTP is disabled
-            smpSndFileTransfer (CryptoFile file Nothing) fileSize fileInline = do
-              let fileName = takeFileName file
-                  fileInvitation = FileInvitation {fileName, fileSize, fileDigest = Nothing, fileConnReq = Nothing, fileInline, fileDescr = Nothing}
-                  fileStatus = if fileInline == Just IFMSent then CIFSSndTransfer 0 1 else CIFSSndStored
-              chSize <- asks $ fileChunkSize . config
-              withStore' $ \db -> do
-                ft@FileTransferMeta {fileId} <- createSndGroupFileTransfer db userId gInfo file fileInvitation chSize
-                let fileSource = Just $ CF.plain file
-                    ciFile = CIFile {fileId, fileName, fileSize, fileSource, fileStatus, fileProtocol = FPSMP}
-                pure (fileInvitation, ciFile, ft)
-        sendGroupFileInline :: [GroupMember] -> SharedMsgId -> FileTransferMeta -> m ()
-        sendGroupFileInline ms sharedMsgId ft@FileTransferMeta {fileInline} =
-          when (fileInline == Just IFMSent) . forM_ ms $ \m ->
-            processMember m `catchChatError` (toView . CRChatError (Just user))
-          where
-            processMember m@GroupMember {activeConn = Just conn@Connection {connStatus}} =
-              when (connStatus == ConnReady || connStatus == ConnSndReady) $ do
-                void . withStore' $ \db -> createSndGroupInlineFT db m conn ft
-                sendMemberFileInline m conn ft sharedMsgId
-            processMember _ = pure ()
+        setupSndFileTransfer :: Group -> Int -> m (Maybe (FileInvitation, CIFile 'MDSnd))
+        setupSndFileTransfer g n = forM file_ $ \file -> do
+          fileSize <- checkSndFile file
+          xftpSndFileTransfer user file fileSize n $ CGGroup g
     CTLocal -> pure $ chatCmdError (Just user) "not supported"
     CTContactRequest -> pure $ chatCmdError (Just user) "not supported"
     CTContactConnection -> pure $ chatCmdError (Just user) "not supported"
     where
-      xftpSndFileTransfer :: User -> CryptoFile -> Integer -> Int -> ContactOrGroup -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
+      xftpSndFileTransfer :: User -> CryptoFile -> Integer -> Int -> ContactOrGroup -> m (FileInvitation, CIFile 'MDSnd)
       xftpSndFileTransfer user file@(CryptoFile filePath cfArgs) fileSize n contactOrGroup = do
         let fileName = takeFileName filePath
             fileDescr = FileDescr {fileDescrText = "", fileDescrPartNo = 0, fileDescrComplete = False}
@@ -793,10 +729,7 @@ processChatCommand' vr = \case
                   withStore' $
                     \db -> createSndFTDescrXFTP db user (Just m) conn ft fileDescr
               saveMemberFD _ = pure ()
-        pure (fInv, ciFile, ft)
-      unzipMaybe3 :: Maybe (a, b, c) -> (Maybe a, Maybe b, Maybe c)
-      unzipMaybe3 (Just (a, b, c)) = (Just a, Just b, Just c)
-      unzipMaybe3 _ = (Nothing, Nothing, Nothing)
+        pure (fInv, ciFile)
   APICreateChatItem folderId (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user -> do
     forM_ quotedItemId_ $ \_ -> throwError $ ChatError $ CECommandError "not supported"
     nf <- withStore $ \db -> getNoteFolder db user folderId
@@ -1014,7 +947,7 @@ processChatCommand' vr = \case
         -- functions below are called in separate transactions to prevent crashes on android
         -- (possibly, race condition on integrity check?)
         withStore' $ \db -> deleteContactConnectionsAndFiles db userId ct
-        withStore' $ \db -> deleteContact db user ct
+        withStore $ \db -> deleteContact db user ct
         pure $ CRContactDeleted user ct
     CTContactConnection -> withChatLock "deleteChat contactConnection" . procCmd $ do
       conn@PendingContactConnection {pccAgentConnId = AgentConnId acId} <- withStore $ \db -> getPendingContactConnection db userId chatId
@@ -1055,7 +988,7 @@ processChatCommand' vr = \case
                     Just _ -> pure []
                     Nothing -> do
                       conns <- withStore' $ \db -> getContactConnections db userId ct
-                      withStore' (\db -> setContactDeleted db user ct)
+                      withStore (\db -> setContactDeleted db user ct)
                         `catchChatError` (toView . CRChatError (Just user))
                       pure $ map aConnId conns
     CTLocal -> pure $ chatCmdError (Just user) "not supported"
@@ -1240,8 +1173,9 @@ processChatCommand' vr = \case
       ok user
   SetUserProtoServers serversConfig -> withUser $ \User {userId} ->
     processChatCommand $ APISetUserProtoServers userId serversConfig
-  APITestProtoServer userId srv@(AProtoServerWithAuth _ server) -> withUserId userId $ \user ->
-    CRServerTestResult user srv <$> withAgent (\a -> testProtocolServer a (aUserId user) server)
+  APITestProtoServer userId srv@(AProtoServerWithAuth p server) -> withUserId userId $ \user ->
+    withServerProtocol p $
+      CRServerTestResult user srv <$> withAgent (\a -> testProtocolServer a (aUserId user) server)
   TestProtoServer srv -> withUser $ \User {userId} ->
     processChatCommand $ APITestProtoServer userId srv
   APISetChatItemTTL userId newTTL_ -> withUserId userId $ \user ->
@@ -2206,27 +2140,13 @@ processChatCommand' vr = \case
     contactMember Contact {contactId} =
       find $ \GroupMember {memberContactId = cId, memberStatus = s} ->
         cId == Just contactId && s /= GSMemRemoved && s /= GSMemLeft
-    checkSndFile :: MsgContent -> CryptoFile -> Integer -> m (Integer, SendFileMode)
-    checkSndFile mc (CryptoFile f cfArgs) n = do
+    checkSndFile :: CryptoFile -> m Integer
+    checkSndFile (CryptoFile f cfArgs) = do
       fsFilePath <- toFSFilePath f
       unlessM (doesFileExist fsFilePath) . throwChatError $ CEFileNotFound f
-      ChatConfig {fileChunkSize, inlineFiles} <- asks config
-      xftpCfg <- readTVarIO =<< asks userXFTPFileConfig
       fileSize <- liftIO $ CF.getFileContentsSize $ CryptoFile fsFilePath cfArgs
       when (fromInteger fileSize > maxFileSize) $ throwChatError $ CEFileSize f
-      let chunks = -((-fileSize) `div` fileChunkSize)
-          fileInline = inlineFileMode mc inlineFiles chunks n
-          fileMode = case xftpCfg of
-            Just cfg
-              | isJust cfArgs -> SendFileXFTP
-              | fileInline == Just IFMSent || fileSize < minFileSize cfg || n <= 0 -> SendFileSMP fileInline
-              | otherwise -> SendFileXFTP
-            _ -> SendFileSMP fileInline
-      pure (fileSize, fileMode)
-    inlineFileMode mc InlineFilesConfig {offerChunks, sendChunks, totalSendChunks} chunks n
-      | chunks > offerChunks = Nothing
-      | chunks <= sendChunks && chunks * n <= totalSendChunks && isVoice mc = Just IFMSent
-      | otherwise = Just IFMOffer
+      pure fileSize
     updateProfile :: User -> Profile -> m ChatResponse
     updateProfile user p' = updateProfile_ user p' $ withStore $ \db -> updateUserProfile db user p'
     updateProfile_ :: User -> Profile -> m User -> m ChatResponse
@@ -2458,7 +2378,7 @@ processChatCommand' vr = \case
       where
         cReqSchemas :: (ConnReqInvitation, ConnReqInvitation)
         cReqSchemas =
-          ( CRInvitationUri crData {crScheme = SSSimplex} e2e,
+          ( CRInvitationUri crData {crScheme = CRSSimplex} e2e,
             CRInvitationUri crData {crScheme = simplexChat} e2e
           )
     connectPlan user (ACR SCMContact (CRContactUri crData)) = do
@@ -2503,7 +2423,7 @@ processChatCommand' vr = \case
       where
         cReqSchemas :: (ConnReqContact, ConnReqContact)
         cReqSchemas =
-          ( CRContactUri crData {crScheme = SSSimplex},
+          ( CRContactUri crData {crScheme = CRSSimplex},
             CRContactUri crData {crScheme = simplexChat}
           )
         cReqHashes :: (ConnReqUriHash, ConnReqUriHash)
@@ -3136,7 +3056,7 @@ cleanupManager = do
     cleanupDeletedContacts user = do
       contacts <- withStore' (`getDeletedContacts` user)
       forM_ contacts $ \ct ->
-        withStore' (\db -> deleteContactWithoutGroups db user ct)
+        withStore (\db -> deleteContactWithoutGroups db user ct)
           `catchChatError` (toView . CRChatError (Just user))
     cleanupMessages = do
       ts <- liftIO getCurrentTime
@@ -4916,7 +4836,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
         else do
           contactConns <- withStore' $ \db -> getContactConnections db userId c
           deleteAgentConnectionsAsync user $ map aConnId contactConns
-          withStore' $ \db -> deleteContact db user c
+          withStore $ \db -> deleteContact db user c
       where
         brokerTs = metaBrokerTs msgMeta
 
@@ -6499,8 +6419,6 @@ chatCommandP =
       "/_temp_folder " *> (SetTempFolder <$> filePath),
       ("/_files_folder " <|> "/files_folder ") *> (SetFilesFolder <$> filePath),
       "/remote_hosts_folder " *> (SetRemoteHostsFolder <$> filePath),
-      "/_xftp " *> (APISetXFTPConfig <$> ("on " *> (Just <$> jsonP) <|> ("off" $> Nothing))),
-      "/xftp " *> (APISetXFTPConfig <$> ("on" *> (Just <$> xftpCfgP) <|> ("off" $> Nothing))),
       "/_files_encrypt " *> (APISetEncryptLocalFiles <$> onOffP),
       "/contact_merge " *> (SetContactMergeEnabled <$> onOffP),
       "/_db export " *> (APIExportArchive <$> jsonP),
@@ -6511,7 +6429,6 @@ chatCommandP =
       "/db encrypt " *> (APIStorageEncryption . dbEncryptionConfig "" <$> dbKeyP),
       "/db key " *> (APIStorageEncryption <$> (dbEncryptionConfig <$> dbKeyP <* A.space <*> dbKeyP)),
       "/db decrypt " *> (APIStorageEncryption . (`dbEncryptionConfig` "") <$> dbKeyP),
-      "/db test key " *> (TestStorageEncryption <$> dbKeyP),
       "/sql chat " *> (ExecChatStoreSQL <$> textP),
       "/sql agent " *> (ExecAgentStoreSQL <$> textP),
       "/sql slow" $> SlowSQLQueries,
@@ -6569,7 +6486,6 @@ chatCommandP =
       "/_server test " *> (APITestProtoServer <$> A.decimal <* A.space <*> strP),
       "/smp test " *> (TestProtoServer . AProtoServerWithAuth SPSMP <$> strP),
       "/xftp test " *> (TestProtoServer . AProtoServerWithAuth SPXFTP <$> strP),
-      "/ntf test " *> (TestProtoServer . AProtoServerWithAuth SPNTF <$> strP),
       "/_servers " *> (APISetUserProtoServers <$> A.decimal <* A.space <*> srvCfgP),
       "/smp " *> (SetUserProtoServers . APSC SPSMP . ProtoServersConfig . map toServerCfg <$> protocolServersP),
       "/smp default" $> SetUserProtoServers (APSC SPSMP $ ProtoServersConfig []),
@@ -6874,14 +6790,6 @@ chatCommandP =
       logErrors <- " log=" *> onOffP <|> pure False
       let tcpTimeout = 1000000 * fromMaybe (maybe 5 (const 10) socksProxy) t_
       pure $ fullNetworkConfig socksProxy tcpTimeout logErrors
-    xftpCfgP = XFTPFileConfig <$> (" size=" *> fileSizeP <|> pure 0)
-    fileSizeP =
-      A.choice
-        [ gb <$> A.decimal <* "gb",
-          mb <$> A.decimal <* "mb",
-          kb <$> A.decimal <* "kb",
-          A.decimal
-        ]
     dbKeyP = nonEmptyKey <$?> strP
     nonEmptyKey k@(DBEncryptionKey s) = if BA.null s then Left "empty key" else Right k
     dbEncryptionConfig currentKey newKey = DBEncryptionConfig {currentKey, newKey, keepKey = Just False}

src/Simplex/Chat/Archive.hs

@@ -9,7 +9,6 @@ module Simplex.Chat.Archive
     importArchive,
     deleteStorage,
     sqlCipherExport,
-    sqlCipherTestKey,
     archiveFilesFolder,
   )
 where
@@ -21,7 +20,6 @@ import Control.Monad.Reader
 import qualified Data.ByteArray as BA
 import Data.Functor (($>))
 import Data.Maybe (fromMaybe)
-import Data.Text (Text)
 import qualified Data.Text as T
 import qualified Database.SQLite3 as SQL
 import Simplex.Chat.Controller
@@ -149,8 +147,19 @@ sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = D
       atomically $ writeTVar dbKey $ storeKey key' (fromMaybe False keepKey)
     export f = do
       withDB f (`SQL.exec` exportSQL) DBErrorExport
-      withDB (exported f) (`SQL.exec` testSQL key') DBErrorOpen
+      withDB (exported f) (`SQL.exec` testSQL) DBErrorOpen
       where
+        withDB f' a err =
+          liftIO (bracket (SQL.open $ T.pack f') SQL.close a $> Nothing)
+            `catch` checkSQLError
+            `catch` (\(e :: SomeException) -> sqliteError' e)
+            >>= mapM_ (throwDBError . err)
+          where
+            checkSQLError e = case SQL.sqlError e of
+              SQL.ErrorNotADatabase -> pure $ Just SQLiteErrorNotADatabase
+              _ -> sqliteError' e
+            sqliteError' :: Show e => e -> m (Maybe SQLiteError)
+            sqliteError' = pure . Just . SQLiteError . show
         exportSQL =
           T.unlines $
             keySQL key
@@ -158,38 +167,14 @@ sqlCipherExport DBEncryptionConfig {currentKey = DBEncryptionKey key, newKey = D
                    "SELECT sqlcipher_export('exported');",
                    "DETACH DATABASE exported;"
                  ]
-
-withDB :: forall a m. ChatMonad m => FilePath -> (SQL.Database -> IO a) -> (SQLiteError -> DatabaseError) -> m ()
-withDB f' a err =
-  liftIO (bracket (SQL.open $ T.pack f') SQL.close a $> Nothing)
-    `catch` checkSQLError
-    `catch` (\(e :: SomeException) -> sqliteError' e)
-    >>= mapM_ (throwDBError . err)
-  where
-    checkSQLError e = case SQL.sqlError e of
-      SQL.ErrorNotADatabase -> pure $ Just SQLiteErrorNotADatabase
-      _ -> sqliteError' e
-    sqliteError' :: Show e => e -> m (Maybe SQLiteError)
-    sqliteError' = pure . Just . SQLiteError . show
-
-testSQL :: BA.ScrubbedBytes -> Text
-testSQL k =
-  T.unlines $
-    keySQL k
-      <> [ "PRAGMA foreign_keys = ON;",
-            "PRAGMA secure_delete = ON;",
-            "SELECT count(*) FROM sqlite_master;"
-          ]
-
-keySQL :: BA.ScrubbedBytes -> [Text]
-keySQL k = ["PRAGMA key = " <> keyString k <> ";" | not (BA.null k)]
-
-sqlCipherTestKey :: forall m. ChatMonad m => DBEncryptionKey -> m ()
-sqlCipherTestKey (DBEncryptionKey key) = do
-  fs <- storageFiles
-  testKey `withDBs` fs
-  where
-    testKey f = withDB f (`SQL.exec` testSQL key) DBErrorOpen
+        testSQL =
+          T.unlines $
+            keySQL key'
+              <> [ "PRAGMA foreign_keys = ON;",
+                   "PRAGMA secure_delete = ON;",
+                   "SELECT count(*) FROM sqlite_master;"
+                 ]
+        keySQL k = ["PRAGMA key = " <> keyString k <> ";" | not (BA.null k)]
 
 withDBs :: Monad m => (FilePath -> m b) -> StorageFiles -> m b
 action `withDBs` StorageFiles {chatStore, agentStore} = action (dbFilePath chatStore) >> action (dbFilePath agentStore)

src/Simplex/Chat/Controller.hs

@@ -128,8 +128,6 @@ data ChatConfig = ChatConfig
     xftpDescrPartSize :: Int,
     inlineFiles :: InlineFilesConfig,
     autoAcceptFileSize :: Integer,
-    xftpFileConfig :: Maybe XFTPFileConfig, -- Nothing - XFTP is disabled
-    tempDir :: Maybe FilePath,
     showReactions :: Bool,
     showReceipts :: Bool,
     subscriptionEvents :: Bool,
@@ -204,7 +202,6 @@ data ChatController = ChatController
     timedItemThreads :: TMap (ChatRef, ChatItemId) (TVar (Maybe (Weak ThreadId))),
     showLiveItems :: TVar Bool,
     encryptLocalFiles :: TVar Bool,
-    userXFTPFileConfig :: TVar (Maybe XFTPFileConfig),
     tempDirectory :: TVar (Maybe FilePath),
     logFilePath :: Maybe FilePath,
     contactMergeEnabled :: TVar Bool
@@ -242,7 +239,6 @@ data ChatCommand
   | SetTempFolder FilePath
   | SetFilesFolder FilePath
   | SetRemoteHostsFolder FilePath
-  | APISetXFTPConfig (Maybe XFTPFileConfig)
   | APISetEncryptLocalFiles Bool
   | SetContactMergeEnabled Bool
   | APIExportArchive ArchiveConfig
@@ -250,7 +246,6 @@ data ChatCommand
   | APIImportArchive ArchiveConfig
   | APIDeleteStorage
   | APIStorageEncryption DBEncryptionConfig
-  | TestStorageEncryption DBEncryptionKey
   | ExecChatStoreSQL Text
   | ExecAgentStoreSQL Text
   | SlowSQLQueries
@@ -474,7 +469,6 @@ allowRemoteCommand = \case
   SetTempFolder _ -> False
   SetFilesFolder _ -> False
   SetRemoteHostsFolder _ -> False
-  APISetXFTPConfig _ -> False
   APISetEncryptLocalFiles _ -> False
   APIExportArchive _ -> False
   APIImportArchive _ -> False
@@ -673,7 +667,7 @@ data ChatResponse
   | CRUserContactLinkSubscribed -- TODO delete
   | CRUserContactLinkSubError {chatError :: ChatError} -- TODO delete
   | CRNtfTokenStatus {status :: NtfTknStatus}
-  | CRNtfToken {token :: DeviceToken, status :: NtfTknStatus, ntfMode :: NotificationsMode, ntfServer :: NtfServer}
+  | CRNtfToken {token :: DeviceToken, status :: NtfTknStatus, ntfMode :: NotificationsMode}
   | CRNtfMessages {user_ :: Maybe User, connEntity_ :: Maybe ConnectionEntity, msgTs :: Maybe UTCTime, ntfMessages :: [NtfMsgInfo]}
   | CRNtfMessage {user :: User, connEntity :: ConnectionEntity, ntfMessage :: NtfMsgInfo}
   | CRContactConnectionDeleted {user :: User, connection :: PendingContactConnection}
@@ -935,22 +929,14 @@ instance FromJSON ComposedMessage where
   parseJSON invalid =
     JT.prependFailure "bad ComposedMessage, " (JT.typeMismatch "Object" invalid)
 
-data XFTPFileConfig = XFTPFileConfig
-  { minFileSize :: Integer
-  }
-  deriving (Show)
-
-defaultXFTPFileConfig :: XFTPFileConfig
-defaultXFTPFileConfig = XFTPFileConfig {minFileSize = 0}
-
 data NtfMsgInfo = NtfMsgInfo {msgId :: Text, msgTs :: UTCTime}
   deriving (Show)
 
 ntfMsgInfo :: SMPMsgMeta -> NtfMsgInfo
 ntfMsgInfo SMPMsgMeta {msgId, msgTs} = NtfMsgInfo {msgId = decodeLatin1 $ strEncode msgId, msgTs = systemToUTCTime msgTs}
 
-crNtfToken :: (DeviceToken, NtfTknStatus, NotificationsMode, NtfServer) -> ChatResponse
-crNtfToken (token, status, ntfMode, ntfServer) = CRNtfToken {token, status, ntfMode, ntfServer}
+crNtfToken :: (DeviceToken, NtfTknStatus, NotificationsMode) -> ChatResponse
+crNtfToken (token, status, ntfMode) = CRNtfToken {token, status, ntfMode}
 
 data SwitchProgress = SwitchProgress
   { queueDirection :: QueueDirection,
@@ -1002,11 +988,6 @@ data CoreVersionInfo = CoreVersionInfo
   }
   deriving (Show)
 
-data SendFileMode
-  = SendFileSMP (Maybe InlineFileMode)
-  | SendFileXFTP
-  deriving (Show)
-
 data SlowSQLQuery = SlowSQLQuery
   { query :: Text,
     queryStats :: SlowQueryStats
@@ -1410,6 +1391,4 @@ $(JQ.deriveFromJSON defaultJSON ''ArchiveConfig)
 
 $(JQ.deriveFromJSON defaultJSON ''DBEncryptionConfig)
 
-$(JQ.deriveJSON defaultJSON ''XFTPFileConfig)
-
 $(JQ.deriveToJSON defaultJSON ''ComposedMessage)

src/Simplex/Chat/Markdown.hs

@@ -30,11 +30,10 @@ import qualified Data.Text as T
 import Data.Text.Encoding (encodeUtf8)
 import Simplex.Chat.Types
 import Simplex.Chat.Types.Util
-import Simplex.Messaging.Agent.Protocol (AConnectionRequestUri (..), ConnReqUriData (..), ConnectionRequestUri (..), SMPQueue (..))
+import Simplex.Messaging.Agent.Protocol (AConnectionRequestUri (..), ConnReqScheme (..), ConnReqUriData (..), ConnectionRequestUri (..), SMPQueue (..))
 import Simplex.Messaging.Encoding.String
 import Simplex.Messaging.Parsers (defaultJSON, dropPrefix, enumJSON, fstToLower, sumTypeJSON)
 import Simplex.Messaging.Protocol (ProtocolServer (..))
-import Simplex.Messaging.ServiceScheme (ServiceScheme (..))
 import Simplex.Messaging.Util (safeDecodeUtf8)
 import System.Console.ANSI.Types
 import qualified Text.Email.Validate as Email
@@ -232,10 +231,10 @@ markdownP = mconcat <$> A.many' fragmentP
     simplexUriFormat :: AConnectionRequestUri -> Format
     simplexUriFormat = \case
       ACR _ (CRContactUri crData) ->
-        let uri = safeDecodeUtf8 . strEncode $ CRContactUri crData {crScheme = SSSimplex}
+        let uri = safeDecodeUtf8 . strEncode $ CRContactUri crData {crScheme = CRSSimplex}
          in SimplexLink (linkType' crData) uri $ uriHosts crData
       ACR _ (CRInvitationUri crData e2e) ->
-        let uri = safeDecodeUtf8 . strEncode $ CRInvitationUri crData {crScheme = SSSimplex} e2e
+        let uri = safeDecodeUtf8 . strEncode $ CRInvitationUri crData {crScheme = CRSSimplex} e2e
          in SimplexLink XLInvitation uri $ uriHosts crData
       where
         uriHosts ConnReqUriData {crSmpQueues} = L.map (safeDecodeUtf8 . strEncode) $ sconcat $ L.map (host . qServer) crSmpQueues

src/Simplex/Chat/Store/Direct.hs

@@ -229,51 +229,45 @@ deleteContactConnectionsAndFiles db userId Contact {contactId} = do
     (userId, contactId)
   DB.execute db "DELETE FROM files WHERE user_id = ? AND contact_id = ?" (userId, contactId)
 
-deleteContact :: DB.Connection -> User -> Contact -> IO ()
-deleteContact db user@User {userId} Contact {contactId, localDisplayName, activeConn} = do
-  DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-  ctMember :: (Maybe ContactId) <- maybeFirstRow fromOnly $ DB.query db "SELECT contact_id FROM group_members WHERE user_id = ? AND contact_id = ? LIMIT 1" (userId, contactId)
-  if isNothing ctMember
-    then do
-      deleteContactProfile_ db userId contactId
-      DB.execute
-        db
-        [sql|
-          DELETE FROM display_names
-          WHERE user_id = ? AND local_display_name = ?
-            AND local_display_name NOT IN (SELECT local_display_name FROM users)
-        |]
-        (userId, localDisplayName)
-    else do
-      currentTs <- getCurrentTime
-      DB.execute db "UPDATE group_members SET contact_id = NULL, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
-  DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ? AND is_user = 0" (userId, contactId)
-  forM_ activeConn $ \Connection {customUserProfileId} ->
-    forM_ customUserProfileId $ \profileId ->
-      deleteUnusedIncognitoProfileById_ db user profileId
+deleteContact :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
+deleteContact db user@User {userId} ct@Contact {contactId, localDisplayName, activeConn} = do
+  assertNotUser db user ct
+  liftIO $ do
+    DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+    ctMember :: (Maybe ContactId) <- maybeFirstRow fromOnly $ DB.query db "SELECT contact_id FROM group_members WHERE user_id = ? AND contact_id = ? LIMIT 1" (userId, contactId)
+    if isNothing ctMember
+      then do
+        deleteContactProfile_ db userId contactId
+        -- user's local display name already checked in assertNotUser
+        DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
+      else do
+        currentTs <- getCurrentTime
+        DB.execute db "UPDATE group_members SET contact_id = NULL, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
+    DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+    forM_ activeConn $ \Connection {customUserProfileId} ->
+      forM_ customUserProfileId $ \profileId ->
+        deleteUnusedIncognitoProfileById_ db user profileId
 
 -- should only be used if contact is not member of any groups
-deleteContactWithoutGroups :: DB.Connection -> User -> Contact -> IO ()
-deleteContactWithoutGroups db user@User {userId} Contact {contactId, localDisplayName, activeConn} = do
-  DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
-  deleteContactProfile_ db userId contactId
-  DB.execute
-    db
-    [sql|
-      DELETE FROM display_names
-      WHERE user_id = ? AND local_display_name = ?
-        AND local_display_name NOT IN (SELECT local_display_name FROM users)
-    |]
-    (userId, localDisplayName)
-  DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ? AND is_user = 0" (userId, contactId)
-  forM_ activeConn $ \Connection {customUserProfileId} ->
-    forM_ customUserProfileId $ \profileId ->
-      deleteUnusedIncognitoProfileById_ db user profileId
+deleteContactWithoutGroups :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
+deleteContactWithoutGroups db user@User {userId} ct@Contact {contactId, localDisplayName, activeConn} = do
+  assertNotUser db user ct
+  liftIO $ do
+    DB.execute db "DELETE FROM chat_items WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+    deleteContactProfile_ db userId contactId
+    -- user's local display name already checked in assertNotUser
+    DB.execute db "DELETE FROM display_names WHERE user_id = ? AND local_display_name = ?" (userId, localDisplayName)
+    DB.execute db "DELETE FROM contacts WHERE user_id = ? AND contact_id = ?" (userId, contactId)
+    forM_ activeConn $ \Connection {customUserProfileId} ->
+      forM_ customUserProfileId $ \profileId ->
+        deleteUnusedIncognitoProfileById_ db user profileId
 
-setContactDeleted :: DB.Connection -> User -> Contact -> IO ()
-setContactDeleted db User {userId} Contact {contactId} = do
-  currentTs <- getCurrentTime
-  DB.execute db "UPDATE contacts SET deleted = 1, updated_at = ? WHERE user_id = ? AND contact_id = ? AND is_user = 0" (currentTs, userId, contactId)
+setContactDeleted :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
+setContactDeleted db user@User {userId} ct@Contact {contactId} = do
+  assertNotUser db user ct
+  liftIO $ do
+    currentTs <- getCurrentTime
+    DB.execute db "UPDATE contacts SET deleted = 1, updated_at = ? WHERE user_id = ? AND contact_id = ?" (currentTs, userId, contactId)
 
 getDeletedContacts :: DB.Connection -> User -> IO [Contact]
 getDeletedContacts db user@User {userId} = do
@@ -334,7 +328,7 @@ updateContactProfile db user@User {userId} c p'
       ExceptT . withLocalDisplayName db userId newName $ \ldn -> do
         currentTs <- getCurrentTime
         updateContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db userId contactId localDisplayName ldn currentTs
+        updateContactLDN_ db user contactId localDisplayName ldn currentTs
         pure $ Right c {localDisplayName = ldn, profile, mergedPreferences}
   where
     Contact {contactId, localDisplayName, profile = LocalProfile {profileId, displayName, localAlias}, userPreferences} = c
@@ -505,8 +499,8 @@ updateMemberContactProfile_' db userId profileId Profile {displayName, fullName,
     |]
     (displayName, fullName, image, updatedAt, userId, profileId)
 
-updateContactLDN_ :: DB.Connection -> UserId -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
-updateContactLDN_ db userId contactId displayName newName updatedAt = do
+updateContactLDN_ :: DB.Connection -> User -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
+updateContactLDN_ db user@User {userId} contactId displayName newName updatedAt = do
   DB.execute
     db
     "UPDATE contacts SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
@@ -515,14 +509,7 @@ updateContactLDN_ db userId contactId displayName newName updatedAt = do
     db
     "UPDATE group_members SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
     (newName, updatedAt, userId, contactId)
-  DB.execute
-    db
-    [sql|
-      DELETE FROM display_names
-      WHERE local_display_name = ? AND user_id = ?
-        AND local_display_name NOT IN (SELECT local_display_name FROM users)
-    |]
-    (displayName, userId)
+  safeDeleteLDN db user displayName
 
 getContactByName :: DB.Connection -> User -> ContactName -> ExceptT StoreError IO Contact
 getContactByName db user localDisplayName = do
@@ -635,14 +622,7 @@ createOrUpdateContactRequest db user@User {userId} userContactLinkId invId (Vers
                 WHERE user_id = ? AND contact_request_id = ?
               |]
               (invId, minV, maxV, ldn, currentTs, userId, cReqId)
-            DB.execute
-              db
-              [sql|
-                DELETE FROM display_names
-                WHERE local_display_name = ? AND user_id = ?
-                  AND local_display_name NOT IN (SELECT local_display_name FROM users)
-              |]
-              (oldLdn, userId)
+            safeDeleteLDN db user oldLdn
       where
         updateProfile currentTs =
           DB.execute
@@ -712,9 +692,9 @@ deleteContactRequest db User {userId} contactRequestId = do
         SELECT local_display_name FROM contact_requests
         WHERE user_id = ? AND contact_request_id = ?
       )
-      AND local_display_name NOT IN (SELECT local_display_name FROM users)
+      AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
     |]
-    (userId, userId, contactRequestId)
+    (userId, userId, contactRequestId, userId)
   DB.execute db "DELETE FROM contact_requests WHERE user_id = ? AND contact_request_id = ?" (userId, contactRequestId)
 
 createAcceptedContact :: DB.Connection -> User -> ConnId -> VersionRange -> ContactName -> ProfileId -> Profile -> Int64 -> Maybe XContactId -> Maybe IncognitoProfile -> SubscriptionMode -> Bool -> IO Contact

src/Simplex/Chat/Store/Files.hs

@@ -14,7 +14,6 @@ module Simplex.Chat.Store.Files
   ( getLiveSndFileTransfers,
     getLiveRcvFileTransfers,
     getPendingSndChunks,
-    createSndDirectFileTransfer,
     createSndDirectFTConnection,
     createSndGroupFileTransfer,
     createSndGroupFileTransferConnection,
@@ -169,23 +168,6 @@ getPendingSndChunks db fileId connId =
       |]
       (fileId, connId)
 
-createSndDirectFileTransfer :: DB.Connection -> UserId -> Contact -> FilePath -> FileInvitation -> Maybe ConnId -> Integer -> SubscriptionMode -> IO FileTransferMeta
-createSndDirectFileTransfer db userId Contact {contactId} filePath FileInvitation {fileName, fileSize, fileInline} acId_ chunkSize subMode = do
-  currentTs <- getCurrentTime
-  DB.execute
-    db
-    "INSERT INTO files (user_id, contact_id, file_name, file_path, file_size, chunk_size, file_inline, ci_file_status, protocol, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)"
-    ((userId, contactId, fileName, filePath, fileSize, chunkSize) :. (fileInline, CIFSSndStored, FPSMP, currentTs, currentTs))
-  fileId <- insertedRowId db
-  forM_ acId_ $ \acId -> do
-    Connection {connId} <- createSndFileConnection_ db userId fileId acId subMode
-    let fileStatus = FSNew
-    DB.execute
-      db
-      "INSERT INTO snd_files (file_id, file_status, file_inline, connection_id, created_at, updated_at) VALUES (?,?,?,?,?,?)"
-      (fileId, fileStatus, fileInline, connId, currentTs, currentTs)
-  pure FileTransferMeta {fileId, xftpSndFile = Nothing, fileName, filePath, fileSize, fileInline, chunkSize, cancelled = False}
-
 createSndDirectFTConnection :: DB.Connection -> User -> Int64 -> (CommandId, ConnId) -> SubscriptionMode -> IO ()
 createSndDirectFTConnection db user@User {userId} fileId (cmdId, acId) subMode = do
   currentTs <- getCurrentTime

src/Simplex/Chat/Store/Groups.hs

@@ -225,9 +225,9 @@ deleteGroupLink db User {userId} GroupInfo {groupId} = do
           JOIN user_contact_links uc USING (user_contact_link_id)
           WHERE uc.user_id = ? AND uc.group_id = ?
         )
-        AND local_display_name NOT IN (SELECT local_display_name FROM users)
+        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
     |]
-    (userId, userId, groupId)
+    (userId, userId, groupId, userId)
   DB.execute
     db
     [sql|
@@ -587,14 +587,7 @@ deleteGroup :: DB.Connection -> User -> GroupInfo -> IO ()
 deleteGroup db user@User {userId} g@GroupInfo {groupId, localDisplayName} = do
   deleteGroupProfile_ db userId groupId
   DB.execute db "DELETE FROM groups WHERE user_id = ? AND group_id = ?" (userId, groupId)
-  DB.execute
-    db
-    [sql|
-      DELETE FROM display_names
-      WHERE user_id = ? AND local_display_name = ?
-        AND local_display_name NOT IN (SELECT local_display_name FROM users)
-    |]
-    (userId, localDisplayName)
+  safeDeleteLDN db user localDisplayName
   forM_ (incognitoMembershipProfile g) $ deleteUnusedIncognitoProfileById_ db user . localProfileId
 
 deleteGroupProfile_ :: DB.Connection -> UserId -> GroupId -> IO ()
@@ -1052,21 +1045,14 @@ deleteGroupMember db user@User {userId} m@GroupMember {groupMemberId, groupId, m
   when (memberIncognito m) $ deleteUnusedIncognitoProfileById_ db user $ localProfileId memberProfile
 
 cleanupMemberProfileAndName_ :: DB.Connection -> User -> GroupMember -> IO ()
-cleanupMemberProfileAndName_ db User {userId} GroupMember {groupMemberId, memberContactId, memberContactProfileId, localDisplayName} =
+cleanupMemberProfileAndName_ db user@User {userId} GroupMember {groupMemberId, memberContactId, memberContactProfileId, localDisplayName} =
   -- check record has no memberContactId (contact_id) - it means contact has been deleted and doesn't use profile & ldn
   when (isNothing memberContactId) $ do
     -- check other group member records don't use profile & ldn
     sameProfileMember :: (Maybe GroupMemberId) <- maybeFirstRow fromOnly $ DB.query db "SELECT group_member_id FROM group_members WHERE user_id = ? AND contact_profile_id = ? AND group_member_id != ? LIMIT 1" (userId, memberContactProfileId, groupMemberId)
     when (isNothing sameProfileMember) $ do
       DB.execute db "DELETE FROM contact_profiles WHERE user_id = ? AND contact_profile_id = ?" (userId, memberContactProfileId)
-      DB.execute
-        db
-        [sql|
-          DELETE FROM display_names
-          WHERE user_id = ? AND local_display_name = ?
-            AND local_display_name NOT IN (SELECT local_display_name FROM users)
-        |]
-        (userId, localDisplayName)
+      safeDeleteLDN db user localDisplayName
 
 deleteGroupMemberConnection :: DB.Connection -> User -> GroupMember -> IO ()
 deleteGroupMemberConnection db User {userId} GroupMember {groupMemberId} =
@@ -1345,7 +1331,7 @@ getViaGroupContact db user@User {userId} GroupMember {groupMemberId} = do
   maybe (pure Nothing) (fmap eitherToMaybe . runExceptT . getContact db user) contactId_
 
 updateGroupProfile :: DB.Connection -> User -> GroupInfo -> GroupProfile -> ExceptT StoreError IO GroupInfo
-updateGroupProfile db User {userId} g@GroupInfo {groupId, localDisplayName, groupProfile = GroupProfile {displayName}} p'@GroupProfile {displayName = newName, fullName, description, image, groupPreferences}
+updateGroupProfile db user@User {userId} g@GroupInfo {groupId, localDisplayName, groupProfile = GroupProfile {displayName}} p'@GroupProfile {displayName = newName, fullName, description, image, groupPreferences}
   | displayName == newName = liftIO $ do
       currentTs <- getCurrentTime
       updateGroupProfile_ currentTs
@@ -1376,14 +1362,7 @@ updateGroupProfile db User {userId} g@GroupInfo {groupId, localDisplayName, grou
         db
         "UPDATE groups SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND group_id = ?"
         (ldn, currentTs, userId, groupId)
-      DB.execute
-        db
-        [sql|
-          DELETE FROM display_names
-          WHERE local_display_name = ? AND user_id = ?
-            AND local_display_name NOT IN (SELECT local_display_name FROM users)
-        |]
-        (localDisplayName, userId)
+      safeDeleteLDN db user localDisplayName
 
 getGroupInfo :: DB.Connection -> VersionRange -> User -> Int64 -> ExceptT StoreError IO GroupInfo
 getGroupInfo db vr User {userId, userContactId} groupId =
@@ -1637,6 +1616,8 @@ mergeContactRecords db user@User {userId} to@Contact {localDisplayName = keepLDN
   let (toCt, fromCt) = toFromContacts to from
       Contact {contactId = toContactId, localDisplayName = toLDN} = toCt
       Contact {contactId = fromContactId, localDisplayName = fromLDN} = fromCt
+  assertNotUser db user toCt
+  assertNotUser db user fromCt
   liftIO $ do
     currentTs <- getCurrentTime
     -- next query fixes incorrect unused contacts deletion
@@ -1678,7 +1659,7 @@ mergeContactRecords db user@User {userId} to@Contact {localDisplayName = keepLDN
         ":updated_at" := currentTs
       ]
     deleteContactProfile_ db userId fromContactId
-    DB.execute db "DELETE FROM contacts WHERE contact_id = ? AND user_id = ? AND is_user = 0" (fromContactId, userId)
+    DB.execute db "DELETE FROM contacts WHERE contact_id = ? AND user_id = ?" (fromContactId, userId)
     deleteUnusedDisplayName_ db userId fromLDN
     when (keepLDN /= toLDN && keepLDN == fromLDN) $
       DB.execute
@@ -2040,7 +2021,7 @@ createMemberContactConn_
     pure Connection {connId, agentConnId = AgentConnId acId, peerChatVRange, connType = ConnContact, contactConnInitiated = False, entityId = Just contactId, viaContact = Nothing, viaUserContactLink = Nothing, viaGroupLink = False, groupLinkId = Nothing, customUserProfileId, connLevel, connStatus = ConnJoined, localAlias = "", createdAt = currentTs, connectionCode = Nothing, authErrCounter = 0}
 
 updateMemberProfile :: DB.Connection -> User -> GroupMember -> Profile -> ExceptT StoreError IO GroupMember
-updateMemberProfile db User {userId} m p'
+updateMemberProfile db user@User {userId} m p'
   | displayName == newName = do
       liftIO $ updateMemberContactProfileReset_ db userId profileId p'
       pure m {memberProfile = profile}
@@ -2052,14 +2033,7 @@ updateMemberProfile db User {userId} m p'
           db
           "UPDATE group_members SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND group_member_id = ?"
           (ldn, currentTs, userId, groupMemberId)
-        DB.execute
-          db
-          [sql|
-            DELETE FROM display_names
-            WHERE local_display_name = ? AND user_id = ?
-              AND local_display_name NOT IN (SELECT local_display_name FROM users)
-          |]
-          (localDisplayName, userId)
+        safeDeleteLDN db user localDisplayName
         pure $ Right m {localDisplayName = ldn, memberProfile = profile}
   where
     GroupMember {groupMemberId, localDisplayName, memberProfile = LocalProfile {profileId, displayName, localAlias}} = m
@@ -2067,7 +2041,7 @@ updateMemberProfile db User {userId} m p'
     profile = toLocalProfile profileId p' localAlias
 
 updateContactMemberProfile :: DB.Connection -> User -> GroupMember -> Contact -> Profile -> ExceptT StoreError IO (GroupMember, Contact)
-updateContactMemberProfile db User {userId} m ct@Contact {contactId} p'
+updateContactMemberProfile db user@User {userId} m ct@Contact {contactId} p'
   | displayName == newName = do
       liftIO $ updateMemberContactProfile_ db userId profileId p'
       pure (m {memberProfile = profile}, ct {profile} :: Contact)
@@ -2075,7 +2049,7 @@ updateContactMemberProfile db User {userId} m ct@Contact {contactId} p'
       ExceptT . withLocalDisplayName db userId newName $ \ldn -> do
         currentTs <- getCurrentTime
         updateMemberContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db userId contactId localDisplayName ldn currentTs
+        updateContactLDN_ db user contactId localDisplayName ldn currentTs
         pure $ Right (m {localDisplayName = ldn, memberProfile = profile}, ct {localDisplayName = ldn, profile} :: Contact)
   where
     GroupMember {localDisplayName, memberProfile = LocalProfile {profileId, displayName, localAlias}} = m

src/Simplex/Chat/Store/Profiles.hs

@@ -267,7 +267,7 @@ updateUserProfile db user p'
           "INSERT INTO display_names (local_display_name, ldn_base, user_id, created_at, updated_at) VALUES (?,?,?,?,?)"
           (newName, newName, userId, currentTs, currentTs)
         updateContactProfile_' db userId profileId p' currentTs
-        updateContactLDN_ db userId userContactId localDisplayName newName currentTs
+        updateContactLDN_ db user userContactId localDisplayName newName currentTs
         pure user {localDisplayName = newName, profile, fullPreferences, userMemberProfileUpdatedAt = userMemberProfileUpdatedAt'}
   where
     updateUserMemberProfileUpdatedAt_ currentTs
@@ -388,7 +388,7 @@ deleteUserAddress db user@User {userId} = do
           JOIN user_contact_links uc USING (user_contact_link_id)
           WHERE uc.user_id = :user_id AND uc.local_display_name = '' AND uc.group_id IS NULL
         )
-        AND local_display_name NOT IN (SELECT local_display_name FROM users)
+        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = :user_id)
     |]
     [":user_id" := userId]
   DB.executeNamed

src/Simplex/Chat/Store/Shared.hs

@@ -110,6 +110,7 @@ data StoreError
   | SERemoteHostDuplicateCA
   | SERemoteCtrlNotFound {remoteCtrlId :: RemoteCtrlId}
   | SERemoteCtrlDuplicateCA
+  | SEProhibitedDeleteUser {userId :: UserId, contactId :: ContactId}
   deriving (Show, Exception)
 
 $(J.deriveJSON (sumTypeJSON $ dropPrefix "SE") ''StoreError)
@@ -401,3 +402,33 @@ createWithRandomBytes' size gVar create = tryCreate 3
 
 encodedRandomBytes :: TVar ChaChaDRG -> Int -> IO ByteString
 encodedRandomBytes gVar n = atomically $ B64.encode <$> C.randomBytes n gVar
+
+assertNotUser :: DB.Connection -> User -> Contact -> ExceptT StoreError IO ()
+assertNotUser db User {userId} Contact {contactId, localDisplayName} = do
+  r :: (Maybe Int64) <-
+    -- This query checks that the foreign keys in the users table
+    -- are not referencing the contact about to be deleted.
+    -- With the current schema it would cause cascade delete of user,
+    -- with mofified schema (in v5.6.0-beta.0) it would cause foreign key violation error.
+    liftIO . maybeFirstRow fromOnly $
+      DB.query
+        db
+        [sql|
+          SELECT 1 FROM users
+          WHERE (user_id = ? AND local_display_name = ?)
+             OR contact_id = ?
+          LIMIT 1
+        |]
+        (userId, localDisplayName, contactId)
+  when (isJust r) $ throwError $ SEProhibitedDeleteUser userId contactId
+
+safeDeleteLDN :: DB.Connection -> User -> ContactName -> IO ()
+safeDeleteLDN db User {userId} localDisplayName = do
+  DB.execute
+    db
+    [sql|
+      DELETE FROM display_names
+      WHERE user_id = ? AND local_display_name = ?
+        AND local_display_name NOT IN (SELECT local_display_name FROM users WHERE user_id = ?)
+    |]
+    (userId, localDisplayName, userId)

src/Simplex/Chat/View.hs

@@ -283,7 +283,7 @@ responseToView hu@(currentRH, user_) ChatConfig {logLevel, showReactions, showRe
   CRUserContactLinkSubError e -> ["user address error: " <> sShow e, "to delete your address: " <> highlight' "/da"]
   CRContactConnectionDeleted u PendingContactConnection {pccConnId} -> ttyUser u ["connection :" <> sShow pccConnId <> " deleted"]
   CRNtfTokenStatus status -> ["device token status: " <> plain (smpEncode status)]
-  CRNtfToken _ status mode srv -> ["device token status: " <> plain (smpEncode status) <> ", notifications mode: " <> plain (strEncode mode) <> ", server: " <> sShow srv]
+  CRNtfToken _ status mode -> ["device token status: " <> plain (smpEncode status) <> ", notifications mode: " <> plain (strEncode mode)]
   CRNtfMessages {} -> []
   CRNtfMessage {} -> []
   CRCurrentRemoteHost rhi_ ->

tests/ChatClient.hs

@@ -15,6 +15,7 @@ import Control.Concurrent.STM
 import Control.Exception (bracket, bracket_)
 import Control.Monad
 import Control.Monad.Except
+import Control.Monad.Reader
 import Data.ByteArray (ScrubbedBytes)
 import Data.Functor (($>))
 import Data.List (dropWhileEnd, find)
@@ -22,7 +23,7 @@ import Data.Maybe (isNothing)
 import qualified Data.Text as T
 import Network.Socket
 import Simplex.Chat
-import Simplex.Chat.Controller (ChatConfig (..), ChatController (..), ChatDatabase (..), ChatLogLevel (..))
+import Simplex.Chat.Controller (ChatCommand (..), ChatConfig (..), ChatController (..), ChatDatabase (..), ChatLogLevel (..))
 import Simplex.Chat.Core
 import Simplex.Chat.Options
 import Simplex.Chat.Store
@@ -129,8 +130,7 @@ testCfg =
     { agentConfig = testAgentCfg,
       showReceipts = False,
       testView = True,
-      tbqSize = 16,
-      xftpFileConfig = Nothing
+      tbqSize = 16
     }
 
 testAgentCfgVPrev :: AgentConfig
@@ -146,9 +146,9 @@ testAgentCfgV1 :: AgentConfig
 testAgentCfgV1 =
   testAgentCfg
     { smpClientVRange = v1Range,
-      smpAgentVRange = versionToRange 2, -- duplexHandshakeSMPAgentVersion,
-      e2eEncryptVRange = versionToRange 2, -- kdfX3DHE2EEncryptVersion,
-      smpCfg = (smpCfg testAgentCfg) {serverVRange = versionToRange 4} -- batchCmdsSMPVersion
+      smpAgentVRange = v1Range,
+      e2eEncryptVRange = v1Range,
+      smpCfg = (smpCfg testAgentCfg) {serverVRange = v1Range}
     }
 
 testCfgVPrev :: ChatConfig
@@ -166,7 +166,7 @@ testCfgV1 =
     }
 
 prevRange :: VersionRange -> VersionRange
-prevRange vr = vr {maxVersion = max (minVersion vr) (maxVersion vr - 1)}
+prevRange vr = vr {maxVersion = maxVersion vr - 1}
 
 v1Range :: VersionRange
 v1Range = mkVersionRange 1 1
@@ -209,6 +209,7 @@ startTestChat_ db cfg opts user = do
   t <- withVirtualTerminal termSettings pure
   ct <- newChatTerminal t opts
   cc <- newChatController db (Just user) cfg opts False
+  void $ execChatCommand' (SetTempFolder "tests/tmp/tmp") `runReaderT` cc
   chatAsync <- async . runSimplexChat opts user cc $ \_u cc' -> runChatTerminal ct cc' opts
   atomically . unless (maintenance opts) $ readTVar (agentAsync cc) >>= \a -> when (isNothing a) retry
   termQ <- newTQueueIO
@@ -384,7 +385,7 @@ serverCfg =
       logStatsStartTime = 0,
       serverStatsLogFile = "tests/smp-server-stats.daily.log",
       serverStatsBackupFile = Nothing,
-      smpServerVRange = supportedServerSMPRelayVRange,
+      smpServerVRange = supportedSMPServerVRange,
       transportConfig = defaultTransportServerConfig,
       smpHandshakeTimeout = 1000000,
       controlPort = Nothing
@@ -407,7 +408,7 @@ xftpServerConfig =
       storeLogFile = Just "tests/tmp/xftp-server-store.log",
       filesPath = xftpServerFiles,
       fileSizeQuota = Nothing,
-      allowedChunkSizes = [kb 64, kb 128, kb 256, mb 1, mb 4],
+      allowedChunkSizes = [kb 128, kb 256, mb 1, mb 4],
       allowNewFiles = True,
       newFileBasicAuth = Nothing,
       fileExpiration = Just defaultFileExpiration,

tests/ChatTests/Direct.hs

@@ -1067,7 +1067,7 @@ testChatWorking alice bob = do
   alice <# "bob> hello too"
 
 testMaintenanceModeWithFiles :: HasCallStack => FilePath -> IO ()
-testMaintenanceModeWithFiles tmp = do
+testMaintenanceModeWithFiles tmp = withXFTPServer $ do
   withNewTestChat tmp "bob" bobProfile $ \bob -> do
     withNewTestChatOpts tmp testOpts {maintenance = True} "alice" aliceProfile $ \alice -> do
       alice ##> "/_start"
@@ -1075,12 +1075,26 @@ testMaintenanceModeWithFiles tmp = do
       alice ##> "/_files_folder ./tests/tmp/alice_files"
       alice <## "ok"
       connectUsers alice bob
-      startFileTransferWithDest' bob alice "test.jpg" "136.5 KiB / 139737 bytes" Nothing
-      bob <## "completed sending file 1 (test.jpg) to alice"
+
+      bob #> "/f @alice ./tests/fixtures/test.jpg"
+      bob <## "use /fc 1 to cancel sending"
+      alice <# "bob> sends file test.jpg (136.5 KiB / 139737 bytes)"
+      alice <## "use /fr 1 [<dir>/ | <path>] to receive it"
+      bob <## "completed uploading file 1 (test.jpg) for alice"
+
+      alice ##> "/fr 1"
+      alice
+        <### [ "saving file 1 from bob to test.jpg",
+               "started receiving file 1 (test.jpg) from bob"
+             ]
       alice <## "completed receiving file 1 (test.jpg) from bob"
+
       src <- B.readFile "./tests/fixtures/test.jpg"
-      B.readFile "./tests/tmp/alice_files/test.jpg" `shouldReturn` src
+      dest <- B.readFile "./tests/tmp/alice_files/test.jpg"
+      dest `shouldBe` src
+
       threadDelay 500000
+
       alice ##> "/_stop"
       alice <## "chat stopped"
       alice ##> "/_db export {\"archivePath\": \"./tests/tmp/alice-chat.zip\"}"
@@ -1124,10 +1138,6 @@ testDatabaseEncryption tmp = do
       testChatWorking alice bob
       alice ##> "/_stop"
       alice <## "chat stopped"
-      alice ##> "/db test key wrongkey"
-      alice <## "error opening database after encryption: wrong passphrase or invalid database file"
-      alice ##> "/db test key mykey"
-      alice <## "ok"
       alice ##> "/db key wrongkey nextkey"
       alice <## "error encrypting database: wrong passphrase or invalid database file"
       alice ##> "/db key mykey nextkey"