@sendbird/uikit-react-native 1.1.1 → 2.0.0-rc.0

package/src/fragments/createGroupChannelFragment.tsx

@@ -73,30 +73,22 @@ const createGroupChannelFragment = (initModule?: Partial<GroupChannelModule>): G
     );
 
     const onSendFileMessage: GroupChannelProps['Input']['onSendFileMessage'] = useFreshCallback(async (file) => {
-      const params = new sdk.FileMessageParams();
-      params.file = file;
-      const processedParams = await onBeforeSendFileMessage(params);
+      const processedParams = await onBeforeSendFileMessage({ file });
       await sendFileMessage(processedParams);
     });
     const onSendUserMessage: GroupChannelProps['Input']['onSendUserMessage'] = useFreshCallback(async (text) => {
-      const params = new sdk.UserMessageParams();
-      params.message = text;
-      const processedParams = await onBeforeSendUserMessage(params);
+      const processedParams = await onBeforeSendUserMessage({ message: text });
       await sendUserMessage(processedParams);
     });
     const onUpdateFileMessage: GroupChannelProps['Input']['onUpdateFileMessage'] = useFreshCallback(
       async (editedFile, message) => {
-        const params = new sdk.FileMessageParams();
-        params.file = editedFile;
-        const processedParams = await onBeforeSendFileMessage(params);
+        const processedParams = await onBeforeSendFileMessage({ file: editedFile });
         await updateFileMessage(message.messageId, processedParams);
       },
     );
     const onUpdateUserMessage: GroupChannelProps['Input']['onUpdateUserMessage'] = useFreshCallback(
       async (editedText, message) => {
-        const params = new sdk.UserMessageParams();
-        params.message = editedText;
-        const processedParams = await onBeforeSendUserMessage(params);
+        const processedParams = await onBeforeSendUserMessage({ message: editedText });
         await updateUserMessage(message.messageId, processedParams);
       },
     );

package/src/fragments/createGroupChannelListFragment.tsx

@@ -57,7 +57,7 @@ const createGroupChannelListFragment = (initModule?: Partial<GroupChannelListMod
     );
 
     if (!currentUser) {
-      Logger.warn('Cannot render GroupChannelListFragment, User is not connected');
+      Logger.warn('Cannot render GroupChannelListFragment, please connect using `useConnection()` hook first');
       return null;
     }
 

package/src/fragments/createGroupChannelMembersFragment.tsx

@@ -27,9 +27,10 @@ const createGroupChannelMembersFragment = (
     const { STRINGS } = useLocalization();
 
     useChannelHandler(sdk, `${name}_${uniqId}`, {
-      onUserEntered(channel) {
-        if (channel.url === activeChannel.url) forceUpdate();
-      },
+      // Note: Removed from v4
+      // onUserEntered(channel) {
+      //   if (channel.url === activeChannel.url) forceUpdate();
+      // },
       onUserLeft(channel) {
         if (channel.url === activeChannel.url) forceUpdate();
       },

package/src/hooks/useConnection.ts

@@ -1,13 +1,12 @@
 import { useCallback } from 'react';
-import type Sendbird from 'sendbird';
 
-import { Logger, SendbirdUser } from '@sendbird/uikit-utils';
+import { Logger, SendbirdError, SendbirdUser } from '@sendbird/uikit-utils';
 
 import { useSendbirdChat } from './useContext';
 import usePushTokenRegistration from './usePushTokenRegistration';
 
 type ConnectOptions = { nickname?: string; accessToken?: string };
-const cacheStrictCodes = [400300, 400301, 400302, 400310];
+const cacheRestrictCodes = [400300, 400301, 400302, 400310];
 
 const useConnection = () => {
   const { sdk, setCurrentUser, features } = useSendbirdChat();
@@ -15,48 +14,47 @@ const useConnection = () => {
 
   const connect = useCallback(
     async (userId: string, opts?: ConnectOptions): Promise<SendbirdUser> => {
-      return new Promise((resolve, reject) => {
-        const callback: Sendbird.userCallback = async (user, error) => {
-          if (error && sdk.isCacheEnabled && cacheStrictCodes.some((code) => error.code === code)) {
-            Logger.warn('[useConnection]', 'connect failure', error.message, error.code);
+      try {
+        Logger.debug('[useConnection]', 'connect start:', userId);
+        let user = await sdk.connect(userId, opts?.accessToken);
+
+        if (opts?.nickname) {
+          Logger.debug('[useConnection]', 'nickname-sync start:', opts.nickname);
+          await sdk
+            .updateCurrentUserInfo({ nickname: opts.nickname })
+            .then((updatedUser) => (user = updatedUser))
+            .catch((e) => Logger.warn('[useConnection]', 'nickname-sync failure', e));
+        }
+
+        if (features.autoPushTokenRegistrationEnabled) {
+          Logger.debug('[useConnection]', 'autoPushTokenRegistration enabled, register for current user');
+          await registerPushTokenForCurrentUser().catch((e) => {
+            Logger.warn('[useConnection]', 'autoPushToken Registration failure', e);
+          });
+        }
+
+        Logger.debug('[useConnection]', 'connected! (online)');
+        setCurrentUser(user);
+
+        return user;
+      } catch (e) {
+        const error = e as unknown as SendbirdError;
+
+        if (sdk.isCacheEnabled) {
+          if (cacheRestrictCodes.some((code) => error.code === code)) {
+            Logger.warn('[useConnection]', 'offline connect restricted', error.message, error.code);
             Logger.warn('[useConnection]', 'clear cached-data');
             await sdk.clearCachedData().catch((e) => Logger.warn('[useConnection]', 'clear cached-data failure', e));
-            return reject(error);
-          }
-
-          if (user) {
-            let _user = user;
-
-            if (opts?.nickname) {
-              Logger.debug('[useConnection]', 'nickname-sync start:', opts.nickname);
-              await sdk
-                .updateCurrentUserInfo(opts.nickname, sdk.currentUser.profileUrl)
-                .then((updatedUser) => (_user = updatedUser))
-                .catch((e) => Logger.warn('[useConnection]', 'nickname-sync failure', e));
-            }
-
-            if (features.autoPushTokenRegistrationEnabled) {
-              Logger.debug('[useConnection]', 'autoPushTokenRegistration enabled, register for current user');
-              await registerPushTokenForCurrentUser().catch((e) => {
-                Logger.warn('[useConnection]', 'autoPushToken Registration failure', e);
-              });
-            }
-
-            Logger.debug('[useConnection]', 'connected!');
-            setCurrentUser(_user);
-            return resolve(_user);
+          } else if (sdk.currentUser) {
+            Logger.debug('[useConnection]', 'connected! (offline)');
+            setCurrentUser(sdk.currentUser);
+            return sdk.currentUser;
           }
+        }
 
-          if (error) {
-            Logger.warn('[useConnection]', 'connect failure', error.message, error.code);
-            return reject(error);
-          }
-        };
-
-        Logger.debug('[useConnection]', 'connect start:', userId);
-        if (opts?.accessToken) sdk.connect(userId, opts.accessToken, callback);
-        else sdk.connect(userId, callback);
-      });
+        Logger.warn('[useConnection]', 'connect failure', error.message, error.code);
+        throw error;
+      }
     },
     [sdk, registerPushTokenForCurrentUser, features.autoPushTokenRegistrationEnabled],
   );
@@ -71,8 +69,7 @@ const useConnection = () => {
       });
     }
 
-    await sdk.disconnect();
-    setCurrentUser(undefined);
+    await sdk.disconnect().then(() => setCurrentUser(undefined));
     Logger.debug('[useConnection]', 'disconnected!');
   }, [sdk, unregisterPushTokenForCurrentUser, features.autoPushTokenRegistrationEnabled]);
 

package/src/hooks/usePushTokenRegistration.ts

@@ -14,11 +14,11 @@ const usePushTokenRegistration = () => {
     return [
       Platform.select({
         ios: (token: string) => sdk.registerAPNSPushTokenForCurrentUser(token),
-        default: (token: string) => sdk.registerGCMPushTokenForCurrentUser(token),
+        default: (token: string) => sdk.registerFCMPushTokenForCurrentUser(token),
       }),
       Platform.select({
         ios: (token: string) => sdk.unregisterAPNSPushTokenForCurrentUser(token),
-        default: (token: string) => sdk.unregisterGCMPushTokenForCurrentUser(token),
+        default: (token: string) => sdk.unregisterFCMPushTokenForCurrentUser(token),
       }),
       Platform.select({
         ios: notificationService.getAPNSToken,

package/src/index.ts

@@ -101,6 +101,7 @@ export {
   SendbirdUIKit,
   SendbirdUIKitContainerProps,
 } from './containers/SendbirdUIKitContainer';
+export { default as SBUError } from './libs/SBUError';
 
 export * from './types';
 

package/src/libs/InternalLocalCacheStorage.ts

@@ -1,3 +1,5 @@
+import { ASYNC_NOOP } from '@sendbird/uikit-utils';
+
 import type { KeyValuePairGet, KeyValuePairSet, LocalCacheStorage } from '../types';
 
 export default class InternalLocalCacheStorage implements LocalCacheStorage {
@@ -42,4 +44,7 @@ export default class InternalLocalCacheStorage implements LocalCacheStorage {
       await Promise.all(keyValuePairs.map(([key, value]) => this.storage.setItem(key, value)));
     }
   }
+
+  clear = ASYNC_NOOP;
+  flushGetRequests = ASYNC_NOOP;
 }

package/src/libs/SBUError.ts

@@ -0,0 +1,26 @@
+enum SBUErrorCode {
+  ERR_UNKNOWN = 90000000,
+
+  // Platform service - 91001000 ~
+  ERR_PERMISSIONS_DENIED = 91001000,
+  ERR_DEVICE_UNAVAILABLE,
+}
+
+export default class SBUError extends Error {
+  static CODE = SBUErrorCode;
+
+  static get UNKNOWN() {
+    return new SBUError(SBUErrorCode.ERR_UNKNOWN);
+  }
+
+  static get PERMISSIONS_DENIED() {
+    return new SBUError(SBUErrorCode.ERR_PERMISSIONS_DENIED);
+  }
+  static get DEVICE_UNAVAILABLE() {
+    return new SBUError(SBUErrorCode.ERR_DEVICE_UNAVAILABLE);
+  }
+
+  constructor(public code: SBUErrorCode, message?: string) {
+    super(message);
+  }
+}

package/src/libs/SBUUtils.ts

@@ -0,0 +1,9 @@
+import { Linking, Platform } from 'react-native';
+
+export default class SBUUtils {
+  static openSettings() {
+    Linking.openSettings().catch(() => {
+      if (Platform.OS === 'ios') Linking.openURL('App-Prefs:root');
+    });
+  }
+}

package/src/localization/StringSet.type.ts

@@ -149,6 +149,11 @@ export interface StringSet {
   };
   DIALOG: {
     ALERT_DEFAULT_OK: string;
+
+    ALERT_PERMISSIONS_TITLE: string;
+    ALERT_PERMISSIONS_MESSAGE: (permission: string, appName: string) => string;
+    ALERT_PERMISSIONS_OK: string;
+
     PROMPT_DEFAULT_OK: string;
     PROMPT_DEFAULT_CANCEL: string;
     PROMPT_DEFAULT_PLACEHOLDER: string;
@@ -316,6 +321,11 @@ export const createBaseStringSet = ({ dateLocale, overrides }: StringSetCreateOp
     },
     DIALOG: {
       ALERT_DEFAULT_OK: 'OK',
+      ALERT_PERMISSIONS_TITLE: 'Allow permission',
+      ALERT_PERMISSIONS_MESSAGE: (permission, appName = 'Application') => {
+        return `${appName} need permission to access your ${permission}. Go to Settings to allow access`;
+      },
+      ALERT_PERMISSIONS_OK: 'SETTINGS',
       PROMPT_DEFAULT_OK: 'Submit',
       PROMPT_DEFAULT_CANCEL: 'Cancel',
       PROMPT_DEFAULT_PLACEHOLDER: 'Enter',

package/src/platform/createFileService.expo.ts

@@ -5,6 +5,7 @@ import type * as ExpoMediaLibrary from 'expo-media-library';
 
 import { getFileExtension, getFileType } from '@sendbird/uikit-utils';
 
+import SBUError from '../libs/SBUError';
 import type { ExpoMediaLibraryPermissionResponse, ExpoPermissionResponse } from '../utils/expoPermissionGranted';
 import expoPermissionGranted from '../utils/expoPermissionGranted';
 import fileTypeGuard from '../utils/fileTypeGuard';
@@ -55,7 +56,7 @@ const createExpoFileService = ({
       if (!hasPermission) {
         const granted = await this.requestCameraPermission();
         if (!granted) {
-          options?.onOpenFailureWithToastMessage?.();
+          options?.onOpenFailure?.(SBUError.PERMISSIONS_DENIED);
           return null;
         }
       }
@@ -89,7 +90,7 @@ const createExpoFileService = ({
       if (!hasPermission) {
         const granted = await this.requestMediaLibraryPermission('read');
         if (!granted) {
-          options?.onOpenFailureWithToastMessage?.();
+          options?.onOpenFailure?.(SBUError.PERMISSIONS_DENIED);
           return null;
         }
       }
@@ -123,8 +124,8 @@ const createExpoFileService = ({
         if (response.type === 'cancel') return null;
         const { mimeType, uri, size, name } = response;
         return fileTypeGuard({ uri, size, name, type: mimeType });
-      } catch {
-        options?.onOpenFailureWithToastMessage?.();
+      } catch (e) {
+        options?.onOpenFailure?.(SBUError.UNKNOWN, e);
         return null;
       }
     }

package/src/platform/createFileService.native.ts

@@ -6,8 +6,9 @@ import type * as ImagePicker from 'react-native-image-picker';
 import type * as Permissions from 'react-native-permissions';
 import type { Permission } from 'react-native-permissions';
 
-import { getFileExtension, getFileType } from '@sendbird/uikit-utils';
+import { getFileExtension, getFileType, normalizeFileName } from '@sendbird/uikit-utils';
 
+import SBUError from '../libs/SBUError';
 import fileTypeGuard from '../utils/fileTypeGuard';
 import nativePermissionGranted from '../utils/nativePermissionGranted';
 import type {
@@ -87,12 +88,13 @@ const createNativeFileService = ({
       if (!hasPermission) {
         const granted = await this.requestCameraPermission();
         if (!granted) {
-          options?.onOpenFailureWithToastMessage?.();
+          options?.onOpenFailure?.(SBUError.PERMISSIONS_DENIED);
           return null;
         }
       }
 
       const response = await imagePickerModule.launchCamera({
+        presentationStyle: 'fullScreen',
         cameraType: options?.cameraType ?? 'back',
         mediaType: (() => {
           switch (options?.mediaType) {
@@ -109,7 +111,7 @@ const createNativeFileService = ({
       });
       if (response.didCancel) return null;
       if (response.errorCode === 'camera_unavailable') {
-        options?.onOpenFailureWithToastMessage?.();
+        options?.onOpenFailure?.(SBUError.DEVICE_UNAVAILABLE, new Error(response.errorMessage));
         return null;
       }
 
@@ -126,12 +128,13 @@ const createNativeFileService = ({
       if (!hasPermission) {
         const granted = await this.requestMediaLibraryPermission();
         if (!granted) {
-          options?.onOpenFailureWithToastMessage?.();
+          options?.onOpenFailure?.(SBUError.PERMISSIONS_DENIED);
           return null;
         }
       }
 
       const response = await imagePickerModule.launchImageLibrary({
+        presentationStyle: 'fullScreen',
         selectionLimit,
         mediaType: (() => {
           switch (options?.mediaType) {
@@ -148,7 +151,7 @@ const createNativeFileService = ({
       });
       if (response.didCancel) return null;
       if (response.errorCode === 'camera_unavailable') {
-        options?.onOpenFailureWithToastMessage?.();
+        options?.onOpenFailure?.(SBUError.DEVICE_UNAVAILABLE, new Error(response.errorMessage));
         return null;
       }
 
@@ -162,7 +165,7 @@ const createNativeFileService = ({
         return fileTypeGuard({ uri, size, name, type });
       } catch (e) {
         if (!documentPickerModule.isCancel(e) && documentPickerModule.isInProgress(e)) {
-          options?.onOpenFailureWithToastMessage?.();
+          options?.onOpenFailure?.(SBUError.UNKNOWN, e);
         }
         return null;
       }
@@ -186,13 +189,18 @@ const createNativeFileService = ({
       await fsModule.FileSystem.fetch(options.fileUrl, { path: downloadPath });
       const fileType = getFileType(getFileExtension(options.fileUrl));
 
-      if (Platform.OS === 'ios' && fileType.match(/image|video/)) {
-        await mediaLibraryModule.save(downloadPath);
+      if (Platform.OS === 'ios' && (fileType === 'image' || fileType === 'video')) {
+        const type = ({ 'image': 'photo', 'video': 'video' } as const)[fileType];
+        await mediaLibraryModule.save(downloadPath, { type });
       }
 
       if (Platform.OS === 'android') {
         const dirType = { 'file': 'downloads', 'audio': 'audio', 'image': 'images', 'video': 'video' } as const;
-        await fsModule.FileSystem.cpExternal(downloadPath, options.fileName, dirType[fileType]);
+        await fsModule.FileSystem.cpExternal(
+          downloadPath,
+          normalizeFileName(options.fileName, getFileExtension(options.fileUrl)),
+          dirType[fileType],
+        );
       }
       return downloadPath;
     }

package/src/platform/types.ts

@@ -1,3 +1,5 @@
+import type SBUError from '../libs/SBUError';
+
 export type Unsubscribe = () => void | undefined;
 export type DownloadedPath = string;
 export type FilePickerResponse = FileType | null;
@@ -23,7 +25,7 @@ export interface ClipboardServiceInterface {
 export interface FileServiceInterface extends FilePickerServiceInterface, FileSystemServiceInterface {}
 
 export interface OpenResultListener {
-  onOpenFailureWithToastMessage?: () => void;
+  onOpenFailure?: (error: SBUError, originError?: unknown) => void;
 }
 export interface OpenMediaLibraryOptions extends OpenResultListener {
   selectionLimit?: number;

package/src/version.ts

@@ -1,2 +1,2 @@
-const VERSION = '1.1.1';
+const VERSION = '2.0.0-rc.0';
 export default VERSION;