react-native-nitro-background-geolocation 0.1.0

package/ios/common/BackgroundGeolocation/SOMotionDetector/SOMotionDetector.m

@@ -0,0 +1,327 @@
+//
+//  MotionDetecter.m
+//  MotionDetection
+//
+// The MIT License (MIT)
+//
+// Created by : arturdev
+// Copyright (c) 2014 SocialObjects Software. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+
+#import "SOMotionDetector.h"
+
+CGFloat kMinimumSpeed        = 0.3f;
+CGFloat kMaximumWalkingSpeed = 1.9f;
+CGFloat kMaximumRunningSpeed = 7.5f;
+CGFloat kMinimumRunningAcceleration = 3.5f;
+
+@interface SOMotionDetector()
+
+@property (strong, nonatomic) NSTimer *shakeDetectingTimer;
+
+@property (strong, nonatomic) CLLocation *currentLocation;
+@property (nonatomic) SOMotionType previousMotionType;
+
+#pragma mark - Accelerometer manager
+@property (strong, nonatomic) CMMotionManager *motionManager;
+@property (strong, nonatomic) CMMotionActivityManager *motionActivityManager;
+
+
+@end
+
+@implementation SOMotionDetector
+
++ (SOMotionDetector *)sharedInstance
+{
+    static SOMotionDetector *instance = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] init];
+    });
+    
+    return instance;
+}
+
+- (id)init
+{
+    self = [super init];
+    if (self) {
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleLocationChangedNotification:)
+                                                     name:LOCATION_DID_CHANGED_NOTIFICATION
+                                                   object:nil];
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(handleLocationWasPausedNotification:)
+                                                     name:LOCATION_WAS_PAUSED_NOTIFICATION
+                                                   object:nil];
+        self.activityDetectionInterval = 0.01f;
+        self.motionManager = [[CMMotionManager alloc] init];
+        _motionActivity = [[SOMotionActivity alloc] init];
+    }
+    
+    return self;
+}
+
++ (BOOL)motionHardwareAvailable
+{
+    static BOOL isAvailable = NO;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        isAvailable = [CMMotionActivityManager isActivityAvailable];
+    });
+    
+    return isAvailable;
+}
+
+#pragma mark - Public Methods
+- (void)startDetection
+{
+
+    [self.motionManager startAccelerometerUpdatesToQueue:[[NSOperationQueue alloc] init]
+                                             withHandler:^(CMAccelerometerData *accelerometerData, NSError *error)
+     {
+         _acceleration = accelerometerData.acceleration;
+         [self calculateMotionType];
+         dispatch_async(dispatch_get_main_queue(), ^{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+             if (self.delegate && [self.delegate respondsToSelector:@selector(motionDetector:accelerationChanged:)]) {
+                 [self.delegate motionDetector:self accelerationChanged:self.acceleration];
+             }
+#pragma GCC diagnostic pop
+             
+             
+             if (self.accelerationChangedBlock) {
+                 self.accelerationChangedBlock (self.acceleration);
+             }
+         });
+     }];
+
+    if (self.useM7IfAvailable && [SOMotionDetector motionHardwareAvailable]) {
+        if (!self.motionActivityManager) {
+            self.motionActivityManager = [[CMMotionActivityManager alloc] init];
+        }
+        
+        [self.motionActivityManager startActivityUpdatesToQueue:[[NSOperationQueue alloc] init] withHandler:^(CMMotionActivity *activity) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                SOMotionType motionType;
+                if (activity.walking) {
+                    motionType = MotionTypeWalking;
+                } else if (activity.running) {
+                    motionType = MotionTypeRunning;
+                } else if (activity.automotive) {
+                    motionType = MotionTypeAutomotive;
+                } else if (activity.stationary || activity.unknown) {
+                    motionType = MotionTypeNotMoving;
+                } else {
+                    motionType = MotionTypeUnknown;
+                }
+                
+                int confidence;
+                switch (activity.confidence) {
+                    case CMMotionActivityConfidenceLow:
+                        confidence = 20;
+                        break;
+                    case CMMotionActivityConfidenceMedium:
+                        confidence = 40;
+                        break;
+                    case CMMotionActivityConfidenceHigh:
+                        confidence = 80;
+                        break;
+                }
+
+                _motionActivity.motionType = motionType;
+                _motionActivity.confidence = activity.confidence;
+                
+                // If type was changed, then call delegate method
+                if (motionType != self.previousMotionType) {
+                    self.previousMotionType = motionType;
+                    if (self.delegate && [self.delegate respondsToSelector:@selector(motionDetector:activityTypeChanged:)]) {
+                        [self.delegate motionDetector:self activityTypeChanged:self.motionActivity];
+                    }
+                    
+                    if (self.activityTypeChangedBlock) {
+                        self.activityTypeChangedBlock (self.motionActivity);
+                    }
+                }
+            });
+            
+        }];
+    } else {
+        [[SOLocationManager sharedInstance] start];
+        
+        self.shakeDetectingTimer = [NSTimer scheduledTimerWithTimeInterval:self.activityDetectionInterval
+                                                                    target:self
+                                                                  selector:@selector(detectShaking)
+                                                                  userInfo:Nil
+                                                                   repeats:YES];
+    }
+}
+
+- (void)stopDetection
+{
+    [self.shakeDetectingTimer invalidate];
+    self.shakeDetectingTimer = nil;
+    
+    [[SOLocationManager sharedInstance] stop];
+    [self.motionManager stopAccelerometerUpdates];
+    [self.motionActivityManager stopActivityUpdates];
+    _previousMotionType = 0;
+}
+
+#pragma mark - Customization Methods
+- (void)setMinimumSpeed:(CGFloat)speed
+{
+    kMinimumSpeed = speed;
+}
+
+- (void)setMaximumWalkingSpeed:(CGFloat)speed
+{
+    kMaximumWalkingSpeed = speed;
+}
+
+- (void)setMaximumRunningSpeed:(CGFloat)speed
+{
+    kMaximumRunningSpeed = speed;
+}
+
+- (void)setMinimumRunningAcceleration:(CGFloat)acceleration
+{
+    kMinimumRunningAcceleration = acceleration;
+}
+#pragma mark - Private Methods
+- (void)calculateMotionType
+{
+    SOMotionType motionType;
+    if (_currentSpeed < kMinimumSpeed) {
+        motionType = MotionTypeNotMoving;
+    } else if (_currentSpeed <= kMaximumWalkingSpeed) {
+        motionType = _isShaking ? MotionTypeRunning : MotionTypeWalking;
+    } else if (_currentSpeed <= kMaximumRunningSpeed) {
+        motionType = _isShaking ? MotionTypeRunning : MotionTypeAutomotive;
+    } else {
+        motionType = MotionTypeAutomotive;
+    }
+    
+    _motionActivity.motionType = motionType;
+    _motionActivity.confidence = 0;
+    
+    // If type was changed, then call delegate method
+    if (motionType != self.previousMotionType) {
+        self.previousMotionType = motionType;
+        
+        dispatch_async(dispatch_get_main_queue(), ^{
+            if (self.delegate && [self.delegate respondsToSelector:@selector(motionDetector:activityTypeChanged:)]) {
+                [self.delegate motionDetector:self activityTypeChanged:self.motionActivity];
+            }
+            
+            if (self.activityTypeChangedBlock) {
+                self.activityTypeChangedBlock (self.motionActivity);
+            }
+        });
+    }
+}
+
+- (void)detectShaking
+{
+    //Array for collecting acceleration for last one seconds period.
+    static NSMutableArray *shakeDataForOneSec = nil;
+    //Counter for calculating completion of one second interval
+    static float currentFiringTimeInterval = 0.0f;
+    
+    currentFiringTimeInterval += 0.01f;
+    if (currentFiringTimeInterval < 1.0f) {// if one second time intervall not completed yet
+        if (!shakeDataForOneSec)
+            shakeDataForOneSec = [NSMutableArray array];
+        
+        // Add current acceleration to array
+        NSValue *boxedAcceleration = [NSValue value:&_acceleration withObjCType:@encode(CMAcceleration)];
+        [shakeDataForOneSec addObject:boxedAcceleration];
+    } else {
+        // Now, when one second was elapsed, calculate shake count in this interval. If there will be at least one shake then
+        // we'll determine it as shaked in all this one second interval.
+        
+        int shakeCount = 0;
+        for (NSValue *boxedAcceleration in shakeDataForOneSec) {
+            CMAcceleration acceleration;
+            [boxedAcceleration getValue:&acceleration];
+         
+            /*********************************
+             *       Detecting shaking
+             *********************************/
+            double accX_2 = powf(acceleration.x,2);
+            double accY_2 = powf(acceleration.y,2);
+            double accZ_2 = powf(acceleration.z,2);
+            
+            double vectorSum = sqrt(accX_2 + accY_2 + accZ_2);
+            
+            if (vectorSum >= kMinimumRunningAcceleration) {
+                shakeCount++;
+            }
+            /*********************************/
+        }
+        _isShaking = shakeCount > 0;
+        
+        shakeDataForOneSec = nil;
+        currentFiringTimeInterval = 0.0f;
+    }
+}
+
+#pragma mark - LocationManager notification handler
+- (void)handleLocationChangedNotification:(NSNotification *)note
+{
+    self.currentLocation = [SOLocationManager sharedInstance].lastLocation;
+    _currentSpeed = self.currentLocation.speed;
+    if (_currentSpeed < 0) {
+        _currentSpeed = 0;
+    }
+
+    dispatch_async(dispatch_get_main_queue(), ^{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+        if (self.delegate && [self.delegate respondsToSelector:@selector(motionDetector:locationChanged:)]) {
+            [self.delegate motionDetector:self locationChanged:self.currentLocation];
+        }
+#pragma GCC diagnostic pop
+
+        if (self.locationChangedBlock) {
+            self.locationChangedBlock (self.currentLocation);
+        }
+    });
+
+    [self calculateMotionType];
+}
+
+#pragma mark - LocationManager notification handler
+- (void)handleLocationWasPausedNotification:(NSNotification *)note
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+        if (self.delegate && [self.delegate respondsToSelector:@selector(motionDetector:locationWasPaused:)]) {
+            [self.delegate motionDetector:self locationWasPaused:TRUE];
+        }
+#pragma GCC diagnostic pop
+
+        if (self.locationWasPausedBlock) {
+            self.locationWasPausedBlock (TRUE);
+        }
+    });
+}
+@end

package/ios/common/BackgroundGeolocation/SOMotionDetector/SOStepDetector.h

@@ -0,0 +1,44 @@
+//
+//  SOMotionDetecter.h
+//  MotionDetection
+//
+// The MIT License (MIT)
+//
+// Created by : arturdev
+// Copyright (c) 2014 SocialObjects Software. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
+
+#import <Foundation/Foundation.h>
+
+@interface SOStepDetector : NSObject
+
++ (instancetype)sharedInstance;
+
+/**
+ * Start accelerometer updates.
+ * @param callback Will be called every time when new step is detected
+ */
+- (void)startDetectionWithUpdateBlock:(void(^)(NSError *error))callback;
+
+/**
+ * Stop motion manager accelerometer updates
+ */
+- (void)stopDetection;
+
+@end

package/ios/common/BackgroundGeolocation/SOMotionDetector/SOStepDetector.m

@@ -0,0 +1,94 @@
+
+//
+//  SOStepDetector.m
+//  MotionDetection
+//
+//  Created by Artur on 5/15/15.
+//  Copyright (c) 2015 Artur Mkrtchyan. All rights reserved.
+//
+
+#import <UIKit/UIKit.h>
+#import "SOStepDetector.h"
+#import <CoreMotion/CoreMotion.h>
+
+#define kUpdateInterval 0.2f
+@interface SOStepDetector()
+
+@property (strong, nonatomic) CMMotionManager *motionManager;
+@property (strong, nonatomic) NSOperationQueue* queue;
+
+@end
+
+@implementation SOStepDetector
+
++ (instancetype)sharedInstance
+{
+    static id instance;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [self new];
+    });
+    
+    return instance;
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    
+    self.motionManager = [CMMotionManager new];
+    
+    self.motionManager.accelerometerUpdateInterval = kUpdateInterval;
+    self.motionManager.deviceMotionUpdateInterval  = kUpdateInterval;
+    self.motionManager.gyroUpdateInterval          = kUpdateInterval;
+    self.motionManager.magnetometerUpdateInterval  = kUpdateInterval;
+    self.motionManager.showsDeviceMovementDisplay  = YES;
+    
+    self.queue = [NSOperationQueue new];
+    self.queue.maxConcurrentOperationCount = 1;
+    
+    return self;
+}
+
+- (void)startDetectionWithUpdateBlock:(void (^)(NSError *))callback
+{
+    if (self.motionManager.isAccelerometerActive) {
+        return;
+    }
+    
+    [self.motionManager startAccelerometerUpdatesToQueue:self.queue
+                                             withHandler:^(CMAccelerometerData *accelerometerData, NSError *error) {
+        if (error) {
+            if (callback) {
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    callback (error);
+                });
+            }
+            return ;
+        }
+        
+        CMAcceleration acceleration = accelerometerData.acceleration;
+        
+        CGFloat strength = 1.2f;
+        BOOL isStep = NO;
+        if (fabs(acceleration.x) > strength || fabs(acceleration.y) > strength || fabs(acceleration.z) > strength) {
+            isStep = YES;
+        }
+        if (isStep) {
+            if (callback) {
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    callback (nil);
+                });
+            }
+        }
+    }];
+}
+
+- (void)stopDetection
+{
+    if (self.motionManager.isAccelerometerActive) {
+        [self.motionManager stopAccelerometerUpdates];
+    }
+}
+
+@end

package/ios/common/BackgroundGeolocation/SQLQueryBuilder/ext/NSString+ZIMString.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2011-2015 Ziminji
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*!
+ @category			NSString (ZIMString)
+ @discussion		This category extends the functionality of the NSString class.
+ @updated			2011-07-16
+ */
+@interface NSString (ZIMString)
+/*!
+ @method			matchesRegex:options:
+ @discussion		This method determines whether the pattern is matched.
+ @param pattern		The regular expression to be used.
+ @param options		The options to be used.
+ @return			A boolean value denoting whether the pattern was matched.
+ @updated			2012-03-20
+ @see				http://developer.apple.com/library/ios/#documentation/Foundation/Reference/NSRegularExpression_Class/Reference/Reference.html
+ @see				http://quickies.seriot.ch/index.php?id=279
+ */
+- (BOOL) matchesRegex: (NSString *)pattern options: (NSRegularExpressionOptions)options;
+/*!
+ @method			capitalizeFirstCharacterInString:
+ @discussion		This method will capitalize the first letter in the specified string.
+ @param string		The string to be modified.
+ @return			The modified string.
+ @updated			2011-06-29
+ @see				http://stackoverflow.com/questions/883897/easy-way-to-set-a-single-character-of-an-nsstring-to-uppercase
+ */
++ (NSString *) capitalizeFirstCharacterInString: (NSString *)string;
+/*!
+ @method			firstTokenInString:scanUpToCharactersFromSet:
+ @discussion		This method returns the first token found in the specified string.
+ @param string		The string to be parsed.
+ @param stopSet		The set of characters up to which to scan.
+ @return			The first token found.
+ @updated			2011-06-29
+ */
++ (NSString *) firstTokenInString: (NSString *)string scanUpToCharactersFromSet: (NSCharacterSet *)stopSet;
+
+@end

package/ios/common/BackgroundGeolocation/SQLQueryBuilder/ext/NSString+ZIMString.m

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2011-2015 Ziminji
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "NSString+ZIMString.h"
+
+@implementation NSString (ZIMString)
+
+#pragma mark -
+#pragma mark Public Methods
+
+- (BOOL) matchesRegex: (NSString *)pattern options: (NSRegularExpressionOptions)options {
+	NSError *error = nil;
+    NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern: pattern options: options error: &error];
+    if (regex == nil) {
+        return NO;
+    }
+    NSUInteger n = [regex numberOfMatchesInString: self options: 0 range: NSMakeRange(0, [self length])];
+    return (n == 1);
+}
+
++ (NSString *) capitalizeFirstCharacterInString: (NSString *)string {
+	return [string stringByReplacingCharactersInRange: NSMakeRange(0, 1) withString: [[string substringToIndex: 1] uppercaseString]];
+}
+
++ (NSString *) firstTokenInString: (NSString *)string scanUpToCharactersFromSet: (NSCharacterSet *)stopSet {
+	NSScanner *scanner = [NSScanner scannerWithString: string];
+	NSString *buffer;
+	if (![scanner scanUpToCharactersFromSet: stopSet intoString: &buffer]) {
+		return @"";
+	}
+	return buffer;
+}
+
+@end

package/ios/common/BackgroundGeolocation/SQLQueryBuilder/sql/ZIMSqlDataManipulationCommand.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2011-2015 Ziminji
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ * 
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import <Foundation/Foundation.h>
+
+/*!
+ @class					ZIMSqlDataManipulationCommand
+ @discussion			This protocol specifies the contract for a Data Manipulation Language (DML) command.
+ @updated				2011-07-15
+ @see					http://www.orafaq.com/faq/what_are_the_difference_between_ddl_dml_and_dcl_commands
+ */
+@protocol ZIMSqlDataManipulationCommand <NSObject>
+
+@end