@huaapp001/m-play 0.0.1 → 0.0.2

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@huaapp001/m-play",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "m-play",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
-  "private": false,
   "exports": {
     ".": {
       "import": "./lib/module/index.js",
@@ -17,6 +16,7 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "src",
     "lib",
     "android",
     "ios",

package/src/NativeMPlay.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiply(a: number, b: number): number;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('MPlay');

package/src/config/index.ts

@@ -0,0 +1,48 @@
+// 定义配置类型
+export interface ConfigType {
+    header: {
+        apiUrl?: string;
+        appId?: string;
+        PACKAGENAME?: string;
+    };
+    webviewUrl: string;
+    adjustConfig: {
+        devKey: string;
+        appId: string;
+        ADJUST_MAX_DELAY_TIME: number;
+        ONELINK_SHARE_VALUE: string;
+        ONELINK_NO_HTTP_VALUE: string;
+        bgImage: string
+        appName: string;
+        loadingText: string;
+        completePrefixUrl: string;
+    }
+}
+
+// 声明全局类型
+declare global {
+    var __MPLAY_CONFIG__: ConfigType | null;
+}
+
+// 初始化全局配置
+if (!global.__MPLAY_CONFIG__) {
+    global.__MPLAY_CONFIG__ = null;
+}
+
+// 设置配置
+export const initializeConfig = (config: ConfigType) => {
+    global.__MPLAY_CONFIG__ = config;
+};
+
+// 获取配置
+export const getConfig = (): ConfigType => {
+    if (!global.__MPLAY_CONFIG__) {
+        throw new Error('Config not initialized. Please call initializeConfig first.');
+    }
+    return global.__MPLAY_CONFIG__;
+};
+
+// 重置配置
+export const resetConfig = () => {
+    global.__MPLAY_CONFIG__ = null;
+};

package/src/index.tsx

@@ -0,0 +1,3 @@
+import ProviderBPackageIndex from './package/screens/home';
+import { initializeConfig } from './config';
+export { ProviderBPackageIndex, initializeConfig };

package/src/package/atoms/global.ts

@@ -0,0 +1,19 @@
+import { atom } from 'jotai';
+import { Platform } from 'react-native';
+
+/** 是否允许att权限访问 */
+export const isAllowAttAccessAtom = atom<boolean>(
+  Platform.OS === 'android' ? true : false
+);
+
+/** 存储的深链后面的参数-临时存储 后期需要清除 */
+export const schemeDeepLinkParamsAtom = atom<Record<string, string>>({});
+
+/** 是否第一次初始化af成功 */
+export const isFirstInitAfSuccessAtom = atom(false);
+
+/** b包webview是否加载完成 */
+export const bPackageWebviewLoadingFinishAtom = atom(false);
+
+/** 中间页是否加载完成 */
+export const MiddleScreenLoadingFinishAtom = atom(false);

package/src/package/components/webview/index.tsx

@@ -0,0 +1,89 @@
+import React, { useRef, useImperativeHandle, forwardRef } from 'react';
+import { onMessageForRN } from '@tianzhitong/js-bridge';
+import { WebView } from 'react-native-webview';
+
+// 注入初始化代码
+const injectJavaScriptInit = `
+(function(){
+  window.ReactNativeJsBridge = {
+    callbackSeq: 1,
+    send: function(data) {
+      return new Promise(function(resolve, reject) {
+        const callbackName = 'ReactNativeWebViewCallback_' + ReactNativeJsBridge.callbackSeq++;
+  
+        window[callbackName] = function(result) {
+          resolve(result);
+          delete window[callbackName];
+        };
+  
+        window.ReactNativeWebView.postMessage(
+          JSON.stringify({
+            callbackId: callbackName,
+            data,
+          }),
+        );
+      });
+    },
+  };
+
+  window.ReactNativeJsBridge.send({
+    type: 'titleChange',
+    data: document.title,
+  });
+
+  new MutationObserver(function(mutations) {
+    window.ReactNativeJsBridge.send({
+      type: 'titleChange',
+      data: mutations[0].target.nodeValue,
+    });
+  }).observe(
+    document.querySelector('title'),
+    { subtree: true, characterData: true, childList: true }
+  );
+})();
+`;
+
+export default (props: any) => {
+  const {
+    source = {},
+    ref,
+    onLoad = () => {},
+    onLoadEnd = () => {},
+    onShouldStartLoadWithRequest = null,
+    injectJavaScript = '',
+    ...other
+  } = props;
+
+  const handleOnLoad = (e) => {
+    onLoad(e);
+  };
+
+  const handleOnLoadEnd = (e) => {
+    onLoadEnd(e);
+  };
+
+  const hanldeShouldStartLoadWithRequest = (e) => {
+    if (onShouldStartLoadWithRequest) {
+      return onShouldStartLoadWithRequest(e);
+    }
+    return true;
+  };
+
+  return (
+    <WebView
+      ref={ref}
+      source={source}
+      webviewDebuggingEnabled
+      domStorageEnabled={true} // 启用 DOM 存储
+      startInLoadingState={true} // 显示加载指示器
+      javaScriptEnabled={true} // 启用 JavaScript
+      onLoad={handleOnLoad}
+      onMessage={onMessageForRN}
+      onLoadEnd={handleOnLoadEnd}
+      onShouldStartLoadWithRequest={hanldeShouldStartLoadWithRequest}
+      injectedJavaScript={`${injectJavaScriptInit}${injectJavaScript}`}
+      allowsInlineMediaPlayback={true}
+      {...other}
+    />
+  );
+};

package/src/package/const/storage.ts

@@ -0,0 +1,10 @@
+export const STORAGE_USER_ID = 'STORAGE_USER_ID';
+
+export const STORAGE_USER_TOKEN = 'STORAGE_USER_TOKEN';
+
+/** 第一次初始化adjust存储key */
+export const APP_FIRST_INIT_ADJUST_KEY = 'APP_FIRST_INIT_ADJUST_KEY';
+/** 不带协议的 */
+export const ONELINK_NO_HTTP_VALUE = 'com.play.flamshort://';
+/** TODO 链接需要替换 */
+export const ONELINK_SHARE_VALUE = 'https://flamshort.onelink.me/';

package/src/package/hooks/useAppGetUID.ts

@@ -0,0 +1,52 @@
+import { axiosGet, axiosPost } from '../request';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { useEffect, useState } from 'react';
+import { NativeModules, Platform } from 'react-native';
+import deviceInfo from 'react-native-device-info';
+import { STORAGE_USER_ID } from '../const/storage';
+import useGetNetwork from './useGetNetwork';
+
+const useAppGetUID = () => {
+  const [isLoading, setIsLoading] = useState(false);
+  const [isAPackage, setIsAPackage] = useState(false);
+  const [isConnectNetwork] = useGetNetwork();
+  useEffect(() => {
+    if(!isConnectNetwork) return;
+    const getUserId = async () => {
+      try {
+        // 获取ip地址
+        const ipRes = await axiosGet('/get_ip_info/');
+        console.log('ipRes', ipRes);
+        // 获取版本信息
+        const res = await axiosPost('/get_version/', {
+          phone_version: deviceInfo.getBrand(),
+          system_version: deviceInfo.getSystemVersion(),
+          language:
+            Platform.OS === 'ios'
+              ? NativeModules.SettingsManager?.settings?.AppleLocale ||
+                NativeModules.SettingsManager?.settings?.AppleLanguages[0]
+              : NativeModules?.I18nManager?.localeIdentifier,
+          app_version: deviceInfo.getVersion(),
+          unique_id: deviceInfo.getUniqueIdSync() + '1112',
+          ip: ipRes.data.ip,
+        });
+
+        console.log('resresres',res)
+        setIsAPackage(res.data.publishStatus !== '1');
+        global.GLOBAL_USER_UID = res.data.user_id;
+        AsyncStorage.setItem(STORAGE_USER_ID, String(res.data.user_id));
+        setIsLoading(true);
+      } catch (ex) {
+        console.log('ex111', ex);
+      }
+    };
+    getUserId();
+  }, [isConnectNetwork]);
+
+  return {
+    isLoading,
+    isAPackage,
+  };
+};
+
+export default useAppGetUID;

package/src/package/hooks/useGetNetwork.ts

@@ -0,0 +1,15 @@
+import { useEffect, useState } from 'react';
+import { useNetInfo } from '@react-native-community/netinfo';
+
+const useGetNetwork = () => {
+  /** 启动app时是否有网络 */
+  const [isConnectNetwork, setIsConnectNetwork] = useState(false);
+  const { isConnected } = useNetInfo();
+  useEffect(() => {
+    if (isConnected) {
+      setIsConnectNetwork(true);
+    }
+  }, [isConnected, setIsConnectNetwork]);
+  return [isConnectNetwork];
+};
+export default useGetNetwork;

package/src/package/hooks/useGetUserToken.ts

@@ -0,0 +1,51 @@
+import { useEffect } from 'react';
+import useGoogleAndIosLogin from './useGoogleAndIosLogin';
+import DeviceInfo from 'react-native-device-info';
+import { NativeModules, Platform } from 'react-native';
+import { axiosPost } from '../request';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { STORAGE_USER_TOKEN } from '../const/storage';
+
+const useGetUserToken = (jsbridge: any) => {
+  const { googleLogin } = useGoogleAndIosLogin();
+  useEffect(() => {
+    jsbridge.addEventListener('LOG_IN', (type: string) => {
+      googleLogin().then((googleCredential) => {
+        const params = {
+          uid: global.GLOBAL_USER_UID,
+          source: '',
+          phone_version: DeviceInfo.getBrand(),
+          system_version: DeviceInfo.getSystemVersion(),
+          language:
+            Platform.OS === 'ios'
+              ? NativeModules.SettingsManager.settings.AppleLocale ||
+                NativeModules.SettingsManager.settings.AppleLanguages[0]
+              : NativeModules.I18nManager.localeIdentifier,
+          app_version: DeviceInfo.getVersion(),
+          account_type: 'google',
+          unique_id: '',
+          ip: DeviceInfo.getIpAddressSync(),
+          id_token: googleCredential?.token,
+        };
+        console.log('params', googleCredential?.token);
+        axiosPost('/register/', params)
+          .then((res) => {
+            console.log('res', res);
+            AsyncStorage.setItem(STORAGE_USER_TOKEN, res.data.token);
+            console.log('res.data.token', res.data.token);
+            jsbridge.postMessage({
+              type: 'USER_STATUS',
+              payload: {
+                token: res.data.token,
+              },
+            });
+          })
+          .catch((err) => {
+            console.log('err', err);
+          });
+      });
+    });
+  }, []);
+};
+
+export default useGetUserToken;

package/src/package/hooks/useGoogleAndIosLogin.ts

@@ -0,0 +1,34 @@
+import { useEffect } from 'react';
+import { GoogleSignin } from '@react-native-google-signin/google-signin';
+import auth from '@react-native-firebase/auth';
+
+const useGoogleAndIosLogin = () => {
+  useEffect(() => {
+    GoogleSignin.configure({
+      webClientId:
+        '964229154053-r3o5j6c6fpq7r35eia03mpfnr5r8frgm.apps.googleusercontent.com',
+      iosClientId:
+        '964229154053-kv218k58e53un307mu8d2i7lrr2ok1kt.apps.googleusercontent.com',
+    });
+  }, []);
+
+  const googleLogin = async () => {
+    try {
+      await GoogleSignin.hasPlayServices({
+        showPlayServicesUpdateDialog: true,
+      });
+      await GoogleSignin.signOut();
+      const { data }: any = await GoogleSignin.signIn();
+      let googleCredential = auth.GoogleAuthProvider.credential(data.idToken);
+      return googleCredential;
+    } catch (error) {
+      // Toast.info('Login failed, please try again later');
+      console.log('谷歌catch错误', error);
+    }
+  };
+
+  return {
+    googleLogin,
+  };
+};
+export default useGoogleAndIosLogin;

package/src/package/hooks/useInitAfInfo.ts

@@ -0,0 +1,213 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import Clipboard from '@react-native-clipboard/clipboard';
+import {
+  isFirstInitAfSuccessAtom,
+  schemeDeepLinkParamsAtom,
+} from '../atoms/global';
+import { useAtomValue, useSetAtom } from 'jotai';
+import { useEffect } from 'react';
+import { Linking } from 'react-native';
+import appsFlyer from 'react-native-appsflyer';
+import { APP_FIRST_INIT_ADJUST_KEY } from '../const/storage';
+import useGetNetwork from './useGetNetwork';
+import { isAllowAttAccessAtom } from '../atoms/global';
+import { extractQueryParams } from '../utils/extractQueryParams';
+import { getUrlFromDevice } from '../utils/getUrlFromDevice';
+import { getConfig } from '../../config';
+
+interface Data {
+  deeplink: string;
+  isAJ?: boolean;
+  isLoadTwo?: boolean;
+}
+
+
+const useInitAfInfo = () => {
+  const systemConfig = getConfig();
+  const setSchemeDeepLinkParamsAtom = useSetAtom(schemeDeepLinkParamsAtom);
+  const [isConnected] = useGetNetwork();
+  const isAllowAttAccess = useAtomValue(isAllowAttAccessAtom);
+  const setIsFirstInitAfSuccessAtom = useSetAtom(isFirstInitAfSuccessAtom);
+
+  /** 处理深链信息 */
+  const processDeepLink = (data: Data) => {
+    const { deeplink, isAJ = false, isLoadTwo = false } = data;
+    // TODO 可删除
+    console.log('deeplinkdeeplink------->>>>>', deeplink);
+    if (!isLoadTwo && isAJ) {
+      global.IS_FIRST_LOAD_DEEP_LINK = true;
+      global.AF_END_LOAD_TIME = new Date().getTime();
+    }
+    let params: Record<string, string> = {};
+    if (deeplink.includes(systemConfig.adjustConfig.ONELINK_SHARE_VALUE)) {
+      const url = deeplink.split(systemConfig.adjustConfig.ONELINK_SHARE_VALUE)[1];
+      params = extractQueryParams(url) ?? {};
+      if (params.deep_link_value) {
+        processDeepLink({
+          deeplink:
+            systemConfig.adjustConfig.ONELINK_NO_HTTP_VALUE + decodeURIComponent(params.deep_link_value),
+          isAJ,
+          isLoadTwo: true,
+        });
+        return;
+      }
+    }
+    if (deeplink.includes(systemConfig.adjustConfig.ONELINK_NO_HTTP_VALUE)) {
+      const url = deeplink.split(systemConfig.adjustConfig.ONELINK_NO_HTTP_VALUE)[1];
+      params = extractQueryParams(url) ?? {};
+      // 做一个兜底处理 目前安卓模拟器会出现右边的情况 ONELINK_NO_HTTP_VALUE?deep_link_value=ONELINK_NO_HTTP_VALUE
+      if (params.deep_link_value) {
+        processDeepLink({
+          deeplink: systemConfig.adjustConfig.ONELINK_NO_HTTP_VALUE + decodeURIComponent(params.deep_link_value),
+          isAJ,
+          isLoadTwo: true,
+        });
+        return;
+      }
+    }
+    console.log('params',params)
+    setSchemeDeepLinkParamsAtom(params);
+    setIsFirstInitAfSuccessAtom(true);
+  };
+
+  /** 剪切板信息 */
+  const handlePasteboardInfo = async () => {
+    // TODO 可删除
+    console.log('deeplinkdeeplink------->>>>>handlePasteboardInfo');
+    // 若是之前执行过，该值是true，但是之前若是没给它赋值是不会相等的
+    const isNotFirstInit =
+      (await AsyncStorage.getItem(APP_FIRST_INIT_ADJUST_KEY)) === 'true';
+    // TODO 可删除
+    console.log(
+      'deeplinkdeeplink------->>>>>handlePasteboardInfo---isNotFirstInit',
+      await AsyncStorage.getItem(APP_FIRST_INIT_ADJUST_KEY),
+      isNotFirstInit
+    );
+    if (isNotFirstInit) {
+      return;
+    }
+    // 剪切板内容
+    let pasteboardValue = await Clipboard.getString();
+    // TODO 可删除
+    console.log(
+      'deeplinkdeeplink------->>>>>handlePasteboardInfo---pasteboardValue',
+      pasteboardValue
+    );
+    if (
+      pasteboardValue &&
+      pasteboardValue.includes(systemConfig.adjustConfig.completePrefixUrl)
+    ) {
+      global.wakeUpDeepLinkType = 'clipboard';
+    }
+    if (
+      !pasteboardValue ||
+      !pasteboardValue.includes(systemConfig.adjustConfig.completePrefixUrl)
+    ) {
+      // 走设备是否匹配 请求接口返回信息
+      pasteboardValue = await getUrlFromDevice();
+      if (pasteboardValue) {
+        global.wakeUpDeepLinkType = 'ip';
+      }
+    }
+    if (pasteboardValue) {
+      processDeepLink({ deeplink: pasteboardValue, isAJ: !isNotFirstInit });
+    }
+
+    await AsyncStorage.setItem(APP_FIRST_INIT_ADJUST_KEY, 'true');
+  };
+
+  useEffect(() => {
+    // TODO 可删除
+    console.log(
+      'deeplinkdeeplink------->>>>>isAllowAttAccess',
+      isAllowAttAccess
+    );
+    if (!isAllowAttAccess) {
+      return;
+    }
+    // TODO 可删除
+    console.log(
+      'isAllowAttAccessisAllowAttAccess111---->>>.',
+      isAllowAttAccess
+    );
+    // 记录下af初始化加载时的时间
+    global.AF_START_LOAD_TIME = new Date().getTime();
+    appsFlyer.onDeepLink((res) => {
+      // TODO 可删除
+      console.log('deeplinkdeeplink------->>>>>deepLinkStatus', res);
+      // 若是对应这个状态直接走兜底逻辑
+      if (res?.deepLinkStatus === 'NOT_FOUND') {
+        handlePasteboardInfo();
+        return;
+      }
+      const linkValue = decodeURIComponent(res?.data?.deep_link_value);
+      // 若是值不存在走兜底逻辑
+      if (!linkValue || linkValue === 'undefined') {
+        handlePasteboardInfo();
+        return;
+      }
+      global.wakeUpDeepLinkType = 'af';
+      processDeepLink({
+        deeplink: `${systemConfig.adjustConfig.ONELINK_NO_HTTP_VALUE}?${linkValue}`,
+        isAJ: res?.isDeferred,
+      });
+      AsyncStorage.setItem(APP_FIRST_INIT_ADJUST_KEY, 'true');
+    });
+    // TODO 可删除
+    console.log('appsFlyerappsFlyer---->>>', appsFlyer);
+    appsFlyer.initSdk(
+      {
+        devKey: systemConfig.adjustConfig.devKey,
+        isDebug: __DEV__,
+        appId: systemConfig.adjustConfig.appId,
+        onInstallConversionDataListener: true,
+        onDeepLinkListener: true,
+        //for iOS 14.5
+        timeToWaitForATTUserAuthorization: 10,
+      },
+      (result) => {
+        console.log(result, 'isAllowAttAccessisAllowAttAccessresult');
+      },
+      (error) => {
+        console.error(error, 'isAllowAttAccessisAllowAttAccesserror');
+      }
+    );
+    // 或者9秒之后设置为true
+    setTimeout(
+      () => {
+        AsyncStorage.setItem(APP_FIRST_INIT_ADJUST_KEY, 'true');
+      },
+      Number(systemConfig.adjustConfig.ADJUST_MAX_DELAY_TIME) + 1000
+    );
+    // 监听 已经启动，但是被h5换起来了会触发这个方法
+    Linking.addEventListener('url', ({ url }) => {
+      processDeepLink({ deeplink: url });
+    });
+    Linking.getInitialURL().then((url) => {
+      // 冷启动的时候，会触发这个
+      if (url) {
+        processDeepLink({ deeplink: url });
+      }
+    });
+  }, [
+    setSchemeDeepLinkParamsAtom,
+    setIsFirstInitAfSuccessAtom,
+    isAllowAttAccess,
+  ]);
+
+  useEffect(() => {
+    if (!isConnected) {
+      return;
+    }
+    const timeout = setTimeout(async () => {
+      if ((await AsyncStorage.getItem(APP_FIRST_INIT_ADJUST_KEY)) !== 'true') {
+        await handlePasteboardInfo();
+      }
+      setIsFirstInitAfSuccessAtom(true);
+    }, Number(systemConfig.adjustConfig.ADJUST_MAX_DELAY_TIME));
+    return () => {
+      clearTimeout(timeout);
+    };
+  }, [isConnected]);
+};
+export default useInitAfInfo;

package/src/package/request/constants.ts

@@ -0,0 +1,12 @@
+export const REQUEST_METHODS = {
+  GET: 'GET',
+  POST: 'POST',
+  PUT: 'PUT',
+  DELETE: 'DELETE',
+};
+
+export const CONTENT_TYPE = {
+  JSON: 'application/json;charset=UTF-8',
+  FORM_URLENCODED: 'application/x-www-form-urlencoded;charset=UTF-8',
+  FORM_DATA: 'multipart/form-data;charset=UTF-8',
+};

package/src/package/request/index.ts

@@ -0,0 +1,99 @@
+import { Platform } from 'react-native';
+
+import axios, {
+  AxiosInstance,
+  AxiosRequestConfig,
+  AxiosResponse,
+  InternalAxiosRequestConfig,
+} from 'axios';
+
+import { CONTENT_TYPE } from './constants';
+import { CustomRequestConfig } from './type';
+import { getConfig } from '../../config';
+
+
+const createAxiosInstance = (): AxiosInstance => {
+  const systemConfig = getConfig();
+  const instance = axios.create({
+    baseURL: systemConfig.header.apiUrl,
+    timeout: 10000,
+    headers: {
+      'Content-Type': CONTENT_TYPE.JSON,
+    },
+  }) as AxiosInstance;
+
+  instance.interceptors.request.use(
+    (config: InternalAxiosRequestConfig<CustomRequestConfig>) => {
+      const mergedConfig = { ...config };
+      mergedConfig.headers = mergedConfig.headers || {};
+
+      if (global.userToken) {
+        mergedConfig.headers.Authorization = global.userToken;
+      }
+
+      mergedConfig.headers.TYPE = Platform.OS;
+      mergedConfig.headers.NID = systemConfig.header.appId;
+      mergedConfig.headers.PACKAGENAME = systemConfig.header.PACKAGENAME;
+
+      if (!global.userToken && global.userId) {
+        mergedConfig.headers.UID = global.userId;
+      }
+
+      return mergedConfig;
+    }
+  );
+
+  instance.interceptors.response.use(
+    (response: AxiosResponse<any>) => {
+      if (response.data.code === 200) {
+        return response.data;
+      }
+
+      // FIXME: Fix me the types
+      return response.data as Promise<AxiosResponse<any>>;
+    },
+    (error) => {
+      if (error.response) {
+        return Promise.reject(
+          error.response.data || { message: 'Unknown server error' }
+        );
+      } else if (error.request) {
+        return Promise.reject({ message: 'No response received from server' });
+      } else {
+        return Promise.reject({
+          message: error.message || 'Unknown error occurred',
+        });
+      }
+    }
+  );
+
+  return instance;
+};
+
+const axiosInstance = createAxiosInstance();
+
+export const axiosGet = <T = any>(
+  url: string,
+  params?: unknown,
+  config?: AxiosRequestConfig
+) => {
+  return axiosInstance.get<T>(url, { params, ...config });
+};
+
+export const axiosPost = <T = any>(
+  url: string,
+  data?: unknown,
+  config?: AxiosRequestConfig
+) => {
+  return axiosInstance.post<T>(url, data, config);
+};
+
+export const axiosPostFormData = <T = any>(
+  url: string,
+  data?: unknown | FormData,
+  config?: AxiosRequestConfig
+) => {
+  return axiosInstance.post<T>(url, data, config);
+};
+
+export default axiosInstance;

package/src/package/request/type.ts

@@ -0,0 +1,24 @@
+import { type AxiosRequestConfig } from 'axios';
+
+export type ApiResponse<T = unknown> = {
+  code: number;
+  data: T;
+  message: string;
+  msg: string;
+};
+
+export type ApiError = Error & {
+  code?: number;
+  config: AxiosRequestConfig;
+  isAxiosError: boolean;
+};
+
+export type CustomRequestConfig = AxiosRequestConfig & {
+  headers: {
+    TYPE?: string;
+    NID?: number;
+    PACKAGENAME?: string;
+    UID?: string;
+    Authorization?: string;
+  };
+};

package/src/package/screens/home/index.tsx

@@ -0,0 +1,100 @@
+import React, { PropsWithChildren, useEffect, useMemo, useRef } from 'react';
+import { Platform, View } from 'react-native';
+import { createJsbridge } from '@tianzhitong/js-bridge';
+import WebView from '../../components/webview';
+import useGetUserToken from '../../hooks/useGetUserToken';
+import { useAtom, useAtomValue } from 'jotai';
+import {
+  bPackageWebviewLoadingFinishAtom,
+  MiddleScreenLoadingFinishAtom,
+  schemeDeepLinkParamsAtom,
+} from '../../atoms/global';
+import MiddleScreen from '../middle';
+import useAppGetUID from '../../hooks/useAppGetUID';
+import useInitAfInfo from '../../hooks/useInitAfInfo';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { getConfig } from '../../../config';
+
+
+const Home = () => {
+  const safeAreaInsets = useSafeAreaInsets();
+  const systemConfig = getConfig();
+  const { top, bottom } = safeAreaInsets;
+  const webRef = useRef<any>(null);
+  const middleScreenLoadingFinish = useAtomValue(MiddleScreenLoadingFinishAtom);
+  const [bPackageWebviewLoadingFinish, setBPackageWebviewLoadingFinish] =
+    useAtom(bPackageWebviewLoadingFinishAtom);
+
+  const schemeDeepLinkParams = useAtomValue(schemeDeepLinkParamsAtom);
+
+  const jsbridge = useMemo(() => {
+    return createJsbridge({ getWebViewRef: () => webRef });
+  }, []);
+
+  useEffect(() => {
+    if (!(bPackageWebviewLoadingFinish && middleScreenLoadingFinish)) {
+      return;
+    }
+    if (schemeDeepLinkParams.pageName) {
+      jsbridge.postMessage({
+        type: 'SEND_H5_PARAMS',
+        payload: schemeDeepLinkParams,
+      });
+    }
+  }, [schemeDeepLinkParams, bPackageWebviewLoadingFinish,middleScreenLoadingFinish, jsbridge]);
+
+  useGetUserToken(jsbridge);
+
+  return (
+    <View
+      style={{
+        flex: 1,
+        opacity:
+          bPackageWebviewLoadingFinish && middleScreenLoadingFinish ? 1 : 0,
+      }}
+    >
+      <WebView
+        ref={webRef}
+        source={{
+          uri: `${systemConfig.webviewUrl}?platform=${Platform.OS
+            }&app_version=${'1.1.1'}&user_id=${global.GLOBAL_USER_UID
+            }&top=${top}&bottom=${bottom}`,
+        }}
+        onInvokeMessage={() => { }}
+        onLoadEnd={() => {
+          console.log('onLoadEnd');
+          setBPackageWebviewLoadingFinish(true);
+        }}
+      />
+    </View>
+  );
+};
+
+
+const ProviderBPackageIndex = (props: PropsWithChildren)  => {
+  const {
+    children,
+  } = props;
+  const { isLoading,isAPackage, } = useAppGetUID();
+  const middleScreenLoadingFinish = useAtomValue(MiddleScreenLoadingFinishAtom);
+  const schemeDeepLinkParams = useAtomValue(schemeDeepLinkParamsAtom);
+  console.log('schemeDeepLinkParams',schemeDeepLinkParams)
+  useInitAfInfo();
+
+  if (!isLoading) {
+    return null;
+  }
+  console.log('isAPackage',isAPackage)
+  if (isAPackage) {
+    return children;
+  }
+  console.log('middleScreenLoadingFinish',middleScreenLoadingFinish)
+  return (
+    <View style={{ flex: 1 }}>
+      {!middleScreenLoadingFinish && <MiddleScreen />}
+      <Home  />
+    </View>
+  );
+};
+
+export default ProviderBPackageIndex;

package/src/package/screens/middle/components/CustomProgressBar.tsx

@@ -0,0 +1,152 @@
+import React, { useState, useEffect, useRef, useImperativeHandle, forwardRef } from 'react';
+import { View, Text, StyleSheet, Animated, Easing } from 'react-native';
+import { rwd } from '../../../utils/rwd';
+
+const CustomProgressBar = forwardRef<any, any>(
+    (
+        {
+            duration = 5000,
+            height = rwd(10),
+            backgroundColor = '#e0e0e0',
+            fillColor = '#4CAF50',
+            showPercentage = true,
+            borderRadius = 10,
+            textStyle = {},
+            containerStyle = {},
+            onComplete = () => {},
+        },
+        ref,
+    ) => {
+        const progress = useState(new Animated.Value(0))[0];
+        const [currentProgress, setCurrentProgress] = useState(0);
+        const animationRef = useRef<Animated.CompositeAnimation | null>(null);
+
+        let listenerId = useRef<string>('');
+
+        const animateTo = (value: number, callback?: () => void) => {
+            // Stop any ongoing animation
+            if (animationRef.current) {
+                animationRef.current.stop();
+            }
+
+            // Calculate remaining duration proportionally
+            const remainingDuration = duration * ((100 - currentProgress) / 100);
+
+            animationRef.current = Animated.timing(progress, {
+                toValue: value,
+                duration: remainingDuration,
+                easing: Easing.linear,
+                useNativeDriver: false,
+            });
+
+            animationRef.current.start(() => {
+                if (value === 100 && callback) {
+                    callback();
+                }
+            });
+        };
+
+        useEffect(() => {
+            // Add listener to animation value
+            listenerId.current = progress.addListener(({ value }) => {
+                setCurrentProgress(Math.floor(value));
+            });
+
+            // Start initial animation
+            animateTo(100, onComplete);
+
+            // Clean up listener
+            return () => {
+                progress.removeListener(listenerId.current);
+                if (animationRef.current) {
+                    animationRef.current.stop();
+                }
+            };
+        }, [duration]);
+
+        useImperativeHandle(
+            ref,
+            () => ({
+                completeProgress: () => {
+                    // Stop current animation and jump to 100%
+                    if (animationRef.current) {
+                        animationRef.current.stop();
+                    }
+                    progress.setValue(100);
+                    setCurrentProgress(100);
+                    onComplete();
+                },
+                setProgress: (value: number) => {
+                    // Set to specific value (0-100)
+                    const clampedValue = Math.min(100, Math.max(0, value));
+                    if (animationRef.current) {
+                        animationRef.current.stop();
+                    }
+                    progress.setValue(clampedValue);
+                    setCurrentProgress(clampedValue);
+                    if (clampedValue === 100) {
+                        onComplete();
+                    }
+                },
+                startAnimation: () => {
+                    // Restart animation from current position
+                    animateTo(100, onComplete);
+                },
+            }),
+            [progress, currentProgress, onComplete],
+        );
+
+        const widthInterpolation = progress.interpolate({
+            inputRange: [0, 100],
+            outputRange: ['0%', '100%'],
+        });
+
+        return (
+            <View style={[styles.container, containerStyle]}>
+                <View
+                    style={[
+                        styles.progressBar,
+                        {
+                            height,
+                            backgroundColor,
+                            borderRadius,
+                        },
+                    ]}
+                >
+                    <Animated.View
+                        style={[
+                            styles.progressFill,
+                            {
+                                width: widthInterpolation,
+                                backgroundColor: fillColor,
+                                borderRadius,
+                            },
+                        ]}
+                    />
+                </View>
+
+                {showPercentage && <Text style={[styles.progressText, textStyle]}>{currentProgress}%</Text>}
+            </View>
+        );
+    },
+);
+
+const styles = StyleSheet.create({
+    container: {
+        width: '100%',
+        padding: rwd(20),
+    },
+    progressBar: {
+        overflow: 'hidden',
+    },
+    progressFill: {
+        height: '100%',
+    },
+    progressText: {
+        marginTop: rwd(8),
+        textAlign: 'center',
+        fontSize: rwd(16),
+    },
+});
+
+export default CustomProgressBar;

package/src/package/screens/middle/index.tsx

@@ -0,0 +1,94 @@
+import { useAtomValue, useSetAtom } from 'jotai';
+import { useEffect, useRef, useState } from 'react';
+import { Image, StatusBar, Text, View } from 'react-native';
+import CustomProgressBar from './components/CustomProgressBar';
+import {
+  bPackageWebviewLoadingFinishAtom,
+  isFirstInitAfSuccessAtom,
+  MiddleScreenLoadingFinishAtom,
+  schemeDeepLinkParamsAtom,
+} from '../../atoms/global';
+import { rwd } from '../../utils/rwd';
+import { getConfig } from '../../../config';
+
+
+const MiddleScreen = () => {
+  const systemConfig = getConfig();
+  const progressRef = useRef<any>(null);
+  /** 深度链接是否成功 */
+  const isFirstInitAfSuccess = useAtomValue(isFirstInitAfSuccessAtom);
+  /** b包webview是否加载完成 */
+  const bPackageWebviewLoadingFinish = useAtomValue(
+    bPackageWebviewLoadingFinishAtom
+  );
+  /** 100%动画是否执行完毕 */
+  const setIsAnimationSuccess = useSetAtom(MiddleScreenLoadingFinishAtom);
+
+  const [isLoading, setIsLoading] = useState(false);
+
+  useEffect(() => {
+    // 深度链接成功，等于成功一半，无需走进度条
+    if (isFirstInitAfSuccess) {
+      setIsLoading(true);
+    }
+  }, [isFirstInitAfSuccess]);
+
+  useEffect(() => {
+    if (bPackageWebviewLoadingFinish && isLoading) {
+      progressRef.current?.completeProgress();
+      setIsAnimationSuccess(true);
+    }
+  }, [isLoading, bPackageWebviewLoadingFinish, setIsAnimationSuccess]);
+
+  return (
+    <View style={{ width: '100%', height: '100%' }}>
+      <StatusBar
+        translucent={true}
+        barStyle="light-content"
+        backgroundColor="transparent"
+      />
+      <View style={{ flex: 1, backgroundColor: '#12141D', paddingTop: '50%' }}>
+        <View style={{ justifyContent: 'center', alignItems: 'center' }}>
+          <Image
+            source={{ uri: systemConfig.adjustConfig.bgImage }}
+            style={{ width: rwd(170), height: rwd(170) }}
+          />
+          <Text
+            style={{
+              color: '#fff',
+              fontSize: rwd(34),
+              fontWeight: 600,
+              marginTop: rwd(50),
+            }}
+          >
+            {systemConfig.adjustConfig.appName}
+          </Text>
+        </View>
+        <View style={{ position: 'absolute', bottom: '20%', width: '100%' }}>
+          <CustomProgressBar
+            ref={progressRef}
+            duration={8000}
+            fillColor="#3498db" // 蓝色进度条
+            textStyle={{ color: '#3498db', fontWeight: 'bold' }} // 蓝色文字
+            onComplete={() => {
+              setIsLoading(true);
+              console.log('进度完成!');
+            }}
+          />
+          <Text
+            style={{
+              color: '#fff',
+              fontSize: rwd(24),
+              fontWeight: 600,
+              marginTop: rwd(30),
+              textAlign: 'center',
+            }}
+          >
+            {systemConfig.adjustConfig.loadingText}
+          </Text>
+        </View>
+      </View>
+    </View>
+  );
+};
+export default MiddleScreen;

package/src/package/utils/extractQueryParams.ts

@@ -0,0 +1,10 @@
+export const extractQueryParams = (url: string) => {
+  // 尝试用正则回退
+  const regex = /[?&]([^=#]+)=([^&#]*)/g;
+  const params: Record<string, string> = {};
+  let match;
+  while ((match = regex.exec(url))) {
+    params[match[1]] = decodeURIComponent(match[2]);
+  }
+  return params;
+};

package/src/package/utils/getUrlFromDevice.ts

@@ -0,0 +1,32 @@
+import { axiosGet } from '../request';
+import { Dimensions, Platform } from 'react-native';
+
+/** 获取系统时区 */
+const obtainDeviceTimeZone = () => {
+  const timeZone = Intl?.DateTimeFormat?.().resolvedOptions()?.timeZone;
+  return timeZone || 'UTC';
+};
+
+export const getUrlFromDevice = async () => {
+  try {
+    const platformOS = Platform.OS;
+    const width = Dimensions.get('screen').width;
+    const height = Dimensions.get('screen').height;
+    const systemTimeZone = obtainDeviceTimeZone();
+    const ipData = await axiosGet('/get_ip_info/');
+    let params = {
+      platform: platformOS,
+      screenWidth: `${Math.ceil(width)}`,
+      screenHeight: `${Math.ceil(height)}`,
+      systemTimeZone,
+      ip: ipData.data?.ip || '',
+      nid: global.GLOBAL_UID ? `${global.GLOBAL_UID}` : undefined,
+    };
+    const data = await axiosGet('/match_device_info/', { ...params });
+    // TODO 可删除
+    console.log('匹配的设备信息---->', data);
+    return data.data?.linkUrl;
+  } catch (error) {
+    return undefined;
+  }
+};

package/src/package/utils/optionalDependencies.ts

@@ -0,0 +1,84 @@
+/**
+ * 可选依赖管理器
+ * 用于处理可能未安装的第三方依赖
+ */
+
+type OptionalModule = {
+  module: any;
+  isAvailable: boolean;
+  error?: Error;
+};
+
+class OptionalDependencyManager {
+  private cache: Map<string, OptionalModule> = new Map();
+
+  /**
+   * 安全地加载可选模块
+   */
+  load(moduleName: string): OptionalModule {
+    // 检查缓存
+    if (this.cache.has(moduleName)) {
+      return this.cache.get(moduleName)!;
+    }
+
+    let result: OptionalModule;
+
+    try {
+      const module = require(moduleName);
+      result = {
+        module,
+        isAvailable: true,
+      };
+    } catch (error) {
+      result = {
+        module: null,
+        isAvailable: false,
+        error: error as Error,
+      };
+    }
+
+    this.cache.set(moduleName, result);
+    return result;
+  }
+
+  /**
+   * 获取模块，如果不可用则抛出友好的错误
+   */
+  getRequired(moduleName: string, featureName: string): any {
+    const { module, isAvailable } = this.load(moduleName);
+
+    if (!isAvailable) {
+      throw new Error(
+        `${featureName} 功能需要安装 ${moduleName}。\n` +
+          `请运行: yarn add ${moduleName}`
+      );
+    }
+
+    return module;
+  }
+
+  /**
+   * 检查多个依赖是否都可用
+   */
+  checkDependencies(dependencies: string[]): boolean {
+    return dependencies.every((dep) => this.load(dep).isAvailable);
+  }
+}
+
+export const optionalDeps = new OptionalDependencyManager();
+
+// 导出常用的可选依赖
+export const getGoogleSignIn = () => {
+  const { GoogleSignin } = optionalDeps.getRequired(
+    '@react-native-google-signin/google-signin',
+    'Google 登录'
+  );
+  return GoogleSignin;
+};
+
+export const getFirebaseAuth = () => {
+  return optionalDeps.getRequired(
+    '@react-native-firebase/auth',
+    'Firebase 认证'
+  );
+};

package/src/package/utils/rwd.ts

@@ -0,0 +1,18 @@
+import { Dimensions, StyleSheet } from 'react-native';
+
+export const rwd = function rwd(width: number) {
+    if (width === 0) {
+        return 0;
+    }
+    let hairlineWidth = StyleSheet.hairlineWidth;
+    if (Math.abs(width) === 1) {
+        return hairlineWidth * (width > 0 ? 1 : -1);
+    }
+    const deviceWidth = Dimensions.get('window').width;
+    const wPixelScale = deviceWidth / 750;
+    let actualWidth = wPixelScale * width;
+    if (Math.abs(actualWidth) <= hairlineWidth) {
+        return hairlineWidth * (width > 0 ? 1 : -1);
+    }
+    return Math.floor(actualWidth);
+};

package/src/types/global.d.ts

@@ -0,0 +1,6 @@
+declare global {
+  var GLOBAL_USER_TOKEN: string | undefined;
+  var GLOBAL_USER_UID: number | undefined;
+}
+
+export {};

package/src/types/optional-modules.d.ts

@@ -0,0 +1,9 @@
+// 声明可选模块，避免 TypeScript 编译错误
+declare module '@react-native-google-signin/google-signin' {
+  export const GoogleSignin: any;
+}
+
+declare module '@react-native-firebase/auth' {
+  const auth: any;
+  export default auth;
+}