1. Trang chủ
  2. » Công Nghệ Thông Tin

Beginning iphone development with swift

813 110 0

Đang tải... (xem toàn văn)

Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang 813
Dung lượng 20,22 MB

Nội dung

Learn to build iPhone and iPad apps using the iOS SDK and Swift Beginning iPhone Development with Swift Exploring the iOS SDK David Mark | Jack Nutting | Kim Topley | Fredrik Olsson | Jeff LaMarche www.it-ebooks.info For your convenience Apress has placed some of the front matter material after the index Please use the Bookmarks and Contents at a Glance links to access them www.it-ebooks.info Contents at a Glance About the Authors�������������������������������������������������������������������������������������������������������������� xxi About the Technical Reviewer����������������������������������������������������������������������������������������� xxiii ■■Chapter 1: Welcome to the Swift Jungle���������������������������������������������������������������������������1 ■■Chapter 2: Appeasing the Tiki Gods���������������������������������������������������������������������������������13 ■■Chapter 3: Handling Basic Interaction�����������������������������������������������������������������������������51 ■■Chapter 4: More User Interface Fun��������������������������������������������������������������������������������87 ■■Chapter 5: Rotation and Adaptive Layout����������������������������������������������������������������������137 ■■Chapter 6: Multiview Applications��������������������������������������������������������������������������������175 ■■Chapter 7: Tab Bars and Pickers�����������������������������������������������������������������������������������205 ■■Chapter 8: Introduction to Table Views�������������������������������������������������������������������������247 ■■Chapter 9: Navigation Controllers and Table Views�������������������������������������������������������301 ■■Chapter 10: Collection View������������������������������������������������������������������������������������������335 ■■Chapter 11: Using Split Views and Popovers�����������������������������������������������������������������349 ■■Chapter 12: Application Settings and User Defaults������������������������������������������������������387 ■■Chapter 13: Basic Data Persistence������������������������������������������������������������������������������425 ■■Chapter 14: Documents and iCloud�������������������������������������������������������������������������������473 v www.it-ebooks.info vi Contents at a Glance ■■Chapter 15: Grand Central Dispatch, Background Processing, and You������������������������507 ■■Chapter 16: Drawing with Core Graphics����������������������������������������������������������������������541 ■■Chapter 17: Getting Started with Sprite Kit�������������������������������������������������������������������569 ■■Chapter 18: Taps, Touches, and Gestures����������������������������������������������������������������������617 ■■Chapter 19: Where Am I? Finding Your Way with Core Location and Map Kit���������������649 ■■Chapter 20: Whee! Gyro and Accelerometer! ���������������������������������������������������������������671 ■■Chapter 21: The Camera and Photo Library�������������������������������������������������������������������697 ■■Chapter 22: Application Localization�����������������������������������������������������������������������������711 ■■Appendix: A Swift Introduction to Swift������������������������������������������������������������������������737 Index���������������������������������������������������������������������������������������������������������������������������������789 www.it-ebooks.info Chapter Welcome to the Swift Jungle So, you want to write iPhone, iPod touch, and iPad applications? Well, we can’t say that we blame you iOS—the core software of all of these devices—is an exciting platform that has been seeing explosive growth since it first came out in 2007 The rise of the mobile software platform means that people are using software everywhere they go With the release of iOS 8, Xcode 6, and the latest incarnation of the iOS software development kit (SDK), things have only gotten better and more interesting What This Book Is This book is a guide to help you get started down the path to creating your own iOS applications Our goal is to get you past the initial difficulties to help you understand the way iOS applications work and how they are built As you work your way through this book, you will create a number of small applications, each designed to highlight specific iOS features and to show you how to control or interact with those features If you combine the foundation you’ll gain through this book with your own creativity and determination, and then add in the extensive and well-written documentation provided by Apple, you’ll have everything you need to build your own professional iPhone and iPad applications Tip  Dave, Jack, Jeff, and Fredrik have set up a forum for this book It’s a great place to meet like-minded folks, get your questions answered, and even answer other people’s questions The forum is at http://forum.learncocoa.org Be sure to check it out! What You Need Before you can begin writing software for iOS, you’ll need a few items For starters, you’ll need an Intel-based Macintosh running Mavericks (OS X 10.9) or Yosemite (OS X 10.10) or later Any recent Intel-based Macintosh computer—laptop or desktop—should work just fine www.it-ebooks.info CHAPTER 1: Welcome to the Swift Jungle To get access to the latest and greatest from Apple, you’ll also really need to sign up to become a registered iOS developer To create your developer account, just navigate to http://developer.apple.com/ios/ That will bring you to a page similar to the one shown in Figure 1-1 Figure 1-1.  Apple’s iOS Dev Center web site First, click Log In You’ll be prompted for your Apple ID If you don’t have an Apple ID, click Register, create such an ID, and then log in Once you are logged in, you’ll be taken to the main iOS development page You’ll find links to a wealth of documentation, videos, sample code, and the like—all dedicated to teaching you the finer points of iOS application development The most important tool you’ll be using to develop iOS applications is called Xcode Xcode is Apple’s integrated development environment (IDE) Xcode includes tools for creating and debugging source code, compiling applications, and performance-tuning the applications you’ve written You can download Xcode from the Mac App Store, which you can access from your Mac’s Apple menu www.it-ebooks.info CHAPTER 1: Welcome to the Swift Jungle SDK VERSIONS AND SOURCE CODE FOR THE EXAMPLES As the versions of the SDK and Xcode evolve, the mechanism for downloading them has also been changing For the past few years, Apple has been publishing the current “stable” version of Xcode and the iOS SDK on the Mac App Store, while simultaneously providing developers the ability to download preview versions of upcoming releases from its developer site Bottom line: you usually want to download the latest released (non-beta) version of Xcode and the iOS SDK, so use the Mac App Store This book has been written to work with the latest versions of Xcode and the SDK In some places, we have chosen to use new functions or methods introduced with iOS that are not available in earlier versions of the SDK We’ll be sure to point those situations out as they arise in this book Be sure to download the latest and greatest source code archive for examples from this book’s page at http://apress.com We’ll update the code as new versions of the SDK are released, so be sure to check the site periodically Developer Options The free Xcode download includes a simulator that will allow you to build and run iPhone and iPad apps on your Mac This is perfect for learning how to program for iOS However, the simulator does not support many hardware-dependent features, such as the accelerometer and camera Also, the free option will not allow you to install your applications onto a real iPhone or other device, and it does not give you the ability to distribute your applications on Apple’s App Store For those capabilities, you’ll need to sign up for one of the other options, which aren’t free:  The Standard program costs $99/year It provides a host of development tools and resources, technical support, distribution of your application via Apple’s App Store, and, most importantly, the ability to test and debug your code on an iOS device, rather than just in the simulator  The Enterprise program costs $299/year It is designed for companies developing proprietary, in-house iOS applications For more details on these programs, visit http://developer.apple.com/programs/ios and http://developer.apple.com/programs/ios/enterprise to compare the two Because iOS supports an always-connected mobile device that uses other companies’ wireless infrastructures, Apple has needed to place far more restrictions on iOS developers than it ever has on Mac developers (who are able—at the moment, anyway—to write and distribute programs with absolutely no oversight or approval from Apple) Even though the iPod touch and the Wi-Fi-only versions of the iPad don’t use anyone else’s infrastructure, they’re still subject to these same restrictions Apple has not added restrictions to be mean, but rather as an attempt to minimize the chances of malicious or poorly written programs being distributed that could degrade performance on the shared network Developing for iOS may appear to present a lot of hoops to jump through, but Apple has expended quite an effort to make the process as painless as possible And also consider that $99 is still much less expensive than buying, for example, any of the paid versions of Visual Studio, which is Microsoft’s software development IDE www.it-ebooks.info CHAPTER 1: Welcome to the Swift Jungle This may seem obvious, but you’ll also need an iPhone, iPod touch, or iPad While much of your code can be tested using the iOS simulator, not all programs can be And even those that can run on the simulator really need to be thoroughly tested on an actual device before you ever consider releasing your application to the public Note  If you are going to sign up for the Standard or Enterprise program, you should it right now The approval process can take a while, and you’ll need that approval to be able to run your applications on an actual device Don’t worry, though, because while you are waiting, you can run all the projects in the first several chapters and the majority of the applications in this book on the iOS simulator What You Need to Know This book assumes that you already have some programming knowledge It assumes that you understand the fundamentals of programming in general and object-oriented programming in particular (you know what classes, objects, loops, and variables are, for example) However, we don’t assume that you are familiar with Swift, Apple’s new programming language There’s an Appendix at the end of the book that introduces you to both Swift and the new Playground feature in Xcode that makes it easy to try out the features of this new and exciting language If you’d like to learn more about Swift after reading the material in the Appendix, here are some useful sources of additional information:  The Swift Programming Language is Apple’s own guide and reference for Swift You can get it from the iBooks store or from the iOS developer site at https://developer.apple.com/library/ios/documentation/Swift/Conceptual/ Swift_Programming_Language/index.html  Swift Quick Syntax Reference by Matthew Campbell (Apress, 2014) is a code and syntax reference for the new language See www.apress.com/9781484204405 for more details  If you have some prior experience with Objective-C, you can leverage it by reading Transitioning to Swift by Scott Gardner (Apress, 2014) See www.apress.com/9781484204078 for more information  Finally, if you’re an Android developer looking to see what life is like on the other side of the great divide, you might find Sean Liao’s Migrating to Swift from Android (Apress, 2014) helpful Read more about it at www.apress.com/9781484204375 You need to be familiar with iOS itself, as a user Just as you would with any platform for which you wanted to write an application, get to know the nuances and quirks of the iPhone, iPad, or iPod touch Take the time to get familiar with the iOS interface and with the way Apple’s iPhone and/or iPad applications look and feel www.it-ebooks.info CHAPTER 1: Welcome to the Swift Jungle What’s Different About Coding for iOS? If you have never programmed in Cocoa or its predecessors NeXTSTEP or OpenStep, you may find Cocoa Touch—the application framework you’ll be using to write iOS applications—a little alien It has some fundamental differences from other common application frameworks, such as those used when building NET or Java applications Don’t worry too much if you feel a little lost at first Just keep plugging away at the exercises, and it will all start to fall into place after a while If you have written programs using Cocoa or NeXTSTEP, a lot in the iOS SDK will be familiar to you A great many classes are unchanged from the versions that are used to develop for OS X Even those that are different tend to follow the same basic principles and similar design patterns However, several differences exist between Cocoa and Cocoa Touch Regardless of your background, you need to keep in mind some key differences between iOS development and desktop application development These differences are discussed in the following sections Only One Active Application On iOS, only one application can be active and displayed on the screen at any given time Since iOS 4, applications have been able to run in the background after the user presses the Home button, but even that is limited to a narrow set of situations, and you must code for it specifically (you’ll see exactly how to that in Chapter 15) When your application isn’t active or running in the background, it doesn’t receive any attention whatsoever from the CPU, which will wreak havoc with open network connections and the like iOS allows background processing, but making your apps play nicely in this situation will require some effort on your part Only One Window Desktop and laptop operating systems allow many running programs to coexist, each with the ability to create and control multiple windows However, unless you attach an external screen or use AirPlay, and your application is coded to handle more than one screen, iOS gives your application just one “window” to work with All of your application’s interaction with the user takes place inside this one window, and its size is fixed at the size of the screen Limited Access Programs on a desktop or laptop computer pretty much have access to everything the user who launched them does However, iOS seriously restricts what your application can access You can read and write files only from the part of iOS’s file system that was created for your application This area is called your application’s sandbox Your sandbox is where your application will store documents, preferences, and every other kind of data it may need to retain www.it-ebooks.info CHAPTER 1: Welcome to the Swift Jungle Your application is also constrained in some other ways You will not be able to access low-number network ports on iOS, for example, or anything else that would typically require root or administrative access on a desktop computer Limited Response Time Because of the way it is used, iOS needs to be snappy, and it expects the same of your application When your program is launched, you need to get your application open, the preferences and data loaded, and the main view shown on the screen as fast as possible—in no more than a few seconds At any time when your program is running, it may have the rug pulled out from under it If the user presses the Home button, iOS goes home, and you must quickly save everything before iOS suspends your application in the background If you take longer than five seconds to save and give up control, your application process will be killed, regardless of whether you finished saving There is an API that allows your app to ask for additional time to work when it’s about to go dark, but you’ve got to know how to use it Limited Screen Size The iPhone’s screen is really nice When introduced, it was the highest resolution screen available on a handheld consumer device, by far But even today, the iPhone display isn’t all that big, and as a result, you have a lot less room to work with than on modern computers The screen was just 320 × 480 on the first few iPhone generations, and it was later doubled in both directions to 640 × 960 with the introduction of the iPhone 4’s Retina display Today, the screen of the largest iPhone (the iPhone Plus) measures 1080 × 1920 pixels That sounds like a decent number of pixels, but keep in mind that these high-density displays (for which Apple uses the term “Retina”) are crammed into pretty small form factors, which has a big impact on the kinds of applications and interactivity you can offer on an iPhone and even an iPad Table 1-1 lists the sizes of the screens of all of the devices that are supported by iOS at the time of writing Table 1-1.  iOS Device Screen Sizes Device Hardware Size Software Size Scaling Factor iPhone 4s 640 × 960 320 × 480 2x iPhone and 5s 640 × 1136 320 × 568 2x iPhone 750 × 1334 375 × 667 2x iPhone Plus 1080 × 1920 414 × 736 3x iPad and iPad mini 768 × 1024 768 × 1024 1x iPad Air, iPad Retina, and iPad mini Retina 1536 × 2048 768 × 1024 2x The hardware size is the actual physical size of the screen in pixels However, when writing software, the size that really matters is the one in the Software Size column As you can see, in most cases, the software size is only half that of the actual hardware This situation came about when Apple introduced the first Retina device, which had twice as many pixels in each direction as its www.it-ebooks.info Contents ix ■■Chapter 4: More User Interface Fun��������������������������������������������������������������������������������87 A Screen Full of Controls�������������������������������������������������������������������������������������������������������������87 Active, Static, and Passive Controls���������������������������������������������������������������������������������������������91 Creating the Application��������������������������������������������������������������������������������������������������������������92 Implementing the Image View and Text Fields����������������������������������������������������������������������������93 Adding the Image View���������������������������������������������������������������������������������������������������������������������������������������� 93 Resizing the Image View������������������������������������������������������������������������������������������������������������������������������������� 96 Setting View Attributes���������������������������������������������������������������������������������������������������������������������������������������� 98 Adding the Text Fields���������������������������������������������������������������������������������������������������������������������������������������� 101 Adding Constraints�������������������������������������������������������������������������������������������������������������������������������������������� 108 Creating and Connecting Outlets����������������������������������������������������������������������������������������������������������������������� 109 Closing the Keyboard����������������������������������������������������������������������������������������������������������������111 Closing the Keyboard When Done Is Tapped������������������������������������������������������������������������������������������������������ 113 Touching the Background to Close the Keyboard���������������������������������������������������������������������������������������������� 113 Adding the Slider and Label������������������������������������������������������������������������������������������������������������������������������ 116 Adding More Constraints����������������������������������������������������������������������������������������������������������������������������������� 118 Creating and Connecting the Actions and Outlets��������������������������������������������������������������������������������������������� 119 Implementing the Action Method����������������������������������������������������������������������������������������������������������������������� 119 Implementing the Switches, Button, and Segmented Control���������������������������������������������������120 Adding Two Labeled Switches��������������������������������������������������������������������������������������������������������������������������� 122 Implementing the Switch Actions���������������������������������������������������������������������������������������������������������������������� 124 Spiffing Up the Button���������������������������������������������������������������������������������������������������������������126 Stretchable Images�������������������������������������������������������������������������������������������������������������������������������������������� 127 Control States���������������������������������������������������������������������������������������������������������������������������������������������������� 128 Connecting and Creating the Button Outlets and Actions���������������������������������������������������������������������������������� 129 Implementing the Segmented Control Action����������������������������������������������������������������������������129 Implementing the Action Sheet and Alert����������������������������������������������������������������������������������131 Showing an Action Sheet����������������������������������������������������������������������������������������������������������������������������������� 131 Showing an Alert����������������������������������������������������������������������������������������������������������������������������������������������� 135 Crossing the Finish Line������������������������������������������������������������������������������������������������������������136 www.it-ebooks.info x Contents ■■Chapter 5: Rotation and Adaptive Layout����������������������������������������������������������������������137 The Mechanics of Rotation��������������������������������������������������������������������������������������������������������138 Points, Pixels, and the Retina Display���������������������������������������������������������������������������������������������������������������� 139 Handling Rotation���������������������������������������������������������������������������������������������������������������������������������������������� 140 Choosing Your View Orientations�����������������������������������������������������������������������������������������������140 Supported Orientations at the App Level����������������������������������������������������������������������������������������������������������� 140 Per-Controller Rotation Support������������������������������������������������������������������������������������������������������������������������� 142 Designing an Interface Using Constraints���������������������������������������������������������������������������������144 Overriding Default Constraints�������������������������������������������������������������������������������������������������������������������������� 148 Full-Width Labels����������������������������������������������������������������������������������������������������������������������������������������������� 150 Creating Adaptive Layouts���������������������������������������������������������������������������������������������������������153 The Restructure Application������������������������������������������������������������������������������������������������������������������������������ 153 Size Classes������������������������������������������������������������������������������������������������������������������������������������������������������� 158 Size Classes and Storyboards��������������������������������������������������������������������������������������������������������������������������� 161 Creating the iPhone Landscape Layout������������������������������������������������������������������������������������������������������������� 164 Adding the iPad Layout�������������������������������������������������������������������������������������������������������������������������������������� 170 Rotating Out of Here������������������������������������������������������������������������������������������������������������������173 ■■Chapter 6: Multiview Applications��������������������������������������������������������������������������������175 Common Types of Multiview Apps���������������������������������������������������������������������������������������������175 The Architecture of a Multiview Application������������������������������������������������������������������������������180 The Root Controller�������������������������������������������������������������������������������������������������������������������������������������������� 183 Anatomy of a Content View�������������������������������������������������������������������������������������������������������������������������������� 184 Building View Switcher�������������������������������������������������������������������������������������������������������������184 Renaming the View Controller��������������������������������������������������������������������������������������������������������������������������� 185 Adding the Content View Controllers����������������������������������������������������������������������������������������������������������������� 187 Modifying SwitchingViewController.swift���������������������������������������������������������������������������������������������������������� 187 Building a View with a Toolbar��������������������������������������������������������������������������������������������������������������������������� 188 Linking the Toolbar Button to the View Controller��������������������������������������������������������������������������������������������� 191 Writing the Root View Controller������������������������������������������������������������������������������������������������������������������������ 192 www.it-ebooks.info Contents xi Implementing the Content Views����������������������������������������������������������������������������������������������������������������������� 197 Animating the Transition������������������������������������������������������������������������������������������������������������������������������������ 200 Switching Off�����������������������������������������������������������������������������������������������������������������������������203 ■■Chapter 7: Tab Bars and Pickers�����������������������������������������������������������������������������������205 The Pickers Application�������������������������������������������������������������������������������������������������������������206 Delegates and Data Sources�����������������������������������������������������������������������������������������������������211 Creating the Pickers Application�����������������������������������������������������������������������������������������������212 Creating the View Controllers���������������������������������������������������������������������������������������������������������������������������� 212 Creating the Tab Bar Controller�������������������������������������������������������������������������������������������������������������������������� 213 The Initial Test Run�������������������������������������������������������������������������������������������������������������������������������������������� 217 Implementing the Date Picker���������������������������������������������������������������������������������������������������218 Implementing the Single-Component Picker�����������������������������������������������������������������������������221 Building the View����������������������������������������������������������������������������������������������������������������������������������������������� 221 Implementing the Controller As a Data Source and Delegate���������������������������������������������������������������������������� 223 Implementing a Multicomponent Picker�����������������������������������������������������������������������������������226 Declaring Outlets and Actions��������������������������������������������������������������������������������������������������������������������������� 226 Building the View����������������������������������������������������������������������������������������������������������������������������������������������� 227 Implementing the Controller������������������������������������������������������������������������������������������������������������������������������ 227 Implementing Dependent Components�������������������������������������������������������������������������������������230 Creating a Simple Game with a Custom Picker�������������������������������������������������������������������������237 Preparing the View Controller���������������������������������������������������������������������������������������������������������������������������� 237 Building the View����������������������������������������������������������������������������������������������������������������������������������������������� 237 Implementing the Controller������������������������������������������������������������������������������������������������������������������������������ 239 Final Details������������������������������������������������������������������������������������������������������������������������������������������������������� 242 Final Spin����������������������������������������������������������������������������������������������������������������������������������246 ■■Chapter 8: Introduction to Table Views�������������������������������������������������������������������������247 Table View Basics����������������������������������������������������������������������������������������������������������������������248 Table Views and Table View Cells���������������������������������������������������������������������������������������������������������������������� 248 Grouped and Plain Tables���������������������������������������������������������������������������������������������������������������������������������� 250 www.it-ebooks.info xii Contents Implementing a Simple Table����������������������������������������������������������������������������������������������������251 Designing the View�������������������������������������������������������������������������������������������������������������������������������������������� 251 Writing the Controller���������������������������������������������������������������������������������������������������������������������������������������� 253 Adding an Image������������������������������������������������������������������������������������������������������������������������������������������������ 258 Using Table View Cell Styles������������������������������������������������������������������������������������������������������������������������������ 259 Setting the Indent Level������������������������������������������������������������������������������������������������������������������������������������� 262 Handling Row Selection������������������������������������������������������������������������������������������������������������������������������������� 263 Changing the Font Size and Row Height����������������������������������������������������������������������������������������������������������� 266 Customizing Table View Cells����������������������������������������������������������������������������������������������������269 Adding Subviews to the Table View Cell ����������������������������������������������������������������������������������������������������������� 269 Creating a UITableViewCell Subclass����������������������������������������������������������������������������������������������������������������� 270 Loading a UITableViewCell from a Nib��������������������������������������������������������������������������������������������������������������� 274 Grouped and Indexed Sections��������������������������������������������������������������������������������������������������280 Building the View����������������������������������������������������������������������������������������������������������������������������������������������� 280 Importing the Data��������������������������������������������������������������������������������������������������������������������������������������������� 280 Implementing the Controller������������������������������������������������������������������������������������������������������������������������������ 281 Adding an Index������������������������������������������������������������������������������������������������������������������������������������������������� 285 Implementing a Search Bar�������������������������������������������������������������������������������������������������������287 How Many Tables?: View Debugging�����������������������������������������������������������������������������������������296 Putting It All on the Table�����������������������������������������������������������������������������������������������������������299 ■■Chapter 9: Navigation Controllers and Table Views�������������������������������������������������������301 Navigation Controller Basics�����������������������������������������������������������������������������������������������������302 Stacky Goodness����������������������������������������������������������������������������������������������������������������������������������������������� 302 A Stack of Controllers���������������������������������������������������������������������������������������������������������������������������������������� 302 Fonts: A Simple Font Browser���������������������������������������������������������������������������������������������������304 Meet the Subcontrollers������������������������������������������������������������������������������������������������������������������������������������ 305 The Fonts Application’s Skeleton����������������������������������������������������������������������������������������������������������������������� 307 Creating the Root View Controller���������������������������������������������������������������������������������������������311 Initial Storyboard Setup�������������������������������������������������������������������������������������������������������������314 www.it-ebooks.info Contents xiii First Subcontroller: The Font List View��������������������������������������������������������������������������������������316 Storyboarding the Font List������������������������������������������������������������������������������������������������������������������������������� 318 Making the Root View Controller Prepare for Segues���������������������������������������������������������������������������������������� 319 Creating the Font Sizes View Controller������������������������������������������������������������������������������������320 Storyboarding the Font Sizes View Controller��������������������������������������������������������������������������������������������������� 322 Making the Font List View Controller Prepare for Segues��������������������������������������������������������������������������������� 322 Creating the Font Info View Controller���������������������������������������������������������������������������������������323 Storyboarding the Font Info View Controller������������������������������������������������������������������������������������������������������ 324 Setting Up Constraints��������������������������������������������������������������������������������������������������������������������������������������� 326 Adapting the Font List View Controller for Multiple Segues������������������������������������������������������������������������������ 326 My Favorite Fonts���������������������������������������������������������������������������������������������������������������������������������������������� 327 Table View Niceties�������������������������������������������������������������������������������������������������������������������328 Implementing Swipe-to-Delete������������������������������������������������������������������������������������������������������������������������� 329 Implementing Drag-to-Reorder������������������������������������������������������������������������������������������������������������������������� 331 Breaking the Tape����������������������������������������������������������������������������������������������������������������������333 ■■Chapter 10: Collection View������������������������������������������������������������������������������������������335 Creating the DialogViewer Project���������������������������������������������������������������������������������������������335 Fixing the View Controller’s Class���������������������������������������������������������������������������������������������337 Defining Custom Cells���������������������������������������������������������������������������������������������������������������337 Configuring the View Controller�������������������������������������������������������������������������������������������������341 Providing Content Cells�������������������������������������������������������������������������������������������������������������342 Making the Layout Flow������������������������������������������������������������������������������������������������������������343 Providing Header Views�������������������������������������������������������������������������������������������������������������346 ■■Chapter 11: Using Split Views and Popovers�����������������������������������������������������������������349 Building Master-Detail Applications with UISplitViewController������������������������������������������������352 The Storyboard Defines the Structure��������������������������������������������������������������������������������������������������������������� 354 The Code Defines the Functionality������������������������������������������������������������������������������������������������������������������� 356 How the Master-Detail Template Application Works������������������������������������������������������������������������������������������ 361 Here Come the Presidents���������������������������������������������������������������������������������������������������������364 Creating Your Own Popover�������������������������������������������������������������������������������������������������������371 www.it-ebooks.info xiv Contents Split Views on the iPhone����������������������������������������������������������������������������������������������������������377 Split Views on the iPhone Plus����������������������������������������������������������������������������������������������������������������������� 380 Getting the iPhone Plus Behavior on All iPhones�������������������������������������������������������������������������������������������� 381 Customizing the Split View��������������������������������������������������������������������������������������������������������384 Time to Wrap Up and Split���������������������������������������������������������������������������������������������������������386 ■■Chapter 12: Application Settings and User Defaults������������������������������������������������������387 Getting to Know Your Settings Bundle���������������������������������������������������������������������������������������387 The Bridge Control Application��������������������������������������������������������������������������������������������������389 Creating the Project������������������������������������������������������������������������������������������������������������������������������������������� 394 Working with the Settings Bundle��������������������������������������������������������������������������������������������������������������������� 395 Reading Settings in Our Application������������������������������������������������������������������������������������������������������������������ 413 Changing Defaults from Our Application����������������������������������������������������������������������������������������������������������� 417 Registering Default Values��������������������������������������������������������������������������������������������������������������������������������� 420 Keeping It Real�������������������������������������������������������������������������������������������������������������������������������������������������� 421 Switching to the Settings Application���������������������������������������������������������������������������������������424 Beam Me Up, Scotty������������������������������������������������������������������������������������������������������������������424 ■■Chapter 13: Basic Data Persistence������������������������������������������������������������������������������425 Your Application’s Sandbox�������������������������������������������������������������������������������������������������������426 Getting the Documents and Library Directories������������������������������������������������������������������������������������������������� 428 Getting the tmp Directory���������������������������������������������������������������������������������������������������������������������������������� 429 File-Saving Strategies���������������������������������������������������������������������������������������������������������������429 Single-File Persistence�������������������������������������������������������������������������������������������������������������������������������������� 430 Multiple-File Persistence����������������������������������������������������������������������������������������������������������������������������������� 430 Using Property Lists������������������������������������������������������������������������������������������������������������������430 Property List Serialization���������������������������������������������������������������������������������������������������������������������������������� 431 The First Version of the Persistence Application����������������������������������������������������������������������������������������������� 432 Archiving Model Objects������������������������������������������������������������������������������������������������������������439 Conforming to NSCoding����������������������������������������������������������������������������������������������������������������������������������� 439 Implementing NSCopying���������������������������������������������������������������������������������������������������������������������������������� 441 Archiving and Unarchiving Data Objects����������������������������������������������������������������������������������������������������������� 442 The Archiving Application���������������������������������������������������������������������������������������������������������������������������������� 443 www.it-ebooks.info Contents xv Using iOS’s Embedded SQLite3�������������������������������������������������������������������������������������������������446 Creating or Opening the Database��������������������������������������������������������������������������������������������������������������������� 447 Using Bind Variables������������������������������������������������������������������������������������������������������������������������������������������ 448 The SQLite3 Application������������������������������������������������������������������������������������������������������������������������������������� 450 Using Core Data�������������������������������������������������������������������������������������������������������������������������456 Entities and Managed Objects��������������������������������������������������������������������������������������������������������������������������� 458 The Core Data Application��������������������������������������������������������������������������������������������������������������������������������� 462 Persistence Rewarded��������������������������������������������������������������������������������������������������������������472 ■■Chapter 14: Documents and iCloud�������������������������������������������������������������������������������473 Managing Document Storage with UIDocument�����������������������������������������������������������������������474 Building TinyPix������������������������������������������������������������������������������������������������������������������������������������������������� 474 Creating TinyPixDocument��������������������������������������������������������������������������������������������������������������������������������� 475 Code Master������������������������������������������������������������������������������������������������������������������������������������������������������ 478 Initial Storyboarding������������������������������������������������������������������������������������������������������������������������������������������ 485 Creating TinyPixView����������������������������������������������������������������������������������������������������������������������������������������� 489 Storyboard Detailing������������������������������������������������������������������������������������������������������������������������������������������ 493 Adding iCloud Support���������������������������������������������������������������������������������������������������������������497 Creating a Provisioning Profile�������������������������������������������������������������������������������������������������������������������������� 498 How to Query����������������������������������������������������������������������������������������������������������������������������������������������������� 500 Save Where?������������������������������������������������������������������������������������������������������������������������������������������������������ 502 Storing Preferences on iCloud��������������������������������������������������������������������������������������������������������������������������� 503 What We Didn’t Cover����������������������������������������������������������������������������������������������������������������505 ■■Chapter 15: Grand Central Dispatch, Background Processing, and You������������������������507 Grand Central Dispatch�������������������������������������������������������������������������������������������������������������507 Introducing SlowWorker �����������������������������������������������������������������������������������������������������������508 Threading Basics�����������������������������������������������������������������������������������������������������������������������511 Units of Work�����������������������������������������������������������������������������������������������������������������������������512 GCD: Low-Level Queuing�����������������������������������������������������������������������������������������������������������512 Improving SlowWorker�������������������������������������������������������������������������������������������������������������������������������������� 514 www.it-ebooks.info xvi Contents Background Processing������������������������������������������������������������������������������������������������������������520 Application Life Cycle���������������������������������������������������������������������������������������������������������������������������������������� 521 State-Change Notifications�������������������������������������������������������������������������������������������������������������������������������� 522 Creating State Lab��������������������������������������������������������������������������������������������������������������������������������������������� 523 Exploring Execution States�������������������������������������������������������������������������������������������������������������������������������� 524 Using Execution State Changes������������������������������������������������������������������������������������������������������������������������� 526 Handling the Inactive State������������������������������������������������������������������������������������������������������������������������������� 527 Handling the Background State������������������������������������������������������������������������������������������������������������������������� 531 Grand Central Dispatch, Over and Out���������������������������������������������������������������������������������������539 ■■Chapter 16: Drawing with Core Graphics����������������������������������������������������������������������541 Paint the World��������������������������������������������������������������������������������������������������������������������������541 The Quartz 2D Approach to Drawing�����������������������������������������������������������������������������������������542 Quartz 2D’s Graphics Contexts�������������������������������������������������������������������������������������������������������������������������� 542 The Coordinate System������������������������������������������������������������������������������������������������������������������������������������� 543 Specifying Colors����������������������������������������������������������������������������������������������������������������������������������������������� 545 Drawing Images in Context�������������������������������������������������������������������������������������������������������������������������������� 547 Drawing Shapes: Polygons, Lines, and Curves�������������������������������������������������������������������������������������������������� 547 Quartz 2D Tool Sampler: Patterns, Gradients, and Dash Patterns���������������������������������������������������������������������� 548 The QuartzFun Application��������������������������������������������������������������������������������������������������������549 Setting Up the QuartzFun Application���������������������������������������������������������������������������������������������������������������� 549 Adding Quartz 2D Drawing Code����������������������������������������������������������������������������������������������������������������������� 559 Optimizing the QuartzFun Application��������������������������������������������������������������������������������������������������������������� 564 Drawing to a Close��������������������������������������������������������������������������������������������������������������������567 ■■Chapter 17: Getting Started with Sprite Kit�������������������������������������������������������������������569 Simple Beginnings��������������������������������������������������������������������������������������������������������������������570 Initial Scene Customization������������������������������������������������������������������������������������������������������������������������������� 576 Player Movement����������������������������������������������������������������������������������������������������������������������580 Adding the Player to the Scene������������������������������������������������������������������������������������������������������������������������� 582 Handling Touches: Player Movement����������������������������������������������������������������������������������������������������������������� 583 Geometry Calculations��������������������������������������������������������������������������������������������������������������������������������������� 584 Wobbly Bits�������������������������������������������������������������������������������������������������������������������������������������������������������� 585 www.it-ebooks.info Contents xvii Creating Your Enemies��������������������������������������������������������������������������������������������������������������586 Putting Enemies in the Scene���������������������������������������������������������������������������������������������������587 Start Shooting���������������������������������������������������������������������������������������������������������������������������588 Defining Your Physics Categories���������������������������������������������������������������������������������������������������������������������� 589 Creating the BulletNode Class��������������������������������������������������������������������������������������������������������������������������� 589 Applying Physics������������������������������������������������������������������������������������������������������������������������������������������������ 590 Adding Bullets to the Scene������������������������������������������������������������������������������������������������������������������������������ 591 Attacking Enemies with Physics�����������������������������������������������������������������������������������������������593 Finishing Levels�������������������������������������������������������������������������������������������������������������������������594 Keeping Tabs on the Enemies���������������������������������������������������������������������������������������������������������������������������� 595 Transitioning to the Next Levels������������������������������������������������������������������������������������������������������������������������ 596 Customizing Collisions��������������������������������������������������������������������������������������������������������������597 Adding a Class Extension to SKNode����������������������������������������������������������������������������������������������������������������� 599 Adding Custom Collision Behavior to Enemies�������������������������������������������������������������������������������������������������� 600 Showing Accurate Player Lives������������������������������������������������������������������������������������������������������������������������� 601 Spicing Things Up with Particles�����������������������������������������������������������������������������������������������602 Your First Particle���������������������������������������������������������������������������������������������������������������������������������������������� 603 Putting Particles into the Scene������������������������������������������������������������������������������������������������������������������������ 605 The End Game���������������������������������������������������������������������������������������������������������������������������607 At Last, a Beginning: Create a StartScene���������������������������������������������������������������������������������609 A Sound Is Worth a Thousand Pictures��������������������������������������������������������������������������������������612 Making the Game a Little Harder: Force Fields�������������������������������������������������������������������������613 Game On������������������������������������������������������������������������������������������������������������������������������������616 ■■Chapter 18: Taps, Touches, and Gestures����������������������������������������������������������������������617 Multitouch Terminology�������������������������������������������������������������������������������������������������������������617 The Responder Chain����������������������������������������������������������������������������������������������������������������618 Responding to Events���������������������������������������������������������������������������������������������������������������������������������������� 618 Forwarding an Event: Keeping the Responder Chain Alive�������������������������������������������������������������������������������� 620 www.it-ebooks.info xviii Contents The Multitouch Architecture������������������������������������������������������������������������������������������������������620 The Four Touch Notification Methods����������������������������������������������������������������������������������������621 The TouchExplorer Application��������������������������������������������������������������������������������������������������622 The Swipes Application�������������������������������������������������������������������������������������������������������������626 Using Touch Events to Detect Swipes���������������������������������������������������������������������������������������������������������������� 627 Automatic Gesture Recognition������������������������������������������������������������������������������������������������������������������������� 630 Implementing Multiple Swipes�������������������������������������������������������������������������������������������������������������������������� 631 Detecting Multiple Taps�������������������������������������������������������������������������������������������������������������633 Detecting Pinch and Rotation����������������������������������������������������������������������������������������������������638 Defining Custom Gestures���������������������������������������������������������������������������������������������������������642 The CheckPlease Application 643 The CheckPlease Touch Methods 645 Garỗon? Check, Please!647 ■■Chapter 19: Where Am I? Finding Your Way with Core Location and Map Kit���������������649 The Location Manager���������������������������������������������������������������������������������������������������������������650 Setting the Desired Accuracy���������������������������������������������������������������������������������������������������������������������������� 650 Setting the Distance Filter��������������������������������������������������������������������������������������������������������������������������������� 651 Getting Permission to Use Location Services���������������������������������������������������������������������������������������������������� 651 Starting the Location Manager�������������������������������������������������������������������������������������������������������������������������� 651 Using the Location Manager Wisely������������������������������������������������������������������������������������������������������������������� 652 The Location Manager Delegate������������������������������������������������������������������������������������������������652 Getting Location Updates���������������������������������������������������������������������������������������������������������������������������������� 652 Getting Latitude and Longitude Using CLLocation��������������������������������������������������������������������������������������������� 652 Error Notifications���������������������������������������������������������������������������������������������������������������������������������������������� 654 Trying Out Core Location�����������������������������������������������������������������������������������������������������������655 Using Location Manager Updates���������������������������������������������������������������������������������������������������������������������� 661 Visualizing Your Movement on a Map����������������������������������������������������������������������������������������663 Changing Location Service Permissions����������������������������������������������������������������������������������������������������������� 667 Wherever You Go, There You Are������������������������������������������������������������������������������������������������668 www.it-ebooks.info Contents xix ■■Chapter 20: Whee! Gyro and Accelerometer! ���������������������������������������������������������������671 Accelerometer Physics��������������������������������������������������������������������������������������������������������������671 Don’t Forget Rotation����������������������������������������������������������������������������������������������������������������673 Core Motion and the Motion Manager���������������������������������������������������������������������������������������673 Event-Based Motion������������������������������������������������������������������������������������������������������������������������������������������ 674 Proactive Motion Access����������������������������������������������������������������������������������������������������������������������������������� 678 Gyroscope and Attitude Results������������������������������������������������������������������������������������������������������������������������� 681 Accelerometer Results�������������������������������������������������������������������������������������������������������������������������������������� 681 Detecting Shakes����������������������������������������������������������������������������������������������������������������������683 Baked-In Shaking���������������������������������������������������������������������������������������������������������������������������������������������� 683 Shake and Break����������������������������������������������������������������������������������������������������������������������������������������������� 684 Accelerometer As Directional Controller�����������������������������������������������������������������������������������687 Rolling Marbles�������������������������������������������������������������������������������������������������������������������������������������������������� 687 Writing the Ball View����������������������������������������������������������������������������������������������������������������������������������������� 690 Calculating Ball Movement�������������������������������������������������������������������������������������������������������������������������������� 692 Rolling On����������������������������������������������������������������������������������������������������������������������������������695 ■■Chapter 21: The Camera and Photo Library�������������������������������������������������������������������697 Using the Image Picker and UIImagePickerController���������������������������������������������������������������697 Using the Image Picker Controller���������������������������������������������������������������������������������������������697 Implementing the Image Picker Controller Delegate����������������������������������������������������������������������������������������� 700 Road Testing the Camera and Library���������������������������������������������������������������������������������������701 Designing the Interface������������������������������������������������������������������������������������������������������������������������������������� 702 Implementing the Camera View Controller�������������������������������������������������������������������������������������������������������� 705 It’s a Snap!��������������������������������������������������������������������������������������������������������������������������������709 ■■Chapter 22: Application Localization�����������������������������������������������������������������������������711 Localization Architecture�����������������������������������������������������������������������������������������������������������711 Strings Files������������������������������������������������������������������������������������������������������������������������������713 What’s in a Strings File?������������������������������������������������������������������������������������������������������������������������������������ 713 The Localized String Function��������������������������������������������������������������������������������������������������������������������������� 714 www.it-ebooks.info xx Contents Real-World iOS: Localizing Your Application������������������������������������������������������������������������������715 Setting Up LocalizeMe��������������������������������������������������������������������������������������������������������������������������������������� 716 Trying Out LocalizeMe��������������������������������������������������������������������������������������������������������������������������������������� 719 Localizing the Project���������������������������������������������������������������������������������������������������������������������������������������� 720 Localizing the Storyboard���������������������������������������������������������������������������������������������������������������������������������� 724 Generating and Localizing a Strings File����������������������������������������������������������������������������������������������������������� 726 Previewing Localizations in Xcode��������������������������������������������������������������������������������������������731 Localizing the App Display Name���������������������������������������������������������������������������������������������������������������������� 733 Adding Another Localization������������������������������������������������������������������������������������������������������734 Auf Wiedersehen�����������������������������������������������������������������������������������������������������������������������734 ■■Appendix: A Swift Introduction to Swift������������������������������������������������������������������������737 Index���������������������������������������������������������������������������������������������������������������������������������789 www.it-ebooks.info About the Authors Dave Mark is a longtime Mac developer and author who has written a number of books on Mac and iOS development, including Beginning iOS Development (Apress, 2013), More iOS Development (Apress, 2013), Learn C on the Mac (Apress, 2013), Ultimate Mac Programming (Wiley, 1995), and the Macintosh Programming Primer series (Addison-Wesley, 1992) Dave was one of the founders of MartianCraft, an iOS and Android development house Dave loves the water and spends as much time as possible on it, in it, or near it He lives with his wife and three children in Virginia On Twitter, he’s @davemark Jack Nutting has been using Cocoa since the olden days, long before it was even called Cocoa He has used Cocoa and its predecessors to develop software for a wide range of industries and applications, including gaming, graphic design, online digital distribution, telecommunications, finance, publishing, and travel Jack has written several books on iOS and Mac development, including Beginning iOS Development (Apress, 2013), Learn Cocoa on the Mac (Apress, 2013), and Beginning iPad Development for iPhone Developers (Apress, 2010) Besides writing software and books, he also leads developer training and blogs from time to time at www.nuthole.com He’s @jacknutting on Twitter xxi www.it-ebooks.info xxii About the Authors Kim Topley is a software engineer with over 30 years of experience ranging from mainframe microcode and the UNIX kernel to graphical user interfaces and mobile applications He is the author of five books on various aspects of Java and JavaFX and has been working with iOS since reading one of the first books published on the subject—the first edition of Beginning iPhone Development Fredrik Olsson has been using Cocoa since Mac OS X 10.1 and for iPhone since the unofficial toolchain He has had a long and varied career, ranging from real-time assembly to enterprise Java He is passionate about Objective-C for its elegance, Cocoa frameworks for its clarity, and both for creating a greater whole than their parts When away from a keyboard, Fredrik has spoken at conferences and led developer training You’ll find Fredrik on Twitter as @peylow Jeff LaMarche is a Mac and an iOS developer with more than 20 years of programming experience Jeff has written a number of iOS and Mac development books, including Beginning iOS Development (Apress, 2013) and More iOS Development (Apress, 2013) Jeff is a principal at MartianCraft, an iOS and Android development house He has written about Cocoa and Objective-C for MacTech magazine, as well as articles for Apple’s developer web site Jeff also writes about iOS development for his widely read blog at www.iphonedevelopment.blogspot.com He can be found on Twitter as @jeff_lamarche www.it-ebooks.info About the Technical Reviewer Nicholas Waynik has been working in the IT field for over 15 years and has done everything from network administration to web development He started writing iOS apps when the SDK was first released Since then, he has gone on to start his own business, focusing on iOS development He loves spending his free time with his wife, Allison, and son, Preston He also sometimes plays golf He blogs at nicholaswaynik.com and can be found on Twitter as @n_dubbs xxiii www.it-ebooks.info ... get to know the nuances and quirks of the iPhone, iPad, or iPod touch Take the time to get familiar with the iOS interface and with the way Apple’s iPhone and/or iPad applications look and feel... work with than on modern computers The screen was just 320 × 480 on the first few iPhone generations, and it was later doubled in both directions to 640 × 960 with the introduction of the iPhone. .. Device Hardware Size Software Size Scaling Factor iPhone 4s 640 × 960 320 × 480 2x iPhone and 5s 640 × 1136 320 × 568 2x iPhone 750 × 1334 375 × 667 2x iPhone Plus 1080 × 1920 414 × 736 3x iPad and

Ngày đăng: 11/03/2019, 17:09