initial commit taken from gitlab.lrz.de

node_modules/react-native/Libraries/Geolocation/Geolocation.js

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @providesModule Geolocation
+ * @flow
+ */
+'use strict';
+
+const NativeEventEmitter = require('NativeEventEmitter');
+const RCTLocationObserver = require('NativeModules').LocationObserver;
+
+const invariant = require('fbjs/lib/invariant');
+const logError = require('logError');
+/* $FlowFixMe(>=0.54.0 site=react_native_oss) This comment suppresses an error
+ * found when Flow v0.54 was deployed. To see the error delete this comment and
+ * run Flow. */
+const warning = require('fbjs/lib/warning');
+
+const LocationEventEmitter = new NativeEventEmitter(RCTLocationObserver);
+
+const Platform = require('Platform');
+const PermissionsAndroid = require('PermissionsAndroid');
+
+var subscriptions = [];
+var updatesEnabled = false;
+
+type GeoConfiguration = {
+  skipPermissionRequests: bool;
+}
+
+type GeoOptions = {
+  timeout?: number,
+  maximumAge?: number,
+  enableHighAccuracy?: bool,
+  distanceFilter: number,
+  useSignificantChanges?: bool,
+}
+
+/**
+ * The Geolocation API extends the web spec:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Geolocation
+ *
+ * See https://facebook.github.io/react-native/docs/geolocation.html
+ */
+var Geolocation = {
+
+  /*
+    * Sets configuration options that will be used in all location requests.
+    *
+    * See https://facebook.github.io/react-native/docs/geolocation.html#setrnconfiguration
+    *
+    */
+  setRNConfiguration: function(
+    config: GeoConfiguration
+  ) {
+    if (RCTLocationObserver.setConfiguration) {
+      RCTLocationObserver.setConfiguration(config);
+    }
+  },
+
+  /*
+   * Request suitable Location permission based on the key configured on pList.
+   *
+   * See https://facebook.github.io/react-native/docs/geolocation.html#requestauthorization
+   */
+  requestAuthorization: function() {
+    RCTLocationObserver.requestAuthorization();
+  },
+
+  /*
+   * Invokes the success callback once with the latest location info.
+   *
+   * See https://facebook.github.io/react-native/docs/geolocation.html#getcurrentposition
+   */
+  getCurrentPosition: async function(
+    geo_success: Function,
+    geo_error?: Function,
+    geo_options?: GeoOptions
+  ) {
+    invariant(
+      typeof geo_success === 'function',
+      'Must provide a valid geo_success callback.'
+    );
+    let hasPermission = true;
+    // Supports Android's new permission model. For Android older devices,
+    // it's always on.
+    if (Platform.OS === 'android' && Platform.Version >= 23) {
+      hasPermission = await PermissionsAndroid.check(
+        PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+      );
+      if (!hasPermission) {
+        const status = await PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+        );
+        hasPermission = status === PermissionsAndroid.RESULTS.GRANTED;
+      }
+    }
+    if (hasPermission) {
+      RCTLocationObserver.getCurrentPosition(
+        geo_options || {},
+        geo_success,
+        geo_error || logError,
+      );
+    }
+  },
+
+  /*
+   * Invokes the success callback whenever the location changes.
+   *
+   * See https://facebook.github.io/react-native/docs/geolocation.html#watchposition
+   */
+  watchPosition: function(success: Function, error?: Function, options?: GeoOptions): number {
+    if (!updatesEnabled) {
+      RCTLocationObserver.startObserving(options || {});
+      updatesEnabled = true;
+    }
+    var watchID = subscriptions.length;
+    subscriptions.push([
+      LocationEventEmitter.addListener(
+        'geolocationDidChange',
+        success
+      ),
+      error ? LocationEventEmitter.addListener(
+        'geolocationError',
+        error
+      ) : null,
+    ]);
+    return watchID;
+  },
+
+  clearWatch: function(watchID: number) {
+    var sub = subscriptions[watchID];
+    if (!sub) {
+      // Silently exit when the watchID is invalid or already cleared
+      // This is consistent with timers
+      return;
+    }
+
+    sub[0].remove();
+    // array element refinements not yet enabled in Flow
+    var sub1 = sub[1]; sub1 && sub1.remove();
+    subscriptions[watchID] = undefined;
+    var noWatchers = true;
+    for (var ii = 0; ii < subscriptions.length; ii++) {
+      if (subscriptions[ii]) {
+        noWatchers = false; // still valid subscriptions
+      }
+    }
+    if (noWatchers) {
+      Geolocation.stopObserving();
+    }
+  },
+
+  stopObserving: function() {
+    if (updatesEnabled) {
+      RCTLocationObserver.stopObserving();
+      updatesEnabled = false;
+      for (var ii = 0; ii < subscriptions.length; ii++) {
+        var sub = subscriptions[ii];
+        if (sub) {
+          warning(false, 'Called stopObserving with existing subscriptions.');
+          sub[0].remove();
+          // array element refinements not yet enabled in Flow
+          var sub1 = sub[1]; sub1 && sub1.remove();
+        }
+      }
+      subscriptions = [];
+    }
+  }
+};
+
+module.exports = Geolocation;

node_modules/react-native/Libraries/Geolocation/RCTGeolocation.xcodeproj/project.pbxproj

@@ -0,0 +1,236 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		134814061AA4E45400B7C361 /* RCTLocationObserver.m in Sources */ = {isa = PBXBuildFile; fileRef = 134814051AA4E45400B7C361 /* RCTLocationObserver.m */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		134814041AA4E45400B7C361 /* RCTLocationObserver.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = RCTLocationObserver.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
+		134814051AA4E45400B7C361 /* RCTLocationObserver.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = RCTLocationObserver.m; sourceTree = "<group>"; };
+		134814201AA4EA6300B7C361 /* libRCTGeolocation.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libRCTGeolocation.a; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+		134814211AA4EA7D00B7C361 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				134814201AA4EA6300B7C361 /* libRCTGeolocation.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		58B511D21A9E6C8500147676 = {
+			isa = PBXGroup;
+			children = (
+				134814041AA4E45400B7C361 /* RCTLocationObserver.h */,
+				134814051AA4E45400B7C361 /* RCTLocationObserver.m */,
+				134814211AA4EA7D00B7C361 /* Products */,
+			);
+			indentWidth = 2;
+			sourceTree = "<group>";
+			tabWidth = 2;
+			usesTabs = 0;
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		58B511DA1A9E6C8500147676 /* RCTGeolocation */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RCTGeolocation" */;
+			buildPhases = (
+				58B511D71A9E6C8500147676 /* Sources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = RCTGeolocation;
+			productName = RCTDataManager;
+			productReference = 134814201AA4EA6300B7C361 /* libRCTGeolocation.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		58B511D31A9E6C8500147676 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 0610;
+				ORGANIZATIONNAME = Facebook;
+				TargetAttributes = {
+					58B511DA1A9E6C8500147676 = {
+						CreatedOnToolsVersion = 6.1.1;
+					};
+				};
+			};
+			buildConfigurationList = 58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RCTGeolocation" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 58B511D21A9E6C8500147676;
+			productRefGroup = 58B511D21A9E6C8500147676;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58B511DA1A9E6C8500147676 /* RCTGeolocation */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		58B511D71A9E6C8500147676 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				134814061AA4E45400B7C361 /* RCTLocationObserver.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		58B511ED1A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Debug;
+		};
+		58B511EE1A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
+				GCC_WARN_SHADOW = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				VALIDATE_PRODUCT = YES;
+				WARNING_CFLAGS = (
+					"-Werror",
+					"-Wall",
+				);
+			};
+			name = Release;
+		};
+		58B511F01A9E6C8500147676 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				RUN_CLANG_STATIC_ANALYZER = YES;
+			};
+			name = Debug;
+		};
+		58B511F11A9E6C8500147676 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_STATIC_ANALYZER_MODE = deep;
+				LIBRARY_SEARCH_PATHS = "$(inherited)";
+				OTHER_LDFLAGS = "-ObjC";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		58B511D61A9E6C8500147676 /* Build configuration list for PBXProject "RCTGeolocation" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511ED1A9E6C8500147676 /* Debug */,
+				58B511EE1A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		58B511EF1A9E6C8500147676 /* Build configuration list for PBXNativeTarget "RCTGeolocation" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				58B511F01A9E6C8500147676 /* Debug */,
+				58B511F11A9E6C8500147676 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 58B511D31A9E6C8500147676 /* Project object */;
+}

node_modules/react-native/Libraries/Geolocation/RCTLocationObserver.h

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import <React/RCTEventEmitter.h>
+
+@interface RCTLocationObserver : RCTEventEmitter
+
+@end

node_modules/react-native/Libraries/Geolocation/RCTLocationObserver.m

@@ -0,0 +1,410 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#import "RCTLocationObserver.h"
+
+#import <CoreLocation/CLError.h>
+#import <CoreLocation/CLLocationManager.h>
+#import <CoreLocation/CLLocationManagerDelegate.h>
+
+#import <React/RCTAssert.h>
+#import <React/RCTBridge.h>
+#import <React/RCTConvert.h>
+#import <React/RCTEventDispatcher.h>
+#import <React/RCTLog.h>
+
+typedef NS_ENUM(NSInteger, RCTPositionErrorCode) {
+  RCTPositionErrorDenied = 1,
+  RCTPositionErrorUnavailable,
+  RCTPositionErrorTimeout,
+};
+
+#define RCT_DEFAULT_LOCATION_ACCURACY kCLLocationAccuracyHundredMeters
+
+typedef struct {
+  BOOL skipPermissionRequests;
+} RCTLocationConfiguration;
+
+typedef struct {
+  double timeout;
+  double maximumAge;
+  double accuracy;
+  double distanceFilter;
+  BOOL useSignificantChanges;
+} RCTLocationOptions;
+
+@implementation RCTConvert (RCTLocationOptions)
+
++ (RCTLocationConfiguration)RCTLocationConfiguration:(id)json
+{
+  NSDictionary<NSString *, id> *options = [RCTConvert NSDictionary:json];
+
+  return (RCTLocationConfiguration) {
+    .skipPermissionRequests = [RCTConvert BOOL:options[@"skipPermissionRequests"]]
+  };
+}
+
++ (RCTLocationOptions)RCTLocationOptions:(id)json
+{
+  NSDictionary<NSString *, id> *options = [RCTConvert NSDictionary:json];
+
+  double distanceFilter = options[@"distanceFilter"] == NULL ? RCT_DEFAULT_LOCATION_ACCURACY
+    : [RCTConvert double:options[@"distanceFilter"]] ?: kCLDistanceFilterNone;
+
+  return (RCTLocationOptions){
+    .timeout = [RCTConvert NSTimeInterval:options[@"timeout"]] ?: INFINITY,
+    .maximumAge = [RCTConvert NSTimeInterval:options[@"maximumAge"]] ?: INFINITY,
+    .accuracy = [RCTConvert BOOL:options[@"enableHighAccuracy"]] ? kCLLocationAccuracyBest : RCT_DEFAULT_LOCATION_ACCURACY,
+    .distanceFilter = distanceFilter,
+    .useSignificantChanges = [RCTConvert BOOL:options[@"useSignificantChanges"]] ?: NO,
+  };
+}
+
+@end
+
+static NSDictionary<NSString *, id> *RCTPositionError(RCTPositionErrorCode code, NSString *msg /* nil for default */)
+{
+  if (!msg) {
+    switch (code) {
+      case RCTPositionErrorDenied:
+        msg = @"User denied access to location services.";
+        break;
+      case RCTPositionErrorUnavailable:
+        msg = @"Unable to retrieve location.";
+        break;
+      case RCTPositionErrorTimeout:
+        msg = @"The location request timed out.";
+        break;
+    }
+  }
+
+  return @{
+    @"code": @(code),
+    @"message": msg,
+    @"PERMISSION_DENIED": @(RCTPositionErrorDenied),
+    @"POSITION_UNAVAILABLE": @(RCTPositionErrorUnavailable),
+    @"TIMEOUT": @(RCTPositionErrorTimeout)
+  };
+}
+
+@interface RCTLocationRequest : NSObject
+
+@property (nonatomic, copy) RCTResponseSenderBlock successBlock;
+@property (nonatomic, copy) RCTResponseSenderBlock errorBlock;
+@property (nonatomic, assign) RCTLocationOptions options;
+@property (nonatomic, strong) NSTimer *timeoutTimer;
+
+@end
+
+@implementation RCTLocationRequest
+
+- (void)dealloc
+{
+  if (_timeoutTimer.valid) {
+    [_timeoutTimer invalidate];
+  }
+}
+
+@end
+
+@interface RCTLocationObserver () <CLLocationManagerDelegate>
+
+@end
+
+@implementation RCTLocationObserver
+{
+  CLLocationManager *_locationManager;
+  NSDictionary<NSString *, id> *_lastLocationEvent;
+  NSMutableArray<RCTLocationRequest *> *_pendingRequests;
+  BOOL _observingLocation;
+  BOOL _usingSignificantChanges;
+  RCTLocationConfiguration _locationConfiguration;
+  RCTLocationOptions _observerOptions;
+}
+
+RCT_EXPORT_MODULE()
+
+#pragma mark - Lifecycle
+
+- (void)dealloc
+{
+  _usingSignificantChanges ?
+    [_locationManager stopMonitoringSignificantLocationChanges] :
+    [_locationManager stopUpdatingLocation];
+
+  _locationManager.delegate = nil;
+}
+
+- (dispatch_queue_t)methodQueue
+{
+  return dispatch_get_main_queue();
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[@"geolocationDidChange", @"geolocationError"];
+}
+
+#pragma mark - Private API
+
+- (void)beginLocationUpdatesWithDesiredAccuracy:(CLLocationAccuracy)desiredAccuracy distanceFilter:(CLLocationDistance)distanceFilter useSignificantChanges:(BOOL)useSignificantChanges
+{
+  if (!_locationConfiguration.skipPermissionRequests) {
+    [self requestAuthorization];
+  }
+  
+  if (!_locationManager) {
+    _locationManager = [CLLocationManager new];
+    _locationManager.delegate = self;
+  }
+
+  _locationManager.distanceFilter  = distanceFilter;
+  _locationManager.desiredAccuracy = desiredAccuracy;
+  _usingSignificantChanges = useSignificantChanges;
+
+  // Start observing location
+  _usingSignificantChanges ?
+    [_locationManager startMonitoringSignificantLocationChanges] :
+    [_locationManager startUpdatingLocation];
+}
+
+#pragma mark - Timeout handler
+
+- (void)timeout:(NSTimer *)timer
+{
+  RCTLocationRequest *request = timer.userInfo;
+  NSString *message = [NSString stringWithFormat: @"Unable to fetch location within %.1fs.", request.options.timeout];
+  request.errorBlock(@[RCTPositionError(RCTPositionErrorTimeout, message)]);
+  [_pendingRequests removeObject:request];
+
+  // Stop updating if no pending requests
+  if (_pendingRequests.count == 0 && !_observingLocation) {
+    _usingSignificantChanges ?
+      [_locationManager stopMonitoringSignificantLocationChanges] :
+      [_locationManager stopUpdatingLocation];
+  }
+}
+
+#pragma mark - Public API
+
+RCT_EXPORT_METHOD(setConfiguration:(RCTLocationConfiguration)config)
+{
+  _locationConfiguration = config;
+}
+
+RCT_EXPORT_METHOD(requestAuthorization)
+{
+  if (!_locationManager) {
+    _locationManager = [CLLocationManager new];
+    _locationManager.delegate = self;
+  }
+
+  // Request location access permission
+  if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationAlwaysUsageDescription"] &&
+    [_locationManager respondsToSelector:@selector(requestAlwaysAuthorization)]) {
+    [_locationManager requestAlwaysAuthorization];
+
+    // On iOS 9+ we also need to enable background updates
+    NSArray *backgroundModes  = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"UIBackgroundModes"];
+    if (backgroundModes && [backgroundModes containsObject:@"location"]) {
+      if ([_locationManager respondsToSelector:@selector(setAllowsBackgroundLocationUpdates:)]) {
+        [_locationManager setAllowsBackgroundLocationUpdates:YES];
+      }
+    }
+  } else if ([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationWhenInUseUsageDescription"] &&
+    [_locationManager respondsToSelector:@selector(requestWhenInUseAuthorization)]) {
+    [_locationManager requestWhenInUseAuthorization];
+  }
+}
+
+RCT_EXPORT_METHOD(startObserving:(RCTLocationOptions)options)
+{
+  checkLocationConfig();
+
+  // Select best options
+  _observerOptions = options;
+  for (RCTLocationRequest *request in _pendingRequests) {
+    _observerOptions.accuracy = MIN(_observerOptions.accuracy, request.options.accuracy);
+  }
+
+  [self beginLocationUpdatesWithDesiredAccuracy:_observerOptions.accuracy
+                                 distanceFilter:_observerOptions.distanceFilter
+                          useSignificantChanges:_observerOptions.useSignificantChanges];
+  _observingLocation = YES;
+}
+
+RCT_EXPORT_METHOD(stopObserving)
+{
+  // Stop observing
+  _observingLocation = NO;
+
+  // Stop updating if no pending requests
+  if (_pendingRequests.count == 0) {
+    _usingSignificantChanges ?
+      [_locationManager stopMonitoringSignificantLocationChanges] :
+      [_locationManager stopUpdatingLocation];
+  }
+}
+
+RCT_EXPORT_METHOD(getCurrentPosition:(RCTLocationOptions)options
+                  withSuccessCallback:(RCTResponseSenderBlock)successBlock
+                  errorCallback:(RCTResponseSenderBlock)errorBlock)
+{
+  checkLocationConfig();
+
+  if (!successBlock) {
+    RCTLogError(@"%@.getCurrentPosition called with nil success parameter.", [self class]);
+    return;
+  }
+
+  if (![CLLocationManager locationServicesEnabled]) {
+    if (errorBlock) {
+      errorBlock(@[
+        RCTPositionError(RCTPositionErrorUnavailable, @"Location services disabled.")
+      ]);
+      return;
+    }
+  }
+
+  if ([CLLocationManager authorizationStatus] == kCLAuthorizationStatusDenied) {
+    if (errorBlock) {
+      errorBlock(@[
+        RCTPositionError(RCTPositionErrorDenied, nil)
+      ]);
+      return;
+    }
+  }
+
+  // Check if previous recorded location exists and is good enough
+  if (_lastLocationEvent &&
+      [NSDate date].timeIntervalSince1970 - [RCTConvert NSTimeInterval:_lastLocationEvent[@"timestamp"]] < options.maximumAge &&
+      [_lastLocationEvent[@"coords"][@"accuracy"] doubleValue] <= options.accuracy) {
+
+    // Call success block with most recent known location
+    successBlock(@[_lastLocationEvent]);
+    return;
+  }
+
+  // Create request
+  RCTLocationRequest *request = [RCTLocationRequest new];
+  request.successBlock = successBlock;
+  request.errorBlock = errorBlock ?: ^(NSArray *args){};
+  request.options = options;
+  request.timeoutTimer = [NSTimer scheduledTimerWithTimeInterval:options.timeout
+                                                          target:self
+                                                        selector:@selector(timeout:)
+                                                        userInfo:request
+                                                         repeats:NO];
+  if (!_pendingRequests) {
+    _pendingRequests = [NSMutableArray new];
+  }
+  [_pendingRequests addObject:request];
+
+  // Configure location manager and begin updating location
+  CLLocationAccuracy accuracy = options.accuracy;
+  if (_locationManager) {
+    accuracy = MIN(_locationManager.desiredAccuracy, accuracy);
+  }
+  [self beginLocationUpdatesWithDesiredAccuracy:accuracy
+                                 distanceFilter:options.distanceFilter
+                          useSignificantChanges:options.useSignificantChanges];
+}
+
+#pragma mark - CLLocationManagerDelegate
+
+- (void)locationManager:(CLLocationManager *)manager
+     didUpdateLocations:(NSArray<CLLocation *> *)locations
+{
+  // Create event
+  CLLocation *location = locations.lastObject;
+  _lastLocationEvent = @{
+    @"coords": @{
+      @"latitude": @(location.coordinate.latitude),
+      @"longitude": @(location.coordinate.longitude),
+      @"altitude": @(location.altitude),
+      @"accuracy": @(location.horizontalAccuracy),
+      @"altitudeAccuracy": @(location.verticalAccuracy),
+      @"heading": @(location.course),
+      @"speed": @(location.speed),
+    },
+    @"timestamp": @([location.timestamp timeIntervalSince1970] * 1000) // in ms
+  };
+
+  // Send event
+  if (_observingLocation) {
+    [self sendEventWithName:@"geolocationDidChange" body:_lastLocationEvent];
+  }
+
+  // Fire all queued callbacks
+  for (RCTLocationRequest *request in _pendingRequests) {
+    request.successBlock(@[_lastLocationEvent]);
+    [request.timeoutTimer invalidate];
+  }
+  [_pendingRequests removeAllObjects];
+
+  // Stop updating if not observing
+  if (!_observingLocation) {
+    _usingSignificantChanges ?
+      [_locationManager stopMonitoringSignificantLocationChanges] :
+      [_locationManager stopUpdatingLocation];
+  }
+
+  // Reset location accuracy if desiredAccuracy is changed.
+  // Otherwise update accuracy will force triggering didUpdateLocations, watchPosition would keeping receiving location updates, even there's no location changes.
+  if (ABS(_locationManager.desiredAccuracy - RCT_DEFAULT_LOCATION_ACCURACY) > 0.000001) {
+    _locationManager.desiredAccuracy = RCT_DEFAULT_LOCATION_ACCURACY;
+  }
+}
+
+- (void)locationManager:(CLLocationManager *)manager didFailWithError:(NSError *)error
+{
+  // Check error type
+  NSDictionary<NSString *, id> *jsError = nil;
+  switch (error.code) {
+    case kCLErrorDenied:
+      jsError = RCTPositionError(RCTPositionErrorDenied, nil);
+      break;
+    case kCLErrorNetwork:
+      jsError = RCTPositionError(RCTPositionErrorUnavailable, @"Unable to retrieve location due to a network failure");
+      break;
+    case kCLErrorLocationUnknown:
+    default:
+      jsError = RCTPositionError(RCTPositionErrorUnavailable, nil);
+      break;
+  }
+
+  // Send event
+  if (_observingLocation) {
+    [self sendEventWithName:@"geolocationError" body:jsError];
+  }
+
+  // Fire all queued error callbacks
+  for (RCTLocationRequest *request in _pendingRequests) {
+    request.errorBlock(@[jsError]);
+    [request.timeoutTimer invalidate];
+  }
+  [_pendingRequests removeAllObjects];
+
+  // Reset location accuracy if desiredAccuracy is changed.
+  // Otherwise update accuracy will force triggering didUpdateLocations, watchPosition would keeping receiving location updates, even there's no location changes.
+  if (ABS(_locationManager.desiredAccuracy - RCT_DEFAULT_LOCATION_ACCURACY) > 0.000001) {
+    _locationManager.desiredAccuracy = RCT_DEFAULT_LOCATION_ACCURACY;
+  }
+}
+
+static void checkLocationConfig()
+{
+#if RCT_DEV
+  if (!([[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationWhenInUseUsageDescription"] ||
+    [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationAlwaysUsageDescription"] ||
+    [[NSBundle mainBundle] objectForInfoDictionaryKey:@"NSLocationAlwaysAndWhenInUseUsageDescription"])) {
+    RCTLogError(@"Either NSLocationWhenInUseUsageDescription or NSLocationAlwaysUsageDescription or NSLocationAlwaysAndWhenInUseUsageDescription key must be present in Info.plist to use geolocation.");
+  }
+#endif
+}
+
+@end