Apple の Article リンク集

去年から Apple のホゲホゲ Programming Guide がメンテされなくなり、Reference や Article を見てねということになりましたが、どこにどんな Article があるのかよくわかりません。そこでクローラ作って一覧にまとめてました。

ARKit

• Choosing Which Camera Feed to Augment
• Displaying an AR Experience with Metal
• Managing Session Lifecycle and Tracking Quality
• Previewing a Model with AR Quick Look
• Understanding World Tracking
• Verifying Device Support and User Permission

AVFoundation

AirPlay 2

• Getting AirPlay 2 into Your App
• Implementing Flexible Enhanced Buffering for Your Content
• Implementing Simple Enhanced Buffering for Your Content

Cameras and Media Capture

• Capturing Photos with Depth
• Capturing Still and Live Photos
  • Capturing Photos in RAW Format
  • Capturing Thumbnail and Preview Images
  • Capturing Uncompressed Image Data
  • Capturing a Bracketed Photo Sequence
  • Capturing and Saving Live Photos
  • Saving Captured Photos
  • Tracking Photo Capture Progress
• Capturing Video in Alternative Formats
• Choosing a Capture Device
• Setting Up a Capture Session

Media Assets, Playback, and Editing

• About the Asset Model
• About the Common Media Application Format with HTTP Live Streaming
• Adding Subtitles and Alternative Audio Tracks

Asset File Import and Export

• Exporting Video to Alternative Formats
• Creating a Basic Video Player (iOS and tvOS)
  • Controlling Background Audio
  • Enabling Background Audio
  • Playing Audio from a Video Asset in the Background
• Creating a Basic Video Player (macOS)
• Finding Metadata Values
• Guidelines for Apple TV 4K Development
• JavaScript Object Notation (JSON) Chapter Format for HTTP Live Streaming
• Observing the Playback Time
• Responding to Playback State Changes
• Seeking Through Media

Video Settings Dictionaries

• Setting Color Properties for a Specific Resolution

AVKit

Adding Information to the Info Panel (tvOS)

• Presenting Metadata in the Info Panel (tvOS)
• Presenting Navigation Markers (tvOS)
• Adopting Picture in Picture in a Custom Player
• Adopting Picture in Picture in a Standard Player
• Presenting Content Proposals (tvOS)
• Working with Interstitial Content (tvOS)

Accelerate

Sparse Solvers

Conversion from Other Formats

• Creating a Sparse Matrix from Coordinate Format Arrays
• Creating Sparse Matrices
• Implementing Iterative Methods
• Solving Systems Using Direct Methods
• Solving Systems Using Iterative Methods

simd

• Working with Matrices
• Working with Quaternions
• Working with Vectors

vDSP

• Controlling vDSP Operations with Stride

Fast Fourier Transforms

• Finding the Component Frequencies in a Composite Sine Wave

Finite Impulse Response Filters

• Resampling a Signal with Decimation

Linear Interpolation Functions

• Use Linear Interpolation to Construct New Data Points
• Using vDSP for Vector-based Arithmetic

Vector Generation

• Using Windowing with Discrete Fourier Transforms

vImage

• Applying vImage Operations to Regions of Interest
• Building a Basic Image-Processing Workflow
• Creating a Core Graphics Image Format
• Creating a Core Graphics Image from a vImage Buffer
• Creating and Populating Buffers from Core Graphics Images
• Optimizing Image Processing Performance

vImage Operations

Conversion

• Building a Basic Conversion Workflow
• Converting From Planar Formats
• Understanding YpCbCr Image Formats
• Resampling in vImage

AppKit

• Supporting Continuity Camera in Your Mac App
• Supporting Dark Mode in Your Interface
  • Choosing a Specific Appearance for Your macOS App

Apple Pay on the Web

Apple Pay JS API

• Checking for Apple Pay Availability
• Creating an Apple Pay Session
• Providing Merchant Validation
• Requesting an Apple Pay Payment Session
• Apple Pay on the Web Version History
  • Apple Pay Version 1 Release Notes
  • Apple Pay Version 2 Release Notes
  • Apple Pay Version 3 Release Notes
  • Apple Pay Version 4 Release Notes
  • Apple Pay Version 5 Release Notes
  • Apple Pay Version 6 Release Notes
• Choosing Button Appearance
• Choosing an API for Implementing Apple Pay on Your Website
• Configuring Your Environment
• Displaying Apple Pay Buttons
• Localizing Apple Pay Buttons
• Maintaining Your Environment
• Setting Up Your Server

AuthenticationServices

• Supporting Single Sign-On in a Web Browser App

BackgroundTasks

• Starting and Terminating Tasks During Development

Bundle Resources

• Accessing Protected Resources
• Accessing the Event Store
• Asking Permission to Use Speech Recognition
• Choosing the Location Services Authorization to Request
• Enabling HomeKit in Your App
• Requesting Authorization for Media Capture on iOS
• Requesting Authorization for Media Capture on macOS
• Requesting Authorization to Access Photos
• Requesting Authorization to Use SiriKit
• Setting Up HealthKit

Business Chat

• About Intent, Group, and Body Values
• Adding a Business Chat Button to Your Website

Business and Place Cards

• Directing Messages to a Specific Business Location
• Displaying Your Business Chat Button to Customers
• Managing Your iOS Search Results
• Setting Up Your Brands Profile
• Exploring Business Chat
• Registering for Business Chat
• Starting a Chat from a URL
• Starting a Chat from your App

CarPlay

• Adding CarPlay Support to Your Navigation App
• Meeting Guidelines for Navigation Apps

ClassKit

• Advertising Your App’s Assignable Content
  • Creating Bookmarks and Handouts from Your App
  • Declaring Your App’s Context Hierarchy
• Building Missing Contexts
• Enabling ClassKit in Your App
  • About ClassKit and User Roles
  • Testing Your App During Development
• Informing ClassKit That a Task Is About to Begin
• Linking Directly to Assignments
• Recording Additional Metrics About a Completed Task
• Recording Student Progress

ClockKit

• Adding a Complication to Your watchOS App
  • Adding Placeholders for Your Complication
  • Providing Data for Your Complication
    • Creating a Timeline Entry
    • Loading Future Timeline Events
    • Updating Your Timeline

CloudKit

• Changing Access Controls on User Data
• Identifying an App's Containers
• Providing User Access to CloudKit Data
• Responding to Requests to Delete Data

Code Diagnostics

• Address Sanitizer
  • Deallocation of Deallocated Memory
  • Deallocation of Nonallocated Memory
  • Enabling the Address Sanitizer
  • Overflow and Underflow of Buffers
  • Overflow of C++ Containers
  • Use of Deallocated Memory
  • Use of Out-of-Scope Stack Memory
  • Use of Stack Memory After Function Return
• Main Thread Checker
• Thread Sanitizer
  • Data Races
  • Enabling the Thread Sanitizer
  • Races on Collections and Other APIs
  • Swift Access Races
  • Thread Leaks
  • Uninitialized Mutexes
• Undefined Behavior Sanitizer
  • Division by Zero
  • Dynamic Type Violation
  • Enabling the Undefined Behavior Sanitizer
  • Integer Overflow
  • Invalid Boolean
  • Invalid Enumeration Value
  • Invalid Float Cast
  • Invalid Object Size
  • Invalid Shift
  • Invalid Variable-Length Array
  • Misaligned Pointer
  • Nonnull Argument Violation
  • Nonnull Return Value Violation
  • Nonnull Variable Assignment Violation
  • Null Reference Creation and Null Pointer Dereference
  • Out-of-Bounds Array Access
  • Reaching of Unreachable Point

Combine

• Receiving and Handling Events with Combine

Compression

• Compressing and Decompressing Data with Buffer Compression
• Compressing and Decompressing Data with Input and Output Filters

Core Data

• Accessing Data When the Store Has Changed
• Consuming Relevant Store Changes
• Creating a Core Data Model
• Mirroring a Core Data Store with CloudKit
  • Creating a Core Data Model for CloudKit
  • Reading CloudKit Records for Core Data
  • Setting Up Core Data with CloudKit
  • Syncing a Core Data Store with CloudKit
• Modeling Data
  • Configuring Attributes
  • Configuring Entities
  • Configuring Relationships
  • Generating Code
• Setting Up a Core Data Stack
  • Setting Up a Core Data Stack Manually
• Using Core Data in the Background
• Using Lightweight Migration

Core Haptics

• Playing a Single-Tap Haptic Pattern
• Preparing Your App to Play Haptics
• Representing Haptic Patterns in AHAP Files

Core Image

• Applying a Chroma Key Effect
• Customizing Image Transitions
• Processing an Image Using Built-in Filters
• Selectively Focusing on an Image
• Simulating Scratchy Analog Film
• Writing Custom Kernels

Core Location

• Adding Location Services to Your App
  • Requiring the Presence of Specific Location Services
• Converting Between Coordinates and User-Friendly Place Names
• Determining the Proximity to an iBeacon Device
• Getting Heading and Course Information
• Getting the User's Location
  • Handling Location Events in the Background
  • Using the Significant-Change Location Service
  • Using the Standard Location Service
  • Using the Visits Location Service
• Monitoring the User's Proximity to Geographic Regions
• Requesting Authorization for Location Services
• Responding to Changes in Authorization Status
• Turning an iOS Device into an iBeacon Device

Core ML

• Converting Trained Models to Core ML

Core ML API

• Creating a Custom Layer
• Downloading and Compiling a Model on the User's Device
• Integrating Custom Layers
• Making Predictions with a Sequence of Inputs
• Getting a Core ML Model
• Reducing the Size of Your Core ML App

Core Motion

• Adhering to the Movement Disorder Data Collection Requirements
• Getting Processed Device-Motion Data
  • Understanding Reference Frames and Device Attitude
• Getting Raw Accelerometer Events
• Getting Raw Gyroscope Events
• Monitoring Movement Disorders

Core NFC

• Adding Support for Background Tag Reading

Core Spotlight

• Making Content Searchable

Create ML

• Creating a Text Classifier Model
• Creating an Image Classifier Model
• Improving Your Model’s Accuracy

CryptoTokenKit

• Authenticating Users with a Cryptographic Token
• Configuring Smart Card Authentication
• Using Cryptographic Assets Stored on a Smart Card

DeviceCheck

• Accessing and Modifying Per-Device Data

EventKit

• Creating Events and Reminders
• Creating a Recurring Event
• Retrieving Events and Reminders
• Setting an Alarm
• Updating with Notifications

FileProvider

Content and Change Tracking

• Defining Your File Provider's Content
• Tracking Your File Provider's Changes
  • Tracking Changes to Documents
  • Using Push Notifications to Signal Changes
• Creating File Providers for Multiple Versions of iOS

FileProviderUI

• Adding Actions

Foundation

App Extension Support

• Supporting Suggestions in Your App’s Share Extension

Archives and Serialization

• Encoding and Decoding Custom Types

File System

• About Apple File System

Task Management

• Implementing Handoff in Your App

URL Loading System

• Accessing Cached Data
• Downloading Files from Websites
• Downloading Files in the Background
• Fetching Website Data into Memory
• Handling an Authentication Challenge
  • Performing Manual Server Trust Authentication
• Pausing and Resuming Downloads
• Uploading Data to a Website
• Uploading Streams of Data

HTTP Live Streaming

• About Apple's HTTP Live Streaming Tools
• About the EXT-X-VERSION tag
• Deploying a Basic HTTP Live Stream

Example Playlists for HTTP Live Streaming

• Adding Alternate Media to a Playlist
• Creating a Master Playlist
• Event Playlist Construction
• Incorporating Ads into a Playlist
• Live Playlist (Sliding Window) Construction
• Video on Demand Playlist Construction
• HLS Authoring Specification for Apple Devices
  • HLS Authoring Specification for Apple Devices Appendices
• Links to Additional Specifications and Videos
• Protocol Extension for Low-Latency HLS (Preliminary Specification)
• Understanding the HTTP Live Streaming Architecture
• Videos about HLS

HealthKit

• About the HealthKit Framework
• Protecting User Privacy
• Reading Data from HealthKit

Samples

• Accessing Health Records
• Accessing Sample Data in the Simulator
• Adding Digital Signatures

Units and Quantities

• Defining and Converting Units and Quantities
• Saving Data to HealthKit

Workouts and Activity Rings

• Creating a Workout Route
• Reading Route Data
• Running Workout Sessions
• Using Workout Samples

HomeKit

• Testing Your App with the HomeKit Accessory Simulator

MapKit

• Converting a User's Location to a Descriptive Placemark

MapKit JS

• Creating a Maps Identifier and a Private Key
• Creating and Using Tokens with MapKit JS
• Loading the Latest or a Specific Version of MapKit JS
• MapKit JS Release Notes
  • MapKit JS 5

Media Player

• Displaying a Media Picker from Your App
• Handling External Player Events Notifications
• Playing Audio Using the Built-In Music Player
• Using Filters to Create Specialized Queries

Messages

• Adding Sticker Packs and iMessage Apps to Effects in Messages and FaceTime

Metal

Basic Tasks and Concepts

• Viewing Your GPU Workload with the Metal Debugger

Buffers

• About Argument Buffers
• Indexing Argument Buffers
• Tracking the Resource Residency of Argument Buffers
• Calculating Threadgroup and Grid Sizes
• Copying Data to a Private Resource
• Creating Threads and Threadgroups
• Developing Metal Apps that Run in Simulator

Drawable Objects

• Displaying HDR Content in a Metal Layer
  • Determining Support for EDR Values
  • Implementing Tone Mapping on Reference Displays
  • Performing Your Own Tone Mapping
  • Using Color Spaces to Display HDR Content
  • Using System Tone Mapping on Video Content

Frame Capture Debugging Tools

• Capturing GPU Command Data Programmatically
• Capturing a Frame Using a Breakpoint
• Creating a Custom Capture Scope
• Enabling Frame Capture
• Enhancing Frame Capture by Using Labels
• Optimizing Performance with GPU Counters
• Optimizing Performance with Pipeline Statistics
• Optimizing Performance with the Shader Profiler
• Viewing Your Frame Graph
• Viewing Your Meshes with the Geometry Viewer

GPU Features

• Understanding GPU Family 4
  • About Enhanced MSAA and Imageblock Sample Coverage Control
  • About Imageblocks
  • About Raster Order Groups
  • About Tile Shading
• Using Metal Feature Set Tables

GPU Selection in macOS

• Finding GPUs on macOS
• Getting the GPU that Drives a View's Display
• Handling External GPU Additions and Removals
• Understanding External GPUs
• Understanding GPU Bandwidth
• Understanding Multi-GPU and Multi-Display Setups
• Generating Multiple Output Vertex Streams from One Input Stream
• Getting the Default GPU

Indirect Command Buffers

• Creating an Indirect Command Buffer

Libraries

• Building a Library with Metal's Command-Line Tools
• Understanding the Metal Shading Language Filename Extension
• Optimizing Performance with the GPU Counters Instrument
  • Finding Your App's GPU Shader Occupancy
  • Measuring the GPU's Use of Memory Bandwidth
  • Reducing Shader Bottlenecks
• Reducing the Memory Footprint of Metal Apps
• Setting Resource Storage Modes
  • Choosing a Resource Storage Mode in iOS and tvOS
  • Choosing a Resource Storage Mode in macOS
• Setting Up a Command Structure

Shader Authoring

• Developing and Debugging Metal Shaders

Synchronization

• About Synchronization Events
• Synchronizing Events Across Multiple Devices
• Synchronizing Events Between a GPU and the CPU
• Synchronizing Events Within a Single Device
• Synchronizing a Managed Resource

Textures

• Improving Filtering Quality and Sampling Performance
  • Adding Mipmap Filtering to Samplers
  • Copying Data into or out of Mipmaps
  • Creating a Mipmapped Texture
  • Determining Which Mipmaps the GPU Will Try to Access
  • Dynamically Adjusting Texture Level of Detail
  • Generating Mipmap Data
  • Restricting Access to Specific Mipmaps
• Managing Texture Memory
  • Assigning Memory to Sparse Textures
  • Converting Between Pixel Regions and Sparse Tile Regions
  • Creating Sparse Heaps and Sparse Textures
  • Estimating How Often a Texture Region Is Accessed
  • Reading and Writing to Sparse Textures
• Optimizing Texture Data
• Understanding Color-Renderable Pixel Format Sizes
• Transferring Data Between Connected GPUs
• Using Metal System Trace in Instruments to Profile Your App

Metal Performance Shaders

• The MPSKernel Class
• Tuning Hints

MetricKit

• Improving Your App's Performance
  • Improving App Responsiveness
  • Reducing Disk Writes
  • Reducing Your App's Launch Time
  • Reducing Your App's Memory Use
    • Gathering Information About Memory Use
    • Making Changes to Reduce Memory Use
    • Preventing Memory-Use Regressions
    • Responding to Low-Memory Warnings

MusicKit JS

• Accessing MusicKit Features Using JavaScript
• Adding MusicKit Features Using HTML

Natural Language

• Identifying Parts of Speech
• Identifying People, Places, and Organizations
• Tokenizing Natural Language Text

Network

• Choosing a Network Debugging Tool
• Debugging HTTP Server-Side Errors
• Debugging HTTPS Problems with CFNetwork Diagnostic Logging
• Recording a Packet Trace
  • Recording a Wi-Fi Packet Trace
  • Submitting a Packet Trace to Apple
  • Troubleshooting Packet Traces
• Taking Advantage of Third-Party Network Debugging Tools

PassKit (Apple Pay and Wallet)

Apple Pay

• Setting Up Apple Pay Requirements

Wallet

• Supporting Semantic Tags in Wallet Passes

PhotoKit

• Creating Photo Editing Extensions
• Displaying Live Photos
• Fetching Objects and Requesting Changes
• Loading and Caching Assets and Thumbnails

Playground Support

• Messaging Between a Playground Page and the Always-On Live View

PlaygroundBluetooth

• Connecting to Bluetooth Peripherals in Swift Playgrounds

Professional Video Applications

• Creating a Plug-in Using FxPlug

Exchanging Content and Metadata with Final Cut Pro

• Associating Ratings, Keywords, Markers, and Metadata with Media
• Creating FCPXML Documents
• Describing Final Cut Pro Items in FCPXML
• Receiving Media and Data Through a Custom Share Destination
  • Creating Scripting Definitions for Custom Share Destinations
  • Responding to Apple Events from Final Cut Pro
  • Supporting Conversions with Scripting Class Extensions
• Sending Data Programmatically to Final Cut Pro
• Sending Media and Metadata to Final Cut Pro
• Sending Media to Final Cut Pro as It's Recorded
• Supporting Drag and Drop for Data Sent to Final Cut Pro
• Supporting Drag and Drop to Receive Final Cut Pro Data
• Using FCPXML to Describe Final Cut Pro Data

PushKit

• Responding to VoIP Notifications from PushKit
• Supporting PushKit Notifications in Your App

Quartz

PDFKit

• Adding Custom Graphics to a PDF
• Adding Widgets to a PDF Document

QuickLookThumbnailing

• Creating Quick Look Thumbnails to Preview Files in Your App
• Providing Thumbnails of Your Custom File Types

RealityKit

• Creating 3D Content with Reality Composer
  • Selecting an Anchor for a Reality Composer Scene

SMS and Call Reporting

SMS and MMS Message Filtering

• Creating a Message Filter App Extension

SafariServices

• Creating a Content Blocker

Safari App Extensions

• About Injected Style Sheets and Scripts
• Building a Safari App Extension
• Converting a Legacy Safari Extension to a Safari App Extension
• Injecting CSS Style Sheets into a Webpage
• Injecting a Script into a Webpage
• Passing Messages Between Safari App Extensions and Injected Scripts

Safari App Extension Info Property List Keys

• About Content Script and Style Sheet Keys
• About Contextual Menu and Toolbar Item Keys
• About Permissions for Scripts and Style Sheets
• About Safari App Extension Default Keys
• Adjusting Settings for Contextual Menu Items
• Adjusting Settings for a Toolbar Item
• Adjusting Website Access Permissions
• Setting Safari App Extension Feature Keys
• Troubleshooting Your Safari App Extension

SceneKit

Animation

• Animating SceneKit Content
• Organizing a Scene with Nodes

Security

Authorization Plug-ins

• Using Authorization Plug-ins

Certificate, Key, and Trust Services

Certificates

• Examining a Certificate
• Getting Certificate Values
• Getting a Certificate
• Storing a Certificate in the Keychain
• Storing a DER-Encoded X.509 Certificate

Identities

• Creating an Identity
• Importing an Identity
• Parsing an Identity
• Storing an Identity in the Keychain

Keys

• Generating New Cryptographic Keys
• Getting an Existing Key
• Signing and Verifying
• Storing Keys as Data
• Storing Keys in the Keychain
• Storing Keys in the Secure Enclave
• Using Keys for Encryption

Trust

• Configuring a Trust
• Creating a Trust Object
• Discovering Why a Trust Evaluation Failed
• Evaluating a Trust and Parsing the Result
• Working with Concurrency

Code Signing Services

• Applying Code Requirements
• Hosting Guest Code
• Complying with Encryption Export Regulations

Keychain Services

Keychain Items

• Adding a Password to the Keychain
• Restricting Keychain Item Accessibility
• Searching for Keychain Items
• Sharing Access to Keychain Items Among a Collection of Apps
• Updating and Deleting Keychain Items
• Using the Keychain to Manage User Secrets
• Notarizing Your App Before Distribution
  • Customizing the Notarization Workflow
    • Customizing the Xcode Archive Process
  • Resolving Common Notarization Issues
• Preparing Your App to Work with Pointer Authentication
• Preventing Insecure Network Connections
  • Identifying the Source of Blocked Connections

Secure Transport

• Using the Secure Socket Layer for Network Communication

Shared Web Credentials

• Managing Shared Credentials

Sign in with Apple JS

• Communicating Using the Private Email Relay Service
• Configuring Your Webpage for Sign In with Apple
• Displaying and Configuring Sign In with Apple Buttons
• Incorporating Sign in with Apple into Other Platforms

SiriKit

• Adding User Interactivity with Siri Shortcuts and the Shortcuts App
• Creating an Intents App Extension
• Creating an Intents UI Extension
  • Configuring Your Intents UI App Extension Target
  • Configuring the View Controller for Your Custom Interface
• Deleting Donated Shortcuts
• Dispatching Intents to Handler Objects
• Donating Shortcuts
• Registering Custom Vocabulary with SiriKit
  • Global Vocabulary Reference
    • Intent Phrases
    • Localizing Your Vocabulary for Chinese Dialects
    • Parameter Vocabularies
  • Specifying Synonyms for Your App Name

Relevant Shortcuts

• Defining Relevant Shortcuts for Your App
• Displaying Shortcut Information in a Siri Watch Face Card
• Resolving and Handling Intents
  • Confirming the Details of an Intent
  • Handling an Intent
  • Resolving the Parameters of an Intent

Ride Booking

• Generating a List of Ride Options
• Handling the Ride-Booking Intents
• Providing Live Status Updates

Shortcut Management

• Suggesting Shortcuts to Users

Siri Event Suggestions

• Donating Reservations
• Structuring Your Code to Support App Extensions

SoundAnalysis

• Analyzing Audio to Classify Sounds

SpriteKit

• Choosing a SpriteKit Scene Renderer
• Drawing SpriteKit Content in a View
• Getting Started with Actions
• Getting Started with Physics
• Maximizing Texture Performance

Nodes for Scene Building

• Maximizing Node Drawing Performance
• Using Base Nodes to Lay Out SpriteKit Content
• Working with Inverse Kinematics

StoreKit

• Handling Errors

In-App Purchase

• Choosing a Receipt Validation Technique
• Enabling Server-to-Server Notifications
• Fetching Product Information from the App Store
• Generating a Signature for Subscription Offers
• Handling Subscriptions Billing
• Implementing Introductory Offers in Your App
• Implementing Subscription Offers in Your App
• Loading In-App Product Identifiers
• Offering a Subscription Across Multiple Apps
• Processing a Transaction
• Reducing Involuntary Subscriber Churn
• Requesting a Payment from the App Store
• Setting Up Subscription Offers
• Setting Up the Transaction Observer and Payment Queue
• Testing Introductory Offers
• Testing Promoted In-App Purchases
• Validating Receipts with the App Store

Swift

• Adopting Common Protocols
• Choosing Between Structures and Classes

Cocoa Design Patterns

• About Imported Cocoa Error Parameters
• Handling Cocoa Errors in Swift
• Managing a Shared Resource Using a Singleton
• Using Delegates to Customize Object Behavior
• Using Key-Value Observing in Swift
• Handling Dynamically Typed Methods and Objects in Swift

Imported C and Objective-C APIs

• Importing Objective-C into Swift
• Importing Swift into Objective-C
• Using Imported C Functions in Swift
• Using Imported C Macros in Swift
• Using Imported C Structs and Unions in Swift
• Using Imported Lightweight Generics in Swift
• Using Imported Protocol-Qualified Classes in Swift
• Working with Core Foundation Types
• Working with Foundation Types
• Maintaining State in Your Apps
• Migrating Your Objective-C Code to Swift

Objective-C and C Code Customization

• Customizing Your C Code for Swift
• Designating Nullability in Objective-C APIs
• Grouping Related Objective-C Constants
• Improving Objective-C API Declarations for Swift
• Making Objective-C APIs Unavailable in Swift
• Marking API Availability in Objective-C
• Renaming Objective-C APIs for Swift
• Preventing Timing Problems When Using Closures

Swift Standard Library

Manual Memory Management

• Calling Functions With Pointer Parameters
• Operator Declarations
• Using Objective-C Runtime Features in Swift

Swift Packages

• Adding Package Dependencies to Your App
• Building Apps that Use Swift Packages in Continuous Integration Workflows
• Creating a Swift Package with Xcode
• Publishing a Swift Package with Xcode

Swift Playgrounds

• Adding a Glossary to a Playground Book
• Creating a Subscription
• Creating and Running a Playground Book
• Customizing the Completions in the Shortcut Bar
• Giving Hints to Help Learners Solve Problems
• Hiding Code from a Playground Page
• Localizing Code Comments and String Literals
• Localizing a Subscription Feed
• Publishing a Subscription
• Specifying Editable Regions in a Playground Page
• Structuring Content for Swift Playgrounds
  • Adding a Chapter to a Playground Book
  • Adding a Cutscene to a Playground Book
  • Adding a Page to a Playground Book
  • Sharing Resources in a Playground Book
  • Using Modules to Share Code in a Playground Book
• Writing Prose for a Playground Page

SwiftUI

Gestures

• Adding Interactivity with Gestures
• Composing SwiftUI Gestures

TVML

• Adding Resource Icons

Alignment, Scrolling, and Coloring

• centered
• indexTitles
• minLength
• rowCount
• showsScrollIndicator
• theme

Background Elements

• audio
• background

Banner and Header Elements

• banner
• footer
• header
• identityBanner
• itemBanner

Binding and DOM Manipulation

• binding
• itemID
• needsMoreThreshold
• prototype
• Button Icons

Color Styles

• background-color
• color
• tv-highlight-color
• tv-tint-color

Data Binding Queries

• {property-path}
• {property-path}-greater-than
• {property-path}-greater-than-equal
• {property-path}-less-than
• {property-path}-less-than-equal
• {property-path}-not-equal

Display Elements

• activityIndicator
• badge
• decorationImage
• fullscreenImg
• heroImg
• img
• progressBar
• ratingBadge
• seasonBadge
• separator
• textBadge

Element Alignment and Spacing

• margin
• padding
• text-align
• tv-align
• tv-content-align
• tv-focus-margin
• tv-interitem-spacing
• tv-line-spacing
• tv-position

Element Shaping

• border-radius
• height
• max-height
• max-width
• min-height
• min-width
• width

Focus Attributes

• autoHighlight
• disabled
• handlesOverflow

Image Attributes

• aspectFill
• aspectRatio
• contentsMode
• height
• mode
• opaque
• src
• srcset
• type
• value
• width

Information Elements

• card
• info
• placeholder
• productInfo
• prototypes
• ratingCard
• relatedContent
• reviewCard
• rules
• specialize

Inline Playback

• audioMode
• playbackMode

Layout Elements

• carousel
• collectionList
• grid
• imgDeck
• infoList
• infoTable
• list
• menuBar
• menuItem
• nowPlayingMenuItem
• organizer
• row
• section
• segmentBar
• segmentBarHeader
• segmentBarItem
• shelf
• stack
• tumblerBar
• tumblerItem

Lockup Elements

• button
• buttonLockup
• listItemLockup
• lockup
• monogramLockup
• overlay

Media Queries

• layout-direction
• tv-theme
• Miscellaneous Icons
• Movie Rating Icons (United States)

Multimedia Elements

• asset
• mediaContent
• relatedContentURL
• searchField
• textField
• Rating Icons (Brazil)
• Rating Icons (New Zealand)
• Rating Icons (United Kingdom)
• Rotten Tomatoes Rating Icons
• Television Rating Icons (United States)

Text Attributes

• accessibilityText
• firstName
• format
• keyboardType
• lastName
• layoutDirection
• locale
• secure
• showSpinner

Text Elements

• date
• decorationLabel
• description
• monogram
• ordinal
• strike
• subtitle
• text
• title

Text Styles

• font-family
• font-size
• font-weight
• text-shadow
• tv-minimum-scale-factor
• tv-text-max-lines
• tv-text-style
• alertTemplate
• catalogTemplate
• compilationTemplate
• descriptiveAlertTemplate
• divTemplate
• formTemplate
• listTemplate
• loadingTemplate
• mainTemplate
• menuBarTemplate
• oneupTemplate
• paradeTemplate
• productBundleTemplate
• productTemplate
• ratingTemplate
• searchTemplate
• showcaseTemplate
• stackTemplate
• tv-placeholder
• tv-rating-style
• tv-scrollable-bounds-inset
  • tv-scrollable-bounds-inset-bottom
  • tv-scrollable-bounds-inset-top
• tv-text-highlight-style
• tv-transition

TVMLKit

• Creating TVML Elements

UIKit

• About App Development with UIKit

Accessibility

• Supporting VoiceOver in Your App

App and Environment

• Managing Your App's Life Cycle
  • Responding to Memory Warnings
• Responding to Changing Display Modes on Apple TV
• Responding to the Launch of Your App
  • About the App Launch Sequence
  • Performing One-Time Setup for Your App

Scenes

• Preparing Your UI to Run in the Background
  • About the Background Execution Sequence
  • Extending Your App's Background Execution Time
  • Updating Your App with Background App Refresh
• Preparing Your UI to Run in the Foreground
  • Processing Queued Notifications
• Specifying the Scenes Your App Supports
• Updating Your App from 32-Bit to 64-Bit Architecture
  • Auditing Pointer Usage
  • Managing Functions and Function Pointers
  • Optimizing Memory Performance
  • Updating Data Structures
  • Verifying Mathematical Calculations

Appearance Customization

• Choosing a Specific Interface Style for Your iOS App

Drag and Drop

• Making a View into a Drag Source
• Making a View into a Drop Destination
• Understanding a Drag Item as a Promise

Focus-based Navigation

• About Focus Interactions for Apple TV
• Adding User-Focusable Elements to a tvOS App
• Creating Custom Navigation Interactions
• Debugging Focus Issues in Your App

Images and PDF

• Configuring and Displaying Symbol Images in Your UI
• Creating Custom Symbol Images for Your App
• Providing Images for Different Appearances

Inter-Process Communication

• Allowing Apps and Websites to Link to Your Content
  • Defining a Custom URL Scheme for Your App
  • Enabling Universal Links
  • Handling Universal Links

Keyboards and Input

• About the Password AutoFill Workflow
• Customizing Password AutoFill Rules
• Enabling Password AutoFill on a Text Input View
• Enabling Password AutoFill on an HTML Input Element
• Setting Up an App’s Associated Domains

Mac Catalyst

• Creating a Mac Version of Your iPad App
• Displaying a Preferences Window
• Optimizing Your iPad App for Mac

Pencil Interactions

• Handling Double Taps from Apple Pencil
• Protecting the User’s Privacy
  • Encrypting Your App’s Files

Resource Management

• Customizing the Behavior of Segue-Based Presentations
• Dismissing a View Controller with an Unwind Segue

Text Display and Fonts

• Adding a Custom Font to Your App
• Scaling Fonts Automatically

Touches, Presses, and Gestures

• Coordinating Multiple Gesture Recognizers
  • Allowing the Simultaneous Recognition of Multiple Gestures
  • Attaching Gesture Recognizers to UIKit Controls
  • Preferring One Gesture Over Another
• Handling Input from Apple Pencil
  • Computing the Perpendicular Force of Apple Pencil
• Handling Touches in Your View
  • Getting High-Fidelity Input with Coalesced Touches
    • Implementing Coalesced Touch Support in an App
  • Implementing a Multi-Touch App
  • Minimizing Latency with Predicted Touches
    • Incorporating Predicted Touches into an App
• Handling UIKit Gestures
  • Handling Long-Press Gestures
  • Handling Pan Gestures
  • Handling Pinch Gestures
  • Handling Rotation Gestures
  • Handling Swipe Gestures
  • Handling Tap Gestures
• Implementing a Custom Gesture Recognizer
  • About the Gesture Recognizer State Machine
  • Implementing a Continuous Gesture Recognizer
  • Implementing a Discrete Gesture Recognizer
• Tracking the Force of 3D Touch Events
  • Checking the Availability of 3D Touch
• Using Responders and the Responder Chain to Handle Events

View Controllers

• Adding a Document Browser to Your App
  • Adding Custom Actions and Activities
  • Customizing the Browser
  • Enabling Document Sharing
  • Presenting Selected Documents
  • Setting Up a Document Browser App
• Creating a Custom Container View Controller
• Displaying and Managing Views with a View Controller
• Managing Content in Your App's Windows
• Preserving Your App's UI Across Launches
  • About the UI Preservation Process
  • About the UI Restoration Process
• Providing Access to Directories
• Showing and Hiding View Controllers

View Layout

• Positioning Content Relative to the Safe Area
• Positioning Content Within Layout Margins

Views and Controls

Collection Views

• Supporting Drag and Drop in Collection Views

Table Views

• Adding Headers and Footers to Table Sections
• Configuring the Cells for Your Table
• Estimating the Height of a Table's Scrolling Area
• Filling a Table with Data
• Handling Row Selection in a Table View
• Supporting Drag and Drop in Table Views

Windows and Screens

• Displaying Content on a Connected Screen
• Displaying Transient Content in a Popover
• Getting the User's Attention with Alerts and Action Sheets

UserNotifications

• Asking Permission to Use Notifications
• Declaring Your Actionable Notification Types
• Handling Notifications and Notification-Related Actions
• Modifying Content in Newly Delivered Notifications
• Registering Your App with APNs
• Scheduling a Notification Locally from Your App
• Setting Up a Remote Notification Server
  • Establishing a Certificate-Based Connection to APNs
  • Establishing a Token-Based Connection to APNs
  • Generating a Remote Notification
  • Handling Notification Responses from APNs
  • Pushing Background Updates to Your App
  • Sending Notification Requests to APNs

UserNotificationsUI

• Customizing the Appearance of Notifications

Vision

• Cropping Images Using Saliency

WatchKit

• Authenticating Users on Apple Watch
• Building watchOS App Interfaces with SwiftUI
• Creating Independent watchOS Apps
  • Setting Up a watchOS Project
• Creating an Effective watchOS Experience
• Enhancing Your watchOS App with Notifications
  • Adding Actions to Notifications on watchOS
  • Adding Interactive Controls to a Long-Look Interface
  • Customizing Your Long-Look Interface
  • Testing Custom Notification Interfaces
• Keeping Your watchOS Content Up to Date
  • Making Background Requests
  • Making Default and Ephemeral Requests
• Playing Background Audio
• Preparing to Take Your watchOS App’s Snapshot
• Running watchOS Apps in the Background

Storyboard Elements

• Adding a Now Playing View
• Building watchOS app Interfaces Using the Storyboard
  • Connecting Your User Interface to Your Code
  • Navigating Between Scenes
  • Setting the App’s Tint Color
  • Supporting Multiple Watch Sizes
• Using Extended Runtime Sessions
• Working with the watchOS App Life Cycle

WebKit

• About WebDriver for Safari

Safari Tools and Features

• Delivering Video Content for Safari
• Optimizing Your Website for Safari
• Testing with WebDriver in Safari
• macOS WebDriver Commands for Safari 11.1 and earlier
• macOS WebDriver Commands for Safari 12 and later

WebKit JS

• Adding Picture in Picture to Your Safari Media Controls
• Adding an AirPlay Button to Your Safari Media Controls

XCTest

Activities and Attachments

• Adding Attachments to Tests and Activities
• Grouping Tests into Substeps with Activities

Asynchronous Tests and Expectations

• Testing Asynchronous Operations with Expectations
• Defining Test Cases and Test Methods

Xcode

• Adding Capabilities to Your App
• Creating Your App's Interface with SwiftUI
• Creating an Xcode Project for an App
• Preparing Your App for Distribution
• Running Your App in the Simulator or on a Device
• Testing Your Xcode Project

XcodeKit

• Creating a Source Editor Extension
• Testing Your Source Editor Extension

iAd

• Setting up Apple Search Ads Attribution

os

• Reading UNIX Manual Pages