ios: events ordering

PRIVACY.md

@@ -1,168 +1,134 @@
-# SimpleX Chat Privacy Policy and Conditions of Use
+# SimpleX Chat Terms & Privacy Policy
 
-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.
+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 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).
+If you believe that some of the clauses in this document are not aligned with our mission or principles, please raise it with us via [email](chat@simplex.chat) or [chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion).
 
 ## Privacy Policy
 
-SimpleX Chat Ltd 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 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 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 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 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.
+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).
 
-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
+### Information you provide
 
 #### User profiles
 
-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.
+We do not store user profiles. The profile you create in the app is local to your device.
 
-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.
+When you create a user profile, no records are created on our servers, and we have no access to any part of your profile information, and even to the fact that you created a profile - it is a local record stored only on your device. That means that if you delete the app, and have no backup, you will permanently lose all the data and the private connections you create with other users.
 
 #### Messages and Files
 
-SimpleX 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.
+SimpleX Chat cannot decrypt or otherwise access the content or even the size of your messages and files you send or receive. Each message is padded to a fixed size of 16kb. Each file is sent in chunks of 256kb, 1mb or 8mb via all or some of the configured file servers. Both messages and files are sent end-to-end encrypted, and the servers do not have technical means to compromise this encryption, because part of the [key exchange](./docs/GLOSSARY.md#key-exchange) happens out-of-band.
 
-Your message history is stored only on your own device and the devices of your contacts. While the recipients' devices are offline, 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.
+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.
 
-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 messages are permanently removed from the preset servers as soon as they are delivered. Undelivered messages are deleted after the time that is configured in the messaging servers you use (21 days for preset messaging servers).
 
-The 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).
+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 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.
+If a messaging or file servers are restarted, the encrypted message or the record of the file can be stored in a backup file until it is overwritten by the next restart (usually within 1 week).
 
 #### Connections with other users
 
-When you create a connection with another user, two messaging queues (you can think about them as 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.
+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.
 
-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.
+At the time of updating this document all our client applications allow configuring the servers. Our servers do not store information about which queues are linked to your profile on the device, and they do not collect any information that would allow us to establish that these queues are related to your device or your profile - the access to each queue is authorized by two anonymous unique cryptographic keys, different for each queue, and separate for sender and recipient of the messages.
 
 #### iOS Push Notifications
 
 When you choose to use instant push notifications in SimpleX iOS app, because the design of push notifications requires storing the device token on notification server, the notifications server can observe how many messaging queues your device has notifications enabled for, and approximately how many messages are sent to each queue.
 
-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.
+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.
 
-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).
+It also does not allow to see message content or sizes, as the actual messages are not sent via the notification server, only the fact that the message is available and where it can be received from (the latter information is encrypted, so that the notification server cannot observe it). You can read more about the design of iOS push notifications [here](https://simplex.chat/blog/20220404-simplex-chat-instant-notifications.html#our-ios-approach-has-one-trade-off).
 
 #### Another information stored on the servers
 
-Additional technical information can be stored on our servers, including randomly generated authentication tokens, keys, push tokens, and other material that is necessary to transmit messages. SimpleX Chat 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.
+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.
 
-#### SimpleX Directory
+#### SimpleX Directory Service
 
-[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).
+[SimpleX directory service](./docs/DIRECTORY.md) stores: your search requests, the messages and the members profiles in the group. You can connect to SimpleX Directory Service via [this address](https://simplex.chat/contact#/?v=1-4&smp=smp%3A%2F%2Fu2dS9sG8nMNURyZwqASV4yROM28Er0luVTx5X1CsMrU%3D%40smp4.simplex.im%2FeXSPwqTkKyDO3px4fLf1wx3MvPdjdLW3%23%2F%3Fv%3D1-2%26dh%3DMCowBQYDK2VuAyEAaiv6MkMH44L2TcYrt_CsX3ZvM11WgbMEUn0hkIKTOho%253D%26srv%3Do5vmywmrnaxalvz6wi3zicyftgio6psuvyniis6gco6bp6ekl4cqj4id.onion).
 
-#### User Support
+#### User Support.
 
-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.
+If you contact SimpleX Chat any personal data you may share with us is kept only for the purposes of researching the issue and contacting you about your case. We recommend contacting support [via chat](https://simplex.chat/contact#/?v=1&smp=smp%3A%2F%2FPQUV2eL0t7OStZOoAsPEV2QYWt4-xilbakvGUGOItUo%3D%40smp6.simplex.im%2FK1rslx-m5bpXVIdMZg9NLUZ_8JBm8xTt%23%2F%3Fv%3D1%26dh%3DMCowBQYDK2VuAyEALDeVe-sG8mRY22LsXlPgiwTNs9dbiLrNuA7f3ZMAJ2w%253D%26srv%3Dbylepyau3ty4czmn77q4fglvperknl4bi2eb2fdy2bh4jxtf32kf73yd.onion), when it is possible.
 
 ### Information we may share
 
-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 operate our Services using third parties. While we do not share any user data, these third party may access the encrypted user data as it is stored or transmitted via our servers.
 
-We use 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).
+We use a third party for email services - if you ask for support via email, your and SimpleX Chat email providers may access these emails according to their privacy policies and terms of service.
 
-The cases when SimpleX Chat Ltd may share the data temporarily stored on the servers:
+The cases when SimpleX Chat may need to share the data we temporarily store on the servers:
 
-- To meet any applicable law, or enforceable governmental request or court order.
-- To enforce applicable terms, including investigation of potential violations.
+- To meet any applicable law, regulation, legal process or enforceable governmental request.
+- 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 software users, SimpleX Chat Ltd, or the public as required or permitted by law.
+- To protect against harm to the rights, property, or safety of SimpleX Chat, our users, or the public as required or permitted by law.
 
-At the time of updating this document, we have never provided or have been requested the access to 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.
+At the time of updating this document, we have never provided or have been requested the access to our servers or any information from our servers by any third parties. If we are ever requested to provide such access or information, we will follow the due legal process.
 
 ### Updates
 
-We will update this Privacy Policy as needed so that it is current, accurate, and as clear as possible. Your continued use of our software applications and preset relays infrastructure confirms your acceptance of our updated Privacy Policy.
+We will update this Privacy Policy as needed so that it is current, accurate, and as clear as possible. Your continued use of our Services confirms your acceptance of our updated Privacy Policy.
 
-Please also read our Conditions of Use of Software and Infrastructure below.
+Please also read our Terms of Service 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).
 
-## Conditions of Use of Software and Infrastructure
+## Terms of Service
 
-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.
+You accept our Terms of Service ("Terms") by installing or using any of our apps or services ("Services").
 
-**Minimal age**. You must be at least 13 years old to use our Applications. The minimum age to use our Applications without parental approval may be higher in your country.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**Traffic and device costs**. You are solely responsible for the traffic and device costs on which you use our Services, and any associated taxes.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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 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.
 
-**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.
+**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.
 
-**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.
+**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 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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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)
 
-**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.
+**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.
 
-**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).
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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.
+**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.
 
-**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
+Updated August 17, 2023

README.md

@@ -234,8 +234,6 @@ You can use SimpleX with your own servers and still communicate with people usin
 
 Recent and important updates:
 
-[Jan 24, 2024. SimpleX Chat: free infrastructure from Linode, v5.5 released with private notes, group history and a simpler UX to connect.](./blog/20240124-simplex-chat-infrastructure-costs-v5-5-simplex-ux-private-notes-group-history.md)
-
 [Nov 25, 2023. SimpleX Chat v5.4 released: link mobile and desktop apps via quantum resistant protocol, and much better groups](./blog/20231125-simplex-chat-v5-4-link-mobile-desktop-quantum-resistant-better-groups.md).
 
 [Sep 25, 2023. SimpleX Chat v5.3 released: desktop app, local file encryption, improved groups and directory service](./blog/20230925-simplex-chat-v5-3-desktop-app-local-file-encryption-directory-service.md).
@@ -301,7 +299,7 @@ What is already implemented:
 11. Transport isolation - different TCP connections and Tor circuits are used for traffic of different user profiles, optionally - for different contacts and group member connections.
 12. Manual messaging queue rotations to move conversation to another SMP relay.
 13. Sending end-to-end encrypted files using [XFTP protocol](https://simplex.chat/blog/20230301-simplex-file-transfer-protocol.html).
-14. Local files encryption.
+14. Local files encryption, except videos (to be added later).
 
 We plan to add:
 
@@ -373,13 +371,12 @@ Please also join [#simplex-devs](https://simplex.chat/contact#/?v=1-2&smp=smp%3A
 - ✅ Desktop client.
 - ✅ Encryption of local files stored in the app.
 - ✅ Using mobile profiles from the desktop app.
-- ✅ Private notes.
-- ✅ Improve sending videos (including encryption of locally stored videos).
 - 🏗 Improve experience for the new users.
 - 🏗 Post-quantum resistant key exchange in double ratchet protocol.
 - 🏗 Large groups, communities and public channels.
-- 🏗 Message delivery relay for senders (to conceal IP address from the recipients' servers and to reduce the traffic).
+- Message delivery relay for senders (to conceal IP address from the recipients' servers and to reduce the traffic).
 - Privacy & security slider - a simple way to set all settings at once.
+- Improve sending videos (including encryption of locally stored videos).
 - SMP queue redundancy and rotation (manual is supported).
 - Include optional message into connection request sent via contact address.
 - Improved navigation and search in the conversation (expand and scroll to quoted message, scroll to search results, etc.).

apps/ios/Shared/Model/ChatModel.swift

@@ -556,9 +556,10 @@ final class ChatModel: ObservableObject {
     }
 
     // this function analyses "connected" events and assumes that each member will be there only once
-    func getConnectedMemberNames(_ chatItem: ChatItem) -> (Int, [String]) {
+    func getConnectedMemberNames(_ chatItem: ChatItem) -> (Int, [String], String?) {
         var count = 0
         var ns: [String] = []
+        var lastNonConnectedEvent: String? = nil
         if let ciCategory = chatItem.mergeCategory,
            var i = getChatItemIndex(chatItem) {
             while i < reversedChatItems.count {
@@ -566,12 +567,14 @@ final class ChatModel: ObservableObject {
                 if ci.mergeCategory != ciCategory { break }
                 if let m = ci.memberConnected {
                     ns.append(m.displayName)
+                } else if count == 0 {
+                    lastNonConnectedEvent = if let name = ci.memberDisplayName { name + " " + ci.text } else { ci.text }
                 }
                 count += 1
                 i += 1
             }
         }
-        return (count, ns)
+        return (count, ns, lastNonConnectedEvent)
     }
 
     // returns the index of the passed item and the next item (it has smaller index)

apps/ios/Shared/Model/SimpleXAPI.swift

@@ -252,6 +252,12 @@ 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 }
@@ -1243,6 +1249,7 @@ 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()
@@ -1854,12 +1861,10 @@ func chatItemSimpleUpdate(_ user: any UserLike, _ aChatItem: AChatItem) async {
     let cItem = aChatItem.chatItem
     if active(user) {
         if await MainActor.run(body: { m.upsertChatItem(cInfo, cItem) }) {
-            if cItem.showNotification {
             NtfManager.shared.notifyMessageReceived(user, cInfo, cItem)
         }
     }
 }
-}
 
 func updateContactsStatus(_ contactRefs: [ContactRef], status: NetworkStatus) async {
     let m = ChatModel.shared

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

@@ -149,7 +149,7 @@ struct ChatItemContentView<Content: View>: View {
     }
 
     private var mergedGroupEventText: Text? {
-        let (count, ns) = chatModel.getConnectedMemberNames(chatItem)
+        let (count, ns, lastNonConnectedEvent) = chatModel.getConnectedMemberNames(chatItem)
         let members: LocalizedStringKey =
             switch ns.count {
             case 1: "\(ns[0]) connected"
@@ -162,6 +162,8 @@ struct ChatItemContentView<Content: View>: View {
             }
         return if count <= 1 {
             nil
+        } else if let last = lastNonConnectedEvent {
+            Text(last) + Text(" ") + Text("and \(count - ns.count) other events")
         } else if ns.count == 0 {
             Text("\(count) group events")
         } else if count > ns.count {

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

@@ -749,9 +749,7 @@ struct ChatView: View {
                 if ci.meta.editable && !mc.isVoice && !live {
                     menu.append(editAction(ci))
                 }
-                if !ci.isLiveDummy {
                 menu.append(viewInfoUIAction(ci))
-                }
                 if revealed {
                     menu.append(hideUIAction())
                 }

apps/ios/Shared/Views/Chat/ComposeMessage/ComposeView.swift

@@ -978,9 +978,6 @@ struct ComposeView: View {
     }
 
     private func cancelLinkPreview() {
-        if let pendingLink = pendingLinkUrl?.absoluteString {
-            cancelledLinks.insert(pendingLink)
-        }
         if let uri = composeState.linkPreview?.uri.absoluteString {
             cancelledLinks.insert(uri)
         }

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

@@ -370,11 +370,7 @@ struct GroupChatInfoView: View {
 
     private func addOrEditWelcomeMessage() -> some View {
         NavigationLink {
-            GroupWelcomeView(
-                groupInfo: $groupInfo,
-                groupProfile: groupInfo.groupProfile,
-                welcomeText: groupInfo.groupProfile.description ?? ""
-            )
+            GroupWelcomeView(groupId: groupInfo.groupId, groupInfo: $groupInfo)
             .navigationTitle("Welcome message")
             .navigationBarTitleDisplayMode(.large)
         } label: {

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

@@ -11,32 +11,29 @@ import SimpleXChat
 
 struct GroupWelcomeView: View {
     @Environment(\.dismiss) var dismiss: DismissAction
+    @EnvironmentObject private var m: ChatModel
+    var groupId: Int64
     @Binding var groupInfo: GroupInfo
-    @State var groupProfile: GroupProfile
-    @State var welcomeText: String
+    @State private var welcomeText: String = ""
     @State private var editMode = true
     @FocusState private var keyboardVisible: Bool
     @State private var showSaveDialog = false
 
-    let maxByteCount = 1200
-
     var body: some View {
         VStack {
             if groupInfo.canEdit {
                 editorView()
                     .modifier(BackButton {
-                        if welcomeTextUnchanged() {
+                        if welcomeText == groupInfo.groupProfile.description || (welcomeText == "" && groupInfo.groupProfile.description == nil) {
                             dismiss()
                         } else {
                             showSaveDialog = true
                         }
                     })
-                    .confirmationDialog(
-                        welcomeTextFitsLimit() ? "Save welcome message?" : "Welcome message is too long",
-                        isPresented: $showSaveDialog
-                    ) {
-                        if welcomeTextFitsLimit() {
-                            Button("Save and update group profile") { save() }
+                    .confirmationDialog("Save welcome message?", isPresented: $showSaveDialog) {
+                        Button("Save and update group profile") {
+                            save()
+                            dismiss()
                         }
                         Button("Exit without saving") { dismiss() }
                     }
@@ -50,15 +47,14 @@ struct GroupWelcomeView: View {
             }
         }
         .onAppear {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
+            welcomeText = groupInfo.groupProfile.description ?? ""
             keyboardVisible = true
         }
     }
-    }
 
     private func textPreview() -> some View {
         messageText(welcomeText, parseSimpleXMarkdown(welcomeText), nil, showSecrets: false)
-            .frame(minHeight: 130, alignment: .topLeading)
+            .frame(minHeight: 140, alignment: .topLeading)
             .frame(maxWidth: .infinity, alignment: .leading)
     }
 
@@ -78,7 +74,7 @@ struct GroupWelcomeView: View {
                         }
                         .padding(.horizontal, -5)
                         .padding(.top, -8)
-                        .frame(height: 130, alignment: .topLeading)
+                        .frame(height: 140, alignment: .topLeading)
                         .frame(maxWidth: .infinity, alignment: .leading)
                     }
                 } else {
@@ -97,9 +93,6 @@ struct GroupWelcomeView: View {
                 }
                 .disabled(welcomeText.isEmpty)
                 copyButton()
-            } footer: {
-                Text(!welcomeTextFitsLimit() ? "Message too large" : "")
-                    .foregroundColor(.red)
             }
 
             Section {
@@ -120,15 +113,7 @@ struct GroupWelcomeView: View {
         Button("Save and update group profile") {
             save()
         }
-        .disabled(welcomeTextUnchanged() || !welcomeTextFitsLimit())
-    }
-
-    private func welcomeTextUnchanged() -> Bool {
-        welcomeText == groupInfo.groupProfile.description || (welcomeText == "" && groupInfo.groupProfile.description == nil)
-    }
-
-    private func welcomeTextFitsLimit() -> Bool {
-        chatJsonLength(welcomeText) <= maxByteCount
+        .disabled(welcomeText == groupInfo.groupProfile.description || (welcomeText == "" && groupInfo.groupProfile.description == nil))
     }
 
     private func save() {
@@ -138,13 +123,11 @@ struct GroupWelcomeView: View {
                 if welcome?.count == 0 {
                     welcome = nil
                 }
-                groupProfile.description = welcome
-                let gInfo = try await apiUpdateGroup(groupInfo.groupId, groupProfile)
-                await MainActor.run {
-                    groupInfo = gInfo
-                    ChatModel.shared.updateGroup(gInfo)
-                    dismiss()
-                }
+                var groupProfileUpdated = groupInfo.groupProfile
+                groupProfileUpdated.description = welcome
+                groupInfo = try await apiUpdateGroup(groupId, groupProfileUpdated)
+                m.updateGroup(groupInfo)
+                welcomeText = welcome ?? ""
             } catch let error {
                 logger.error("apiUpdateGroup error: \(responseError(error))")
             }
@@ -154,6 +137,6 @@ struct GroupWelcomeView: View {
 
 struct GroupWelcomeView_Previews: PreviewProvider {
     static var previews: some View {
-        GroupProfileView(groupInfo: Binding.constant(GroupInfo.sampleData), groupProfile: GroupProfile.sampleData)
+        GroupWelcomeView(groupId: 1, groupInfo: Binding.constant(GroupInfo.sampleData))
     }
 }

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

@@ -42,6 +42,25 @@ 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/SimpleX NSE/NotificationService.swift

@@ -453,6 +453,7 @@ 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
@@ -498,6 +499,7 @@ 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()
@@ -731,6 +733,12 @@ 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

@@ -61,6 +61,11 @@
 		5C7505A527B679EE00BE3227 /* NavLinkPlain.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C7505A427B679EE00BE3227 /* NavLinkPlain.swift */; };
 		5C7505A827B6D34800BE3227 /* ChatInfoToolbar.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C7505A727B6D34800BE3227 /* ChatInfoToolbar.swift */; };
 		5C764E89279CBCB3000C6508 /* ChatModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C764E88279CBCB3000C6508 /* ChatModel.swift */; };
+		5C83A1AD2B5EF67D00AE0A4A /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5C83A1A82B5EF67D00AE0A4A /* libgmp.a */; };
+		5C83A1AE2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5C83A1A92B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a */; };
+		5C83A1AF2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5C83A1AA2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.a */; };
+		5C83A1B02B5EF67D00AE0A4A /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5C83A1AB2B5EF67D00AE0A4A /* libffi.a */; };
+		5C83A1B12B5EF67D00AE0A4A /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5C83A1AC2B5EF67D00AE0A4A /* libgmpxx.a */; };
 		5C8F01CD27A6F0D8007D2C8D /* CodeScanner in Frameworks */ = {isa = PBXBuildFile; productRef = 5C8F01CC27A6F0D8007D2C8D /* CodeScanner */; };
 		5C93292F29239A170090FFF9 /* ProtocolServersView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C93292E29239A170090FFF9 /* ProtocolServersView.swift */; };
 		5C93293129239BED0090FFF9 /* ProtocolServerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5C93293029239BED0090FFF9 /* ProtocolServerView.swift */; };
@@ -90,11 +95,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 */; };
-		5CB1CE922B86660100963938 /* libgmp.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE8D2B86660100963938 /* libgmp.a */; };
-		5CB1CE932B86660100963938 /* libgmpxx.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE8E2B86660100963938 /* libgmpxx.a */; };
-		5CB1CE942B86660100963938 /* libffi.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE8F2B86660100963938 /* libffi.a */; };
-		5CB1CE952B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE902B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a */; };
-		5CB1CE962B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 5CB1CE912B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.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 */; };
@@ -325,6 +325,11 @@
 		5C7505A427B679EE00BE3227 /* NavLinkPlain.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NavLinkPlain.swift; sourceTree = "<group>"; };
 		5C7505A727B6D34800BE3227 /* ChatInfoToolbar.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChatInfoToolbar.swift; sourceTree = "<group>"; };
 		5C764E88279CBCB3000C6508 /* ChatModel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ChatModel.swift; sourceTree = "<group>"; };
+		5C83A1A82B5EF67D00AE0A4A /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
+		5C83A1A92B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a"; sourceTree = "<group>"; };
+		5C83A1AA2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.a"; sourceTree = "<group>"; };
+		5C83A1AB2B5EF67D00AE0A4A /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
+		5C83A1AC2B5EF67D00AE0A4A /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
 		5C84FE9129A216C800D95B1A /* nl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = nl; path = nl.lproj/Localizable.strings; sourceTree = "<group>"; };
 		5C84FE9329A2179C00D95B1A /* nl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = nl; path = "nl.lproj/SimpleX--iOS--InfoPlist.strings"; sourceTree = "<group>"; };
 		5C84FE9429A2179C00D95B1A /* nl */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = nl; path = nl.lproj/InfoPlist.strings; sourceTree = "<group>"; };
@@ -372,11 +377,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>"; };
-		5CB1CE8D2B86660100963938 /* libgmp.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmp.a; sourceTree = "<group>"; };
-		5CB1CE8E2B86660100963938 /* libgmpxx.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgmpxx.a; sourceTree = "<group>"; };
-		5CB1CE8F2B86660100963938 /* libffi.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libffi.a; sourceTree = "<group>"; };
-		5CB1CE902B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a"; sourceTree = "<group>"; };
-		5CB1CE912B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = "libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.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>"; };
@@ -514,13 +514,13 @@
 			isa = PBXFrameworksBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				5CB1CE932B86660100963938 /* libgmpxx.a in Frameworks */,
 				5CE2BA93284534B000EC33A6 /* libiconv.tbd in Frameworks */,
-				5CB1CE962B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.a in Frameworks */,
-				5CB1CE922B86660100963938 /* libgmp.a in Frameworks */,
-				5CB1CE952B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a in Frameworks */,
-				5CB1CE942B86660100963938 /* libffi.a in Frameworks */,
+				5C83A1B02B5EF67D00AE0A4A /* libffi.a in Frameworks */,
+				5C83A1AD2B5EF67D00AE0A4A /* libgmp.a in Frameworks */,
+				5C83A1AE2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a in Frameworks */,
+				5C83A1AF2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.a in Frameworks */,
 				5CE2BA94284534BB00EC33A6 /* libz.tbd in Frameworks */,
+				5C83A1B12B5EF67D00AE0A4A /* libgmpxx.a in Frameworks */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -582,11 +582,11 @@
 		5C764E5C279C70B7000C6508 /* Libraries */ = {
 			isa = PBXGroup;
 			children = (
-				5CB1CE8F2B86660100963938 /* libffi.a */,
-				5CB1CE8D2B86660100963938 /* libgmp.a */,
-				5CB1CE8E2B86660100963938 /* libgmpxx.a */,
-				5CB1CE902B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV-ghc9.6.3.a */,
-				5CB1CE912B86660100963938 /* libHSsimplex-chat-5.5.5.0-7lQXtpK7ThcLvpQEItJUcV.a */,
+				5C83A1AB2B5EF67D00AE0A4A /* libffi.a */,
+				5C83A1A82B5EF67D00AE0A4A /* libgmp.a */,
+				5C83A1AC2B5EF67D00AE0A4A /* libgmpxx.a */,
+				5C83A1A92B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3-ghc9.6.3.a */,
+				5C83A1AA2B5EF67D00AE0A4A /* libHSsimplex-chat-5.5.0.4-HTW6wkBBAjO2GDtnvnI9O3.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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -1531,7 +1531,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				ENABLE_PREVIEWS = YES;
@@ -1574,7 +1574,7 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -1646,7 +1646,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				ENABLE_BITCODE = NO;
 				GENERATE_INFOPLIST_FILE = YES;
@@ -1678,7 +1678,7 @@
 					"@executable_path/Frameworks",
 					"@executable_path/../../Frameworks",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -1721,7 +1721,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Libraries/sim",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				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 = 200;
+				CURRENT_PROJECT_VERSION = 194;
 				DEFINES_MODULE = YES;
 				DEVELOPMENT_TEAM = 5NN7GUYB6T;
 				DYLIB_COMPATIBILITY_VERSION = 1;
@@ -1767,7 +1767,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/Libraries/sim",
 				);
-				MARKETING_VERSION = 5.5.5;
+				MARKETING_VERSION = 5.5;
 				PRODUCT_BUNDLE_IDENTIFIER = chat.simplex.SimpleXChat;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
 				SDKROOT = iphoneos;

apps/ios/SimpleXChat/API.swift

@@ -105,11 +105,6 @@ public func parseSimpleXMarkdown(_ s: String) -> [FormattedText]? {
     return nil
 }
 
-public func chatJsonLength(_ s: String) -> Int {
-    var c = s.cString(using: .utf8)!
-    return Int(chat_json_length(&c))
-}
-
 struct ParsedMarkdown: Decodable {
     var formattedText: [FormattedText]?
 }

apps/ios/SimpleXChat/APITypes.swift

@@ -31,6 +31,7 @@ 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)
@@ -161,6 +162,11 @@ 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))"
@@ -305,6 +311,7 @@ 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"
@@ -998,6 +1005,10 @@ 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,6 +265,10 @@ 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/ios/SimpleXChat/SimpleX.h

@@ -25,7 +25,6 @@ extern char *chat_parse_markdown(char *str);
 extern char *chat_parse_server(char *str);
 extern char *chat_password_hash(char *pwd, char *salt);
 extern char *chat_valid_name(char *name);
-extern int chat_json_length(char *str);
 extern char *chat_encrypt_media(chat_ctrl ctl, char *key, char *frame, int len);
 extern char *chat_decrypt_media(char *key, char *frame, int len);
 

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

@@ -1,12 +1,11 @@
 package chat.simplex.app
 
-import android.content.Context
 import android.content.Intent
 import android.net.Uri
 import android.os.*
 import android.view.WindowManager
 import androidx.activity.compose.setContent
-import androidx.compose.ui.platform.ClipboardManager
+import androidx.appcompat.app.AppCompatDelegate
 import androidx.fragment.app.FragmentActivity
 import chat.simplex.app.model.NtfManager
 import chat.simplex.app.model.NtfManager.getUserIdFromIntent
@@ -59,17 +58,6 @@ class MainActivity: FragmentActivity() {
   override fun onResume() {
     super.onResume()
     AppLock.recheckAuthState()
-    withApi {
-      delay(1000)
-      if (!isAppOnForeground) return@withApi
-      /**
-       * When the app calls [ClipboardManager.shareText] and a user copies text in clipboard, Android denies
-       * access to clipboard because the app considered in background.
-       * This will ensure that the app will get the event on resume
-       * */
-      val service = getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
-      chatModel.clipboardHasText.value = service.hasPrimaryClip()
-    }
   }
 
   override fun onPause() {

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

@@ -71,7 +71,7 @@ class SimplexApp: Application(), LifecycleEventObserver {
 
   override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
     Log.d(TAG, "onStateChanged: $event")
-    withLongRunningApi {
+    withBGApi {
       when (event) {
         Lifecycle.Event.ON_START -> {
           isAppOnForeground = true
@@ -97,6 +97,13 @@ class SimplexApp: Application(), LifecycleEventObserver {
         }
         Lifecycle.Event.ON_RESUME -> {
           isAppOnForeground = true
+          /**
+           * When the app calls [ClipboardManager.shareText] and a user copies text in clipboard, Android denies
+           * access to clipboard because the app considered in background.
+           * This will ensure that the app will get the event on resume
+           * */
+          val service = androidAppContext.getSystemService(Context.CLIPBOARD_SERVICE) as android.content.ClipboardManager
+          chatModel.clipboardHasText.value = service.hasPrimaryClip()
           if (chatModel.controller.appPrefs.onboardingStage.get() == OnboardingStage.OnboardingComplete && chatModel.currentUser.value != null) {
             SimplexService.showBackgroundServiceNoticeIfNeeded()
           }
@@ -190,19 +197,11 @@ class SimplexApp: Application(), LifecycleEventObserver {
         }
         SimplexService.StartReceiver.toggleReceiver(mode == NotificationsMode.SERVICE)
         CoroutineScope(Dispatchers.Default).launch {
-          if (mode == NotificationsMode.SERVICE) {
+          if (mode == NotificationsMode.SERVICE)
             SimplexService.start()
-            // Sometimes, when we change modes fast from one to another, system destroys the service after start.
-            // We can wait a little and restart the service, and it will work in 100% of cases
-            delay(2000)
-            if (!SimplexService.isServiceStarted && appPrefs.notificationsMode.get() == NotificationsMode.SERVICE) {
-              Log.i(TAG, "Service tried to start but destroyed by system, repeating once more")
-              SimplexService.start()
-            }
-          } else {
+          else
             SimplexService.safeStopService()
         }
-        }
 
         if (mode != NotificationsMode.PERIODIC) {
           MessagesFetcherWorker.cancelAll()

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

@@ -104,7 +104,7 @@ class SimplexService: Service() {
     if (wakeLock != null || isStartingService) return
     val self = this
     isStartingService = true
-    withLongRunningApi {
+    withLongRunningApi(slow = 30_000, deadlock = 60_000) {
       val chatController = ChatController
       waitDbMigrationEnds(chatController)
       try {
@@ -262,7 +262,7 @@ class SimplexService: Service() {
     private const val SHARED_PREFS_SERVICE_STATE = "SIMPLEX_SERVICE_STATE"
     private const val WORK_NAME_ONCE = "ServiceStartWorkerOnce"
 
-    var isServiceStarted = false
+    private var isServiceStarted = false
     private var stopAfterStart = false
 
     fun scheduleStart(context: Context) {

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

@@ -14,12 +14,8 @@ import chat.simplex.common.views.helpers.*
 import java.io.BufferedOutputStream
 import java.io.File
 import chat.simplex.res.MR
-import kotlin.math.min
 
 actual fun ClipboardManager.shareText(text: String) {
-  var text = text
-  for (i in 10 downTo 1) {
-    try {
   val sendIntent: Intent = Intent().apply {
     action = Intent.ACTION_SEND
     putExtra(Intent.EXTRA_TEXT, text)
@@ -29,12 +25,6 @@ actual fun ClipboardManager.shareText(text: String) {
   val shareIntent = Intent.createChooser(sendIntent, null)
   shareIntent.addFlags(FLAG_ACTIVITY_NEW_TASK)
   androidAppContext.startActivity(shareIntent)
-      break
-    } catch (e: Exception) {
-      Log.e(TAG, "Failed to share text: ${e.stackTraceToString()}")
-      text = text.substring(0, min(i * 1000, text.length))
-    }
-  }
 }
 
 actual fun shareFile(text: String, fileSource: CryptoFile) {

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

@@ -12,8 +12,6 @@ import androidx.activity.compose.setContent
 import androidx.compose.runtime.*
 import androidx.compose.ui.platform.LocalView
 import chat.simplex.common.AppScreen
-import chat.simplex.common.model.clear
-import chat.simplex.common.ui.theme.SimpleXTheme
 import chat.simplex.common.views.helpers.*
 import androidx.compose.ui.platform.LocalContext as LocalContext1
 import chat.simplex.res.MR
@@ -114,8 +112,7 @@ actual class GlobalExceptionsHandler: Thread.UncaughtExceptionHandler {
     Handler(Looper.getMainLooper()).post {
       AlertManager.shared.showAlertMsg(
         title = generalGetString(MR.strings.app_was_crashed),
-        text = e.stackTraceToString(),
-        shareText = true
+        text = e.stackTraceToString()
       )
     }
   }

apps/multiplatform/common/src/androidMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.android.kt

@@ -1,106 +0,0 @@
-package chat.simplex.common.views.helpers
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Text
-import androidx.compose.runtime.*
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import chat.simplex.common.model.CustomTimeUnit
-import chat.simplex.common.ui.theme.DEFAULT_PADDING
-import com.sd.lib.compose.wheel_picker.*
-
-@Composable
-actual fun CustomTimePicker(
-  selection: MutableState<Int>,
-  timeUnitsLimits: List<TimeUnitLimits>
-) {
-  fun getUnitValues(unit: CustomTimeUnit, selectedValue: Int): List<Int> {
-    val unitLimits = timeUnitsLimits.firstOrNull { it.timeUnit == unit } ?: TimeUnitLimits.defaultUnitLimits(unit)
-    val regularUnitValues = (unitLimits.minValue..unitLimits.maxValue).toList()
-    return regularUnitValues + if (regularUnitValues.contains(selectedValue)) emptyList() else listOf(selectedValue)
-  }
-
-  val (unit, duration) = CustomTimeUnit.toTimeUnit(selection.value)
-  val selectedUnit: MutableState<CustomTimeUnit> = remember { mutableStateOf(unit) }
-  val selectedDuration = remember { mutableStateOf(duration) }
-  val selectedUnitValues = remember { mutableStateOf(getUnitValues(selectedUnit.value, selectedDuration.value)) }
-  val isTriggered = remember { mutableStateOf(false) }
-
-  LaunchedEffect(selectedUnit.value) {
-    // on initial composition, if passed selection doesn't fit into picker bounds, so that selectedDuration is bigger than selectedUnit maxValue
-    // (e.g., for selection = 121 seconds: selectedUnit would be Second, selectedDuration would be 121 > selectedUnit maxValue of 120),
-    // selectedDuration would've been replaced by maxValue - isTriggered check prevents this by skipping LaunchedEffect on initial composition
-    if (isTriggered.value) {
-      val maxValue = timeUnitsLimits.firstOrNull { it.timeUnit == selectedUnit.value }?.maxValue
-      if (maxValue != null && selectedDuration.value > maxValue) {
-        selectedDuration.value = maxValue
-        selectedUnitValues.value = getUnitValues(selectedUnit.value, selectedDuration.value)
-      } else {
-        selectedUnitValues.value = getUnitValues(selectedUnit.value, selectedDuration.value)
-        selection.value = selectedUnit.value.toSeconds * selectedDuration.value
-      }
-    } else {
-      isTriggered.value = true
-    }
-  }
-
-  LaunchedEffect(selectedDuration.value) {
-    selection.value = selectedUnit.value.toSeconds * selectedDuration.value
-  }
-
-  Row(
-    Modifier
-      .fillMaxWidth()
-      .padding(horizontal = DEFAULT_PADDING),
-    horizontalArrangement = Arrangement.spacedBy(0.dp)
-  ) {
-    Column(Modifier.weight(1f)) {
-      val durationPickerState = rememberFWheelPickerState(selectedUnitValues.value.indexOf(selectedDuration.value))
-      FVerticalWheelPicker(
-        count = selectedUnitValues.value.count(),
-        state = durationPickerState,
-        unfocusedCount = 2,
-        focus = {
-          FWheelPickerFocusVertical(dividerColor = MaterialTheme.colors.primary)
-        }
-      ) { index ->
-        Text(
-          selectedUnitValues.value[index].toString(),
-          fontSize = 18.sp,
-          color = MaterialTheme.colors.primary
-        )
-      }
-      LaunchedEffect(durationPickerState) {
-        snapshotFlow { durationPickerState.currentIndex }
-          .collect {
-            selectedDuration.value = selectedUnitValues.value[it]
-          }
-      }
-    }
-    Column(Modifier.weight(1f)) {
-      val unitPickerState = rememberFWheelPickerState(timeUnitsLimits.indexOfFirst { it.timeUnit == selectedUnit.value })
-      FVerticalWheelPicker(
-        count = timeUnitsLimits.count(),
-        state = unitPickerState,
-        unfocusedCount = 2,
-        focus = {
-          FWheelPickerFocusVertical(dividerColor = MaterialTheme.colors.primary)
-        }
-      ) { index ->
-        Text(
-          timeUnitsLimits[index].timeUnit.text,
-          fontSize = 18.sp,
-          color = MaterialTheme.colors.primary
-        )
-      }
-      LaunchedEffect(unitPickerState) {
-        snapshotFlow { unitPickerState.currentIndex }
-          .collect {
-            selectedUnit.value = timeUnitsLimits[it].timeUnit
-          }
-      }
-    }
-  }
-}

apps/multiplatform/common/src/commonMain/cpp/android/simplex-api.c

@@ -66,7 +66,6 @@ extern char *chat_parse_markdown(const char *str);
 extern char *chat_parse_server(const char *str);
 extern char *chat_password_hash(const char *pwd, const char *salt);
 extern char *chat_valid_name(const char *name);
-extern int chat_json_length(const char *str);
 extern char *chat_write_file(chat_ctrl ctrl, const char *path, char *ptr, int length);
 extern char *chat_read_file(const char *path, const char *key, const char *nonce);
 extern char *chat_encrypt_file(chat_ctrl ctrl, const char *from_path, const char *to_path);
@@ -164,14 +163,6 @@ Java_chat_simplex_common_platform_CoreKt_chatValidName(JNIEnv *env, jclass clazz
     return res;
 }
 
-JNIEXPORT int JNICALL
-Java_chat_simplex_common_platform_CoreKt_chatJsonLength(JNIEnv *env, jclass clazz, jstring str) {
-    const char *_str = (*env)->GetStringUTFChars(env, str, JNI_FALSE);
-    int res = chat_json_length(_str);
-    (*env)->ReleaseStringUTFChars(env, str, _str);
-    return res;
-}
-
 JNIEXPORT jstring JNICALL
 Java_chat_simplex_common_platform_CoreKt_chatWriteFile(JNIEnv *env, jclass clazz, jlong controller, jstring path, jobject buffer) {
     const char *_path = (*env)->GetStringUTFChars(env, path, JNI_FALSE);

apps/multiplatform/common/src/commonMain/cpp/desktop/simplex-api.c

@@ -39,7 +39,6 @@ extern char *chat_parse_markdown(const char *str);
 extern char *chat_parse_server(const char *str);
 extern char *chat_password_hash(const char *pwd, const char *salt);
 extern char *chat_valid_name(const char *name);
-extern int chat_json_length(const char *str);
 extern char *chat_write_file(chat_ctrl ctrl, const char *path, char *ptr, int length);
 extern char *chat_read_file(const char *path, const char *key, const char *nonce);
 extern char *chat_encrypt_file(chat_ctrl ctrl, const char *from_path, const char *to_path);
@@ -174,14 +173,6 @@ Java_chat_simplex_common_platform_CoreKt_chatValidName(JNIEnv *env, jclass clazz
     return res;
 }
 
-JNIEXPORT int JNICALL
-Java_chat_simplex_common_platform_CoreKt_chatJsonLength(JNIEnv *env, jclass clazz, jstring str) {
-    const char *_str = encode_to_utf8_chars(env, str);
-    int res = chat_json_length(_str);
-    (*env)->ReleaseStringUTFChars(env, str, _str);
-    return res;
-}
-
 JNIEXPORT jstring JNICALL
 Java_chat_simplex_common_platform_CoreKt_chatWriteFile(JNIEnv *env, jclass clazz, jlong controller, jstring path, jobject buffer) {
     const char *_path = encode_to_utf8_chars(env, path);

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

@@ -108,7 +108,6 @@ fun MainScreen() {
     val localUserCreated = chatModel.localUserCreated.value
     var showInitializationView by remember { mutableStateOf(false) }
     when {
-      chatModel.dbMigrationInProgress.value -> DefaultProgressView(stringResource(MR.strings.database_migration_in_progress))
       chatModel.chatDbStatus.value == null && showInitializationView -> DefaultProgressView(stringResource(MR.strings.opening_database))
       showChatDatabaseError -> {
         // Prevent showing keyboard on Android when: passcode enabled and database password not saved

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

@@ -2,7 +2,6 @@ package chat.simplex.common.model
 
 import androidx.compose.material.*
 import androidx.compose.runtime.*
-import androidx.compose.runtime.snapshots.SnapshotStateList
 import androidx.compose.runtime.snapshots.SnapshotStateMap
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.SpanStyle
@@ -49,7 +48,6 @@ object ChatModel {
   val chatDbEncrypted = mutableStateOf<Boolean?>(false)
   val chatDbStatus = mutableStateOf<DBMigrationResult?>(null)
   val ctrlInitInProgress = mutableStateOf(false)
-  val dbMigrationInProgress = mutableStateOf(false)
   val chats = mutableStateListOf<Chat>()
   // map of connections network statuses, key is agent connection id
   val networkStatuses = mutableStateMapOf<String, NetworkStatus>()
@@ -57,7 +55,7 @@ object ChatModel {
 
   // current chat
   val chatId = mutableStateOf<String?>(null)
-  val chatItems = mutableStateOf(SnapshotStateList<ChatItem>())
+  val chatItems = mutableStateListOf<ChatItem>()
   // rhId, chatId
   val deletedChats = mutableStateOf<List<Pair<Long?, String>>>(emptyList())
   val chatItemStatuses = mutableMapOf<Long, CIStatus>()
@@ -65,6 +63,8 @@ object ChatModel {
 
   val terminalItems = mutableStateOf<List<TerminalItem>>(listOf())
   val userAddress = mutableStateOf<UserContactLinkRec?>(null)
+  // Allows to temporary save servers that are being edited on multiple screens
+  val userSMPServersUnsaved = mutableStateOf<(List<ServerCfg>)?>(null)
   val chatItemTTL = mutableStateOf<ChatItemTTL>(ChatItemTTL.None)
 
   // set when app opened from external intent
@@ -269,15 +269,18 @@ object ChatModel {
     } else {
       addChat(Chat(remoteHostId = rhId, chatInfo = cInfo, chatItems = arrayListOf(cItem)))
     }
+    Log.d(TAG, "TODOCHAT: addChatItem: adding to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
     withContext(Dispatchers.Main) {
       // add to current chat
       if (chatId.value == cInfo.id) {
+        Log.d(TAG, "TODOCHAT: addChatItem: chatIds are equal, size ${chatItems.size}")
         // Prevent situation when chat item already in the list received from backend
-        if (chatItems.value.none { it.id == cItem.id }) {
-          if (chatItems.value.lastOrNull()?.id == ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
-            chatItems.add(kotlin.math.max(0, chatItems.value.lastIndex), cItem)
+        if (chatItems.none { it.id == cItem.id }) {
+          if (chatItems.lastOrNull()?.id == ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
+            chatItems.add(kotlin.math.max(0, chatItems.lastIndex), cItem)
           } else {
             chatItems.add(cItem)
+            Log.d(TAG, "TODOCHAT: addChatItem: added to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
           }
         }
       }
@@ -304,13 +307,14 @@ object ChatModel {
       addChat(Chat(remoteHostId = rhId, chatInfo = cInfo, chatItems = arrayListOf(cItem)))
       res = true
     }
+    Log.d(TAG, "TODOCHAT: upsertChatItem: upserting to chat ${chatId.value} from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
     return withContext(Dispatchers.Main) {
       // update current chat
       if (chatId.value == cInfo.id) {
-        val items = chatItems.value
-        val itemIndex = items.indexOfFirst { it.id == cItem.id }
+        val itemIndex = chatItems.indexOfFirst { it.id == cItem.id }
         if (itemIndex >= 0) {
-          items[itemIndex] = cItem
+          chatItems[itemIndex] = cItem
+          Log.d(TAG, "TODOCHAT: upsertChatItem: updated in chat $chatId from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
           false
         } else {
           val status = chatItemStatuses.remove(cItem.id)
@@ -320,6 +324,7 @@ object ChatModel {
             cItem
           }
           chatItems.add(ci)
+          Log.d(TAG, "TODOCHAT: upsertChatItem: added to chat $chatId from ${cInfo.id} ${cItem.id}, size ${chatItems.size}")
           true
         }
       } else {
@@ -331,10 +336,9 @@ object ChatModel {
   suspend fun updateChatItem(cInfo: ChatInfo, cItem: ChatItem, status: CIStatus? = null) {
     withContext(Dispatchers.Main) {
       if (chatId.value == cInfo.id) {
-        val items = chatItems.value
-        val itemIndex = items.indexOfFirst { it.id == cItem.id }
+        val itemIndex = chatItems.indexOfFirst { it.id == cItem.id }
         if (itemIndex >= 0) {
-          items[itemIndex] = cItem
+          chatItems[itemIndex] = cItem
         }
       } else if (status != null) {
         chatItemStatuses[cItem.id] = status
@@ -358,10 +362,10 @@ object ChatModel {
     }
     // remove from current chat
     if (chatId.value == cInfo.id) {
-      chatItems.removeAll {
-        val remove = it.id == cItem.id
-        if (remove) { AudioPlayer.stop(it) }
-        remove
+      val itemIndex = chatItems.indexOfFirst { it.id == cItem.id }
+      if (itemIndex >= 0) {
+        AudioPlayer.stop(chatItems[itemIndex])
+        chatItems.removeAt(itemIndex)
       }
     }
   }
@@ -402,7 +406,7 @@ object ChatModel {
   }
 
   fun removeLiveDummy() {
-    if (chatItems.value.lastOrNull()?.id == ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
+    if (chatItems.lastOrNull()?.id == ChatItem.TEMP_LIVE_CHAT_ITEM_ID) {
       chatItems.removeLast()
     }
   }
@@ -434,14 +438,14 @@ object ChatModel {
     var markedRead = 0
     if (chatId.value == cInfo.id) {
       var i = 0
-      val items = chatItems.value
-      while (i < items.size) {
-        val item = items[i]
+      Log.d(TAG, "TODOCHAT: markItemsReadInCurrentChat: marking read ${cInfo.id}, current chatId ${chatId.value}, size was ${chatItems.size}")
+      while (i < chatItems.count()) {
+        val item = chatItems[i]
         if (item.meta.itemStatus is CIStatus.RcvNew && (range == null || (range.from <= item.id && item.id <= range.to))) {
           val newItem = item.withStatus(CIStatus.RcvRead())
-          items[i] = newItem
+          chatItems[i] = newItem
           if (newItem.meta.itemLive != true && newItem.meta.itemTimed?.ttl != null) {
-            items[i] = newItem.copy(meta = newItem.meta.copy(itemTimed = newItem.meta.itemTimed.copy(
+            chatItems[i] = newItem.copy(meta = newItem.meta.copy(itemTimed = newItem.meta.itemTimed.copy(
               deleteAt = Clock.System.now() + newItem.meta.itemTimed.ttl.toDuration(DurationUnit.SECONDS)))
             )
           }
@@ -449,6 +453,7 @@ object ChatModel {
         }
         i += 1
       }
+      Log.d(TAG, "TODOCHAT: markItemsReadInCurrentChat: marked read ${cInfo.id}, current chatId ${chatId.value}, size now ${chatItems.size}")
     }
     return markedRead
   }
@@ -489,10 +494,11 @@ object ChatModel {
   }
 
   // this function analyses "connected" events and assumes that each member will be there only once
-  fun getConnectedMemberNames(cItem: ChatItem): Pair<Int, List<String>> {
+  fun getConnectedMemberNames(cItem: ChatItem): Triple<Int, List<String>, String?> {
     var count = 0
     val ns = mutableListOf<String>()
     var idx = getChatItemIndexOrNull(cItem)
+    var lastNonConnectedEvent: String? = null
     if (cItem.mergeCategory != null && idx != null) {
       val reversedChatItems = chatItems.asReversed()
       while (idx < reversedChatItems.size) {
@@ -501,12 +507,14 @@ object ChatModel {
         val m = ci.memberConnected
         if (m != null) {
           ns.add(m.displayName)
+        } else if (count == 0) {
+          lastNonConnectedEvent = if (ci.memberDisplayName != null) ci.memberDisplayName + " " + ci.text else ci.text
         }
         count++
         idx++
       }
     }
-    return count to ns
+    return Triple(count, ns, lastNonConnectedEvent)
   }
 
   // returns the index of the passed item and the next item (it has smaller index)
@@ -639,8 +647,7 @@ object ChatModel {
   }
 
   fun addTerminalItem(item: TerminalItem) {
-    val maxItems = if (appPreferences.developerTools.get()) 500 else 200
-    if (terminalItems.value.size >= maxItems) {
+    if (terminalItems.value.size >= 500) {
       terminalItems.value = terminalItems.value.subList(1, terminalItems.value.size)
     }
     terminalItems.value += item
@@ -2002,46 +2009,6 @@ data class ChatItem (
   }
 }
 
-fun MutableState<SnapshotStateList<ChatItem>>.add(index: Int, chatItem: ChatItem) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); add(index, chatItem) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.add(chatItem: ChatItem) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); add(chatItem) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.addAll(index: Int, chatItems: List<ChatItem>) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); addAll(index, chatItems) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.addAll(chatItems: List<ChatItem>) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); addAll(chatItems) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.removeAll(block: (ChatItem) -> Boolean) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); removeAll(block) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.removeAt(index: Int) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); removeAt(index) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.removeLast() {
-  value = SnapshotStateList<ChatItem>().apply { addAll(value); removeLast() }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.replaceAll(chatItems: List<ChatItem>) {
-  value = SnapshotStateList<ChatItem>().apply { addAll(chatItems) }
-}
-
-fun MutableState<SnapshotStateList<ChatItem>>.clear() {
-  value = SnapshotStateList<ChatItem>()
-}
-
-fun State<SnapshotStateList<ChatItem>>.asReversed(): MutableList<ChatItem> = value.asReversed()
-
-val State<List<ChatItem>>.size: Int get() = value.size
-
 enum class CIMergeCategory {
   MemberConnected,
   RcvGroupEvent,

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

@@ -451,21 +451,7 @@ object ChatController {
         }
         try {
           val msg = recvMsg(ctrl)
-          if (msg != null) {
-            val finishedWithoutTimeout = withTimeoutOrNull(60_000L) {
-              processReceivedMsg(msg)
-            }
-            if (finishedWithoutTimeout == null) {
-              Log.e(TAG, "Timeout reached while processing received message: " + msg.resp.responseType)
-              if (appPreferences.developerTools.get() && appPreferences.showSlowApiCalls.get()) {
-                AlertManager.shared.showAlertMsg(
-                  title = generalGetString(MR.strings.possible_slow_function_title),
-                  text = generalGetString(MR.strings.possible_slow_function_desc).format(60, msg.resp.responseType + "\n" + Exception().stackTraceToString()),
-                  shareText = true
-                )
-              }
-            }
-          }
+          if (msg != null) processReceivedMsg(msg)
         } catch (e: Exception) {
           Log.e(TAG, "ChatController recvMsg/processReceivedMsg exception: " + e.stackTraceToString());
         } catch (e: Throwable) {
@@ -631,6 +617,12 @@ 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) {
@@ -1693,7 +1685,7 @@ object ChatController {
           chatModel.networkStatuses[s.agentConnId] = s.networkStatus
         }
       }
-      is CR.NewChatItem -> withBGApi {
+      is CR.NewChatItem -> {
         val cInfo = r.chatItem.chatInfo
         val cItem = r.chatItem.chatItem
         if (active(r.user)) {
@@ -1708,7 +1700,7 @@ object ChatController {
             ((mc is MsgContent.MCImage && file.fileSize <= MAX_IMAGE_SIZE_AUTO_RCV)
                 || (mc is MsgContent.MCVideo && file.fileSize <= MAX_VIDEO_SIZE_AUTO_RCV)
                 || (mc is MsgContent.MCVoice && file.fileSize <= MAX_VOICE_SIZE_AUTO_RCV && file.fileStatus !is CIFileStatus.RcvAccepted))) {
-          receiveFile(rhId, r.user, file.fileId, auto = true)
+          withBGApi { receiveFile(rhId, r.user, file.fileId, auto = true) }
         }
         if (cItem.showNotification && (allowedToShowNotification() || chatModel.chatId.value != cInfo.id || chatModel.remoteHostId() != rhId)) {
           ntfManager.notifyMessageReceived(r.user, cInfo, cItem)
@@ -2167,6 +2159,10 @@ object ChatController {
     }
   }
 
+  fun getXFTPCfg(): XFTPFileConfig {
+    return XFTPFileConfig(minFileSize = 0)
+  }
+
   fun getNetCfg(): NetCfg {
     val useSocksProxy = appPrefs.networkUseSocksProxy.get()
     val proxyHostPort  = appPrefs.networkProxyHostPort.get()
@@ -2275,6 +2271,7 @@ 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()
@@ -2404,6 +2401,7 @@ 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)}"
@@ -2538,6 +2536,7 @@ sealed class CC {
     is SetTempFolder -> "setTempFolder"
     is SetFilesFolder -> "setFilesFolder"
     is SetRemoteHostsFolder -> "setRemoteHostsFolder"
+    is ApiSetXFTPConfig -> "apiSetXFTPConfig"
     is ApiSetEncryptLocalFiles -> "apiSetEncryptLocalFiles"
     is ApiExportArchive -> "apiExportArchive"
     is ApiImportArchive -> "apiImportArchive"
@@ -2703,6 +2702,9 @@ 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

@@ -28,7 +28,6 @@ external fun chatParseMarkdown(str: String): String
 external fun chatParseServer(str: String): String
 external fun chatPasswordHash(pwd: String, salt: String): String
 external fun chatValidName(name: String): String
-external fun chatJsonLength(str: String): Int
 external fun chatWriteFile(ctrl: ChatCtrl, path: String, buffer: ByteBuffer): String
 external fun chatReadFile(path: String, key: String, nonce: String): Array<Any>
 external fun chatEncryptFile(ctrl: ChatCtrl, fromPath: String, toPath: String): String
@@ -43,7 +42,7 @@ val appPreferences: AppPreferences
 val chatController: ChatController = ChatController
 
 fun initChatControllerAndRunMigrations() {
-  withLongRunningApi {
+  withLongRunningApi(slow = 30_000, deadlock = 60_000) {
     if (appPreferences.chatStopped.get() && appPreferences.storeDBPassphrase.get() && ksDatabasePassword.get() != null) {
       initChatController(startChat = ::showStartChatAfterRestartAlert)
     } else {
@@ -59,23 +58,10 @@ suspend fun initChatController(useKey: String? = null, confirmMigrations: Migrat
     chatModel.ctrlInitInProgress.value = true
     val dbKey = useKey ?: DatabaseUtils.useDatabaseKey()
     val confirm = confirmMigrations ?: if (appPreferences.developerTools.get() && appPreferences.confirmDBUpgrades.get()) MigrationConfirmation.Error else MigrationConfirmation.YesUp
-    var migrated: Array<Any> = chatMigrateInit(dbAbsolutePrefixPath, dbKey, MigrationConfirmation.Error.value)
-    var res: DBMigrationResult = runCatching {
+    val migrated: Array<Any> = chatMigrateInit(dbAbsolutePrefixPath, dbKey, confirm.value)
+    val res: DBMigrationResult = kotlin.runCatching {
       json.decodeFromString<DBMigrationResult>(migrated[0] as String)
     }.getOrElse { DBMigrationResult.Unknown(migrated[0] as String) }
-    val rerunMigration = res is DBMigrationResult.ErrorMigration && when (res.migrationError) {
-      // we don't allow to run down migrations without confirmation in UI, so currently it won't be YesUpDown
-      is MigrationError.Upgrade -> confirm == MigrationConfirmation.YesUp || confirm == MigrationConfirmation.YesUpDown
-      is MigrationError.Downgrade ->  confirm == MigrationConfirmation.YesUpDown
-      is MigrationError.Error -> false
-    }
-    if (rerunMigration) {
-      chatModel.dbMigrationInProgress.value = true
-      migrated = chatMigrateInit(dbAbsolutePrefixPath, dbKey, confirm.value)
-      res = runCatching {
-        json.decodeFromString<DBMigrationResult>(migrated[0] as String)
-      }.getOrElse { DBMigrationResult.Unknown(migrated[0] as String) }
-    }
     val ctrl = if (res is DBMigrationResult.OK) {
       migrated[1] as Long
     } else null
@@ -91,6 +77,7 @@ 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)
@@ -132,7 +119,6 @@ suspend fun initChatController(useKey: String? = null, confirmMigrations: Migrat
     }
   } finally {
     chatModel.ctrlInitInProgress.value = false
-    chatModel.dbMigrationInProgress.value = false
   }
 }
 

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

@@ -55,7 +55,7 @@ abstract class NtfManager {
   }
 
   fun openChatAction(userId: Long?, chatId: ChatId) {
-    withLongRunningApi {
+    withLongRunningApi(slow = 30_000, deadlock = 60_000) {
       awaitChatStartedIfNeeded(chatModel)
       if (userId != null && userId != chatModel.currentUser.value?.userId && chatModel.currentUser.value != null) {
         // TODO include remote host ID in desktop notifications?
@@ -70,7 +70,7 @@ abstract class NtfManager {
   }
 
   fun showChatsAction(userId: Long?) {
-    withLongRunningApi {
+    withLongRunningApi(slow = 30_000, deadlock = 60_000) {
       awaitChatStartedIfNeeded(chatModel)
       if (userId != null && userId != chatModel.currentUser.value?.userId && chatModel.currentUser.value != null) {
         // TODO include remote host ID in desktop notifications?

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

@@ -324,7 +324,7 @@ fun ChatItemInfoView(chatModel: ChatModel, ci: ChatItem, ciInfo: ChatItemInfo, d
           .fillMaxHeight(),
         verticalArrangement = Arrangement.SpaceBetween
       ) {
-        LaunchedEffect(ciInfo) {
+        LaunchedEffect(Unit) {
           if (ciInfo.memberDeliveryStatuses != null) {
             selection.value = CIInfoTab.Delivery(ciInfo.memberDeliveryStatuses)
           }

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

@@ -67,13 +67,13 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
     launch {
       snapshotFlow { chatModel.chatId.value }
         .distinctUntilChanged()
-        .filterNotNull()
+        .onEach { Log.d(TAG, "TODOCHAT: chatId: activeChatId ${activeChat.value?.id} == new chatId $it ${activeChat.value?.id == it} ") }
+        .filter { it != null && activeChat.value?.id != it }
         .collect { chatId ->
-          if (activeChat.value?.id != chatId) {
           // Redisplay the whole hierarchy if the chat is different to make going from groups to direct chat working correctly
           // Also for situation when chatId changes after clicking in notification, etc
-            activeChat.value = chatModel.getChat(chatId)
-          }
+          activeChat.value = chatModel.getChat(chatId!!)
+          Log.d(TAG, "TODOCHAT: chatId: activeChatId became ${activeChat.value?.id}")
           markUnreadChatAsRead(activeChat, chatModel)
         }
     }
@@ -92,10 +92,12 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
         }
       }
         .distinctUntilChanged()
+        .onEach { Log.d(TAG, "TODOCHAT: chats: activeChatId ${activeChat.value?.id} == new chatId ${it?.id} ${activeChat.value?.id == it?.id} ") }
         // Only changed chatInfo is important thing. Other properties can be skipped for reducing recompositions
-        .filter { it != null && it.chatInfo != activeChat.value?.chatInfo }
+        .filter { it != null && it?.chatInfo != activeChat.value?.chatInfo }
         .collect {
           activeChat.value = it
+          Log.d(TAG, "TODOCHAT: chats: activeChatId became ${activeChat.value?.id}")
         }
     }
   }
@@ -146,6 +148,7 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
           },
           attachmentOption,
           attachmentBottomSheetState,
+          chatModel.chatItems,
           searchText,
           useLinkPreviews = useLinkPreviews,
           linkMode = chatModel.simplexLinkMode.value,
@@ -223,17 +226,19 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
           loadPrevMessages = {
             if (chatModel.chatId.value != activeChat.value?.id) return@ChatLayout
             val c = chatModel.getChat(chatModel.chatId.value ?: return@ChatLayout)
-            val firstId = chatModel.chatItems.value.firstOrNull()?.id
+            val firstId = chatModel.chatItems.firstOrNull()?.id
             if (c != null && firstId != null) {
               withBGApi {
+                Log.d(TAG, "TODOCHAT: loadPrevMessages: loading for ${c.id}, current chatId ${ChatModel.chatId.value}, size was ${ChatModel.chatItems.size}")
                 apiLoadPrevMessages(c, chatModel, firstId, searchText.value)
+                Log.d(TAG, "TODOCHAT: loadPrevMessages: loaded for ${c.id}, current chatId ${ChatModel.chatId.value}, size now ${ChatModel.chatItems.size}")
               }
             }
           },
           deleteMessage = { itemId, mode ->
             withBGApi {
               val cInfo = chat.chatInfo
-              val toDeleteItem = chatModel.chatItems.value.firstOrNull { it.id == itemId }
+              val toDeleteItem = chatModel.chatItems.firstOrNull { it.id == itemId }
               val toModerate = toDeleteItem?.memberToModerate(chat.chatInfo)
               val groupInfo = toModerate?.first
               val groupMember = toModerate?.second
@@ -399,15 +404,12 @@ fun ChatView(chatId: String, chatModel: ChatModel, onComposed: suspend (chatId:
                   setGroupMembers(chatRh, chat.chatInfo.groupInfo, chatModel)
                 }
                 ModalManager.end.closeModals()
-                ModalManager.end.showModalCloseable(endButtons = {
+                ModalManager.end.showModal(endButtons = {
                   ShareButton {
                     clipboard.shareText(itemInfoShareText(chatModel, cItem, ciInfo, chatModel.controller.appPrefs.developerTools.get()))
                   }
-                }) { close ->
+                }) {
                   ChatItemInfoView(chatModel, cItem, ciInfo, devTools = chatModel.controller.appPrefs.developerTools.get())
-                  KeyChangeEffect(chatModel.chatId.value) {
-                    close()
-                  }
                 }
               }
             }
@@ -493,6 +495,7 @@ fun ChatLayout(
   composeView: (@Composable () -> Unit),
   attachmentOption: MutableState<AttachmentOption?>,
   attachmentBottomSheetState: ModalBottomSheetState,
+  chatItems: List<ChatItem>,
   searchValue: State<String>,
   useLinkPreviews: Boolean,
   linkMode: SimplexLinkMode,
@@ -579,7 +582,7 @@ fun ChatLayout(
             .padding(contentPadding)
           ) {
             ChatItemsList(
-              chat, unreadCount, composeState, searchValue,
+              chat, unreadCount, composeState, chatItems, searchValue,
               useLinkPreviews, linkMode, showMemberInfo, loadPrevMessages, deleteMessage, deleteMessages,
               receiveFile, cancelFile, joinGroup, acceptCall, acceptFeature, openDirectChat,
               updateContactStats, updateMemberStats, syncContactConnection, syncMemberConnection, findModelChat, findModelMember,
@@ -837,6 +840,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
   chat: Chat,
   unreadCount: State<Int>,
   composeState: MutableState<ComposeState>,
+  chatItems: List<ChatItem>,
   searchValue: State<String>,
   useLinkPreviews: Boolean,
   linkMode: SimplexLinkMode,
@@ -865,7 +869,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
 ) {
   val listState = rememberLazyListState()
   val scope = rememberCoroutineScope()
-  ScrollToBottom(chat.id, listState, chatModel.chatItems)
+  ScrollToBottom(chat.id, listState, chatItems)
   var prevSearchEmptiness by rememberSaveable { mutableStateOf(searchValue.value.isEmpty()) }
   // Scroll to bottom when search value changes from something to nothing and back
   LaunchedEffect(searchValue.value.isEmpty()) {
@@ -882,7 +886,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
   PreloadItems(listState, ChatPagination.UNTIL_PRELOAD_COUNT, loadPrevMessages)
 
   Spacer(Modifier.size(8.dp))
-  val reversedChatItems by remember { derivedStateOf { chatModel.chatItems.asReversed() } }
+  val reversedChatItems by remember { derivedStateOf { chatItems.reversed().toList() } }
   val maxHeightRounded = with(LocalDensity.current) { maxHeight.roundToPx() }
   val scrollToItem: (Long) -> Unit = { itemId: Long ->
     val index = reversedChatItems.indexOfFirst { it.id == itemId }
@@ -935,7 +939,7 @@ fun BoxWithConstraintsScope.ChatItemsList(
           }
         }
         val provider = {
-          providerForGallery(i, chatModel.chatItems.value, cItem.id) { indexInReversed ->
+          providerForGallery(i, chatItems, cItem.id) { indexInReversed ->
             scope.launch {
               listState.scrollToItem(
                 kotlin.math.min(reversedChatItems.lastIndex, indexInReversed + 1),
@@ -1058,11 +1062,11 @@ fun BoxWithConstraintsScope.ChatItemsList(
       }
     }
   }
-  FloatingButtons(chatModel.chatItems, unreadCount, chat.chatStats.minUnreadItemId, searchValue, markRead, setFloatingButton, listState)
+  FloatingButtons(chatItems, unreadCount, chat.chatStats.minUnreadItemId, searchValue, markRead, setFloatingButton, listState)
 }
 
 @Composable
-private fun ScrollToBottom(chatId: ChatId, listState: LazyListState, chatItems: State<List<ChatItem>>) {
+private fun ScrollToBottom(chatId: ChatId, listState: LazyListState, chatItems: List<ChatItem>) {
   val scope = rememberCoroutineScope()
   // Helps to scroll to bottom after moving from Group to Direct chat
   // and prevents scrolling to bottom on orientation change
@@ -1080,7 +1084,7 @@ private fun ScrollToBottom(chatId: ChatId, listState: LazyListState, chatItems:
   * When the first visible item (from bottom) is visible (even partially) we can autoscroll to 0 item. Or just scrollBy small distance otherwise
   * */
   LaunchedEffect(Unit) {
-    snapshotFlow { chatItems.value.lastOrNull()?.id }
+    snapshotFlow { chatItems.lastOrNull()?.id }
       .distinctUntilChanged()
       .filter { listState.layoutInfo.visibleItemsInfo.firstOrNull()?.key != it }
       .collect {
@@ -1103,7 +1107,7 @@ private fun ScrollToBottom(chatId: ChatId, listState: LazyListState, chatItems:
 
 @Composable
 fun BoxWithConstraintsScope.FloatingButtons(
-  chatItems: State<List<ChatItem>>,
+  chatItems: List<ChatItem>,
   unreadCount: State<Int>,
   minUnreadItemId: Long,
   searchValue: State<String>,
@@ -1137,11 +1141,10 @@ fun BoxWithConstraintsScope.FloatingButtons(
   val bottomUnreadCount by remember {
     derivedStateOf {
       if (unreadCount.value == 0) return@derivedStateOf 0
-      val items = chatItems.value
-      val from = items.lastIndex - firstVisibleIndex - lastIndexOfVisibleItems
-      if (items.size <= from || from < 0) return@derivedStateOf 0
+      val from = chatItems.lastIndex - firstVisibleIndex - lastIndexOfVisibleItems
+      if (chatItems.size <= from || from < 0) return@derivedStateOf 0
 
-      items.subList(from, items.size).count { it.isRcvNew }
+      chatItems.subList(from, chatItems.size).count { it.isRcvNew }
     }
   }
   val firstVisibleOffset = (-with(LocalDensity.current) { maxHeight.roundToPx() } * 0.8).toInt()
@@ -1187,7 +1190,7 @@ fun BoxWithConstraintsScope.FloatingButtons(
         painterResource(MR.images.ic_check),
         onClick = {
           markRead(
-            CC.ItemRange(minUnreadItemId, chatItems.value[chatItems.size - listState.layoutInfo.visibleItemsInfo.lastIndex - 1].id - 1),
+            CC.ItemRange(minUnreadItemId, chatItems[chatItems.size - listState.layoutInfo.visibleItemsInfo.lastIndex - 1].id - 1),
             bottomUnreadCount
           )
           showDropDown.value = false
@@ -1492,6 +1495,7 @@ fun PreviewChatLayout() {
       composeView = {},
       attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
       attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
+      chatItems = chatItems,
       searchValue,
       useLinkPreviews = true,
       linkMode = SimplexLinkMode.DESCRIPTION,
@@ -1564,6 +1568,7 @@ fun PreviewGroupChatLayout() {
       composeView = {},
       attachmentOption = remember { mutableStateOf<AttachmentOption?>(null) },
       attachmentBottomSheetState = rememberModalBottomSheetState(initialValue = ModalBottomSheetValue.Hidden),
+      chatItems = chatItems,
       searchValue,
       useLinkPreviews = true,
       linkMode = SimplexLinkMode.DESCRIPTION,

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

@@ -267,7 +267,7 @@ fun ComposeView(
   fun loadLinkPreview(url: String, wait: Long? = null) {
     if (pendingLinkUrl.value == url) {
       composeState.value = composeState.value.copy(preview = ComposePreview.CLinkPreview(null))
-      withLongRunningApi(slow = 60_000) {
+      withLongRunningApi(slow = 30_000, deadlock = 60_000) {
         if (wait != null) delay(wait)
         val lp = getLinkPreview(url)
         if (lp != null && pendingLinkUrl.value == url) {
@@ -551,7 +551,7 @@ fun ComposeView(
   }
 
   fun sendMessage(ttl: Int?) {
-    withLongRunningApi(slow = 120_000) {
+    withLongRunningApi(slow = 30_000, deadlock = 60_000) {
       sendMessageAsync(null, false, ttl)
     }
   }
@@ -583,10 +583,6 @@ fun ComposeView(
   }
 
   fun cancelLinkPreview() {
-    val pendingLink = pendingLinkUrl.value
-    if (pendingLink != null) {
-      cancelledLinks.add(pendingLink)
-    }
     val uri = composeState.value.linkPreview?.uri
     if (uri != null) {
       cancelledLinks.add(uri)
@@ -665,7 +661,7 @@ fun ComposeView(
 
   fun editPrevMessage() {
     if (composeState.value.contextItem != ComposeContextItem.NoContextItem || composeState.value.preview != ComposePreview.NoPreview) return
-    val lastEditable = chatModel.chatItems.value.findLast { it.meta.editable }
+    val lastEditable = chatModel.chatItems.findLast { it.meta.editable }
     if (lastEditable != null) {
       composeState.value = ComposeState(editingItem = lastEditable, useLinkPreviews = useLinkPreviews)
     }

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

@@ -59,6 +59,14 @@ fun SendMsgView(
 ) {
   val showCustomDisappearingMessageDialog = remember { mutableStateOf(false) }
 
+  if (showCustomDisappearingMessageDialog.value) {
+    CustomDisappearingMessageDialog(
+      sendMessage = sendMessage,
+      setShowDialog = { showCustomDisappearingMessageDialog.value = it },
+      customDisappearingMessageTimePref = customDisappearingMessageTimePref
+    )
+  }
+
   Box(Modifier.padding(vertical = 8.dp)) {
     val cs = composeState.value
     var progressByTimeout by rememberSaveable { mutableStateOf(false) }
@@ -195,11 +203,6 @@ fun SendMsgView(
             DefaultDropdownMenu(showDropdown) {
               menuItems.forEach { composable -> composable() }
             }
-            CustomDisappearingMessageDialog(
-              showCustomDisappearingMessageDialog,
-              sendMessage = sendMessage,
-              customDisappearingMessageTimePref = customDisappearingMessageTimePref
-            )
           } else {
             SendMsgButton(icon, sendButtonSize, sendButtonAlpha, sendButtonColor, !sendMsgButtonDisabled, sendMessage)
           }
@@ -217,43 +220,93 @@ expect fun VoiceButtonWithoutPermissionByPlatform()
 
 @Composable
 private fun CustomDisappearingMessageDialog(
-  showMenu: MutableState<Boolean>,
   sendMessage: (Int?) -> Unit,
+  setShowDialog: (Boolean) -> Unit,
   customDisappearingMessageTimePref: SharedPreference<Int>?
 ) {
-  DefaultDropdownMenu(showMenu) {
-    Text(
-      generalGetString(MR.strings.send_disappearing_message),
-      Modifier.padding(vertical = DEFAULT_PADDING_HALF, horizontal = DEFAULT_PADDING * 1.5f),
-      fontSize = 16.sp,
-      color = MaterialTheme.colors.secondary
-    )
+  val showCustomTimePicker = remember { mutableStateOf(false) }
 
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_30_seconds)) {
-      sendMessage(30)
-      showMenu.value = false
+  if (showCustomTimePicker.value) {
+    val selectedDisappearingMessageTime = remember {
+      mutableStateOf(customDisappearingMessageTimePref?.get?.invoke() ?: 300)
     }
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_1_minute)) {
-      sendMessage(60)
-      showMenu.value = false
-    }
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_5_minutes)) {
-      sendMessage(300)
-      showMenu.value = false
-    }
-    ItemAction(generalGetString(MR.strings.send_disappearing_message_custom_time)) {
-      showMenu.value = false
-      val selectedDisappearingMessageTime = mutableStateOf(customDisappearingMessageTimePref?.get?.invoke() ?: 300)
-      showCustomTimePickerDialog(
+    CustomTimePickerDialog(
       selectedDisappearingMessageTime,
       title = generalGetString(MR.strings.delete_after),
       confirmButtonText = generalGetString(MR.strings.send_disappearing_message_send),
       confirmButtonAction = { ttl ->
         sendMessage(ttl)
         customDisappearingMessageTimePref?.set?.invoke(ttl)
+        setShowDialog(false)
       },
-        cancel = { showMenu.value = false }
+      cancel = { setShowDialog(false) }
     )
+  } else {
+    @Composable
+    fun ChoiceButton(
+      text: String,
+      onClick: () -> Unit
+    ) {
+      TextButton(onClick) {
+        Text(
+          text,
+          fontSize = 18.sp,
+          color = MaterialTheme.colors.primary
+        )
+      }
+    }
+
+    DefaultDialog(onDismissRequest = { setShowDialog(false) }) {
+      Surface(
+        shape = RoundedCornerShape(corner = CornerSize(25.dp)),
+        contentColor = LocalContentColor.current
+      ) {
+        Box(
+          contentAlignment = Alignment.Center
+        ) {
+          Column(
+            modifier = Modifier.padding(DEFAULT_PADDING),
+            verticalArrangement = Arrangement.spacedBy(6.dp),
+            horizontalAlignment = Alignment.CenterHorizontally
+          ) {
+            Row(
+              modifier = Modifier.fillMaxWidth(),
+              horizontalArrangement = Arrangement.SpaceBetween,
+              verticalAlignment = Alignment.CenterVertically
+            ) {
+              Text(" ") // centers title
+              Text(
+                generalGetString(MR.strings.send_disappearing_message),
+                fontSize = 16.sp,
+                color = MaterialTheme.colors.secondary
+              )
+              Icon(
+                painterResource(MR.images.ic_close),
+                generalGetString(MR.strings.icon_descr_close_button),
+                tint = MaterialTheme.colors.secondary,
+                modifier = Modifier
+                  .size(25.dp)
+                  .clickable { setShowDialog(false) }
+              )
+            }
+            ChoiceButton(generalGetString(MR.strings.send_disappearing_message_30_seconds)) {
+              sendMessage(30)
+              setShowDialog(false)
+            }
+            ChoiceButton(generalGetString(MR.strings.send_disappearing_message_1_minute)) {
+              sendMessage(60)
+              setShowDialog(false)
+            }
+            ChoiceButton(generalGetString(MR.strings.send_disappearing_message_5_minutes)) {
+              sendMessage(300)
+              setShowDialog(false)
+            }
+            ChoiceButton(generalGetString(MR.strings.send_disappearing_message_custom_time)) {
+              showCustomTimePicker.value = true
+            }
+          }
+        }
+      }
     }
   }
 }

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

@@ -54,7 +54,7 @@ fun AddGroupMembersView(rhId: Long?, groupInfo: GroupInfo, creatingGroup: Boolea
     },
     inviteMembers = {
       allowModifyMembers = false
-      withLongRunningApi(slow = 120_000) {
+      withLongRunningApi(slow = 30_000, deadlock = 60_000) {
         for (contactId in selectedContacts) {
           val member = chatModel.controller.apiAddMember(rhId, groupInfo.groupId, contactId, selectedRole.value)
           if (member != null) {

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

@@ -152,7 +152,7 @@ fun leaveGroupDialog(rhId: Long?, groupInfo: GroupInfo, chatModel: ChatModel, cl
     text = generalGetString(MR.strings.you_will_stop_receiving_messages_from_this_group_chat_history_will_be_preserved),
     confirmText = generalGetString(MR.strings.leave_group_button),
     onConfirm = {
-      withLongRunningApi(60_000) {
+      withBGApi {
         chatModel.controller.leaveGroup(rhId, groupInfo.groupId)
         close?.invoke()
       }

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

@@ -3,9 +3,11 @@ package chat.simplex.common.views.chat.group
 import InfoRow
 import SectionBottomSpacer
 import SectionDividerSpaced
+import SectionItemView
 import SectionSpacer
 import SectionTextFooter
 import SectionView
+import TextIconSpaced
 import androidx.compose.desktop.ui.tooling.preview.Preview
 import java.net.URI
 import androidx.compose.foundation.*
@@ -72,8 +74,9 @@ fun GroupMemberInfoView(
             if (chatModel.getContactChat(it) == null) {
               chatModel.addChat(c)
             }
+            chatModel.chatItems.clear()
             chatModel.chatItemStatuses.clear()
-            chatModel.chatItems.replaceAll(c.chatItems)
+            chatModel.chatItems.addAll(c.chatItems)
             chatModel.chatId.value = c.id
             closeAll()
           }

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

@@ -3,7 +3,6 @@ package chat.simplex.common.views.chat.group
 import SectionBottomSpacer
 import SectionDividerSpaced
 import SectionItemView
-import SectionTextFooter
 import SectionView
 import TextIconSpaced
 import androidx.compose.foundation.layout.*
@@ -15,7 +14,6 @@ import androidx.compose.runtime.*
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalUriHandler
 import androidx.compose.ui.text.AnnotatedString
@@ -29,13 +27,9 @@ import chat.simplex.common.views.chat.item.MarkdownText
 import chat.simplex.common.views.helpers.*
 import chat.simplex.common.model.ChatModel
 import chat.simplex.common.model.GroupInfo
-import chat.simplex.common.platform.chatJsonLength
-import chat.simplex.common.ui.theme.DEFAULT_PADDING_HALF
 import chat.simplex.res.MR
 import kotlinx.coroutines.delay
 
-private const val maxByteCount = 1200
-
 @Composable
 fun GroupWelcomeView(m: ChatModel, rhId: Long?, groupInfo: GroupInfo, close: () -> Unit) {
   var gInfo by remember { mutableStateOf(groupInfo) }
@@ -60,11 +54,8 @@ fun GroupWelcomeView(m: ChatModel, rhId: Long?, groupInfo: GroupInfo, close: ()
 
   ModalView(
     close = {
-      when {
-        welcomeTextUnchanged(welcomeText, gInfo) -> close()
-        !welcomeTextFitsLimit(welcomeText) -> showUnsavedChangesTooLongAlert(close)
-        else -> showUnsavedChangesAlert({ save(close) }, close)
-      }
+      if (welcomeText.value == gInfo.groupProfile.description || (welcomeText.value == "" && gInfo.groupProfile.description == null)) close()
+      else showUnsavedChangesAlert({ save(close) }, close)
     },
   ) {
     GroupWelcomeLayout(
@@ -76,14 +67,6 @@ fun GroupWelcomeView(m: ChatModel, rhId: Long?, groupInfo: GroupInfo, close: ()
   }
 }
 
-private fun welcomeTextUnchanged(welcomeText: MutableState<String>, groupInfo: GroupInfo): Boolean {
-  return welcomeText.value == groupInfo.groupProfile.description || (welcomeText.value == "" && groupInfo.groupProfile.description == null)
-}
-
-private fun welcomeTextFitsLimit(welcomeText: MutableState<String>): Boolean {
-  return chatJsonLength(welcomeText.value) <= maxByteCount
-}
-
 @Composable
 private fun GroupWelcomeLayout(
   welcomeText: MutableState<String>,
@@ -112,13 +95,6 @@ private fun GroupWelcomeLayout(
       } else {
         TextPreview(wt.value, linkMode)
       }
-      SectionTextFooter(
-        if (!welcomeTextFitsLimit(wt)) { generalGetString(MR.strings.message_too_large) } else "",
-        color = if (welcomeTextFitsLimit(wt)) MaterialTheme.colors.secondary else Color.Red
-      )
-
-      Spacer(Modifier.size(8.dp))
-
       ChangeModeButton(
         editMode.value,
         click = {
@@ -128,18 +104,10 @@ private fun GroupWelcomeLayout(
       )
       val clipboard = LocalClipboardManager.current
       CopyTextButton { clipboard.setText(AnnotatedString(wt.value)) }
-
-      Divider(
-        Modifier.padding(
-          start = DEFAULT_PADDING_HALF,
-          top = 8.dp,
-          end = DEFAULT_PADDING_HALF,
-          bottom = 8.dp)
-      )
-
+      SectionDividerSpaced(maxBottomPadding = false)
       SaveButton(
         save = save,
-        disabled = welcomeTextUnchanged(wt, groupInfo) || !welcomeTextFitsLimit(wt)
+        disabled = wt.value == groupInfo.groupProfile.description || (wt.value == "" && groupInfo.groupProfile.description == null)
       )
     } else {
       val clipboard = LocalClipboardManager.current
@@ -214,11 +182,3 @@ private fun showUnsavedChangesAlert(save: () -> Unit, revert: () -> Unit) {
     onDismiss = revert,
   )
 }
-
-private fun showUnsavedChangesTooLongAlert(revert: () -> Unit) {
-  AlertManager.shared.showAlertDialogStacked(
-    title = generalGetString(MR.strings.welcome_message_is_too_long),
-    confirmText = generalGetString(MR.strings.exit_without_saving),
-    onConfirm = revert,
-  )
-}

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

@@ -94,7 +94,7 @@ fun CIFileView(
             FileProtocol.LOCAL -> {}
           }
         file.fileStatus is CIFileStatus.RcvComplete || (file.fileStatus is CIFileStatus.SndStored && file.fileProtocol == FileProtocol.LOCAL) -> {
-          withLongRunningApi(slow = 600_000) {
+          withLongRunningApi(slow = 60_000, deadlock = 600_000) {
             var filePath = getLoadedFilePath(file)
             if (chatModel.connectedToRemote() && filePath == null) {
               file.loadRemoteFile(true)

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

@@ -41,7 +41,7 @@ fun CIVideoView(
     val filePath = remember(file, CIFile.cachedRemoteFileRequests.toList()) { mutableStateOf(getLoadedFilePath(file)) }
     if (chatModel.connectedToRemote()) {
       LaunchedEffect(file) {
-        withLongRunningApi(slow = 600_000) {
+        withLongRunningApi(slow = 60_000, deadlock = 600_000) {
           if (file != null && file.loaded && getLoadedFilePath(file) == null) {
             file.loadRemoteFile(false)
             filePath.value = getLoadedFilePath(file)

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

@@ -103,7 +103,7 @@ fun ChatItemView(
               setReaction(cInfo, cItem, !r.userReacted, r.reaction)
             }
           }
-          Row(modifier.padding(2.dp), verticalAlignment = Alignment.CenterVertically) {
+          Row(modifier.padding(2.dp)) {
             ReactionIcon(r.reaction.text, fontSize = 12.sp)
             if (r.totalReacted > 1) {
               Spacer(Modifier.width(4.dp))
@@ -112,6 +112,7 @@ fun ChatItemView(
                 fontSize = 11.5.sp,
                 fontWeight = if (r.userReacted) FontWeight.Bold else FontWeight.Normal,
                 color = if (r.userReacted) MaterialTheme.colors.primary else MaterialTheme.colors.secondary,
+                modifier = if (appPlatform.isAndroid) Modifier else Modifier.padding(top = 4.dp)
               )
             }
           }
@@ -177,8 +178,7 @@ fun ChatItemView(
         fun MsgContentItemDropdownMenu() {
           val saveFileLauncher = rememberSaveFileLauncher(ciFile = cItem.file)
           when {
-            // cItem.id check is a special case for live message chat item which has negative ID while not sent yet
-            cItem.content.msgContent != null && cItem.id >= 0 -> {
+            cItem.content.msgContent != null -> {
               DefaultDropdownMenu(showMenu) {
                 if (cInfo.featureEnabled(ChatFeature.Reactions) && cItem.allowAddReaction) {
                   MsgReactionsMenu()
@@ -213,7 +213,7 @@ fun ChatItemView(
                       showMenu.value = false
                     }
                     if (chatModel.connectedToRemote() && fileSource == null) {
-                      withLongRunningApi(slow = 600_000) {
+                      withLongRunningApi(slow = 60_000, deadlock = 600_000) {
                         cItem.file?.loadRemoteFile(true)
                         fileSource = getLoadedFileSource(cItem.file)
                         shareIfExists()
@@ -332,7 +332,7 @@ fun ChatItemView(
         }
 
         fun mergedGroupEventText(chatItem: ChatItem): String? {
-          val (count, ns) = chatModel.getConnectedMemberNames(chatItem)
+          val (count, ns, lastNonConnectedEvent) = chatModel.getConnectedMemberNames(chatItem)
           val members = when {
             ns.size == 1 -> String.format(generalGetString(MR.strings.rcv_group_event_1_member_connected), ns[0])
             ns.size == 2 -> String.format(generalGetString(MR.strings.rcv_group_event_2_members_connected), ns[0], ns[1])
@@ -342,6 +342,8 @@ fun ChatItemView(
           }
           return if (count <= 1) {
             null
+          } else if (lastNonConnectedEvent != null) {
+            lastNonConnectedEvent + " " + generalGetString(MR.strings.rcv_group_and_other_events).format(count - ns.size)
           } else if (ns.isEmpty()) {
             generalGetString(MR.strings.rcv_group_events_count).format(count)
           } else if (count > ns.size) {
@@ -527,9 +529,8 @@ fun DeleteItemAction(
           val range = chatViewItemsRange(currIndex, prevHidden)
           if (range != null) {
             val itemIds: ArrayList<Long> = arrayListOf()
-            val reversedChatItems = chatModel.chatItems.asReversed()
             for (i in range) {
-              itemIds.add(reversedChatItems[i].id)
+              itemIds.add(chatModel.chatItems.asReversed()[i].id)
             }
             deleteMessagesAlertDialog(itemIds, generalGetString(MR.strings.delete_message_mark_deleted_warning), deleteMessages = deleteMessages)
           } else {
@@ -652,23 +653,6 @@ fun ItemAction(text: String, icon: ImageVector, onClick: () -> Unit, color: Colo
   }
 }
 
-@Composable
-fun ItemAction(text: String, color: Color = Color.Unspecified, onClick: () -> Unit) {
-  val finalColor = if (color == Color.Unspecified) {
-    MenuTextColor
-  } else color
-  DropdownMenuItem(onClick, contentPadding = PaddingValues(horizontal = DEFAULT_PADDING * 1.5f)) {
-    Text(
-      text,
-      modifier = Modifier
-        .fillMaxWidth()
-        .weight(1F)
-        .padding(end = 15.dp),
-      color = finalColor
-    )
-  }
-}
-
 fun cancelFileAlertDialog(fileId: Long, cancelFile: (Long) -> Unit, cancelAction: CancelAction) {
   AlertManager.shared.showAlertDialog(
     title = generalGetString(cancelAction.alert.titleId),

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

@@ -212,15 +212,18 @@ suspend fun openGroupChat(rhId: Long?, groupId: Long, chatModel: ChatModel) {
 }
 
 suspend fun openChat(rhId: Long?, chatInfo: ChatInfo, chatModel: ChatModel) {
+  Log.d(TAG, "TODOCHAT: openChat: opening ${chatInfo.id}, current chatId ${ChatModel.chatId.value}, size ${ChatModel.chatItems.size}")
   val chat = chatModel.controller.apiGetChat(rhId, chatInfo.chatType, chatInfo.apiId)
   if (chat != null) {
     openLoadedChat(chat, chatModel)
+    Log.d(TAG, "TODOCHAT: openChat: opened ${chatInfo.id}, current chatId ${ChatModel.chatId.value}, size ${ChatModel.chatItems.size}")
   }
 }
 
 fun openLoadedChat(chat: Chat, chatModel: ChatModel) {
+  chatModel.chatItems.clear()
   chatModel.chatItemStatuses.clear()
-  chatModel.chatItems.replaceAll(chat.chatItems)
+  chatModel.chatItems.addAll(chat.chatItems)
   chatModel.chatId.value = chat.chatInfo.id
 }
 
@@ -236,7 +239,8 @@ suspend fun apiFindMessages(ch: Chat, chatModel: ChatModel, search: String) {
   val chatInfo = ch.chatInfo
   val chat = chatModel.controller.apiGetChat(ch.remoteHostId, chatInfo.chatType, chatInfo.apiId, search = search) ?: return
   if (chatModel.chatId.value != chat.id) return
-  chatModel.chatItems.replaceAll(chat.chatItems)
+  chatModel.chatItems.clear()
+  chatModel.chatItems.addAll(0, chat.chatItems)
 }
 
 suspend fun setGroupMembers(rhId: Long?, groupInfo: GroupInfo, chatModel: ChatModel) {

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

@@ -62,7 +62,7 @@ fun DatabaseEncryptionView(m: ChatModel) {
       initialRandomDBPassphrase,
       progressIndicator,
       onConfirmEncrypt = {
-        withLongRunningApi {
+        withLongRunningApi(slow = 30_000, deadlock = 60_000) {
           encryptDatabase(currentKey, newKey, confirmNewKey, initialRandomDBPassphrase, useKeychain, storedKey, progressIndicator)
         }
       }

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

@@ -368,7 +368,7 @@ fun chatArchiveTitle(chatArchiveTime: Instant, chatLastStart: Instant): String {
 }
 
 fun startChat(m: ChatModel, chatLastStart: MutableState<Instant?>, chatDbChanged: MutableState<Boolean>, progressIndicator: MutableState<Boolean>? = null) {
-  withLongRunningApi {
+  withLongRunningApi(slow = 30_000, deadlock = 60_000) {
     try {
       progressIndicator?.value = true
       if (chatDbChanged.value) {
@@ -581,7 +581,7 @@ private fun importArchive(
   progressIndicator.value = true
   val archivePath = saveArchiveFromURI(importedArchiveURI)
   if (archivePath != null) {
-    withLongRunningApi {
+    withLongRunningApi(slow = 60_000, deadlock = 180_000) {
       try {
         m.controller.apiDeleteStorage()
         try {

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

@@ -12,7 +12,6 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.focus.*
 import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalClipboardManager
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.style.TextAlign
@@ -23,8 +22,6 @@ import chat.simplex.common.ui.theme.*
 import chat.simplex.res.MR
 import dev.icerock.moko.resources.StringResource
 import dev.icerock.moko.resources.compose.painterResource
-import dev.icerock.moko.resources.compose.stringResource
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 
 class AlertManager {
@@ -131,8 +128,6 @@ class AlertManager {
             ) {
               val focusRequester = remember { FocusRequester() }
               LaunchedEffect(Unit) {
-                // Wait before focusing to prevent auto-confirming if a user used Enter key on hardware keyboard
-                delay(200)
                 focusRequester.requestFocus()
               }
               TextButton(onClick = {
@@ -191,7 +186,6 @@ class AlertManager {
     title: String, text: String? = null,
     confirmText: String = generalGetString(MR.strings.ok),
     hostDevice: Pair<Long?, String>? = null,
-    shareText: Boolean? = null
   ) {
     showAlert {
       AlertDialog(
@@ -201,23 +195,12 @@ class AlertManager {
           AlertContent(text, hostDevice, extraPadding = true) {
             val focusRequester = remember { FocusRequester() }
             LaunchedEffect(Unit) {
-              // Wait before focusing to prevent auto-confirming if a user used Enter key on hardware keyboard
-              delay(200)
               focusRequester.requestFocus()
             }
-            // Can pass shareText = false to prevent showing Share button if it's needed in a specific case
-            val showShareButton = text != null && (shareText == true || (shareText == null && text.length > 500))
             Row(
               Modifier.fillMaxWidth().padding(horizontal = DEFAULT_PADDING),
-              horizontalArrangement = if (showShareButton) Arrangement.SpaceBetween else Arrangement.Center
+              horizontalArrangement = Arrangement.Center
             ) {
-              val clipboard = LocalClipboardManager.current
-              if (showShareButton && text != null) {
-                TextButton(onClick = {
-                  clipboard.shareText(text)
-                  hideAlert()
-                }) { Text(stringResource(MR.strings.share_verb)) }
-              }
               TextButton(
                 onClick = {
                   hideAlert()

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

@@ -1,21 +1,116 @@
 package chat.simplex.common.views.helpers
 
-import SectionItemView
+import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.CornerSize
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
+import dev.icerock.moko.resources.compose.painterResource
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Dialog
+import chat.simplex.common.ui.theme.DEFAULT_PADDING
 import chat.simplex.common.model.CustomTimeUnit
 import chat.simplex.common.model.timeText
 import chat.simplex.res.MR
+import com.sd.lib.compose.wheel_picker.*
 
 @Composable
-expect fun CustomTimePicker(
+fun CustomTimePicker(
   selection: MutableState<Int>,
   timeUnitsLimits: List<TimeUnitLimits> = TimeUnitLimits.defaultUnitsLimits
+) {
+  fun getUnitValues(unit: CustomTimeUnit, selectedValue: Int): List<Int> {
+    val unitLimits = timeUnitsLimits.firstOrNull { it.timeUnit == unit } ?: TimeUnitLimits.defaultUnitLimits(unit)
+    val regularUnitValues = (unitLimits.minValue..unitLimits.maxValue).toList()
+    return regularUnitValues + if (regularUnitValues.contains(selectedValue)) emptyList() else listOf(selectedValue)
+  }
+
+  val (unit, duration) = CustomTimeUnit.toTimeUnit(selection.value)
+  val selectedUnit: MutableState<CustomTimeUnit> = remember { mutableStateOf(unit) }
+  val selectedDuration = remember { mutableStateOf(duration) }
+  val selectedUnitValues = remember { mutableStateOf(getUnitValues(selectedUnit.value, selectedDuration.value)) }
+  val isTriggered = remember { mutableStateOf(false) }
+
+  LaunchedEffect(selectedUnit.value) {
+    // on initial composition, if passed selection doesn't fit into picker bounds, so that selectedDuration is bigger than selectedUnit maxValue
+    // (e.g., for selection = 121 seconds: selectedUnit would be Second, selectedDuration would be 121 > selectedUnit maxValue of 120),
+    // selectedDuration would've been replaced by maxValue - isTriggered check prevents this by skipping LaunchedEffect on initial composition
+    if (isTriggered.value) {
+      val maxValue = timeUnitsLimits.firstOrNull { it.timeUnit == selectedUnit.value }?.maxValue
+      if (maxValue != null && selectedDuration.value > maxValue) {
+        selectedDuration.value = maxValue
+        selectedUnitValues.value = getUnitValues(selectedUnit.value, selectedDuration.value)
+      } else {
+        selectedUnitValues.value = getUnitValues(selectedUnit.value, selectedDuration.value)
+        selection.value = selectedUnit.value.toSeconds * selectedDuration.value
+      }
+    } else {
+      isTriggered.value = true
+    }
+  }
+
+  LaunchedEffect(selectedDuration.value) {
+    selection.value = selectedUnit.value.toSeconds * selectedDuration.value
+  }
+
+  Row(
+    Modifier
+      .fillMaxWidth()
+      .padding(horizontal = DEFAULT_PADDING),
+    horizontalArrangement = Arrangement.spacedBy(0.dp)
+  ) {
+    Column(Modifier.weight(1f)) {
+      val durationPickerState = rememberFWheelPickerState(selectedUnitValues.value.indexOf(selectedDuration.value))
+      FVerticalWheelPicker(
+        count = selectedUnitValues.value.count(),
+        state = durationPickerState,
+        unfocusedCount = 2,
+        focus = {
+          FWheelPickerFocusVertical(dividerColor = MaterialTheme.colors.primary)
+        }
+      ) { index ->
+        Text(
+          selectedUnitValues.value[index].toString(),
+          fontSize = 18.sp,
+          color = MaterialTheme.colors.primary
         )
+      }
+      LaunchedEffect(durationPickerState) {
+        snapshotFlow { durationPickerState.currentIndex }
+          .collect {
+            selectedDuration.value = selectedUnitValues.value[it]
+          }
+      }
+    }
+    Column(Modifier.weight(1f)) {
+      val unitPickerState = rememberFWheelPickerState(timeUnitsLimits.indexOfFirst { it.timeUnit == selectedUnit.value })
+      FVerticalWheelPicker(
+        count = timeUnitsLimits.count(),
+        state = unitPickerState,
+        unfocusedCount = 2,
+        focus = {
+          FWheelPickerFocusVertical(dividerColor = MaterialTheme.colors.primary)
+        }
+      ) { index ->
+        Text(
+          timeUnitsLimits[index].timeUnit.text,
+          fontSize = 18.sp,
+          color = MaterialTheme.colors.primary
+        )
+      }
+      LaunchedEffect(unitPickerState) {
+        snapshotFlow { unitPickerState.currentIndex }
+          .collect {
+            selectedUnit.value = timeUnitsLimits[it].timeUnit
+          }
+      }
+    }
+  }
+}
 
 data class TimeUnitLimits(
   val timeUnit: CustomTimeUnit,
@@ -46,7 +141,8 @@ data class TimeUnitLimits(
   }
 }
 
-fun showCustomTimePickerDialog(
+@Composable
+fun CustomTimePickerDialog(
   selection: MutableState<Int>,
   timeUnitsLimits: List<TimeUnitLimits> = TimeUnitLimits.defaultUnitsLimits,
   title: String,
@@ -54,30 +150,57 @@ fun showCustomTimePickerDialog(
   confirmButtonAction: (Int) -> Unit,
   cancel: () -> Unit
 ) {
-  AlertManager.shared.showAlertDialogButtonsColumn(
-    title = title,
-    onDismissRequest = cancel
+  DefaultDialog(onDismissRequest = cancel) {
+    Surface(
+      shape = RoundedCornerShape(corner = CornerSize(25.dp)),
+      contentColor = LocalContentColor.current
     ) {
-    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+      Box(
+        contentAlignment = Alignment.Center
+      ) {
+        Column(
+          modifier = Modifier.padding(DEFAULT_PADDING),
+          verticalArrangement = Arrangement.spacedBy(6.dp),
+          horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+          Row(
+            modifier = Modifier.fillMaxWidth(),
+            horizontalArrangement = Arrangement.SpaceBetween,
+            verticalAlignment = Alignment.CenterVertically
+          ) {
+            Text(" ") // centers title
+            Text(
+              title,
+              fontSize = 16.sp,
+              color = MaterialTheme.colors.secondary
+            )
+            Icon(
+              painterResource(MR.images.ic_close),
+              generalGetString(MR.strings.icon_descr_close_button),
+              tint = MaterialTheme.colors.secondary,
+              modifier = Modifier
+                .size(25.dp)
+                .clickable { cancel() }
+            )
+          }
+
           CustomTimePicker(
             selection,
             timeUnitsLimits
           )
-      SectionItemView({
-        AlertManager.shared.hideAlert()
-        confirmButtonAction(selection.value)
-      }
-      ) {
+
+          TextButton(onClick = { confirmButtonAction(selection.value) }) {
             Text(
               confirmButtonText,
-          Modifier.fillMaxWidth(),
-          textAlign = TextAlign.Center,
+              fontSize = 18.sp,
               color = MaterialTheme.colors.primary
             )
           }
         }
       }
     }
+  }
+}
 
 @Composable
 fun DropdownCustomTimePickerSettingRow(
@@ -97,6 +220,7 @@ fun DropdownCustomTimePickerSettingRow(
 
   val dropdownSelection: MutableState<DropdownSelection> = remember { mutableStateOf(DropdownSelection.DropdownValue(selection.value)) }
   val values: MutableState<List<DropdownSelection>> = remember { mutableStateOf(getValues(selection.value)) }
+  val showCustomTimePicker = remember { mutableStateOf(false) }
 
   fun updateValue(selectedValue: Int?) {
     values.value = getValues(selectedValue)
@@ -123,23 +247,29 @@ fun DropdownCustomTimePickerSettingRow(
     onSelected = { sel: DropdownSelection ->
       when (sel) {
         is DropdownSelection.DropdownValue -> updateValue(sel.value)
-        DropdownSelection.Custom -> {
-          val selectedCustomTime = mutableStateOf(selection.value ?: 86400)
-          showCustomTimePickerDialog(
+        DropdownSelection.Custom -> showCustomTimePicker.value = true
+      }
+    }
+  )
+
+  if (showCustomTimePicker.value) {
+    val selectedCustomTime = remember { mutableStateOf(selection.value ?: 86400) }
+    CustomTimePickerDialog(
       selectedCustomTime,
       timeUnitsLimits = customPickerTimeUnitsLimits,
       title = customPickerTitle,
       confirmButtonText = customPickerConfirmButtonText,
-            confirmButtonAction = ::updateValue,
+      confirmButtonAction = { time ->
+        updateValue(time)
+        showCustomTimePicker.value = false
+      },
       cancel = {
         dropdownSelection.value = DropdownSelection.DropdownValue(selection.value)
+        showCustomTimePicker.value = false
       }
     )
   }
 }
-    }
-  )
-}
 
 private sealed class DropdownSelection {
   data class DropdownValue(val value: Int?): DropdownSelection()

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

@@ -5,7 +5,6 @@ import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import chat.simplex.common.ui.theme.DEFAULT_PADDING
 
@@ -21,7 +20,7 @@ fun DefaultProgressView(description: String?) {
         strokeWidth = 2.5.dp
       )
       if (description != null) {
-        Text(description, textAlign = TextAlign.Center)
+        Text(description)
       }
     }
   }

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

@@ -61,10 +61,10 @@ class ModalManager(private val placement: ModalPlacement? = null) {
     }
   }
 
-  fun showModalCloseable(settings: Boolean = false, showClose: Boolean = true, endButtons: @Composable RowScope.() -> Unit = {}, content: @Composable ModalData.(close: () -> Unit) -> Unit) {
+  fun showModalCloseable(settings: Boolean = false, showClose: Boolean = true, content: @Composable ModalData.(close: () -> Unit) -> Unit) {
     val data = ModalData()
     showCustomModal { close ->
-      ModalView(close, showClose = showClose, endButtons = endButtons, content = { data.content(close) })
+      ModalView(close, showClose = showClose, content = { data.content(close) })
     }
   }
 

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

@@ -16,7 +16,7 @@ class ProcessedErrors <T: AgentErrorType>(val interval: Long) {
 
   fun newError(error: T, offerRestart: Boolean) {
     timer.cancel()
-    timer = withLongRunningApi(slow = 130_000) {
+    timer = withLongRunningApi(slow = 70_000, deadlock = 130_000) {
       val delayBeforeNext = (lastShownTimestamp + interval) - System.currentTimeMillis()
       if ((lastShownOfferRestart || !offerRestart) && delayBeforeNext >= 0) {
         delay(delayBeforeNext)

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

@@ -198,16 +198,16 @@ fun <T> SectionItemWithValue(
 }
 
 @Composable
-fun SectionTextFooter(text: String, color: Color = MaterialTheme.colors.secondary) {
-  SectionTextFooter(AnnotatedString(text), color = color)
+fun SectionTextFooter(text: String) {
+  SectionTextFooter(AnnotatedString(text))
 }
 
 @Composable
-fun SectionTextFooter(text: AnnotatedString, textAlign: TextAlign = TextAlign.Start, color: Color = MaterialTheme.colors.secondary) {
+fun SectionTextFooter(text: AnnotatedString, textAlign: TextAlign = TextAlign.Start) {
   Text(
     text,
     Modifier.padding(start = DEFAULT_PADDING, end = DEFAULT_PADDING, top = DEFAULT_PADDING_HALF).fillMaxWidth(0.9F),
-    color = color,
+    color = MaterialTheme.colors.secondary,
     lineHeight = 18.sp,
     fontSize = 14.sp,
     textAlign = textAlign

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

@@ -37,22 +37,30 @@ fun withBGApi(action: suspend CoroutineScope.() -> Unit): Job =
     CoroutineScope(singleThreadDispatcher).launch(block = { wrapWithLogging(action, it) })
   }
 
-fun withLongRunningApi(slow: Long = Long.MAX_VALUE, action: suspend CoroutineScope.() -> Unit): Job =
+fun withLongRunningApi(slow: Long = Long.MAX_VALUE, deadlock: Long = Long.MAX_VALUE, action: suspend CoroutineScope.() -> Unit): Job =
   Exception().let {
-    CoroutineScope(Dispatchers.Default).launch(block = { wrapWithLogging(action, it, slow = slow) })
+    CoroutineScope(Dispatchers.Default).launch(block = { wrapWithLogging(action, it, slow = slow, deadlock = deadlock) })
   }
 
-private suspend fun wrapWithLogging(action: suspend CoroutineScope.() -> Unit, exception: java.lang.Exception, slow: Long = 20_000) = coroutineScope {
+private suspend fun wrapWithLogging(action: suspend CoroutineScope.() -> Unit, exception: java.lang.Exception, slow: Long = 10_000, deadlock: Long = 60_000) = coroutineScope {
   val start = System.currentTimeMillis()
+  val job = launch {
+    delay(deadlock)
+    Log.e(TAG, "Possible deadlock of the thread, not finished after ${deadlock / 1000}s:\n${exception.stackTraceToString()}")
+    AlertManager.shared.showAlertMsg(
+      title = generalGetString(MR.strings.possible_deadlock_title),
+      text = generalGetString(MR.strings.possible_deadlock_desc).format(deadlock / 1000, exception.stackTraceToString()),
+    )
+  }
   action()
+  job.cancel()
+  if (appPreferences.developerTools.get() && appPreferences.showSlowApiCalls.get()) {
     val end = System.currentTimeMillis()
     if (end - start > slow) {
       Log.e(TAG, "Possible problem with execution of the thread, took ${(end - start) / 1000}s:\n${exception.stackTraceToString()}")
-    if (appPreferences.developerTools.get() && appPreferences.showSlowApiCalls.get()) {
       AlertManager.shared.showAlertMsg(
         title = generalGetString(MR.strings.possible_slow_function_title),
         text = generalGetString(MR.strings.possible_slow_function_desc).format((end - start) / 1000, exception.stackTraceToString()),
-        shareText = true
       )
     }
   }

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

@@ -49,7 +49,7 @@ fun LocalAuthView(m: ChatModel, authRequest: LocalAuthRequest) {
 }
 
 private fun deleteStorageAndRestart(m: ChatModel, password: String, completed: (LAResult) -> Unit) {
-  withLongRunningApi {
+  withLongRunningApi(slow = 30_000, deadlock = 60_000) {
     try {
       /** Waiting until [initChatController] finishes */
       while (m.ctrlInitInProgress.value) {

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

@@ -50,7 +50,7 @@ fun SetupDatabasePassphrase(m: ChatModel) {
     confirmNewKey,
     progressIndicator,
     onConfirmEncrypt = {
-      withLongRunningApi {
+      withLongRunningApi(slow = 30_000, deadlock = 60_000) {
         if (m.chatRunning.value == true) {
           // Stop chat if it's started before doing anything
           stopChatAsync(m)

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

@@ -47,6 +47,10 @@ fun NetworkAndServersView(
   val onionHosts = remember { mutableStateOf(netCfg.onionHosts) }
   val sessionMode = remember { mutableStateOf(netCfg.sessionMode) }
 
+  LaunchedEffect(Unit) {
+    chatModel.userSMPServersUnsaved.value = null
+  }
+
   val proxyPort = remember { derivedStateOf { chatModel.controller.appPrefs.networkProxyHostPort.state.value?.split(":")?.lastOrNull()?.toIntOrNull() ?: 9050 } }
   NetworkAndServersLayout(
     currentRemoteHost = currentRemoteHost,

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

@@ -96,7 +96,7 @@ fun PrivacySettingsView(
     val currentUser = chatModel.currentUser.value
     if (currentUser != null) {
       fun setSendReceiptsContacts(enable: Boolean, clearOverrides: Boolean) {
-        withLongRunningApi(slow = 60_000) {
+        withLongRunningApi(slow = 30_000, deadlock = 60_000) {
           val mrs = UserMsgReceiptSettings(enable, clearOverrides)
           chatModel.controller.apiSetUserContactReceipts(currentUser, mrs)
           chatModel.controller.appPrefs.privacyDeliveryReceiptsSet.set(true)
@@ -119,7 +119,7 @@ fun PrivacySettingsView(
       }
 
       fun setSendReceiptsGroups(enable: Boolean, clearOverrides: Boolean) {
-        withLongRunningApi(slow = 60_000) {
+        withLongRunningApi(slow = 30_000, deadlock = 60_000) {
           val mrs = UserMsgReceiptSettings(enable, clearOverrides)
           chatModel.controller.apiSetUserGroupReceipts(currentUser, mrs)
           chatModel.controller.appPrefs.privacyDeliveryReceiptsSet.set(true)

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

@@ -28,18 +28,19 @@ import chat.simplex.res.MR
 @Composable
 fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: ServerProtocol, close: () -> Unit) {
   var presetServers by remember(rhId) { mutableStateOf(emptyList<String>()) }
-  var servers by remember { stateGetOrPut("servers") { emptyList<ServerCfg>() } }
-  var serversAlreadyLoaded by remember { stateGetOrPut("serversAlreadyLoaded") { false } }
+  var servers by remember(rhId) {
+    mutableStateOf(m.userSMPServersUnsaved.value ?: emptyList())
+  }
   val currServers = remember(rhId) { mutableStateOf(servers) }
   val testing = rememberSaveable(rhId) { mutableStateOf(false) }
-  val serversUnchanged = remember(servers) { derivedStateOf { servers == currServers.value || testing.value } }
-  val allServersDisabled = remember { derivedStateOf { servers.none { it.enabled } } }
-  val saveDisabled = remember(servers) {
+  val serversUnchanged = remember { derivedStateOf { servers == currServers.value || testing.value } }
+  val allServersDisabled = remember { derivedStateOf { servers.all { !it.enabled } } }
+  val saveDisabled = remember {
     derivedStateOf {
       servers.isEmpty() ||
       servers == currServers.value ||
       testing.value ||
-      servers.none { srv ->
+      !servers.all { srv ->
         val address = parseServerAddress(srv.server)
         address != null && uniqueAddress(srv, address, servers)
       } ||
@@ -48,8 +49,8 @@ fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: Ser
   }
 
   KeyChangeEffect(rhId) {
+    m.userSMPServersUnsaved.value = null
     servers = emptyList()
-    serversAlreadyLoaded = false
   }
 
   LaunchedEffect(rhId) {
@@ -58,9 +59,8 @@ fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: Ser
       if (res != null) {
         currServers.value = res.protoServers
         presetServers = res.presetServers
-        if (servers.isEmpty() && !serversAlreadyLoaded) {
+        if (servers.isEmpty()) {
           servers = currServers.value
-          serversAlreadyLoaded = true
         }
       }
     }
@@ -80,11 +80,13 @@ fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: Ser
           newServers.add(index, updated)
           old = updated
           servers = newServers
+          m.userSMPServersUnsaved.value = servers
         },
         onDelete = {
           val newServers = ArrayList(servers)
           newServers.removeAt(index)
           servers = newServers
+          m.userSMPServersUnsaved.value = servers
           close()
         })
     }
@@ -123,6 +125,7 @@ fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: Ser
                     ScanProtocolServer(rhId) {
                       close()
                       servers = servers + it
+                      m.userSMPServersUnsaved.value = servers
                     }
                   }
                 }
@@ -147,11 +150,13 @@ fun ModalData.ProtocolServersView(m: ChatModel, rhId: Long?, serverProtocol: Ser
         testServersJob.value = withLongRunningApi {
           testServers(testing, servers, m) {
             servers = it
+            m.userSMPServersUnsaved.value = servers
           }
         }
       },
       resetServers = {
-        servers = currServers.value
+        servers = currServers.value ?: emptyList()
+        m.userSMPServersUnsaved.value = null
       },
       saveSMPServers = {
         saveServers(rhId, serverProtocol, currServers, servers, m)
@@ -350,6 +355,7 @@ private fun saveServers(rhId: Long?, protocol: ServerProtocol, currServers: Muta
   withBGApi {
     if (m.controller.setUserProtoServers(rhId, protocol, servers)) {
       currServers.value = servers
+      m.userSMPServersUnsaved.value = null
     }
     afterSave()
   }

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

@@ -1588,6 +1588,8 @@
     <string name="remote_ctrl_error_busy">سطح المكتب مشغول</string>
     <string name="remote_ctrl_error_bad_version">يحتوي سطح المكتب على إصدار غير مدعوم. يُرجى التأكد من استخدام نفس الإصدار على كلا الجهازين</string>
     <string name="past_member_vName">العضو السابق %1$s</string>
+    <string name="possible_deadlock_title">مأزق</string>
+    <string name="possible_deadlock_desc">يستغرق تنفيذ التعليمات البرمجية وقتًا طويلاً جدًا: %1$d ثانية. من المحتمل أن التطبيق مجمّد: %2$s</string>
     <string name="possible_slow_function_title">وظيفة بطيئة</string>
     <string name="developer_options_section">خيارات المطور</string>
     <string name="profile_update_event_member_name_changed">تغيّر العضو %1$s إلى %2$s</string>

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

@@ -16,7 +16,6 @@
 
   <!-- MainActivity.kt -->
   <string name="opening_database">Opening database…</string>
-  <string name="database_migration_in_progress">Database migration is in progress.\nIt may take a few minutes.</string>
   <string name="non_content_uri_alert_title">Invalid file path</string>
   <string name="non_content_uri_alert_text">You shared an invalid file path. Report the issue to the app developers.</string>
   <string name="app_was_crashed">View crashed</string>
@@ -147,6 +146,8 @@
   <string name="smp_server_test_delete_file">Delete file</string>
   <string name="error_deleting_user">Error deleting user profile</string>
   <string name="error_updating_user_privacy">Error updating user privacy</string>
+  <string name="possible_deadlock_title">Deadlock</string>
+  <string name="possible_deadlock_desc">Execution of code takes too long time: %1$d seconds. Probably, the app is frozen: %2$s</string>
   <string name="possible_slow_function_title">Slow function</string>
   <string name="possible_slow_function_desc">Execution of function takes too long time: %1$d seconds: %2$s</string>
 
@@ -1376,11 +1377,9 @@
   <!-- GroupWelcomeView.kt -->
   <string name="group_welcome_title">Welcome message</string>
   <string name="save_welcome_message_question">Save welcome message?</string>
-  <string name="welcome_message_is_too_long">Welcome message is too long</string>
   <string name="save_and_update_group_profile">Save and update group profile</string>
   <string name="group_welcome_preview">Preview</string>
   <string name="enter_welcome_message">Enter welcome message…</string>
-  <string name="message_too_large">Message too large</string>
 
   <!-- ConnectionStats -->
   <string name="conn_stats_section_title_servers">SERVERS</string>

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

@@ -1555,6 +1555,7 @@
     <string name="chat_is_stopped_you_should_transfer_database">Чатът е спрян. Ако вече сте използвали тази база данни на друго устройство, трябва да я прехвърлите обратно, преди да стартирате чата отново.</string>
     <string name="remote_ctrl_error_bad_invitation">Настолното устройство има грешен код за връзка</string>
     <string name="remote_ctrl_error_bad_version">Настолното устройство е с неподдържана версия. Моля, уверете се, че използвате една и съща версия и на двете устройства</string>
+    <string name="possible_deadlock_desc">Изпълнението на кода отнема твърде много време: %1$d секунди. Вероятно приложението е замразено: %2$s</string>
     <string name="possible_slow_function_title">Бавна функция</string>
     <string name="possible_slow_function_desc">Изпълнението на функцията отнема твърде много време: %1$d секунди: %2$s</string>
     <string name="show_internal_errors">Покажи вътрешните грешки</string>
@@ -1590,4 +1591,5 @@
 \nПрепоръчително е да рестартирате приложението.</string>
     <string name="developer_options_section">Опции за разработчици</string>
     <string name="show_slow_api_calls">Показване на бавни API заявки</string>
+    <string name="possible_deadlock_title">Грешка в заключено положение</string>
 </resources>

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

@@ -1672,7 +1672,9 @@
     <string name="possible_slow_function_title">Langsame Funktion</string>
     <string name="show_slow_api_calls">Zeige langsame API-Aufrufe an</string>
     <string name="group_member_status_unknown_short">unbekannt</string>
+    <string name="possible_deadlock_title">Blockade</string>
     <string name="developer_options_section">Optionen für Entwickler</string>
+    <string name="possible_deadlock_desc">Die Code-Ausführung dauert zu lange: %1$d Sekunden. Wahrscheinlich ist die App eingefroren: %2$s</string>
     <string name="group_member_status_unknown">unbekannter Gruppenmitglieds-Status</string>
     <string name="v5_5_private_notes_descr">Mit verschlüsselten Dateien und Medien.</string>
     <string name="v5_5_private_notes">Private Notizen</string>

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

@@ -1559,9 +1559,11 @@
     <string name="remote_host_error_bad_state"><![CDATA[État médiocre de la connexion au mobile <b>%s</b>.]]></string>
     <string name="remote_ctrl_was_disconnected_title">Connexion interrompue</string>
     <string name="remote_ctrl_error_bad_state">État médiocre de la connexion avec le bureau</string>
+    <string name="possible_deadlock_title">Impasse</string>
     <string name="remote_ctrl_error_bad_version">La version de l\'ordinateur de bureau n\'est pas prise en charge. Veillez à utiliser la même version sur les deux appareils.</string>
     <string name="remote_ctrl_error_disconnected">Le bureau a été déconnecté</string>
     <string name="developer_options_section">Options pour les développeurs</string>
+    <string name="possible_deadlock_desc">Le code prend trop de temps à s\'exécuter : %1$d secondes. Il est probable que l\'application soit figée : %2$s</string>
     <string name="agent_internal_error_title">Erreur interne</string>
     <string name="remote_host_error_bad_version"><![CDATA[La version du mobile <b>%s</b> n\'est pas prise en charge. Veillez à utiliser la même version sur les deux appareils.]]></string>
     <string name="show_internal_errors">Afficher les erreurs internes</string>

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

@@ -1583,7 +1583,9 @@
     <string name="possible_slow_function_title">Lassú funkció</string>
     <string name="show_slow_api_calls">Lassú API-hívások megjelenítése</string>
     <string name="remote_host_error_inactive"><![CDATA[A(z) <b>%s</b> mobil eszköz inaktív]]></string>
+    <string name="possible_deadlock_title">Elakadt</string>
     <string name="developer_options_section">Fejlesztői beállítások</string>
+    <string name="possible_deadlock_desc">A kód végrehajtása túl sokáig tart: %1$d másodperc. Valószínűleg az alkalmazás lefagyott: %2$s</string>
     <string name="possible_slow_function_desc">A funkció végrehajtása túl sokáig tart: %1$d másodperc: %2$s</string>
     <string name="remote_host_error_busy"><![CDATA[A(z) <b>%s</b> mobil eszköz elfoglalt]]></string>
     <string name="past_member_vName">Legutóbbi tag %1$s</string>

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

@@ -1591,7 +1591,9 @@
     <string name="possible_slow_function_title">Funzione lenta</string>
     <string name="show_slow_api_calls">Mostra chiamate API lente</string>
     <string name="group_member_status_unknown_short">sconosciuto</string>
+    <string name="possible_deadlock_desc">L\'esecuzione del codice impiega troppo tempo: %1$d secondi. Probabilmente l\'app è congelata: %2$s</string>
     <string name="group_member_status_unknown">stato sconosciuto</string>
+    <string name="possible_deadlock_title">Stallo</string>
     <string name="developer_options_section">Opzioni sviluppatore</string>
     <string name="v5_5_private_notes">Note private</string>
     <string name="v5_5_new_interface_languages">Interfaccia in ungherese e turco</string>

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

@@ -1571,7 +1571,9 @@
     <string name="remote_ctrl_error_busy">PC版が処理中</string>
     <string name="remote_ctrl_error_disconnected">PC版が切断されました</string>
     <string name="remote_ctrl_error_bad_version">ご利用のPC版のバージョンがサポートされてません。両端末が同じバージョンかどうか、ご確認ください。</string>
+    <string name="possible_deadlock_title">デッドロック状態</string>
     <string name="developer_options_section">開発者向けの設定</string>
+    <string name="possible_deadlock_desc">処理時間が異常にかかるようです: %1$d 秒。アプリが固まった恐れがあります: %2$s</string>
     <string name="remote_host_error_busy"><![CDATA[携帯版 <b>%s</b> がただいま処理中]]></string>
     <string name="possible_slow_function_desc">機能の処理時間が以上にかかってます: %1$d 秒: %2$s</string>
     <string name="show_internal_errors">内部エラーを表示</string>

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

@@ -1574,6 +1574,7 @@
     <string name="remote_host_error_missing"><![CDATA[Mobiel <b>%s</b> ontbreekt]]></string>
     <string name="remote_host_error_bad_state"><![CDATA[De verbinding met de mobiel <b>%s</b> is in slechte staat]]></string>
     <string name="remote_ctrl_error_disconnected">De verbinding met desktop is verbroken</string>
+    <string name="possible_deadlock_title">Impasse</string>
     <string name="possible_slow_function_desc">Uitvoering van functie duurt te lang: %1$d seconden: %2$s</string>
     <string name="possible_slow_function_title">Langzame functie</string>
     <string name="developer_options_section">Ontwikkelaars opties</string>
@@ -1587,6 +1588,7 @@
     <string name="restart_chat_button">Chat opnieuw starten</string>
     <string name="remote_host_error_timeout"><![CDATA[Time-out bereikt tijdens het verbinden met de mobiel <b>%s</b>]]></string>
     <string name="remote_ctrl_error_bad_state">De verbinding met de desktop is in slechte staat</string>
+    <string name="possible_deadlock_desc">Het uitvoeren van de code duurt te lang: %1$d seconden. Waarschijnlijk is de app vastgelopen: %2$s</string>
     <string name="remote_ctrl_error_bad_invitation">Desktop heeft verkeerde uitnodigingscode</string>
     <string name="remote_host_error_bad_version"><![CDATA[Mobiel <b>%s</b> heeft een niet-ondersteunde versie. Zorg ervoor dat u op beide apparaten dezelfde versie gebruikt]]></string>
     <string name="remote_ctrl_error_timeout">Time-out bereikt tijdens het verbinden met de desktop</string>

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

@@ -1606,6 +1606,7 @@
     <string name="remote_ctrl_error_bad_version">Komputer ma niewspieraną wersję. Proszę upewnić się, że używasz tych samych wersji na obu urządzeniach</string>
     <string name="blocked_by_admin_items_description">%d wiadomości zablokowanych przez admina</string>
     <string name="error_creating_message">Błąd tworzenia wiadomości</string>
+    <string name="possible_deadlock_desc">Wykonanie kodu zajmuje za dużo czasu: %1$d sekund. Prawdopodobnie aplikacja jest zamrożona: %2$s</string>
     <string name="possible_slow_function_desc">Wykonanie kodu zajmuje za dużo czasu: %1$d sekund: %2$s</string>
     <string name="note_folder_local_display_name">Prywatne notatki</string>
     <string name="group_member_status_unknown">nieznany status</string>
@@ -1620,6 +1621,7 @@
     <string name="remote_host_error_inactive"><![CDATA[Telefon <b>%s</b> jest nieaktywny]]></string>
     <string name="remote_host_error_bad_version"><![CDATA[Telefon <b>%s</b> ma niewspieraną wersję. Proszę, upewnij się, że używasz tej samej wersji na obydwu urządzeniach]]></string>
     <string name="group_member_status_unknown_short">nieznany</string>
+    <string name="possible_deadlock_title">Blokada</string>
     <string name="profile_update_event_contact_name_changed">kontakt %1$s zmieniony na %2$s</string>
     <string name="profile_update_event_removed_address">usunięto adres kontaktu</string>
     <string name="profile_update_event_removed_picture">usunięto zdjęcie profilu</string>

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

@@ -1680,6 +1680,8 @@
     <string name="error_showing_message">ошибка отображения сообщения</string>
     <string name="error_showing_content">ошибка отображения содержания</string>
     <string name="remote_ctrl_disconnected_with_reason">Отсоединён по причине: %s</string>
+    <string name="possible_deadlock_title">Взаимная блокировка</string>
+    <string name="possible_deadlock_desc">Выполнение задачи занимает долгое время: %1$d секунд. Возможно, приложение заблокировано: %2$s</string>
     <string name="possible_slow_function_desc">Выполнение задачи занимает долгое время: %1$d секунд: %2$s</string>
     <string name="possible_slow_function_title">Медленный вызов</string>
     <string name="profile_update_event_contact_name_changed">контакт %1$s изменён на %2$s</string>

apps/multiplatform/common/src/commonMain/resources/MR/zh-rCN/strings.xml

@@ -1586,6 +1586,8 @@
     <string name="remote_host_error_bad_state"><![CDATA[到移动主机 <b>%s</b>的连接状态不佳]]></string>
     <string name="remote_host_error_timeout"><![CDATA[连接到移动主机<b>%s</b>时超时]]></string>
     <string name="failed_to_create_user_invalid_desc">显示名无效。请另选一个名称。</string>
+    <string name="possible_deadlock_title">死锁</string>
+    <string name="possible_deadlock_desc">代码执行花费的时间过久：%1$d秒。应用可能卡住了：%2$s</string>
     <string name="possible_slow_function_title">慢函数</string>
     <string name="show_slow_api_calls">显示缓慢的 API 调用</string>
     <string name="past_member_vName">过往成员 %1$s</string>

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/DesktopApp.kt

@@ -14,7 +14,8 @@ import androidx.compose.ui.input.key.*
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.*
-import chat.simplex.common.model.*
+import chat.simplex.common.model.ChatController
+import chat.simplex.common.model.ChatModel
 import chat.simplex.common.platform.*
 import chat.simplex.common.ui.theme.DEFAULT_START_MODAL_WIDTH
 import chat.simplex.common.ui.theme.SimpleXTheme
@@ -39,8 +40,7 @@ fun showApp() {
           WindowExceptionHandler { e ->
             AlertManager.shared.showAlertMsg(
               title = generalGetString(MR.strings.app_was_crashed),
-              text = e.stackTraceToString(),
-              shareText = true
+              text = e.stackTraceToString()
             )
             Log.e(TAG, "App crashed, thread name: " + Thread.currentThread().name + ", exception: " + e.stackTraceToString())
             window.dispatchEvent(WindowEvent(window, WindowEvent.WINDOW_CLOSING))

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/chat/item/ChatItemView.desktop.kt

@@ -42,7 +42,7 @@ actual fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserL
     }
     var fileSource = getLoadedFileSource(cItem.file)
     if (chatModel.connectedToRemote() && fileSource == null) {
-      withLongRunningApi(slow = 600_000) {
+      withLongRunningApi(slow = 60_000, deadlock = 600_000) {
         cItem.file?.loadRemoteFile(true)
         fileSource = getLoadedFileSource(cItem.file)
         saveIfExists()
@@ -51,7 +51,7 @@ actual fun SaveContentItemAction(cItem: ChatItem, saveFileLauncher: FileChooserL
   })
 }
 
-actual fun copyItemToClipboard(cItem: ChatItem, clipboard: ClipboardManager) = withLongRunningApi(slow = 600_000) {
+actual fun copyItemToClipboard(cItem: ChatItem, clipboard: ClipboardManager) = withLongRunningApi(slow = 60_000, deadlock = 600_000) {
   var fileSource = getLoadedFileSource(cItem.file)
   if (chatModel.connectedToRemote() && fileSource == null) {
     cItem.file?.loadRemoteFile(true)

apps/multiplatform/common/src/desktopMain/kotlin/chat/simplex/common/views/helpers/CustomTimePicker.desktop.kt

@@ -1,80 +0,0 @@
-package chat.simplex.common.views.helpers
-
-import androidx.compose.foundation.layout.*
-import androidx.compose.material.MaterialTheme
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import chat.simplex.common.model.CustomTimeUnit
-import chat.simplex.common.ui.theme.DEFAULT_PADDING
-
-@Composable
-actual fun CustomTimePicker(
-  selection: MutableState<Int>,
-  timeUnitsLimits: List<TimeUnitLimits>
-) {
-  val unit = remember {
-    var res: CustomTimeUnit = CustomTimeUnit.Second
-    val found = timeUnitsLimits.asReversed().any {
-      if (selection.value >= it.minValue * it.timeUnit.toSeconds && selection.value <= it.maxValue * it.timeUnit.toSeconds) {
-        res = it.timeUnit
-        selection.value = (selection.value / it.timeUnit.toSeconds).coerceIn(it.minValue, it.maxValue) * it.timeUnit.toSeconds
-        true
-      } else {
-        false
-      }
-    }
-    if (!found) {
-      // If custom interval doesn't fit in any category, set it to 1 second interval
-      selection.value = 1
-    }
-    mutableStateOf(res)
-  }
-  val values = remember(unit.value) {
-    val limit = timeUnitsLimits.first { it.timeUnit == unit.value }
-    val res = ArrayList<Pair<Int, String>>()
-    for (i in limit.minValue..limit.maxValue) {
-      val seconds = i * limit.timeUnit.toSeconds
-      val desc = i.toString()
-      res.add(seconds to desc)
-    }
-    if (res.none { it.first == selection.value }) {
-      // Doesn't fit into min..max, put it equal to the closest value
-      selection.value = selection.value.coerceIn(res.first().first, res.last().first)
-      //selection.value = res.last { it.first <= selection.value }.first
-    }
-    res
-  }
-  val units = remember {
-    val res = ArrayList<Pair<CustomTimeUnit, String>>()
-    for (unit in timeUnitsLimits) {
-      res.add(unit.timeUnit to unit.timeUnit.text)
-    }
-    res
-  }
-
-  Row(
-    Modifier.padding(bottom = DEFAULT_PADDING),
-    verticalAlignment = Alignment.CenterVertically,
-    horizontalArrangement = Arrangement.SpaceEvenly
-  ) {
-    ExposedDropDownSetting(
-      values,
-      selection,
-      textColor = MaterialTheme.colors.onBackground,
-      enabled = remember { mutableStateOf(true) },
-      onSelected = { selection.value = it }
-    )
-    Spacer(Modifier.width(DEFAULT_PADDING))
-    ExposedDropDownSetting(
-      units,
-      unit,
-      textColor = MaterialTheme.colors.onBackground,
-      enabled = remember { mutableStateOf(true) },
-      onSelected = {
-        selection.value = selection.value / unit.value.toSeconds * it.toSeconds
-        unit.value = it
-      }
-    )
-  }
-}

apps/multiplatform/gradle.properties

@@ -25,11 +25,11 @@ android.nonTransitiveRClass=true
 android.enableJetifier=true
 kotlin.mpp.androidSourceSetLayoutVersion=2
 
-android.version_name=5.5.5
-android.version_code=185
+android.version_name=5.5
+android.version_code=175
 
-desktop.version_name=5.5.5
-desktop.version_code=31
+desktop.version_name=5.5
+desktop.version_code=26
 
 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 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](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).
 
 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.
+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).
 
 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://supernovas.space/detailed_reviews.html#simplex) and increased [SimpleX Chat recommendation ratings](https://supernovas.space/messengers.html).
+- Supernova published [the review](https://supernova.tilde.team/detailed_reviews.html#simplex) and increased [SimpleX Chat recommendation ratings](https://supernova.tilde.team/messengers.html).
 
 ## What's new in v4.3
 

blog/20240124-simplex-chat-infrastructure-costs-v5-5-simplex-ux-private-notes-group-history.md

@@ -1,119 +0,0 @@
----
-layout: layouts/article.html
-title: "SimpleX Chat: free infrastructure from Linode, v5.5 released with private notes, group history and a simpler UX to connect."
-date: 2024-01-24
-previewBody: blog_previews/20240124.html
-image: images/20240124-connect1.png
-permalink: "/blog/20240124-simplex-chat-infrastructure-costs-v5-5-simplex-ux-private-notes-group-history.html"
----
-
-# SimpleX Chat: free infrastructure from Linode, v5.5 released with private notes, group history and a simpler UX to connect.
-
-**Published:** Jan 24, 2024
-
-[SimpleX Chat infrastructure on Linode](#simplex-chat-infrastructure-on-linode):
-- Free infrastructure.
-- SimpleX servers in Linode Marketplace.
-- High capacity messaging servers.
-
-What's new in v5.5:
-- [private notes](#private-notes)
-- [group history](#group-history)
-- [simpler UX to connect to other users](#simpler-ux-to-connect-to-other-users)
-- [message delivery stability and other improvements](#message-delivery-stability-and-other-improvements)
-
-Also, we added Hungarian (only Android) and Turkish interface languages, thanks to [our users and Weblate](https://github.com/simplex-chat/simplex-chat#help-translating-simplex-chat).
-
-SimpleX Chat Android app is now available in 20 languages!
-
-## SimpleX Chat infrastructure on Linode
-
-We chose Linode as our hosting provider as and they have been consistently reliable, cheaper than alternatives, with excellent support and great documentation.
-
-When Linode was acquired by Akamai, we were a bit nervous about how it may affect service quality. So far it's been working out quite well.
-
-As the usage of SimpleX network was growing, so did our hosting costs, and from being really small they started to become significant, particularly as we didn't yet manage to optimize the servers last year.
-
-Linode helped - we're really excited to announce that Akamai decided to support SimpleX Chat growth by accepting it into their [Linode Rise startup program](https://www.linode.com/linode-for-startups/).
-
-Thanks to this program:
-
-- we received free infrastructure for the first year up to $10,000 per month, no strings attached. It already saved us some money, and gave us enough time to optimize the servers - the latest version of the servers are much less costly to operate with the current traffic, and can support a much larger traffic within this limit. In the year 2 of the program we will receive 50% discount with unlimited traffic, and in year 3 - 25% discount.
-
-- Linode Marketplace now includes [SimpleX Chat messages and file servers](https://www.linode.com/marketplace/apps/simplex-chat/simplex-chat/) - you can get free $100 credits for the first 2 months and run your own servers in just a few clicks, and use them in SimpleX Chat apps. Anybody can submit their application to Linode marketplace, but dedicated support we have from Linode team via this program made it simpler.
-
-- Akamai solution engineers are helping us to design high capacity server solution, free of charge, so that a single host can provide horizontally scalable capacity for messaging, allowing for a much larger number of concurrent users on a single server address. Initially we considered using HAProxy, and the latest proof of concept uses OpenResty - a fork of Nginx with Lua script engine - to route requests from a single host to multiple SMP relays, reducing an overhead for the clients that would be configured with a smaller number of higher capacity servers. This project is still in progress, there will be more details as we roll it out.
-
-## What's new in v5.5
-
-### Private notes
-
-<img src="./images/20240124-notes1.png" width="220" class="float-to-left"> <img src="./images/20240124-notes2.png" width="220" class="float-to-left">
-
-*"Where do I put notes for myself?"* was a very common support question. There was a workaround - you could create an empty group, just with yourself, and use it to save notes, but it was not very convenient, and you could accidentally add members there.
-
-This version has a more convenient and private alternative - the Private notes. It looks like an ordinary conversation where you can put text messages, links with previews, and any media and files, but they are not sent anywhere - they are stored locally, only on your device, with encrypted files.
-
-You can access the Private notes created in mobile app from desktop app too, by linking a mobile and desktop apps - the feature [added in the previous version](./20231125-simplex-chat-v5-4-link-mobile-desktop-quantum-resistant-better-groups.md). It allows to conveniently share files between the devices without sending them over the Internet.
-
-### Group history
-
-<img src="./images/20240124-history1.png" width="220" class="float-to-left"> <img src="./images/20240124-history2.png" width="220" class="float-to-left">
-
-In the previous version, when users joined groups, they only saw an empty conversation, and the notifications of being connected to other members. This version allows group admins sending recent group history to the new members - this option is enabled by default for new groups, and can be enabled for the existing groups in the preferences. So now new members can join the conversation as soon as they join.
-
-This does not mean that these messages are stored on any servers - the admin member that adds a new member to the group sends these messages directly when a new member joins. Groups are still fully decentralized, do not have any identity on the network, and fully private - only their members know they exist.
-
-That is, unless a group owner decides to make it public. Groups can be registered in [SimpleX groups directory](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) to be discovered by the new members - group directory is also improved.
-
-### Simpler UX to connect to other users
-
-<img src="./images/20240124-connect1.png" width="220" class="float-to-left"> <img src="./images/20240124-connect2.png" width="220" class="float-to-left">
-
-SimpleX platform has no user accounts or identities, and while it improves metadata privacy, it also makes it harder to understand how to connect to other people, particularly for the new users who are not invited by the existing users.
-
-This version simplifies this interface by allowing to connect via the received link just by pasting the address into the search bar, as is common in many wallet apps and some other decentralized messengers. We also improved the interface of creating invitation links.
-
-We will continue working on improving and simplifying user interface throughout the year. Please send us any feedback and suggestions to the team's address available in the app.
-
-### Message delivery stability and other improvements
-
-One of the long standing issues was that message reception could get stuck in some rare occasions, and only get resumed once the app is fully restarted. As Android app includes an always-on notification service that runs in background, full restart should be done via the app settings.
-
-This version fixed many issues with message delivery stability and also added some diagnostics to identify any other cases when message delivery may stop. These fixes should also reduce battery usage, particularly on slow internet connections.
-
-Other improvements in this version:
-- you can now reveal secret messages by tapping. To send a secret message wrap in "#" characters, e.g. "\#password\#".
-- you can delete the last user profile, simplifying account deletion. If you have [hidden user profiles](./20230328-simplex-chat-v4-6-hidden-profiles.md), they won't be deleted in this case, and will be accessible again once you create a new profile.
-
-## SimpleX platform
-
-Some links to answer the most common questions:
-
-[How can SimpleX deliver messages without user identifiers](./20220511-simplex-chat-v2-images-files.md#the-first-messaging-platform-without-user-identifiers).
-
-[What are the risks to have identifiers assigned to the users](./20220711-simplex-chat-v3-released-ios-notifications-audio-video-calls-database-export-import-protocol-improvements.md#why-having-users-identifiers-is-bad-for-the-users).
-
-[Technical details and limitations](https://github.com/simplex-chat/simplex-chat#privacy-technical-details-and-limitations).
-
-[How SimpleX is different from Session, Matrix, Signal, etc.](https://github.com/simplex-chat/simplex-chat/blob/stable/README.md#frequently-asked-questions).
-
-Please also see our [website](https://simplex.chat).
-
-## Help us with donations
-
-Huge thank you to everybody who donated to SimpleX Chat!
-
-We are prioritizing users privacy and security - it would be impossible without your support.
-
-Our pledge to our users is that SimpleX protocols are and will remain open, and in public domain, - so anybody can build the future implementations of the clients and the servers. We are building SimpleX platform based on the same principles as email and web, but much more private and secure.
-
-Your donations help us raise more funds – any amount, even the price of the cup of coffee, makes a big difference for us.
-
-See [this section](https://github.com/simplex-chat/simplex-chat/tree/master#help-us-with-donations) for the ways to donate.
-
-Thank you,
-
-Evgeny
-
-SimpleX Chat founder

blog/README.md

@@ -1,20 +1,5 @@
 # Blog
 
-Jan 24, 2024 [SimpleX Chat: free infrastructure from Linode, v5.5 released](./20240124-simplex-chat-infrastructure-costs-v5-5-simplex-ux-private-notes-group-history.md)
-
-SimpleX Chat infrastructure on Linode:
-- Free infrastructure.
-- SimpleX servers in Linode Marketplace.
-- High capacity messaging servers.
-
-What's new in v5.5:
-- private notes.
-- group history.
-- simpler UX to connect to other users.
-- message delivery stability and other improvements.
-
----
-
 Nov 25, 2023 [SimpleX Chat v5.4 released](./20231125-simplex-chat-v5-4-link-mobile-desktop-quantum-resistant-better-groups.md)
 
 - Link mobile and desktop apps via secure quantum-resistant protocol. 🔗
@@ -146,7 +131,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://supernovas.space/detailed_reviews.html#simplex) and [messenger ratings](https://supernovas.space/messengers.html).
+- [Supernova review](https://supernova.tilde.team/detailed_reviews.html#simplex) and [messenger ratings](https://supernova.tilde.team/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://supernovas.space/detailed_reviews.html#simplex) et [évaluations des messageries](https://supernovas.space/messengers.html).
+- [Revue de Supernova](https://supernova.tilde.team/detailed_reviews.html#simplex) et [évaluations des messageries](https://supernova.tilde.team/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: 32c94df040b7921584a4685a814818daec3bf209
+    tag: 7a0cd8041bbb7d7ab2f089395a244dc4af0f9e3b
 
 source-repository-package
     type: git

docs/DOWNLOADS.md

@@ -1,13 +1,13 @@
 ---
 title: Download SimpleX apps
 permalink: /downloads/index.html
-revision: 11.02.2024
+revision: 25.11.2023
 ---
 
-| Updated 11.02.2024 | Languages: EN |
+| Updated 25.11.2023 | Languages: EN |
 # Download SimpleX apps
 
-The latest stable version is v5.5.3.
+The latest stable version is v5.5.
 
 You can get the latest beta releases from [GitHub](https://github.com/simplex-chat/simplex-chat/releases).
 
@@ -21,24 +21,24 @@ You can get the latest beta releases from [GitHub](https://github.com/simplex-ch
 
 Using the same profile as on mobile device is not yet supported – you need to create a separate profile to use desktop apps.
 
-**Linux**: [AppImage](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-x86_64.AppImage) (most Linux distros), [Ubuntu 20.04](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-ubuntu-20_04-x86_64.deb) (and Debian-based distros), [Ubuntu 22.04](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-ubuntu-22_04-x86_64.deb).
+**Linux**: [AppImage](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-x86_64.AppImage) (most Linux distros), [Ubuntu 20.04](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-ubuntu-20_04-x86_64.deb) (and Debian-based distros), [Ubuntu 22.04](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-ubuntu-22_04-x86_64.deb).
 
-**Mac**: [aarch64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-macos-aarch64.dmg) (Apple Silicon), [x86_64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-macos-x86_64.dmg) (Intel).
+**Mac**: [x86_64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-macos-x86_64.dmg) (Intel), [aarch64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-macos-aarch64.dmg) (Apple Silicon).
 
-**Windows**: [x86_64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-desktop-windows-x86_64.msi).
+**Windows**: [x86_64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-desktop-windows-x86_64.msi).
 
 ## Mobile apps
 
 **iOS**: [App store](https://apps.apple.com/us/app/simplex-chat/id1605771084), [TestFlight](https://testflight.apple.com/join/DWuT2LQu).
 
-**Android**: [Play store](https://play.google.com/store/apps/details?id=chat.simplex.app), [F-Droid](https://simplex.chat/fdroid/), [APK aarch64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex.apk), [APK armv7](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-armv7a.apk).
+**Android**: [Play store](https://play.google.com/store/apps/details?id=chat.simplex.app), [F-Droid](https://simplex.chat/fdroid/), [APK aarch64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex.apk), [APK armv7](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-armv7a.apk).
 
 ## Terminal (console) app
 
 See [Using terminal app](/docs/CLI.md).
 
-**Linux**: [Ubuntu 20.04](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-chat-ubuntu-20_04-x86-64), [Ubuntu 22.04](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-chat-ubuntu-22_04-x86-64).
+**Linux**: [Ubuntu 20.04](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-chat-ubuntu-20_04-x86-64), [Ubuntu 22.04](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-chat-ubuntu-22_04-x86-64).
 
-**Mac** [x86_64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-chat-macos-x86-64), aarch64 - [compile from source](/docs/CLI.md#).
+**Mac** [x86_64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-chat-macos-x86-64), aarch64 - [compile from source](/docs/CLI.md#).
 
-**Windows**: [x86_64](https://github.com/simplex-chat/simplex-chat/releases/latest/download/simplex-chat-windows-x86-64).
+**Windows**: [x86_64](https://github.com/simplex-chat/simplex-chat/releases/download/v5.5.0/simplex-chat-windows-x86-64).

docs/GLOSSARY.md

@@ -143,12 +143,6 @@ 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.
@@ -191,12 +185,6 @@ 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](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.
+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.
 
 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.
 

flake.nix

@@ -385,7 +385,6 @@
                   "chat_send_cmd"
                   "chat_send_remote_cmd"
                   "chat_valid_name"
-                  "chat_json_length"
                   "chat_write_file"
                 ];
                 postInstall = ''
@@ -488,7 +487,6 @@
                   "chat_send_cmd"
                   "chat_send_remote_cmd"
                   "chat_valid_name"
-                  "chat_json_length"
                   "chat_write_file"
                 ];
                 postInstall = ''

libsimplex.dll.def

@@ -12,7 +12,6 @@ EXPORTS
     chat_parse_server
     chat_password_hash
     chat_valid_name
-    chat_json_length
     chat_encrypt_media
     chat_decrypt_media
     chat_write_file

package.yaml

@@ -1,5 +1,5 @@
 name: simplex-chat
-version: 5.5.5.0
+version: 5.5.0.4
 #synopsis:
 #description:
 homepage: https://github.com/simplex-chat/simplex-chat#readme
@@ -36,6 +36,7 @@ dependencies:
   - network >= 3.1.2.7 && < 3.2
   - network-transport == 0.5.6
   - optparse-applicative >= 0.15 && < 0.17
+  - process == 1.6.*
   - random >= 1.1 && < 1.3
   - record-hasfield == 1.0.*
   - simple-logger == 0.1.*
@@ -63,13 +64,11 @@ when:
   - condition: impl(ghc >= 9.6.2)
     dependencies:
       - bytestring == 0.11.*
-      - process == 1.6.*
       - template-haskell == 2.20.*
       - text >= 2.0.1 && < 2.2
   - condition: impl(ghc < 9.6.2)
     dependencies:
       - bytestring == 0.10.*
-      - process >= 1.6 && < 1.6.18
       - template-haskell == 2.16.*
       - text >= 1.2.3.0 && < 1.3
 
@@ -126,19 +125,13 @@ tests:
       - apps/simplex-broadcast-bot/src
       - apps/simplex-directory-service/src
     main: Test.hs
-    when:
-      - condition: impl(ghc >= 9.6.2)
-        dependencies:
-          - hspec == 2.11.*
-      - condition: impl(ghc < 9.6.2)
-        dependencies:
-          - hspec == 2.7.*
     dependencies:
       - QuickCheck == 2.14.*
       - simplex-chat
       - async == 2.2.*
       - deepseq == 1.4.*
       - generic-random == 1.5.*
+      - hspec == 2.11.*
       - network == 3.1.*
       - silently == 1.2.*
       - stm == 2.5.*

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

@@ -12,6 +12,7 @@ export type ChatCommand =
   | APIStopChat
   | SetTempFolder
   | SetFilesFolder
+  | APISetXFTPConfig
   | SetIncognito
   | APIExportArchive
   | APIImportArchive
@@ -111,6 +112,7 @@ type ChatCommandTag =
   | "apiStopChat"
   | "setTempFolder"
   | "setFilesFolder"
+  | "apiSetXFTPConfig"
   | "setIncognito"
   | "apiExportArchive"
   | "apiImportArchive"
@@ -240,6 +242,15 @@ 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
@@ -696,6 +707,8 @@ 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":

scripts/desktop/build-lib-linux.sh

@@ -20,10 +20,6 @@ root_dir="$(dirname "$(dirname "$(readlink "$0")")")"
 cd $root_dir
 BUILD_DIR=dist-newstyle/build/$ARCH-$OS/ghc-${GHC_VERSION}/simplex-chat-*
 
-exports=( $(sed 's/foreign export ccall "chat_migrate_init_key"//' src/Simplex/Chat/Mobile.hs | sed 's/foreign export ccall "chat_reopen_store"//' |grep "foreign export ccall" | cut -d '"' -f2) )
-for elem in "${exports[@]}"; do count=$(grep -R "$elem$" libsimplex.dll.def | wc -l); if [ $count -ne 1 ]; then echo Wrong exports in libsimplex.dll.def. Add \"$elem\" to that file; exit 1; fi ; done
-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'
 cd $BUILD_DIR/build

scripts/desktop/build-lib-mac.sh

@@ -19,10 +19,6 @@ GHC_LIBS_DIR=$(ghc --print-libdir)
 
 BUILD_DIR=dist-newstyle/build/$ARCH-*/ghc-*/simplex-chat-*
 
-exports=( $(sed 's/foreign export ccall "chat_migrate_init_key"//' src/Simplex/Chat/Mobile.hs | sed 's/foreign export ccall "chat_reopen_store"//' |grep "foreign export ccall" | cut -d '"' -f2) )
-for elem in "${exports[@]}"; do count=$(grep -R "$elem$" libsimplex.dll.def | wc -l); if [ $count -ne 1 ]; then echo Wrong exports in libsimplex.dll.def. Add \"$elem\" to that file; exit 1; fi ; done
-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"
 

scripts/desktop/build-lib-windows.sh

@@ -17,10 +17,6 @@ fi
 
 BUILD_DIR=dist-newstyle/build/$ARCH-$OS/ghc-*/simplex-chat-*
 
-exports=( $(sed 's/foreign export ccall "chat_migrate_init_key"//' src/Simplex/Chat/Mobile.hs | sed 's/foreign export ccall "chat_reopen_store"//' |grep "foreign export ccall" | cut -d '"' -f2) )
-for elem in "${exports[@]}"; do count=$(grep -R "$elem$" libsimplex.dll.def | wc -l); if [ $count -ne 1 ]; then echo Wrong exports in libsimplex.dll.def. Add \"$elem\" to that file; exit 1; fi ; done
-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
-
 # IMPORTANT: in order to get a working build you should use x86_64 MinGW with make, cmake, gcc.
 # 100% working MinGW is https://github.com/brechtsanders/winlibs_mingw/releases/download/13.1.0-16.0.5-11.0.0-ucrt-r5/winlibs-x86_64-posix-seh-gcc-13.1.0-mingw-w64ucrt-11.0.0-r5.zip
 # Many other distributions I tested don't work in some cases or don't have required tools.

scripts/nix/sha256map.nix

@@ -1,5 +1,5 @@
 {
-  "https://github.com/simplex-chat/simplexmq.git"."32c94df040b7921584a4685a814818daec3bf209" = "0bfyzra8x67zwqr7g8hkglxpy503qwn0xni0sjnbjmvh7wlh6pyz";
+  "https://github.com/simplex-chat/simplexmq.git"."7a0cd8041bbb7d7ab2f089395a244dc4af0f9e3b" = "0jxf9dnsg14ffd1y3i7md2ninrds4daq1fmpnd6j5z99im07ns52";
   "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.5.0
+version:        5.5.0.4
 category:       Web, System, Services, Cryptography
 homepage:       https://github.com/simplex-chat/simplex-chat#readme
 author:         simplex.chat
@@ -197,6 +197,7 @@ library
     , network >=3.1.2.7 && <3.2
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -216,13 +217,11 @@ library
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -257,6 +256,7 @@ executable simplex-bot
     , network >=3.1.2.7 && <3.2
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -277,13 +277,11 @@ executable simplex-bot
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -318,6 +316,7 @@ executable simplex-bot-advanced
     , network >=3.1.2.7 && <3.2
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -338,13 +337,11 @@ executable simplex-bot-advanced
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -381,6 +378,7 @@ executable simplex-broadcast-bot
     , network >=3.1.2.7 && <3.2
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -401,13 +399,11 @@ executable simplex-broadcast-bot
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -443,6 +439,7 @@ executable simplex-chat
     , network ==3.1.*
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -464,13 +461,11 @@ executable simplex-chat
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -510,6 +505,7 @@ executable simplex-directory-service
     , network >=3.1.2.7 && <3.2
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , simple-logger ==0.1.*
@@ -530,13 +526,11 @@ executable simplex-directory-service
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
 
@@ -598,6 +592,7 @@ test-suite simplex-chat-test
     , exceptions ==0.10.*
     , filepath ==1.4.*
     , generic-random ==1.5.*
+    , hspec ==2.11.*
     , http-types ==0.12.*
     , http2 >=4.2.2 && <4.3
     , memory ==0.18.*
@@ -605,6 +600,7 @@ test-suite simplex-chat-test
     , network ==3.1.*
     , network-transport ==0.5.6
     , optparse-applicative >=0.15 && <0.17
+    , process ==1.6.*
     , random >=1.1 && <1.3
     , record-hasfield ==1.0.*
     , silently ==1.2.*
@@ -626,18 +622,10 @@ test-suite simplex-chat-test
   if impl(ghc >= 9.6.2)
     build-depends:
         bytestring ==0.11.*
-      , process ==1.6.*
       , template-haskell ==2.20.*
       , text >=2.0.1 && <2.2
   if impl(ghc < 9.6.2)
     build-depends:
         bytestring ==0.10.*
-      , process >=1.6 && <1.6.18
       , template-haskell ==2.16.*
       , text >=1.2.3.0 && <1.3
-  if impl(ghc >= 9.6.2)
-    build-depends:
-        hspec ==2.11.*
-  if impl(ghc < 9.6.2)
-    build-depends:
-        hspec ==2.7.*

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)
+import Simplex.FileTransfer.Description (ValidFileDescription, gb, kb, mb)
 import Simplex.FileTransfer.Protocol (FileParty (..), FilePartyI)
 import Simplex.Messaging.Agent as Agent
 import Simplex.Messaging.Agent.Client (AgentStatsKey (..), SubInfo (..), agentClientStore, getAgentWorkersDetails, getAgentWorkersSummary, temporaryAgentError)
@@ -142,6 +142,8 @@ defaultChatConfig =
       xftpDescrPartSize = 14000,
       inlineFiles = defaultInlineFilesConfig,
       autoAcceptFileSize = 0,
+      xftpFileConfig = Just defaultXFTPFileConfig,
+      tempDir = Nothing,
       showReactions = False,
       showReceipts = False,
       logLevel = CLLImportant,
@@ -199,7 +201,7 @@ newChatController :: ChatDatabase -> Maybe User -> ChatConfig -> ChatOpts -> Boo
 newChatController
   ChatDatabase {chatStore, agentStore}
   user
-  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, deviceNameForRemote}
+  cfg@ChatConfig {agentConfig = aCfg, defaultServers, inlineFiles, tempDir, 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}
@@ -234,7 +236,8 @@ newChatController
     chatActivated <- newTVarIO True
     showLiveItems <- newTVarIO False
     encryptLocalFiles <- newTVarIO False
-    tempDirectory <- newTVarIO Nothing
+    userXFTPFileConfig <- newTVarIO $ xftpFileConfig cfg
+    tempDirectory <- newTVarIO tempDir
     contactMergeEnabled <- newTVarIO True
     pure
       ChatController
@@ -269,6 +272,7 @@ newChatController
           chatActivated,
           showLiveItems,
           encryptLocalFiles,
+          userXFTPFileConfig,
           tempDirectory,
           logFilePath = logFile,
           contactMergeEnabled
@@ -578,6 +582,9 @@ 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)
@@ -638,7 +645,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 -> withChatLock "sendMessage" $ case cType of
+  APISendMessage (ChatRef cType chatId) live itemTTL (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user@User {userId} -> withChatLock "sendMessage" $ case cType of
     CTDirect -> do
       ct@Contact {contactId, contactUsed} <- withStore $ \db -> getContact db user chatId
       assertDirectAllowed user MDSnd ct XMsgNew_
@@ -646,19 +653,45 @@ 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_) <- L.unzip <$> setupSndFileTransfer ct
+          (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer ct
           timed_ <- sndContactCITimed live ct itemTTL
           (msgContainer, quotedItem_) <- prepareMsg fInv_ timed_
-          (msg, _) <- sendDirectContactMessage ct (XMsgNew msgContainer)
+          (msg@SndMessage {sharedMsgId}, _) <- 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))
+        setupSndFileTransfer :: Contact -> m (Maybe (FileInvitation, CIFile 'MDSnd, FileTransferMeta))
         setupSndFileTransfer ct = forM file_ $ \file -> do
-          fileSize <- checkSndFile file
-          xftpSndFileTransfer user file fileSize 1 $ CGContact ct
+          (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)
         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)
@@ -685,27 +718,53 @@ 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_) <- L.unzip <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
+              (fInv_, ciFile_, ft_) <- unzipMaybe3 <$> setupSndFileTransfer g (length $ filter memberCurrent ms)
               timed_ <- sndGroupCITimed live gInfo itemTTL
               (msgContainer, quotedItem_) <- prepareGroupMsg user gInfo mc quotedItemId_ fInv_ timed_ live
-              (msg, sentToMembers) <- sendGroupMessage user gInfo ms (XMsgNew msgContainer)
+              (msg@SndMessage {sharedMsgId}, 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))
-        setupSndFileTransfer g n = forM file_ $ \file -> do
-          fileSize <- checkSndFile file
-          xftpSndFileTransfer user file fileSize n $ CGGroup g
+        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 ()
     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)
+      xftpSndFileTransfer :: User -> CryptoFile -> Integer -> Int -> ContactOrGroup -> m (FileInvitation, CIFile 'MDSnd, FileTransferMeta)
       xftpSndFileTransfer user file@(CryptoFile filePath cfArgs) fileSize n contactOrGroup = do
         let fileName = takeFileName filePath
             fileDescr = FileDescr {fileDescrText = "", fileDescrPartNo = 0, fileDescrComplete = False}
@@ -729,7 +788,10 @@ processChatCommand' vr = \case
                   withStore' $
                     \db -> createSndFTDescrXFTP db user (Just m) conn ft fileDescr
               saveMemberFD _ = pure ()
-        pure (fInv, ciFile)
+        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)
   APICreateChatItem folderId (ComposedMessage file_ quotedItemId_ mc) -> withUser $ \user -> do
     forM_ quotedItemId_ $ \_ -> throwError $ ChatError $ CECommandError "not supported"
     nf <- withStore $ \db -> getNoteFolder db user folderId
@@ -947,7 +1009,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
@@ -966,7 +1028,6 @@ processChatCommand' vr = \case
         when (memberActive membership && isOwner) . void $ sendGroupMessage' user gInfo members XGrpDel
         deleteGroupLinkIfExists user gInfo
         deleteMembersConnections user members
-        updateCIGroupInvitationStatus user gInfo CIGISRejected `catchChatError` \_ -> pure ()
         -- functions below are called in separate transactions to prevent crashes on android
         -- (possibly, race condition on integrity check?)
         withStore' $ \db -> deleteGroupConnectionsAndFiles db user gInfo members
@@ -988,7 +1049,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"
@@ -1625,9 +1686,17 @@ processChatCommand' vr = \case
             createMemberConnection db userId fromMember agentConnId (fromJVersionRange peerChatVRange) subMode
             updateGroupMemberStatus db userId fromMember GSMemAccepted
             updateGroupMemberStatus db userId membership GSMemAccepted
-          updateCIGroupInvitationStatus user g CIGISAccepted `catchChatError` \_ -> pure ()
+          updateCIGroupInvitationStatus user
           pure $ CRUserAcceptedGroupSent user g {membership = membership {memberStatus = GSMemAccepted}} Nothing
         Nothing -> throwChatError $ CEContactNotActive ct
+    where
+      updateCIGroupInvitationStatus user = do
+        AChatItem _ _ cInfo ChatItem {content, meta = CIMeta {itemId}} <- withStore $ \db -> getChatItemByGroupId db vr user groupId
+        case (cInfo, content) of
+          (DirectChat ct, CIRcvGroupInvitation ciGroupInv memRole) -> do
+            let aciContent = ACIContent SMDRcv $ CIRcvGroupInvitation ciGroupInv {status = CIGISAccepted} memRole
+            updateDirectChatItemView user ct itemId aciContent False Nothing
+          _ -> pure () -- prohibited
   APIMemberRole groupId memberId memRole -> withUser $ \user -> do
     Group gInfo@GroupInfo {membership} members <- withStore $ \db -> getGroup db vr user groupId
     if memberId == groupMemberId' membership
@@ -2140,13 +2209,27 @@ processChatCommand' vr = \case
     contactMember Contact {contactId} =
       find $ \GroupMember {memberContactId = cId, memberStatus = s} ->
         cId == Just contactId && s /= GSMemRemoved && s /= GSMemLeft
-    checkSndFile :: CryptoFile -> m Integer
-    checkSndFile (CryptoFile f cfArgs) = do
+    checkSndFile :: MsgContent -> CryptoFile -> Integer -> m (Integer, SendFileMode)
+    checkSndFile mc (CryptoFile f cfArgs) n = 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
-      pure fileSize
+      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
     updateProfile :: User -> Profile -> m ChatResponse
     updateProfile user p' = updateProfile_ user p' $ withStore $ \db -> updateUserProfile db user p'
     updateProfile_ :: User -> Profile -> m User -> m ChatResponse
@@ -2429,14 +2512,6 @@ processChatCommand' vr = \case
         cReqHashes :: (ConnReqUriHash, ConnReqUriHash)
         cReqHashes = bimap hash hash cReqSchemas
         hash = ConnReqUriHash . C.sha256Hash . strEncode
-    updateCIGroupInvitationStatus user GroupInfo {groupId} newStatus = do
-      AChatItem _ _ cInfo ChatItem {content, meta = CIMeta {itemId}} <- withStore $ \db -> getChatItemByGroupId db vr user groupId
-      case (cInfo, content) of
-        (DirectChat ct, CIRcvGroupInvitation ciGroupInv@CIGroupInvitation {status} memRole)
-          | status == CIGISPending -> do
-              let aciContent = ACIContent SMDRcv $ CIRcvGroupInvitation ciGroupInv {status = newStatus} memRole
-              updateDirectChatItemView user ct itemId aciContent False Nothing
-        _ -> pure () -- prohibited
 
 toggleNtf :: ChatMonad m => User -> GroupMember -> Bool -> m ()
 toggleNtf user m ntfOn =
@@ -3056,7 +3131,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
@@ -4836,7 +4911,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
 
@@ -6419,6 +6494,8 @@ 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),
@@ -6790,6 +6867,14 @@ 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/Controller.hs

@@ -128,6 +128,8 @@ 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,
@@ -202,6 +204,7 @@ 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
@@ -239,6 +242,7 @@ data ChatCommand
   | SetTempFolder FilePath
   | SetFilesFolder FilePath
   | SetRemoteHostsFolder FilePath
+  | APISetXFTPConfig (Maybe XFTPFileConfig)
   | APISetEncryptLocalFiles Bool
   | SetContactMergeEnabled Bool
   | APIExportArchive ArchiveConfig
@@ -469,6 +473,7 @@ allowRemoteCommand = \case
   SetTempFolder _ -> False
   SetFilesFolder _ -> False
   SetRemoteHostsFolder _ -> False
+  APISetXFTPConfig _ -> False
   APISetEncryptLocalFiles _ -> False
   APIExportArchive _ -> False
   APIImportArchive _ -> False
@@ -929,6 +934,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)
 
@@ -988,6 +1001,11 @@ data CoreVersionInfo = CoreVersionInfo
   }
   deriving (Show)
 
+data SendFileMode
+  = SendFileSMP (Maybe InlineFileMode)
+  | SendFileXFTP
+  deriving (Show)
+
 data SlowSQLQuery = SlowSQLQuery
   { query :: Text,
     queryStats :: SlowQueryStats
@@ -1391,4 +1409,6 @@ $(JQ.deriveFromJSON defaultJSON ''ArchiveConfig)
 
 $(JQ.deriveFromJSON defaultJSON ''DBEncryptionConfig)
 
+$(JQ.deriveJSON defaultJSON ''XFTPFileConfig)
+
 $(JQ.deriveToJSON defaultJSON ''ComposedMessage)

src/Simplex/Chat/Mobile.hs

@@ -20,7 +20,6 @@ import qualified Data.ByteArray as BA
 import qualified Data.ByteString.Base64.URL as U
 import Data.ByteString.Char8 (ByteString)
 import qualified Data.ByteString.Char8 as B
-import qualified Data.ByteString.Lazy.Char8 as LB
 import Data.Functor (($>))
 import Data.List (find)
 import qualified Data.List.NonEmpty as L
@@ -95,8 +94,6 @@ foreign export ccall "chat_password_hash" cChatPasswordHash :: CString -> CStrin
 
 foreign export ccall "chat_valid_name" cChatValidName :: CString -> IO CString
 
-foreign export ccall "chat_json_length" cChatJsonLength :: CString -> IO CInt
-
 foreign export ccall "chat_encrypt_media" cChatEncryptMedia :: StablePtr ChatController -> CString -> Ptr Word8 -> CInt -> IO CString
 
 foreign export ccall "chat_decrypt_media" cChatDecryptMedia :: CString -> Ptr Word8 -> CInt -> IO CString
@@ -179,10 +176,6 @@ cChatPasswordHash cPwd cSalt = do
 cChatValidName :: CString -> IO CString
 cChatValidName cName = newCString . mkValidName =<< peekCString cName
 
--- | returns length of JSON encoded string
-cChatJsonLength :: CString -> IO CInt
-cChatJsonLength s = fromIntegral . subtract 2 . LB.length . J.encode . safeDecodeUtf8 <$> B.packCString s
-
 mobileChatOpts :: String -> ChatOpts
 mobileChatOpts dbFilePrefix =
   ChatOpts
@@ -271,18 +264,9 @@ chatSendRemoteCmd :: ChatController -> Maybe RemoteHostId -> B.ByteString -> IO
 chatSendRemoteCmd cc rh s = J.encode . APIResponse Nothing rh <$> runReaderT (execChatCommand rh s) cc
 
 chatRecvMsg :: ChatController -> IO JSONByteString
-chatRecvMsg ChatController {outputQ} = json <$> readChatResponse
+chatRecvMsg ChatController {outputQ} = json <$> atomically (readTBQueue outputQ)
   where
     json (corr, remoteHostId, resp) = J.encode APIResponse {corr, remoteHostId, resp}
-    readChatResponse = do
-      out@(_, _, cr) <- atomically $ readTBQueue outputQ
-      if filterEvent cr then pure out else readChatResponse
-    filterEvent = \case
-      CRGroupSubscribed {} -> False
-      CRGroupEmpty {} -> False
-      CRMemberSubSummary {} -> False
-      CRPendingSubSummary {} -> False
-      _ -> True
 
 chatRecvMsgWait :: ChatController -> Int -> IO JSONByteString
 chatRecvMsgWait cc time = fromMaybe "" <$> timeout time (chatRecvMsg cc)

src/Simplex/Chat/Store/Direct.hs

@@ -229,16 +229,13 @@ 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 -> ExceptT StoreError IO ()
-deleteContact db user@User {userId} ct@Contact {contactId, localDisplayName, activeConn} = do
-  assertNotUser db user ct
-  liftIO $ do
+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
-        -- 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
@@ -249,23 +246,18 @@ deleteContact db user@User {userId} ct@Contact {contactId, localDisplayName, act
       deleteUnusedIncognitoProfileById_ db user profileId
 
 -- should only be used if contact is not member of any groups
-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
+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
-    -- 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 -> ExceptT StoreError IO ()
-setContactDeleted db user@User {userId} ct@Contact {contactId} = do
-  assertNotUser db user ct
-  liftIO $ do
+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 = ?" (currentTs, userId, contactId)
 
@@ -328,7 +320,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 user contactId localDisplayName ldn currentTs
+        updateContactLDN_ db userId contactId localDisplayName ldn currentTs
         pure $ Right c {localDisplayName = ldn, profile, mergedPreferences}
   where
     Contact {contactId, localDisplayName, profile = LocalProfile {profileId, displayName, localAlias}, userPreferences} = c
@@ -499,8 +491,8 @@ updateMemberContactProfile_' db userId profileId Profile {displayName, fullName,
     |]
     (displayName, fullName, image, updatedAt, userId, profileId)
 
-updateContactLDN_ :: DB.Connection -> User -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
-updateContactLDN_ db user@User {userId} contactId displayName newName updatedAt = do
+updateContactLDN_ :: DB.Connection -> UserId -> Int64 -> ContactName -> ContactName -> UTCTime -> IO ()
+updateContactLDN_ db userId contactId displayName newName updatedAt = do
   DB.execute
     db
     "UPDATE contacts SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
@@ -509,7 +501,7 @@ updateContactLDN_ db user@User {userId} contactId displayName newName updatedAt
     db
     "UPDATE group_members SET local_display_name = ?, updated_at = ? WHERE user_id = ? AND contact_id = ?"
     (newName, updatedAt, userId, contactId)
-  safeDeleteLDN db user displayName
+  DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (displayName, userId)
 
 getContactByName :: DB.Connection -> User -> ContactName -> ExceptT StoreError IO Contact
 getContactByName db user localDisplayName = do
@@ -622,7 +614,7 @@ createOrUpdateContactRequest db user@User {userId} userContactLinkId invId (Vers
                 WHERE user_id = ? AND contact_request_id = ?
               |]
               (invId, minV, maxV, ldn, currentTs, userId, cReqId)
-            safeDeleteLDN db user oldLdn
+            DB.execute db "DELETE FROM display_names WHERE local_display_name = ? AND user_id = ?" (oldLdn, userId)
       where
         updateProfile currentTs =
           DB.execute
@@ -692,9 +684,8 @@ 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 WHERE user_id = ?)
     |]
-    (userId, userId, contactRequestId, userId)
+    (userId, userId, contactRequestId)
   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