@appmetrica/react-native-analytics 3.3.0 → 3.4.0

package/android/build.gradle

@@ -85,5 +85,5 @@ dependencies {
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
-  implementation "io.appmetrica.analytics:analytics:7.2.0"
+  implementation "io.appmetrica.analytics:analytics:7.8.0"
 }

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

@@ -19,6 +19,7 @@ import io.appmetrica.analytics.AppMetrica;
 import io.appmetrica.analytics.AppMetricaConfig;
 import io.appmetrica.analytics.ModulesFacade;
 import io.appmetrica.analytics.ecommerce.ECommerceEvent;
+import io.appmetrica.analytics.plugins.PluginErrorDetails;
 
 @ReactModule(name = AppMetricaModule.NAME)
 public class AppMetricaModule extends ReactContextBaseJavaModule {
@@ -70,12 +71,9 @@ public class AppMetricaModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void reportError(String identifier, String message) {
-        try {
-            Integer.valueOf("00xffWr0ng");
-        } catch (Throwable error) {
-            AppMetrica.reportError(identifier, message, error);
-        }
+    public void reportError(String identifier, String message, ReadableMap _reason) {
+        PluginErrorDetails errorDetails = _reason != null ? ExceptionSerializer.fromObject(_reason) : null;
+        AppMetrica.getPluginExtension().reportError(identifier, message, errorDetails);
     }
 
     @ReactMethod
@@ -156,6 +154,22 @@ public class AppMetricaModule extends ReactContextBaseJavaModule {
         AppMetrica.putErrorEnvironmentValue(key, value);
     }
 
+    @ReactMethod
+    public void reportErrorWithoutIdentifier(String message, ReadableMap error) {
+        PluginErrorDetails details = ExceptionSerializer.fromObject(error);
+        if (details.getStacktrace().isEmpty()) {
+            AppMetrica.getPluginExtension().reportError("Errors without stacktrace", message, details);
+        } else {
+            AppMetrica.getPluginExtension().reportError(details, message);
+        }
+    }
+
+    @ReactMethod
+    public void reportUnhandledException(ReadableMap error) {
+        PluginErrorDetails details = ExceptionSerializer.fromObject(error);
+        AppMetrica.getPluginExtension().reportUnhandledException(details);
+    }
+
     @ReactMethod
     public void reportExternalAttribution(ReadableMap attribution) {
         ModulesFacade.reportExternalAttribution(
@@ -163,4 +177,44 @@ public class AppMetricaModule extends ReactContextBaseJavaModule {
                 ExternalAttributionSerializer.parseValue(attribution.getMap("value"))
         );
     }
+
+    @ReactMethod
+    public void putAppEnvironmentValue(String key, String value) {
+        AppMetrica.putAppEnvironmentValue(key, value);
+    }
+
+    @ReactMethod
+    public void clearAppEnvironment() {
+        AppMetrica.clearAppEnvironment();
+    }
+
+    @ReactMethod
+    public void activateReporter(ReadableMap configMap) {
+        AppMetrica.activateReporter(reactContext, Utils.toReporterConfig(configMap));
+    }
+
+    @ReactMethod
+    public void touchReporter(String apiKey) {
+        AppMetrica.getReporter(reactContext, apiKey);
+    }
+
+    @ReactMethod
+    public void getDeviceId(Promise promise) {
+        promise.resolve(AppMetrica.getDeviceId(reactContext));
+    }
+
+    @ReactMethod
+    public void getUuid(Promise promise) {
+        promise.resolve(AppMetrica.getUuid(reactContext));
+    }
+
+    @ReactMethod
+    public void requestDeferredDeeplink(Callback failureCallback, Callback successCallback) {
+        AppMetrica.requestDeferredDeeplink(new ReactNativeDeferredDeeplinkListener(failureCallback, successCallback));
+    }
+
+    @ReactMethod
+    public void requestDeferredDeeplinkParameters(Callback failureCallback, Callback successCallback) {
+        AppMetrica.requestDeferredDeeplinkParameters(new ReactNativeDeferredDeeplinkParametersListener(failureCallback, successCallback));
+    }
 }

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

@@ -17,6 +17,7 @@ public class AppMetricaPackage implements ReactPackage {
     public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new AppMetricaModule(reactContext));
+        modules.add(new ReporterModule(reactContext));
         return modules;
     }
 

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

@@ -0,0 +1,91 @@
+package io.appmetrica.analytics.reactnative;
+
+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 java.util.LinkedList;
+import java.util.List;
+
+import io.appmetrica.analytics.plugins.PluginErrorDetails;
+import io.appmetrica.analytics.plugins.StackTraceItem;
+
+final class ExceptionSerializer {
+    private ExceptionSerializer() {}
+    private static final String TAG = "ExceptionSerializer";
+
+    @NonNull
+    public static PluginErrorDetails fromObject(@NonNull ReadableMap exception) {
+        PluginErrorDetails.Builder builder = new PluginErrorDetails.Builder();
+        builder.withPlatform(PluginErrorDetails.Platform.REACT_NATIVE);
+        if (exception.hasKey("errorName")) {
+            builder.withExceptionClass(exception.getString("errorName"));
+        }
+        if (exception.hasKey("message")) {
+            builder.withMessage(exception.getString("message"));
+        }
+        if (exception.hasKey("stackTrace")) {
+            builder.withStacktrace(getStackTrace(exception.getArray("stackTrace")));
+        }
+        if (exception.hasKey("virtualMachineVersion")) {
+            builder.withVirtualMachineVersion(exception.getString("virtualMachineVersion"));
+        }
+        if (exception.hasKey("pluginEnvironment")) {
+            builder.withPluginEnvironment(Utils.toMapOfStrings(exception.getMap("pluginEnvironment")));
+        }
+        return builder.build();
+    }
+
+    @Nullable
+    private static List<StackTraceItem> getStackTrace(@Nullable ReadableArray stackTraceArray) {
+        if (stackTraceArray == null) {
+            return null;
+        }
+        List<StackTraceItem> items = new LinkedList<>();
+        for (int idx = 0; idx < stackTraceArray.toArrayList().size(); idx++) {
+            items.add(getStackTraceItem(stackTraceArray.getMap(idx)));
+        }
+        return items;
+    }
+
+    @NonNull
+    private static StackTraceItem getStackTraceItem(@Nullable ReadableMap item) {
+        StackTraceItem.Builder builder = new StackTraceItem.Builder();
+        if (item == null) {
+            return builder.build();
+        }
+        if (item.hasKey("fileName")) {
+            builder.withFileName(item.getString("fileName"));
+        }
+        if (item.hasKey("className")) {
+            builder.withClassName(item.getString("className"));
+        }
+        if (item.hasKey("methodName")) {
+            builder.withMethodName(item.getString("methodName"));
+        }
+        if (item.hasKey("line")) {
+            builder.withLine(parseInt(item.getString("line")));
+        }
+        if (item.hasKey("column")) {
+           builder.withColumn(parseInt(item.getString("column")));
+        }
+        return builder.build();
+    }
+
+    @Nullable
+    private static Integer parseInt(@Nullable String string) {
+        if (string == null) {
+            return null;
+        }
+        try {
+            return Integer.parseInt(string);
+        } catch (NumberFormatException exception) {
+            Log.w(TAG, "uncorrected number in the stacktrace line or column: " + string);
+            return null;
+        }
+    }
+}

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

@@ -16,15 +16,22 @@ final class ExternalAttributionSerializer {
             return -1;
         }
 
-        return switch (sourceString) {
-            case "AppsFlyer" -> ModulesFacade.EXTERNAL_ATTRIBUTION_APPSFLYER;
-            case "Adjust" -> ModulesFacade.EXTERNAL_ATTRIBUTION_ADJUST;
-            case "Kochava" -> ModulesFacade.EXTERNAL_ATTRIBUTION_KOCHAVA;
-            case "Tenjin" -> ModulesFacade.EXTERNAL_ATTRIBUTION_TENJIN;
-            case "Airbridge" -> ModulesFacade.EXTERNAL_ATTRIBUTION_AIRBRIDGE;
-            case "Singular" -> ModulesFacade.EXTERNAL_ATTRIBUTION_SINGULAR;
-            default -> -1;
-        };
+        switch (sourceString) {
+            case "AppsFlyer":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_APPSFLYER;
+            case "Adjust":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_ADJUST;
+            case "Kochava":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_KOCHAVA;
+            case "Tenjin":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_TENJIN;
+            case "Airbridge":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_AIRBRIDGE;
+            case "Singular":
+                return ModulesFacade.EXTERNAL_ATTRIBUTION_SINGULAR;
+            default:
+                return -1;
+        }
     }
 
     public static String parseValue(ReadableMap valueMap) {

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

@@ -0,0 +1,48 @@
+package io.appmetrica.analytics.reactnative;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+
+import io.appmetrica.analytics.DeferredDeeplinkListener;
+import io.appmetrica.analytics.StartupParamsCallback;
+
+public class ReactNativeDeferredDeeplinkListener implements DeferredDeeplinkListener {
+
+    @NonNull
+    private final Callback failureListener;
+
+    @NonNull
+    private final Callback successListener;
+
+    ReactNativeDeferredDeeplinkListener(@NonNull Callback failureCallback, @NonNull Callback successCallback) {
+        this.failureListener = failureCallback;
+        this.successListener = successCallback;
+    }
+
+    @Override
+    public void onDeeplinkLoaded(@NonNull String deeplink) {
+        successListener.invoke(deeplink);
+    }
+
+    @Override
+    public void onError(@NonNull Error error, @Nullable String referrer) {
+        failureListener.invoke(getErrorStr(error), referrer);
+    }
+
+    @NonNull
+    private static String getErrorStr(@NonNull Error error) {
+        switch (error) {
+          case NO_REFERRER:
+              return "NO_REFERRER";
+          case NOT_A_FIRST_LAUNCH:
+              return "NOT_A_FIRST_LAUNCH";
+          case PARSE_ERROR:
+              return "PARSE_ERROR";
+          default:
+              return "UNKNOWN";
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+package io.appmetrica.analytics.reactnative;
+
+import androidx.annotation.NonNull;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.facebook.react.bridge.Arguments;
+
+import io.appmetrica.analytics.DeferredDeeplinkListener;
+import io.appmetrica.analytics.DeferredDeeplinkParametersListener;
+import java.util.Map;
+
+public class ReactNativeDeferredDeeplinkParametersListener implements DeferredDeeplinkParametersListener {
+    @NonNull
+    private final Callback failureListener;
+
+    @NonNull
+    private final Callback successListener;
+
+    ReactNativeDeferredDeeplinkParametersListener(@NonNull Callback failureCallback, @NonNull Callback successCallback) {
+        this.failureListener = failureCallback;
+        this.successListener = successCallback;
+    }
+
+    @Override
+    public void onParametersLoaded(@NonNull Map<String, String> map) {
+      WritableMap writableMap = Arguments.createMap();
+      for (Map.Entry<String, String> entry : map.entrySet()) {
+        writableMap.putString(entry.getKey(), entry.getValue());
+      }
+      successListener.invoke(writableMap, null);
+    }
+
+    @Override
+    public void onError(@NonNull Error error, @NonNull String referrer) {
+        failureListener.invoke(getErrorStr(error), referrer);
+    }
+
+    @NonNull
+    private static String getErrorStr(@NonNull DeferredDeeplinkParametersListener.Error error) {
+        switch (error) {
+          case NO_REFERRER:
+              return "NO_REFERRER";
+          case NOT_A_FIRST_LAUNCH:
+              return "NOT_A_FIRST_LAUNCH";
+          case PARSE_ERROR:
+              return "PARSE_ERROR";
+          default:
+              return "UNKNOWN";
+        }
+    }
+}

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

@@ -0,0 +1,130 @@
+package io.appmetrica.analytics.reactnative;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+import io.appmetrica.analytics.AppMetrica;
+import io.appmetrica.analytics.ecommerce.ECommerceEvent;
+import io.appmetrica.analytics.plugins.PluginErrorDetails;
+
+public class ReporterModule extends ReactContextBaseJavaModule {
+
+    public static final String NAME = "AppMetricaReporter";
+
+    private static final String TAG = "ReporterModule";
+
+    @NonNull
+    private final ReactApplicationContext reactContext;
+
+    public ReporterModule(@NonNull ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @ReactMethod
+    public void reportError(String apiKey, String identifier, String message, ReadableMap _reason) {
+        PluginErrorDetails errorDetails = _reason != null ? ExceptionSerializer.fromObject(_reason) : null;
+        AppMetrica.getReporter(reactContext, apiKey).getPluginExtension().reportError(identifier, message, errorDetails);
+    }
+
+    @ReactMethod
+    public void reportErrorWithoutIdentifier(String apiKey, String message, ReadableMap error) {
+        PluginErrorDetails details = ExceptionSerializer.fromObject(error);
+        if (details.getStacktrace().isEmpty()) {
+            AppMetrica.getReporter(reactContext, apiKey).getPluginExtension().reportError("Errors without stacktrace", message, details);
+        } else {
+            AppMetrica.getReporter(reactContext, apiKey).getPluginExtension().reportError(details, message);
+        }
+    }
+
+    @ReactMethod
+    public void reportUnhandledException(String apiKey, ReadableMap error) {
+        PluginErrorDetails details = ExceptionSerializer.fromObject(error);
+        AppMetrica.getReporter(reactContext, apiKey).getPluginExtension().reportUnhandledException(details);
+    }
+
+    @ReactMethod
+    public void reportEvent(String apiKey, String eventName, ReadableMap attributes) {
+        if (attributes == null) {
+            AppMetrica.getReporter(reactContext, apiKey).reportEvent(eventName);
+        } else {
+            AppMetrica.getReporter(reactContext, apiKey).reportEvent(eventName, attributes.toHashMap());
+        }
+    }
+
+    @ReactMethod
+    public void pauseSession(String apiKey) {
+        AppMetrica.getReporter(reactContext, apiKey).pauseSession();
+    }
+
+    @ReactMethod
+    public void resumeSession(String apiKey) {
+        AppMetrica.getReporter(reactContext, apiKey).resumeSession();
+    }
+
+    @ReactMethod
+    public void sendEventsBuffer(String apiKey) {
+        AppMetrica.getReporter(reactContext, apiKey).sendEventsBuffer();
+    }
+
+    @ReactMethod
+    public void clearAppEnvironment(String apiKey) {
+        AppMetrica.getReporter(reactContext, apiKey).clearAppEnvironment();
+    }
+
+    @ReactMethod
+    public void putAppEnvironmentValue(String apiKey, String key, String value) {
+        AppMetrica.getReporter(reactContext, apiKey).putAppEnvironmentValue(key, value);
+    }
+
+    @ReactMethod
+    public void setUserProfileID(String apiKey, String userProfileID) {
+        AppMetrica.getReporter(reactContext, apiKey).setUserProfileID(userProfileID);
+    }
+
+    @ReactMethod
+    public void reportUserProfile(String apiKey, ReadableMap userProfile) {
+        try {
+            AppMetrica.getReporter(reactContext, apiKey).reportUserProfile(Utils.toUserProfile(userProfile));
+        } catch (Throwable e) {
+            Log.w(TAG, "Cannot parse user profile", e);
+        }
+    }
+
+    @ReactMethod
+    public void setDataSendingEnabled(String apiKey, boolean enabled) {
+        AppMetrica.getReporter(reactContext, apiKey).setDataSendingEnabled(enabled);
+    }
+
+    @ReactMethod
+    public void reportAdRevenue(String apiKey, ReadableMap AdRevenueMap) {
+        AppMetrica.getReporter(reactContext, apiKey).reportAdRevenue(Utils.toAdRevenue(AdRevenueMap));
+    }
+
+    @ReactMethod
+    public void reportECommerce(String apiKey, ReadableMap ecommerceEvent) {
+        ECommerceEvent event = Utils.toECommerceEvent(ecommerceEvent);
+        if (event != null) {
+            AppMetrica.getReporter(reactContext, apiKey).reportECommerce(event);
+        } else {
+            Log.w(TAG, "ECommerceEvent is null");
+        }
+    }
+
+    @ReactMethod
+    public void reportRevenue(String apiKey, ReadableMap revenueMap) {
+        AppMetrica.getReporter(reactContext, apiKey).reportRevenue(Utils.toRevenue(revenueMap));
+    }
+}

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

@@ -11,6 +11,7 @@ import io.appmetrica.analytics.AdRevenue;
 import io.appmetrica.analytics.AdType;
 import io.appmetrica.analytics.AppMetricaConfig;
 import io.appmetrica.analytics.PreloadInfo;
+import io.appmetrica.analytics.ReporterConfig;
 import io.appmetrica.analytics.Revenue;
 import io.appmetrica.analytics.StartupParamsCallback;
 import io.appmetrica.analytics.profile.UserProfile;
@@ -84,6 +85,21 @@ abstract class Utils {
                 }
             }
         }
+        if (configMap.hasKey("appEnvironment")) {
+            ReadableMap appEnvironmentMap = configMap.getMap("appEnvironment");
+            if (appEnvironmentMap != null) {
+                for (Map.Entry<String, Object> entry : appEnvironmentMap.toHashMap().entrySet()) {
+                    Object value = entry.getValue();
+                    builder.withAppEnvironmentValue(entry.getKey(), value == null ? null : value.toString());
+                }
+            }
+        }
+        if (configMap.hasKey("maxReportsCount")) {
+            builder.withMaxReportsCount(configMap.getInt("maxReportsCount"));
+        }
+        if (configMap.hasKey("dispatchPeriodSeconds")) {
+            builder.withDispatchPeriodSeconds(configMap.getInt("dispatchPeriodSeconds"));
+        }
 
         return builder.build();
     }
@@ -473,7 +489,7 @@ abstract class Utils {
     }
 
     @Nullable
-    private static Map<String, String> toMapOfStrings(@Nullable ReadableMap oldMap) {
+    static Map<String, String> toMapOfStrings(@Nullable ReadableMap oldMap) {
         if (oldMap == null) {
             return null;
         }
@@ -498,4 +514,42 @@ abstract class Utils {
         }
         return newArray;
     }
+
+    @NonNull
+    static ReporterConfig toReporterConfig(@NonNull ReadableMap configMap) {
+        ReporterConfig.Builder builder = ReporterConfig.newConfigBuilder(Objects.requireNonNull(configMap.getString("apiKey")));
+
+        if (configMap.hasKey("logs") && Boolean.TRUE.equals(configMap.getBoolean("logs"))) {
+            builder.withLogs();
+        }
+        if (configMap.hasKey("maxReportsInDatabaseCount")) {
+            builder.withMaxReportsInDatabaseCount(configMap.getInt("maxReportsInDatabaseCount"));
+        }
+        if (configMap.hasKey("sessionTimeout")) {
+            builder.withSessionTimeout(configMap.getInt("sessionTimeout"));
+        }
+        if (configMap.hasKey("dataSendingEnabled")) {
+            builder.withDataSendingEnabled(configMap.getBoolean("dataSendingEnabled"));
+        }
+        if (configMap.hasKey("appEnvironment")) {
+            ReadableMap appMap = configMap.getMap("appEnvironment");
+            if (appMap != null) {
+                for (Map.Entry<String, Object> entry : appMap.toHashMap().entrySet()) {
+                    if (entry.getValue() instanceof String) {
+                        builder.withAppEnvironmentValue(entry.getKey(), entry.getValue().toString());
+                    }
+                }
+            }
+        }
+        if (configMap.hasKey("dispatchPeriodSeconds")) {
+            builder.withDispatchPeriodSeconds(configMap.getInt("dispatchPeriodSeconds"));
+        }
+        if (configMap.hasKey("userProfileID")) {
+            builder.withUserProfileID(configMap.getString("userProfileID"));
+        }
+        if (configMap.hasKey("maxReportsCount")) {
+            builder.withMaxReportsCount(configMap.getInt("maxReportsCount"));
+        }
+        return builder.build();
+    }
 }

package/appmetrica-react-native-analytics.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm}"
 
-  s.dependency "AppMetricaAnalytics", "5.8.0"
+  s.dependency "AppMetricaAnalytics", "5.10.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.

package/ios/AMARNAppMetrica.m

@@ -5,6 +5,7 @@
 #import "AMARNUserProfileSerializer.h"
 #import "AMARNExternalAttribution.h"
 #import <AppMetricaCrashes/AppMetricaCrashes.h>
+#import "AMARNExceptionSerializer.h"
 
 @implementation AMARNAppMetrica
 
@@ -38,9 +39,13 @@ 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(reportError:(NSString *)identifier:(NSString *)message:(NSDictionary *)_reason) {
+    [[[AMAAppMetricaCrashes crashes] pluginExtension] reportErrorWithIdentifier:identifier
+                                                                        message:message
+                                                                        details:amarn_exceptionForDictionary(_reason)
+                                                                      onFailure:^(NSError *error) {
+        NSLog(@"Failed to report error to AppMetrica: %@", [error localizedDescription]);
+    }];
 }
 
 RCT_EXPORT_METHOD(reportEvent:(NSString *)eventName:(NSDictionary *)attributes)
@@ -93,7 +98,7 @@ RCT_EXPORT_METHOD(setDataSendingEnabled:(BOOL)enabled)
 
 RCT_EXPORT_METHOD(reportECommerce:(NSDictionary *)ecommerceDict)
 {
-   [AMAAppMetrica reportECommerce:[AMARNAppMetricaUtils ecommerceForDict:ecommerceDict] onFailure:nil];
+    [AMAAppMetrica reportECommerce:[AMARNAppMetricaUtils ecommerceForDict:ecommerceDict] onFailure:nil];
 }
 
 RCT_EXPORT_METHOD(setUserProfileID:(NSString *)userProfileID)
@@ -123,21 +128,86 @@ RCT_EXPORT_METHOD(putErrorEnvironmentValue:(NSString *)key:(NSString *)value)
 
 RCT_EXPORT_METHOD(reportExternalAttribution:(NSDictionary *)externalAttributionsDict)
 {
-    
+
     NSString *sourceStr = externalAttributionsDict[@"source"];
     AMAAttributionSource source = amarn_getExternalAttributionSource(sourceStr);
     if (source == nil) {
         NSLog(@"Failed to report external attribution to AppMetrica. Unknown source %@", sourceStr);
         return;
     }
-    
+
     NSDictionary *value = externalAttributionsDict[@"value"];
-    
+
     [AMAAppMetrica reportExternalAttribution:value source:source onFailure:^(NSError *error) {
         NSLog(@"Failed to report external attribution to AppMetrica: %@", [error localizedDescription]);
     }];
 }
 
+RCT_EXPORT_METHOD(reportErrorWithoutIdentifier:(NSString *)message:(NSDictionary *)error)
+{
+    AMAPluginErrorDetails *details = amarn_exceptionForDictionary(error);
+    if (details.backtrace.count == 0) {
+        [[[AMAAppMetricaCrashes crashes] pluginExtension] reportErrorWithIdentifier:@"Errors without stacktrace"
+                                                                            message:message
+                                                                            details:details
+                                                                          onFailure:^(NSError *error) {
+            NSLog(@"Failed to report error to AppMetrica: %@", [error localizedDescription]);
+        }];
+    } else {
+        [[[AMAAppMetricaCrashes crashes] pluginExtension] reportError:details message:message onFailure:^(NSError *error) {
+            NSLog(@"Failed to report error to AppMetrica: %@", [error localizedDescription]);
+        }];
+    }
+}
+
+RCT_EXPORT_METHOD(reportUnhandledException:(NSDictionary *)error)
+{
+    [[[AMAAppMetricaCrashes crashes] pluginExtension] reportUnhandledException:amarn_exceptionForDictionary(error)
+                                                                     onFailure:^(NSError *error) {
+        NSLog(@"Failed to report unhandled exception to AppMetrica: %@", [error localizedDescription]);
+    }];
+}
+
+RCT_EXPORT_METHOD(putAppEnvironmentValue:(NSString *)key:(NSString *)value)
+{
+    [AMAAppMetrica setAppEnvironmentValue:value forKey:key];
+}
+
+RCT_EXPORT_METHOD(clearAppEnvironment)
+{
+    [AMAAppMetrica clearAppEnvironment];
+}
+
+RCT_EXPORT_METHOD(activateReporter:(NSDictionary *)configDict)
+{
+    [AMAAppMetrica activateReporterWithConfiguration:[AMARNAppMetricaUtils reporterConfigurationForDictionary:configDict]];
+}
+
+RCT_EXPORT_METHOD(touchReporter:(NSString *)apiKey)
+{
+    [AMAAppMetrica reporterForAPIKey:apiKey];
+}
+
+RCT_EXPORT_METHOD(getDeviceId:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    resolve([AMAAppMetrica deviceID]);
+}
+
+RCT_EXPORT_METHOD(getUuid:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+{
+    resolve([AMAAppMetrica UUID]);
+}
+
+RCT_EXPORT_METHOD(requestDeferredDeeplink:(RCTResponseSenderBlock)onFailure:(RCTResponseSenderBlock)onSuccess)
+{
+    // It does nothing for iOS
+}
+
+RCT_EXPORT_METHOD(requestDeferredDeeplinkParameters:(RCTResponseSenderBlock)onFailure:(RCTResponseSenderBlock)onSuccess)
+{
+    // It does nothing for iOS
+}
+
 - (NSObject *)wrap:(NSObject *)value
 {
     if (value == nil) {