motion-locman 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a6f0fe017e53fd5fd42b7e8da965f5bba50c2121
+  data.tar.gz: d5f238ed5ec67fb62ae601e1b7583531c53d5006
+SHA512:
+  metadata.gz: f9754fb1ce8504df4425f02607d52a294a7bdca82e09da8f001aaefeaaf90bc51913cb51fc0f43066f1800e57f333132001270290024f9f7a9b770c6fddc8662
+  data.tar.gz: d329b7070fddcb2db215b4c07181663efd1e0f9b3527acb944b336272b885537d1079061407dcd66da61eeaa16e2b1652ef74e29ddfb93a634b9cc291e986c13

data/README.md

@@ -0,0 +1,48 @@
+# motion-locman
+
+Simple location library for Rubymotion
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "motion-locman"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install motion-locman
+
+## Usage
+
+Initialize a new **Locman::Manager**, request for user authorization:
+
+```ruby
+@manager = Locman::Manager.new(
+  accuracy: :ten_meters,
+  distance_filter: 20 # in meter
+)
+
+@manager.after_authorize = lambda do |authorized|
+  puts "Authorized!" if authorized
+end
+
+@manager.authorize!
+```
+
+Start receiving location updates:
+
+```ruby
+@manager.on_update = lambda do |locations|
+  locations.each { |loc| puts "(#{loc.latitude}, #{loc.longitude})" }
+end
+
+@manager.start!
+```
+
+## License
+
+MIT

data/lib/locman.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "locman/**/*.rb")))
+  app.frameworks += %w(CoreLocation)
+end

data/lib/locman/location.rb

@@ -0,0 +1,23 @@
+module Locman
+  class Location
+    attr_accessor :latitude, :longitude, :altitude, :floor,
+                  :accuracy, :altitude_accuracy,
+                  :determined_at
+
+    def self.create_from_cl_location(cl_location)
+      Locman::Location.new(
+        latitude: cl_location.coordinate.latitude,
+        longitude: cl_location.coordinate.longitude,
+        altitude: cl_location.altitude,
+        floor: cl_location.floor.nil? ? nil : cl_location.floor.level,
+        accuracy: cl_location.horizontalAccuracy,
+        altitude_accuracy: cl_location.verticalAccuracy,
+        determined_at: cl_location.timestamp
+      )
+    end
+
+    def initialize(params = {})
+      params.each { |key, value| send("#{key}=", value) }
+    end
+  end
+end

data/lib/locman/manager.rb

@@ -0,0 +1,124 @@
+module Locman
+  class Manager
+    attr_accessor :accuracy, :distance_filter, :on_update, :on_error
+
+    AUTHORIZED_CONSTS = [
+      KCLAuthorizationStatusAuthorized,
+      KCLAuthorizationStatusAuthorizedAlways,
+      KCLAuthorizationStatusAuthorizedWhenInUse
+    ]
+
+    NOT_AUTHORIZED_CONSTS = [
+      KCLAuthorizationStatusNotDetermined,
+      KCLAuthorizationStatusRestricted,
+      KCLAuthorizationStatusDenied
+    ]
+
+    ACCURACY_MAP = {
+      navigation: KCLLocationAccuracyBestForNavigation,
+      best: KCLLocationAccuracyBest,
+      ten_meters: KCLLocationAccuracyNearestTenMeters,
+      hundred_meters: KCLLocationAccuracyHundredMeters,
+      kilometer: KCLLocationAccuracyKilometer,
+      three_kilometers: KCLLocationAccuracyThreeKilometers
+    }
+
+    def initialize(params = {})
+      params.each { |key, value| send("#{key}=", value) }
+
+      @accuracy ||= :best
+      @distance_filter ||= 0
+    end
+
+    def accuracy=(accuracy)
+      fail(ArgumentError, "Invalid accuracy: #{accuracy}") if ACCURACY_MAP[accuracy].nil?
+      @accuracy = accuracy
+    end
+
+    def authorize!
+      return true unless CLLocationManager.authorizationStatus == KCLAuthorizationStatusNotDetermined
+      manager.requestAlwaysAuthorization
+    end
+
+    def authorized?(status = nil)
+      status ||= CLLocationManager.authorizationStatus
+
+      if AUTHORIZED_CONSTS.include? status
+        return true
+      elsif NOT_AUTHORIZED_CONSTS.include? status
+        return false
+      end
+
+      nil
+    end
+
+    def after_authorize=(after_authorize)
+      fail(ArgumentError, "Must provide proc") unless after_authorize.is_a?(Proc)
+      @after_authorize = after_authorize
+    end
+
+    def start!(params = {})
+      params[:background] ||= false
+
+      if CLLocationManager.authorizationStatus != KCLAuthorizationStatusAuthorized
+        fail(Exception, "Location permission is not authorized by user")
+      end
+
+      manager.desiredAccuracy = ACCURACY_MAP[@accuracy]
+      manager.distanceFilter = @distance_filter
+      manager.allowsBackgroundLocationUpdates = true if params[:background]
+      manager.startUpdatingLocation
+    end
+
+    def stop!
+      manager.stopUpdatingLocation
+    end
+
+    def start_monitor!
+      manager.startMonitoringSignificantLocationChanges
+    end
+
+    def stop_monitor!
+      manager.stopMonitoringSignificantLocationChanges
+    end
+
+    def on_update=(on_update)
+      fail(ArgumentError, "Must provide proc") unless on_update.is_a?(Proc)
+      @on_update = on_update
+    end
+
+    def on_error=(on_error)
+      fail(ArgumentError, "Must provide proc") unless on_error.is_a?(Proc)
+      @on_error = on_error
+    end
+
+    # Delegates
+
+    def locationManager(manager, didChangeAuthorizationStatus: status)
+      @after_authorize.call(authorized?(status)) unless @after_authorize.nil?
+    end
+
+    def locationManager(manager, didFailWithError: error)
+      @on_error.call(error) unless @on_error.nil?
+    end
+
+    def locationManager(manager, didUpdateLocations: cl_locations)
+      locations = cl_locations.map do |cl_location|
+        Locman::Location.create_from_cl_location(cl_location)
+      end
+
+      @on_update.call(locations) unless @on_update.nil?
+    end
+
+    private
+
+    def manager
+      @manager ||= begin
+        manager = CLLocationManager.new
+        manager.delegate = self
+
+        manager
+      end
+    end
+  end
+end

data/lib/motion-locman.rb

@@ -0,0 +1 @@
+require "locman"

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: motion-locman
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Minku Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple location library for Rubymotion
+email:
+- premist@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/locman.rb
+- lib/locman/location.rb
+- lib/locman/manager.rb
+- lib/motion-locman.rb
+homepage: https://github.com/premist/motion-locman
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Simple location library for Rubymotion. Wraps CLLocationManager and more.
+test_files: []