Merge branch 'main' of https://github.com/aritroCoder/zulip-mobile

Author: aritroCoder

android/app/src/main/java/com/zulipmobile/TextCompression.kt

@@ -0,0 +1,93 @@
+package com.zulipmobile
+
+import android.util.Base64
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import java.io.ByteArrayOutputStream
+import java.io.IOException
+import java.io.UnsupportedEncodingException
+import java.util.zip.DataFormatException
+import java.util.zip.Deflater
+import java.util.zip.Inflater
+
+// TODO: Write unit tests; see
+//   https://github.com/zulip/zulip-mobile/blob/main/docs/howto/testing.md#unit-tests-android.
+
+// TODO: Experiment what value gives the best performance.
+private const val bufferSize = 8192
+
+private const val header = "z|zlib base64|"
+
+internal fun compress(input: String): String {
+    val outputStream = ByteArrayOutputStream()
+    val deflater = Deflater()
+    deflater.setInput(input.toByteArray(charset("UTF-8")))
+    deflater.finish()
+    val buffer = ByteArray(bufferSize)
+    while (!deflater.finished()) {
+        val byteCount = deflater.deflate(buffer)
+        outputStream.write(buffer, 0, byteCount)
+    }
+    deflater.end()
+    outputStream.close()
+    // The RN bridge currently doesn't support sending byte strings, so we
+    // have to encode the compressed output as a `String`.  To avoid any
+    // trouble, we use base64 to keep things inside ASCII.
+    //
+    // Ultimately our ASCII data seems to end up going to SQLite with size
+    // no more than about 1 byte/char (presumably the string gets encoded
+    // as UTF-8 and it's exactly 1 byte/char), so this is pretty OK.
+    return header + Base64.encodeToString(outputStream.toByteArray(),
+        Base64.DEFAULT)
+}
+
+internal fun decompress(input: String): String {
+    val inflater = Inflater()
+    val inputBytes = input.toByteArray(charset("ISO-8859-1"))
+    inflater.setInput(Base64.decode(inputBytes,
+        header.length,
+        inputBytes.size - header.length,
+        Base64.DEFAULT))
+    val outputStream = ByteArrayOutputStream()
+    val buffer = ByteArray(bufferSize)
+    while (inflater.remaining != 0) {
+        val byteCount = inflater.inflate(buffer)
+        outputStream.write(buffer, 0, byteCount)
+    }
+    inflater.end()
+    outputStream.close()
+    return outputStream.toString("UTF-8")
+}
+
+internal class TextCompressionModule(reactContext: ReactApplicationContext?) :
+        ReactContextBaseJavaModule(reactContext) {
+    override fun getName(): String = "TextCompressionModule"
+
+    override fun getConstants(): Map<String, Any> = hashMapOf("header" to header)
+
+    @ReactMethod
+    fun compress(input: String, promise: Promise) {
+        try {
+            promise.resolve(compress(input))
+        } catch (e: UnsupportedEncodingException) {
+            promise.reject("UNSUPPORTED_ENCODING_EXCEPTION", e)
+        } catch (e: IOException) {
+            promise.reject("IO_EXCEPTION", e)
+        }
+    }
+
+    @ReactMethod
+    fun decompress(input: String, promise: Promise) {
+        try {
+            promise.resolve(decompress(input))
+        } catch (e: UnsupportedEncodingException) {
+            promise.reject("UNSUPPORTED_ENCODING_EXCEPTION", e)
+        } catch (e: IOException) {
+            promise.reject("IO_EXCEPTION", e)
+        } catch (e: DataFormatException) {
+            promise.reject("DATA_FORMAT_EXCEPTION", e)
+        }
+    }
+}

android/app/src/main/java/com/zulipmobile/TextCompressionModule.java

@@ -723,7 +723,7 @@ export const action = Object.freeze({
       msg: '',
       queue_id: '1',
       zulip_feature_level: recentZulipFeatureLevel,
-      zulip_version: recentZulipVersion.raw(),
+      zulip_version: recentZulipVersion,
 
       // InitialDataAlertWords
       alert_words: [],

src/__tests__/lib/exampleData.js

@@ -16,13 +16,14 @@ import { tryStopNotifications } from '../notification/notifTokens';
 import AccountDetails from './AccountDetails';
 import { getRealm } from '../directSelectors';
 import { getOwnUser, getOwnUserId } from '../users/userSelectors';
-import { getAuth, getIdentity, getZulipFeatureLevel } from '../account/accountsSelectors';
+import { getAuth, getAccount, getZulipFeatureLevel } from '../account/accountsSelectors';
 import { useNavigation } from '../react-navigation';
 import { showConfirmationDialog } from '../utils/info';
 import { OfflineNoticePlaceholder } from '../boot/OfflineNoticeProvider';
 import { getUserStatus } from '../user-statuses/userStatusesModel';
 import SwitchRow from '../common/SwitchRow';
 import * as api from '../api';
+import { identityOfAccount } from '../account/accountMisc';
 
 const styles = createStyleSheet({
   buttonRow: {
@@ -94,7 +95,8 @@ function SwitchAccountButton(props: {||}) {
 function LogoutButton(props: {||}) {
   const dispatch = useDispatch();
   const _ = useContext(TranslationContext);
-  const identity = useSelector(getIdentity);
+  const account = useSelector(getAccount);
+  const identity = identityOfAccount(account);
   return (
     <ZulipButton
       style={styles.button}
@@ -109,7 +111,7 @@ function LogoutButton(props: {||}) {
             values: { email: identity.email, realmUrl: identity.realm.toString() },
           },
           onPressConfirm: () => {
-            dispatch(tryStopNotifications());
+            dispatch(tryStopNotifications(account));
             dispatch(logout());
           },
           _,

src/account-info/ProfileScreen.js

@@ -8,18 +8,18 @@ import ViewPlaceholder from '../common/ViewPlaceholder';
 import AccountItem from './AccountItem';
 
 type Props = $ReadOnly<{|
-  accounts: $ReadOnlyArray<AccountStatus>,
+  accountStatuses: $ReadOnlyArray<AccountStatus>,
   onAccountSelect: number => Promise<void> | void,
   onAccountRemove: number => Promise<void> | void,
 |}>;
 
 export default function AccountList(props: Props): Node {
-  const { accounts, onAccountSelect, onAccountRemove } = props;
+  const { accountStatuses, onAccountSelect, onAccountRemove } = props;
 
   return (
     <View>
       <FlatList
-        data={accounts}
+        data={accountStatuses}
         keyExtractor={item => `${item.email}${item.realm.toString()}`}
         ItemSeparatorComponent={() => <ViewPlaceholder height={8} />}
         renderItem={({ item, index }) => (

src/account/AccountList.js

@@ -2,22 +2,24 @@
 
 import React, { useContext, useCallback } from 'react';
 import type { Node } from 'react';
+import invariant from 'invariant';
 
 import * as api from '../api';
 import { TranslationContext } from '../boot/TranslationProvider';
 import type { RouteProp } from '../react-navigation';
 import type { AppNavigationProp } from '../nav/AppNavigator';
 import { useGlobalSelector, useGlobalDispatch } from '../react-redux';
-import { getAccountStatuses } from '../selectors';
+import { getAccountStatuses, getAccountsByIdentity } from '../selectors';
 import Centerer from '../common/Centerer';
 import ZulipButton from '../common/ZulipButton';
 import Logo from '../common/Logo';
 import Screen from '../common/Screen';
 import ViewPlaceholder from '../common/ViewPlaceholder';
 import AccountList from './AccountList';
 import { accountSwitch, removeAccount } from '../actions';
-import type { ApiResponseServerSettings } from '../api/settings/getServerSettings';
+import type { ServerSettings } from '../api/settings/getServerSettings';
 import { showConfirmationDialog, showErrorAlert } from '../utils/info';
+import { tryStopNotifications } from '../notification/notifTokens';
 
 type Props = $ReadOnly<{|
   navigation: AppNavigationProp<'account-pick'>,
@@ -26,33 +28,41 @@ type Props = $ReadOnly<{|
 
 export default function AccountPickScreen(props: Props): Node {
   const { navigation } = props;
-  const accounts = useGlobalSelector(getAccountStatuses);
+  const accountStatuses = useGlobalSelector(getAccountStatuses);
+
+  // In case we need to grab the API for an account (being careful while
+  // doing so, of course).
+  const accountsByIdentity = useGlobalSelector(getAccountsByIdentity);
+
   const dispatch = useGlobalDispatch();
   const _ = useContext(TranslationContext);
 
   const handleAccountSelect = useCallback(
     async (index: number) => {
-      const { realm, isLoggedIn } = accounts[index];
+      const { realm, isLoggedIn } = accountStatuses[index];
       if (isLoggedIn) {
         setTimeout(() => {
           dispatch(accountSwitch(index));
         });
       } else {
         try {
-          const serverSettings: ApiResponseServerSettings = await api.getServerSettings(realm);
+          const serverSettings: ServerSettings = await api.getServerSettings(realm);
           navigation.push('auth', { serverSettings });
         } catch {
           // TODO: show specific error message from error object
           showErrorAlert(_('Failed to connect to server: {realm}', { realm: realm.toString() }));
         }
       }
     },
-    [accounts, dispatch, navigation, _],
+    [accountStatuses, dispatch, navigation, _],
   );
 
   const handleAccountRemove = useCallback(
     (index: number) => {
-      const { realm, email } = accounts[index];
+      const { realm, email, isLoggedIn } = accountStatuses[index];
+      const account = accountsByIdentity({ realm, email });
+      invariant(account, 'AccountPickScreen: should have account');
+
       showConfirmationDialog({
         destructive: true,
         title: 'Remove account',
@@ -61,12 +71,19 @@ export default function AccountPickScreen(props: Props): Node {
           values: { realmUrl: realm.toString(), email },
         },
         onPressConfirm: () => {
+          if (isLoggedIn) {
+            // Don't delay the removeAccount action by awaiting this
+            // request: it may take a long time or never succeed, and the
+            // user expects the account to be removed from the list
+            // immediately.
+            dispatch(tryStopNotifications(account));
+          }
           dispatch(removeAccount(index));
         },
         _,
       });
     },
-    [accounts, _, dispatch],
+    [accountStatuses, accountsByIdentity, _, dispatch],
   );
 
   return (
@@ -78,9 +95,9 @@ export default function AccountPickScreen(props: Props): Node {
       shouldShowLoadingBanner={false}
     >
       <Centerer>
-        {accounts.length === 0 && <Logo />}
+        {accountStatuses.length === 0 && <Logo />}
         <AccountList
-          accounts={accounts}
+          accountStatuses={accountStatuses}
           onAccountSelect={handleAccountSelect}
           onAccountRemove={handleAccountRemove}
         />

src/account/AccountPickScreen.js

@@ -26,7 +26,7 @@ describe('accountsReducer', () => {
       expect(
         accountsReducer(
           deepFreeze([account1, account2, account3]),
-          eg.mkActionRegisterComplete({ zulip_version: newZulipVersion.raw() }),
+          eg.mkActionRegisterComplete({ zulip_version: newZulipVersion }),
         ),
       ).toEqual([{ ...account1, zulipVersion: newZulipVersion }, account2, account3]);
     });

src/account/__tests__/accountsReducer-test.js

@@ -21,8 +21,8 @@ const registerComplete = (state, action) => [
   {
     ...state[0],
     userId: action.data.user_id,
-    zulipFeatureLevel: action.data.zulip_feature_level ?? 0,
-    zulipVersion: new ZulipVersion(action.data.zulip_version),
+    zulipFeatureLevel: action.data.zulip_feature_level,
+    zulipVersion: action.data.zulip_version,
     lastDismissedServerPushSetupNotice: action.data.realm_push_notifications_enabled
       ? null
       : state[0].lastDismissedServerPushSetupNotice,