react-native-radar 3.20.4 → 3.21.0-beta.1

package/src/index.web.js

@@ -0,0 +1,528 @@
+import RadarJS from 'radar-sdk-js';
+import { VERSION } from './version';
+
+let throws = false;
+const throwOnUnimplemented = (value) => {
+  throws = value
+}
+
+const initialize = (publishableKey) => {
+  RadarJS.initialize(publishableKey);
+}
+
+const setLogLevel = (level) => {
+  if (throws) throw new Error("setLogLevel() is not implemented on web");
+};
+
+const setUserId = (userId) => {
+  RadarJS.setUserId(userId);
+};
+
+const getUserId = () => {
+  if (throws) throw new Error("getUserId() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getUserId() is not implemented on web") });
+}
+
+const setDeviceId = (deviceId, installId) => {
+  RadarJS.setDeviceId(deviceId, installId);
+}
+const setDeviceType = (deviceType) => {
+  RadarJS.setDeviceType(deviceType);
+}
+
+const setRequestHeaders = (headers) => {
+  RadarJS.setRequestHeaders(headers);
+}
+
+const setDescription = (description) => {
+  RadarJS.setDescription(description);
+};
+
+const getDescription = () => {
+  if (throws) throw new Error("getDescription() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getDescription() is not implemented on web") });
+}
+
+const setMetadata = (metadata) => {
+  RadarJS.setMetadata(metadata);
+};
+
+const getMetadata = () => {
+  if (throws) throw new Error("getMetadata() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getMetadata() is not implemented on web") });
+}
+
+const setAnonymousTrackingEnabled = () => {
+  if (throws) throw new Error("setAnonymousTrackingEnabled() is not implemented on web");
+}
+
+const getPermissionsStatus = () => {
+  return new Promise(resolve => {
+    const navigator = window.navigator;
+
+    if (!navigator.permissions) {
+      resolve({
+        status: 'UNKNOWN'
+      });
+    } else {
+      navigator.permissions.query({ name: 'geolocation' }).then((result) => {
+        resolve({
+          status: result.state === 'granted' ? 'GRANTED_FOREGROUND' : 'DENIED',
+        });
+      });
+    }
+  });
+};
+
+const requestPermissions = (background) => {
+  if (throws) throw new Error("requestPermissions() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("requestPermissions() is not implemented on web") });
+};
+
+const getLocation = () => {
+  return new Promise((resolve, reject) => {    
+    RadarJS.getLocation((err, result) => {
+      if (err)
+        reject(err);
+      else
+        resolve(result);
+    })
+  });
+};
+
+const trackOnce = (options) => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, location, user, events }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          user,
+          events,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.trackOnce(options.location ? options.location : options, callback);
+    } else {
+      RadarJS.trackOnce(callback);
+    }
+  });
+};
+
+const trackVerified = () => {
+  if (throws) throw new Error("trackVerified() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("trackVerified() is not implemented on web") });
+};
+
+const getVerifiedLocationToken = () => {
+  if (throws) throw new Error("getVerifiedLocationToken() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getVerifiedLocationToken() is not implemented on web") });
+};
+
+const startTrackingEfficient = () => {  
+  if (throws) throw new Error("startTrackingEfficient() is not implemented on web");
+};
+
+const startTrackingResponsive = () => {
+  if (throws) throw new Error("startTrackingResponsive() is not implemented on web");
+};
+
+const startTrackingContinuous = () => {
+  if (throws) throw new Error("startTrackingContinuous() is not implemented on web");
+};
+
+const startTrackingCustom = (options) => {
+  if (throws) throw new Error("startTrackingCustom() is not implemented on web");
+};
+
+const startTrackingVerified = (options) => {
+  if (throws) throw new Error("startTrackingVerified() is not implemented on web");
+}
+
+const mockTracking = (options) => {
+  if (throws) throw new Error("mockTracking() is not implemented on web");
+};
+
+const stopTracking = () => {
+  if (throws) throw new Error("stopTracking() is not implemented on web");
+};
+
+const stopTrackingVerified = () => {
+  if (throws) throw new Error("stopTrackingVerified() is not implemented on web");
+}
+
+const isTracking = () => {
+  if (throws) throw new Error("isTracking() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("isTracking() is not implemented on web") });
+}
+
+const getTrackingOptions = () => {
+  if (throws) throw new Error("getTrackingOptions() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getTrackingOptions() is not implemented on web") });
+}
+
+const isUsingRemoteTrackingOptions = () => {
+  if (throws) throw new Error("isUsingRemoteTrackingOptions() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("isUsingRemoteTrackingOptions() is not implemented on web") });
+}
+
+const setForegroundServiceOptions = (options) => {
+  if (throws) throw new Error("setForegroundServiceOptions() is not implemented on web");
+};
+
+const setNotificationOptions = (options) => {
+  if (throws) throw new Error("setNotificationOptions() is not implemented on web");
+}
+
+const getTripOptions = () => {
+  if (throws) throw new Error("getTripOptions() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("getTripOptions() is not implemented on web") });
+}
+
+const startTrip = (options) => {
+  if (options.tripOptions) {
+    options = options.tripOptions;
+  }
+  console.log(options)
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+
+    RadarJS.startTrip(options, callback);
+  });
+};
+
+const completeTrip = () => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.completeTrip(callback);
+  });
+};
+
+const cancelTrip = () => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.cancelTrip(callback);
+  });
+};
+
+const updateTrip = (tripOptions) => {  
+  return new Promise((resolve, reject) => {
+    const callback = (err, { trip, events, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          trip,
+          events,
+          status
+        });
+      }
+    };
+    
+    RadarJS.updateTrip(tripOptions.options, tripOptions.status, callback);
+  });
+};
+
+const acceptEvent = (eventId, verifiedPlaceId) => {
+  if (throws) throw new Error("acceptEvent() is not implemented on web");
+};
+
+const rejectEvent = (eventId) => {
+  if (throws) throw new Error("rejectEvent() is not implemented on web");
+};
+
+const getContext = (options) => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, location, context }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          context,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.getContext(options, callback);
+    } else {
+      RadarJS.getContext(callback);
+    }
+  });
+};
+
+const searchPlaces = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.searchPlaces(options, (err, { status, location, places }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          places,
+        });
+      }
+    });
+  });
+};
+
+const searchGeofences = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.searchGeofences(options, (err, { status, location, geofences }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          location,
+          geofences,
+        });
+      }
+    });
+  });
+};
+
+const autocomplete = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.autocomplete(options, (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    });
+  });
+};
+
+const geocode = (options) => {
+  return new Promise((resolve, reject) => {
+    let newOptions = options;
+    if (typeof options === 'string') {
+      newOptions = {
+        query: options
+      };
+    } else if (options.address) {
+      newOptions.query = options.address;
+    }
+    RadarJS.geocode(newOptions, (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    });
+  });
+};
+
+const reverseGeocode = (options) => {
+  return new Promise((resolve, reject) => {
+    const callback = (err, { status, addresses }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          addresses,
+        });
+      }
+    };
+
+    if (options) {
+      RadarJS.reverseGeocode(options, callback);
+    } else {
+      RadarJS.reverseGeocode(callback);
+    }
+  });
+};
+
+const ipGeocode = () => {
+  return new Promise((resolve, reject) => {
+    RadarJS.ipGeocode((err, { status, address }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          address,
+        });
+      }
+    });
+  });
+};
+
+const validateAddress = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.validateAddress(options, (err, { status, address }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          address
+        })
+      }
+    });
+  })
+};
+
+const getDistance = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.getDistance(options, (err, { status, routes }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          status,
+          routes,
+        });
+      }
+    });
+  });
+};
+
+const getMatrix = (options) => {
+  return new Promise((resolve, reject) => {
+    RadarJS.getMatrix(options, (err, { origins, destinations, matrix, status }) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve({
+          origins,
+          destinations,
+          matrix,
+          status,
+        });
+      }
+    });
+  });
+};
+
+const logConversion = (options) => {
+  if (throws) throw new Error("logConversion() is not implemented on web");
+  return new Promise((resolve, reject) => { reject("logConversion() is not implemented on web") });
+}
+
+const sendEvent = (name, metadata) => {
+  if (throws) throw new Error("sendEvent() is not implemented on web");
+}
+
+const on = (event, callback) => {
+  if (throws) throw new Error("on() is not implemented on web");
+};
+
+const off = (event, callback) => {
+  if (throws) throw new Error("off() is not implemented on web");
+};
+
+const nativeSdkVersion = () => {
+  return new Promise((resolve, reject) => { resolve(RadarJS.VERSION) });
+}
+
+const rnSdkVersion = () => VERSION;
+
+const Radar = {
+  initialize,
+  setLogLevel,
+  setUserId,
+  getUserId,
+  setDescription,
+  getDescription,
+  setMetadata,
+  getMetadata,
+  setAnonymousTrackingEnabled,
+  getPermissionsStatus,
+  requestPermissions,
+  getLocation,
+  trackOnce,
+  trackVerified,
+  getVerifiedLocationToken,
+  startTrackingEfficient,
+  startTrackingResponsive,
+  startTrackingContinuous,
+  startTrackingCustom,
+  startTrackingVerified,
+  mockTracking,
+  stopTracking,
+  stopTrackingVerified,
+  isTracking,
+  getTrackingOptions,
+  isUsingRemoteTrackingOptions,
+  setForegroundServiceOptions,
+  setNotificationOptions,
+  getTripOptions,
+  startTrip,
+  completeTrip,
+  cancelTrip,
+  updateTrip,
+  acceptEvent,
+  rejectEvent,
+  getContext,
+  searchPlaces,
+  searchGeofences,
+  autocomplete,
+  geocode,
+  reverseGeocode,
+  ipGeocode,
+  validateAddress,
+  getDistance,
+  getMatrix,
+  logConversion,
+  sendEvent,
+  on,
+  off,
+  nativeSdkVersion,
+  rnSdkVersion,
+
+  // only for web, these should be called via RadarRNWeb instead of Radar for typing
+  throwOnUnimplemented,
+  setDeviceId,
+  setDeviceType,
+  setRequestHeaders,
+};
+
+export default Radar;

package/{plugin/build/types.d.ts → src/plugin/types.ts}

@@ -9,4 +9,4 @@ export interface RadarPluginProps {
     androidActivityRecognition?: boolean;
     addRadarSDKMotion?: boolean;
     iosNSMotionUsageDescription?: string;
-}
+  }

package/src/plugin/withRadar.ts

@@ -0,0 +1,39 @@
+import {
+  ConfigPlugin,
+  createRunOncePlugin,
+  WarningAggregator,
+} from "expo/config-plugins";
+
+
+import { withRadarAndroid } from "./withRadarAndroid";
+import { withRadarIOS } from "./withRadarIOS";
+const pkg = require("../../../package.json");
+
+import type { RadarPluginProps } from "./types";
+
+const withRadarPlugin: ConfigPlugin<RadarPluginProps> = (config, args = {}) => {
+  try {
+    config = withRadarAndroid(config, args);
+  } catch (e) {
+    WarningAggregator.addWarningAndroid(
+      "react-native-radar",
+      "There was a problem configuring react-native-radar in your native Android project: " +
+        e
+    );
+  }
+  try {
+    config = withRadarIOS(config, args);
+  } catch (e) {
+    WarningAggregator.addWarningIOS(
+      "react-native-radar",
+      "There was a problem configuring react-native-radar in your native iOS project: " +
+        e
+    );
+  }
+
+  return config;
+};
+
+const withRadar = createRunOncePlugin(withRadarPlugin, pkg.name, pkg.version);
+
+export default withRadar;

package/src/plugin/withRadarAndroid.ts

@@ -0,0 +1,147 @@
+import { ExpoConfig } from "expo/config";
+
+import {
+  withAppBuildGradle,
+  AndroidConfig,
+  withDangerousMod,
+} from "expo/config-plugins";
+import fs from "fs";
+import path from "path";
+
+import { RadarPluginProps } from "./types";
+
+export const withRadarAndroid = (
+  config: ExpoConfig,
+  args: RadarPluginProps
+) => {
+  config = withAndroidPermissions(config, args);
+
+  config = withDangerousMod(config, [
+    "android",
+    async (config) => {
+      if (!args.androidFraud) {
+        return config;
+      }
+      // Get the path to the Android folder
+      const androidPath = path.join(
+        config.modRequest.projectRoot,
+        "android",
+        "app",
+        "src",
+        "main",
+        "res",
+        "xml"
+      );
+
+      // Check if the directory exists, if not, create it
+      if (!fs.existsSync(androidPath)) {
+        fs.mkdirSync(androidPath, { recursive: true });
+      }
+
+      // Create the path to the new file
+      const newFilePath = path.join(androidPath, "network_security_config.xml");
+
+      // Define xml content
+
+      const xml = `<?xml version="1.0" encoding="utf-8"?>
+      <network-security-config>
+          <!-- for React Native -->
+          <domain-config cleartextTrafficPermitted="true">
+              <domain includeSubdomains="true">localhost</domain>
+          </domain-config>
+      
+          <!-- for SSL pinning -->
+          <domain-config cleartextTrafficPermitted="false">
+              <domain includeSubdomains="true">api-verified.radar.io</domain>
+              <pin-set>
+                  <pin digest="SHA-256">15ktYXSSU2llpy7YyCgeqUKDBkjcimK/weUcec960sI=</pin>
+                  <pin digest="SHA-256">15ktYXSSU2llpy7YyCgeqUKDBkjcimK/weUcec960sI=</pin>
+              </pin-set>
+          </domain-config>
+      </network-security-config>`;
+
+      // Write to the new file
+      fs.writeFileSync(newFilePath, xml);
+
+      return config;
+    },
+  ]);
+
+  return withAppBuildGradle(config, (config) => {
+    if (config.modResults.language === "groovy") {
+      config.modResults.contents = modifyAppBuildGradle(
+        config.modResults.contents,
+        args.androidFraud ?? false
+      );
+    } else {
+      throw new Error(
+        "Cannot configure Sentry in the app gradle because the build.gradle is not groovy"
+      );
+    }
+    return config;
+  });
+};
+
+function withAndroidPermissions(
+  config: any,
+  args: RadarPluginProps
+): ExpoConfig {
+  const isAndroidBackgroundLocationEnabled = !!args.androidBackgroundPermission;
+  const enableAndroidForegroundService = !!args.androidForegroundService;
+  const enableAndroidActivityRecognition = !!args.androidActivityRecognition;
+  return AndroidConfig.Permissions.withPermissions(
+    config,
+    [
+      isAndroidBackgroundLocationEnabled &&
+        "android.permission.ACCESS_BACKGROUND_LOCATION",
+      enableAndroidForegroundService && "android.permission.FOREGROUND_SERVICE",
+      enableAndroidForegroundService &&
+        "android.permission.FOREGROUND_SERVICE_LOCATION",
+      enableAndroidActivityRecognition &&
+        "android.permission.ACTIVITY_RECOGNITION",
+    ].filter(Boolean) as string[]
+  );
+}
+
+function modifyAppBuildGradle(buildGradle: string, androidFraud: boolean) {
+  let hasLocationService = false;
+  let hasPlayIntegrity = false;
+  if (
+    buildGradle.includes(
+      'com.google.android.gms:play-services-location:21.0.1"'
+    )
+  ) {
+    hasLocationService = true;
+  }
+
+  if (buildGradle.includes('com.google.android.play:integrity:1.2.0"')) {
+    hasPlayIntegrity = true;
+  }
+
+  const pattern = /^dependencies {/m;
+
+  if (!buildGradle.match(pattern)) {
+    throw new Error(
+      `Failed to find react.gradle script in android/app/build.gradle.
+      This is required for react-native-radar to function properly.
+      Please ensure your android/app/build.gradle includes the react.gradle script.
+      Current build.gradle content: ${buildGradle}`
+    );
+  }
+
+  let replacementString =
+    "\n\n" +
+    (!hasLocationService
+      ? '    implementation "com.google.android.gms:play-services-location:21.0.1"'
+      : "");
+
+  if (androidFraud && !hasPlayIntegrity) {
+    replacementString +=
+      "\n\n" + '    implementation "com.google.android.play:integrity:1.2.0"';
+  }
+
+  return buildGradle.replace(
+    pattern,
+    (match: string) => match + replacementString
+  );
+}