@appmetrica/react-native-analytics 3.0.0

package/android/src/main/java/io/appmetrica/analytics/reactnative/Utils.java

@@ -0,0 +1,483 @@
+package io.appmetrica.analytics.reactnative;
+
+import android.location.Location;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import io.appmetrica.analytics.AdRevenue;
+import io.appmetrica.analytics.AdType;
+import io.appmetrica.analytics.AppMetricaConfig;
+import io.appmetrica.analytics.PreloadInfo;
+import io.appmetrica.analytics.Revenue;
+import io.appmetrica.analytics.StartupParamsCallback;
+import io.appmetrica.analytics.ecommerce.ECommerceAmount;
+import io.appmetrica.analytics.ecommerce.ECommerceCartItem;
+import io.appmetrica.analytics.ecommerce.ECommerceEvent;
+import io.appmetrica.analytics.ecommerce.ECommerceOrder;
+import io.appmetrica.analytics.ecommerce.ECommercePrice;
+import io.appmetrica.analytics.ecommerce.ECommerceProduct;
+import io.appmetrica.analytics.ecommerce.ECommerceReferrer;
+import io.appmetrica.analytics.ecommerce.ECommerceScreen;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Currency;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+abstract class Utils {
+
+    @NonNull
+    static AppMetricaConfig toAppMetricaConfig(@NonNull ReadableMap configMap) {
+        AppMetricaConfig.Builder builder = AppMetricaConfig.newConfigBuilder(configMap.getString("apiKey"));
+
+        if (configMap.hasKey("appVersion")) {
+            builder.withAppVersion(configMap.getString("appVersion"));
+        }
+        if (configMap.hasKey("crashReporting")) {
+            builder.withCrashReporting(configMap.getBoolean("crashReporting"));
+        }
+        if (configMap.hasKey("firstActivationAsUpdate")) {
+            builder.handleFirstActivationAsUpdate(configMap.getBoolean("firstActivationAsUpdate"));
+        }
+        if (configMap.hasKey("location")) {
+            builder.withLocation(toLocation(configMap.getMap("location")));
+        }
+        if (configMap.hasKey("locationTracking")) {
+            builder.withLocationTracking(configMap.getBoolean("locationTracking"));
+        }
+        if (configMap.hasKey("logs") && configMap.getBoolean("logs")) {
+            builder.withLogs();
+        }
+        if (configMap.hasKey("maxReportsInDatabaseCount")) {
+            builder.withMaxReportsInDatabaseCount(configMap.getInt("maxReportsInDatabaseCount"));
+        }
+        if (configMap.hasKey("nativeCrashReporting")) {
+            builder.withNativeCrashReporting(configMap.getBoolean("nativeCrashReporting"));
+        }
+        if (configMap.hasKey("preloadInfo")) {
+            builder.withPreloadInfo(toPreloadInfo(configMap.getMap("preloadInfo")));
+        }
+        if (configMap.hasKey("sessionTimeout")) {
+            builder.withSessionTimeout(configMap.getInt("sessionTimeout"));
+        }
+        if (configMap.hasKey("statisticsSending")) {
+            builder.withDataSendingEnabled(configMap.getBoolean("statisticsSending"));
+        }
+        if (configMap.hasKey("sessionsAutoTracking")) {
+            builder.withSessionsAutoTrackingEnabled(configMap.getBoolean("sessionsAutoTracking"));
+        }
+
+        return builder.build();
+    }
+
+    @Nullable
+    static Location toLocation(@Nullable ReadableMap locationMap) {
+        if (locationMap == null) {
+            return null;
+        }
+
+        Location location = new Location("Custom");
+
+        if (locationMap.hasKey("latitude")) {
+            location.setLatitude(locationMap.getDouble("latitude"));
+        }
+        if (locationMap.hasKey("longitude")) {
+            location.setLongitude(locationMap.getDouble("longitude"));
+        }
+        if (locationMap.hasKey("altitude")) {
+            location.setAltitude(locationMap.getDouble("altitude"));
+        }
+        if (locationMap.hasKey("accuracy")) {
+            location.setAccuracy((float) locationMap.getDouble("accuracy"));
+        }
+        if (locationMap.hasKey("course")) {
+            location.setBearing((float) locationMap.getDouble("course"));
+        }
+        if (locationMap.hasKey("speed")) {
+            location.setSpeed((float) locationMap.getDouble("speed"));
+        }
+        if (locationMap.hasKey("timestamp")) {
+            location.setTime((long) locationMap.getDouble("timestamp"));
+        }
+
+        return location;
+    }
+
+    @Nullable
+    private static PreloadInfo toPreloadInfo(@Nullable ReadableMap preloadInfoMap) {
+        if (preloadInfoMap == null) {
+            return null;
+        }
+
+        PreloadInfo.Builder builder = PreloadInfo.newBuilder(preloadInfoMap.getString("trackingId"));
+
+        if (preloadInfoMap.hasKey("additionalInfo")) {
+            ReadableMap additionalInfo = preloadInfoMap.getMap("additionalInfo");
+            if (additionalInfo != null) {
+                for (Map.Entry<String, Object> entry : additionalInfo.toHashMap().entrySet()) {
+                    Object value = entry.getValue();
+                    builder.setAdditionalParams(entry.getKey(), value == null ? null : value.toString());
+                }
+            }
+        }
+
+        return builder.build();
+    }
+
+    @NonNull
+    static ECommerceScreen toECommerceScreen(@NonNull ReadableMap ecommerceEventMap) {
+        ECommerceScreen screen = new ECommerceScreen();
+        if (ecommerceEventMap.hasKey("name")) {
+            screen.setName(ecommerceEventMap.getString("name"));
+        }
+        if (ecommerceEventMap.hasKey("searchQuery")) {
+            screen.setSearchQuery(ecommerceEventMap.getString("searchQuery"));
+        }
+        if (ecommerceEventMap.hasKey("payload")) {
+            ReadableMap payloadMap = ecommerceEventMap.getMap("payload");
+            screen.setPayload(toMapOfStrings(payloadMap));
+        }
+        if (ecommerceEventMap.hasKey("categoriesPath")) {
+            ReadableArray categoriesPathArray = ecommerceEventMap.getArray("categoriesPath");
+            screen.setCategoriesPath(toListOfStrings(categoriesPathArray));
+        }
+        return screen;
+    }
+
+    @Nullable
+    static ECommerceAmount toEcommerceAmount(@NonNull ReadableMap amountMap) {
+        ReadableType amountType = amountMap.getType("amount");
+        String unit = amountMap.getString("unit");
+        if (unit != null) {
+            if (amountType == ReadableType.Number) {
+                return new ECommerceAmount(amountMap.getDouble("amount"), unit);
+            } else {
+                String amountString = amountMap.getString("amount");
+                return new ECommerceAmount(new BigDecimal(amountString), unit);
+            }
+        } else {
+            Log.w(AppMetricaModule.TAG, "ECommerceAmount unit is null");
+            return null;
+        }
+    }
+
+    @Nullable
+    static ECommercePrice toECommercePrice(@Nullable ReadableMap priceMap) {
+        if (priceMap == null) {
+            return null;
+        }
+        ReadableMap amountMap = Objects.requireNonNull(priceMap.getMap("amount"));
+        ECommerceAmount amount = toEcommerceAmount(amountMap);
+        if (amount == null) {
+            return null;
+        }
+        ECommercePrice price = new ECommercePrice(amount);
+        if (priceMap.hasKey("internalComponents")) {
+            ReadableArray list = priceMap.getArray("internalComponents");
+            if (list != null) {
+                List<ECommerceAmount> newlist = new ArrayList<ECommerceAmount>(list.size());
+                for (int i = 0; i < list.size(); i++) {
+                    ECommerceAmount component = toEcommerceAmount(list.getMap(i));
+                    newlist.add(component);
+                }
+                price.setInternalComponents(newlist);
+            }
+        }
+        return price;
+    }
+
+    @NonNull
+    static ECommerceProduct toECommerceProduct(@NonNull ReadableMap productMap) {
+        ECommerceProduct product = new ECommerceProduct(Objects.requireNonNull(productMap.getString("sku")));
+
+        if (productMap.hasKey("name")) {
+            product.setName(productMap.getString("name"));
+        }
+        if (productMap.hasKey("actualPrice")) {
+            ReadableMap priceMap = productMap.getMap("actualPrice");
+            product.setActualPrice(toECommercePrice(priceMap));
+        }
+        if (productMap.hasKey("originalPrice")) {
+            ReadableMap priceMap = productMap.getMap("originalPrice");
+            product.setOriginalPrice(toECommercePrice(priceMap));
+        }
+        if (productMap.hasKey("promocodes")) {
+            ReadableArray promocodesArray = productMap.getArray("promocodes");
+            product.setPromocodes(toListOfStrings(promocodesArray));
+        }
+        if (productMap.hasKey("categoriesPath")) {
+            ReadableArray categoriesArray = productMap.getArray("categoriesPath");
+            product.setCategoriesPath(toListOfStrings(categoriesArray));
+        }
+        if (productMap.hasKey("payload")) {
+            ReadableMap payloadMap = productMap.getMap("payload");
+            product.setPayload(toMapOfStrings(payloadMap));
+        }
+        return product;
+    }
+
+    @Nullable
+    static ECommerceReferrer toECommerceReferrer(@Nullable ReadableMap referrerMap) {
+        if (referrerMap == null) return null;
+        ECommerceReferrer referrer = new ECommerceReferrer();
+        if (referrerMap.hasKey("type")) {
+            referrer.setType(referrerMap.getString("type"));
+        }
+        if (referrerMap.hasKey("identifier")) {
+            referrer.setIdentifier(referrerMap.getString("identifier"));
+        }
+        if (referrerMap.hasKey("screen")) {
+            ReadableMap screenMap = referrerMap.getMap("screen");
+            if (screenMap != null) {
+                referrer.setScreen(toECommerceScreen(screenMap));
+            }
+        }
+        return referrer;
+    }
+
+    @Nullable
+    static ECommerceCartItem toECommerceCartItem(@Nullable ReadableMap cartItemMap) {
+        if (cartItemMap == null) {
+            return null;
+        }
+        ECommerceProduct product = toECommerceProduct(Objects.requireNonNull(cartItemMap.getMap("product")));
+        ECommercePrice price = toECommercePrice(Objects.requireNonNull(cartItemMap.getMap("price")));
+        if (price == null) {
+            return null;
+        }
+        ReadableType quantityType = cartItemMap.getType("quantity");
+        if (quantityType == ReadableType.Number) {
+            double quantity = cartItemMap.getDouble("quantity");
+            ECommerceCartItem item = new ECommerceCartItem(product, price, quantity);
+            if (cartItemMap.hasKey("referrer")) {
+                ReadableMap referrer = cartItemMap.getMap("referrer");
+                item.setReferrer(toECommerceReferrer(referrer));
+            }
+            return item;
+        } else {
+            BigDecimal quantity = new BigDecimal(cartItemMap.getString("quantity"));
+            ECommerceCartItem item = new ECommerceCartItem(product, price, quantity);
+            if (cartItemMap.hasKey("referrer")) {
+                ReadableMap referrer = cartItemMap.getMap("referrer");
+                item.setReferrer(toECommerceReferrer(referrer));
+            }
+            return item;
+        }
+    }
+
+    @NonNull
+    static ECommerceOrder toECommerceOrder(@NonNull ReadableMap orderMap) {
+        String orderId = orderMap.getString("orderId");
+        ReadableArray list = orderMap.getArray("products");
+        List<ECommerceCartItem> newlist = new ArrayList<ECommerceCartItem>(Objects.requireNonNull(list).size());
+        for (int i = 0; i < list.size(); i++) {
+            ECommerceCartItem component = toECommerceCartItem(list.getMap(i));
+            newlist.add(component);
+        }
+        ECommerceOrder order = new ECommerceOrder(Objects.requireNonNull(orderId), newlist);
+        if (orderMap.hasKey("payload")) {
+            ReadableMap payload = orderMap.getMap("payload");
+            order.setPayload(toMapOfStrings(payload));
+        }
+        return order;
+    }
+
+    @Nullable
+    static ECommerceEvent toECommerceEvent(@NonNull ReadableMap ecommerceEventMap) {
+        String type = ecommerceEventMap.getString("ecommerceEvent");
+        if (type == null) return null;
+        if (type.equals("showSceenEvent")) {
+            ReadableMap screenMap = ecommerceEventMap.getMap("ecommerceScreen");
+            if (screenMap != null) {
+                return ECommerceEvent.showScreenEvent(toECommerceScreen(screenMap));
+            }
+        }
+        if (type.equals("showProductCardEvent")) {
+            ReadableMap cardMap = ecommerceEventMap.getMap("product");
+            ReadableMap screenMap = ecommerceEventMap.getMap("ecommerceScreen");
+            if (cardMap != null && screenMap != null) {
+                return ECommerceEvent.showProductCardEvent(toECommerceProduct(cardMap), toECommerceScreen(screenMap));
+            }
+        }
+        if (type.equals("showProductDetailsEvent")) {
+            ReadableMap productMap = ecommerceEventMap.getMap("product");
+            ReadableMap referrerMap = ecommerceEventMap.getMap("referrer");
+            if (productMap != null) {
+                return ECommerceEvent.showProductDetailsEvent(toECommerceProduct(productMap), toECommerceReferrer(referrerMap));
+            }
+        }
+        if (type.equals("addCartItemEvent")) {
+            ECommerceCartItem cartItem = toECommerceCartItem(ecommerceEventMap.getMap("cartItem"));
+            if (cartItem != null) {
+                return ECommerceEvent.addCartItemEvent(cartItem);
+            }
+        }
+        if (type.equals("removeCartItemEvent")) {
+            ECommerceCartItem cartItem = toECommerceCartItem(ecommerceEventMap.getMap("cartItem"));
+            if (cartItem != null) {
+                return ECommerceEvent.removeCartItemEvent(cartItem);
+            }
+        }
+        if (type.equals("beginCheckoutEvent")) {
+            ReadableMap orderMap = ecommerceEventMap.getMap("order");
+            if (orderMap != null) {
+                return ECommerceEvent.beginCheckoutEvent(toECommerceOrder(orderMap));
+            }
+        }
+        if (type.equals("purchaseEvent")) {
+            ReadableMap orderMap = ecommerceEventMap.getMap("order");
+            if (orderMap != null) {
+                return ECommerceEvent.purchaseEvent(toECommerceOrder(orderMap));
+            }
+        }
+        return null;
+    }
+
+    @NonNull
+    static List<String> toStartupKeyList(@NonNull ReadableArray keys) {
+        ArrayList<String> startupKeys = new ArrayList<>();
+        for (int i = 0; i < keys.size(); i++) {
+            String item = keys.getString(i);
+            if (item.equals("appmetrica_device_id_hash")) {
+                startupKeys.add(StartupParamsCallback.APPMETRICA_DEVICE_ID_HASH);
+            }
+            if (item.equals("appmetrica_device_id")) {
+                startupKeys.add(StartupParamsCallback.APPMETRICA_DEVICE_ID);
+            }
+            if (item.equals("appmetrica_uuid")) {
+                startupKeys.add(StartupParamsCallback.APPMETRICA_UUID);
+            }
+        }
+        return startupKeys;
+    }
+
+    @NonNull
+    static Revenue toRevenue(@NonNull ReadableMap revenueMap) {
+        long price = (long) (revenueMap.getDouble("price") * 1000000);
+        String currency = revenueMap.getString("currency");
+        Revenue.Builder revenue = Revenue.newBuilder(price, Currency.getInstance(currency));
+        if (revenueMap.hasKey("productID")) {
+            revenue.withProductID(revenueMap.getString("productID"));
+        }
+        if (revenueMap.hasKey("payload")) {
+            revenue.withPayload(revenueMap.getString("payload"));
+        }
+        if (revenueMap.hasKey("quantity")) {
+            revenue.withQuantity(revenueMap.getInt("quantity"));
+        }
+        revenue.withReceipt(toReceipt(revenueMap.getMap("receipt")));
+        return revenue.build();
+    }
+
+    @Nullable
+    static Revenue.Receipt toReceipt(@Nullable ReadableMap receipt) {
+        if (receipt == null) {
+          return null;
+        }
+        Revenue.Receipt.Builder revenueReceipt = Revenue.Receipt.newBuilder();
+        if (receipt.hasKey("receiptData")) {
+            revenueReceipt.withData(receipt.getString("receiptData"));
+        }
+        if (receipt.hasKey("signature")) {
+            revenueReceipt.withSignature(receipt.getString("signature"));
+        }
+        return revenueReceipt.build();
+    }
+
+    @NonNull
+    private static AdRevenue.Builder parseAdRevenuePrice(@NonNull ReadableMap revenueMap) {
+        ReadableType priceType = revenueMap.getType("price");
+        String currency = revenueMap.getString("currency");
+        if (priceType == ReadableType.Number) {
+            double price = revenueMap.getDouble("price");
+            return AdRevenue.newBuilder(price, Currency.getInstance(currency));
+        } else {
+            String price = revenueMap.getString("price");
+            return AdRevenue.newBuilder(new BigDecimal(price), Currency.getInstance(currency));
+        }
+    }
+
+    @NonNull
+    static AdRevenue toAdRevenue(@NonNull ReadableMap revenueMap) {
+        AdRevenue.Builder adRevenue = parseAdRevenuePrice(revenueMap);
+        if (revenueMap.hasKey("payload")) {
+            ReadableMap payloadMap = revenueMap.getMap("payload");
+            adRevenue.withPayload(toMapOfStrings(payloadMap));
+        }
+        if (revenueMap.hasKey("adType")) {
+            String type = revenueMap.getString("adType");
+            if (type != null) {
+                adRevenue.withAdType(toAdType(type));
+            }
+        }
+        if (revenueMap.hasKey("adNetwork")) {
+            adRevenue.withAdNetwork(revenueMap.getString("adNetwork"));
+        }
+        if (revenueMap.hasKey("adPlacementID")) {
+            adRevenue.withAdPlacementId(revenueMap.getString("adPlacementID"));
+        }
+        if (revenueMap.hasKey("adPlacementName")) {
+            adRevenue.withAdPlacementName(revenueMap.getString("adPlacementName"));
+        }
+        if (revenueMap.hasKey("adUnitID")) {
+            adRevenue.withAdUnitId(revenueMap.getString("adUnitID"));
+        }
+        if (revenueMap.hasKey("adUnitName")) {
+            adRevenue.withAdUnitName(revenueMap.getString("adUnitName"));
+        }
+        if (revenueMap.hasKey("precision")) {
+            adRevenue.withPrecision(revenueMap.getString("precision"));
+        }
+        return adRevenue.build();
+    }
+
+    @NonNull
+    static AdType toAdType(@NonNull String type) {
+        switch (type) {
+            case "native":
+                return AdType.NATIVE;
+            case "banner":
+                return AdType.BANNER;
+            case "mrec":
+                return AdType.MREC;
+            case "interstitial":
+                return AdType.INTERSTITIAL;
+            case "rewarded":
+                return AdType.REWARDED;
+            default:
+                return AdType.OTHER;
+        }
+    }
+
+    @Nullable
+    private static Map<String, String> toMapOfStrings(@Nullable ReadableMap oldMap) {
+        if (oldMap == null) {
+            return null;
+        }
+        HashMap<String, String> newMap = new HashMap<>();
+        for (Map.Entry<String, Object> entry : oldMap.toHashMap().entrySet()) {
+            if (entry.getValue() instanceof String) {
+                newMap.put(entry.getKey(), (String) entry.getValue());
+            }
+        }
+        return newMap;
+    }
+
+    @Nullable
+    private static List<String> toListOfStrings(@Nullable ReadableArray oldArray) {
+        if (oldArray == null) {
+            return null;
+        }
+        List<Object> list = oldArray.toArrayList();
+        List<String> newArray = new ArrayList<String>(list.size());
+        for (Object object : list) {
+            newArray.add(Objects.toString(object));
+        }
+        return newArray;
+    }
+}

package/appmetrica-react-native-analytics.podspec

@@ -0,0 +1,43 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "appmetrica-react-native-analytics"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/appmetrica/appmetrica-react-native-plugin.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency "AppMetricaAnalytics", "5.4.0"
+
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+end

package/ios/AMARNAppMetrica.h

@@ -0,0 +1,6 @@
+
+#import <React/RCTBridgeModule.h>
+
+@interface AMARNAppMetrica : NSObject <RCTBridgeModule>
+
+@end

package/ios/AMARNAppMetrica.m

@@ -0,0 +1,120 @@
+
+#import "AMARNAppMetrica.h"
+#import "AMARNAppMetricaUtils.h"
+#import "AMARNStartupParamsUtils.h"
+#import <AppMetricaCrashes/AppMetricaCrashes.h>
+
+@implementation AMARNAppMetrica
+
+@synthesize methodQueue = _methodQueue;
+
+RCT_EXPORT_MODULE(AppMetrica)
+
+RCT_EXPORT_METHOD(activate:(NSDictionary *)configDict)
+{
+    [[AMAAppMetricaCrashes crashes] setConfiguration:[AMARNAppMetricaUtils crashConfigurationForDictionary:configDict]];
+    [AMAAppMetrica activateWithConfiguration:[AMARNAppMetricaUtils configurationForDictionary:configDict]];
+}
+
+RCT_EXPORT_METHOD(getLibraryApiLevel)
+{
+    // It does nothing for iOS
+}
+
+RCT_EXPORT_METHOD(getLibraryVersion:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    resolve([AMAAppMetrica libraryVersion]);
+}
+
+RCT_EXPORT_METHOD(pauseSession)
+{
+    [AMAAppMetrica pauseSession];
+}
+
+RCT_EXPORT_METHOD(reportAppOpen:(NSString *)deeplink)
+{
+    [AMAAppMetrica trackOpeningURL:[NSURL URLWithString:deeplink]];
+}
+
+RCT_EXPORT_METHOD(reportError:(NSString *)identifier:(NSString *)message) {
+    AMAError *error = [AMAError errorWithIdentifier:identifier message:message parameters:NULL];
+    [[AMAAppMetricaCrashes crashes] reportError:error onFailure:nil];
+}
+
+RCT_EXPORT_METHOD(reportEvent:(NSString *)eventName:(NSDictionary *)attributes)
+{
+    if (attributes == nil) {
+        [AMAAppMetrica reportEvent:eventName onFailure:^(NSError *error) {
+            NSLog(@"error: %@", [error localizedDescription]);
+        }];
+    } else {
+        [AMAAppMetrica reportEvent:eventName parameters:attributes onFailure:^(NSError *error) {
+            NSLog(@"error: %@", [error localizedDescription]);
+        }];
+    }
+}
+
+RCT_EXPORT_METHOD(requestStartupParams:(NSArray *)identifiers:(RCTResponseSenderBlock)listener)
+{
+    AMAIdentifiersCompletionBlock block = ^(NSDictionary<AMAStartupKey,id> * _Nullable identifiers, NSError * _Nullable error) {
+        NSDictionary *result = [AMARNStartupParamsUtils toStrartupParamsResult:identifiers];
+        NSString *errorStr = [AMARNStartupParamsUtils stringFromRequestStartupParamsError:error];
+        listener(@[[self wrap:result], [self wrap:errorStr]]);
+    };
+    [AMAAppMetrica requestStartupIdentifiersWithKeys:[AMARNStartupParamsUtils toStartupKeys:identifiers] completionQueue:nil completionBlock:block];
+}
+
+RCT_EXPORT_METHOD(resumeSession)
+{
+    [AMAAppMetrica resumeSession];
+}
+
+RCT_EXPORT_METHOD(sendEventsBuffer)
+{
+    [AMAAppMetrica sendEventsBuffer];
+}
+
+RCT_EXPORT_METHOD(setLocation:(NSDictionary *)locationDict)
+{
+    AMAAppMetrica.customLocation = [AMARNAppMetricaUtils locationForDictionary:locationDict];
+}
+
+RCT_EXPORT_METHOD(setLocationTracking:(BOOL)enabled)
+{
+    AMAAppMetrica.locationTrackingEnabled = enabled;
+}
+
+RCT_EXPORT_METHOD(setDataSendingEnabled:(BOOL)enabled)
+{
+    [AMAAppMetrica setDataSendingEnabled:enabled];
+}
+
+RCT_EXPORT_METHOD(reportECommerce:(NSDictionary *)ecommerceDict)
+{
+   [AMAAppMetrica reportECommerce:[AMARNAppMetricaUtils ecommerceForDict:ecommerceDict] onFailure:nil];
+}
+
+RCT_EXPORT_METHOD(setUserProfileID:(NSString *)userProfileID)
+{
+    [AMAAppMetrica setUserProfileID:userProfileID];
+}
+
+RCT_EXPORT_METHOD(reportRevenue:(NSDictionary *)revenueDict)
+{
+    [AMAAppMetrica reportRevenue:[AMARNAppMetricaUtils revenueForDict:revenueDict] onFailure:nil];
+}
+
+RCT_EXPORT_METHOD(reportAdRevenue:(NSDictionary *)revenueDict)
+{
+    [AMAAppMetrica reportAdRevenue:[AMARNAppMetricaUtils adRevenueForDict:revenueDict] onFailure:nil];
+}
+
+- (NSObject *)wrap:(NSObject *)value
+{
+    if (value == nil) {
+        return [NSNull null];
+    }
+    return value;
+}
+
+@end

package/ios/AMARNAppMetricaUtils.h

@@ -0,0 +1,24 @@
+
+#import <CoreLocation/CoreLocation.h>
+#import <AppMetricaCore/AppMetricaCore.h>
+#import <AppMetricaCrashes/AppMetricaCrashes.h>
+
+@interface AMARNAppMetricaUtils : NSObject
+
++ (AMAAppMetricaConfiguration *)configurationForDictionary:(NSDictionary *)configDict;
++ (AMAAppMetricaCrashesConfiguration *)crashConfigurationForDictionary:(NSDictionary *)crashConfigDict;
++ (CLLocation *)locationForDictionary:(NSDictionary *)locationDict;
++ (AMAECommerceScreen *)ecommerceScreenForDict:(NSDictionary *)ecommerceScreenDict;
++ (AMAECommerceAmount *)ecommerceAmountForDict:(NSDictionary *)ecommerceAmountDict;
++ (AMAECommercePrice *)ecommercePriceForDict:(NSDictionary *)ecommercePriceDict;
++ (AMAECommerceReferrer *)ecommerceReferrerForDict:(NSDictionary *)ecommerceReferrerDict;
++ (AMAECommerceProduct *)ecommerceProductForDict:(NSDictionary *)ecommerceProductDict;
++ (AMAECommerceCartItem *)ecommerceCartItemForDict:(NSDictionary *)ecommerceCartItemDict;
++ (AMAECommerceOrder *)ecommerceOrderForDict:(NSDictionary *)ecommerceOrderDict;
++ (AMAECommerce *)ecommerceForDict:(NSDictionary *)ecommerceDict;
++ (AMARevenueInfo *)revenueForDict:(NSDictionary *)revenueDict;
++ (AMAAdRevenueInfo *)adRevenueForDict:(NSDictionary *)revenueDict;
++ (AMAAdType)toAdType:(NSString *)type;
++ (NSDictionary *)convertRevenueInfoPayload:(NSString *)payload;
+
+@end