Learn Swift: Annotations (aka the pins on maps)

This post shows you how to add annotations (aka pins) to a map using Swift and the Map Kit framework.

Specifically, this post uses the MKPointAnnotation class to create a basic annotation as mentioned in Apple’s Location and Maps Programming Guide.  Note, alternatively you could create an annotation object by defining a custom object that conforms to the MKAnnotation protocol, also mentioned in Apple’s Location and Maps Programming Guide.

Here is a picture of the annotation on the map:

As shown in the next image, the annotation object used in this example also has a callout bubble that is shown if the user clicks on the annotation.

Here are two other resources I found on this topic:

1) http://www.ioscreator.com/tutorials/mapkit-tutorial-swift-ios8 (This one I used to learn the basics and my code reflects this.)

2) http://www.youtube.com/watch?v=uB100xVS_Yc

Instructions:

1. Open XCode
2. File->New->Project
3. In iOS Application section select Single View Application and click Next.
4. Name & save as you desire.
5. In the Project Navigator, open the Main.storyboard file.
6. In the File Inspector of the Utilities pane, uncheck “Use Size Classes”.  (This is not really part of understanding the Annotations, but just to tell XCode we want to design for a specific device.  In this case, the iPhone.)
7. Find MapKit View in the Object Library and drag 1 onto the view.
8. Set the MKMapView size using the dashed blue lines of XCode’s AutoLayout.
9. Use the Document Outline area to select the Map View.
10. Select Editor->Resolve Auto Layout Issues->Reset to Suggested Constraints.
11. In the Project Navigator, open the ViewController.swift file.
12. import MapKit
13. Now use the Assistant Editor to create an outlet by dragging from the MKMapview in the Main.storyboard file to just below the class definition (i.e. not inside one of the functions) in the ViewController.swift file.
14. In the viewDidLoad method below the call to the super’s viewDidLoad method:
    1. Create a constant to store a CLLocationCoordinate2D structure.
       1. let sfGiantsStadiumLocation = CLLocationCoordinate2D(latitude: 37.77831, longitude: -122.38758)
    2. Create a variable to store an MKCoordinateSpan structure.
       1. var span = MKCoordinateSpanMake(0.01, 0.01)
    3. Create a variable to store an MKCoordianteRegion structure
       1. var coordinateRegion = MKCoordinateRegion(center: sfGiantsStadiumLocation, span: span)
    4. Set the region of the MKMapView object.
       1. map.setRegion(coordinateRegion, animated: true)
    5. Create an MKPointAnnotation object.
       1. let sfGiantsStadiumAnnotation = MKPointAnnotation()
    6. Set properties of the MKPointAnnotation object.
       1. (see code below)
    7. Add the MKPointAnnotation object to the MKMapView object.
       1. map.addAnnotation(sfGiantsStadiumAnnotation)

All the code for this example goes in the ViewController.swift file.  Here is the code:

import UIKit
import MapKit

class ViewController: UIViewController {

@IBOutlet weak var map: MKMapView!

override func viewDidLoad() {

super.viewDidLoad()
// Do any additional setup after loading the view, typically from a nib.

//set lat/lon coordinates of a location
let sfGiantsStadiumLocation = CLLocationCoordinate2D(latitude: 37.77831, longitude: –122.38758)
//set a span to be used by the MKCoordinateRegion structure
var span = MKCoordinateSpanMake(0.01, 0.01)
//create MKCoordinateRegion structure
var coordinateRegion = MKCoordinateRegion(center: sfGiantsStadiumLocation, span: span)
//set the region of the MKMapView object
map.setRegion(coordinateRegion, animated: true)

//create an MKPointAnnotation object
let sfGiantsStadiumAnnotation = MKPointAnnotation()
//set properties of the MKPointAnnotation object
sfGiantsStadiumAnnotation.setCoordinate(sfGiantsStadiumLocation)
sfGiantsStadiumAnnotation.title = “AT & T Park”
sfGiantsStadiumAnnotation.subtitle = “Home of the San Francisco Giants”

//add the annotation to the map
map.addAnnotation(sfGiantsStadiumAnnotation)

}

override func didReceiveMemoryWarning() {

super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.

}

}

Advertisements

Learn Swift: Methods

This post includes Swift code to be used in XCode Playgrounds.  The code illustrates methods in Swift as detailed in the Methods section in Apple’s book The Swift Programming Language.

I think opening and playing around with the code will illuminate some of the ideas.  In the Swift code I included some comments to help provide direction.

Open XCode 6.0.

Open a new Playground file.

Copy & paste the following Swift code:

//Methods

//Instance Methods (for classes, structures, or enumerations)
class ScoreBoard {
    
    var homeTeamScore = 0
    var awayTeamScore = 0
    
    //increaseHomeTeamScoreBy is an instance method
    func increaseHomeTeamScoreBy(points: Int) {
        homeTeamScore += points
    }
    //increaseAwayTeamScoreBy is an instance method
    func increaseAwayTeamScoreBy(points: Int) {
        awayTeamScore += points
    }
    func setScoreForHomeTeam(points:Int, scoreForAwayTeam:Int){
        homeTeamScore = points
        awayTeamScore = scoreForAwayTeam
    }
}

let gameScore = ScoreBoard()
gameScore.increaseHomeTeamScoreBy(4)
gameScore.increaseAwayTeamScoreBy(1)
gameScore.setScoreForHomeTeam(7, scoreForAwayTeam: 2)

//Local & External Parameter Names for Methods
//This is illustrated by the setScoreForHomeTeam method & its parameters.
//Points is a local parameter name, and scoreFowAwayTeam is a local & external parameter name.
//The definition for setScoreForHomeTeam is like the function defintion func setScoreForHomeTeam(points:Int, #scoreForAwayTeam:Int) b/c of Swift’s default behavior for method parameters.

//Modifying External Parameter Name Behavior for Methods
class AnotherScoreBoard {
    
    var homeTeamScore = 0
    var awayTeamScore = 0
    
    //points is now an internal & external parameter name
    func setScoreForHomeTeam(#points:Int, scoreForAwayTeam:Int){
        homeTeamScore = points
        awayTeamScore = scoreForAwayTeam
    }
}
let nextGameScore = AnotherScoreBoard()
//notice the use of the external paramter name points
nextGameScore.setScoreForHomeTeam(points: 10, scoreForAwayTeam: 2)

class NextScoreBoard {
    
    var homeTeamScore = 0
    var awayTeamScore = 0
    
    //scoreForHomeTeam is now an external parameter name
    func setScore(scoreForHomeTeam points:Int, scoreForAwayTeam:Int){
        homeTeamScore = points
        awayTeamScore = scoreForAwayTeam
    }
}
let aGameScore = NextScoreBoard()
//notice the use of the external paramter name scoreForHomeTeam
aGameScore.setScore(scoreForHomeTeam: 12, scoreForAwayTeam: 11)

class MoreScoreBoard {
    
    var homeTeamScore = 0
    var awayTeamScore = 0
    
    //override default behavior so that awayTeamPoints is NOT an external parameter name
    func setScoreForHomeTeamAndAwayTeam(homeTeamPoints:Int, _ awayTeamPoints:Int){
        homeTeamScore = homeTeamPoints
        awayTeamScore = awayTeamPoints
    }
}
let exampleGameScore = MoreScoreBoard()
//notice below that no external parameter names are used
exampleGameScore.setScoreForHomeTeamAndAwayTeam(21, 3)
//uncomment the next line to see the error when you try to use awayTeamPoints as an external parameter
//exampleGameScore.setScoreForHomeTeamAndAwayTeam(3, awayTeamPoints:1)

//The self Property
//self refers to the instance of the type
class SportsScoreBoard {
    
    var homeTeamScore = 0
    var awayTeamScore = 0
    
    //notice the use of self to identify the instance property vs. the parameter
    func setScoreForHomeTeamAndAwayTeam(homeTeamScore:Int, awayTeamScore:Int){
        self.homeTeamScore = homeTeamScore
        self.awayTeamScore = awayTeamScore
    }
}
let newScore = SportsScoreBoard()
newScore.setScoreForHomeTeamAndAwayTeam(21, awayTeamScore: 4)
newScore.homeTeamScore
newScore.awayTeamScore

//Modifying Value Types from Within Instance Methods (for stuctures & enumerations)
struct Person {
    var firstName: String?
    var lastName: String?
    
    //mutating keyword before func keyword allows properties (including implicity self property to be modified
    mutating func changeFirstName(newFirstName: String) {
        firstName = newFirstName
    }
    //example of modifying self property
    mutating func newPersonInstanceWith(newFirstName: String, newLastName: String) {
        self = Person(firstName: newFirstName, lastName: newLastName)
    }
}
var aPerson = Person(firstName: “Chris”, lastName: “Johnson”)
aPerson.changeFirstName(“Dennis”)
aPerson
//assign a completely new instance of Person by calling the mutating function that assigns a new Person instance to the implicit self property
aPerson.newPersonInstanceWith(“Dale”, newLastName: “Mann”)
aPerson

//Assigning to self Within a Mutating Method
//I showed an example of this just above.
//Here is another example of assigning to self within a mutating method, this time using an enumeration.
enum BasketballPosition {
    case guard, forward, center
    mutating func rotatePosition() {
        switch self {
            case guard:
                self = forward
            case forward:
                self = center
            case center:
                self = guard
        }
    }
    var description: String {
        get {
            switch self {
                case .guard:
                    return “guard”
                case .forward:
                    return “forward”
                case .center:
                    return “center”
            }
        }
    }
}
var adamsPosition = BasketballPosition.guard
adamsPosition.description
adamsPosition.rotatePosition()
adamsPosition.description

//Type Methods (for classes, enumerations, & structures)
//w/in body of type method, self refers to the type (compare this against w/in body of instance method, self refers to an instance of the type)

//for enumerations & structures, place static keyword before the func keyword to indicate a type method
struct FundraisingCampaign {
    
    //declare type property
    static var totalDollarsRaised = 0.0
    
    //declare type method
    static func addDollars(dollars: Double){
        totalDollarsRaised += dollars
    }
    
    //declare instance property
    var lastAmountRaised: Double = 0.0
}

class FundraisingMember{
    
    let nameOfMember: String
    
    //declare instance property of type FundraisingCampaign
    var fundraiser = FundraisingCampaign()
    
    //declare instance method
    func raisedMoreDollars(dollars: Double) {
        
        //call addDollars type method of type Fundraiser
        FundraisingCampaign.addDollars(dollars)
        
        //set instance property lastAmountRaised of the instance fundraiser of the type FundraisingCampaign
        fundraiser.lastAmountRaised = dollars
    }
    
    init(name: String) {
        nameOfMember = name
    }
}
var lisa = FundraisingMember(name: “Lisa”)
FundraisingCampaign.totalDollarsRaised
//The next line refers to the instance property lastAmountRaised of the fundraiser instance (of type FundraisingCampaign) of the lisa instance (of type FundraisingMember)
lisa.fundraiser.lastAmountRaised
//uncomment next line to see error when try to access instance property as if it was a type property
//FundraisingCampaign.lastAmountRaised
lisa.raisedMoreDollars(12.22)
FundraisingCampaign.totalDollarsRaised
lisa.raisedMoreDollars(20.00)
FundraisingCampaign.totalDollarsRaised
lisa.fundraiser.lastAmountRaised

//for classes, place class keyword before the func keyword to indicate a type method
class FavoriteNumberAndColor {
    var favoriteColor = “blue”
    var favoriteNumber = 2
    
    //declare a type property (as of 09/29/2014 not supported in XCode’s Playgrounds
    //class var aboutThisClass: String = “”
    
    //declare a type method
    class func setAboutThisClass() {
        println(“Not a very useful message!”)
    }
}

//call type method setAboutThisClass of the FavoriteNumberAndColor class
FavoriteNumberAndColor.setAboutThisClass()

Learn Swift: Properties

This post includes Swift code to be used in XCode Playgrounds.  The code illustrates properties in Swift as detailed in the Properties section in Apple’s book The Swift Programming Language.

I think opening and playing around with the code will illuminate some of the ideas.  In the Swift code I included some comments to help provide direction.

Open XCode 6.0.

Open a new Playground file.

Copy & paste the following Swift code:

//Properties

//Stored Properties

//variable or constant stored properties
struct BasketballPlayer {
     let name: String
     var shootingPercentage: Double
}
var kenny = BasketballPlayer(name:”Kenny”, shootingPercentage:46.5)
//note name can’t be changed now; uncomment next line to see this error
//kenny.name = “James”
kenny.shootingPercentage = 49.2
//Stored Properties of Constant Structure Instances
let klay = BasketballPlayer(name: “Klay”, shootingPercentage: 51.2)
//can’t change instance properties b/c klay is constant structure instance & structures are value types; uncomment next line to see this error
//klay.shootingPercentage = 47.4

class SoccerPlayer {
     var name: String? = nil
     var team: String? = nil
}
let matt = SoccerPlayer()
matt.team = “Sting”
matt.team = “Quake”
//notice even though matt is a constant instance of SoccerPlayer class, it’s variable instance properties can still be changed

//Lazy Stored Properties: “a property that’s not calculated until the first time it is used.” (quoted from Apple’s book on Swift)
class ThisTaskMightTakeLong {
     let str = “Pretend this class might do something that could take a long time”
}
class AnExample {
     lazy var possiblyLongTask = ThisTaskMightTakeLong()
     var str = “An Example”
}
let oneExample = AnExample()
//At this point, possiblyLongTaks has not been created.
oneExample.str
oneExample
oneExample.possiblyLongTask
oneExample.possiblyLongTask.str
//At this point, possiblyLongTask has been created since we accessed 1 of it’s properties.  possiblyLongTask would also be created if we accessed it (i.e. oneExample.possiblyLongTask) and not 1 of it’s properties.
oneExample  //compare this line with the line above that has oneExample on it

//Stored Properties and Instance Variables
//Not much here.  Read in Apple’s Swift book if you like.

//Computed Properties (available for classes, structures, & enumerations)
struct PitchingStats {

     var fastballs = 0
     var nonFastballs = 0

     //totalPitches is a computed property
     var totalPitches:Int {
          //getter
          get {
          return fastballs + nonFastballs
          }
          //setter
          set(newTotalPitches) {
          //let’s assume # of fastballs is correct
          nonFastballs = newTotalPitches – fastballs
          }
     }
}
var will = PitchingStats(fastballs: 4, nonFastballs: 3)
will.totalPitches  //totalPitches is computed from the other properties
will.totalPitches = 20
will

//Shorthand Setter Declaration (notice no name defined in setter & use of default name of newValue
struct MorePitchingStats {

     var fastballs = 0
     var nonFastballs = 0

     //totalPitches is a computed property
     var totalPitches:Int {
          //getter
          get {
               return fastballs + nonFastballs
          }
          //shorthand setter uses default name of newValue
          set{
               //let’s assume # of fastballs is correct
               nonFastballs = newValue – fastballs
          }
     }
}
var chris = MorePitchingStats(fastballs: 4, nonFastballs: 3)
chris.totalPitches  //totalPitches is computed from the other properties
chris.totalPitches = 20  //This call uses the setter, and newValue = 20.
chris

//Read-Only Computed Properties: a computed property w/ getter, but no setter
struct Circle {
     var radius: Double = 0
     var area: Double {
          get {
               return 3.14 * radius * radius
          }
     }
}
let theCircle = Circle(radius: 3)
theCircle.area
theCircle.radius

//an example w/ simplified declaration that leaves out the get keyword
struct Square {
     var sideLength: Double = 0
     var area: Double {
     return sideLength * sideLength
     }
}
var theSquare = Square(sideLength: 5.0)
theSquare.area
theSquare.sideLength

//Property Observers (can add to stored properties you define, stored or computed inherited properties; can’t add to lazy stored properties
class SavingsAccount {

     var dollarsInAccount: Double = 0 {
          //willSet called before dollarsInAccount set to newNumberOfDollarsInAccount
          willSet(newNumberOfDollarsInAccount) {
               println(“There are $\(newNumberOfDollarsInAccount) in the account.”)
          }
          //didSet called just after dollarsInAccount set to newNumberOfDollarsInAccount; oldValue is the default name for the value of dollarsInAccount before willSet was called
          didSet {
               if dollarsInAccount > oldValue {
                    println(“Account has more money.”)
               } else if dollarsInAccount < oldValue {
                    println(“Account has less money.”)
               } else {
                    println(“Account has the same amount of money.”)
               }
          }
     }
}

let mySavingsAccount = SavingsAccount()
//For the next 2 lines, look at the Console Output to see when the willSet & didSet property observers are being called
mySavingsAccount.dollarsInAccount = 120.00
mySavingsAccount.dollarsInAccount = 40.00

//Global & Local Variables
//Read in Apple’s Swift book if you like.

//Type Properties: belong to the type and not any 1 instance
//For value types: stored & computed type properties & can be variable or constant properties; stored type properties require default value
//For classes: computed type properties only & they must be variable properties

//Type Property Syntax (I should review this section & clarify ideas.)
//static keyword to define type properties for value types (i.e. structures, enumerations)
enum GreatEnumeration {
     static var amazingStoredTypeProperty: String = “An amazing stored type property!”
     static var bestComputedTypeProperty: String {
          return “This is not ” + amazingStoredTypeProperty + ” This is a computed type property”
     }
}
//query & set type properties
var anEnumeration = GreatEnumeration.amazingStoredTypeProperty
GreatEnumeration.amazingStoredTypeProperty = “Changed”
anEnumeration = GreatEnumeration.amazingStoredTypeProperty

//class keyword to define type properties for class types
class BestClassEver {
     var storedTypeProperty = “Boring”
     class var exampleComputedTypeProperty: String {
          return “The stored type is ” + BestClassEver().storedTypeProperty
     }
}
var aGreatClass = BestClassEver()
BestClassEver.exampleComputedTypeProperty

//Querying & Setting Type Properties
//This has been done on some of the above lines, but I’ll do again.
//example querying a type property
GreatEnumeration.amazingStoredTypeProperty
//example setting a type property
GreatEnumeration.amazingStoredTypeProperty = “A simple alteration”
//another query
GreatEnumeration.amazingStoredTypeProperty

Learn Swift: Classes and Structures

This post includes Swift code to be used in XCode Playgrounds.  The code illustrates functions in Swift as detailed in the Classes and Structures section in Apple’s book The Swift Programming Language.

I think opening and playing around with the code will illuminate some of the ideas.  In the Swift code I included some comments to help provide direction.

Open XCode 6.0.

Open a new Playground file.

Copy & paste the following Swift code:

//Classes and Structures

//define BasketballPlayer structure with 2 stored properties
struct BasketballPlayer {
    var yearsOfExperience: Int? = nil
    var currentTeam: String? = nil
}
//create a new instance using initializer syntax
var aBasketballPlayer = BasketballPlayer()
//access properties using dot syntax
aBasketballPlayer.yearsOfExperience = 4
aBasketballPlayer.currentTeam = “Warriors”
//use auto-generated memberwise initializer for structure types (note: classes do not have this)
let thePlayer = BasketballPlayer(yearsOfExperience: 6, currentTeam: “Knicks”)

//define Person class with 4 stored properties
class Person {
    var age: Int? = nil
    var height: Double? = nil //in inches
    var occupation = BasketballPlayer()
}
//create a new instance using initializer syntax
var aPerson = Person()
//access properties using dot syntax
aPerson.age = 28
aPerson.height = 75.2
//access sub-properties by using multiple dots
aPerson.occupation.currentTeam = “Celtics”
aPerson.occupation.yearsOfExperience = 5

//structures and enumerations are value types (i.e. assigning a value type to a variable or constant or passing one to a function results in a copy)
var anotherPlayer = thePlayer
anotherPlayer.currentTeam = “Kings”
//notice thePlayer.currentTeam didn’t change
thePlayer.currentTeam

//classes are reference types (i.e. a reference to the same instance is used when setting variables, constants, and passing a reference type to a function)
let thePerson = aPerson
thePerson.age = 24
//notice aPerson.age changed since thePerson and aPerson point to the same instance of Person
aPerson.age
//also notice thePerson is a constant, but we can change it’s age property; this is b/c we didn’t change the value of aPerson (i.e. the reference to the Person instance)

//identity operators
aPerson === thePerson  //Do aPerson and thePerson refer to the same class instance?
aPerson !== thePerson  //Do aPerson and thePerson not refer to the same class instance?

//pointers: a Swift variable or constant of reference type is not a direct pointer to an address in memory, but is like a pointer

//classes vs. structures
//class instances are passed by reference
//structure instances are passed by value

//assignment & copy behavior for Strings, Arrays, & Dictionaries
//I recommend reading the small section (including the note at the end) in Apple’s book.
//Swift implements String, Array, & Dictionary types as structures.
//Objective-C implements NSString, NSArray, & NS Dictionary as classes.

Learn Swift: Control Flow

I will add a series of posts on learning Swift.

This post includes Swift code to be used in XCode Playgrounds.  The code illustrates a few of the control flow principles mentioned at the end of the Control Flow section in Apple’s book The Swift Programming Language.

I think opening and playing around with the code will illuminate some of the ideas.  In the Swift code I included some comments to help provide direction.

Open XCode 6.0.

Open a new Playground file.

Copy & paste the following Swift code:
// command click on UIKit below to see what it includes
import UIKit

//value binding and the where clause

//person is a tuple of type (String, Int)
let person = (“Pat”, 34)
switch person {
case (let name, 34):
println(“\(name) is 34 years old.”)
     case (“John”, let age):
          println(“John is \(age)”)
     case (let name, let age) where name == “Pat”:
          println(“Pat is \(age)”)
     case (let name, let age):
          println(“\(name) is \(age)”)

}

//Control Transfer statements

for i in 1…20 {

     //don’t print the unlucky number 13
     if i == 13 {
          continue
     }

     //don’t print past 17
     if i == 17 {
          break
     }
     println(“i == \(i)”)
}

//comment in and out fallthrough keyword to see the effect
let name = “Johnny”
var outputString = “”

switch name {
     case “Johnny”:
          outputString += “1,”
          fallthrough
     case “Ted”:
          outputString += “2,”
     case “Johnny”:
          outputString += “3,”
          fallthrough
     default:
          outputString += “4”
}
outputString

//labeled statements
let numberArray = [4, 5, 1, 2, 7, 10]
var i = 0
theGameLabel: while numberArray[i] != 7 {

                                   switch numberArray[i] {
                                        case 1:
                                             //the number is 1
                                             println(“\(numberArray[i])”)
                                             i++
                                             //notice the effect of this break that doesn’t use the label theGameLabel
                                             break
                                        case 2:
                                             //the number is 2
                                             println(“\(numberArray[i])”)
                                             i++
                                             break theGameLabel
                                        default:
                                             println(“\(numberArray[i])”)
                                             i++
                                             println(“Not 1, 2, or 7”)

                                   }

                              }