MapStack - lesson 0

Transcript

2. iOS Application > Single View Application Product Name: ‘MapStack’ Organization Name: your name Organization id and bundle id: reverse domain of your name Language: Objective-C Uncheck ‘use core data’ and ‘include UI tests’ Check ‘Create a Git Repository’ Creating a new Xcode project
3. The standard C ‘main’ function Foundation and UIKit #import vs #include Compiler directives
4. The Run Loop “Run loops are what separates interactive apps from command-line tools” - Nicolas Bouilleaud The run loop allows your app to wait for the user to touch the screen before responding. The run loop ‘listens’ for this touch event.
5. The Run Loop Think of it as a taxi cab that circles a city block over and over waiting to pick you up. Or like a Pneumatic tube at a bank drive-through waiting for you to put a message in the tube so it can wisk it away.
6. The Run Loop There is exactly one run loop for each thread. There are six types of events that will cause a run loop to deliver a message. Besides touch events, they can be timers or messages from other apps. The important thing to remember is that the main thread (good old main()) starts an event loop at app launch that ‘listens’ for touch/shake/rotate/tap/etc. events.
7. The Run Loop The important thing to remember is that the main thread (good old main()) starts an event loop at app launch that ‘listens’ for touches/shakes/rotations/taps/etc.
8. The Lifecycle of an iOS app Info.plist (just XML under the hood) for high level app configuration
9. The Lifecycle of an iOS app The AppDelegate listens for device related events
10. The Lifecycle of an iOS app
11. Object Oriented Programming Concepts Each will have its own slide… Methods and Properties Encapsulation Inheritance Polymorphism Introspection Delegation Reference semantics
12. Methods and properties The methods are what the object does, the properties are the things the object has. Some find it easier to think of methods as verbs and properties as nouns. Methods and properties are declared publicly in interface files (.h extension) and privately in implementation files (.m extension). Frameworks will only expose header files so that you only get the info that you need without worrying about implementation (or being able to breach copyright).
13. Methods and properties Public methods give you access to private implementations. This is known as encapsulation...
14. Encapsulation Objects hide as much information as they can You cannot get an object’s data unless that object exposes its data. When you’re a junior developer, your project manager may create just the interface file and have you fill out the implementation details.
15. Inheritance All classes are descended from other classes except for the root class. NSObject -> UIResponder -> AppDelegate -> UIWindow -> UIViewController -> UIView -> UILabel Everything descends from NSObject. All objects are related to NSObject.
16. Inheritance NSObject -> UIResponder -> AppDelegate -> UIWindow -> UIViewController -> UIView -> UILabel These last 3 are what you’ll be working with most of the time. You’ll also spend some time with AppDelegate. UIResponder and UIWindow, not so much.
17. Polymorphism Objects have ownership of their methods and properties so that methods with the same name but different owners can do different things. A Car object and a House object both have a numberOfDoors public property but the runtime doesn’t get confused because of polymorphism
18. Introspection Objects know about their own abilities Objects have methods like isKindOfClass, isMemberOfClass, respondsToSelector, etc. These methods reveal meta info about the object - different from most methods that reveal and manipulate program data or properties.
19. Delegation from the Apple Docs: “A delegate is an object that acts on behalf of, or in coordination with, another object when that object encounters an event in a program.” The delegate pattern so important and popular in Apple land that we’ll be using it and referring back to it throughout the course.
20. Reference semantics
21. Reference semantics Objects are typically allocated on the heap, primitives on the stack.
22. Primitives vs objects Objects are like turbocharged C structs. But structs... Rarely have methods Usually have basic inheritance Basic data hiding (encapsulation) that’s error-prone and forced Pseudo-polymorphism.
23. structs vs objects Structs aren’t used like this is the real world. Objects are a better representation of the real world. The biggest difference is that objects have reference semantics as we discussed.
24. Automatic Reference Counting ARC is how Objective-C manages memory Each object on the heap has a retain count. If the retain count reaches 0, the object is deallocated (free() is called under the hood).
25. Automatic Reference Counting An object that is a local variable inside of a function has a retain count of 1 until that function returns. Objects that are ‘owned’ by other objects have a retain count of 1. The more ‘owners’ an object has, the higher its retain count.
26. Automatic Reference Counting Let’s breakdown this verbose property declaration: @property - compiler declaration that our class has an encapsulated value. nonatomic - allocating this property is thread safe - concurrent processing can be done. strong - increments this pointer’s retain count by one . readonly - this datatype can only be accessed via a setter that is implemented by you. nullable - indicates that the pointer can be nil. Contrast this with null_unspecified, nonnull, and null_resettable. <NSString *> - indicates that the elements in the array are of type NSString and are also pointers
27. Storage and Instance variables
28. atomic vs nonatomic Properties almost always use ‘nonatomic’ storage in any project you’ll see. Only projects that deal with multi-threaded environments should use ‘atomic’ storage. Atomic code is treated as a critical section of code and is guaranteed to complete before any other thread gets access to the data inside, because of this safety feature, it is slower to allocate atomic properties.
29. Objects are everywhere!
30. Xcode crash course Each will get its own slide Navigator Main Window Debug area Utilities Devices Organizer
31. Navigator Project navigator - Files, asset catalogs, xibs, plists, frameworks Symbol navigator - Mostly classes Find navigator - Search Issue navigator - Warnings and errors Test navigator - Test files Debug navigator - Debugging Breakpoint navigator - Breakpoints Report navigator - Build, debug, and run logs
32. Main Window Meta panel - (Shown right, studying this will help in understanding OOP) Standard editor - shows one file at a time Assistant editor - defaults to show the header and implementation files Version editor - shows changes since the last commit
33. Debug area Debug console Breakpoint console