COMP327 Mobile Computing Session: Lecture Set 1a - Swift Introduction and the Foundation Framework Part 2

Transcription

1 COMP327 Mobile Computing Session: Lecture Set 1a - Swift Introduction and the Foundation Framework Part 2 73

2 Other Swift Guard Already seen that for optionals it may be necessary to test that a value is not nil, using if let if let name = places[currentplace]["name"] { Nested if statements lead to the pyramid of doom if currentplace!= -1 { if places.count > currentplace { if let name = places[currentplace]["name"] { if let lat = places[currentplace]["lat"] { if let lon = places[currentplace]["lon"] { if let latitude = Double(lat) { if let longitude = Double(lon) { let span = MKCoordinateSpan(latitudeDelta: 0.008, longitudedelta: 0.008) let coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude) let region = MKCoordinateRegion(center: coordinate, span: span) self.map.setregion(region, animated: true) let annotation = MKPointAnnotation() annotation.coordinate = coordinate annotation.title = name self.map.addannotation(annotation) 74

3 Other Swift Guard if currentplace!= -1 { if places.count > currentplace {... //do the rest of our processing One way to avoid this is to do your individual checks first, and for each one, exit if it fails if currentplace == -1 { return //when we get here, currentplace!= -1 if places.count <= currentplace { return //when we get here, places.count > currentplace //do the rest of our processing But then this is testing for things you don t want, which seems over-complicated. 75

4 Other Swift Guard if currentplace!= -1 { if places.count > currentplace {... //do the rest of our processing Guard lets you test for what you want, and handle the situation when it s false guard currentplace!= -1 else { return guard places.count > currentplace else { return... //do the rest of our processing Your code doesn t end up massively indented and so it is easier to read. 76

5 Other Swift Guard Normal rules of scope limit access to a variable to the scope in which it is declared if let name = places[currentplace]["name"] { //the identifier "name" is valid here (of course) print(name) //at this point, the identifier "name" is no longer valid However, using the guard equivalent, variable scope is extended to give access to the variable guard let name = places[currentplace]["name"] else { return let annotation = MKPointAnnotation() annotation.title = name //the identifier "name" is still valid here 77

6 Method Syntax Each method declaration consists of: the word func an optional return type The syntax is a name (starting with a lowercase letter) an optional list of arguments (and their data or object types) func setnumerator(n: Int)-> Int Declaring a method (function) Method Name Argument Name Argument Type Indicates we return a value Return Type 78

7 Method Syntax A dot syntax is used myinstance.method1() method3 has been declared to not have a named first parameter myinstance.method2(name: argument) myinstance.method3(anonymousarg1,name2: Arg2) myinstance.method4(name1: arg1, name2: arg2) Object receiving the message (i.e. executing the method) The method name The main (first) argument, usually named Subsequent named arguments arg-name : arg-value 79

8 Method Syntax By default all parameters are named class Counter { var count: Int = 0 func incrementby(amount: Int, numberoftimes: Int) { count += amount * numberoftimes let counter = Counter() //create an instance of the Counter class counter.incrementby(amount: 5, numberoftimes: 3) // counter value is now 15 Though can suppress the first parameter name class Counter { var count: Int = 0 func incrementby(_ amount: Int, numberoftimes: Int) { count += amount * numberoftimes let counter = Counter() //create an instance of the Counter class counter.incrementby(5, numberoftimes: 3) // counter value is now 15 80

9 Method Syntax By default, methods use their parameter names as labels for their arguments. func greet(person: String, day: String) -> String { return "Hello \(person), today is \(day)." greet(person: Bob", day: "Tuesday") Can create a custom argument label before the parameter name, or _ to use no argument label. func greet(_ person: String, on day: String) -> String { return "Hello \(person), today is \(day)." greet("john", on: "Wednesday") 81

10 Examples // Assume that we have a Person Class defined var voter = Person() voter.castvote() let theage = voter.age voter.age = 16 // Create a new instance of the class // call a no-parameter instance method // Get something (getter) // Define something (setter) if voter.canlegallyvote() { // allow the user to submit a ballot // Send several arguments to a method voter.registerforelection(ward: Wirral West,party: Labour ) // Embed the returning value of one message in another let name = voter.spouse.name 82

11 class Person { var name = " ; var age = 0 //two statements on this one line - note the ; var spouse: Person? = nil func castvote() { //do the voting here func canlegallyvote() -> Bool { return age >= 18 func registerforelection(ward: String, party: String) { //do the registration stuff here let voter = Person() var voterswife = Person() voter.name = "Terry" voter.age = 20 voterswife.name = "Valli" voterswife.age = 19 voter.spouse = voterswife voterswife.spouse = voter let theage = voter.age // Create a new instance of the class // Set the value of an instance property (setter) // Get the value of an instance property (getter) if voter.canlegallyvote() { // allow the user to submit a ballot print ("You \(voter.name), can vote ) voter.castvote() // call a no-parameter instance method voter.registerforelection(ward:"wirral West",party:"Labour") // Send 2 arguments to a method if let name = voter.spouse?.name { print(name) else { print("voter is not married") 83

12 Methods Both Types and Instances can have methods/properties themselves (denoted with the word static in a Type) We re used to seeing: let teststring = "Just Testing!" let thelength = teststring.count The Double Type has a pi property: /// The mathematical constant pi. /// /// This value should be rounded toward zero to keep user computations with /// angles from inadvertently ending up in the wrong quadrant. A type that /// conforms to the `FloatingPoint` protocol provides the value for `pi` at /// its best possible precision. /// /// print(double.pi) /// // Prints " " public static var pi: Double { get let zz = Double.pi 84

13 Methods The Double Type has a minimum method public static func minimum(_ x: Double, _ y: Double) -> Double let x2 = Double.minimum(4.56, 8.92) In Swift 3, abs is a Class method for Double. In Swift 4 this has been deprecated, and abs() is now global: let x = abs(-3.75) 85

14 Method Syntax class Robot { let R2D2 = Robot() Now got an instance of the class Robot An initialiser has been called (although it didn t do very much). class Robot { var name = " //placeholder var serialnumber = 0 //placeholder init(name:string) { self.name = name init(serialnumber:int) { self.serialnumber = serialnumber init(name:string, serialnumber:int) { self.name = name self.serialnumber = serialnumber let myrobot = Robot(name: R2D2") let yourrobot = Robot(name:"C3PO",serialNumber: ) 86

15 Method Syntax Now able to create an instance in any one of four ways. class Robot { var name = "" var serialnumber = 0 init() { init(name:string) { self.name = name init(serialnumber:int) { self.serialnumber = serialnumber init(name:string, serialnumber:int) { self.name = name self.serialnumber = serialnumber let myrobot = Robot(name: R2D2") let yourrobot = Robot(name: C3PO",serialNumber: ) let herrobot = Robot(serialNumber:209) let hisrobot = Robot() 87

16 Method Syntax Functions in Swift can have default values Can replace all four initialisers with one class Robot { var name = "" var serialnumber = 0 init(name:string = "",serialnumber:int = 0 ) { self.name = name self.serialnumber = serialnumber let myrobot = Robot(name:"R2D2") let yourrobot = Robot(name:"C3PO",serialNumber: ) let herrobot = Robot(serialNumber:209) let hisrobot = Robot() 88

17 Method Syntax Don t need to give properties values in their declarations, as long as they have values in all the initialisers! class Robot { var name : String var serialnumber : Int init(name:string = "",serialnumber:int = 0 ) { self.name = name self.serialnumber = serialnumber let myrobot = Robot(name:"R2D2") let yourrobot = Robot(name:"C3PO",serialNumber: ) let herrobot = Robot(serialNumber:209) let hisrobot = Robot() 89

18 Swift Basics Apple have a good guide to Swift 4.2 (from where some of these examples were borrowed): Swift_Programming_Language/TheBasics.html 90

19 Swift programs Xcode automatically generates the basic files for a project of the selected type. Typical single-view projects have: 91

20 Swift programs AppDelegate.swift source file has 2 functions: 1. Creates entry point and run loop for your app (equivalent to main in creates an application object to manage lifecycle of app and app delegate 2. Defines the AppDelegate class - blueprint for the app delegate object. Creates window where app content is drawn and provides place to respond to state transitions. You write your custom app-level code here. 92

21 Swift programs class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? func application(_ application: UIApplication, didfinishlaunchingwithoptions launchoptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { return true func applicationwillresignactive(_ application: UIApplication) { func applicationdidenterbackground(_ application: UIApplication) { func applicationwillenterforeground(_ application: UIApplication) { func applicationdidbecomeactive(_ application: UIApplication) { func applicationwillterminate(_ application: UIApplication) { 93

22 Swift programs ViewController.swift (for single view apps) import UIKit class ViewController: UIViewController { override func viewdidload() { super.viewdidload() // Do any additional setup after loading the view, typically from a nib. override func didreceivememorywarning() { super.didreceivememorywarning() // Dispose of any resources that can be recreated. in Xcode 10 Your code to work with this view is placed here. IBOutlets (labels etc.) and IBActions (buttons) Class and Structure names start with A-Z Method names start a-z 94

23 Memory Management within Swift Swift and the Foundation Framework 95

24 Managing Memory iphone imac RAM configuration of the imac and iphone 96

25 Managing Memory All Operating Systems support some sort of memory management - allocating and freeing up memory for processes Traditionally used some sort of Garbage Collection process to deal with formerly used blocks. Efficient Garbage Collection approaches have been problematic, and lead to Apple originally choosing manual memory management for ios. In the tightly constrained environment of the iphone, efficient use of memory is essential. 97

26 Managing Memory In Garbage Collection, an automated process runs at various times, to check which blocks can be deallocated, and return them to the general pool. Typically this involves tracing objects that are reachable via a set of root objects (and disposing of those that aren t reachable). This frees the user from too much worrying about memory allocation, but at a price. GC can be time-consuming and require significant extra resources - leading to other processes pausing. Not good if you re in the middle of a phone call! 98

27 Managing Memory Apple originally implemented a manual memory management model MRR - the user was responsible for indicating when blocks were no longer in use. These could then be handled at an appropriate point in the App lifecycle. In Objective C 2.0 (in 2007), Apple actually added a Garbage Collector for use on Mac OS Leopard. It was not enabled in Xcode projects by default, and eventually replaced by ARC. 99

28 Managing Memory There are two approaches to managing memory used in ios ARC: Automatic Reference Counting Introduced in ios5 for Objective C. Standard in Swift Compiler evaluates the requirements of your objects, and automatically inserts memory management calls at compile time. MRR: Manual Retain-Release Used prior to ios5, but still available for Objective C Developer explicitly inserts memory management calls (retain and release) into the code In Obj C, both approaches assume the developer will allocate new memory for new objects Both approaches use retain counts for each object However, ARC takes responsibility for retaining or releasing objects at compile time. In Swift, allocation and freeing of memory is automatic, via ARC 100

29 Reference Counting in Memory Management Every allocated object has a retain count Defined on NSObject (in the Foundation Framework) As long as retain count is > 0, object is alive and valid When objects are shared (i.e. owned by more than one variable), then the retain count should track this. In Objective C: +alloc and -copy create objects with retain count == 1 -retain increments retain count -release decrements retain count When retain count reaches 0, object is destroyed -dealloc method invoked automatically 101

30 Object Graph Heap Class A alloc/init Retain count = 1 mything Class B [mything retain]; Retain count = 2 Class A [mything release]; Retain count = 1 mything Heap Class B [mything release]; Retain count = 0... object destroyed 102

31 ARC When you create an instance of a class, ARC also allocates a control block to maintain it When you are done with the instance, ARC frees up the memory it used But what if it deallocated an instance that actually was in use? - most probably your app would crash ARC tracks properties, constants and variables to check the instance is not being referenced 103

32 ARC class Person { let name: String init(name: String) { self.name = name print("\(name) is being initialized") deinit { print("\(name) is being deinitialized") var reference1: Person? var reference2: Person? var reference3: Person? reference1 = Person(name: "Phil Jimmieson") // Prints "Phil Jimmieson is being initialized" Define a class Person that prints the name of the person when initialised / deinitialised Create 3 variables that will reference instances of the class Assign one to an instance reference2 = reference1 reference3 = reference1 Assign that same instance to 2 other vars reference1 = nil reference2 = nil Break these 2 strong references reference3 = nil // Prints "Phil Jimmieson is being deinitialized" Break final strong reference 104

33 ARC It is possible to have a situation where an instance never has zero strong references. e.g. two class instances have a strong reference to each other. known as a strong reference cycle Can define relationships as weak or unowned to avoid this Revisit our Person class example from earlier 105

34 class Person { var name = "" ; var age = 0 var spouse: Person? = nil init(name:string) { self.name = name; print("initialising \(name)") deinit { print("deinitialising \(name)") func castvote() { //do the voting here func canlegallyvote() -> Bool { return age >= 18 func registerforelection(ward: String, party: String) { //do the registration stuff here var voter: Person? //we re setting up optionals to eventually reference instances of our class var voterswife: Person? voter = Person(name: "Terry") voterswife = Person(name: "Valli") voter?.age = 20 voterswife?.age = 19 voter?.spouse = voterswife voterswife?.spouse = voter let theage = voter?.age if (voter?.canlegallyvote())! { // allow the user to submit a ballot print ("You \(voter!.name), can vote ) voter?.castvote() voter?.registerforelection(ward:"wirral West",party:"Labour") if let name = voter?.spouse?.name { print(name) else { print("voter is not married") voter = nil voterswife?.spouse = nil //Terry not deinitialised until this point (and only if we do this!!) voterswife = nil //Valli is deinitialised ok as well (but not if we do not do the previous line). 106

35 class Person { var name = "" ; var age = 0 weak var spouse: Person? = nil //*** note the weak reference!! *** init(name:string) { self.name = name; print("initialising \(name)") deinit { print("deinitialising \(name)") func castvote() { //do the voting here func canlegallyvote() -> Bool { return age >= 18 func registerforelection(ward: String, party: String) { //do the registration stuff here var voter: Person? //we re setting up optionals to eventually reference instances of our class var voterswife: Person? voter = Person(name: Terry") voterswife = Person(name: "Valli") voter?.age = 20 voterswife?.age = 19 voter?.spouse = voterswife voterswife?.spouse = voter let theage = voter?.age if (voter?.canlegallyvote())! { // allow the user to submit a ballot print ("You \(voter!.name), can vote") voter?.castvote() voter?.registerforelection(ward:"wirral West",party:"Labour") if let name = voter?.spouse?.name { print(name) else { print("voter is not married") voter = nil //terry is deinitialised at this point // voterswife?.spouse = nil //No longer need to set this to nil voterswife = nil //Valli is deinitialised here 107

36 The Foundation Framework Swift and the Foundation Framework 108

37 Foundation Framework Defines a base layer of classes for use in creating applications (including NSObject root class) Supports all the underlying (common) classes Common to all Apple platforms (macos, ios, tvos etc) Provides object wrappers for primitive types and collections Provides support for internationalisation and localisation with the use of dynamically loaded bundles Facilitated access to various lower level services of the operating system, including threads, file system, IPC etc Practically all Swift and Objective C applications include this framework (via e.g. UIKit) 109

38 Foundation Framework Provides a base layer of functionality for MacOS, ios, watchos and tvos apps. Fundamentals: Numbers, Data, Basic Values; Strings and Text; Collections; Dates and Times; Units and Measurement; Data Formatting; Files and Sorting App Support: Task Management; Resources; Notifications; App Extensions Support; Errors and Exceptions; Scripting Support. Files and Data Persistence: Cocoa & Cocoa Touch - the application development environments for OS X (now macos) and ios respectively. File System; Archives and Serialisation; Preferences; Spotlight; icloud Networking: URL Loading System; Bonjour Low-Level Utilities: XPC; Object Runtime; Processes and Threads; Streams, Sockets and Ports - Cocoa Touch includes the Foundation and UIKit frameworks. 110

39 Foundation Framework Several of Swift s standard types are bridged to Foundation classes String => NSString Array => NSArray Set => NSSet Dictionary => NSDictionary Means that we can utilise some of the features available to the Foundation classes but in general avoid the overhead of Foundation. In early releases of Swift, missing functionality provided by Foundation 111

40 Questions? Swift and the Foundation Framework 112