MapKitWrapper

This is a MapKit wrapper for RubyMotion. It's purpose is to make dealing with MapKit less painful.

MapKitWrapper is work in progress. Right now there are wrappers for the Map Kit Data Types and the Core Location Data Types. Those will save you a lot of typing.

Installation

gem install map-kit-wrapper

Setup

Edit the Rakefile of your RubyMotion project and add the following require line.

require 'map-kit-wrapper'

Example

class FooViewController < UIViewController
    include MapKit
    def viewDidLoad
      super

      map = MapView.new
      map.frame = self.view.frame
      map.delegate = self
      map.region = CoordinateRegion.new([56, 10.6], [3.1, 3.1])
      map.shows_user_location = true
      view.addSubview(map)
    end

    #...
end

MapView: Convenient subclass of MKMapView

Include the module

include MapKit

Initializer

MapView.new

Methods on MapView

Zoom methods

>> map = MapView.new
=> MapView
>> map.zoom_enabled?
=> false
>> map.zoom_enabled = true
=> true

Scroll methods

>> map = MapView.new
=> MapView
>> map.scroll_enabled?
=> false
>> map.scroll_enabled = true
=> true

Location methods

>> map.user_located?
=> false
>> map.shows_user_location?
=> false
>> map.user_coordinates
=> nil
>> map.shows_user_location = true
=> true
# wait for a bit
>> map.user_located?
=> true
>> map.user_coordinates
=> LocationCoordinate

MapView zoom level methods

MapView includes calculations to easily get and set the zoom level as seen on Google Maps. It's a Ruby adaption of http://troybrant.net/blog/2010/01/set-the-zoom-level-of-an-mkmapview/

>> map.zoom_level
=> 5
>> map.set_zoom_level(13)
=> 13
# set the zoom level with animation
>> map.set_zoom_level(13, true)
=> 13

Wrappers for the CoreLocation data types

Include the module

include CoreLocation::DataTypes

LocationCoordinate: The wrapper for CLLocationCoordinate2D

The LocationCoordinate initializer takes a variety of argument types

LocationCoordinate.new(1,2)
LocationCoordinate.new([1,2])
LocationCoordinate.new({:latitude => 1, :longitude => 2})
LocationCoordinate.new(LocationCoordinate)
LocationCoordinate.new(CLLocationCoordinate2D)

Methods on LocationCoordinate

>> lc = LocationCoordinate.new(1, 2)
=> [1, 2]
>> lc.latitude
=> 1
>> lc.latitude = 10
=> 10
>> lc.longitude
=> 2
>> lc.longitude = 15
=> 15
>> lc.to_a
=> [10, 15]
>> lc.to_h
=> {:latitude => 10, :longitude => 15}
>> lc.api
=> CLLocationCoordinate2D

Wrappers for the MapKit data types

Include the module

include MapKit::DataTypes

CoordinateSpan: The wrapper for MKCoordinateSpan

The CoordinateSpan initializer takes a variety of argument types

CoordinateSpan.new(1, 2)
CoordinateSpan.new([1, 2])
CoordinateSpan.new({:latitude_delta => 1, :longitude_delta => 2})
CoordinateSpan.new(CoordinateSpan)
CoordinateSpan.new(MKCoordinateSpan)

Methods on CoordinateSpan

>> cs = CoordinateSpan.new(1, 2)
=> [1, 2]
>> cs.latitude_delta
=> 1
>> cs.longitude_delta
=> 2
>> cs.to_a
=> [1, 2]
>> cs.to_h
=> {:latitude_delta => 1, :longitude_delta => 2}
>> cs.api
=> MKCoordinateSpan

CoordinateRegion: The wrapper for MKCoordinateRegion

The CoordinateRegion initializer takes a variety of argument types

CoordinateRegion.new(CoordinateRegion)
CoordinateRegion.new(MKCoordinateRegion)
CoordinateRegion.new([56, 10.6], [3.1, 3.1])
CoordinateRegion.new({:center => {:latitude => 56, :longitude => 10.6}, :span => {:latitude_delta => 3.1, :longitude_delta => 5.1}})
CoordinateRegion.new(CLLocationCoordinate2D, MKCoordinateSpan)
CoordinateRegion.new(LocationCoordinate, CoordinateSpan)

Methods on CoordinateRegion

>> cr = CoordinateRegion.new([56, 10.6], [3.1, 5.1])
=> {:center => [56, 10.6], :span => [3.1, 5.1]}
>> cs.center
=> LocationCoordinate([56, 10.6])
>> cs.region
=> CoordinateSpan([3.1, 5.1])
>> cs.to_h
=> {:center => {:latitude => 56, :longitude => 10.6}, :span => {:latitude_delta => 3.1, :longitude_delta => 5.1}}
>> cs.api
=> MKCoordinateRegion

MapPoint: The wrapper for MKMapPoint

The MapPoint initializer takes a variety of argument types

MapPoint.new(50, 45)
MapPoint.new([50, 45])
MapPoint.new({:x => 50, :y => 45})
MapPoint.new(MKMapPoint)
MapPoint.new(MapPoint)

Methods on MapPoint

>> mp = MapPoint.new(50, 45)
=> [50, 45]
>> mp.x
=> 50
>> mp.y
=> 45
>> mp.to_a
=> [50, 45]
>> mp.to_h
=> {:x => 50, :y => 45}
>> mp.api
=> MKMapPoint

MapSize: The wrapper for MKMapSize

The MapSize initializer takes a variety of argument types

MapSize.new(10, 12)
MapSize.new([10, 12])
MapSize.new({:width => 50, :height => 45})
MapSize.new(MKMapSize)
MapSize.new(MapSize)

Methods on MapSize

>> ms = MapSize.new(10, 12)
=> [10, 12]
>> ms.width
=> 10
>> ms.height
=> 12
>> ms.to_a
=> [50, 45]
>> ms.to_h
=> {:width => 50, :height => 45}
>> ms.api
=> MKMapSize

MapRect: The wrapper for MKMapRect

The MapRect initializer takes a variety of argument types

MapRect.new(x, y, width, height)
MapRect.new([x, y], [width, height])
MapRect.new({:origin => {:x => 2, :y => 3}, :size => {:width => 10, :height => 12}})
MapRect.new(MapPoint, MapSize)
MapRect.new(MKMapPoint, MKMapSize)
MapRect.new(MapRect)
MapRect.new(MKMapRect)

Methods on MapRect

>> mr = MapRect.new(2, 3, 10, 12)
=> {:origin => [2, 3], :size => [10, 12]}
>> mr.origin
=> MapRect([2, 3])
>> mr.size
=> MapSize([10, 12])
>> mr.to_h
=> {:origin => {:x => 2, :y => 3}, :size => {:width => 10, :height => 12}}
>> mr.api
=> MKMapRect