@mapvina-com/mapvina-react-native 1.0.0

package/ios/components/user-location/MLRNNativeUserLocationComponentView.mm

@@ -0,0 +1,51 @@
+#import "MLRNNativeUserLocationComponentView.h"
+
+#import <react/renderer/components/MapVinaReactNativeSpec/ComponentDescriptors.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/Props.h>
+#import <react/renderer/components/MapVinaReactNativeSpec/RCTComponentViewHelpers.h>
+
+#import "MLRNNativeUserLocation.h"
+
+using namespace facebook::react;
+
+@interface MLRNNativeUserLocationComponentView () <RCTMLRNNativeUserLocationViewProtocol>
+
+@end
+
+@implementation MLRNNativeUserLocationComponentView {
+  MLRNNativeUserLocation *_view;
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps = std::make_shared<const MLRNNativeUserLocationProps>();
+    _props = defaultProps;
+    [self prepareView];
+  }
+
+  return self;
+}
+
+- (void)prepareView {
+  _view = [[MLRNNativeUserLocation alloc] init];
+  self.contentView = _view;
+}
+
+#pragma mark - RCTComponentViewProtocol
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps {
+  const auto &oldViewProps = *std::static_pointer_cast<MLRNNativeUserLocationProps const>(_props);
+  const auto &newViewProps = *std::static_pointer_cast<MLRNNativeUserLocationProps const>(props);
+
+  if (oldViewProps.mode != newViewProps.mode) {
+    [_view setShowsUserHeadingIndicator:newViewProps.mode != MLRNNativeUserLocationMode::Default];
+  }
+
+  [super updateProps:props oldProps:oldProps];
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<MLRNNativeUserLocationComponentDescriptor>();
+}
+
+@end

package/ios/components/user-location/MLRNUserLocation.h

@@ -0,0 +1,15 @@
+//
+//  MLRNUserLocation.h
+//  MLRN
+
+#import <CoreLocation/CoreLocation.h>
+#import <Foundation/Foundation.h>
+#import <MapVina/MLNUserLocationAnnotationView.h>
+
+@interface MLRNUserLocation : NSObject
+
++ (id)sharedInstance;
+
+- (MLNUserLocationAnnotationView*)hiddenUserAnnotation;
+
+@end

package/ios/components/user-location/MLRNUserLocation.m

@@ -0,0 +1,36 @@
+//
+//  MLRNUserLocation.m
+//  MLRN
+//
+
+#import "MLRNUserLocation.h"
+#import <MapVina/MLNUserLocationAnnotationView.h>
+
+@interface HiddenUserLocationAnnotationView : MLNUserLocationAnnotationView
+
+@end
+
+@implementation HiddenUserLocationAnnotationView
+
+- (void)update {
+  self.frame = CGRectNull;
+}
+
+@end
+
+@implementation MLRNUserLocation : NSObject
+
++ (id)sharedInstance {
+  static MLRNUserLocation *userLocation = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    userLocation = [[self alloc] init];
+  });
+  return userLocation;
+}
+
+- (MLNUserLocationAnnotationView *)hiddenUserAnnotation {
+  return [[HiddenUserLocationAnnotationView alloc] init];
+}
+
+@end

package/ios/modules/location/MLRNLocation.h

@@ -0,0 +1,10 @@
+#import <CoreLocation/CoreLocation.h>
+
+@interface MLRNLocation : NSObject
+
+@property (nonatomic, strong) CLLocation *location;
+@property (nonatomic, strong) CLHeading *heading;
+
+- (NSDictionary<NSString *, id> *)toJSON;
+
+@end

package/ios/modules/location/MLRNLocation.m

@@ -0,0 +1,26 @@
+#import "MLRNLocation.h"
+
+@implementation MLRNLocation
+
+- (id)numberOrNull:(double)value {
+  return value < 0 ? [NSNull null] : @(value);
+}
+
+- (NSDictionary<NSString *, id> *)toJSON {
+  double altitudeAccuracy = _location.verticalAccuracy;
+
+  return @{
+    @"coords" : @{
+      @"longitude" : @(_location.coordinate.longitude),
+      @"latitude" : @(_location.coordinate.latitude),
+      @"accuracy" : @(_location.horizontalAccuracy),
+      @"altitude" : altitudeAccuracy < 0 ? [NSNull null] : @(_location.altitude),
+      @"altitudeAccuracy" : [self numberOrNull:altitudeAccuracy],
+      @"heading" : [self numberOrNull:_location.course],
+      @"speed" : [self numberOrNull:_location.speed]
+    },
+    @"timestamp" : @([_location.timestamp timeIntervalSince1970])
+  };
+}
+
+@end

package/ios/modules/location/MLRNLocationManager.h

@@ -0,0 +1,20 @@
+#import "MLRNLocation.h"
+#import "MLRNLocationManagerDelegate.h"
+
+typedef void (^MLRNLocationBlock)(MLRNLocation *location);
+typedef void (^MLRNPermissionsBlock)(BOOL granted);
+
+@interface MLRNLocationManager : NSObject
+
+@property (nonatomic, strong) id<MLRNLocationManagerDelegate> delegate;
+
++ (id)sharedInstance;
+
+- (void)start;
+- (void)stop;
+- (void)setMinDisplacement:(CLLocationDistance)minDisplacement;
+- (BOOL)isEnabled;
+- (MLRNLocation *)getLastKnownLocation;
+- (void)requestPermissions:(MLRNPermissionsBlock)completion;
+
+@end

package/ios/modules/location/MLRNLocationManager.m

@@ -0,0 +1,167 @@
+#import "MLRNLocationManager.h"
+#import <CoreLocation/CoreLocation.h>
+
+@interface MLRNLocationManager () <CLLocationManagerDelegate>
+@end
+
+@implementation MLRNLocationManager {
+  CLLocationManager *locationManager;
+  CLLocation *lastKnownLocation;
+  CLHeading *lastKnownHeading;
+  CLLocationDistance displacement;
+  BOOL isListening;
+  MLRNPermissionsBlock permissionsCompletionBlock;
+}
+
++ (id)sharedInstance {
+  static MLRNLocationManager *manager = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    manager = [[self alloc] init];
+  });
+  return manager;
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    [self _setupLocationManager];
+    displacement = 0.0;
+  }
+  return self;
+}
+
+- (void)dealloc {
+  locationManager.delegate = nil;
+  [self stop];
+}
+
+- (void)start {
+  if ([self isEnabled]) {
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self->locationManager requestWhenInUseAuthorization];
+    [self->locationManager startUpdatingLocation];
+    [self->locationManager startUpdatingHeading];
+    self->isListening = YES;
+  });
+}
+
+- (void)requestPermissions:(MLRNPermissionsBlock)completion {
+  dispatch_async(dispatch_get_main_queue(), ^{
+    CLAuthorizationStatus status = self->locationManager.authorizationStatus;
+
+    if (status == kCLAuthorizationStatusAuthorizedWhenInUse ||
+        status == kCLAuthorizationStatusAuthorizedAlways) {
+      if (completion) {
+        completion(YES);
+      }
+
+      return;
+    }
+
+    if (status == kCLAuthorizationStatusDenied || status == kCLAuthorizationStatusRestricted) {
+      if (completion) {
+        completion(NO);
+      }
+
+      return;
+    }
+
+    self->permissionsCompletionBlock = completion;
+    [self->locationManager requestWhenInUseAuthorization];
+  });
+}
+
+- (void)setMinDisplacement:(CLLocationDistance)minDisplacement {
+  displacement = minDisplacement;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self->locationManager setDistanceFilter:(minDisplacement)];
+  });
+}
+
+- (void)stop {
+  if (![self isEnabled]) {
+    return;
+  }
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    [self->locationManager stopUpdatingLocation];
+    [self->locationManager stopUpdatingHeading];
+    self->isListening = NO;
+  });
+}
+
+- (BOOL)isEnabled {
+  return isListening;
+}
+
+- (MLRNLocation *)getLastKnownLocation {
+  CLLocation *newLastLocation = locationManager.location;
+  if (newLastLocation) {
+    lastKnownLocation = newLastLocation;
+  }
+  MLRNLocation *location = [self _convertToMLRNLocation:lastKnownLocation];
+  return location;
+}
+
+- (void)locationManager:(CLLocationManager *)manager didUpdateHeading:(CLHeading *)heading {
+  lastKnownHeading = heading;
+
+  if (displacement > 0) {
+    return;
+  }
+
+  [self _updateDelegate];
+}
+
+- (void)locationManager:(CLLocationManager *)manager
+     didUpdateLocations:(NSArray<CLLocation *> *)locations {
+  lastKnownLocation = [locations lastObject];
+  [self _updateDelegate];
+}
+
+- (void)locationManagerDidChangeAuthorization:(CLLocationManager *)manager {
+  if (permissionsCompletionBlock) {
+    CLAuthorizationStatus status = manager.authorizationStatus;
+
+    BOOL granted = (status == kCLAuthorizationStatusAuthorizedWhenInUse ||
+                    status == kCLAuthorizationStatusAuthorizedAlways);
+    permissionsCompletionBlock(granted);
+    permissionsCompletionBlock = nil;
+  }
+}
+
+- (void)_setupLocationManager {
+  __weak MLRNLocationManager *weakSelf = self;
+
+  dispatch_async(dispatch_get_main_queue(), ^{
+    self->locationManager = [[CLLocationManager alloc] init];
+    self->locationManager.delegate = weakSelf;
+  });
+}
+
+- (void)_updateDelegate {
+  if (_delegate == nil) {
+    return;
+  }
+
+  MLRNLocation *userLocation = [self _convertToMLRNLocation:lastKnownLocation];
+
+  [_delegate locationManager:self didUpdateLocation:userLocation];
+}
+
+- (MLRNLocation *)_convertToMLRNLocation:(CLLocation *)location {
+  if (location == nil) {
+    return nil;
+  }
+
+  MLRNLocation *userLocation = [[MLRNLocation alloc] init];
+  userLocation.location = location;
+  userLocation.heading = lastKnownHeading;
+  return userLocation;
+}
+
+@end

package/ios/modules/location/MLRNLocationManagerDelegate.h

@@ -0,0 +1,10 @@
+#import "MLRNLocation.h"
+
+@class MLRNLocationManager;
+
+@protocol MLRNLocationManagerDelegate <NSObject>
+
+- (void)locationManager:(MLRNLocationManager *)locationManager
+      didUpdateLocation:(MLRNLocation *)location;
+
+@end

package/ios/modules/location/MLRNLocationModule.h

@@ -0,0 +1,7 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+#import "MLRNLocationManagerDelegate.h"
+
+@interface MLRNLocationModule
+    : NativeLocationModuleSpecBase <NativeLocationModuleSpec, MLRNLocationManagerDelegate>
+@end

package/ios/modules/location/MLRNLocationModule.mm

@@ -0,0 +1,67 @@
+#import "MLRNLocationModule.h"
+#import "MLRNEventTypes.h"
+#import "MLRNLocation.h"
+#import "MLRNLocationManager.h"
+#import "MLRNLocationManagerDelegate.h"
+
+@implementation MLRNLocationModule {
+  MLRNLocationManager *locationManager;
+}
+
++ (NSString *)moduleName {
+  return @"MLRNLocationModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeLocationModuleSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    locationManager = [[MLRNLocationManager alloc] init];
+    locationManager.delegate = self;
+  }
+
+  return self;
+}
+
+- (void)start {
+  [locationManager start];
+}
+
+- (void)pause {
+  [locationManager stop];
+}
+
+- (void)stop {
+  [locationManager stop];
+}
+
+- (void)setMinDisplacement:(CLLocationDistance)minDisplacement {
+  [locationManager setMinDisplacement:minDisplacement];
+}
+
+- (void)getCurrentPosition:(nonnull RCTPromiseResolveBlock)resolve
+                    reject:(nonnull RCTPromiseRejectBlock)reject {
+  MLRNLocation *lastKnownLocation = [locationManager getLastKnownLocation];
+  resolve(lastKnownLocation);
+}
+
+- (void)requestPermissions:(nonnull RCTPromiseResolveBlock)resolve
+                    reject:(nonnull RCTPromiseRejectBlock)reject {
+  [locationManager requestPermissions:^(BOOL granted) {
+    if (granted) {
+      resolve(nil);
+    } else {
+      reject(@"requestPermissions", @"Request denied", nil);
+    }
+  }];
+}
+
+- (void)locationManager:(MLRNLocationManager *)locationManager
+      didUpdateLocation:(MLRNLocation *)location {
+  [self emitOnUpdate:[location toJSON]];
+}
+
+@end

package/ios/modules/logging/MLRNLogModule.h

@@ -0,0 +1,10 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+#import "MLRNLogging.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNLogModule : NativeLogModuleSpecBase <NativeLogModuleSpec, MLRNLoggingDelegate>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/modules/logging/MLRNLogModule.mm

@@ -0,0 +1,39 @@
+#import "MLRNLogModule.h"
+
+#import "MLRNLogging.h"
+
+@implementation MLRNLogModule {
+  MLRNLogging *logging;
+}
+
++ (NSString *)moduleName {
+  return @"MLRNLogModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeLogModuleSpecJSI>(params);
+}
+
+- (instancetype)init {
+  if (self = [super init]) {
+    logging = [[MLRNLogging alloc] init];
+    logging.delegate = self;
+  }
+
+  return self;
+}
+
+- (void)setLogLevel:(NSString *)logLevel {
+  [logging setLogLevel:logLevel];
+}
+
+- (void)logging:(nonnull id)logging
+    didReceiveLogWithLevel:(nonnull NSString *)level
+                  filePath:(nonnull NSString *)filePath
+                      line:(NSUInteger)line
+                   message:(nonnull NSString *)message {
+  [self emitOnLog:@{@"level" : level, @"tag" : filePath, @"message" : message}];
+}
+
+@end

package/ios/modules/logging/MLRNLogging.h

@@ -0,0 +1,27 @@
+#import <Foundation/Foundation.h>
+
+@class MLNLoggingConfiguration;
+
+@protocol MLRNLoggingDelegate <NSObject>
+
+- (void)logging:(nonnull id)logging
+    didReceiveLogWithLevel:(nonnull NSString*)level
+
+                  filePath:(nonnull NSString*)filePath
+                      line:(NSUInteger)line
+                   message:(nonnull NSString*)message;
+
+@end
+
+@interface MLRNLogging : NSObject
+
+@property (nonatomic, nonnull) MLNLoggingConfiguration* loggingConfiguration;
+@property (nonatomic, weak, nullable) id<MLRNLoggingDelegate> delegate;
+
+- (void)setLogLevel:(nonnull NSString*)logLevel;
+
+- (void)forwardLog:(nonnull NSString*)level
+               tag:(nonnull NSString*)tag
+           message:(nonnull NSString*)message;
+
+@end

package/ios/modules/logging/MLRNLogging.m

@@ -0,0 +1,102 @@
+#import "MLRNLogging.h"
+
+@import MapVina;
+
+@implementation MLRNLogging
+
++ (id)allocWithZone:(NSZone *)zone {
+  static MLRNLogging *sharedInstance = nil;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    sharedInstance = [super allocWithZone:zone];
+  });
+  return sharedInstance;
+}
+
+- (id)init {
+  if (self = [super init]) {
+    self.loggingConfiguration = [MLNLoggingConfiguration sharedConfiguration];
+    [self.loggingConfiguration setLoggingLevel:MLNLoggingLevelWarning];
+    __weak typeof(self) weakSelf = self;
+    self.loggingConfiguration.handler =
+        ^(MLNLoggingLevel loggingLevel, NSString *filePath, NSUInteger line, NSString *message) {
+          [weakSelf sendLogWithLevel:loggingLevel filePath:filePath line:line message:message];
+        };
+  }
+  return self;
+}
+
+- (void)sendLogWithLevel:(MLNLoggingLevel)loggingLevel
+                filePath:(NSString *)filePath
+                    line:(NSUInteger)line
+                 message:(NSString *)message {
+  NSString *level = @"unknown";
+  switch (loggingLevel) {
+    case MLNLoggingLevelNone:
+      level = @"none";
+      break;
+    case MLNLoggingLevelFault:
+      level = @"fault";
+      break;
+    case MLNLoggingLevelError:
+      level = @"error";
+      break;
+    case MLNLoggingLevelWarning:
+      level = @"warn";
+      break;
+    case MLNLoggingLevelInfo:
+      level = @"info";
+      break;
+#if MLN_LOGGING_ENABLE_DEBUG
+    case MLNLoggingLevelDebug:
+      level = @"debug";
+      break;
+#endif
+    case MLNLoggingLevelVerbose:
+      level = @"verbose";
+      break;
+  }
+
+  if (self.delegate) {
+    [self.delegate logging:self
+        didReceiveLogWithLevel:level
+                      filePath:filePath
+                          line:line
+                       message:message];
+  }
+}
+
+- (void)forwardLog:(nonnull NSString *)level
+               tag:(nonnull NSString *)tag
+           message:(nonnull NSString *)message {
+  if (self.delegate) {
+    [self.delegate logging:self didReceiveLogWithLevel:level filePath:tag line:0 message:message];
+  }
+}
+
+- (void)setLogLevel:(nonnull NSString *)logLevel {
+  MLNLoggingLevel mlnLogLevel = MLNLoggingLevelNone;
+  if ([logLevel isEqualToString:@"none"]) {
+    mlnLogLevel = MLNLoggingLevelNone;
+  } else if ([logLevel isEqualToString:@"fault"]) {
+    mlnLogLevel = MLNLoggingLevelFault;
+  } else if ([logLevel isEqualToString:@"error"]) {
+    mlnLogLevel = MLNLoggingLevelError;
+  } else if ([logLevel isEqualToString:@"warn"]) {
+    mlnLogLevel = MLNLoggingLevelWarning;
+  } else if ([logLevel isEqualToString:@"info"]) {
+    mlnLogLevel = MLNLoggingLevelInfo;
+  } else if ([logLevel isEqualToString:@"debug"]) {
+#if MLN_LOGGING_ENABLE_DEBUG
+    mlnLogLevel = MLNLoggingLevelDebug;
+#else
+    mlnLogLevel = MLNLoggingLevelVerbose;
+#endif
+  } else if ([logLevel isEqualToString:@"verbose"]) {
+    mlnLogLevel = MLNLoggingLevelVerbose;
+  }
+
+  [self.loggingConfiguration setLoggingLevel:mlnLogLevel];
+}
+
+@end

package/ios/modules/network/MLRNNetworkModule.h

@@ -0,0 +1,8 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface MLRNNetworkModule : NativeNetworkModuleSpecBase <NativeNetworkModuleSpec>
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/modules/network/MLRNNetworkModule.mm

@@ -0,0 +1,18 @@
+#import "MLRNNetworkModule.h"
+
+@implementation MLRNNetworkModule
+
++ (NSString *)moduleName {
+  return @"MLRNNetworkModule";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeNetworkModuleSpecJSI>(params);
+}
+
+- (void)setConnected:(BOOL)connected {
+  // Android only
+}
+
+@end

package/ios/modules/offline/MLRNOfflineModule.h

@@ -0,0 +1,7 @@
+#import <MapVinaReactNativeSpec/MapVinaReactNativeSpec.h>
+
+#import <React/RCTInitializing.h>
+
+@interface MLRNOfflineModule : NativeOfflineModuleSpecBase <NativeOfflineModuleSpec>
+
+@end