capacitor-firebase-kit
Version:
Provider-less Firebase Kit - Universal Firebase services integration for React, React Native, and Capacitor apps
261 lines • 11.7 kB
JavaScript
import { PlatformAdapter } from '../core/platform-adapter';
export class ReactNativeAdapter extends PlatformAdapter {
async initialize(config) {
this.validateConfig(config);
this.config = config;
// React Native Firebase auto-initializes from native config files
console.warn('React Native Firebase initialized with native config');
}
async getService(serviceName) {
if (!this.isSupported(serviceName)) {
throw new Error(`Service ${serviceName} is not supported on React Native platform`);
}
if (this.serviceCache.has(serviceName)) {
return this.serviceCache.get(serviceName);
}
const service = await this.loadServiceModule(serviceName);
this.serviceCache.set(serviceName, service);
return service;
}
async loadServiceModule(serviceName) {
switch (serviceName) {
case 'analytics':
return this.loadAnalytics();
case 'appCheck':
return this.loadAppCheck();
case 'crashlytics':
return this.loadCrashlytics();
case 'performance':
return this.loadPerformance();
case 'remoteConfig':
return this.loadRemoteConfig();
case 'adMob':
return this.loadAdMob();
default:
throw new Error(`Unknown service: ${serviceName}`);
}
}
async loadAnalytics() {
try {
const analytics = await import('@react-native-firebase/analytics');
const analyticsInstance = analytics.default();
return {
logEvent: (eventName, eventParams) => analyticsInstance.logEvent(eventName, eventParams),
setUserId: (userId) => analyticsInstance.setUserId(userId),
setUserProperties: (properties) => analyticsInstance.setUserProperties(properties),
setCurrentScreen: (screenName, screenClassOverride) => analyticsInstance.logScreenView({
screen_name: screenName,
screen_class: screenClassOverride,
}),
setEnabled: (enabled) => analyticsInstance.setAnalyticsCollectionEnabled(enabled),
isSupported: async () => ({ isSupported: true }),
};
}
catch (_a) {
throw new Error('@react-native-firebase/analytics not installed. Run: npm install @react-native-firebase/analytics');
}
}
async loadAppCheck() {
try {
const appCheck = await import('@react-native-firebase/app-check');
const appCheckInstance = appCheck.default();
return {
initialize: async (options) => {
var _a;
if (options.provider === 'debug') {
await appCheckInstance.newReactNativeFirebaseAppCheckProvider();
}
await appCheckInstance.initializeAppCheck({
provider: appCheckInstance.newReactNativeFirebaseAppCheckProvider(),
isTokenAutoRefreshEnabled: (_a = options.isTokenAutoRefreshEnabled) !== null && _a !== void 0 ? _a : true,
});
},
getToken: async (forceRefresh) => {
const result = await appCheckInstance.getToken(forceRefresh);
return { token: result.token };
},
setTokenAutoRefreshEnabled: async (_enabled) => {
console.warn('setTokenAutoRefreshEnabled must be set during initialization');
},
};
}
catch (_a) {
throw new Error('@react-native-firebase/app-check not installed. Run: npm install @react-native-firebase/app-check');
}
}
async loadCrashlytics() {
try {
const crashlytics = await import('@react-native-firebase/crashlytics');
const crashlyticsInstance = crashlytics.default();
return {
crash: () => crashlyticsInstance.crash(),
setUserId: (userId) => crashlyticsInstance.setUserId(userId),
log: (message) => crashlyticsInstance.log(message),
setEnabled: (enabled) => crashlyticsInstance.setCrashlyticsCollectionEnabled(enabled),
isEnabled: async () => ({
isEnabled: await crashlyticsInstance.isCrashlyticsCollectionEnabled(),
}),
recordException: (error) => crashlyticsInstance.recordError(error),
setCustomKey: (key, value) => crashlyticsInstance.setAttribute(key, String(value)),
setCustomKeys: (customKeys) => crashlyticsInstance.setAttributes(customKeys),
};
}
catch (_a) {
throw new Error('@react-native-firebase/crashlytics not installed. Run: npm install @react-native-firebase/crashlytics');
}
}
async loadPerformance() {
try {
const perf = await import('@react-native-firebase/perf');
const perfInstance = perf.default();
const traces = new Map();
return {
startTrace: async (traceName) => {
const trace = await perfInstance.startTrace(traceName);
traces.set(traceName, trace);
return { traceName, traceId: traceName };
},
stopTrace: async (traceName) => {
const trace = traces.get(traceName);
if (trace) {
await trace.stop();
traces.delete(traceName);
}
},
incrementMetric: async (traceName, metricName, value) => {
const trace = traces.get(traceName);
if (trace) {
trace.incrementMetric(metricName, value);
}
},
setEnabled: (enabled) => perfInstance.setPerformanceCollectionEnabled(enabled),
isEnabled: async () => ({
isEnabled: await perfInstance.isPerformanceCollectionEnabled(),
}),
};
}
catch (_a) {
throw new Error('@react-native-firebase/perf not installed. Run: npm install @react-native-firebase/perf');
}
}
async loadRemoteConfig() {
try {
const remoteConfig = await import('@react-native-firebase/remote-config');
const remoteConfigInstance = remoteConfig.default();
return {
initialize: async (options) => {
var _a;
await remoteConfigInstance.setConfigSettings({
minimumFetchIntervalMillis: (_a = options.minimumFetchIntervalMillis) !== null && _a !== void 0 ? _a : 43200000,
});
if (options.defaultConfig) {
await remoteConfigInstance.setDefaults(options.defaultConfig);
}
},
fetchAndActivate: async () => {
const activated = await remoteConfigInstance.fetchAndActivate();
return { activated };
},
fetchConfig: async () => {
await remoteConfigInstance.fetch();
},
activate: async () => {
const activated = await remoteConfigInstance.activate();
return { activated };
},
getValue: async (key) => {
const value = remoteConfigInstance.getValue(key);
return {
value: value.asString(),
source: value.getSource(),
};
},
getString: async (key) => {
const value = remoteConfigInstance.getString(key);
return { value };
},
getNumber: async (key) => {
const value = remoteConfigInstance.getNumber(key);
return { value };
},
getBoolean: async (key) => {
const value = remoteConfigInstance.getBoolean(key);
return { value };
},
setLogLevel: async (_logLevel) => {
console.warn('setLogLevel not supported in React Native');
},
};
}
catch (_a) {
throw new Error('@react-native-firebase/remote-config not installed. Run: npm install @react-native-firebase/remote-config');
}
}
async loadAdMob() {
try {
const admob = await import('react-native-google-mobile-ads');
return {
initialize: async (options) => {
await admob.default().initialize();
if (options === null || options === void 0 ? void 0 : options.testMode) {
// Set test device IDs if needed
}
},
showBanner: async (_options) => {
console.warn('Use BannerAd component from react-native-google-mobile-ads');
},
hideBanner: async () => {
console.warn('Control banner visibility through component state');
},
resumeBanner: async () => {
console.warn('Control banner visibility through component state');
},
removeBanner: async () => {
console.warn('Remove BannerAd component from render');
},
prepareInterstitial: async (options) => {
const { InterstitialAd, TestIds } = admob;
const adUnitId = options.testing ? TestIds.INTERSTITIAL : options.adId;
const interstitial = InterstitialAd.createForAdRequest(adUnitId);
return { interstitial };
},
showInterstitial: async () => {
console.warn('Use interstitial.show() from prepareInterstitial result');
},
prepareRewardVideoAd: async (options) => {
const { RewardedAd, TestIds } = admob;
const adUnitId = options.testing ? TestIds.REWARDED : options.adId;
const rewarded = RewardedAd.createForAdRequest(adUnitId);
return { rewarded };
},
showRewardVideoAd: async () => {
console.warn('Use rewarded.show() from prepareRewardVideoAd result');
},
setApplicationMuted: async (muted) => {
await admob.default().setAppMuted(muted);
},
setApplicationVolume: async (volume) => {
await admob.default().setAppVolume(volume);
},
};
}
catch (_a) {
throw new Error('react-native-google-mobile-ads not installed. Run: npm install react-native-google-mobile-ads');
}
}
isSupported(serviceName) {
const supportedServices = [
'analytics',
'appCheck',
'crashlytics',
'performance',
'remoteConfig',
'adMob',
];
return supportedServices.includes(serviceName);
}
async cleanup() {
this.serviceCache.clear();
}
}
//# sourceMappingURL=react-native-adapter.js.map