ProMotion-map 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 730e656d5fad2888c9705a25a3344e086c3db6ff
+  data.tar.gz: d6d4d53d49f436970603a88d2c78110699900119
+SHA512:
+  metadata.gz: 6fed3989bcade0436a2ee3d5f72f695de72ba733bf846917ab9c4a76cab8b12805eab9c8754cacd353e4b2596f6f86f988b4446f0a0ec1221b72c3399be820a3
+  data.tar.gz: e583ef3a2a88df469cbc54c8df5a507508698fd6c15151f9023590120c0b890a6d8e29755eda88a57ce8fb2cd4932ca0d82a527af728f7615ad5a6453797b8a5

data/README.md

@@ -0,0 +1,224 @@
+# ProMotion-map
+
+ProMotion-map is push notification support, extracted from the 
+popular RubyMotion gem [ProMotion](https://github.com/clearsightstudio/ProMotion).
+
+## Installation
+
+```ruby
+gem 'ProMotion-map'
+```
+
+## Usage
+
+Easily create a map screen, complete with annotations.
+
+*Has all the methods of PM::Screen*
+
+```ruby
+class MyMapScreen < PM::MapScreen
+  title "My Map"
+  start_position latitude: 35.090648651123, longitude: -82.965972900391, radius: 4
+  
+  def on_appear
+    update_annotation_data
+  end
+  
+  def annotation_data
+    [{
+      longitude: -82.965972900391,
+      latitude: 35.090648651123,
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest"
+    },{
+      longitude: -82.966093558105,
+      latitude: 35.092520895652,
+      title: "Turtleback Falls",
+      subtitle: "Nantahala National Forest"
+    },{
+      longitude: -82.95916,
+      latitude: 35.07496,
+      title: "Windy Falls"
+    },{
+      longitude: -82.943031505056,
+      latitude: 35.102516828489,
+      title: "Upper Bearwallow Falls",
+      subtitle: "Gorges State Park"
+    },{
+      longitude: -82.956244328014,
+      latitude: 35.085548421623,
+      title: "Stairway Falls",
+      subtitle: "Gorges State Park",
+      your_param: "CustomWhatever"
+    }, {
+      longitude: -82.965972900391,
+      latitude: 35.090648651123,
+      title: "Rainbow Falls",
+      subtitle: "Nantahala National Forest",
+      image: UIImage.imageNamed("custom-pin")
+    }]
+  end
+
+  
+end
+```
+
+Here's a neat way to zoom into a specific marker in an animated fashion and then select the marker:
+
+```ruby
+def zoom_to_marker(marker)
+  set_region region(coordinate: marker.coordinate, span: [0.05, 0.05])
+  select_annotation marker
+end
+```
+
+---
+
+### Methods
+
+#### annotation_data
+      
+Method that is called to get the map's annotation data and build the map. If you do not want any annotations, simply return an empty array.
+
+```ruby
+def annotation_data
+  [{
+    longitude: -82.965972900391,
+    latitude: 35.090648651123,
+    title: "Rainbow Falls",
+    subtitle: "Nantahala National Forest"
+  },{
+    longitude: -82.965972900391,
+    latitude: 35.090648651123,
+    title: "Rainbow Falls",
+    subtitle: "Nantahala National Forest",
+    image: "custom-pin" # Use your own custom image. It will be converted to a UIImage automatically.
+  },{
+    longitude: -82.966093558105,
+    latitude: 35.092520895652,
+    title: "Turtleback Falls",
+    subtitle: "Nantahala National Forest"
+  },{
+    longitude: -82.95916,
+    latitude: 35.07496,
+    title: "Windy Falls"
+  },{
+    longitude: -82.943031505056,
+    latitude: 35.102516828489,
+    title: "Upper Bearwallow Falls",
+    subtitle: "Gorges State Park"
+  },{
+    longitude: -82.956244328014,
+    latitude: 35.085548421623,
+    title: "Stairway Falls",
+    subtitle: "Gorges State Park",
+    your_param: "CustomWahtever"
+  }]
+end
+```
+
+You may pass whatever properties you want in the annotation hash, but `:longitude`, `:latitude`, and `:title` are required.
+
+Use `:image` to specify a custom image. Pass in a string to conserve memory and it will be converted using `UIImage.imageNamed(your_string)`. If you pass in a `UIImage`, we'll use that, but keep in mind that there will be another unnecessary copy of the UIImage in memory.
+
+You can access annotation data you've arbitrarily stored in the hash by calling `annotation_instance.annotation_params[:your_param]`.
+
+#### update_annotation_data
+
+Forces a reload of all the annotations
+
+#### center
+
+Returns a `CLLocation2D` instance with the center coordinates of the map.
+
+#### center=({latitude: Float, longitude: Float, animated: Boolean})
+
+Sets the center of the map. `animated` property defaults to `true`.
+
+#### annotations
+
+Returns an array of all the annotations.
+
+#### select_annotation(annotation, animated=true)
+
+Selects a single annotation.
+
+#### select_annotation_at(annotation_index, animated=true)
+
+Selects a single annotation using the annotation at the index of your `annotation_data` array.
+
+#### selected_annotations
+
+Returns an array of annotations that are selected. If no annotations are selected, returns `nil`.
+
+#### deselect_annotations(animated=false)
+
+Deselects all selected annotations.
+
+#### add_annotation(annotation)
+
+Adds a new annotation to the map. Refer to `annotation_data` (above) for hash properties.
+
+#### add_annotations(annotations)
+
+Adds more than one annotation at a time to the map.
+
+#### clear_annotations
+
+Removes all annotations from the `MapScreen`.
+
+#### zoom_to_fit_annotations(animated=true)
+
+Changes the zoom and center point of the `MapScreen` to fit all the annotations.
+
+#### set_region(region, animated=true)
+
+Sets the region of the `MapScreen`. `region` should be an instance of `MKCoordinateRegion`.
+
+#### region(params)
+
+Helper method to create an `MKCoordinateRegion`. Expects a hash in the form of:
+
+```ruby
+my_region = region({
+  coordinate:{
+    latitude: 35.0906, 
+    longitude: -82.965
+  },
+  # span is the latitude and longitude delta
+  span: [0.5, 0.5]
+})
+```
+
+---
+
+### Class Methods
+
+#### start_position(latitude: Float, longitude: Float, radius: Float)
+    
+Class method to set the initial starting position of the `MapScreen`.
+
+```ruby
+class MyMapScreen < PM::MapScreen
+  start_position latitude: 36.10, longitude: -80.26, radius: 4
+end
+```
+
+`radius` is the zoom level of the map in miles (default: 10).
+
+---
+
+### Accessors
+
+#### mapview
+
+Reference to the created UIMapView.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Make some specs pass
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/lib/ProMotion-map.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "ProMotion-map must be required within a RubyMotion project."
+end
+
+Motion::Project::App.setup do |app|
+  lib_dir_path = File.dirname(File.expand_path(__FILE__))
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_annotation.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen_module.rb")
+  app.files << File.join(lib_dir_path, "ProMotion/map/map_screen.rb")
+
+  app.frameworks += %w(CoreLocation MapKit)
+end

data/lib/ProMotion/map/map_screen.rb

@@ -0,0 +1,6 @@
+module ProMotion
+  class MapScreen < ViewController
+    include ProMotion::ScreenModule
+    include ProMotion::MapScreenModule
+  end
+end

data/lib/ProMotion/map/map_screen_annotation.rb

@@ -0,0 +1,65 @@
+module ProMotion
+  class MapScreenAnnotation
+
+    # Creates the new annotation object
+    def initialize(params = {})
+      @params = params
+      set_defaults
+
+      unless @params[:latitude] && @params[:longitude]
+        PM.logger.error("You are required to specify :latitude and :longitude for annotations.")
+        return nil
+      end
+      @coordinate = CLLocationCoordinate2D.new(@params[:latitude], @params[:longitude])
+    end
+
+    def set_defaults
+      @params = {
+        title: "Title",
+        pin_color: MKPinAnnotationColorRed,
+        identifier: "Annotation-#{@params[:pin_color] || @params[:image]}",
+        show_callout: true,
+        animates_drop: false
+      }.merge(@params)
+    end
+
+    def title
+      @params[:title]
+    end
+
+    def subtitle
+      @params[:subtitle] ||= nil
+    end
+
+    def coordinate
+      @coordinate
+    end
+
+    def cllocation
+      CLLocation.alloc.initWithLatitude(@params[:latitude], longitude:@params[:longitude])
+    end
+
+    def setCoordinate(new_coordinate);
+      if new_coordinate.is_a? Hash
+        @coordinate = CLLocationCoordinate2D.new(new_coordinate[:latitude], new_coordinate[:longitude])
+      else
+        @coordinate = new_coordinate
+      end
+    end
+
+    # Allows for retrieving your own custom values on the annotation
+    def annotation_params
+      @params
+    end
+
+    def method_missing(meth, *args)
+      if @params[meth.to_sym]
+        @params[meth.to_sym]
+      else
+        PM.logger.warn "The annotation parameter \"#{meth}\" does not exist on this pin."
+        nil
+      end
+    end
+
+  end
+end

data/lib/ProMotion/map/map_screen_module.rb

@@ -0,0 +1,248 @@
+module ProMotion
+  module MapScreenModule
+    attr_accessor :mapview
+
+    def screen_setup
+      check_mapkit_included
+      self.mapview ||= add MKMapView.new, {
+        frame: CGRectMake(0, 0, self.view.frame.size.width, self.view.frame.size.height),
+        resize: [ :width, :height ],
+        delegate: self
+      }
+
+      check_annotation_data
+      @promotion_annotation_data = []
+      set_up_start_position
+    end
+
+    def view_will_appear(animated)
+      super
+      update_annotation_data
+    end
+
+    def check_mapkit_included
+      PM.logger.error "You must add MapKit and CoreLocation to your project's frameworks in the Rakefile." unless defined?(CLLocationCoordinate2D)
+    end
+
+    def check_annotation_data
+      PM.logger.error "Missing #annotation_data method in MapScreen #{self.class.to_s}." unless self.respond_to?(:annotation_data)
+    end
+
+    def update_annotation_data
+      clear_annotations
+      add_annotations annotation_data
+    end
+
+    def map
+      self.mapview
+    end
+
+    def center
+      self.mapview.centerCoordinate
+    end
+
+    def center=(params={})
+      PM.logger.error "Missing #:latitude property in call to #center=." unless params[:latitude]
+      PM.logger.error "Missing #:longitude property in call to #center=." unless params[:longitude]
+      params[:animated] = true
+
+      # Set the new region
+      self.mapview.setCenterCoordinate(
+        CLLocationCoordinate2D.new(params[:latitude], params[:longitude]),
+        animated:params[:animated]
+      )
+    end
+
+    def show_user_location
+      set_show_user_location true
+    end
+
+    def hide_user_location
+      set_show_user_location false
+    end
+
+    def set_show_user_location(show)
+      self.mapview.showsUserLocation = show
+    end
+
+    def showing_user_location?
+      self.mapview.showsUserLocation
+    end
+
+    def user_location
+      self.mapview.userLocation.location.nil? ? nil : self.mapview.userLocation.location.coordinate
+    end
+
+    def zoom_to_user(radius = 0.05, animated=true)
+      show_user_location unless showing_user_location?
+      set_region(MKCoordinateRegionMake(user_location, [radius, radius]), animated)
+    end
+
+    def annotations
+      @promotion_annotation_data
+    end
+
+    def select_annotation(annotation, animated=true)
+      self.mapview.selectAnnotation(annotation, animated:animated)
+    end
+
+    def select_annotation_at(annotation_index, animated=true)
+      select_annotation(annotations[annotation_index], animated:animated)
+    end
+
+    def selected_annotations
+      self.mapview.selectedAnnotations
+    end
+
+    def deselect_annotations(animated=false)
+      unless selected_annotations.nil?
+        selected_annotations.each do |annotation|
+          self.mapview.deselectAnnotation(annotation, animated:animated)
+        end
+      end
+    end
+
+    def add_annotation(annotation)
+      @promotion_annotation_data << MapScreenAnnotation.new(annotation)
+      self.mapview.addAnnotation @promotion_annotation_data.last
+    end
+
+    def add_annotations(annotations)
+      @promotion_annotation_data = Array(annotations).map{|a| MapScreenAnnotation.new(a)}
+      self.mapview.addAnnotations @promotion_annotation_data
+    end
+
+    def clear_annotations
+      @promotion_annotation_data.each do |a|
+        self.mapview.removeAnnotation(a)
+      end
+      @promotion_annotation_data = []
+    end
+
+    def mapView(mapView, viewForAnnotation:annotation)
+      return if annotation.is_a? MKUserLocation
+
+      identifier = annotation.annotation_params[:identifier]
+      if view = mapView.dequeueReusableAnnotationViewWithIdentifier(identifier)
+        view.annotation = annotation
+      else
+        #Set the pin properties
+        if annotation.annotation_params[:image]
+          view = MKAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
+          view.image =  annotation.annotation_params[:image]
+        else
+          view = MKPinAnnotationView.alloc.initWithAnnotation(annotation, reuseIdentifier:identifier)
+          view.animatesDrop = annotation.annotation_params[:animates_drop]
+          view.pinColor = annotation.annotation_params[:pin_color]
+        end
+        view.canShowCallout = annotation.annotation_params[:show_callout]
+      end
+      view
+    end
+
+    def set_start_position(params={})
+      params[:latitude] ||= 37.331789
+      params[:longitude] ||= -122.029620
+      params[:radius] ||= 10
+
+      meters_per_mile = 1609.344
+
+      initialLocation = CLLocationCoordinate2D.new(params[:latitude], params[:longitude])
+      region = MKCoordinateRegionMakeWithDistance(initialLocation, params[:radius] * meters_per_mile, params[:radius] * meters_per_mile)
+      set_region(region, animated:false)
+    end
+
+    def set_up_start_position
+      if self.class.respond_to?(:get_start_position) && self.class.get_start_position
+        self.set_start_position self.class.get_start_position_params
+      end
+    end
+
+    # TODO: Why is this so complex?
+    def zoom_to_fit_annotations(animated=true)
+      #Don't attempt the rezoom of there are no pins
+      return if annotations.count == 0
+
+      #Set some crazy boundaries
+      topLeft = CLLocationCoordinate2D.new(-90, 180)
+      bottomRight = CLLocationCoordinate2D.new(90, -180)
+
+      #Find the bounds of the pins
+      annotations.each do |a|
+        topLeft.longitude = [topLeft.longitude, a.coordinate.longitude].min
+        topLeft.latitude = [topLeft.latitude, a.coordinate.latitude].max
+        bottomRight.longitude = [bottomRight.longitude, a.coordinate.longitude].max
+        bottomRight.latitude = [bottomRight.latitude, a.coordinate.latitude].min
+      end
+
+      #Find the bounds of all the pins and set the mapView
+      coord = CLLocationCoordinate2D.new(
+        topLeft.latitude - (topLeft.latitude - bottomRight.latitude) * 0.5,
+        topLeft.longitude + (bottomRight.longitude - topLeft.longitude) * 0.5
+      )
+
+      # Add some padding to the edges
+      span = MKCoordinateSpanMake(
+        ((topLeft.latitude - bottomRight.latitude) * 1.075).abs,
+        ((bottomRight.longitude - topLeft.longitude) * 1.075).abs
+      )
+
+      region = MKCoordinateRegionMake(coord, span)
+      fits = self.mapview.regionThatFits(region);
+
+      set_region(fits, animated:animated)
+    end
+
+    def set_region(region, animated=true)
+      self.mapview.setRegion(region, animated:animated)
+    end
+
+    def region(params)
+      return nil unless params.is_a? Hash
+
+      params[:coordinate] = CLLocationCoordinate2D.new(params[:coordinate][:latitude], params[:coordinate][:longitude]) if params[:coordinate].is_a? Hash
+      params[:span] = MKCoordinateSpanMake(params[:span][0], params[:span][1]) if params[:span].is_a? Array
+
+      if params[:coordinate] && params[:span]
+        MKCoordinateRegionMake( params[:coordinate], params[:span] )
+      end
+    end
+
+    def look_up_address(args={}, &callback)
+      args[:address] = args if args.is_a? String # Assume if a string is passed that they want an address
+
+      geocoder = CLGeocoder.new
+      return geocoder.geocodeAddressDictionary(args[:address], completionHandler: callback) if args[:address].is_a?(Hash)
+      return geocoder.geocodeAddressString(args[:address].to_s, completionHandler: callback) unless args[:region]
+      return geocoder.geocodeAddressString(args[:address].to_s, inRegion:args[:region].to_s, completionHandler: callback) if args[:region]
+    end
+
+    ########## Cocoa touch methods #################
+    def mapView(mapView, didUpdateUserLocation:userLocation)
+      if self.respond_to?(:on_user_location)
+        on_user_location(userLocation)
+      else
+        PM.logger.info "You're tracking the user's location but have not implemented the #on_user_location(location) method in MapScreen #{self.class.to_s}."
+      end
+    end
+
+    module MapClassMethods
+      def start_position(params={})
+        @start_position_params = params
+        @start_position = true
+      end
+
+      def get_start_position_params
+        @start_position_params ||= nil
+      end
+
+      def get_start_position
+        @start_position ||= false
+      end
+    end
+    def self.included(base)
+      base.extend(MapClassMethods)
+    end
+
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: ProMotion-map
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Rickert
+- Jamon Holmgren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ProMotion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: motion-stump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: motion-redgreen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !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: Adds PM::MapScreen support to ProMotion.
+email:
+- mark@mohawkapps.com
+- jamon@clearsightstudio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ProMotion-map.rb
+- lib/ProMotion/map/map_screen.rb
+- lib/ProMotion/map/map_screen_annotation.rb
+- lib/ProMotion/map/map_screen_module.rb
+homepage: https://github.com/clearsightstudio/ProMotion-map
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Adds PM::MapScreen support to ProMotion. Extracted from ProMotion.
+test_files: []