@appmetrica/react-native-analytics/lib/module/index.js

React Native plugin for AppMetrica analytics tool

import { Linking, NativeModules, Platform } from 'react-native';
import { normalizeAdRevenue } from './utils';
import { AppMetricaError } from './error';
import { Reporter } from './reporter';
const LINKING_ERROR = `The package '@appmetrica/react-native-analytics' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
  ios: "- You have run 'pod install'\n",
  default: ''
}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
const AppMetricaNative = NativeModules.AppMetrica ? NativeModules.AppMetrica : new Proxy({}, {
  get() {
    throw new Error(LINKING_ERROR);
  }
});
var activated = false;
function appOpenTracking() {
  const getUrlAsync = async () => {
    const initialUrl = await Linking.getInitialURL();
    if (initialUrl != null) {
      AppMetricaNative.reportAppOpen(initialUrl);
    }
  };
  const callback = event => {
    AppMetricaNative.reportAppOpen(event.url);
  };
  getUrlAsync();
  Linking.addEventListener('url', callback);
}
export const DEVICE_ID_HASH_KEY = 'appmetrica_device_id_hash';
export const DEVICE_ID_KEY = 'appmetrica_device_id';
export const UUID_KEY = 'appmetrica_uuid';
export * from './ecommerce';
export * from './revenue';
export * from './userProfile';
export * from './externalAttribution';
export * from './deferredDeeplink';
export default class AppMetrica {
  static reporters = new Map();
  static activate(config) {
    if (!activated) {
      AppMetricaNative.activate(config);
      if (config.appOpenTrackingEnabled !== false) {
        appOpenTracking();
      }
      activated = true;
    }
  }

  // Android only
  static async getLibraryApiLevel() {
    return AppMetricaNative.getLibraryApiLevel();
  }
  static async getLibraryVersion() {
    return AppMetricaNative.getLibraryVersion();
  }
  static pauseSession() {
    AppMetricaNative.pauseSession();
  }
  static reportAppOpen(deeplink) {
    AppMetricaNative.reportAppOpen(deeplink);
  }
  static reportError(identifier, message, _reason) {
    AppMetricaNative.reportError(identifier, message, _reason instanceof Error ? AppMetricaError.withError(_reason) : AppMetricaError.withObject(_reason));
  }
  static reportUnhandledException(error) {
    AppMetricaNative.reportUnhandledException(AppMetricaError.withError(error));
  }
  static reportErrorWithoutIdentifier(message, error) {
    AppMetricaNative.reportErrorWithoutIdentifier(message, AppMetricaError.withError(error));
  }
  static reportEvent(eventName, attributes) {
    AppMetricaNative.reportEvent(eventName, attributes);
  }
  static requestStartupParams(listener, identifiers) {
    AppMetricaNative.requestStartupParams(identifiers, listener);
  }
  static resumeSession() {
    AppMetricaNative.resumeSession();
  }
  static sendEventsBuffer() {
    AppMetricaNative.sendEventsBuffer();
  }
  static setLocation(location) {
    AppMetricaNative.setLocation(location);
  }
  static setLocationTracking(enabled) {
    AppMetricaNative.setLocationTracking(enabled);
  }
  static setDataSendingEnabled(enabled) {
    AppMetricaNative.setDataSendingEnabled(enabled);
  }
  static setUserProfileID(userProfileID) {
    AppMetricaNative.setUserProfileID(userProfileID);
  }
  static reportECommerce(event) {
    AppMetricaNative.reportECommerce(event);
  }
  static reportRevenue(revenue) {
    AppMetricaNative.reportRevenue(revenue);
  }
  static reportAdRevenue(adRevenue) {
    AppMetricaNative.reportAdRevenue(normalizeAdRevenue(adRevenue));
  }
  static reportUserProfile(userProfile) {
    AppMetricaNative.reportUserProfile(userProfile);
  }
  static putErrorEnvironmentValue(key, value) {
    AppMetricaNative.putErrorEnvironmentValue(key, value);
  }
  static reportExternalAttribution(attribution) {
    AppMetricaNative.reportExternalAttribution(attribution);
  }
  static putAppEnvironmentValue(key, value) {
    AppMetricaNative.putAppEnvironmentValue(key, value);
  }
  static clearAppEnvironment() {
    AppMetricaNative.clearAppEnvironment();
  }
  static getReporter(apiKey) {
    if (AppMetrica.reporters.has(apiKey)) {
      return AppMetrica.reporters.get(apiKey);
    } else {
      AppMetricaNative.touchReporter(apiKey);
      const reporter = new Reporter(apiKey);
      AppMetrica.reporters.set(apiKey, reporter);
      return reporter;
    }
  }
  static activateReporter(config) {
    AppMetricaNative.activateReporter(config);
  }
  static getDeviceId() {
    return AppMetricaNative.getDeviceId();
  }
  static getUuid() {
    return AppMetricaNative.getUuid();
  }
  static requestDeferredDeeplink(listener) {
    AppMetricaNative.requestDeferredDeeplink(listener.onFailure, listener.onSuccess);
  }
  static requestDeferredDeeplinkParameters(listener) {
    AppMetricaNative.requestDeferredDeeplinkParameters(listener.onFailure, listener.onSuccess);
  }
}
//# sourceMappingURL=index.js.map