@norcy/react-native-toolkit 0.1.5 → 0.1.6

package/src/AppleLoginUtil.ts

@@ -0,0 +1,107 @@
+import { appleAuth } from '@invertase/react-native-apple-authentication';
+import { getBundleId } from 'react-native-device-info';
+import { LoginState } from './constant';
+
+const AV = require('leancloud-storage');
+
+const AppleLoginUtil = {
+  // 这是监听苹果取消授权的回调，目前不需要
+  //     appleAuth.onCredentialRevoked(async () => {
+  //         fetchAndUpdateCredentialState(loginUser).catch(error => {
+  //             updateCredentialStateForUser(`Error: ${error.code}`)
+  //         });
+  //     });
+
+  fetchAndUpdateCredentialState: async (user: string, callback: Function) => {
+    console.log('User 正在登录鉴权：', user);
+
+    if (user === null) {
+      callback({ result: LoginState.NOTLOGIN }, { error: 'USER EMPTY' });
+    } else {
+      const credentialState = await appleAuth.getCredentialStateForUser(user);
+      if (credentialState === appleAuth.State.AUTHORIZED) {
+        console.log('登录鉴权成功');
+        callback({ result: LoginState.AUTHORIZED });
+      } else {
+        console.warn('登录鉴权失败');
+        callback(
+          { result: LoginState.NOTLOGIN },
+          { error: 'Authorized Failed' }
+        );
+      }
+    }
+  },
+
+  requestAppleUserForLogin: async () => {
+    if (!appleAuth.isSupported) {
+      return { error: 'Apple Auth Not Supported' };
+    }
+
+    // start a login request
+    try {
+      const appleAuthRequestResponse = await appleAuth.performRequest({
+        requestedOperation: appleAuth.Operation.LOGIN,
+        requestedScopes: [appleAuth.Scope.EMAIL, appleAuth.Scope.FULL_NAME],
+      });
+
+      console.log('appleAuthRequestResponse login', appleAuthRequestResponse);
+
+      const { user: newUser, email, identityToken } = appleAuthRequestResponse;
+
+      console.log(`Apple Authentication Completed, ${newUser}, ${email}`);
+
+      return { user: newUser, email: email, identityToken: identityToken };
+    } catch (error: any) {
+      if (error.code === appleAuth.Error.CANCELED) {
+        // console.warn('User canceled Apple Sign in.');
+        return { error: 'User Cancel Login', code: error.code };
+      } else {
+        // console.warn('登录鉴权出错: ', error);
+        return { error: 'Login Request Fail', code: error.code };
+      }
+    }
+  },
+
+  requestAppleUserForLogout: async () => {
+    if (!appleAuth.isSupported) {
+      throw { error: 'Apple Auth Not Supported', code: -1 };
+    }
+
+    // start a login request
+    try {
+      const appleAuthRequestResponse = await appleAuth.performRequest({
+        requestedOperation: appleAuth.Operation.LOGOUT,
+      });
+
+      console.log('appleAuthRequestResponse logout', appleAuthRequestResponse);
+
+      return { authorizationCode: appleAuthRequestResponse.authorizationCode };
+    } catch (error: any) {
+      if (error.code === appleAuth.Error.CANCELED) {
+        throw { error: 'User Cancel Logout', code: error.code };
+      } else {
+        throw { error: 'Logout Request Fail', code: error.code };
+      }
+    }
+  },
+
+  requestDeleteAccount: async () => {
+    if (appleAuth.isSupported) {
+      const { authorizationCode } =
+        await AppleLoginUtil.requestAppleUserForLogout();
+      console.log('get authorizationCode success', authorizationCode);
+      const { token } = await AV.Cloud.run('getToken', {
+        authorizationCode,
+        bundleId: getBundleId(),
+      });
+      console.log('get token success', token);
+      await AV.Cloud.run('revokeAppleAccount', {
+        token,
+        bundleId: getBundleId(),
+      });
+      console.log('revoke account success');
+    }
+  },
+};
+
+export default AppleLoginUtil;

package/src/PrefData.ts

@@ -0,0 +1,134 @@
+import AsyncStorage from '@react-native-community/async-storage';
+
+const EventEmitter = require('events').EventEmitter;
+const eventEmitter = new EventEmitter();
+
+let isDataLoaded = false;
+
+export interface PrefType {
+  key: string;
+  type: string;
+  default: any;
+}
+
+export interface PrefsType {
+  [key: string]: PrefType;
+}
+
+const _PrefDatas: { [key: string]: any } = {};
+
+export const BuildInPrefs: PrefsType = {
+  LastLoginType: {
+    key: 'LastLoginType_Key',
+    type: 'int',
+    default: -1,
+  },
+  isFirstLaunch: {
+    key: 'isFirstLaunch_Key2',
+    type: 'bool',
+    default: true,
+  },
+};
+
+const getPrefByKey = (Prefs: PrefsType, key: string) => {
+  for (const keyOfPref in Prefs) {
+    if (Prefs[keyOfPref].key === key) {
+      return Prefs[keyOfPref];
+    }
+  }
+  return null;
+};
+
+export const PrefData = {
+  load: async (initPrefs: PrefsType) => {
+    console.log('读取配置');
+    let keys = [];
+    const Prefs = { ...BuildInPrefs, ...initPrefs };
+    for (const pref in Prefs) {
+      keys.push(Prefs[pref].key);
+    }
+    const values = await getMultiDatas(keys);
+
+    for (let i = 0; i < values.length; i++) {
+      const key = values[i][0];
+      const value = values[i][1];
+      const pref = getPrefByKey(Prefs, key);
+      if (!pref) {
+        continue;
+      }
+      // console.log(key, value, pref);
+      if (!value) {
+        _PrefDatas[key] = pref.default;
+      } else if (pref.type === 'object' || pref.type === 'array') {
+        _PrefDatas[key] = JSON.parse(value);
+      } else if (pref.type === 'int') {
+        _PrefDatas[key] = parseInt(value, 10);
+      } else if (pref.type === 'bool') {
+        _PrefDatas[key] = JSON.parse(value);
+      } else {
+        _PrefDatas[key] = value;
+      }
+      // console.log(
+      //   '配置读取结果：',
+      //   key,
+      //   _PrefDatas[key],
+      //   typeof _PrefDatas[key],
+      // );
+    }
+
+    eventEmitter.emit('load');
+    isDataLoaded = true;
+  },
+
+  getValue: (pref: PrefType) => {
+    return _PrefDatas[pref.key];
+  },
+
+  setValue: async (pref: PrefType, value: any) => {
+    const key = pref.key;
+    let finalValue: string;
+    _PrefDatas[key] = value;
+    if (pref.type === 'object' || pref.type === 'array') {
+      finalValue = JSON.stringify(value);
+    } else if (pref.type === 'int') {
+      finalValue = value.toString();
+    } else if (pref.type === 'bool') {
+      finalValue = value.toString();
+    } else {
+      finalValue = value;
+    }
+
+    await storeData(key, finalValue);
+  },
+
+  addListener: (callback: Function) => {
+    if (isDataLoaded) {
+      callback && callback();
+      return;
+    }
+    eventEmitter.on('load', callback);
+  },
+};
+
+const storeData = async (key: string, value: string) => {
+  try {
+    if (typeof value !== 'string') {
+      console.error('只接受 String');
+    }
+    // console.log('save to storage ' + value);
+    await AsyncStorage.setItem(key, value);
+  } catch (e) {
+    console.error(e);
+  }
+};
+
+const getMultiDatas = async (keys: string[]) => {
+  try {
+    const values = await AsyncStorage.multiGet(keys);
+    // console.log('read from storage ' + values);
+    return values;
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+};

package/src/ReportUtil.ts

@@ -0,0 +1,138 @@
+import { NativeModules, Platform } from 'react-native';
+import {
+  getBrand,
+  getDeviceId,
+  getModel,
+  getReadableVersion,
+} from 'react-native-device-info';
+import { Notification } from './Notification';
+import { UserType } from './constant';
+
+export interface ReportItemType {
+  [key: string]: number | string;
+}
+
+const CommonInfo: ReportItemType = {
+  appVer: getReadableVersion(),
+  platform: Platform.OS,
+  sysVer: Platform.Version,
+  model: getModel(),
+  brand: getBrand(),
+  device: getDeviceId(),
+};
+
+const enable = () => {
+  if (__DEV__) {
+    return false;
+  }
+  if (!NativeModules.NCYReport) {
+    return false;
+  }
+  return true;
+};
+
+const isValidReport = (eventId: string, params?: ReportItemType) => {
+  if (typeof eventId !== 'string' || eventId?.length === 0) {
+    console.error('Report 数据非法 1');
+    return false;
+  }
+
+  if (params == null) {
+    return true;
+  }
+
+  if (typeof params !== 'object' || Array.isArray(params)) {
+    console.error('Report 数据非法 2');
+    return false;
+  }
+
+  for (const key in params) {
+    if (typeof key !== 'string') {
+      console.error('Report 数据非法 3');
+      return false;
+    }
+  }
+
+  return true;
+};
+
+const convertToValidParams = (params?: ReportItemType) => {
+  const ret: ReportItemType = {};
+  for (const key in params) {
+    const value = JSON.stringify(params[key]);
+    ret[key] = value;
+  }
+  return ret;
+};
+
+const ReportUtil = {
+  init: () => {
+    if (!enable()) {
+      return;
+    }
+
+    Notification.addListener(
+      'onLogin',
+      ({ error, user }: { error: any; user: UserType }) => {
+        if (!error && user) {
+          NativeModules.NCYReport.signIn(user.AVUser.get('objectId'));
+          ReportUtil.setCommonInfo('user', user.AVUser.get('objectId'));
+        }
+      }
+    );
+
+    Notification.addListener('onLogout', () => {
+      NativeModules.NCYReport.signOut();
+      ReportUtil.setCommonInfo('user', '');
+    });
+  },
+
+  report: (eventId: string, params?: ReportItemType) => {
+    if (!enable()) {
+      return;
+    }
+
+    if (!isValidReport(eventId, params)) {
+      return;
+    }
+
+    const validParams = convertToValidParams(params);
+    const realParams = { ...validParams, ...ReportUtil.getCommonInfo() };
+    console.log(realParams);
+    NativeModules.NCYReport.report(eventId, realParams);
+  },
+
+  setCommonInfo: (key: string, value: string) => {
+    CommonInfo[key] = value;
+  },
+
+  getCommonInfo: () => {
+    return CommonInfo;
+  },
+
+  viewAppear: (page: string) => {
+    if (!__DEV__) {
+      console.log(page, 'viewWillAppear');
+    }
+
+    if (!enable()) {
+      return;
+    }
+
+    NativeModules.NCYReport.enterPage(page);
+  },
+
+  viewDisappear: (page: string) => {
+    if (!__DEV__) {
+      console.log(page, 'viewWillDisappear');
+    }
+
+    if (!enable()) {
+      return;
+    }
+
+    NativeModules.NCYReport.leavePage(page);
+  },
+};
+
+export default ReportUtil;

package/src/SentryManager.ts

@@ -0,0 +1,49 @@
+import { Notification, UserType } from '@norcy/react-native-toolkit';
+import * as Sentry from '@sentry/react-native';
+
+const SentryManager = {
+  init: () => {
+    if (__DEV__) {
+      console.log('__DEV__ 下不使用 Sentry');
+    } else {
+      // DEV 下不打开 Sentry
+      console.log('__RELEASE__ 下使用 Sentry');
+      Sentry.init({
+        dsn: 'https://a67f2741a16c45c4a66527b8f8b046a2@o473216.ingest.sentry.io/6509175',
+        tracesSampleRate: 1.0,
+      });
+
+      Notification.addListener(
+        'onLogin',
+        ({ error, user }: { error: any; user: UserType }) => {
+          if (!error && user) {
+            const sentryUser: Sentry.User = {
+              id: user.AVUser.get('objectId'),
+              email: user.email,
+              username: user.nickname,
+            };
+            Sentry.setUser(sentryUser);
+          }
+        }
+      );
+
+      Notification.addListener('onLogout', () => {
+        Sentry.setUser(null);
+      });
+
+      // Sentry.nativeCrash();
+      // Sentry.captureException(new Error('测试77！'));
+      // throw new Error('My first Sentry error!');
+    }
+  },
+
+  setTag: (key: string, value: any) => {
+    if (!__DEV__) {
+      if (key.length) {
+        Sentry.setTag(key, value);
+      }
+    }
+  },
+};
+
+export default SentryManager;

package/src/constant.ts

@@ -0,0 +1,20 @@
+import { User } from 'leancloud-storage';
+
+export interface UserType {
+  nickname: string;
+  email: string;
+  headimgurl: string;
+  type: number;
+  AVUser: User;
+}
+
+export enum LoginState {
+  NOTLOGIN,
+  AUTHORIZED,
+}
+
+export enum LoginType {
+  LoginTypeApple,
+  LoginTypeWeChat,
+  LoginTypeVisitor,
+}

package/src/index.tsx

@@ -9,3 +9,8 @@ const { ReactNativeToolkit } = NativeModules;
 export default ReactNativeToolkit as ReactNativeToolkitType;
 export * from './SyncPrefData';
 export * from './Notification';
+export * from './ReportUtil';
+export * from './SentryManager';
+export * from './AppleLoginUtil';
+export * from './constant';
+export * from './PrefData';