579 Results for 'accessibility'

Accessibility on OS X. My name is Patti Hoa. I'm a software engineer on the OS X Accessibility team. Today my colleague Chris Dolan and I are extremely excited to tell you about this brand new API was have installed for you that's designed to make your life

Accessibility in iOS. My name is Sam White, I am one of the iOS Accessibility Engineers here at Apple. Today, I want to talk to you about developing great applications for everyone. And I want to show you how to do that by implementing a little bit of Accessibility in

Accessibility on iOS, my name is Ian Fisch and I'm an engineer on the Accessibility team. So accessibility is really about making sure all users, regardless of abilities, have full access to all of our products and the great features you put in your apps, and that means we

Accessibility team. Welcome to Accessibility on the Watch. Before we get into that, let's talk a little bit about accessibility. As you know, there are many different kinds of users, and as you can imagine, these users have many different ways of interacting with the world. But for the

Accessibility team at Apple, and with me today I have Bhavya, an engineer on the Mac accessibility team at Apple. And together we're going to delve into what it means to create an exceptional experience in your app when it comes to accessibility. As a quick refresher, we tend

Accessibility on iPhone OS. We're going to learn how to make an app useable by everyone. My name is Chris Fleizach. I'm on the iPhone Accessibility and VoiceOver team. So when I talk about accessibility, what do I mean? I think about accessibility as using technology to overcome

Accessibility Team here at Apple. And welcome to What's New in Accessibility. Today we're going to learn about some cool new assistive features in our operating systems and learn about what you need to know to make sure your apps are usable by everyone. So let's get

Accessibility. Welcome. We think that you're here because you are a content provider involved in the production of content and you're ready to make your content more useful, more accessible to more users in more situations, or you're an app developer and you also want to make

accessible in your applications. We'll then build on some of those topics and talk about how to make your games more accessible. How do you think about accessible design in gaming. And this is really interesting. As we talk about this, it's really easy to sit back and

Accessibility Team. And I'm here today with my colleague Patti. And we're really excited to introduce to you a new tool that will make it easier than ever for you to find, diagnose and fix accessibility issues in your apps. So, some of you may be new to

accessing the information they actually need to get their work done and not having unrestricted access to your whole computer. I have an example that I, that I like. This is a beautiful new application updated for Mavericks. It's called Watch Grass Grow. I spent a lot of time

accessibility on OS X. I'm really excited to be able to have the opportunity to speak to you this morning about some of the great new accessibility features in OS X Mavericks. Here at Apple, we care very deeply about accessibility and we work really hard to deliver a

Accessibility Team here at Apple. Today, I'll be sharing with you about accessibility on iOS, and how you can develop your apps to be used by everyone. Our talk today is going to be in two parts. First, I'll give an introduction to accessibility. I'll talk about

access and modify their documents on their Windows devices. Third, we've added an iCloud folder into Finder. Now your users can add whatever documents they want into their iCloud folder in Finder and organize them however they see fit. Fourth, we've added access to this iCloud folder from

Accessibility Team. Today, I want to talk about how do you take you app to the next level in terms of accessibility. I'm going to be saying the word accessibility a lot in this presentation. What do I mean when I say this word? It can have a lot

Accessibility Team and I'm here today to talk to you about what's new in accessibility this year. So, for those of you that don't know exactly what I mean when I say accessibility well first of all, I'm happy that you're here and second, when

Accessibility and Usability of Complex Web Applications." So my teammates and I have been hard at work improving the accessibility of iWork for iCloud, which is a sophisticated suite of web applications designed to allow you to create and edit your Pages documents, your Numbers spreadsheets, and your Keynote presentations

Accessibility. Accessibility is the technology on our platforms, that gives disabled people the same great experience on our devices and with our applications that all other users receive. To make Accessibility work, it offers a rich set of semantic data about the UI that technologies like Voice Over can use

access to these. So, you need something to let you access, copy, and move documents between these locations, and this is what the Document Picker does. It goes away once the files get chosen, so if you want something which stays onscreen for a long time, you should check out

accessible technologies that Apple has built into a number of our products, and these help highlight how accessible technologies also make products better. These universal design features are making the operating system and our portable products better for everyone. And last, I want to talk about how you the developers

access control. Now, what this does is it allows your application access to its portion of the Keychain, while preventing other applications access to the same secrets. Now, I'd like to take a moment and show how your application interacts with the Keychain. And, in order for your application

accessing their user data classes. In this particular example, we see that Camera would like to access your location so that it can geotag photos and videos. Transparency is the other key ingredient. It makes it clear to the user what is going to happen with their data. It helps

access an application is by name. Here we're accessing the Safari application. And beyond name we can also access applications by Bundle ID, by Path, by Process ID, and we can get the application that's running the script we're currently in by getting the current application. So

accessing user data and more broadly, data stewardship. So for data access, let's start by talking about iOS, and much of this guidance will apply to tvOS and watchOS as well. Let's imagine you're building a game for iOS where players can compete against each other, and

access control Essentially, a predefined way of determining what programs, and to a certain extent, what users get at the secret, and they give you a way of controlling how your program and other programs can share access to these secrets If you write your secrets to a file, then

access their user data. This should already be familiar to you. The model that Apple has chosen to adopt is the Just in Time model, meaning that consent is only presented to the user at the exact time that the access occurs. We think that Just in Time access is

access to all of the windows and tabs, as an Extension developer. Unlike a webpage, where you only have access to your window and any windows you open, you can access all of the windows and tabs. You can create them. You can move them around. You can request them

access that memory which means that executing any code could potentially cause a page fault. And this is what makes swapping so dangerous. The application has no control over when these accesses to disk happen or what thread they happen on. And as a result, it's very important to

accessing. And we'll get not just its address but we'll also get some description of it. How large the heap region is and which byte out of it are we accessing. And we also get the allocation and deallocation backtrace of how that memory was allocated. So, this

accessible. But the word accessible wasn't invented to describe accommodating those with disabilities. It's about access, whoever we are. Easily reached or obtained. Easily used. Easily understood. Everyone. Whether you have a permanent or situational impairment, young or old, new or pro to technology. Whatever language you sign

access to those services that they have privileges for. And Sandboxing is that basically, they only have access to those documents or API's that they have privileges for. Now, this has kind of evolved over time because obviously, in the first release of iOS, there was no third party

access the currently interactive text field that the user has selected. And we do this via a special property, called Text Document Proxy. Now the Text Document Proxy allows you to access things like the text input traits for the currently selected text field. So, that would be stuff like

access their own data but can't get at your personal information or mess with other apps without your permission. Well, the handle Extensibility in an iOS way, we wanted to build on the same sandboxing model. So now extensions live inside an application's own sandbox with access to

access to the Media Stack, which means you're limited to basic media playback. Or, you might be using AVFoundation, and thus have access to the Media Stack, and can do things beyond basic media playback, but you have to implement your own playback user interface. Finally, some of you

accessing a class method on NSFont that returns me an object for the default system font. And so this is a real object from Objective-C. I can access properties on it, call methods, do everything that you expect. Now, another important piece of Cocoa are protocols, and Swift supports

access to full-sized images, not the little dinky images we give back, as well as access to the image metadata. Now for those of you eagle-eyed viewers in the audience, when you saw the iMovie demo on Monday in the keynote, you might have noticed that they were

access the kth element of the work group. So there is an in order access there. And there's also a contiguous access requirement. There's one exception. Not all threads need to be participating. But let's look at some real examples here. So in these two examples we

Accessibility team and I'm here to talk about making your drags and drops in iOS accessible. Let's get started. Let's briefly go over what we're going to cover. We'll start with a very brief refresher of the basics of Drag and Drop. Then, we'll

access to health records with HealthKit. Earlier this year in iOS 11.3 we introduced Health Records and Health. Users can connect to their healthcare institutions and securely download their health securely download their health records for quick access and safekeeping. We aggregate data from multiple healthcare institutions and present it

access the internal website, I do not have access to it right now. I now can go into my VPN app and I hit start VPN. And what this did, in the background it kicked off the tunnel packet provider. If you can see now, I do have the VPN

Accessibility is really something that I think nowadays we should think of as an essential, as a part of the foundation, the basics of good view craftsmanship by making your views accessible as it has been pointed out in other sessions or earlier this week, including the Cocoa Tips and

access to memory. Which is a semantic restriction we're introducing into the Swift language to build for the future. So, let's start with one small little feature. Access control. So, here are I've defined this simple date structure. And it's similar to the one in foundation

accessibility based. Now, there's one key thing with accessibility that's going to make automating your application easier, and that's up here. The Accessibility Label. You set this in Interface Builder, you put a name in for your controls that you're building up, that is going to

access to any text supports, you first need a font reference, that's the CGFontRef. It's the most fundamental object to get an access to fonts. And one thing I want you to note is that Quartz, even though you can use it to render text, it's truly

access pretty much all the new language features String, codable, all of them. You can access all the new APIs from the SDK. The only thing you don't get is any Swift-related improvements to existing APIs that you may have been using before. That's what gives you

access the Taptic Engine. You can do audio recording right from the Watch. And you can embed audio and video playback. You can make a phone call from your application, and you get access live access to the data from the health sensors and the Accelerometer. We are so excited

access to that next subscription window. subscription window. And so the user who is on your website trying to access your content can now access that next subscription period all without the app having to launch with that new transaction. If you are using this technique though status polling it

accessed by everybody in the world or it's restricted to just a single user. Well, the new CloudKit sharing feature opens that up and gives your app explicit control over who can access your data. [ Applause ] The new CKShare class gives you a, governs the permissions, who can read

accesses contacts through the API, the OS is going to show a dialogue box or alert asking the user to allow or deny access. You have probably seen these before. This means that the first time you call a method on the contacts store, it cannot provide the results until

access their location off the bet, you have to ask permission and we have the API that lets you do that. After that we have the bread and butter, which is location updates. This is the portion of the API you can use to get access to where the user

access is provided to those items. For example, when the device is unlocked. In iOS 8, we added the AfterFirstUnlock I beg your pardon. That's been around for a while, but you can use it if you have to access items in the background, for example, if you are

access to time-based media and professional access to time-based media with dropping ease of use. To set the stage, I would like to talk a little bit about what we had in iOS 3. In iOS 3, we gave you UIKit API to access the camera, record data

Accessibility throw an exception or two when an Accessibility client has happened, or an Accessibility client has experienced an error. But in general, it doesn't happen that much. So reporting exceptions. One thing that a lot of apps do, and it's a good thing for you to do

access my photos on the Glance. They have one trust relationship. They trust you to access that data and protect that data or they don't. So we think that this is important to focus on making sure that you embed and think about privacy from the beginning because your

access to the motion sensors in the iOS devices. It also exists on watchOS and gives you access to the accelerometer. As on iOS, on watchOS Core Motion can give you live data while the application is running, but new and cool and specific to Apple Watch is it also

access to their accessories at home is provided via the Apple TV, which acts as a remote access gateway. And Apple TV then securely channels the communication between the user's device and their accessories, which are at home. Security. We have built HomeKit with security in mind right from

access control for user. That returns a HMHome access control object, which encapsulates the privileges of that user. Let's see what this class looks like. It has an administrative property that will be set if you are the administrator of the home. So now you can update your apps

Access Log. Let's see how we do that. So this is a snippet of code. First, we get a reference to the Access Log from the player item. We iterate through the events in the Access Log, and we simply sum up each events duration sum up each events

accessing the preferredConstantSizeCategory property on either your view's traitCollection or on the UIApplication object. The default text size will return large and the standard sizes run from extra small to extra, extra, extra large. The Accessibility sizes are prefixed with Accessibility to avoid adding more extras. Now, in iOS

access setting is how you specify which servers you need to send those requests to. Now the website access setting only cares about the host or the domain part of the URL. And we actually allow you to specify patterns so let's take a look at what some of

Access app. This app is designed to access a secure document, like a sensitive document maybe over your intranet, and store it on the device in a secure manner. The second app that we're going to see is a Point of Sale app. This may be something like you

access in a single payload and this is a technique we call the carrot and stick. So the carrot and stick basically says if you want access to my email servers you must have a passcode of a certain standard on your device. If you want access to my VPN

access to your experience, and it's built in to every Apple device. Now think about that last point. It's kind of awesome. I mean that means that every person who uses your app has access to VoiceOver. But not every VoiceOver user has access to every app. And

accessibility. We're doing something a little bit unique here. So, we have to inform accessibility of that. Cocoa does a lot of things for us but what this looks like to the user is that there's a list of suggestions associated with the text field. In reality, we

access data live you do get not just the raw sensor data but also features built on top of the sensors like device motion which gives you the altitude of the device or the pedometer or motion activity. On platforms that have the altimeter you also get access to the

access. CloudKit supports both a concept of public and private databases. You can see public databases as a soup of data that's all your user can access to. Private databases are meant to store the actual data just on behalf of a specific user. CloudKit support both structured and

access patterns, you gain a lot more support from the compiler to tell you when you're accessing something incorrectly. It's better to use a more direct set name accessor method, rather than to set value for key, and you might mistype name or something like that. This improves

accessibility API, and just like a moment ago I said Fantastical set the standard for what productivity apps on the Mac should be like, Workflow sets the standard for what accessibility what apps should be doing in terms of adopting accessibility, to enable these apps to be used by people

access the microphone on the Watch. So yes, in watchOS 2, you can access the microphone right on the Watch and bring that audio right into your app. [Applause] We also heard you want to play audio out of the speaker. You can do that. WatchOS 2 with native apps

access to the accelerometer, the gyroscope, the magnetometer and the altimeter; and through the framework, you can access raw forms of the sensor data, as well as process forms and use these in your applications. Now, there are a number of interfaces available through Core Motion. The first is CMMotionManager

access to location in the background. Legacy apps will continue to work, but when you link against the watchOS 4 SDK, you must adopt the continuous background location API. Otherwise, your app will be unable to access the user's location. Luckily, it's very easy to adopt our API

accessible offline. There's a fantastic new standard called the HTML5 application cache and it does that for us. And it makes the entire application accessible offline. All the HTML and JavaScript, CSS, all of the media that makes up the UI. And even though cache is in the name

access to the console. If you don't do anything, you can do evaluations here in the console. You can get access to any globals that you might have available in your context. And you will see exceptions in logs and errors. And in this case, we have an example

access. So here, if I were to choose something like finance, I'd get a key that has access to things like financial reports or sales reports but it won't have access to things like beta testers or builds. I can add on levels of access or I can

access. Your shaders can access half a million textures and buffers to for you to do this do these new algorithms. While tier one is supported on all Metal devices, tier two is something you need to query for. But don't worry, the support is really wide. All the

Accessibility, way down at bottom, Guided Access. And if you turn this on, it is now possible to lock an iPad, any iPad, to any arbitrary application. A lot of parents and teachers do this before they turn over their iPad to their child. For instance, if your child was

accessibility. Accessibility with Standard Web Technologies is either free or very easy to do. Easy to add. And so let's talk about, I just want to get you started on doing Info Graphics. We're certainly not going to go into all the details here. But what we're

access to more controls. And this allows us to pack lots of capabilities really easily into the design. So you see, we have our wireless control so I could just tap on Airplane Mode. But if I 3D Touch on the platter, I get access to even more features. And

access. For buffers this means you get a pointer to the memory backing the object. Protectors, this means you can call certain easy-to-use methods to set and retrieve data from the texture. You can use private storage mode which only gives the GPU access to the data, this

access to. Like information about content scripts and style sheets, your extension's website access is described in the extension's Info.plist under the SFSafariWebsiteAccess/key and it's a dictionary with two parts. The first part is the website access level. And this extension is specifying an access level of

access to the parameter sets. This sort of packaging is superior for random access in a file. It allows you to jump anywhere and begin decoding at an I frame. So what do you have to do if you have an Elementary Stream coming in? Well, we've got you

access the file system outside of your own sandbox directory. You can’t connect to or host any network servers. You can’t access devices such as the camera, microphone, USB devices, or printers. You can’t access the user’s personal data like contacts, calendars, and location services. What

access things through Python. We made our APIs such that they're very easy to hand off to some of the script interpreters. The Script Interpreter Tool such as SWIG that allows us to give you guys the full access to the LLDB API. So from Python, you can start

access points or dual band APs to offer a variety of in-car services and applications. If these access points are operating in the same frequency band they need to use different channels to avoid interference. If the access points use the same SSID and password they need to offer

access to their entire photos library. So, this will make them more comfortable using your app because they will have better control over their data. We're also adding a write only access to the photos library. So, for example, if there's a game that wants to save a

access to all the documents inside the app container. You will be able to import and create new documents but only the default safe location which will be a [inaudible] for you. So how are you going to access to a file in any other place in the system? Well

access to the Store with all of its content. Books of course ultimately about reading so you can get in here and read, move easily between the pages. You have access to all the controls you'd expect. Your Bookmark, search, can adjust your type and font and type size

access to fly charts the latest fly charts, access to financial services, all the professional apps. Now if you summarize, iOS supports all four types of in-app purchases. OS X supports only consumables and non-consumables. And as you've probably guessed, today we're excited to bring subscriptions

accessible apps. We're looking for localized apps. Because accessible and localized apps mean that those apps are available to an even wider audience than they were prior to being accessible and localized. And so there's a lot of stuff that we look for in winning apps, and these

Accessibility. It's really important to implement accessibility in your apps and in your Custom Controls so that all of your users can really enjoy using your applications. It's also really easy to do. So, if we look at our Ratings Control it acts as kind of a container

access with documents that you're accessing using this class. And you can do that by using NSFileCoordinator, directly, or by sub-classing UIDocument, which builds in a lot of file coordination behavior for you. To hear more about this class and other document based topics, please check out this

accessibility by automatically. This may not work in the current seed but it will work fine in the next seed. We have a session coming up tomorrow on preparing and presenting media for accessibility that goes into more details about what it means for the playback pipeline to honor the

access to the hard drive, and access to the network, and the one on the right has access only to the contacts. So this provides two really key benefits. The first is one of security, which I just mentioned. So the process on the right, if it's compromised in

access, the status bar will not be presented because the user has granted access for that app to use location at any time, which is what is needed in order to access location anytime from the background. For example, when your app is running the background due to Background App

access, eliminate dynamic access to local arrays. This is basically saying that we have an array variable in our shader code that is storing the stack and where accessing it using some other index variable. This is a very common pattern when providing for the CPU, but GPUs are different

access to Apple Music. This user consent is very similar to what ou would request before getting access to the user's location or the user's contact information. This is also something you need to request per application and per iOS device. So, if your apps, app works on

access certain sensitive user data like photos or contacts. You'll get a dialog saying: "Would you like to allow this app to have access to this piece of data?" And the user can either decline or allow. So when the user allows your app to have access to a

accessed documents, but this suffers from many similar pitfalls as NSFileManager did earlier. Let's take a quick look at this. So let's say we store a list of NSURLs to our documents which are the recently accessed documents. But then the iCloud Drive daemon moves the document while

access these items easily. The third part are the inspectors, and the inspectors are where you're going to edit the properties of your views and controls. So, there's a lot of step you can do in a canvas but this gives you the fine-grained access to all

access to the recent files, unsaved files, but I also have access to counter parts of this file, in this case, the header, but also, super classes, siblings, and include files. This kind of navigation right at your fingertips is so critical, but so powerful, that I can actually decide

accessibility enhancements. So Dynamic Type includes the text styles, it includes user settable sizes including enhance to accessibility sizes and it contains these legibility enhancements. And so, by simply changing the way you specify your application, from specifying specific fonts, specific sizes, to using text styles and letting the system

access to some shared system data. So what do I mean by shared? What's shared system data? Well we have a number of APIs that allow you to access Calendar, Address Book, music and media libraries. Those are all, all those APIs are basically wrapping access to some shared

access to its own audio, video, and microphone samples straight from ReplayKit. Giving you direct access to your application's audio and video samples from ReplayKit will provide you with more flexibility and control over the content your users are already creating. Just like with recording, In-App Screen Capture

access all the information that you need that pertains to the output. And sampler lets you access all the information that pertains to the input image. And sample is a representation of a single-color sample from an input image. And along with these types we also have some convenience

access to system services. You can choose to use Objective-C, which you cannot do in the kernel. You have access to better logging facilities, such as the ASL log system. You can create your own log file and log your messages out to that. And you should not be

access to all the great features in SpriteKit for nodes. You have access to our actions library so you can now run actions on the camera. You have access to our constraint system so you can apply constraints to the camera. You can make it align with game entities, you

accessibility to our custom rendered apps. It's actually incredibly easy. By implementing focusItemContainers, focusItems in rect method, you are providing the focus engine with enough information to allow voiceover to assist your users in navigation. Remember to set accessibility labels and accessibility hints on your focusItems in order for

access to your Image or Video Editing tool right from within the built-in camera or photo applications. No need for the user to switch between applications. No need for the user to grant specific access rights to your application. It's a very simple way for your tool to

accessing actions without losing your current scroll position. Now, Menus are also a great when your app has a global control that you want people to be able to access from any screen. So for example, in the activity app, there's an action for changing your daily move goal

access the location of the user when the user starts playing a game. But if you see from the energy report that the pie chart tells you that your location utilization is very high, that could be a possible leak within your application where you're continuously accessing location and

access to amazing API's on the platform like Gyroscope and Cameran and so on, ads also have access to these API's. The ads are seamlessly integrated with iOS' software and as hardware, so there's not this sandboxed limited experience inside an ad. It's just an app

access to a build they receive an invite to test the app. We only send the invite once and testers won't have access to any builds until they accept the invite. So here's what the invitation looks like and when testers tap "view in test flight" it'll

accessing this content, playing it back and displaying it, capturing and creating HEIF and HEVC Movies, and then export and transcode. So, first let's cover access. So, many of you are using PhotoKit and PhotoKit will deliver HEVC assets for playback. So, if you're using requestPlayerItem or requestLivePhoto

access, permission to access the user's contacts, or we may not have found a match for this friend. So we'll want to have a fall-back, in this case we'll use the system's message style to display as the icon. Now that we have the icon

access a piece of information or service some interaction in your app, it's not going to keep them waiting, and that makes them really happy and keeps them coming back. If you are going to adopt Multitasking on iPad in iOS 9, not only does your app no longer

access. User account is a very important aspect of managing the user in your app. App access provide this necessary functionality. Two basic operations to support account in your app, account registration and account login. Account registration allows your user to log in to register with your app is password

accessible buffer, you can accessible buffer, you can modify its contents at any time, like change the shader type, or the camera matrix, or anything else that you might need to change. And of course, by moving your rendering to the GPU, you remove expensive CPU and GPU synchronization points

accesses the GPU. On the one side we have our high-level 2D and 3D scene graphs APIs that give you incredible functionality and convenience. And on the other side with Metal, we provided a direct access path to the GPU. So this gives you an amazing range to do

accesses are statically bounded. The best way to do this is to pass your arguments by reference rather than pointer where possible. If you're passing only a single item or a single struct, this is straightforward, you can just change your pointers to references and change your accesses accordingly

access their health data, but remember health data is really sensitive to many of our users. We want to encourage our users to only give apps access to the information that they feel comfortable sharing. To support this we let users give your app permission on a per object type

access via access control. Let's begin by talking about inheritance constraints, namely, the final keyword. When an API contains a declaration with the final keyword attached, the API is communicating that this declaration will never be overridden by a subclass. Consider again the make noise example. By default, the

access the deferred mode? You access it from the file menu in Instruments, and you go to Record Options and select Deferred Display. After you do that, if you hit Start Recording, Instruments will immediately disable the UI and gray it out like you see here, and you start recording

accesses. Like, it couldn't reorder them. It couldn't merge them or it couldn't remove the useless ones, like we just saw. Dealing with memory access is a huge part of the compiler job. So, here you have an example of how undefined behavior changes the behavior of

access control list that says who has access to that item And the default value is the application that made it. The keychain doesn't care who you are. The keychain care what program that is. All that it cares is that the program that comes along tomorrow and says

accessibility settings such as bold type. San Francisco will work great in most apps. But, if you need to use a custom font, make sure that it respects accessibility settings, and it's legible from a distance. So, for example, in Badland they use a custom font that fits well

access to both the microphone and the speakers. So media playback is interrupted and the channels are switched. And audio switched over to the channel, which provides access to both the microphone and the speakers. In addition to switching to audio channel, the screen switches to CarPlay to show the

access these things from apps, the actual protocols and the frameworks, like I said, that are available, again, across both OS platforms. And so let's dive in to a couple of these. Let's talk a little bit about what you can do with them and we won't

accessibility. We just had some discussion of accessibility in this session right before this one. Accessories can now leverage VoiceOver technology to communicate with the phone and completely control the iPhone OS device. They can send commands such as moving to a particular X,Y coordinates or moving to the

accessing resource on the NS Bundle resource request. This moves all the content that I fetched into the cache so it is available for future access but it also marks it as available for purging in the even that the system runs out of space. With that, we have written

accessing the Managed Object Context, and that included things like accessing properties on NSManagedObjects created by that managed object context, the developer had to lock the context. If they wanted to message PersistentStoreCoordinator, they needed to manually lock PersistentStoreCoordinator before they sent whatever message they wanted. And, you know, because

accessibility you now have the ability to use more speech voices like Alex as well as high-quality voices in AV speech synthesis. I encourage you to come out to iOS Accessibility to find out more about how to make your app accessible. You also saw that we're introducing

access: how and where to access HEIF and HEVC movie content. And finally transfer: so what strategies do you need to consider when you want to move HEIF or HEVC content off a capture or supported device? So first I'd like to start with access. So we've discussed

access to your applications data structures and API, but for your UI tests, you have to access your application using accessibility and send events and see your application as a user would from the outside. For your unit tests, all your tests are going to run in the same launch

access the layer. And then we'll set it's borderWidth to be five. And then, of course, we have to initialize that to be a borderColor as well. Now in this case, because we're accessing the layer that's a core graphics API we get the CGColor from

accessed and only when it's accessed and only that one time. Now just as we have initialization in Swift, we also have [ Applause ] Just as we have initialization in Swift we have deinitialization. Deinitialization is responsible for tearing down the object. Now as Joe has already told you, memory

access to all of our specifications that define everything I've talked about here, explain to you how to implement all of the security, the pairing, the protocol and the profiles on your accessory. You also get access to a great development and certification tool. It's an OS X

access the glyph information using this method, glyphAtIndex, simply enough. But notice that the index passed through this method is a glyph index. It's not the character index you use to access the contents of NSTextStorage. So glyph index character index, where are they? They are usually the same

accessible Keychain for you so you don't have to pass the Keychain access group identifier to these APIs. It's just a tip to remember. And you can find out more about these APIs by watching the Security and Your Apps video. In summary, today Sophia told you all

accessing so I can go and get the right index. Use that index to access the right vertex data. So, just you know, imagine, just imagine that this is that ID, okay. So in this code, what we see is here is going to use this ID and reference into

access to the API, get access to the implementation without having the go through and parse the headers. Now in support of Modules, we introduced one little bit of syntax. It's the @import declaration. What @import does is it pulls in the API for a particular Module which corresponds

access. Well, we thought we could do better. So, in iOS 11, we have revamped the privacy and security fundaments of UIMessageViewController. We started off with three goals. Put the user in charge of their content. Create a great user experience in your apps. And third, give a higher level

access. Now, most in our API's almost all of the instance variables are private. And, we've said so, but in a way that they have been declared, especially in some older AppKit classes, subclasses were allowed to touch the instance variables, directly access those instance variables. Now, some

access and show a leaderboard in game, how you can access the data from a leaderboard if you want to use custom UI, and achievements. So I'll also show you how you can report achievements from your game; how you can show achievements in your game using the standard

access some of the same content or functionality as in your app? Great. This talk is for you. So we are going to talk about how we can tear down the walls between your app and your website and create a tight association between them. As an example of what

access rights and providing write privileges to members of our community. In fact, we've chosen five all-star contributors and given them direct access to the ResearchKit repository that also allows them to merge MPRs. A huge thank you and congratulations to Erin, Fernando, Nino, Ricardo, and Shannon. Next

accessibility so it uses the built-in accessibility that's already there for voiceover support on the phone and the iPad and last year with Interface Builder we added support for setting the traits in accessibility directly in Interface Builder and I'll be showing that in the Demo as

access to it. So, what is CloudKit? CloudKit is a technology that gives you the ability to have your application data and your user data available wherever you need it. CloudKit is a framework which gives you access to a database stored on iCloud. We use CloudKit extensively inside of

accessibility label. For brevity in the demo, I'm just going to reuse my message caption as my accessibility label. Now that I have my message, I'm ready to stage it in the conversation. I'll get a reference to my active conversation and call conversation.insert to insert the

access that repository to get that source code? And secondly, the project or the workspace inside that SCM location that we're going to access where that project lives? Secondly, a bot defines when we're going to build it. So we have some great scheduling options in the Xcode

accesses a piece of memory and another one right next to it accesses the piece of memory right next to it and so on down the line, the compiler might be smart enough to spot; hey, you just loaded a continuous range of data, and turn that into one big

accesses now, it will access this very soon again. Spatial locality simply means data your program accesses now, it will also access neighboring data. So when you access an array field, it will also access the field next to it. When it accesses a field in your data structure, it

accessibility system, which is available on both Mac OS and iOS. That means just by adopting PDFView, you get all of these accessibility improvements for free on both platforms. All right. So, there's another cool feature new to 2017, which is PDFPages Method Thumbnail of size for a display

access to a stream API in CFStream which allows you to access files streams or sockets streams. CFNetServices which allows you to publish and subscribe to or browse for Bonjour services. And CFHTTPReadStream which gives you a way of issuing an HTTP request and receiving the body of the response

accessing the session I'm accessing the session and calling Run with a World Tracking session configuration. So this will run World Tracking. And automatically the view will handle updating my virtual camera for me. So let's go ahead and give that a try. Maybe I'm going to

access to certain functionality. So it's very important that you understand blocks and understand how to use them properly in order to access all the available functionality in the system. Well, for those of you who may not have seen all of the public materials that we've had

access the care plan store. So by doing [inaudible] cloud bridge is setting up a local variable, the cloud bridge, to the cloud bridge that we received from callback, we have access to the cloud bridge from anywhere in our app. And that's what we can do cloudbridge.careplanstore. It

access that from our shader similar to how the CSTRUCK would work. Pretty straight forward. And for setting that up in the API we would have just created a buffer object of type uniform buffer, set up the size of that and then we have to get the location. Instead

access one of the first 3 objects poof there will be objects. You don't need to know or care how that happened. If you then try and access an object elsewhere in the array, poof there are objects. Again you don't need to know or care. So it

ACCESS. This means that your program or your application was trying to access memory, which wasn't available sorry available to it at that time. It will tell you the Exception Code and it will tell you the Crashed Thread, which in this case, is thread number 6. The iPhone

access. This is those two ones that we saw on the vDSP_dotpr signature before. What strided data access is, is it lets you operate not on every element of array, but on every nth element of array. So if I wanted to operate on the 0th element, the 2nd

access that font using any of its names. For instance, if I could use CTFontCreateWithName using the PostScript name on that particular font that I had registered and access it that way. Alternatively, I could create a CT font directly from that graphics font using CTFontCreateWithGraphics. Then on Lion or

access a single value out of a plist, we have to take that entire object graph into the plist, bring in some memory before you can access that one element. Similarly, when you're writing out the plist, if you modify a single element in the plist, we have to

access to all the tech services that are supported by the OS like accessibility, spell checking and more. And you can take advantage of all of these great features without having to write a single line of code and that's pretty awesome. And so with all of this functionality

access for interaction to new access for interaction to your messages apps. In compact mode, previously swiping horizontally down in your messages app would switch between apps. In iOS 12, these horizontal swipes and interactions that move horizontally are now available for us by your apps directly so they'll

accessible, searchable, and easily editable. Now let's talk about animations. I said it earlier in the presentation: nowadays you really need animations to draw in your users. And so far, you've done so much work making a great site that goes fast, that has accessible text, so you

accessibility features that we have built into the operating systems. So, why would ship your app with artwork for people that need it or want it or use it but then not have the accessibility features in there? That's not fair. So, resolve some of the technical debt that

access to the intranet. So that's what it is conceptually. This limits VPN access to only the apps that the enterprise has installed, specific Apps. It enhances both security and privacy. So, security because you are not exposing your intranet to apps that the user may have installed from

access to that data structure and you can use GCD by creating a serial queue with a dispatch queue serial flag at the data structure and then use dispatch sync to execute a critical section block on that queue where that block has exclusive access to the data structure. How

access to the CPU, and everyone's background queues get equal access to the CPU. No single foreground app is prioritized above any other. If you prioritize your work appropriately, the system can guarantee that we get the best possible performance while there are multiple apps on screen. So how

accessibility integration. Now, some of you might be familiar with Speakable Items. How many people in here have used Speakable Items? Quite a few. And it's an architecture built into OS X in the accessibility frameworks and allows you to speak commands to your computer and have them perform

access to partial objects. I say lightweight access, so there's going to be no buffer allocation and no copy. Things that you can do with slices are for example, taking the odd elements of a vector. We shouldn't have to allocate a temporary buffer and copy those odd

accessible. The one that was really important for us is actually describing the important locations using VoiceOver, and the reason I want to show you this in more detail is because it's surprisingly easy to do. So just like in your UIKit apps we're overriding an accessibility element

access information and provide a really fast way to get to apps. Notifications tell people about significant events that they might otherwise overlook. And because they're also interactive, they're a great way to push interactions to the people who use your app. And lastly, apps offer a deeper

access. It's really just a very large store of random access memory. Read-only random access memory, that is. Data normally passed in via a glUniform can be passed in via a texture. There are a number of advantages here. It's a really, a much larger store. We

access to the performance and power of the GPU in literally hundreds of millions of our most popular products. And Metal is also a foundational technology on these platforms. It powers Core Graphics, Core Animation, as well as our Games and Graphics Libraries such as SpriteKit, SceneKit, and Model I/O

access, you tell us which access you want this view to be floating on and we'll go ahead and put in a special place in the view hierarchy and scrolling will be handled automatically in sync. So if you're scrolling ob the access is not floating on, it

access these light content controls? Well, they're available through a new API called NSAppearance. This is a class that lets you access alternate appearances and it's got a bunch of methods, the one I'm going to show here is appearance name, you just give it an appearance

Accessibility. I was actually talking with a former co-worker just before lunch, make sure you have accessibility in your application. This helps people that couldn't otherwise use your application. And they get quite emotional when they can see that they can finally use an app because you're

Accessibility is a huge deal for us. One of the things that we are really proud of is making our apps as accessible as possible for users who are differently abled. There's new UI there's new API to be able to participate in the Guided Access system. So

accessible at any time in a really simple manner. When you want to access the project for the first time, the new checkout workflow makes that really easy. Select the repository, select the branch, and Xcode will check out your project and open it for you. Now, once you have

access. Because for security reasons, normally you can't access from one process into another's storage area. And you enable this index code. You use something called 'app groups' for both the extension and the application you give a unique identifier and that's your application group. And so

access to their own private data or they're using it as their company's device with access to the corporate secure data. We don't think this is the right approach. We think that place is the burden on the employee to make that decision and that's not

access points, you need to know where those access points are and so what we focused on in the past year is really improving our sources of data for Wi-Fi positioning. Our goal was to improve coverage in the areas where people use iOS devices most. So, just to

access to the attributes like geometry, camera and light. And from the geometry, you also have access to the materials. But you can do more than simply modifying positions, you can also animate everything in your scene. And for animations, Scene Kit includes an animation engine and regarding the API

Accessibility APIs. The new APIs are simpler. They are expressed - the accessibility values, the accessibility values for various UI elements and UI properties are expressed directly as properties. There's no need to subclass. Good, somebody's used the old APIs. And there are better compile time warnings as well

access to the movie files. These are only accessible to the user via ReplayKit's preview UI and share sheet. All right, so let's take a look at how ReplayKit works by taking a look at its architecture. So your application links to the ReplayKit framework and it uses

access it the system font API's are the same between iOS, watchOS, tvOS, and the macOS. So, NSFont and UIFont basically have the same API's. And they have a lot of benefits. They give you access to the weight of San Francisco, of the nine weights, but also

accessed. And then you've got less-frequently accessed well, you've got the changing dates in the middle of the Calendar mentioned that earlier and then towards the bottom placement, less important, less frequently accessed by the user, less on their radar if you will. You've got the

access to everything related to a drop. You can get access to the drag location where the user is dragging inside your view. It gives you access to the items in the view, what type of data is there, and actually their data in the end. It gives you access

access via Touch ID or a device passcode prompt, I'm going to go ahead and change the state of the car as I did earlier without prompting, but this time I'm actually waiting for the user to give me access. And then I'm going to call the

access the camera if they're running on iOS 11. You can use the AVFoundation APIs to get access to the camera. It's important to note, though, that this won't work on earlier versions of iOS, so if your Playground depends on the camera, we recommend that you

access as much of your information as possible while you are debugging. Access to the Objective-C runtime gives you more insight into fields that before were unavailable to you. The SDK modules offer an unprecedented level of access to the operating environment that your application is running in, more

access to both the Mac and iOS SDKs. You go to the dev portal, sign in, you agree to the single agreement. Come into iTunes Connect, and you set up your tax and banking information just for that one contract, letting you set up paid apps and paid in-app

access to a small number of things that you do regularly, very powerful construct. Second thing is workspaces: workspaces let you organize work in multiple projects and associate projects together on an ad hoc basis or on a team basis without having to change the project itself so you can

access iTunes Connect at itunesconnect.apple.com. The first time you log in, you will land here, this is the home page. Now if you are interested in having a commercial relationship with us, your first stop should be the contracts module, second one down on the left. Note that banking contact

access. After that they can renew at 1.99 for another 3 months of access. When that's over they'll renew at the normal subscription terms of 9.99 for 3 months. Here's what the data from StoreKit would look like in this case. You can see the subscriptionPeriod has

access to the power of the OS. So up in the Services menu, in the Application menu you have the ability to access Services. In the Finder, in the Action menu you can access Services contextually based upon what you have selected. The same with the contextual menu in the

access stuff nice and quickly. And the cool thing is, you can access all the stuff right from Xcode and the Help menu. Go there and you get the documentation API Reference guide. And the nice thing is in Xcode 5, we've actually revamp this to make it really

access to software update, no multicast packet traffic allowed, and certain ports blocks, which all have impact on printers. Enterprise customers also may have accounting requirements since every page printed costs money. And of course security requirements are essential and are increasingly important in enterprise printing. The top requests we

access to new kinds of input. You can now do gestures with gesture recognizers in your apps. We are giving you access to the rotation events in the Digital Crown. And we're also having three other areas. One is for improved table navigation, the support for the new user

access to that functionality you paid for if it's now a subscription model. So use type 19 as a bit of a gate to be able to supply that. So once you've done this step, that's the process of checking the transaction and confirming subscription state on

access network with NAT64/DNS64 on my Wi-Fi interface. So when I start it, I see that the Wi-Fi icon has grayed out and it has an arrow pointing up. That means now the Wi-Fi interface is in access point mode. What that really means is now it

access and file access to a background thread. So this leads to another common mistake which can cause compatibility problems. All right you see here, well I don't want to do this in the main thread so let me do it on a background thread. Okay well I can

access to them. And the way the node application gets that access is by fetching the host callback property. It will receive that structure full of function pointers. They won't actually point to functions in the host process, of course. We can't make a cross process call there

access to your account to an intern that won't be here in a few months. So make sure you give access to someone who will be with you for a while. So a common problem that we have. You also want to use a real e-mail address that

access those different addresses, as if you had read it in memory, each time you access an address that hasn't been accessed before it will cause a page fault, the kernel will read just that one page. And that gives you lazy reading of your file. Now we can

access to the latest news in a super accessible form. Okay, now that we talked about the UI of apps, I want to talk about the other side of the experience. The person using your app. And I'm going to get aspirational about the kind of experience that can

accessible to your users. And, they can access these shortcuts by saying key phrases into Siri, or tapping on various system UI. And, in the case of watchOS, that's a platter on the Siri watch face. There's a lot of in-depth discussion about how to make great

access the memory. And for complex scenes, this cost can add up as well. Resource sub-allocation addresses both of these performance issues. Remember that the expensive part of resource creation is in the memory operations. With resource heaps you can perform the memory operations ahead of time outside of

accessibility to benefit voiceover users. And here we access the same imaging code using the standard UIImage or NSImage APIs. Similarly, to images you can also imbed videos in your markup. This is done by using a syntax similar for that images with additional support for specifying a poster image

access the count property of that collection to see how many there are. If we pass that to the print function, we find out that we do, indeed, have five characters. But if you still don't believe me, well, let's iterate over each of those characters in turn

access these from your touch bar. And as you can see, I can bring those up with Xcode being in the background, so you can access them even when you're, for example, developing your app in full screen mode. And one of these options allows me to capture the

access to the LLDB object model, they're like peers to your program. Breakpoint action is written in Python in a full program inspection and by full program inspection, I mean that they have access to the data, they have access to the code and they have also access to

access to credentials that Safari has stored for your website to make your users' login experiences easier than ever. Then we're going to learn about AutoFill and how that works on the web and ways to make that better as well. Then we're going to look at ways

accessibility, get AX accessibility? And Apple has many ways to make your products accessible to all users. I'm just going to go over a few small things. VoiceOver is not small, but I'll talk about it briefly. It comes built-in on all Apple products and it's

Accessibility. Accessibility not only expands the audience available to buy your app, but it also makes it easier for you to use as a developer, that's because accessible apps are able to be automated and automated apps are more easily tested. So you should definitely look into supporting accessibility

access vectors in different spaces. But most of all, all the node transform properties, access position, rotation, scale, and matrix, and transform, are now directly available as SIMD properties for, to ease math operations. So thanks to SIMD types, operations on quaternions vectors, and matrices are much simpler to write

access it just at the LLDB command prompt any time that you're debugging your program. That's not all though. You can also access the Swift REPL when you don't have a program running. You can access it directly off of the shell prompt, for a clean slate

access the image file in order to read the depth data. So let's see how to do that. If you're using PhotoKit, there's a couple of ways to can access the image file. You may be using PH Content Editing input, for instance. Here's how you

access to the texture of the sprite, the sprite size in pixels, the global time (in case you need to do any of the animation in terms of color or shapes) and you also have access, if you have a custom shader that's running on a shape, to the

access to use the user's HealthKit data. When your app requests authorization, a prompt will appear on both the Watch and the user's phone to authorize your app for access. So if your phone application is authorized to store and retrieve distance samples, let's say, then your

access the GPU. Now it's important to note that these techniques apply equally to iOS 4 and Mac OS X. So the codes you write on one platform and the knowledge that you've gained here, you can leverage on the other platform. They've got pretty different architectures

access to your favorite sets of handlers. It's different from scripting additions because you can write them yourself in AppleScript and they're controlled by the script that loads them. They can use AppleScript objective C to access all the wonderment of Cocoa and they can also publish their

accessed in their photos library. And we did that by popping up a dialog the first time your application tries to access that is read to read from, or write to the assets library, so that the user would have an opportunity to opt in or out. And we warned

access to the developer tools and the rights as a developer by virtue of joining your team, okay. Once you do that the next thing you should do as a team member is to go to Xcode and type your registered Apple ID in, so you click register, you register

accessing through context. So today we're going to be talking a lot about Instruments and not only how we use Instruments to find problems, but how we interpret the information that we see and figure out what it means and what we need to do about it. We're

accessibility needs of our users and responds to a lot of different accessibility settings. So in the end of the day, there's basically a combinatorial explosion of ways that people use Siri, both in terms of how they phrase something to Siri and in terms of how Siri will

access to an encoder and a decoder. These provide you access to containers, and that's what actually holds the values that are in the archive. In the case of a keyed container, we use the coding keys that are defined by your type. And finally, the encoders and containers

access the notifications that I'm not very good for your hockey and all that and you guys probably know what I'm talking about. But these are three other command solutions that are being used nowadays. So, first one is the Message Access Pro or the Message Access Profile

access to the Date value type. So, let's go ahead and use it, and consuming it is very similar, however now this var takes on a whole new kind of behavior. We specifically, we now allow inline mutation. And so, we've done zero, these two examples here are

accessibility settings. So dynamic type is organized by what we consider to be usage. Each one of these is a text style as we like to call it. As you've seen in the previous session, there are, I believe, eight of these different usage categories for use with text

access to our neighbors to the North. Any Canadians here? I'm so sorry about the Canadians, but, in fact, the Rangers knocked my Flyers out in the first round; so get them next year. We've also made a number of other changes already since launch that I wanted

access to the source code or not be aware of what work it's doing, and in such cases, you can often estimate. You can consider what the code would have to do, what kind of work it's trying to accomplish, and another complimentary alternative is to profile with

access point, or if they're not connected to an access point at all. So, many of you have wondered which devices support Peer-to-Peer networking. So I'd like to talk about that a bit. Well, on iOS it's pretty simple. If your iOS device has the

access to a Table of Contents, your Bookmarks, Xcode even makes it super easy to share links right from the ID. Now, Xcode 5 intentionally feels a lot like Xcode 4, but there's one aspect of the field that we thought could be much improved, and that's in

access to a certain CloudKit container, or only execute this operation if we have access to your calendar or to your photo library or to your contacts or whatever else you'd like. So that's conditions. And the final piece is operation observers. An operation observer is again a

accessed by both the app and the extension. So what you need to do is create an app group, which provides a shared container for you to store these data and they can be accessed by both. So that's all you need to know, and if you want to

accessed through the top level Source Control menu where we have access to the every working copy that a project or workspace is currently using and what branch we're currently on in each one. So this is a great easy way to quickly see what code you're working

access to mail. So, if you can detach yourself from the requirement of a companion app, you actually have access to much larger user base, right? There's more of a chance that they will see, they'll see my Gift Card then if it goes to your mail then

accessing Transport Layer Security within iPhone OS, there is no Transport Layer Security that's accessible at the dial-up level. The secure transport mechanism, which is available on Mac OS X, public API Mac OS X is not a public API on iPhone OS, so you just can't

access that local variable again printing it. So what the problem here? Well, it turns out this code is Well, it turns out this code is actually ambiguous because when I access that local variable inside the closure, it's already being modified by this withAppended method, which is a

access all customer feedback within App Store Connect by accessing the ratings and reviews section where you'll be able to see your current rating across any one of the territories you've selected or, obviously, all territories. You can also take a look at your reviews, read them in

access. But, do not allow any mutation. That's a separate capability. So, we also have the mutableCollection protocol here. And, we can think of types here that allow mutation, but not random access, like the singlyLinkedList that we talked about earlier. Now, you notice that we've essentially split

access to the app's content and features even if the receipt's invalid if you choose. You could maybe have a you could maybe have a grace period where you will allow some use of the app. You could limit access to certain areas of the app; perhaps there

accessed exactly the same way as you would access the RemoteIO unit. So, basically, setting up, creating the instance, setting parameters, and so on. But this year, in iOS 4, we added a new algorithm which provides significantly better quality, of course, at the cost of a heavier CPU load

accessible to in the past. So let's get started. So today I will tell you a little bit about the features of HomeKit, and we'll go through the core concepts, how to use the APIs, how to get started, and then a few advanced topics that are either

access to a hardware codec or not. With MixWithOthers with ambient that means you would use that for applications that don't require access to a hardware codec, don't need to use it. Excuse me. With solo ambient, that's the category you would choose if your, you know

access to hardware, use properties to configure them and parameters to control them. And make sure you understand the lifecycle of an audio unit which includes access, instantiation, configuration, initialization and then rendering. Render callbacks let you send your own audio into an audio unit and audio processing graphs let

access to Objective-C APIs through the Objective-C Module System we introduced last year. So you can pull your Objective-C APIs whether they be from Cocoa or your own into Swift and use them. And then Swift maps those Objective-C APIs into the Swift syntax. This covers

accessible in this API, so you can ask the split view controller for it and put it in whatever bar you want. Although I'm not going to say it explicitly, if you were to look in the header files of UISplitViewController, you would find that most of the API

accessible behind a VPN and the admin recently changed VPN access. How do you as an app developer deal with a network load that fails? In the past, we've advised you to use the SCNetworkReachability API to monitor when you might have connectivity again to the server. Other approaches

accessing it from Objective-C. The top method is still named 'perform operation.' In Xcode 7, we've added another option for solving this problem, which is the non-ObjC attribute. As you might have expected, this will take something that's normally exposed to Objective-C and prevent it

access. The power can be accessed simply by drag dropping the text UIObjects in Interface Builder and its design to scale. The same layout engine is used by various projects from a single line text field to subsequent application with advanced text handling features like these. And advanced typography features

access and use your great applications, but they can't do that if you don't give them the ability to use your apps in their native language. And your app can easily access this global audience by following some simple steps and best practices. And, in today's session

access it, even if you don't plan on mutating it. But before you go bananas changing all of your string accesses to MutableString, let's consider that graph, again. Now, due to the nature of the text storage API, you're probably going to be up here on the

access methods for properties on the audio rendering thread. So we've taken some great care to do that in our implementations and as we go I'll give you a couple of examples of places where you need to do this to be aware of real-time issues when

accessible or not. Bytes on invalid memory are called red zones or as we say, memory there is poisoned. When you compile your program with Address Sanitizer, it instruments every memory access and prefixes it with a check. If the memory is poisoned, the Address Sanitizer will track the program

access them from your view controller. You can also get them from the current screen, and then using that information, you have your size class. You can make the determination of what is the right thing to do for you. So as a simple example, we can think of what

access any of the other files reachable from your workspace. And on the right here is the issue mini navigator. If you have any issues at the issue pane that are associated with files, you can use the arrow keys to go back and forth between them or pop that

accessibility support. Generally, they do have good support, but that could also be an issue. You might not be able to give a command for the thing that you want it to do. But here's the good news user commands. This is where we leave the world of accessibility

access to what they need to. This particular extension right now does not have access to the network. So we are trying to make an NSURL request, we definitely need access to the network. So if I click on the project here, and then go to capabilities, right here I

Accessibility is a critical part of iOS. We care very deeply about making sure our operating system is accessible to as many people as possible and there's some very powerful APIs around accessibility that are important for you to use if you decide to build custom UI in your

access to constant buffers. We've already got a semaphore and they're great for controlling access to limited resources. In this case our limit is three but it can be whatever you'd like. So here we create our semaphore with our count. And instead of creating one constant

access extended glyphs inside a font. Sometimes they can be the only mechanism or sometimes they can be a convenience mechanism to access these extended glyphs. So to give you an example of what features can do, let me tell you about fractions. So you are looking at this, and

access to connect to your service, but what we're going to do here is set these keychain items to be partially protected and specifically, we're going to use the mode where the data is available after the very first unlock. So what we encourage you to do is

access this roster information from Apple School Manager and give your NDM solution access to all the student and teacher Managed Apple IDs, as well as the classes. In terms of the transition from schools moving from the Apple deployment programs to Apple School Manager, the good news for them

access the contacts. You can actually have multiple Address Book instances. The Address Book object you can create multiple ones of those and they all access the same database, the same set of contacts on the device. So that's the Address Book. The second one in there is a

accessibility settings, low vision people can get even larger sizes for body copy. And here is Ulysses. They do a great job scaling their UIs dynamically. So, how do I specify a design to be dynamic? First you start by specifying different text styles for semantically distinct blocks of text

accessibility settings. So when you go to the settings app, go into accessibility and speech, you will find pronunciations and find a screen like this. You can enter in the phrase that you want to find the correct pronunciation for, tap the microphone button, and then speak it. After you

access should expire and restrict access to a specific domain. It's the web and others will still be able to view course and poke around in the web inspector, but if somebody ends up with your credentials for any reason, there will be limits on how they can use

access and convenient access to from your iOS app? Make sure that you focus on the essentials. Don't overload your app with too much information or functionality. This is really a recipe for poor usability on Apple Watch. So for example, the Calendar app on the iPhone does all

access to that information as well. Also, new this year, in watchOS 4, your apps can now enable Water lock. So, this is a really great feature that allows your app to ignore any input from water on the screen. Which is really great to get a consistent user experience

access to the current render pass descriptor. Now, let me just note that this isn't a problem specific to the MetalKit view. You need to be aware of this issue if you roll your own view in access core animation directly. So this is information that's quite useful

access my CloudKit data through web services. I have here chosen that any domain can access my data but for added security I could have restricted to viewer domains so now we have enabled web services. Let's get some users to log in. So authentication is handled transparently. What

accessed. This would ensure that everyone knows where to go to check out the necessary assets. Unfortunately designers don't have similarly universal options as engineers currently do with their IDE's and Version Control. There's an increasing number of solutions that have come in the last few years

access to 147 countries. This is really huge. Now that means one sign up, one payment set up, all your tax information, all that sort of financial transaction stuff that you need to get started with the program, you do that once and you're working across the globe. Even

access. So anytime you want to try something it's right there at your fingertips. So with all that said, let's dive in and take a look in an actual Playground. To do that, I'm going to invite my colleague Connor up on stage. Thank you, Rick. Hello

access all the code in your application which means when we run the test, we run it in the context of your application. Alternatively, you can run them in a hosting process that's provided by Xcode. Resources for tests, as I mentioned before, are not in the main bundle

access to WebGL and set it up in your web page. And then, we're going to show how to do basic drawing with WebGL. And this is going to be sort of like crash course into how to draw something with WebGL and you get an idea of how

access my texture, I'm going to use my 2-dimensional global ID, but if I access a buffer, I need to create a 1-dimensional ID. So we're trying to help you not have to write all that code because there may be bugs; we fixed that for

accesses motion activity, we'll do the proper popups. The only time you'll want to do something more than that is to check to make sure that your app does have authorization to access activity because when you don't, you want to show a dialogue box saying, informing

access the data that's inside of it so we have various things like converting to a Boolean, to numbers, to dates, strings, et cetera. And when you call one of these on a JSValue, JavaScriptCore will do its best effort to convert it to the type that you asked

access buffers is usually not cached, and so sometimes it can be higher latency to access tasks as buffer objects. Image objects are kind of like GL textures. They're either read only or write only, so you have to decide when you're writing a kernel if you're

access of the weak object's delegate by an arrow reference. If you get back nil then you've referenced no and crashed. So better would be to use the dot syntax in this case to access a delegate, because sending a message to nil is just fine. Or, you

access in the machine on which I generated the key in the first place, I can go to that machine, use the export functionality that Joshua showed you earlier in the accounts pane, and import it here using the button on the left. Alternatively, if I no longer have access

access to the apps if they have some way of interacting with a pass in the user's pass library. So it looks like this. You have this banner at the top of the back of your pass, kind of like the one in Safari. It shows your app icon

accessibility inspector and one thing you can do with that is, it's really great, you can connect to an app and automatically, immediately know the accessibility properties of a given UI element. There is another really nice feature. You can also run an audit on the application running in

access system info, play [inaudible] slideshow photos, and many more. In addition to that, the framework also provides very simple API to handle media playback. Now one important thing I would want to point out is that there is a single JavaScript context per application controller, and you manage all

access to a simple key/value store that is kept with the document. This lets you track preferences or even more advanced forms of progress as the learner moves through the book page to page. And Playground Books are resettable. Every change made is kept in a separate place away from

access to things like running on devices. There's a list of identifiers in a profile. And at install time, the device runs down those list of identifiers to check if yours is included. And if it is, you can install the app. Profiles also allow access to entitlements. There

access to dynamic behavior. Let's think back to the tower defense example. Perhaps I want to implement a magic spell that roots archers to the ground so they can no longer move. One way to represent this might be to simply temporarily remove it's MoveComponent. This implicitly tells

access. Now you've got to do a little bit more than that so color got added at a later stage just to distinguish controls from content. Some background colors, a couple of crisp lines but at all times the message stayed present, it stayed front and center, it was

access your photos and your messages, gin access to your camera and your microphone, then there is corporate espionage, which is gaining access to your business emails and documents and your intellectual property, and then finally, there is direct financial benefit, stealing money directly from your online banking session or

access to notification that are pending delivery for your locally scheduled notifications, as well as access to delivered notification that the user might never see while local or remove notifications. Now you can also remove notifications that have already been sent to the user, as well as update and promote

access logs and error logs. Once again, don’t forget to get the user's permission to grab this data. We got a lot of fields in the access log, so you want to look at what streams am I actually getting. How long are they playing for? Where are

access to their credentials, their user names and passwords, but we're not giving access to the host app to this data. In fact, Safari View Controller runs in a separate process from your application. Which categorically frees you from the responsibility of thinking about this important sensitive user data

accessing functionality. And there's a good reason for a lot of that, and that's that not every user has a Touch Bar, so if you only put something in the Touch Bar, you're going to be losing out on functionality for a lot of users. And finally

access and load at least some of the data so you can show it to the user; that's what they're expecting. If the user instigates a network access, it's the same thing. Know when the user is accessing the network and how' they're accessing the network

accessible. You will, however, be able to white list some of your employees who will be able to test your end-to-end experience to make sure that you're ready. So let's talk about how we're making it easy for your customers to find you and to

access to a lot of information about what happened in your integration. And one of the ways we provide access to that information is through environment variables. This is just a sample of some of the variables that are defined when your scripts run. Any scripting language worth using is

access to all the places where their users have their documents. Replaces the multiple SDKs that they have had to adapt to until now. The reasons for file providers to adopt is the privacy model, which is really awesome here. So document-based applications open documents one at a time

access to horizontal. And you can see with stack views I can get the exact layout I'm looking for with very minimal constraints. Our recommendation when adopting auto layout is to use stack views and to try to use stack views first and then only when you need to

accessibility. All of your accessibility labels should use NSLocalizedString, so that when someone is using the accessibility features in another language, they can get the proper voiceover in their language and have a great experience with your content. Now once you use NSLocalizedString you would extract this into the strings

accessing either directory or filename will cause a use after free. The root cause is that split was passed a temporary. The temporary is destroyed after the call to split, and its references are invalidated. Accessing the temporary invokes undefined behavior. AddressSanitizer can catch this bug. Watch Understanding Undefined Behavior

accessibility, you get the larger accessibility sizes' option, which gives a large range of values for the type to vary on. So check that out. Now it's time to add some more views to our app. And I'd like to bring up Jason to introduce you to this

access to the AMD card so that I can pull resources on it back to host memory, on your behalf, okay? So now I'll go ahead and I draw with it and I Flush, that causes that data to get pulled up to the NVIDIA card now, and everything

access to the CPU. You have to wait each time you context switch for the rest of the queue to drain out and so you may be delayed by somebody else ahead of you in line. So, let's look about what might cause excessive context switching. So, there's

accessible from the CarPlay screen. If an app has posted now playing metadata and playback controls for audio content this information will also be accessible from the Now Playing app on the CarPlay Home screen. Audio will be played through a car speaker system and some SiriKit intents will be

accessibility. In the Accessibility display preferences, there's the Increase contrast checkbox. If we turn on Increase contrast mode, you'll see that colors and artwork throughout the system change to make the UI easier to see for people to see with low vision. Well, now in asset catalogs, we

access to the entire Apple Music catalog with a REST API. This year, as Betim mentioned, we're launching new additions to that REST API that'll let you access the iCloud Music Library for the logged-in user. We're also launching the MusicKit JS library. Makes it really

accessible to everyone, and we do mean everyone. Accessibility is one of our core values, and so we made AR Quick Look work with VoiceOver and switch control. So, let me show you the VoiceOver flow right now. So, I'll triple click the home button to activate VoiceOver. button

access all the repositories that Xcode 4 knows about because of the projects you've been working with. You can also access information about the projects there as well as documentation. The Version Editor again, we support some version and get. And the Version Editor was a great way to

access to critical sections of code or to serialize access, serialize access to some shared state between threads or just in general to ensure data integrity when you have some complex piece of state that needs to always have a consistent in a consistent state and that can be modified

access, where is it? I was accessing my mutable data here and I was setting zeros in every 10, 24th position, don't ask me why, and it seems to have crashed, so I'm going to roll back up and, holy cow, I activated the, I allocated way too

access it. And then you introduce this notion of accessing the data outside of the lock, which causes random corruption. Or if you have more than one lock in your program, you end up in deadlocks. And in general, that sort of thing is just a mess and it's

accessed from two different threads and so I need to serialize those accesses in some way and I can do that using a lock or again I could use Grand Central Dispatch. So that's actually what I'm going to do in this case. So I'm just going

access the touch surface and the buttons on the Siri Remote. The second profile that the Siri Remote supports is called GCMotion and this is what you use to access the gyroscope and accelerometer on the Siri Remote. Now note that this is different than what you might be used

access to the index, so if you need it, you'll have to keep track of it yourself. When you fast enumerate over a dictionary, the objects you're getting back are the keys. That means that if you need the objects, you should call objectForKey and get the value

accessed by a web service, whether that's a web service provided by a vendor or you loading in this content into your own database and vending it out to your own web services. This would be internal or external as I said at the very beginning. And having this

access to the Share Sheet that they get elsewhere on the system. They get access to some standard system activities that they might want to perform, as well as any third-party extensions that they have access to in Safari. And they get content blocker extensions that they'd have

access to content. You can take advantage of the presence of Touch Bar to hide controls on-screen to reduce clutter. For instance, here is Keynote. In fact, the app we're using for these presentations. Here is Keynote in presentation mode. You can see that in presentation mode, there

access to all of the tools that you need in order to play background audio. So, if you, for example, are an application that synthesizes audio; those applications have some really hard real-time deadlines that have to be made, so we make sure that we allow you to play

accessibility. See, I say like this. Apple brought me to a phone, and they did a radical job of that. But everybody out here in the room, you bring me, you bring us to the world. Because you all smart people in this room. You got brains and you're

access at the thinnest possible API layer, that's where Metal comes in. So how do we do this? Well, first thing we wanted to understand is how most modern games try to manage their CPU and GPU workloads. So most games will target a frame rate. Oftentimes, it could

access to settings related to audio and subtitles. Finally, AVKit supports Siri voice commands automatically. And as I go back to the beginning, or "What did she say?" to skip back 30 seconds and replay with captions turned on temporarily. AVKit uses the modern media stack, the same as on

accessible through iadworkbench.apple.com. All you need is an Apple ID to log in. When you log in, the first page you go to is the Dashboard. Dashboard is a summary of all the campaigns, and also it gives basic metrics. To get into the campaign creation flow, let's click

access to a shared data structure by executing blocks on a queue and accessing the data structure only from those blocks. And because queues are lightweight, this is actually easier and cheaper in many cases than using locking. You can imagine queues being an on demand locking mechanism that only

access is exclusively for the foreground application to ensure responsiveness. So while you can use some of these other scenarios, you can create a finish task to do CPU processing in the background, you do not have access to the GP one in the background. There's one really important

access to TCP and TLS connections. Now you might be looking at this, and you may not have cheated by looking at the description in the WWDC app. You might think that URLSession is built on the same primitives is built on the same primitives that you would use yourself

access to those things in your own pipelines. Model I/O is integrated into Xcode 7, and the GameKit APIs, it's on iOS 9, and OS 10.11. So in a nut shell, the big green box there is where Model I/O fits in your framework or in your application. We

access them inside your content extension. So when you receive the notification [inaudible] notification method, you can extract the attachments from your content. As I mentioned earlier, the attachment is managed by the system, and it's moved to a separate location. This means that it's outside of your

access the same data as my iOS and OS X CloudKit app. To talk about both of those, I would like to hand it over to Eric. Eric is the manager for the iCloud Server team. [Applause]. ERIC KRUGLER: Thank you. Well, thank you, Olivier. It's terrific to be

accessing that step's property. Now if you need conditional logic, there is now another version of ordered task, a subclass of it, called ORKNavigable ordered task, which allows you to specify predicates on the results and corresponding destination steps. This is a recent addition to the framework from an

access. And in a random access app, especially when the assets are larger, the content in total, what you want to do is tag more assets and read things in progressively so that as soon as the user makes a decision, they can start to see some progress of that

accessing the same data model. In the case of our chat app that meant it was the database as well as the data accessor methods written for it that could be moved to an embedded framework, so it could be reused by application and extension. After moving that, we took

Accessibility Inspector, Console and Configurator. For tvOS developers, Safari Web Inspector supports wirelessly connected Apple TVs. So this is great news for TVMLKit developers. And QuickTime screen recording also supports wirelessly connected Apple TVs. Now, while we're calling this wireless development, strictly speaking, you're not limited to only

access to my repository. I don't want to flip back to Xcodes to do that. I don't want to have to search for it. So now we work closely with GitHub so you can clone your Xcode projects right from github.com. You find the repo you're looking

access to all of the same build settings that were available to you throughout the context of your run script phase. The important thing to note here, though, is that these files cannot be modified or generated throughout your build process. They are read when your build They are read

access to a lot of functionality. There's more than 2,000 APIs available on the Accelerate Framework. Throughout the rest of the talk we'll break this down into four easy-to-remember categories and show you what exactly is available. Think accurate. We spent a lot of time

access to features like interactive text coloring. As the user types into your app, you can change attributes. Let's pretend I'm building an interactive client for a popular internet messaging service. Just pretend, this is hypothetical. I type in my friend's handle, and it just sort of

access to a shared data structure by executing blocks on a queue and accessing the data structure only from those blocks. And because queues are lightweight, this is actually easier and cheaper in many cases than using locking. You can imagine queues being an on demand locking mechanism that only

access it multiple times whenever you want to go and get access to it. So this is Instruments launched. And what we want to do is take a look at the memory profile associated with this particular demonstration. And so, what I'm going to use is this Activity Monitor

access the network right now, don't access the network until there's something really important. In terms of design, anything that you can do to offload to the system and let the system decide when, give it some variance of in the next 10 minutes, the next hour, the

access to the task that was asking the question. So there's a new category NSURLSessionTaskAdditions. If you look in the headers or on the NSURLLibrary, you're going to see this category show up, and it provides asynchronous gets and, presumably, asynchronous sets, although that's an implementation detail

access to a shared data container, which both your app and its extensions can access. And this year we have introduced new API to let you create a cookie storage associated with that group container. And I would like to show you how to do that. So what you want

access align boundary box to boundary box, Graphics Gems 2. You kind of learn where those tricks are. Those fast algorithms, you want to get those books, have them on your shelves. Same thing applies to the Games Programming Gems which kind of has much larger systems in it. If

access the normal functions of your app. For us, there's the top right corner, there's the small white arrow thing, you can see it? If you tap that, the UI will minimize and then you can access the other functions of the store of the app. And just

access to the public database. Let's say for demonstration purposes here that the clown central app will require an iCloud account. We talk about a couple of features that use the private database which, by definition, require an authenticated account. And by default, write access to the database requires

access to notification settings for all of your shows. That means if you only want to get notifications for your favorite show, 99% invisible, it's as simple as toggling the it's as simple as toggling the switches on this single settings page. So, last year, at WWDC, we

access to Xcode extensions to the text and metadata that they need at runtime to perform their operations. They don't get access to the project structure, they don't get access to the user's files on disc. And why are we doing it this way? Well, stability. We

access your machine across the other side of the country, it's wide area Bonjour and the standard Bonjour APIs that are doing that for you and if you have an application that registers with Bonjour and browses with Bonjour, then your application will work planet-wide using Back to

accessed the source code and we didn't know that. And this is one of those. So, NSExpression can actually parse mathematical expressions. So here, I've got 3 plus 5 times 4e10. And if you've ever messed around with this spotlight menu in the upper right hand corner

accessibility features and dynamic type right out of the box. So, I said that these let you customize things to some degree, but as soon as you want to kind of go beyond just setting a tint color or an image override on something, you might have to start dropping

accessibility [ Silence ] in general last year in our "Preparing and Presenting Media [ Silence ] for Accessibility" talk so check that one out for more details. [ Silence ] For the purposes of this talk, [ Silence ] just know that to get this SDH label here, [ Silence ] it involves setting track-specific metadata. [ Silence ] So

access to their data as they're wearing it or throughout the night, and you want to make sure that your connection to your Accessories is reliable. So on iOS we allow you to be a background application. You can continue connecting out to your accessory or you can continue

access qualifier write, and then you can write to your texture. Read-write texture, a texture to which you can both that you can both read and write in your shader. Only a limited number of formats is reported for those textures. To use the read-write texture you will

accessible to the user again, but the scroll view presents kind of a challenge for us. We want it to start off unobscured by the title bar and we don't want the scroller to be obscured by the title bar either. However, if we just leave the scroll view

access to the H.264 video encoder during real-time capture and manual camera controls. Good news, you're getting both of them in iOS 8. [ Applause ] So, H.264 video encoder. We're introducing support for access to the hardware H.264 video encoder via the video toolbox APIs, which have already

accessed, here. And I can tap on this little arrow button, here, in order to collapse it. And the files which I am interested in are the PLIST files. So, there are two files that are available, here, Patient dot plist and Template dot plist. Template, as the name suggests

access that state restoration archive, so in this case we take a simpler path. We let the application get its work done, fetch its assets, do whatever it needs to do in the background, but we don't try to restore state, we won't be able to access the

access to hardware functionality. These are things your GPU could already do but you didn't have good access to. Most of this is 10.6.3 and above only. So if you want to target these cool new things you've got to use 10.6.3 and above. But first some advice

access. Anywhere on iOS, I can just swipe down on my phone and I will see that push notifications that were most recently posted per app grouped together in Notifications Center. And this is great, not just because I know exactly where to go to get my notifications, but because

accessible with background processes even when you're not using the iPhone. Because your phone is personal and private, it's protected with Touch ID. And, to make those short engagements really easy and fun, you have a very detailed touch screen. The Watch is quite similar. It's also

access to all of our app source code. UI tests on the other hand, are great when you need to test large chunks of code, working together. Of course, we need to keep in mind that unit tests do have access to all of our app's source, whereas UI

access to information you want. And of course, we support this on Yosemite and you can see it looks gorgeous blended right over that new background. It's just beautiful, stunningly beautiful. The team did a great job. Next, I want to show you the Custom Action Extensions. You can

access to the application. Allow them to keep using your app, and don't let them get stuck on any kind of modal loading spinners or things like that. The transaction will eventually come through as a purchased one, once it does get approved. And you can just handle it

access that way. And, finally, once we have this library of music or library of other content that you want to link to the iTunes Store, you might want to construct a custom playlist for your users, so that they can buy a mix of their favorite genre of music

access to a subset of those filters, and in-app purchases allow users to gain access to even more incredible filters. This is my app development timeline, which may look similar to your own. Starting with the design phase, then I'll be developing the app, launching it in the

access to millions of apps in the App Store. You've already passed the first hurdle when someone installs your app. Great. So prevent them from backing out and deleting your app in the same way you'd probably be off to the next apartment on your list. And then

access to the credentials stored in Keychain, so users' privacy is preserved, as well. The iCloud Password Keychain Manager can help users log into and create accounts in your app. We've added some new features on iOS 12 to help make account creation and login even easier. I'm

accessible while they're playing with the game pad, and so is motion control of the device. And by "standard," we're referring to the controls layout on the gamepad, specifically that there's a D-pad, that there are four face buttons (A, B, X and Y, always in

accessible to multiple apps in the system, even system apps can have behavior provided by your extension, you may want to select a process other than your main app executable when you're profiling your sharing extension. Now for this demo I'm actually going to select a today extension

accessible to your scripts using some simple class conventions in JavaScriptCore. Let's go into detail into each one of these methods starting with the simplest. When your TVML application loads, the first thing that's going to happen is, TVMLKit is going to fetch a JavaScript file that contains

access the currently presented notification actions to the user as well as replace these actions by setting a brand new array of notification actions for your content extension. So going back to our sample, what if after the user took the like action we wanted to replace it say with

access to all sensitive data. In order to use any of these services, you must provide a reason string. If you don't, your app will not be granted access to the desired service. The three specific keys you should be concerned about for Capture are NSCameraUsageDescription, NSMicrophone3UsageDescription, and NSPhotoLibraryUsageDescription

accessible via keyboard access and with voiceover. It has the beautiful cartography that we all know and love in Apple Maps. And it has support for native gestures like Pinch to Zoom, Two-Finger Rotation, and also Shift, and Two Finger Scroll to zoom in. It also uses something that

access SSLv3. Research has simply moved too far for both of these technologies and no longer think that they provide effective security for our users. So, these are disabled. Other algorithms are starting to show their age; specifically SHA-1 is showing more and more vulnerability to attacks, as is

accessibility features such as the HUD and how you can pick that up, there's the What's New in Accessibility session happening this Wednesday. I recommend you go there to learn all about what's new in accessibility in iOS 11. And so let's talk next about navigation

accessing the camera. AV Foundation is broad and deep. If you're new to camera capture on iOS, I invite you to review our past WWC camera presentation videos listed here. They give you a good base for today's presentation and plus, you get to watch me age gracefully

access control. The problem is that Swift requires you to mark symbols Public to be visible to your unit test bundle so you can test them, leading to tons of stuff being public that really shouldn't be. Swift 2 and Xcode 7 has solved this problem. Now your code

access to the mic on the Watch itself and provide a great experience. And you have access to the Keychain now, so you can provide a really secure experience for your user. So in recap, we were able to discuss the architecture of an app, we added a Watch app

access to files or databases, and pay careful attention to your memory use. Do notice that each call to CoreSpotlight has a cost, so pass batches of items instead of single items when possible. And just making batches as small as ten items will still reduce the IPC overhead by

access our viewport dependent data like this model view projection matrix in this example. And then, finally, you do want to associate your viewport index with the instance underscore id so that the right viewport is selected when rasterizing your image. And that's how you use the new Viewport

access to Apple Pay; and your iMessage app will also be able to use the camera. And we believe these technologies and features will allow you to create great apps for your users. Now let's talk about supportive platforms. iMessage apps will only run on iOS X. However, the

access and search one of the things we found is that users want to search for things they have seen in the past. NSUserActivity makes searching this information and indexing it very easy. It sort of works like how a web browser maintains your browsing history and the user activity

access to in watchOS 2. I'm going to take a look at what that means in code. So let's zoom in on our soccer club digital ModularLarge template. This has four pieces. There is a header image that you can provide. Header text. And then there is two

access to this program as well. The next slide is an evergreen topic. Every year we add new Setup Assistant panes in one or more of our OS's, and this year is no exception. And, we continue to want to enable organizations to configure the experience they provide to

accesses on modern architectures are expensive compared to most other operations. The compiler tries very, very hard to hide that cost by moving memory accesses around, removing redundant operations, killing dead code, but to do that effectively, the compiler needs to be able to analyze which pointers may possibly be

accessible and discoverable throughout the App Store. You will see them on the Today tab. We actually designed a card specifically for in-app purchases. They will be highlighted on the Apps and Games tab. And they will be searchable. They will also be featured by you on your product

access the first item in the Array just using subscripting. Here we're extracting eggs. If we want to add an item to the Array, we literally just add it to the Array, we add it to the end. Here we're adding a third item, flour. We can also

access their safe credentials, iOS 12 allows password manager apps to participate in AutoFill for the same experience as iCloud Keychain. In iOS 12, there is a new UI for password AutoFill settings, which allows users to select an app to provide credentials to AutoFill, in addition to or instead

accessible via the candidateListTouchBarItem property. Now once again, remember the Candidate List you see with a TextField is actually in the bar associated with the window's field editor. Candidate data generally comes from these three sources. In the QuickType case, the data for the Candidates is supplied by NSSpellChecker

access to the calendar data on the device. It's split into two parts, mostly as a function of the way we built our OS. But we have a non-UI side and a UI side. So, in EventKit, we have all of the APIs that allow you to get

accessibility engine was rewritten in Swift. Why did we do this? We just didn't rewrite code just for the sake of rewriting code. The code had kind of grown organically over time as features had been added and it was time to refactor it. But also some new functionality

access on iOS and you pass horizontal or vertical and if you call this in the debugger, keep in mind that horizontal is 0 and vertical is 1 so you don’t have to type out those long constants. And it’s also possible that the layout is ambiguous and

access to the model data that it's going to present. For our application, most of our model data is stored in a user session class. So let me add a property to hold that now. So I'll call it userSession and declare its type. Naturally, we have live

access to in order to read information out of its container. The second one is a stream-based asset. We have a lesser degree of control over what we can read out of that asset. It's essentially being beamed to us by a server. There's a little bit

access to the gesture recognizers themselves. But in 2012 with iOS 6, there was another fairly large internal update to UIScrollView that added support for resting touches. And so what I mean by this is that in previous years, prior to iOS 6, if you put a finger down on

access to a completely separate data container. In practice, the fact that class is executed on different clones will likely be invisible to your tests, but it's something to be aware of. So, where can you run tests in parallel? You can run unit tests in parallel on macOS

accessible for people coming to JavaScript from languages like Swift or C++ or other class-based syntax languages. So here I have a simple example of a polygon class written in the standard prototype syntax. But in ES6, a new syntax has been introduced, an object, a class-based syntax

accessing it at the same time. And if every one of those clients is trying to save if, save the same record and you're locking on that, most of those clients are going to be hitting locking errors, they're going to hit conflicts, and they're going to

accessible to the servers that you're using. So when you're streaming your game play to Mobcrush or YouTube, share your screen in WebEx video call. Use TeamViewer to work as customer support, or maybe stream your drawing app on a Facebook. All of that is powered with ReplayKit

access of our releases today is we have two releases, we have the Xcode 3 Production Release and the Xcode 4 Developer Preview. So, today, I'm going to start by talking about Xcode 3 and the new features we have in the Production Release. And then later in the

access it. now safe for GPU B to access it. So, this is an elegant way to fix our synchronization problem. But, clearly, having a GPU, potentially, a very powerful GPU just sitting there waiting is not good. So, we need to make this wait as short as possible and

access the file system or sockets. We can't log. We can't even call a dispatch "async" because it allocates continuations. And we have to be careful not to interact with the Objective-C and Swift runtimes because they are not entirely real-time safe. There are cases when

access a property on an object. Its purpose is to look up the method implementation for the selector and invoke that method. That's a long way of saying that's how we do dynamic dispatch in Objective-C. Objc msgSend is extremely fast and does not push a stack

access to the high-performance engine running underneath SpriteKit. In this case it's running inverse kinematics. And this little scene was set up in Xcode. And very quickly just clicking and setting up a couple of parameters. Here's another one that's actually new and cool. You can

accessible on one screen. Problem solved. But wait a second. Is this really a good idea? If you think about it, the map is only half of its original size; so is the list. We have to pan the map more. We have to scroll the list more in order

access the views and see the data in Instruments. So now you can collapse away just about anything you don't want to see. Collapse away the track view, collapse away the Instruments list and configuration panel on the left. Collapse away the extended detail view. And if that's

accesser on the dynamic item protocol. And now you can specify an ellipse type, which will derive from the bounds width and bounds height on the protocol. And finally, you can specify a UI BezierPath to use for the collision bounds of your dynamic item. Now, to accomplish this, we

access all these different features for notifications? For this we introduced two new frameworks last year, namely User Notifications and User Notifications UI. We went in depth covering all those different APIs at last year's WWDC and we highly encourage you to go check out these two sessions from

access to the low-level APIs, which are OpenGL and Metal. SceneKit was introduced on OS X on Mountain Lion and last year on iOS in iOS 8. Last year, we added a few new features to SceneKit to make it ready for casual games, like particle systems, physics, force

accessible is not what we want here. Because then that means we have to keep things running all the time or the client has to have knowledge of the server's life cycle. So we can sum all this up by just saying we have to learn to let go

access to any special distribution signing certificates. The archive contains both the machine code and bitcode of your app, as well as your debugging symbols, all bundled up together. And once you've built one of these you can use XCode's Organizer window to generate an IPA and upload

access. This is the 1Password overview screen. Everything you see here is built using open web standards. On the left, you see logins. They help you to quickly login to different websites. In the center identities they help with signing up for new online accounts and on the right credit

accessed by tapping that button. And these conventions that exist, at least for iOS and Mac, are not at all arbitrary. Swiping to delete isn't just intuitive because of the thousands and thousands of apps that support that same interaction. It's consistent, or sorry, that's a part

access to the name of our place, so we can just go ahead and throw that into the initializer there. So now, when we Quick Look our place again, we should see, cool, we've got Moscone Center there and everything is starting to look a bit more like a

access all the objects and all the property of your scene so you can of course move, scale and rotate the objects in your scene. You can also add some animations, change the colors or change the textures, adjust the lighting etc. To do this, you need to know what

access point or if they're connected to different access points. So we think this will bring nearby networking on iOS to a whole new level. We're very excited about this. So what are the features of the framework? So as I just mentioned, we support multiple wireless technologies

access to a file. If you can't execute through the parent directory of a particular file, you can't see the file much less read it. However, world-read permissions are not appropriate for everything. So if you have a file where world-read permissions aren't appropriate or

access into an array. Here's another example where you're calling a method which expects a caller but you're calling it with a string, you know sort of maybe looks like a caller. And an invalid parameter value, we often consider nil not to be a valid string

access for everyone back on. So that's pretty good for me. I think that's a good set of access controls for my server. From OS X Server you can also set up hosted repositories. If you'd like Xcode Server to host your repositories for you, you can

accesses the run data to generate this Bezier path that they gets overlaid onto the map. So let's look at that a little further. Well I'm going to click on the map and I'm going to hit this whoa, scrolls really fast. I'm going to hit

access the elements of the array as instances of the specified class or instances of a subclass as well. So this is now this works. Note that kindof is a compile time facility like most of the things I have talked about here. There is no runtime code changes, there

access to the camera inside your application and use the entire iPad as a view finder. Now, if using the camera is not the primary feature of your application, you will likely want to adopt the multitasking enhancements on iPad. Our notes app is a great example of this. People

access to the underlying model. So for more advanced use cases, you can use it as well to programmatically interact with it. We take a look inside the MLModel class, we can see that there's a model description which gives you access to anything you saw in the metadata

access the web inspector through Safari's develop menu. And then the tab that's most interesting in terms of power usage is the timelines tab. So you can switch to that tab and then you would start recording a timeline by pressing the button. And then interact with your

accessible to more customers. This is the type of data that we deliver with App Analytics. With all of these, our ultimate goal is to help you build a better app. You are here to learn tips and tricks from experts so you can build a better app. That's

access to creative agencies and may not want to spend even for all of that. You get the benefit of Apple designed beautiful templates here. The templates have been designed to ensure that your app is highlighted in the banners. So we have five templates, each with five colors. So

access to everything. So what what do you have to do. Subclass UIGestureRecognizer. All right, what do I implement. Well, there's just one single most important thing to well actually sorry we have to get to that in one second. Before we do that, keep in mind that UIGestureRecognizer

accessibility and better integration with other devices. And finally, I'll tell you about a bunch of smaller enhancements that I think you'll find very handy. Before we dig in, I want to take a moment to talk about the dash WebKit prefix. This is a technique that we

accessible from the match. The next class, the participant, you know, this is the seat. This is how many people are playing the game and who they are if you know. Alright so, if we know who they are it's a player ID but you got to keep in

Access to the MFi program grants technical information such as the specification that we have put together concerning MFi game controllers. Hardware components such as the lightning connector that some of you may choose to use in your game controller. Test tools, technical support and last but not least certification

access an Audio Unit's View Controller, then you also need to use a new asynchronous method to do that. There is a new property, Request View Controller. It is also asynchronous. You can read about the details of that in Audio Unit properties.h. So about these asynchronous methods. You

accessing speech recognition. Authorization can be changed later in the device's privacy settings. Let's see what it looks like to recognize a prerecorded audio file. We'll assume we already have a file url. Recognition requires a speech recognizer which only recognizes a single language. The default initializer

accessibility identifiers on your views, those identifiers will show up in the log paired with those views, so you can find the view you are looking for. That's how I got Saturn from the constraints we saw earlier. It has an accessibility identifier called Saturn. You can also set

access what's attached to the window. You can add them. You can insert them at a particular index. And you can remove them at a particular index. But it's really easy to just add and remove. And so here's what you'll typically do. You'll call

access to Quick Looks which are also available in the variable view. We talked about some drawing diagnostics that you have access to. And we talked about XPC Services and the debug capabilities in Xcode. I know many of you; perhaps all of you have new features or new applications

access via PassKit, our framework. The second value we use is a passTypeIdentifier. And now this defines the class or the category of passes that this particular pass is. You register for this in the developer portal as well. We also use this value to group passes together. And lastly

access properties of that instance. All we really are going to need to do is wire our item up to the represented object, i.e. its ImageFile, and then all of these controls will just populate, including the image view over here. Because we're using a separate nib file for

access to DOM elements that were probably generated through JavaScript, which you won't be able to find in your editor. So something neat about this DOM hierarchy is as you hover over the elements, they actually highlight on the page. So some that move might not work perfectly, but

access to the outstanding user info transfers in the queue. Next, let's talk about file transfer. An example we will use for file transfer is this image-editing app. The user can edit images on the iOS side, and then they can select their favorites, and those favorites are

access that same data. That is App Transfer. It's available today, and we're very excited to see how you use it. [applause] Dave: With that, I'm going to turn the time over to Nick Oogloff [phonetic] to talk about our automation enhancements. Nik: I'm Nik Uglov

access. And you do this with the shared storage mode option when you create your resource. And this creates resources in memory shared by both the CPU and the GPU. Now, this is actually the default storage mode on iOS, iOS devices being unified memory architecture, so the same memory

accessible through CSS. Style it however you want. For the next step, we're going to push past what the built-in controller can do and add functionality that it never could in the first place. So subtitles, why should you care about subtitles? For one reason, perhaps you have

access, which is normal to the rotation. So, when we get that, that's going to do what we saw on the previous slide, and then finally we'll just set the duration at the animation of the layer, and off we go. So, one final animation point, which is

access to your devices rendering hardware. Instead of keeping all three separate we think it's time that SpriteKit breaks out of its 2D mold. SpriteKit has a great deal to offer to make using it in combination with SceneKit and Metal attractive. Since they both use Metal under the

access. But, every time there's a modification, when there's network availability, we want to send that back to the server. The server holds the truth. And, if we use in CloudKit what's called subscriptions, we can have the server send push notifications to my other devices or

access to users' systems. We removed trust in all MD-5 signed certificates across our platforms in previous years. SHA-1 just recently had an attack. The Shouted attack was performed earlier this year, and so this is the freshest information. Knowing that the SHA-1 one attack was imminent

access them in your code. Then, we're really deep dive into some of the features and give you a good understanding of what they are. Finally, we'll write some code. But before we get to any of that, let's talk about an idea. This is an idea

accessibility data, the same semantic information used by VoiceOver technologies as a kind of searchable structure for the application. To evaluate a query the test process requests what we call a snapshot of the current data. This request is sent from the test process to the application so these are

access to the now playing UI right from inside of a workout as well as surfacing important information throughout your day in a new Siri watch face. And of course, we're introducing a ton of new features for developer so you can continue to create great watchOS apps. Now

access resources within those bundles. And when you use NSBundle's APIs, they automatically get the most appropriate resource for your current language. And what's more, building bundles is directly supported by Xcode. So when you have localized resources in your application, you don't need to write scripts

access or modify some kind of resource that the GPU also happened to be using. And so this can happen in a number of ways. It can happen because you're reading back the contents of a frame buffer that you rendered to or you're modifying the contents of

access. And because we want these to be evaluated at exactly the same time, we create a motion effect group. We add both of those motion effects and then we add that to the button. So each button has its own grouping of motion effects. And that's how each

accessible, such as adding Closed Captions or supporting Dynamic Type. You can also, just like in Mushroom 11, support Left and Right-Hand Mode, or you can support Color Blind Mode, like in KAMI 2. And one of the coolest Accessibility updates that I have seen is from Blackbox, which

access to user data, such as contacts, location, or financial information. We provided a format for your use, and put a lot of thought in its content. It explains concisely and clearly what data is requested, and how it will be used. Alerts are also used to notify people of

access to the video cameras through AV Foundations so you'll be able to capture right off the camera. You can put your own layers over the views that are drawing, right. So rather than putting up an MP media player controller and trying to get stuff in front of

accessing encrypted data, which is separate from off. Again, these shortcuts are going to execute on iPhone over Internet. The richest experience for users will always be with a Watch app that can handle the shortcut locally, either by launching the app or by executing the intent in the background

access to all of your user's cookies through this API. user's cookies through this API. You should not be offering them that much power. Instead, you should protect your cookies, especially your authentication cookies that are effectively a way to log in as a user by marking them

access to a ton of cool features. And we're using the multi-process architecture that we're also using on Safari on both OS X and Lion, and now on iOS with iOS 8. In fact, one of the goals we had with this modern API was to take

accessing part of the object in a way that a subscript operator does. And that's going to make it a major obstacle to somebody trying to actually understand your code. And finally it's okay to add new idioms that everybody who reads your code is going to have

access to their data to just their app, to other apps developed by the same team, and then, of course, to all apps on the system. And when we GM, we will also be supporting manage configuration for our enterprise customers. So finally, the most important thing was that it

access your app's information and, ultimately, CarPlay will timeout. So, if your data needs to be accessed while the phone is unlocked, you'll need to audit your app's data intergradation policies. The other issue is that you may be driving in areas, or CarPlay users are driving

access to that report from within the assigned handout. So, this entire flow involves you having a teacher managed ID, a student managed ID, and maybe a couple of devices or even one device from which you'll be logging in and out, so you can test. But with all

accessibility. The good news here is that the Focus engine again does some work for you. For example, if the user wants a high-contrast user interface, the Focus engine will helpfully put an extra ring around the currently focused item to really make it pop out on the screen

accesses. Compiler validates that these are actually Objective-C properties, gets the right names. And then produces the string that we pass down into the frameworks. And so between #selector and #keyPath, you can essentially not worry about the Objective-C names. You just write everything in terms of the

access to the system hierarchy, the whole hierarchy down from /System and everything in there. So, be proactive and stay out of there because changes are coming that will require that you not be there. So all the other common locations that I talked about, applications in your application bundle

access to information on the fly, it's really, really a cool thing for them to be able to expect. And what it means though for you as developers is a real significant change in your mindset in terms of how you develop networking applications. The mobility is not the

access to the content and functions in your app. The way it works is your app is launched, you receive a link, and the app displays the content. The same can be done to complete a function in your app automatically. Here's an example of launching a video from

accessible through the camera calibration data. In fact, this operation is done in every frame of the TrueDepth stream. The reason for that is that the video stream and the depth stream are coming from two separate cameras. But because the TrueDepth camera gives us a depth map we can

specifically is Inclusive App Design. It kind of will talk more about some of the things I mentioned at the end about how you can keep an inclusive design in mind for both internationalization and for users that need accessibility support. And that's all. Thank you very much. [ Applause ]

access to your heap data or at least a part of it. And there might be a password in there. There could be any number of little gems for a security attacker to take advantage of. So, now that we've covered how you would safely share a piece of

access this at the Foundation level. You simply call a 'string by applying transform.' Then you provide a string or here a constant, representing how you wish to transform the string. Here, we wish to translate the emoji character or, sorry, transliterate the emoji character "thumbs up" into an XML

accessed from across iOS, Mac OS, and tvOS and can also be shared. And thanks to iCloud authentication, you don't have to ask your customers for a separate login anymore. And this is still true even if your app happens to also run on other platforms that do not

access an updated value in sync with our own animation. So I'd like to show you what you can do with that. A very simple custom layout, a stack layout that's in a collection view controller implemented in navigation controller. So I have this nice layout to layout

accessing everything else on demand. We recognize this does add complication. When you talk about presenting the next Scene traditionally you know it is in local storage, you can prepare those resources, and when the user requests it, you can present. Now we're adding an extra complication. Maybe you

access to on your WWDC app for Auto Layout. Introduction to SpriteKit, I made a plug for it earlier. That's going to be great if you're doing any kind of cross-platform 2D Game. Best practices for Cocoa Animation, that's a great place to go to for

access to limited resources like CPU time, disk IO and most importantly for this talk, energy. So in designing this feature, we wanted to focus system resources on the most important user work. And the benefit of that is going to be increased battery life and improved responsiveness. Now the

access to the GPU to interleave graphics and compute, and so on. And really take control yourself over how the frame is being rendered. So that is number seven: optimize graphics performance. Okay, number eight: now, we're lifting out of the tech in just a couple of really kind

access to them, there is Keynote. And that's what we are going to be using today because it's very quick to make animations, and it's very, very quick to get things onto a device. So let's look again at the requests from our CEO. Conveniently, they

access or for this idiom and then calls that and it returns that answer, and if it doesn't respond to the selector, it goes ahead and just returns idiom phone. And that's actually a really good technique also in terms of dealing with symbol availability. You're going

accessibility labels, so that your users using VoiceOver have just as rich of an experience as those who are not using VoiceOver. Here's a wall of text. Lots of stuff going on here. Luckily, there's a callout. I know which part of this I need to pay attention

access to the new Mac Pro. We originally designed MARI with multiple GPUs in mind. For me it makes so much sense that you're going to want to be processing huge amounts of data on one device while you're displaying it fluidly at 60 frames per second on

access to the object but just don't peek at it because everything inside of it is subject to change at any time. If you need control over paper size like pages, for example, at the document center gap where the user is designing their layout with the page in

access log to make a better guess about the bitrate that the next playback station is going to get. So let's suppose that you come up with a hero stick based on startup quality and recent bitrate statistics. And you decide on a way to choose which variant you

access this page. But remember that developer accounts are free. Now once you've done that, you end up on the downloads page. The download itself is a disk image which contains an installer package. Now the screenshot here is a little out of date. You should see a newer

accessible to the system and the broadcast service. Alright, so to illustrate how this works, we've been working with flair games to implement the broadcast feature, and the flagship game, Olympus Rising. So it's a really awesome game. It's available in the app store today. And it

access to their different payment cards, as well as shipping, billing and contact information. And they can see a detail of what they are paying for. When they're ready to pay, they simply double click the side button and it's done. It is that simple. Now let's

access Siri even if the CarPlay UI isn't showing. Usually this requirement is satisfied with a push-to-talk button on the steering wheel. For the Siri button, we require that the head unit send iPhone all button up/down events so that interaction during the Siri conversation is possible

accessible from Swift as well. It supports low latency real-time audio. Using AVAudioEngine, you will be able to perform a variety of audio tasks, like play and record audio, connect various audio processing blocks together to form your processing chain. You could capture audio at any point in this

access it from the handler. You want to do that all the time. And the location we're getting in the view is super view so we have a steady reference frame. And then we're going to switch on State. It will go to through four states. In the

access that and create a movie from a block of data. We are not actually going to talk about this anymore in this talk, but if you look at our sample code package called AVMovieEditor, you will see very nicely how you can put stuff and take stuff off of

Accessibility Settings for even larger type, much easier. It also makes localizing your app seamless. Your text will adjust the lettering, or line height based on the height of the characters. So using these features will only make it easier for more people to use your app. So, this is

place stickers, Apple Pay sheet, access to the microphone, camera and photos. Think about what is best for your app, and improve on an existing experience, or create a new one. Because in the end, you want to create a wonderful experience for your family and friends. Thank you. [ Applause ]

accessed. And the browser picks the appropriate stream based on the characteristics of the current device. Now Safari on OS X and iOS use the AV Foundation Framework to play HLS streams so you get the same high quality streaming experience as the native apps. And AV Foundation will seamlessly

access photos that are local to the user's device. And using this new API that will be possible. There's also a lot of game developers out there we hear from who have an in game newsletter or an in game leaderboard that uses web technology. And they want

accessing the dropped items so you can actually perform the data transfer. It gives you some really great convenience methods for updating your collection and table view. And finally it gives you some ways to specify some default system animations for your drop. So now that we've talked about

access both of these objects using two new user info keys that we're providing. The UIFocusUpdateContext key and the UIFocusUpdate AnimiationCoordinator key. We're also introducing another key notification type related to focus updates and that's called UIFocusMovementDidFail and this notification is sent whenever the user tries, but

access that same file, instead of getting their own copy. There's some really great information available in the following two sessions. I highly recommend that you attend them, if you are interested in providing File Providers in the context of drag and drop. All right. Next, we're going

accessing the scroll view's pan gesture recognizer property. I'm just taking that gesture recognizer and I'm moving it over to the dummy view. I only care about the pan gesture recognizer in this case, because I'm not trying to allow zooming on my view. Then finally

access to the same data as the app, so I'll add it to the same app group. In the Project Settings, I select the intents target and in the capability step, I'll add it to the same app group. Great. Now, we're ready to implement the intent

accessed this directly probably. UIKit surfaces that context to you via UIGraphicsGetCurrentContext which you've probably used if you've ever done any CG drawing calls of your own in drawRect. Even if you haven't the methods that you may be more familiar with like UImage drawAtPoint, the Bezier

access to each of the bands and set up the different filter parameters. Connecting the EQ is no different than what we've already seen. I can connect the player to the EQ with the file's processing format and connect the EQ to the engine's output node with

access to all of the other assets that are used in that project. When they're done with their editing session, they simply hit the Done button, and they're returned to the project that they're working on. You get a notification that the library changed. You can respond

accessed by the GPU on which it was created. Now, we see a code snippet showing us how our VR application would send IOSurface to VR compositor in the past. We will now go through this code snippet, and see what changes needs to be applied to switch from using

access up front to the sizes of the content that you're going to display. So I'm going to show you where this change needs to take place. It's in this configurePage-forIndex method that I keep calling, but I haven't shown you yet. So, let's

access sharing. A great place for an action button in a detail view like this is in the title bar. It helps communicate to the user that you can share all the information in this view. On tapping that button, you can call a UIActivityViewController. This will display the user

access the same framework, but we're not letting you use the framework out of some other application installed even if it's one of your own. All right, so all of these things get imbedded directly in the application. So your apps are still completely stand-alone items. So

access to content. In this particular case, the asset packs that are built by Xcode based on your asset tags get moved off. They are stored separately from your IPA in the App Store. You can download them on-demand. You can designate some of them as being part of

accessing their properties, exactly the same way that you work with classes. It's exactly the same way that you work with enums, or enums. It's all the same consistent style. We also get to use initializers that are the same across all the different data types. We get

access to these builds right away, and beta app review will be required to unlock your 1,000 testers. But while your build is in review, you can continue to upload new builds, and your internal testers can continue to test, and you can continue to manage your testers in

access, that a table is going to be populated with a set of multiple choices, and that the user is going to choose one of them. That's going to be the responsibility of the controller to then turn around and take that change and commit it back to the

accessible by 40 or 50 people in a local network area by both computers and wireless devices as well, and how we can use automation and the technologies of OS X to make that possible. The second scenario we're going to look at a basic thing that faces everyone

access all the keys that you preloaded with the ContentKeySession object. So now we have 2 API's, AVContentKeySession and AVAssetResourceLoader, and you might be wondering which API to use for loading different types of resources, and here's what we recommend. Use AVContentKeySession for loading content decryption keys, and

access to the depthDataMap itself which, again, is a CV pixel buffer; you can iterate through it by row and column using standard CV pixel buffer APIs. And the final two properties I want to highlight here have to do with inherent problems in capturing depth data, and we're

access to today. And you simply set the AirPlay 2 toggle in the developer pane, flip that on. And then you can use an updated Apple TV as your AirPlay 2 receiver and send to it. In an upcoming beta, we're going to enable multi-room audio. And lastly

access to the microphone [inaudible] directly, you could use the AVAudio Input Node, and also optionally, write it to a file. And here are the formats that are supported on watchOS, both for playback and recording. A last note on the recording policies. The recording can start only when the

access to it, it's the same popup, you know do you allow this ad to see your current location. Now the annotations are pretty easy, obviously they [got a lat, long, this is their position and the name of the description, now this is the title and subtitle of

access any links and notes while they listen to your episode. Another exciting update, we have podcast type. We also have episode type. So, in iOS 11, we're coming out with three episode types, a full, trailer and bonus. So, full is the default episode type, and it represents

access you can check them that way and you can use relative paths, absolute paths or file URLs. However, I should note that you can't mix file URLs and HTTP, that is if the master playlist is a file path then the media playlist it references can't be

accessibility of the surface from the outside and encoded that as a signal on the surface of the plane, so that your shader can render an object to be more physically grounded in your scene. Here's another fun thing that you can do. We've got all kinds of

access to the media protocol. You can also chain your animations using various timings. But that's also a possibility. OK. So what we've done is we've put together a sample code. What I've trying to do is put up sample code that will make that will

access point, which basically means the connection that you have created on Wi-Fi is getting slower and slower, and ultimately your application is actually getting slower as well because it cannot download the content from the internet. And it will only be able to continue again when you have

accessed here. We've designed the package this way so that it's compatible and extensible. At the top level, the converters give Core ML compatibility with a variety of popular tools. Underneath that, the Core ML Bindings, Converter Library, and the Core ML Specification make this package extensible so

access the delegate at that point because we don't know that it's gone away. So just remember, always set the banner view delegate to nil before you release it. So now let's talk about multiple interface orientations. This is really a question of ad content sizes. So

access documents on their OS X server account. There are a number of other settings added to existing payloads, including a lot of changes in the IKEv2 VPN connection type, more about that later, and a large number of new restrictions. So let's look at those. There are a

access to if they did subscribe. And finally, you can allow people to sample content. It's a great way to engage through experience. And it works great for the majority of apps. This is "The New York Times." And you're able to read ten articles for free per

access to more information with these coalesced touches. The coalesced touches not only have information about the intermediate touches but they also give you a copy of the main touch itself. And the great thing about this is that it allows you a choice. You can look at the main

access the Spotlight search indexes from your application, which is cool. And it does all of this without scattering zero-length files all over the file system. And I'm really hoping that at least some of you are mentally cheering about this because I sure was. So how does

accessing them through voice. And that's what we'll focus on today. So, let's get started. First, we'll talk about how your users can add shortcuts to Siri and how simple it is to write use it right away. Then, we'll talk about how you can

accessible from the GKMatch. You can use properties on the Voice Chats or methods to start and stop them so you can hear selected chats. You can have multiple chats going. The microphone is always routed to only a single chat. And you can increase or decrease the volume of

access through a class property on NSAppearance. If you're familiar with concepts like the current NSGraphics context or the current NSProgress, you already know what I'm talking about. If not, just remember that this is the appearance used to resolve dynamic colors and images. AppKit will set up

Accessibility settings. And then you tap and hold on an item in the tab bar a little HUD shows up as a magnified view of the item that you're currently holding your finger over. So, if you want your artwork to look good in places like this check the

access to our data, even when we're using many at the same time through features like query generations, connection pooling, and history tracking. Setting this all up requires finding the model and loading it and deciding where to keep the store, but a lot of these error paths can

accessing it continuously, periodically from another thread or maybe even another process. Well, now, if you go ahead and try to change it essentially behind AV Foundations back, well, you can imagine that bad things can happen. So our recommendation is that you pass a copy for these tasks, and

accessible to every developer. And now that we're doing that, we're strongly encouraging everyone to get on board. We really want you to get on board. We're here for the session. We're going to be in the lab. We're here to help you get on

access to your very favorite applications right from the watch face. We encourage you to adopt this policy for your application as well. Implement a complication whether or not you have data to display. Additionally, new in watchOS 3 we've brought you the dock. Just by pressing the side

access to. So that's layout. The next best practice I want to impart upon you is to use properties in your classes as an alternative to tags on UIView. So what I mean here is if you are using View With Tag or Set Tag UIView API and shipping

access the objects that are in the rest of your object graph at runtime. And that's the role of the File's Owner. Okay, so now I want to do another demo. As I said, this session is demo-heavy. So for those of you that are familiar with

access from Foo are well we know its methods and so in this case the only results you're going to get is the method bar and you could explicitly call the destructor for Foo; very precise results, these are operator overloading and templates, this is something that you could

access to tools, doesn't distract from the content that they're creating. Well, what works for that? Dark palette. Let's look at some similar apps, what did they do? What are the characteristics of those apps? So there's a progression of considerations that you have to go

access logs, investigate the root cause. And try to mitigate errors so your users can get the best your users can get the best experience they deserve on our platforms. If you haven't already, you should also check out one of our recorded sessions from last year to learn

access to the file system or databases that you have to do in order to create items. And remember that each call to Core Spotlight carries overhead. So, has batches of items instead of single items whenever it's possible. That said, consider that memory is limited, so keep your

access to all the system frameworks. In this case, we're able to edit the P list directly. It's a really great technique and we hope that you'll be able to take advantage of it. So, today I hope you've seen how AR provides really new AR

accessible allocated memory that is never used again. It's conceptually abandoned by you, the programmer, abandoned by your app; it's leftover and it's wasted or perhaps just forgotten. And so this memory is not nearly as easy to detect and more importantly, it also occurs in garbage

accessible to CPU. That's where vImage lives. After we apply the effects, whatever effects that may be, and we have to unlock the base address of this pixel buffer so that the camera can reuse this piece of memory. The second step, we have to prepare the vImage input

access the column using a subscript notation. So all you do is house at a price and you get an entire of price. You can add to column, subtract to column, multiply to column, divide to columns. And the way you do it is in very natural looking syntax. So

accessible here with this handy little clock icon, in the center. You can see the revision on the left and you can select any revision you'd like to, going back through time on the right. The thicker bars that stand for revision, the thinner bars divide the dates. You

access to a bunch of different training libraries that can all be converted to Core ML using the new ONNX converter. So that was a quick wrap-up of Core ML Tools ecosystem. Core ML Tools ecosystem. Now to talk about quantization, I would like to invite my friend Sohaib

access specific rows. Or columns of our data. And of course we can do common operations like joining our two SFrames into one. And saving the resulting SFrame for later use or to share with a colleague. Next we create our model. So I mentioned we have this simple function

Access, you don't have to go to the portal, it does it all from within Xcode. Additionally, if you are an agent or an admin or a single person on an individual team, it will go ahead and approve that CSR for you immediately. So, the certificate is ready

access. So, an example of that is Measure. Measure uses an indirect control, the plus button, the add button at the bottom of the add button at the bottom of the screen to add points. And, that control is in a really reachable spot. So, even while you're using

access to the private instance variables, again, a little dangerous here. We don't allow that across frameworks, though. These categories are very useful. Let's talk about Memory Management. So why? Well, if you don't do it well, you're going to crash. Memory Management is about keeping

access it without first having to make the bundle resource request for it. And of course, this increase does not come at the cost of counting towards the rest of your asset pack allowance, which remains the same at 20 gigabytes. So, now, the combined size of your app bundle

accessible from that wheel screen. So this is a perfect opportunity to preload those images so then they'll be available. The images and data will be there when people seek it out. And 1 final tip is you should cache artwork appropriately so it's not going to have

access is totally free which is pretty cool. There are a lot of great sessions coming up this week related to HTML5 media and web technologies in general. A couple of specific ones that I wanted to point out to you: In this room following this session we have Delivering

access it wirelessly anywhere on any devices. That's the goal of iCloud. iCloud was introduced last year. It's integrated in OS X and iOS. It's a free service. And it's simple and easy for our users to use. As I said we are integrating iCloud in

accessibility to the text engine and a single API such as drawing [inaudible 0:38:17] gives you convince way to render NS string efficiently and NS Cell renders many user interface control strings. These APIs can be categorized into two groups further. One is document contents. NS lay out

access and be sure that you only hand out those valuable assets to people who have paid. But what you definitely don't want to do is try and use that online validation service directly from the device. Now there was a time a little while ago when that was

access to this year. If you have more questions about this stuff, Jake Behrens is the UI Frameworks Evangelist or sorry, the App Frameworks Evangelist now. Documentation, of course, we've got the UIScrollView Programming Guide and the Apple Developer Forums are a great place to find out about this

access this later. What's great about that? First, you can actually call these methods several times. You're going to aggregate that information. What does that mean for your layout? Let's take a very simple grid-like layout with section headers. And you want to implement a sticky

access to these features. And of course and along with the new Auto Layout workflows and of course support for iOS 7, Xcode 5 brings along a new readable and diff-able XML format for this. [ Applause ] If you'd like more information, you can contact the Dev Tools Evangelist

access control splitting among multiple files, et cetera. Not writing code using synthesized properties. Let the compiler write accessors and instance variables for you. Not executing code, using weak-linked classes to write an application that runs on a newer OS uses the features of the newer OS, but also

access your view on that view controller. We're then going to make a request up the ad server. It's going to come and hopefully a banner is going to load. And at that time, we're going to move the banner onscreen and we're going to resize

access them by asking to instantiate the controller with identifier. We'll find it in the storyboard with that name. We'll instantiate, start doing the wiring up and hand it back to you, then you can take it from there. So that's really all there is with storyboards

access you wanted to create, it will actually create a separate activity ID on that next thread on whatever work you're trying to initiate. So, now you have two completely individual activities to scope this information into your diagnostic reports. So, how do you initiate an activity? So, I

access the launch of HomeKit Accessories. We now have automated tools to test your accessory and continue to automate more and more test cases, and we urge all MFi licensees to always get the latest tools before you begin your testing. Also, we are glad to announce that we now

access the value for key kCIInput ImageNoiseReductionAmount. If we want to alter that, it's equally easy. We just set a new value for that key. When we're done making changes, we ask for the outputImage and we're done. That's all we need to do. Of course

access the equation input user experience through the Insert panel, I'm going to insert equation and up will pop our Equation Editor. And I hope to God, I can remember this equation. So for circular pads, the equation is something like 2 [inaudible] 3. There you go. You can

accessible as it should be from the user interface of our previous version is the ability to add a new rule. So we've made that a lot easier. There's a big button in the style sidebar, you can't miss it, and what it and we've also

access to a number of functionalities including doing hit test within rectangles to see what bodies are in there. You can do ray casts from any points if you want to use that to drive your AI or pathfinding system. You can also add joints between nodes. You can set

access to the CPU prioritized, and the idea is that under contention, high priorities get to the CPU first. But even if you set low-priority there's no restriction to your execution if they're no contention, but then if something high-priority comes along like a UI action

accesses any files on disk, you need to be sure that they belong in the correct data protection class. For more information on data protection, we'll point you toward some more resources at the end of this session. So here's an example of the accept invite action. It

access to the data that's attached. In addition to metadata for those intervals, you may want to those intervals, you may want to add individual points in time. That is, in addition to the begin signpost and the end signpost, you may have a signpost that's not tethered

accessibility right when they enter the conversation. So we think this is a great way for users to enter a conversation, tap the app they want and be able to use your application immediately. One really cool change their making this year revolves around how we handle app installations. So

access information about what's really happening under the hood with your network transactions. This will help you in your debugging and development to be able to get, you know, fix your apps and make your apps work the best that they can be. And tune, really tune the Web

access technical support and developer forums, and please direct general inquiries to Paul, our core list evangelist. There are related sessions you may be interested in, specifically ones about ClockKit, Watch connectivity, and things that Michel demoed and the networking with NSURL session has more details on HTTP/2. Thank you

access to the pixels with the CPU and the GPU to colorize, warp, texture map. Achieve a much wider variety of complex effects. And we'll see more of the sea otters later [laughter]. So custom video compositor. But what is a video compositor? Well, it's basically a chunk